utils.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "matrix.h"
#include "ri.h"
#include "graph.h"
#include "paf_ri.h"
#include "database.h"
#include "parser_private.h"
#include "ri-util.h"
#include "workspace-util.h"
#include "prettyprint.h"
#include "constants.h"
#include "misc.h"
#include "text.h"
#include "text-util.h"
#include "paf-util.h"
#include "effects-generic.h"
#include "alias-classes.h"
#include "static_controlize.h"

Include dependency graph for utils.c:

Go to the source code of this file.

Macros
#define	entity_assigned_by_array_p(ent)   (gen_find_eq(ent, assigned_var) != chunk_undefined)

Typedefs
typedef void *	arc_label
	Name : utils.c Package : static_controlize.c Author : Arnauld LESERVOT Date : 27/04/93 Modified : Documents: "Implementation du Data Flow Graph dans Pips" Comments : More...
typedef void *	vertex_label

Functions
list	stco_same_loops (statement_mapping in_map, statement in_s, statement in_s2)
	====================================================================== More...
int	stco_renumber_code (statement in_st, int in_ct)
	================================================================ More...
expression	sc_opposite_exp_of_conjunction (expression exp, list *ell)
	================================================================ More...
bool	splc_positive_relation_p (expression exp, list *ell)
	================================================================ More...
list	ndf_normalized_test (expression exp, list *ell)
	================================================================ More...
expression	normalize_test_leaves (expression exp, list *ell)
	================================================================ More...
expression	sc_conditional (expression exp, list *ell)
	================================================================ More...
list	loops_to_indices (list l)
	================================================================ More...
bool	splc_linear_expression_p (expression exp, list *ell)
	================================================================ More...
bool	splc_linear_expression_list_p (list l, list *ell)
	================================================================ More...
bool	splc_linear_access_to_arrays_p (list l, list *ell)
	================================================================ More...
string	print_structurals (list l)
	================================================================ More...
list	sc_list_of_exp_dup (list l)
	================================================================ More...
list	sc_list_of_entity_dup (list l)
	================================================================ More...
list	sc_list_of_loop_dup (list l)
	================================================================ More...
loop	sc_loop_dup (loop l)
	================================================================ More...
list	make_undefined_list ()
	================================================================ More...
int	in_forward_defined (entity ent, list *swfl)
	================================================================ More...
bool	in_forward_defined_p (entity ent, list *swfl)
	================================================================ More...
void	verify_structural_parameters (list the_list, list *swfl)
	================================================================ More...
list	sc_entity_to_formal_integer_parameters (entity f)
	================================================================ More...
bool	sp_linear_expression_p (expression exp)
	================================================================ More...
bool	splc_feautrier_expression_p (expression exp, list *ell)
	================================================================ More...
bool	sp_feautrier_expression_p (expression exp)
	================================================================ More...
entity	sp_feautrier_scalar_assign_call (call c)
	================================================================ More...
bool	get_sp_of_call_p (call c, hash_table fst, list *swfl)
	================================================================ More...
static void	substitute_variable_by_expression (expression e, hash_table fst)
	rewriting of forward_substitute_in_exp, in_loop,... More...
void	forward_substitute_in_anyloop (void *pl, hash_table fst)
void	forward_substitute_in_exp (expression *pe, hash_table fst)
void	forward_substitute_in_call (call *pc, hash_table fst)
bool	normalizable_loop_p (loop l)
	bool normalizable_loop_p(loop l) Returns true if "l" has a constant step. More...
bool	normalizable_loop_p_retrieved (loop l)
	Code retrieved from revision 14476, transformations/loop_normalize.c. More...
bool	is_expression_in_list (expression exp, list l)
	State if an expression OR part of that expression corresponds to one of the entity of the list l. More...
bool	get_reference_assignments (statement s, list *l)
	Allows the static_controlize phase to keep and update a list containing all the variables of the program assigned directly or indirectly by an array. More...

Variables
list	Gstructure_parameters
	Global variables More...
list	assigned_var
	================================================================= More...

Macro Definition Documentation

entity_assigned_by_array_p

#define entity_assigned_by_array_p

(

ent

)

(gen_find_eq(ent, assigned_var) != chunk_undefined)

Definition at line 86 of file utils.c.

Typedef Documentation

arc_label

typedef void* arc_label

Name : utils.c Package : static_controlize.c Author : Arnauld LESERVOT Date : 27/04/93 Modified :
Documents: "Implementation du Data Flow Graph dans Pips" Comments :

Ansi includes
Newgen includes C3 includes
Pips includes
Types arc_label and vertex_label must be defined although they are not used

Definition at line 62 of file utils.c.

vertex_label

typedef void* vertex_label

Definition at line 63 of file utils.c.

Function Documentation

forward_substitute_in_anyloop()

void forward_substitute_in_anyloop	(	void *	pl,
		hash_table	fst
	)

Would it be better to loop over with HASH_MAP or to check every reference?

Parameters

pl	l
fst	st

Definition at line 1139 of file utils.c.

{
  /* Would it be better to loop over with HASH_MAP or to check every
     reference? */
  gen_context_multi_recurse(pl, fst,
                            expression_domain, gen_true, substitute_variable_by_expression,
                            NULL);
}

References expression_domain, gen_context_multi_recurse(), gen_true(), pl, and substitute_variable_by_expression().

Referenced by loop_normalize_of_statement(), and static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

forward_substitute_in_call()

void forward_substitute_in_call	(	call *	pc,
		hash_table	fst
	)

Would it be better to loop over with HASH_MAP or to check every reference?

Parameters

pc	c
fst	st

Definition at line 1157 of file utils.c.

{
  pips_assert("call c is consistent_p\n", call_consistent_p(*pc));
 
  /* Would it be better to loop over with HASH_MAP or to check every
     reference? */
  gen_context_multi_recurse(*pc, fst,
                            expression_domain, gen_true, substitute_variable_by_expression,
                            NULL);
}

References call_consistent_p(), expression_domain, gen_context_multi_recurse(), gen_true(), pips_assert, and substitute_variable_by_expression().

Referenced by loop_normalize_of_statement(), and static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

forward_substitute_in_exp()

void forward_substitute_in_exp	(	expression *	pe,
		hash_table	fst
	)

Would it be better to loop over with HASH_MAP or to check every reference?

Parameters

pe	e
fst	st

Definition at line 1148 of file utils.c.

{
  /* Would it be better to loop over with HASH_MAP or to check every
     reference? */
  gen_context_multi_recurse(*pe, fst,
                            expression_domain, gen_true, substitute_variable_by_expression,
                            NULL);
}

References expression_domain, gen_context_multi_recurse(), gen_true(), and substitute_variable_by_expression().

Referenced by adg_dataflowgraph(), loop_normalize_of_statement(), and static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_reference_assignments()

bool get_reference_assignments	(	statement	s,
		list *	l
	)

Allows the static_controlize phase to keep and update a list containing all the variables of the program assigned directly or indirectly by an array.

Definition at line 1300 of file utils.c.

                                                      {
  // we only compute assignments
  if (!assignment_statement_p(s)) {
    return false;
  }
  instruction inst = statement_instruction(s);
  // May not be necessary
  if (!instruction_call_p(inst)) {
    return false;
  }
  // Being an assignment, logically this call has only two arguments
  call c = instruction_call(inst);
  list args = call_arguments(c);
  // Left member of the assignment
  expression left = gen_car(args);
  entity eleft = expression_to_entity(left);
  // Right member of the assignment
  expression right = gen_car(CDR(args));
  // If the assigned variable is not in the list
  if (gen_find_eq(eleft, *l) == chunk_undefined) {
    // Test if the assignment is static control
    entity e = sp_feautrier_scalar_assign_call(c);
    syntax s = expression_syntax(left);
    // We look for the right member in the list in order to know if the variable read has not been assigned by an array
    bool isRightArrayAccess = is_expression_in_list(right, *l);
    // If the left member is a scalar and if the right member is not static control or if it is a variable previously assigned
    // by an array, then we add the left member to the list
    if ((syntax_reference_p(s) && reference_indices(syntax_reference(s)) == NIL) && (entity_undefined_p(e) || isRightArrayAccess == true)) {
      *l = gen_cons(eleft, *l);    
    }
  }
  return true;
}

References assignment_statement_p(), call_arguments, CDR, chunk_undefined, entity_undefined_p, expression_syntax, expression_to_entity(), gen_car(), gen_cons(), gen_find_eq(), instruction_call, instruction_call_p, is_expression_in_list(), NIL, reference_indices, sp_feautrier_scalar_assign_call(), statement_instruction, syntax_reference, and syntax_reference_p.

Referenced by static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

get_sp_of_call_p()

bool get_sp_of_call_p	(	call	c,
		hash_table	fst,
		list *	swfl
	)

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

bool get_sp_of_call_p( (call) c, fst) AL 04/93 Updates the global variables Gstructure_parameters and Gforward_substitute_table according to the type of call. Returns true if the call has to be modified (redefinition of a structural parameter), false in all the other cases.

AP, sep 95 : Gforward_substitute_table is no longer a global variable, we pass it as an argument.

I: not too sure about the false parameter...

Parameters

fst	st
swfl	bool get_sp_of_call_p( (call) c, fst) AL 04/93 Updates the global variables Gstructure_parameters and Gforward_substitute_table according to the type of call. Returns true if the call has to be modified (redefinition of a structural parameter), false in all the other cases.

AP, sep 95 : Gforward_substitute_table is no longer a global variable, we pass it as an argument. forward substitute table

Definition at line 1056 of file utils.c.

{
   entity       lhs_ent, ent;
   bool         ret_bool = false;
 
   pips_debug(7, "begin\n");
   /*FI: not too sure about the false parameter... */
   pips_debug(9, "input call : %s \n",
              words_to_string(Words_Regular_Call(c, false )));
   pips_debug(9, "struct param. before : %s \n",
                        print_structurals( Gstructure_parameters ));
 
   if (ENTITY_READ_P( call_function(c) )) {
        list the_arg = call_arguments( c );
 
        MAPL( exp_ptr,
              {
          expression exp = EXPRESSION(CAR( exp_ptr ));
          ent = expression_int_scalar( (expression) exp );
          if ((ent != entity_undefined)  && !in_forward_defined_p(ent, swfl))
                ADD_ELEMENT_TO_LIST( Gstructure_parameters, ENTITY, ent );
          },
              the_arg);
   }
 
   if (    ((lhs_ent = sp_feautrier_scalar_assign_call(c)) != entity_undefined)
        && (in_forward_defined(lhs_ent, swfl) <= 1) )   {
 
        expression nsp_exp;
        entity     nsp_ent;
 
        if ( !ENTITY_SP_P( lhs_ent ) ) {
                ADD_ELEMENT_TO_LIST( Gstructure_parameters, ENTITY, lhs_ent );
        }
        else {
                nsp_ent = make_nsp_entity();
                nsp_exp = make_entity_expression( nsp_ent, NIL );
                hash_put(fst, (char*) lhs_ent, (char*) nsp_exp  );
                ADD_ELEMENT_TO_LIST( Gstructure_parameters, ENTITY, nsp_ent );
                ret_bool = true;
        }
   }
 
   pips_debug(9, "struct param. after  : %s \n",
                        print_structurals( Gstructure_parameters ));
   pips_debug(9, "call has to be modified : %s \n",
                ((ret_bool == true)?"TRUE":"FALSE") );
   pips_debug(7, "end\n");
   return( ret_bool );
}

References ADD_ELEMENT_TO_LIST, call_arguments, call_function, CAR, ENTITY, ENTITY_READ_P, ENTITY_SP_P, entity_undefined, exp, EXPRESSION, expression_int_scalar(), Gstructure_parameters, hash_put(), in_forward_defined(), in_forward_defined_p(), make_entity_expression(), make_nsp_entity(), MAPL, NIL, pips_debug, print_structurals(), sp_feautrier_scalar_assign_call(), Words_Regular_Call(), and words_to_string().

Here is the call graph for this function:

in_forward_defined()

int in_forward_defined	(	entity	ent,
		list *	swfl
	)

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

int in_forward_defined( (entity) ent ) AL 30/08/93 Returns the number of entities ent in the list Gscalar_written_forward.

Parameters

ent	nt
swfl	wfl

Definition at line 836 of file utils.c.

{
    cons *pc;
    int  ret_int = 0;
 
    pips_debug(9, "doing \n");
    for (pc = *swfl; pc != NIL; pc = pc->cdr ) {
        if ((void *) ent == CAR(pc).p)
                ret_int++;
    }
 
    pips_debug(9, "returns : %d\n", ret_int);
    return( ret_int );
}

References CAR, cons::cdr, NIL, and pips_debug.

Referenced by get_sp_of_call_p().

Here is the caller graph for this function:

in_forward_defined_p()

bool in_forward_defined_p	(	entity	ent,
		list *	swfl
	)

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

bool in_forward_defined_p( (entity) ent ) AL 04/93 Returns true if ent is in global variable Gscalar_written_forward.

Parameters

ent	nt
swfl	wfl

Definition at line 855 of file utils.c.

{
        entity ch;
 
        pips_debug(7, "doing \n");
        ch = (entity) gen_find_eq(ent, *swfl );
        pips_debug(9, "scalar written_forward = %s\n",
                        print_structurals(*swfl) );
        return( ch != entity_undefined );
}

References entity_undefined, gen_find_eq(), pips_debug, and print_structurals().

Referenced by get_sp_of_call_p().

Here is the call graph for this function:

Here is the caller graph for this function:

is_expression_in_list()

bool is_expression_in_list	(	expression	exp,
		list	l
	)

State if an expression OR part of that expression corresponds to one of the entity of the list l.

This function was specifically designed in order to find if an expression is using one of the variable/entity listed in l. The function considers that the list only contains scalar variables.

Parameters

exp

xp

Definition at line 1200 of file utils.c.

                                                     {
   if (l == NIL)
     return false;
   syntax s = expression_syntax(exp);
   switch (syntax_tag(s)) {
     // If the expression is an array we go look among the indices by calling
     // the function on these indices
   case is_syntax_reference :
     {
       reference ref = syntax_reference(s);
       if (reference_indices(ref) != NIL) {
         FOREACH(expression, e, reference_indices(ref)) {
           if(is_expression_in_list(e, l))
             return true;
         }
       }
       else {
         entity ent = reference_variable(ref);
         if (gen_find_eq(ent, l) != chunk_undefined)
           return true;
       }
     }
     break;
     // Same principle, we go look among the arguments of the call
   case is_syntax_call :
     {
       call c = syntax_call(s);
       FOREACH(expression, e, call_arguments(c)) {
         if(is_expression_in_list(e, l))
           return true;
       }
     }
     break;
   case is_syntax_cast :
     {
       cast ca = syntax_cast(s);
       entity ent = expression_to_entity(cast_expression(ca));
       if (gen_find_eq(ent, l) != chunk_undefined) {
         return true;
       }
     }
     break;
     // We call the function on every component of the range object
   case is_syntax_range :
     {
       range ra = syntax_range(s);
       return is_expression_in_list(range_lower(ra), l) || is_expression_in_list(range_upper(ra), l) || is_expression_in_list(range_increment(ra), l);
     }
     break;
   case is_syntax_subscript :
     {
       subscript sub = syntax_subscript(s);
       bool isinArray = is_expression_in_list(subscript_array(sub), l);
       if (isinArray)
         return true;
       FOREACH(expression, e, subscript_indices(sub)) {
         if (is_expression_in_list(e, l)) {
           return true;
         }
       }
     }
     break;
   case is_syntax_application :
     {
       application app = syntax_application(s);
       bool isinFunction = is_expression_in_list(application_function(app), l);
       if (isinFunction)
         return true;
       FOREACH(expression, e, application_arguments(app)) {
         if (is_expression_in_list(e, l)) {
           return true;
         }
       }
     }
     break;
   case is_syntax_va_arg :
     {
       list sil = syntax_va_arg(s);
       FOREACH(sizeofexpression, soe, sil) {
         if (is_expression_in_list(sizeofexpression_expression(soe), l))
           return true;
       }
     }
     break;
   case is_syntax_sizeofexpression :
     {
       sizeofexpression si = syntax_sizeofexpression(s);
       if (is_expression_in_list(sizeofexpression_expression(si), l))
         return true;
     }
     break;
   default :
     return false;
   }
   return false;
 }

References application_arguments, application_function, call_arguments, cast_expression, chunk_undefined, exp, expression_syntax, expression_to_entity(), FOREACH, gen_find_eq(), is_expression_in_list(), 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, NIL, range_increment, range_lower, range_upper, ref, reference_indices, reference_variable, sizeofexpression_expression, subscript_array, subscript_indices, syntax_application, syntax_call, syntax_cast, syntax_range, syntax_reference, syntax_sizeofexpression, syntax_subscript, syntax_tag, and syntax_va_arg.

Referenced by get_reference_assignments(), and is_expression_in_list().

Here is the call graph for this function:

Here is the caller graph for this function:

loops_to_indices()

list loops_to_indices

(

list

l

)

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

list loops_to_indices((loop) l ) AL 04/93 Returns indices of the loop -list l.

Definition at line 630 of file utils.c.

{
        list rl = NIL;
        loop lo;
 
        pips_debug(7, "doing\n");
        if (l == NIL) return(NIL);
        MAPL( loop_ptr, {
                lo = LOOP(CAR( loop_ptr ));
                ADD_ELEMENT_TO_LIST( rl, ENTITY, loop_index( lo ) );
        }, l);
        return rl;
}

References ADD_ELEMENT_TO_LIST, CAR, ENTITY, LOOP, loop_index, MAPL, NIL, and pips_debug.

Referenced by splc_linear_expression_p().

Here is the caller graph for this function:

make_undefined_list()

list make_undefined_list

(

void

)

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

list make_undefined_list( ) AL 04/93 Duplicates a list of 2 undefined statements.

FI: this is no longer possible. List elements must be defined. Maybe empty/nop statements could be used instead?

Definition at line 815 of file utils.c.

{
        list the_list = NIL;
 
        pips_debug(7, "doing\n");
        /*
        ADD_ELEMENT_TO_LIST( the_list, STATEMENT, statement_undefined);
        ADD_ELEMENT_TO_LIST( the_list, STATEMENT, statement_undefined);
        */
        ADD_ELEMENT_TO_LIST( the_list, STATEMENT,
                             make_continue_statement(entity_empty_label()));
        ADD_ELEMENT_TO_LIST( the_list, STATEMENT,
                             make_continue_statement(entity_empty_label()));
        return the_list;
}

References ADD_ELEMENT_TO_LIST, entity_empty_label(), make_continue_statement(), NIL, pips_debug, and STATEMENT.

Referenced by loop_normalize_of_loop(), and loop_normalize_of_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

ndf_normalized_test()

list ndf_normalized_test	(	expression	exp,
		list *	ell
	)

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

list ndf_normalized_test( (expression) exp, (list) *ell) AL 04/93 Returns a list of positive linear forms from an input expression which is a logical combinaison of affine forms of structural parameters and of loop counters.

Redon FND propagation : see document.

We propagate an Exclusive Normal Disjunctive Form

if (ENTITY_OR_P( fun )) { list not_l1, not_l2, l1, l2;

l1 = ndf_normalized_test(arg1, ell); l2 = ndf_normalized_test( arg2, ell); not_l1 = ndf_normalized_test( MakeUnaryCall(ENTITY_NOT, arg1), ell ); not_l2 = ndf_normalized_test( MakeUnaryCall(ENTITY_NOT, arg2), ell );

MAPL( exp_ptr, { expression S1 = EXPRESSION(CAR( exp_ptr )); MAPL( exp_ptr2, { expression T1 = EXPRESSION(CAR( exp_ptr )); ADD_ELEMENT_TO_LIST( ret_list, EXPRESSION, MakeBinaryCall( ENTITY_AND, S1, T1 ) ); }, l2); }, not_l1 );

MAPL( exp_ptr, { expression S1 = EXPRESSION(CAR( exp_ptr )); MAPL( exp_ptr2, { expression T1 = EXPRESSION(CAR( exp_ptr )); ADD_ELEMENT_TO_LIST( ret_list, EXPRESSION, MakeBinaryCall( ENTITY_AND, S1, T1 ) ); }, l2); }, l1 );

MAPL( exp_ptr, { expression S1 = EXPRESSION(CAR( exp_ptr )); MAPL( exp_ptr2, { expression T1 = EXPRESSION(CAR( exp_ptr )); ADD_ELEMENT_TO_LIST( ret_list, EXPRESSION, MakeBinaryCall( ENTITY_AND, S1, T1 ) ); }, not_l2); }, l1 );

return( ret_list ); }

Parameters

exp	xp
ell	ll

Definition at line 306 of file utils.c.

{
        list            args, ret_list = NIL;
        entity          fun;
        expression      arg1, arg2, exp2, exp3;
 
        pips_debug(7, "doing\n");
        if ( (exp == expression_undefined) ||
                (syntax_tag(expression_syntax( exp )) != is_syntax_call) ) {
                return  NIL;
        }
        pips_debug(7, "input exp : %s\n",
                   expression_to_string( exp ) );
 
        fun = call_function(syntax_call(expression_syntax( exp )));
        args = call_arguments(syntax_call(expression_syntax( exp )));
        if(ENDP(args)) return NIL;
 
        if (splc_positive_relation_p(exp, ell))  {
                ADD_ELEMENT_TO_LIST( ret_list, EXPRESSION, exp );
                return( ret_list );
        }
        if (ENTITY_NOT_P( fun )) {
                arg1 = EXPRESSION(CAR(args));
                if (splc_positive_relation_p(arg1, ell)) {
                        exp3 = EXPRESSION(CAR( call_arguments(
                                 syntax_call(expression_syntax( arg1 )))));
                        exp2 = MakeBinaryCall( ENTITY_GE,
                                 make_op_exp( MINUS_OPERATOR_NAME,
                                   int_to_expression(-1),
                                   exp3 ),
                                 int_to_expression(0) );
                        ADD_ELEMENT_TO_LIST( ret_list, EXPRESSION, exp2 );
                        return( ret_list );
                }
                else {
                        expression exp2 = expression_undefined;
 
                        MAPL( exp_ptr, {
                           exp3 = EXPRESSION(CAR( exp_ptr ));
                           if (exp2 == expression_undefined)
                             exp2 = sc_opposite_exp_of_conjunction(exp3, ell);
                           else
                             exp2 = MakeBinaryCall(ENTITY_AND,
                                     sc_opposite_exp_of_conjunction(exp3, ell),
                                                   copy_expression( exp2 ) );
                        }, ndf_normalized_test(arg1, ell));
                        ret_list = ndf_normalized_test(exp2, ell);
                        return( ret_list );
                }
        }
 
        arg1 = EXPRESSION(CAR(args));
        arg2 = EXPRESSION(CAR(CDR(args)));
 
        /*  Redon FND propagation : see document. */
        if (ENTITY_OR_P( fun )) {
           expression exp3;
        
           MAPL( exp_ptr, {
              exp3 = EXPRESSION(CAR( exp_ptr ));
              ADD_ELEMENT_TO_LIST( ret_list, EXPRESSION, exp3 );
              }, ndf_normalized_test(arg1, ell));
           MAPL( exp_ptr, {
              exp3 = EXPRESSION(CAR( exp_ptr ));
              ADD_ELEMENT_TO_LIST( ret_list, EXPRESSION, exp3 );
              }, ndf_normalized_test(arg2, ell));
           return( ret_list );
        }
        
        /*
        %%%%%%%%%%%%%
        */
 
        /* We propagate an Exclusive Normal Disjunctive Form */
        /* if (ENTITY_OR_P( fun )) {
         * list         not_l1, not_l2, l1, l2;
         *
         *l1 = ndf_normalized_test(arg1, ell);
         *l2 = ndf_normalized_test( arg2, ell);
         *not_l1 = ndf_normalized_test( MakeUnaryCall(ENTITY_NOT, arg1), ell );
         *not_l2 = ndf_normalized_test( MakeUnaryCall(ENTITY_NOT, arg2), ell );
         *
         * MAPL( exp_ptr, {
         * expression S1 = EXPRESSION(CAR( exp_ptr ));
         *MAPL( exp_ptr2, {
         *expression T1 = EXPRESSION(CAR( exp_ptr ));
         *ADD_ELEMENT_TO_LIST( ret_list,  EXPRESSION,
         *MakeBinaryCall( ENTITY_AND, S1, T1 ) );
         *}, l2);
         *}, not_l1 );
         *
         *MAPL( exp_ptr, {
         *expression S1 = EXPRESSION(CAR( exp_ptr ));
         *              MAPL( exp_ptr2, {
         *                      expression T1 = EXPRESSION(CAR( exp_ptr ));
         *                      ADD_ELEMENT_TO_LIST( ret_list,  EXPRESSION,
         *                              MakeBinaryCall( ENTITY_AND, S1, T1 ) );
         *              }, l2);
         *      }, l1 );
         *
         *      MAPL( exp_ptr, {
         *              expression S1 = EXPRESSION(CAR( exp_ptr ));
         *              MAPL( exp_ptr2, {
         *                      expression T1 = EXPRESSION(CAR( exp_ptr ));
         *                      ADD_ELEMENT_TO_LIST( ret_list,  EXPRESSION,
         *                              MakeBinaryCall( ENTITY_AND, S1, T1 ) );
         *              }, not_l2);
         *      }, l1 );
         *
         *      return( ret_list );
         *}
         */
        else if (ENTITY_AND_P( fun )) {
                expression      exp4, exp5, exp6;
                list            l1, l2;
                
                l1 = ndf_normalized_test(arg1, ell);
                l2 = ndf_normalized_test(arg2, ell);
                MAPL( exp_ptr, {
                        exp4 = EXPRESSION(CAR( exp_ptr ));
                        MAPL( ep, {
                           exp5 = EXPRESSION(CAR( ep ));
                           exp6 = MakeBinaryCall( ENTITY_AND,
                                        exp4, exp5 );
                           ADD_ELEMENT_TO_LIST(ret_list, EXPRESSION, exp6);
                        }, l2 );
                }, l1 );
                return( ret_list );
        }
        else return NIL;
}

References ADD_ELEMENT_TO_LIST, call_arguments, call_function, CAR, CDR, copy_expression(), ENDP, ENTITY_AND, ENTITY_AND_P, ENTITY_GE, ENTITY_NOT_P, ENTITY_OR_P, exp, EXPRESSION, expression_syntax, expression_to_string(), expression_undefined, int_to_expression(), is_syntax_call, make_op_exp(), MakeBinaryCall(), MAPL, MINUS_OPERATOR_NAME, ndf_normalized_test(), NIL, pips_debug, sc_opposite_exp_of_conjunction(), splc_positive_relation_p(), syntax_call, and syntax_tag.

Referenced by ndf_normalized_test(), and sc_conditional().

Here is the call graph for this function:

Here is the caller graph for this function:

normalizable_loop_p()

bool normalizable_loop_p

(

loop

l

)

bool normalizable_loop_p(loop l) Returns true if "l" has a constant step.

Definition at line 1172 of file utils.c.

{
  pips_debug(7, "doing\n");
  return(expression_constant_p(range_increment(loop_range(l))));
}

References expression_constant_p(), loop_range, pips_debug, and range_increment.

Referenced by loop_normalize_of_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

normalizable_loop_p_retrieved()

bool normalizable_loop_p_retrieved

(

loop

l

)

Code retrieved from revision 14476, transformations/loop_normalize.c.

Code to be retrieved: I suppose you need a constant increment?

Definition at line 1183 of file utils.c.

{
  bool ok = false;
  entity i = loop_index(l);
  range r = loop_range(l);
 
  ok = normalizable_and_linear_loop_p(i, r);
 
  return ok;
}

References loop_index, loop_range, normalizable_and_linear_loop_p(), and ok.

Here is the call graph for this function:

normalize_test_leaves()

expression normalize_test_leaves	(	expression	exp,
		list *	ell
	)

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

expression normalize_test_leaves((expression) exp, (list) *ell) AL 04/93 If exp is linear in structurals and loop-counters, it returns the same expression with linear positive forms

We return expression_undefined if we can not normalize

Parameters

exp	xp
ell	ll

Definition at line 445 of file utils.c.

{
        syntax          s        = expression_syntax( exp );
        entity          fun      = call_function(syntax_call( s ));
        list            args     = call_arguments(syntax_call( s ));
        list            new_args = NIL;
        expression      ret_exp  = expression_undefined , ret_exp1  = expression_undefined, ret_exp2  = expression_undefined;
        expression      e, ne, arg1, arg2, arg3, arg4;
 
        if (exp == expression_undefined || args == NIL) return( exp );
        pips_debug(7, "exp : %s\n",
                   expression_to_string( exp ) );
        if (syntax_tag( s ) != is_syntax_call) return( ret_exp );
 
        if (ENTITY_NOT_P( fun )) {
                expression exp1 =
                  normalize_test_leaves(EXPRESSION(CAR(args)), ell);
 
                /* We return expression_undefined if we can not normalize */
                if (exp1 == expression_undefined) return(expression_undefined);
 
                ret_exp = MakeUnaryCall(ENTITY_NOT, exp1 );
                pips_debug(7, "returning : %s\n",
                           expression_to_string( ret_exp ) );
                return( ret_exp );
        }
 
        arg1 = EXPRESSION(CAR(args));
        arg2 = EXPRESSION(CAR(CDR(args)));
        arg3 = copy_expression( arg1 );
        arg4 = copy_expression( arg2 );
        if (ENTITY_EQUIV_P( fun )) {
          ret_exp1 = MakeBinaryCall( ENTITY_OR,
                                     MakeUnaryCall( ENTITY_NOT, arg1),
                                     arg2 );
          ret_exp2 = MakeBinaryCall( ENTITY_OR,
                                     MakeUnaryCall( ENTITY_NOT, arg4),
                                     arg3 ) ;
          exp = MakeBinaryCall( ENTITY_AND, ret_exp1, ret_exp2 );
        }
        else if (ENTITY_NON_EQUIV_P( fun )) {
          MakeBinaryCall( ENTITY_AND,
                          MakeUnaryCall( ENTITY_NOT, arg2),
                          arg1 );
          MakeBinaryCall( ENTITY_AND,
                          MakeUnaryCall( ENTITY_NOT, arg3),
                          arg4 ) ;
          exp = MakeBinaryCall( ENTITY_OR, ret_exp1, ret_exp2);
        }
        
        s = expression_syntax( exp );
        fun = call_function(syntax_call( s ));
        args = call_arguments(syntax_call( s ));
        arg1 = EXPRESSION(CAR(args));
        arg2 = EXPRESSION(CAR(CDR(args)));
        arg3 = copy_expression( arg1 );
        arg4 = copy_expression( arg2 );
        if (ENTITY_STRICT_LOGICAL_OPERATOR_P( fun )) {
          MAPL( exp_ptr, {
              e = EXPRESSION(CAR( exp_ptr ));
              ne = normalize_test_leaves(e, ell);
              if (ne == expression_undefined) return(ne);
              ADD_ELEMENT_TO_LIST(new_args, EXPRESSION,
                                  copy_expression( ne ));
            }, args);
          call_arguments(syntax_call( s )) = new_args;
          ret_exp = copy_expression( exp );
          pips_debug(7, "returning : %s\n",
                     expression_to_string( ret_exp ) );
          return( ret_exp );
        }
        else if (       ENTITY_RELATIONAL_OPERATOR_P( fun ) &&
                        (!splc_linear_expression_p(arg1, ell) ||
                         !splc_linear_expression_p(arg2, ell)) ) {
          
          pips_debug(7, "returning : %s\n",
                     "expression_undefined" );
          return( expression_undefined );
        }
        if (ENTITY_LESS_THAN_P( fun )) {
          ret_exp = MakeBinaryCall( ENTITY_GE,
                                    make_op_exp( MINUS_OPERATOR_NAME,
                                                 make_op_exp(
                                                             MINUS_OPERATOR_NAME,
                                                             arg2, arg1 ),
                                                 int_to_expression(1) ),
                                    int_to_expression(0) );
        }
        else if (ENTITY_LESS_OR_EQUAL_P( fun )) {
          ret_exp = MakeBinaryCall( ENTITY_GE,
                                    make_op_exp( MINUS_OPERATOR_NAME,
                                                 arg2, arg1 ),
                                    int_to_expression(0) );
        }
        else if (ENTITY_GREATER_THAN_P( fun )) {
          ret_exp = MakeBinaryCall( ENTITY_GE,
                                    make_op_exp( MINUS_OPERATOR_NAME,
                                                 make_op_exp(
                                                             MINUS_OPERATOR_NAME,
                                                             arg1, arg2 ),
                                                 int_to_expression(1) ),
                                    int_to_expression(0) );
        }
        else if (ENTITY_GREATER_OR_EQUAL_P( fun )) {
          ret_exp = MakeBinaryCall( (entity) ENTITY_GE,
                                    make_op_exp( MINUS_OPERATOR_NAME,
                                                 arg1, arg2 ),
                                    int_to_expression(0) );
        }
        else if (ENTITY_EQUAL_P( fun )) {
          ret_exp1 = MakeBinaryCall( ENTITY_GE,
                                     make_op_exp( MINUS_OPERATOR_NAME,
                                                  arg1, arg2 ),
                                     int_to_expression(0) );
          ret_exp2 = MakeBinaryCall( ENTITY_GE,
                                     make_op_exp( MINUS_OPERATOR_NAME,
                                                  arg4, arg3 ),
                                     int_to_expression(0) ) ;
           ret_exp = MakeBinaryCall( ENTITY_AND, ret_exp1, ret_exp2);
        }
        else if (ENTITY_NON_EQUAL_P( fun )) {
          ret_exp1 = MakeBinaryCall( ENTITY_GE,
                                make_op_exp( MINUS_OPERATOR_NAME,
                                             make_op_exp( MINUS_OPERATOR_NAME,
                                        arg1, arg2 ),
                                   int_to_expression(1) ),
                                 int_to_expression(0) );
          ret_exp2 =  MakeBinaryCall( ENTITY_GE,
                                make_op_exp( MINUS_OPERATOR_NAME,
                                   make_op_exp( MINUS_OPERATOR_NAME,
                                        arg4, arg3 ),
                                   int_to_expression(1) ),
                                      int_to_expression(0) );
          ret_exp = MakeBinaryCall( ENTITY_OR, ret_exp1, ret_exp2);
        }
        else ret_exp = expression_undefined;
 
        pips_debug(7, "returning : %s\n",
                ((ret_exp == expression_undefined)?"expression_undefined":\
                 expression_to_string( ret_exp )) );
        return( ret_exp );
}

References ADD_ELEMENT_TO_LIST, call_arguments, call_function, CAR, CDR, copy_expression(), ENTITY_AND, ENTITY_EQUAL_P, ENTITY_EQUIV_P, ENTITY_GE, ENTITY_GREATER_OR_EQUAL_P, ENTITY_GREATER_THAN_P, ENTITY_LESS_OR_EQUAL_P, ENTITY_LESS_THAN_P, ENTITY_NON_EQUAL_P, ENTITY_NON_EQUIV_P, ENTITY_NOT, ENTITY_NOT_P, ENTITY_OR, ENTITY_RELATIONAL_OPERATOR_P, ENTITY_STRICT_LOGICAL_OPERATOR_P, exp, EXPRESSION, expression_syntax, expression_to_string(), expression_undefined, int_to_expression(), is_syntax_call, make_op_exp(), MakeBinaryCall(), MakeUnaryCall(), MAPL, MINUS_OPERATOR_NAME, NIL, normalize_test_leaves(), pips_debug, splc_linear_expression_p(), syntax_call, and syntax_tag.

Referenced by normalize_test_leaves(), and sc_conditional().

Here is the call graph for this function:

Here is the caller graph for this function:

print_structurals()

string print_structurals

(

list

l

)

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

char* print_structurals( (list) l ) AL 04/93 Prints structural parameters.

Definition at line 732 of file utils.c.

{
        return(strdup( words_to_string(words_entity_list( l )) ));
}

References strdup(), words_entity_list(), and words_to_string().

Referenced by get_sp_of_call_p(), in_forward_defined_p(), static_controlize(), static_controlize_statement(), static_controlize_unstructured(), and verify_structural_parameters().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_conditional()

expression sc_conditional	(	expression	exp,
		list *	ell
	)

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

expression sc_conditional( (expression) exp, (list) *ell ) AL 04/93 If exp is linear in structurals and loop-counters, it returns the same expression with a normal disjunctive form.

Parameters

exp	xp
ell	ll

Definition at line 596 of file utils.c.

{
        expression      e, ret_exp = expression_undefined;
        syntax          s = expression_syntax( exp );
        list            ndf_list;
 
        pips_debug(7, "exp : %s\n",
                   expression_to_string(exp));
 
        if ( syntax_tag(s) != is_syntax_call ) return( ret_exp );
        e = normalize_test_leaves(exp, ell);
        ndf_list = ndf_normalized_test(e, ell);
        if (ndf_list != NIL) {
                ret_exp = EXPRESSION(CAR( ndf_list ));
                ndf_list = CDR( ndf_list );
                MAPL( exp_ptr,{
                        e = EXPRESSION(CAR( exp_ptr ));
                        ret_exp = MakeBinaryCall( ENTITY_OR,
                                        copy_expression( ret_exp ), e );
                }, ndf_list );
        }
 
        pips_debug(7, "returning : %s\n",
                ((ret_exp == expression_undefined)?"expression_undefined":
                 expression_to_string( ret_exp )) );
        return( ret_exp );
}                       

References CAR, CDR, copy_expression(), ENTITY_OR, exp, EXPRESSION, expression_syntax, expression_to_string(), expression_undefined, is_syntax_call, MakeBinaryCall(), MAPL, ndf_normalized_test(), NIL, normalize_test_leaves(), pips_debug, and syntax_tag.

Referenced by static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_entity_to_formal_integer_parameters()

list sc_entity_to_formal_integer_parameters

(

entity

f

)

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

list sc_entity_to_formal_integer_parameters((entity) f) This is a strict copy of entity_to_formal_integer_parameters from semantics/interprocedural.c . This function is copied here to keep locality of local functions to each pass.

FI: Well, but it was modified to handle all integer scalar variables and a bug was added because a COMMON has a RAM storage (OK, this could be discussed). I add a test on type_variable_p()

Definition at line 900 of file utils.c.

{
    list formals_or_ram_integer = NIL;
    list decl = NIL;
 
    pips_assert("sc_entity_to_formal_integer_parameters",entity_module_p(f));
 
    decl = code_declarations(entity_code(f));
    MAPL(ce, {entity e = ENTITY(CAR(ce));
              storage sto = entity_storage(e);
              type t = entity_type(e);
 
              if( type_variable_p(t)
                  && (storage_formal_p(sto) || storage_ram_p(sto))
                  && entity_integer_scalar_p(e))
                  formals_or_ram_integer = CONS(ENTITY, e,
                                                formals_or_ram_integer);},
         decl);
 
    return formals_or_ram_integer;
}

References CAR, code_declarations, CONS, ENTITY, entity_code(), entity_integer_scalar_p(), entity_module_p(), entity_storage, entity_type, f(), MAPL, NIL, pips_assert, storage_formal_p, storage_ram_p, and type_variable_p.

Referenced by static_controlize().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_list_of_entity_dup()

list sc_list_of_entity_dup

(

list

l

)

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

list sc_list_of_entity_dup( (list) l ) AL 04/93 Duplicates a list of entities.

Definition at line 761 of file utils.c.

{
        list rl = NIL;
 
        pips_debug( 7, "doing\n");
        if ( l == NIL ) return( NIL );
        MAPL( ent_ptr, {
                entity ent = ENTITY(CAR( ent_ptr ));
                ADD_ELEMENT_TO_LIST( rl, ENTITY, ent );
        }, l );
        return( rl );
}

References ADD_ELEMENT_TO_LIST, CAR, ENTITY, MAPL, NIL, and pips_debug.

Referenced by static_controlize_call(), static_controlize_statement(), and static_controlize_unstructured().

Here is the caller graph for this function:

sc_list_of_exp_dup()

list sc_list_of_exp_dup

(

list

l

)

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

list sc_list_of_exp_dup( (list) l ) AL 04/93 Duplicates a list of expressions.

Definition at line 741 of file utils.c.

{
        list ret_list = NIL;
 
        pips_debug(9, "begin\n");
        for(; !ENDP( l ); POP( l ) ) {
                expression exp;
 
                exp = EXPRESSION(CAR( l ));
                ADD_ELEMENT_TO_LIST( ret_list, EXPRESSION, copy_expression(exp) );
        }
 
        pips_debug(9, "end\n");
        return( ret_list );
}

References ADD_ELEMENT_TO_LIST, CAR, copy_expression(), ENDP, exp, EXPRESSION, NIL, pips_debug, and POP.

Referenced by static_controlize_call(), static_controlize_statement(), and static_controlize_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

sc_list_of_loop_dup()

list sc_list_of_loop_dup

(

list

l

)

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

list sc_list_of_loop_dup( (list) l ) AL 04/93 Duplicates a list of loops. See Newgen gen_copy_seq()?

Definition at line 778 of file utils.c.

{
        list rl = NIL;
 
        pips_debug( 7, "doing\n");
        if ( l == NIL ) return(NIL);
        MAPL( loop_ptr, {
                loop lo = LOOP(CAR( loop_ptr ));
                ADD_ELEMENT_TO_LIST( rl, LOOP, lo );
        }, l );
        return( rl );
}

References ADD_ELEMENT_TO_LIST, CAR, LOOP, MAPL, NIL, and pips_debug.

Referenced by static_controlize_statement(), and static_controlize_unstructured().

Here is the caller graph for this function:

sc_loop_dup()

loop sc_loop_dup

(

loop

l

)

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

list sc_loop_dup( (list) l ) AL 04/93 Duplicates a loop with sharing of the loop_body and sharing of the loop locals.

Definition at line 796 of file utils.c.

{
        loop new_loop;
 
        pips_debug( 7, "doing\n");
        new_loop = make_loop(loop_index(l), copy_range(loop_range(l)),
                        loop_body(l), loop_label(l), loop_execution(l),
                        loop_locals(l));
 
        return(new_loop);
}

References copy_range(), loop_body, loop_execution, loop_index, loop_label, loop_locals, loop_range, make_loop(), and pips_debug.

Here is the call graph for this function:

sc_opposite_exp_of_conjunction()

expression sc_opposite_exp_of_conjunction	(	expression	exp,
		list *	ell
	)

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

expression sc_opposite_exp_of_conjunction(expression exp, (list) *ell) AL 08/19/93 Input : exp a conjunction of linear expressions Output : simplified value of NOT( exp )

Parameters

exp	xp
ell	ll

Definition at line 236 of file utils.c.

{
        expression ret_exp;
 
        pips_debug(9, "begin\n");
        if ( (exp == expression_undefined) ||
                (syntax_tag(expression_syntax( exp )) != is_syntax_call) ) {
                ret_exp = expression_undefined;
        }
        else if (splc_positive_relation_p(exp, ell)) {
                expression      exp1, exp2;
                exp1 = EXPRESSION(CAR( call_arguments(
                                syntax_call(expression_syntax( exp )))));
                exp2 = MakeBinaryCall( ENTITY_GE,
                           make_op_exp( MINUS_OPERATOR_NAME,
                                int_to_expression(-1), exp1 ),
                           int_to_expression(0) );
                ret_exp = exp2;
        }
        else if(ENTITY_AND_P(call_function(
                        syntax_call(expression_syntax( exp ))))) {
                list            args = NIL;
                expression      r_exp, l_exp;
 
                args = call_arguments(syntax_call(expression_syntax( exp )));
                l_exp = EXPRESSION(CAR( args ));
                r_exp = EXPRESSION(CAR(CDR( args )));
                ret_exp = MakeBinaryCall( ENTITY_OR,
                                sc_opposite_exp_of_conjunction(l_exp, ell),
                                sc_opposite_exp_of_conjunction(r_exp, ell));
                        
        }
        else ret_exp = expression_undefined;
 
        pips_debug(9, "end\n");
        return( ret_exp );
}

References call_arguments, call_function, CAR, CDR, ENTITY_AND_P, ENTITY_GE, ENTITY_OR, exp, EXPRESSION, expression_syntax, expression_undefined, int_to_expression(), is_syntax_call, make_op_exp(), MakeBinaryCall(), MINUS_OPERATOR_NAME, NIL, pips_debug, sc_opposite_exp_of_conjunction(), splc_positive_relation_p(), syntax_call, and syntax_tag.

Referenced by ndf_normalized_test(), and sc_opposite_exp_of_conjunction().

Here is the call graph for this function:

Here is the caller graph for this function:

sp_feautrier_expression_p()

bool sp_feautrier_expression_p

(

expression

exp

)

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

bool sp_feautrier_expression_p( (expression) exp) Returns true if exp quasi affine form.

Parameters

exp

xp

Definition at line 995 of file utils.c.

{
        bool b = false;
        syntax s = expression_syntax( exp );
 
        pips_debug(7, "exp : %s \n",
                ((exp == expression_undefined)?"expression_undefined":
                 expression_to_string( exp  ) ));
 
        if (sp_linear_expression_p( exp )) return( true );
        if ( syntax_tag( s ) == is_syntax_call ) {
                call c;
                list args;
                expression exp1, exp2;
 
                c = syntax_call( s );
                if (ENTITY_DIVIDE_P(call_function( c ))) {
                        args = call_arguments( c );
                        exp1 = EXPRESSION(CAR( args ));
                        exp2 = EXPRESSION(CAR( CDR(args) ));
                        b    = sp_feautrier_expression_p( exp1 )
                          && expression_constant_p( exp2 );
                }
        }
        pips_debug(7, "returning : %s\n",
                        (b?"TRUE":"FALSE") );
        return( b );
}

References call_arguments, call_function, CAR, CDR, ENTITY_DIVIDE_P, exp, EXPRESSION, expression_constant_p(), expression_syntax, expression_to_string(), expression_undefined, is_syntax_call, pips_debug, sp_feautrier_expression_p(), sp_linear_expression_p(), syntax_call, and syntax_tag.

Referenced by sp_feautrier_expression_p(), sp_feautrier_scalar_assign_call(), and static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

sp_feautrier_scalar_assign_call()

entity sp_feautrier_scalar_assign_call

(

call

c

)

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

entity sp_feautrier_scalar_assign_call( (call) c ) Returns the left-hand-side entity if it is an assignement of a linear combinaison of structural parameters.

Definition at line 1029 of file utils.c.

{
        entity          ent, ret_ent = entity_undefined;
        expression      rhs;
 
        pips_debug(7, "doing\n");
        if ((ent = scalar_assign_call(c)) != entity_undefined) {
                rhs = EXPRESSION(CAR(CDR(call_arguments(c))));
                if (sp_feautrier_expression_p( rhs )) ret_ent = ent;
        }
        pips_debug(7,
                "returning : %s \n",
                ((ret_ent == entity_undefined)?"entity_undefined":
                entity_name( ret_ent )) );
        return( ret_ent );
}

References call_arguments, CAR, CDR, entity_name, entity_undefined, EXPRESSION, pips_debug, scalar_assign_call(), and sp_feautrier_expression_p().

Referenced by get_reference_assignments(), and get_sp_of_call_p().

Here is the call graph for this function:

Here is the caller graph for this function:

sp_linear_expression_p()

bool sp_linear_expression_p

(

expression

exp

)

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

bool sp_linear_expression_p( (expression) exp) Returns true if the expression is a linear combinaison of structural parameters.

Parameters

exp

xp

Definition at line 928 of file utils.c.

{
   Pvecteur     vect;
   bool         ONLY_SP;
 
   pips_debug(7, "exp : %s\n", expression_to_string(exp));
 
   if(normalized_tag(NORMALIZE_EXPRESSION(exp)) == is_normalized_complex)
        ONLY_SP = false;
   else
   {
        vect = (Pvecteur) normalized_linear(expression_normalized(exp));
        ONLY_SP = true;
 
        for(; !VECTEUR_NUL_P(vect) && ONLY_SP ; vect = vect->succ)
        {
                entity var = (entity) vect->var;
 
                if( ! term_cst(vect) )
                if( ! (ENTITY_SP_P(var)) )
                        ONLY_SP = false;
        }
   }
   unnormalize_expression(exp);
   pips_debug(7,
                 "  result : %s\n", (ONLY_SP?"TRUE":"FALSE") );
   return(ONLY_SP);
}

References ENTITY_SP_P, exp, expression_normalized, expression_to_string(), is_normalized_complex, NORMALIZE_EXPRESSION, normalized_linear, normalized_tag, pips_debug, Svecteur::succ, term_cst, unnormalize_expression(), Svecteur::var, and VECTEUR_NUL_P.

Referenced by sp_feautrier_expression_p().

Here is the call graph for this function:

Here is the caller graph for this function:

splc_feautrier_expression_p()

bool splc_feautrier_expression_p	(	expression	exp,
		list *	ell
	)

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

bool splc_feautrier_expression_p( (expression) exp ) Returns true if exp quasi affine form in structural parameters and in surrounding loop-counters.

Parameters

exp	xp
ell	ll

Definition at line 962 of file utils.c.

{
        bool b = false;
        syntax s = expression_syntax( exp );
 
        pips_debug(7, "exp : %s \n",
                ((exp == expression_undefined)?"expression_undefined":
                 expression_to_string( exp  ) ));
 
        if (splc_linear_expression_p(exp, ell)) return( true );
        if ( syntax_tag( s ) == is_syntax_call ) {
                call c;
                list args;
                expression exp1, exp2;
 
                c = syntax_call( s );
                if (ENTITY_DIVIDE_P(call_function( c ))) {
                        args = call_arguments( c );
                        exp1 = EXPRESSION(CAR( args ));
                        exp2 = EXPRESSION(CAR( CDR(args) ));
                        b    = splc_feautrier_expression_p(exp1, ell)
                               && expression_constant_p( exp2 );
                }
        }
        pips_debug(7, "returning : %s\n",
                        (b?"TRUE":"FALSE") );
        return( b );
}

References call_arguments, call_function, CAR, CDR, ENTITY_DIVIDE_P, exp, EXPRESSION, expression_constant_p(), expression_syntax, expression_to_string(), expression_undefined, is_syntax_call, pips_debug, splc_feautrier_expression_p(), splc_linear_expression_p(), syntax_call, and syntax_tag.

Referenced by splc_feautrier_expression_p(), and static_controlize_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

splc_linear_access_to_arrays_p()

bool splc_linear_access_to_arrays_p	(	list	l,
		list *	ell
	)

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

bool splc_linear_access_to_arrays_p((list) l, (list) *ell) AL 04/93 Returns true if all expressions exp are structural parameters and loop counters linear functions.

Parameters

ell

ll

Definition at line 700 of file utils.c.

{
        bool            bo, ret_bo = true;
        expression      exp;
        syntax          s;
        tag             t;
 
        pips_debug(7, "doing\n");
        if (l == NIL) return(true);
        MAPL( exp_ptr, {
          exp = EXPRESSION(CAR( exp_ptr ));
          s   = expression_syntax( exp );
          t   = syntax_tag( s );
          if (t == is_syntax_call)
            bo =
              splc_linear_access_to_arrays_p(call_arguments(syntax_call(s)),
                                             ell);
          else if (t == is_syntax_reference)
            bo =
              splc_linear_expression_list_p(reference_indices(syntax_reference(s)),
                                            ell);
                else bo = false;
                ret_bo = ret_bo && bo;
        }, l );
 
        return( ret_bo );
}

References call_arguments, CAR, exp, EXPRESSION, expression_syntax, is_syntax_call, is_syntax_reference, MAPL, NIL, pips_debug, reference_indices, splc_linear_access_to_arrays_p(), splc_linear_expression_list_p(), syntax_call, syntax_reference, and syntax_tag.

Referenced by splc_linear_access_to_arrays_p(), and static_controlize_call().

Here is the call graph for this function:

Here is the caller graph for this function:

splc_linear_expression_list_p()

bool splc_linear_expression_list_p	(	list	l,
		list *	ell
	)

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

bool splc_linear_expression_list_p((list) l) AL 04/93 Returns true if all expressions exp are structural parameters and loop counters linear functions.

Parameters

ell

ll

Definition at line 682 of file utils.c.

{
        bool            bo = true;
        expression      exp;
 
        pips_debug( 7, "doing \n");
        MAPL( exp_ptr, {
                exp = EXPRESSION(CAR( exp_ptr ));
                bo = bo && splc_linear_expression_p(exp, ell);
                }, l );
        return( bo );
}

References CAR, exp, EXPRESSION, MAPL, pips_debug, and splc_linear_expression_p().

Referenced by splc_linear_access_to_arrays_p().

Here is the call graph for this function:

Here is the caller graph for this function:

splc_linear_expression_p()

bool splc_linear_expression_p	(	expression	exp,
		list *	ell
	)

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

bool splc_linear_expression_p((expression) exp) AL 04/93 Returns true if exp is linear in structural parameters and loop counters.

Parameters

exp	xp
ell	ll

Definition at line 648 of file utils.c.

{
  Pvecteur     vect;
  bool         ONLY_SPLC;
 
  pips_debug(7, "exp : %s\n", expression_to_string(exp));
 
  if(normalized_tag(NORMALIZE_EXPRESSION(exp)) == is_normalized_complex)
    ONLY_SPLC = false;
  else
  {
    vect = (Pvecteur) normalized_linear(expression_normalized(exp));
    ONLY_SPLC = true;
 
    for(; !VECTEUR_NUL_P(vect) && ONLY_SPLC ; vect = vect->succ)
    {
      entity var = (entity) vect->var;
      bool assigned_by_array = entity_assigned_by_array_p(var);
      if( ! term_cst(vect) )
        if(!(ENTITY_SP_P(var) || (gen_find_eq(var,loops_to_indices(*ell)) != chunk_undefined)) || assigned_by_array == true)
          ONLY_SPLC = false;
    }
  }
  unnormalize_expression(exp);
  pips_debug(7, "  result : %s\n", (ONLY_SPLC?"TRUE":"FALSE") );
  return(ONLY_SPLC);
}

References chunk_undefined, entity_assigned_by_array_p, ENTITY_SP_P, exp, expression_normalized, expression_to_string(), gen_find_eq(), is_normalized_complex, loops_to_indices(), NORMALIZE_EXPRESSION, normalized_linear, normalized_tag, pips_debug, Svecteur::succ, term_cst, unnormalize_expression(), Svecteur::var, and VECTEUR_NUL_P.

Referenced by normalize_test_leaves(), splc_feautrier_expression_p(), splc_linear_expression_list_p(), and splc_positive_relation_p().

Here is the call graph for this function:

Here is the caller graph for this function:

splc_positive_relation_p()

bool splc_positive_relation_p	(	expression	exp,
		list *	ell
	)

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

bool splc_positive_relation_p((expression) exp, list *ell) AL 04/93 Returns true if exp is an affine form of structural parameters and of loop-counters.

Parameters

exp	xp
ell	ll

Definition at line 282 of file utils.c.

{
        syntax s = expression_syntax( exp );
        call c;
        list args;
 
        pips_debug(7, "exp : %s\n",
                   expression_to_string( exp ));
        if (syntax_tag(s) != is_syntax_call) return( false );
        c = syntax_call( s );
        if (!ENTITY_GREATER_OR_EQUAL_P(call_function( c ))) return( false );
        args = call_arguments( c );
        return(splc_linear_expression_p(EXPRESSION(CAR(args)), ell) &&
               expression_equal_integer_p( EXPRESSION(CAR(CDR(args))), 0 ) );
}

References call_arguments, call_function, CAR, CDR, ENTITY_GREATER_OR_EQUAL_P, exp, EXPRESSION, expression_equal_integer_p(), expression_syntax, expression_to_string(), is_syntax_call, pips_debug, splc_linear_expression_p(), syntax_call, and syntax_tag.

Referenced by ndf_normalized_test(), and sc_opposite_exp_of_conjunction().

Here is the call graph for this function:

Here is the caller graph for this function:

stco_renumber_code()

int stco_renumber_code	(	statement	in_st,
		int	in_ct
	)

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

int stco_renumber_code( (statement) in_st, (int) in_ct ) AL 25/10/93 Input : A statement in_st and a begin count number in_ct. Output : Renumber statement_number in an textual order and return the last number attributed.

I've removed many renumbering since it is done by a deeper call to stco_renumber_code() and renumbering sequences kill an assert in the prettyprinter...

Renumber all the statement but the sequence:

Parameters

in_st	n_st
in_ct	n_ct

Definition at line 137 of file utils.c.

{
  int           count;
  instruction   inst;
  
  pips_debug(7, "begin\n");
  count = in_ct;
  inst = statement_instruction( in_st );
  
  /* Renumber all the statement but the sequence: */
  if (instruction_tag(inst) != is_instruction_block)
    statement_number(in_st) = count++;
  
  switch(instruction_tag(inst)) {
  case is_instruction_block : {
    MAPL( stmt_ptr, {
        statement st = STATEMENT(CAR( stmt_ptr ));
        /*
          statement_number( st ) = count++;
        */
        count = stco_renumber_code( st, count );
      }, instruction_block( inst ) );
    break;
  }
  case is_instruction_test : {
    test t = instruction_test(inst);
    statement tt, tf;
    
    tt = test_true( t );
    tf = test_false( t );
    /*
      statement_number( tt ) = count++;
      statement_number( tf ) = count++;
    */
    count = stco_renumber_code( tt, count );
    count = stco_renumber_code( tf, count );
    break;
  }
  case is_instruction_loop : {
    statement lb = loop_body( instruction_loop( inst ) );
    /*
      statement_number( lb ) = count++;
    */
    count = stco_renumber_code( lb, count );
    break;
  }
  case is_instruction_forloop :
    {
      break;
    }
  case  is_instruction_whileloop :
    {
      break;
    }
  case is_instruction_call : {
    break;
  }
  case is_instruction_goto : {
    statement gs = instruction_goto( inst );
    /*
      statement_number( gs ) = count++;
    */
    count = stco_renumber_code( gs, count );
    break;
  }
  case is_instruction_expression :
    {
      break;
    }
  case is_instruction_unstructured : {
    list blocs = NIL;
    unstructured u = instruction_unstructured( inst );
    
    control_map_get_blocs(unstructured_control(u), &blocs ) ;
    blocs = gen_nreverse( blocs ) ;
    MAPL( ctl_ptr,  {
        statement stmt = control_statement(
                                           CONTROL(CAR( ctl_ptr )));
        /*
          statement_number( stmt ) = count++;
        */
        count = stco_renumber_code( stmt, count );
      }, blocs);
    gen_free_list(blocs);
    break;
  }
  default : pips_internal_error("Ill. instruction tag");
  }
  
  pips_debug(7, "return count : %d\n", count);
  return( count );
}

References CAR, CONTROL, control_map_get_blocs(), control_statement, count, gen_free_list(), gen_nreverse(), instruction_block, instruction_goto, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, is_instruction_block, is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, loop_body, MAPL, NIL, pips_debug, pips_internal_error, STATEMENT, statement_instruction, statement_number, stco_renumber_code(), test_false, test_true, and unstructured_control.

Referenced by static_controlize(), and stco_renumber_code().

Here is the call graph for this function:

Here is the caller graph for this function:

stco_same_loops()

list stco_same_loops	(	statement_mapping	in_map,
		statement	in_s,
		statement	in_s2
	)

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

utils.c

list stco_same_loops( in_map, in_s, in_s2 ) AL 25/10/93 Input : A static_control mapping on statements and 2 statements. Output : A list of loops common to in_s and in_s2.

Parameters

in_map	n_map
in_s	n_s
in_s2	n_s2

Definition at line 98 of file utils.c.

{
        list            l, l2, ret_l = NIL;
        static_control  sc, sc2;
 
        pips_debug(7,"begin\n");
        sc = (static_control) GET_STATEMENT_MAPPING( in_map, in_s );
        sc2= (static_control) GET_STATEMENT_MAPPING( in_map, in_s2 );
        l = static_control_loops( sc );
        l2 = static_control_loops( sc2 );
        for(; !ENDP(l); POP(l)) {
                list l3 = l2;
                loop lo = LOOP(CAR( l ));
                int in = statement_ordering(loop_body( lo ));
                for(; !ENDP(l3); POP(l3) ) {
                        loop ll = LOOP(CAR( l3 ));
                        int in2 = statement_ordering(loop_body( ll ));
                        if( in == in2 ) ADD_ELEMENT_TO_LIST(ret_l, LOOP, ll);
                }
        }
        pips_debug(7, "end \n");
 
        return( ret_l );
}

References ADD_ELEMENT_TO_LIST, CAR, ENDP, GET_STATEMENT_MAPPING, LOOP, loop_body, NIL, pips_debug, POP, statement_ordering, and static_control_loops.

Referenced by stco_common_loops_of_statements().

Here is the caller graph for this function:

substitute_variable_by_expression()

static void substitute_variable_by_expression ( expression  e, hash_table  fst  )

static

rewriting of forward_substitute_in_exp, in_loop,...

FI: what was the initial semantics? Substitute the left hand sides only?

see transformations/induction_substitution.c

It's a simple case because the loop indices cannot be written within the loop bounds

FI: let's take care of memory leaks later...

The hash_table could contain syntax objects...

Definition at line 1122 of file utils.c.

{
  syntax s = expression_syntax(e);
  if(syntax_reference_p(s)) {
    entity v = reference_variable(syntax_reference(s));
    expression ne = hash_get(fst, (void *) v);
 
    if(!expression_undefined_p(ne)) {
      /* FI: let's take care of memory leaks later...
       *
       * The hash_table could contain syntax objects...
       */
      expression_syntax(e) = expression_syntax(ne);
    }
  }
}

References expression_syntax, expression_undefined_p, hash_get(), reference_variable, syntax_reference, and syntax_reference_p.

Referenced by forward_substitute_in_anyloop(), forward_substitute_in_call(), and forward_substitute_in_exp().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_structural_parameters()

void verify_structural_parameters	(	list	the_list,
		list *	swfl
	)

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

void verify_structural_parameters( (list) l ) AL 04/93 Updates the global variable Gstructure_parameters. 'l' is a list of entities, which are structural-parameters candidates. An entity will be a structural parameter if it is a candidate and if it is not written forward.

Parameters

the_list	he_list
swfl	wfl

Definition at line 873 of file utils.c.

{
        pips_debug(7,"doing\n");
        MAPL( el_ptr,
                {
                entity ent = ENTITY(CAR( el_ptr ));
                if (   gen_find_eq( ent, *swfl )
                    == chunk_undefined )
                        ADD_ELEMENT_TO_LIST( Gstructure_parameters,
                                             ENTITY,
                                             ent );
                },
              the_list);
        pips_debug(7, "list of structurals : %s\n",
                   print_structurals(Gstructure_parameters) );
}

References ADD_ELEMENT_TO_LIST, CAR, chunk_undefined, ENTITY, gen_find_eq(), Gstructure_parameters, MAPL, pips_debug, and print_structurals().

Referenced by static_controlize().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

assigned_var

list assigned_var

extern

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

static_control static_controlize_statement((statement) s) AL 05/93 Computes s's static_control

Definition at line 207 of file static_controlize.c.

Referenced by static_controlize(), and static_controlize_statement().

Gstructure_parameters

list Gstructure_parameters

extern

Global variables

extern list Gscalar_written_forward;

Global variables

static_controlize.c

Definition at line 81 of file static_controlize.c.

Referenced by get_sp_of_call_p(), static_controlize(), static_controlize_call(), static_controlize_statement(), static_controlize_unstructured(), and verify_structural_parameters().