static_controlize.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	STATIC_CONTROLIZE_MODULE_NAME   "STATCON"
	Warning! Do not modify this file that is automatically generated! More...
#define	NLC_PREFIX   "NLC"
#define	NSP_PREFIX   "NSP"
#define	NUB_PREFIX   "NUB"
#define	give_entity(n)
#define	ENTITY_GE   give_entity(GREATER_OR_EQUAL_OPERATOR_NAME)
#define	ENTITY_GT   give_entity(GREATER_THAN_OPERATOR_NAME)
#define	ENTITY_LE   give_entity(LESS_OR_EQUAL_OPERATOR_NAME)
#define	ENTITY_LT   give_entity(LESS_THAN_OPERATOR_NAME)
#define	ENTITY_NOT   give_entity(NOT_OPERATOR_NAME)
#define	ENTITY_EQ   give_entity(EQUAL_OPERATOR_NAME)
#define	ENTITY_NE   give_entity(NOT_EQUAL_OPERATOR_NAME)
#define	ENTITY_OR   give_entity(OR_OPERATOR_NAME)
#define	ENTITY_AND   give_entity(AND_OPERATOR_NAME)
#define	ENTITY_NLC_P(e)   (strncmp(entity_local_name(e), NLC_PREFIX, 3) == 0)
#define	ENTITY_NSP_P(e)   (strncmp(entity_local_name(e), NSP_PREFIX, 3) == 0)
#define	ENTITY_NUB_P(e)   (strcmp(entity_local_name(e), NUB_PREFIX, 3) == 0)
#define	ENTITY_SP_P(ent)    (gen_find_eq(ent, Gstructure_parameters) != chunk_undefined)
#define	ENTITY_STRICT_LOGICAL_OPERATOR_P(e)

Functions
bool	print_code_static_control (const string)
	cproto-generated files More...
text	text_static_control (entity, int, statement)
text	store_sc_text_line (static_control)
	================================================================ More...
cons *	words_test_list (list)
	================================================================ More...
cons *	words_loop_list (list)
	================================================================ More...
list	words_entity_list (list)
	================================================================ More...
static_control	static_controlize_call (call)
	================================================================ More...
static_control	static_controlize_loop (loop)
	================================================================= More...
static_control	static_controlize_forloop (forloop)
	================================================================= More...
static_control	static_controlize_whileloop (whileloop)
	================================================================= More...
static_control	static_controlize_statement (statement)
static_control	static_controlize_unstructured (unstructured)
	================================================================= More...
bool	static_controlize (string)
	================================================================= More...
list	loop_normalize_of_loop (loop, hash_table, list *, list *, list *, int *)
	================================================================= More...
list	loop_normalize_of_statement (statement, hash_table, list *, list *, list *, int *)
	================================================================= More...
void	loop_normalize_of_unstructured (unstructured, hash_table, list *, list *, list *, int *)
	================================================================= More...
list	stco_same_loops (statement_mapping, statement, statement)
	utils.c More...
int	stco_renumber_code (statement, int)
	================================================================ More...
expression	sc_opposite_exp_of_conjunction (expression, list *)
	================================================================ More...
bool	splc_positive_relation_p (expression, list *)
	================================================================ More...
list	ndf_normalized_test (expression, list *)
	================================================================ More...
expression	normalize_test_leaves (expression, list *)
	================================================================ More...
expression	sc_conditional (expression, list *)
	================================================================ More...
list	loops_to_indices (list)
	================================================================ More...
bool	splc_linear_expression_p (expression, list *)
	================================================================ More...
bool	splc_linear_expression_list_p (list, list *)
	================================================================ More...
bool	splc_linear_access_to_arrays_p (list, list *)
	================================================================ More...
string	print_structurals (list)
	================================================================ More...
list	sc_list_of_exp_dup (list)
	================================================================ More...
list	sc_list_of_entity_dup (list)
	================================================================ More...
list	sc_list_of_loop_dup (list)
	================================================================ More...
loop	sc_loop_dup (loop)
	================================================================ More...
list	make_undefined_list (void)
	================================================================ More...
int	in_forward_defined (entity, list *)
	================================================================ More...
bool	in_forward_defined_p (entity, list *)
	================================================================ More...
void	verify_structural_parameters (list, list *)
	================================================================ More...
list	sc_entity_to_formal_integer_parameters (entity)
	================================================================ More...
bool	sp_linear_expression_p (expression)
	================================================================ More...
bool	splc_feautrier_expression_p (expression, list *)
	================================================================ More...
bool	sp_feautrier_expression_p (expression)
	================================================================ More...
entity	sp_feautrier_scalar_assign_call (call)
	================================================================ More...
bool	get_sp_of_call_p (call, hash_table, list *)
	================================================================ More...
void	forward_substitute_in_anyloop (void *, hash_table)
void	forward_substitute_in_exp (expression *, hash_table)
void	forward_substitute_in_call (call *, hash_table)
bool	normalizable_loop_p (loop)
	bool normalizable_loop_p(loop l) Returns true if "l" has a constant step. More...
bool	normalizable_loop_p_retrieved (loop)
	Code retrieved from revision 14476, transformations/loop_normalize.c. More...
bool	is_expression_in_list (expression, list)
	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, list *)
	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
int	Gcount_nlc
int	Gcount_nsp
	================================================================ More...
int	Gcount_nub
list	Gstructure_parameters
	static_controlize.c More...
statement_mapping	Gstatic_control_map
list	assigned_var
	================================================================= More...

Macro Definition Documentation

ENTITY_AND

#define ENTITY_AND   give_entity(AND_OPERATOR_NAME)

Definition at line 47 of file static_controlize.h.

ENTITY_EQ

#define ENTITY_EQ   give_entity(EQUAL_OPERATOR_NAME)

Definition at line 44 of file static_controlize.h.

ENTITY_GE

#define ENTITY_GE   give_entity(GREATER_OR_EQUAL_OPERATOR_NAME)

Definition at line 39 of file static_controlize.h.

ENTITY_GT

#define ENTITY_GT   give_entity(GREATER_THAN_OPERATOR_NAME)

Definition at line 40 of file static_controlize.h.

ENTITY_LE

#define ENTITY_LE   give_entity(LESS_OR_EQUAL_OPERATOR_NAME)

Definition at line 41 of file static_controlize.h.

ENTITY_LT

#define ENTITY_LT   give_entity(LESS_THAN_OPERATOR_NAME)

Definition at line 42 of file static_controlize.h.

ENTITY_NE

#define ENTITY_NE   give_entity(NOT_EQUAL_OPERATOR_NAME)

Definition at line 45 of file static_controlize.h.

ENTITY_NLC_P

#define ENTITY_NLC_P

(

e

)

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

Definition at line 49 of file static_controlize.h.

ENTITY_NOT

#define ENTITY_NOT   give_entity(NOT_OPERATOR_NAME)

Definition at line 43 of file static_controlize.h.

ENTITY_NSP_P

#define ENTITY_NSP_P

(

e

)

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

Definition at line 50 of file static_controlize.h.

ENTITY_NUB_P

#define ENTITY_NUB_P

(

e

)

(strcmp(entity_local_name(e), NUB_PREFIX, 3) == 0)

Definition at line 51 of file static_controlize.h.

ENTITY_OR

#define ENTITY_OR   give_entity(OR_OPERATOR_NAME)

Definition at line 46 of file static_controlize.h.

ENTITY_SP_P

#define ENTITY_SP_P

(

ent

)

(gen_find_eq(ent, Gstructure_parameters) != chunk_undefined)

Definition at line 52 of file static_controlize.h.

ENTITY_STRICT_LOGICAL_OPERATOR_P

#define ENTITY_STRICT_LOGICAL_OPERATOR_P

(

e

)

Value:

                ( ENTITY_AND_P(e) || \
                  ENTITY_OR_P(e) || \
                  ENTITY_EQUIV_P(e) || \
                  ENTITY_NON_EQUIV_P(e) || \
                  ENTITY_NOT_P(e) )

Definition at line 54 of file static_controlize.h.

give_entity

#define give_entity

(

n

)

Value:

                                gen_find_tabulated(make_entity_fullname( \
                                TOP_LEVEL_MODULE_NAME, n), entity_domain)

Definition at line 37 of file static_controlize.h.

NLC_PREFIX

#define NLC_PREFIX   "NLC"

Definition at line 33 of file static_controlize.h.

NSP_PREFIX

#define NSP_PREFIX   "NSP"

Definition at line 34 of file static_controlize.h.

NUB_PREFIX

#define NUB_PREFIX   "NUB"

Definition at line 35 of file static_controlize.h.

STATIC_CONTROLIZE_MODULE_NAME

#define STATIC_CONTROLIZE_MODULE_NAME   "STATCON"

Warning! Do not modify this file that is automatically generated!

Modify src/Libs/static_controlize/static_controlize-local.h instead, to add your own modifications. header file built by cproto static_controlize-local.h

Definition at line 32 of file static_controlize.h.

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:

loop_normalize_of_loop()

list loop_normalize_of_loop	(	loop	l,
		hash_table	fst,
		list *	ell,
		list *	etl,
		list *	swfl,
		int *	Gcount_nlc
	)

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

================================================================= list loop_normalize_of_loop((loop) l, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc) AL 04/93

FI/SG Question: why change the loop index when it is not necessary? To have a uniform behavior when it is necessary?

loop_body( l ) = make_block_with_stmt( loop_body( l ));

If it is not a constant step, we just normalize the loop body

new upper bound, or at least iteration count

Generate the new loop index and the new loop bounds

assume C

Generate the change of basis expression: the new index starts at 0 in C and 1 in Fortran:

old_index = rl + (new_index * ri) // C

old_index = rl + (new_index * ri) - ri // Fortran

Compute the value of the index when the loop is exited: exp_max

nub3 is not used any longer

FI: Why copy nub? it does not seem used anywhere else.

Parameters

fst	st
ell	================================================================= list loop_normalize_of_loop((loop) l, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc) AL 04/93

FI/SG Question: why change the loop index when it is not necessary? To have a uniform behavior when it is necessary? forward substitute table

Parameters

etl	================================================================= list loop_normalize_of_loop((loop) l, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc) AL 04/93

FI/SG Question: why change the loop index when it is not necessary? To have a uniform behavior when it is necessary? enclosing loops list

Parameters

swfl	================================================================= list loop_normalize_of_loop((loop) l, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc) AL 04/93

FI/SG Question: why change the loop index when it is not necessary? To have a uniform behavior when it is necessary? enclosing tests list

Parameters

Gcount_nlc

================================================================= list loop_normalize_of_loop((loop) l, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc) AL 04/93

FI/SG Question: why change the loop index when it is not necessary? To have a uniform behavior when it is necessary? scalar written forward list

Definition at line 616 of file static_controlize.c.

{
  entity          index, nlc_ent, max_ent;
  expression      rl, ru, ri, nub, nlc_exp, exp_plus;
  expression    nub2, nub3, index_exp, new_index_exp;
  expression      exp_max = expression_undefined;
  range           lr;
  statement       before_stmt = make_continue_statement(entity_empty_label());
  statement       end_stmt = statement_undefined;
  list            stmt_list = NIL;
 
  pips_debug(4, "begin LOOP\n");
 
  loop_label( l ) = entity_empty_label();
  /* loop_body( l ) = make_block_with_stmt( loop_body( l ));*/
  loop_body( l ) = make_block_with_stmt_if_not_already( loop_body( l ));
  index = loop_index( l );
 
  /* If it is not a constant step, we just normalize the loop body */
  if(!normalizable_loop_p(l)) {
    ADD_ELEMENT_TO_LIST(*swfl, ENTITY, index);
    (void) loop_normalize_of_statement(loop_body( l ), fst, ell,
                    etl, swfl, Gcount_nlc);
    return( make_undefined_list() );
  }
 
  lr = loop_range( l );
  rl = range_lower( lr );
  ru = range_upper( lr );
  ri = range_increment( lr );
 
  /* new upper bound, or at least iteration count */
  nub =   make_op_exp(DIVIDE_OPERATOR_NAME,
                      make_op_exp(PLUS_OPERATOR_NAME,
                                  make_op_exp(MINUS_OPERATOR_NAME,
                                              copy_expression(ru),
                                              copy_expression(rl)),
                                  copy_expression(ri)),
                      copy_expression(ri));
  nub2 = copy_expression(nub);
 
  ADD_ELEMENT_TO_LIST( stmt_list, STATEMENT, before_stmt );
 
  /* Generate the new loop index and the new loop bounds */
  nlc_ent = make_nlc_entity(Gcount_nlc);
  ADD_ELEMENT_TO_LIST(*swfl, ENTITY, nlc_ent);
  nlc_exp = make_entity_expression( nlc_ent, NIL);
  loop_index( l ) = nlc_ent;
  if(fortran_module_p(get_current_module_entity())) {
    range_lower( lr ) = int_to_expression( 1 );
    range_upper( lr ) = nub2;
  }
  else {
    /* assume C */
    range_lower( lr ) = int_to_expression( 0 );
    range_upper( lr ) = make_op_exp(MINUS_OPERATOR_NAME, nub2,
                                    int_to_expression(1));
  }
  range_increment( lr ) = int_to_expression( 1 );
 
  /* Generate the change of basis expression: the new index starts at
     0 in C and 1 in Fortran:
 
     old_index = rl + (new_index * ri) // C
 
     old_index = rl + (new_index * ri) - ri // Fortran
 
 */
  new_index_exp = make_op_exp(MULTIPLY_OPERATOR_NAME,
                              copy_expression(ri),
                              nlc_exp);
  if(fortran_module_p(get_current_module_entity())) {
    new_index_exp = make_op_exp(MINUS_OPERATOR_NAME,
                                new_index_exp,
                                copy_expression(ri));
  }
  new_index_exp = make_op_exp(PLUS_OPERATOR_NAME,
                              new_index_exp,
                              copy_expression(rl));
  hash_put(fst, (char*) index, (char*) new_index_exp);
 
  /* Compute the value of the index when the loop is exited: exp_max */
  nub3 = copy_expression( nub );
  if ( expression_constant_p( nub3 )) {
    int upper = expression_to_int( nub3 );
    if ( upper > 0 )
      /* nub3 is not used any longer */
      exp_max = int_to_expression( upper );
  }
  else {
    max_ent = gen_find_tabulated(make_entity_fullname(TOP_LEVEL_MODULE_NAME,
                                                      MAX_OPERATOR_NAME),
                                 entity_domain);
    /* FI: Why copy nub? it does not seem used anywhere else. */
    exp_max = make_max_exp(max_ent, copy_expression( nub ),
                           int_to_expression( 0 ));
  }
  if ( exp_max == expression_undefined )
    exp_plus = copy_expression( rl );
  else
    exp_plus = make_op_exp(PLUS_OPERATOR_NAME,
                           make_op_exp( MULTIPLY_OPERATOR_NAME,
                                       copy_expression( ri ),
                                       exp_max),
                           copy_expression( rl ));
  index_exp = make_entity_expression( index, NIL );
  end_stmt = make_assign_statement(copy_expression(index_exp), exp_plus );
  ADD_ELEMENT_TO_LIST( stmt_list, STATEMENT, end_stmt);
 
  loop_normalize_of_statement(loop_body(l), fst , ell, etl, swfl, Gcount_nlc);
 
  hash_del(fst, (char*) index );
  pips_debug(4, "end LOOP\n");
  return( stmt_list );
}

References ADD_ELEMENT_TO_LIST, copy_expression(), DIVIDE_OPERATOR_NAME, ENTITY, entity_domain, entity_empty_label(), expression_constant_p(), expression_to_int(), expression_undefined, fortran_module_p(), Gcount_nlc, gen_find_tabulated(), get_current_module_entity(), hash_del(), hash_put(), int_to_expression(), loop_body, loop_index, loop_label, loop_normalize_of_statement(), loop_range, make_assign_statement(), make_block_with_stmt_if_not_already(), make_continue_statement(), make_entity_expression(), make_entity_fullname(), make_max_exp(), make_nlc_entity(), make_op_exp(), make_undefined_list(), MAX_OPERATOR_NAME, MINUS_OPERATOR_NAME, MULTIPLY_OPERATOR_NAME, NIL, normalizable_loop_p(), pips_debug, PLUS_OPERATOR_NAME, range_increment, range_lower, range_upper, STATEMENT, statement_undefined, stmt_list, and TOP_LEVEL_MODULE_NAME.

Referenced by loop_normalize_of_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_normalize_of_statement()

list loop_normalize_of_statement	(	statement	s,
		hash_table	fst,
		list *	ell,
		list *	etl,
		list *	swfl,
		int *	Gcount_nlc
	)

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

list loop_normalize_of_statement(statement s, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc): Normalization of a statement.

Before walking down the statements, we forward-substitute the new-loop-counters on each type of statements. We then return a list of two statements to be put before and after statement 's'. These two new statements are generated by loops when they are treated. See document for more detail, section : "Normalisation des boucles".

est_true(t) = make_block_with_stmt( test_true(t) );

test_false(t) = make_block_with_stmt( test_false(t) );

Parameters

fst	st
ell	list loop_normalize_of_statement(statement s, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc): Normalization of a statement.

Before walking down the statements, we forward-substitute the new-loop-counters on each type of statements. We then return a list of two statements to be put before and after statement 's'. These two new statements are generated by loops when they are treated. See document for more detail, section : "Normalisation des boucles". forward substitute table

Parameters

etl	list loop_normalize_of_statement(statement s, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc): Normalization of a statement.

Before walking down the statements, we forward-substitute the new-loop-counters on each type of statements. We then return a list of two statements to be put before and after statement 's'. These two new statements are generated by loops when they are treated. See document for more detail, section : "Normalisation des boucles". enclosing loops list

Parameters

swfl	list loop_normalize_of_statement(statement s, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc): Normalization of a statement.

Before walking down the statements, we forward-substitute the new-loop-counters on each type of statements. We then return a list of two statements to be put before and after statement 's'. These two new statements are generated by loops when they are treated. See document for more detail, section : "Normalisation des boucles". enclosing tests list

Parameters

Gcount_nlc

list loop_normalize_of_statement(statement s, hash_table fst, list *ell, *etl, *swfl, int *Gcount_nlc): Normalization of a statement.

Before walking down the statements, we forward-substitute the new-loop-counters on each type of statements. We then return a list of two statements to be put before and after statement 's'. These two new statements are generated by loops when they are treated. See document for more detail, section : "Normalisation des boucles". scalar written forward list

Definition at line 750 of file static_controlize.c.

{
  instruction   inst = statement_instruction(s);
  list          return_list = NIL;
 
  pips_assert("statement s is consistent\n", statement_consistent_p(s));
 
  pips_debug(3, "begin STATEMENT\n");
  return_list = make_undefined_list();
 
  switch(instruction_tag(inst))
    {
    case is_instruction_block :
      {
        list tail, head;
 
        tail = instruction_block(inst);
        for(head = NIL ; tail != NIL; )
          {
            statement stmt, before_stmt, after_stmt;
            list        insert_stmt;
 
            stmt = STATEMENT(CAR(tail));
            insert_stmt = loop_normalize_of_statement(stmt, fst, ell,
                                                      etl, swfl, Gcount_nlc);
            before_stmt = STATEMENT(CAR( insert_stmt ));
            after_stmt  = STATEMENT(CAR(CDR( insert_stmt )));
 
            if( before_stmt != statement_undefined)
              ADD_ELEMENT_TO_LIST( head, STATEMENT, before_stmt);
            ADD_ELEMENT_TO_LIST( head, STATEMENT, stmt );
            if (after_stmt != statement_undefined )
              ADD_ELEMENT_TO_LIST( head, STATEMENT, after_stmt );
 
            tail = CDR(tail);
          }
        instruction_block(inst) = head;
        break;
      }
    case is_instruction_test :
      {
        test t = instruction_test(inst);
        (void) forward_substitute_in_exp(&test_condition(t), fst);
        ADD_ELEMENT_TO_LIST(*etl, EXPRESSION, test_condition(t) );
        /*test_true(t) = make_block_with_stmt( test_true(t) );*/
        test_true(t) = make_block_with_stmt_if_not_already(test_true(t));
        /* test_false(t) = make_block_with_stmt( test_false(t) );*/
        test_false(t) = make_block_with_stmt_if_not_already( test_false(t) );
        loop_normalize_of_statement(test_true(t), fst, ell,
                                    etl, swfl, Gcount_nlc);
        loop_normalize_of_statement(test_false(t), fst, ell,
                                    etl, swfl, Gcount_nlc);
        gen_remove(etl, (gen_chunk*) test_condition( t ));
        break;
      }
    case is_instruction_loop :
      {
        (void) forward_substitute_in_anyloop(instruction_loop(inst), fst);
        ADD_ELEMENT_TO_LIST(*ell, LOOP, instruction_loop( inst ));
        return_list = loop_normalize_of_loop(instruction_loop(inst), fst, ell,
                                             etl, swfl, Gcount_nlc);
        gen_remove(ell, (gen_chunk*) instruction_loop( inst ));
        break;
      }
    case is_instruction_call :
      {
        (void) forward_substitute_in_call(&instruction_call(inst), fst);
        scalar_written_in_call( instruction_call( inst ), ell,
                                etl, swfl);
        break;
      }
    case is_instruction_goto : break;
    case is_instruction_unstructured :
      {
        loop_normalize_of_unstructured(instruction_unstructured(inst), fst, ell,
                                       etl, swfl, Gcount_nlc);
        break;
      }
    default : pips_internal_error("Bad instruction tag");
    }
  pips_debug(3, "end STATEMENT\n");
  return( return_list );
}

References ADD_ELEMENT_TO_LIST, CAR, CDR, EXPRESSION, forward_substitute_in_anyloop(), forward_substitute_in_call(), forward_substitute_in_exp(), Gcount_nlc, gen_remove(), 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, loop_normalize_of_loop(), loop_normalize_of_unstructured(), make_block_with_stmt_if_not_already(), make_undefined_list(), NIL, pips_assert, pips_debug, pips_internal_error, scalar_written_in_call(), STATEMENT, statement_consistent_p(), statement_instruction, statement_undefined, test_condition, test_false, and test_true.

Referenced by loop_normalize_of_loop(), and loop_normalize_of_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

loop_normalize_of_unstructured()

void loop_normalize_of_unstructured	(	unstructured	u,
		hash_table	fst,
		list *	ell,
		list *	etl,
		list *	swfl,
		int *	Gcount_nlc
	)

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

void loop_normalize_of_unstructured(unstructured u, fst): Normalization of an unstructured instruction.

tmt = make_block_with_stmt( stmt );

Parameters

fst	st
ell	void loop_normalize_of_unstructured(unstructured u, fst): Normalization of an unstructured instruction. forward substitute table
etl	void loop_normalize_of_unstructured(unstructured u, fst): Normalization of an unstructured instruction. enclosing loops list
swfl	void loop_normalize_of_unstructured(unstructured u, fst): Normalization of an unstructured instruction. enclosing tests list
Gcount_nlc	void loop_normalize_of_unstructured(unstructured u, fst): Normalization of an unstructured instruction. scalar written forward list

Definition at line 845 of file static_controlize.c.

{
        list blocs = NIL, lc;
        list insert_stmts;
 
        pips_debug(2, "begin UNSTRUCTURED\n");
        control_map_get_blocs(unstructured_control(u), &blocs ) ;
        blocs = gen_nreverse( blocs ) ;
 
        for(lc = blocs; lc != NIL; lc = CDR(lc)) {
                list            head = NIL;
                control         ctl;
                statement       before_stmt, after_stmt, stmt;
 
                ctl             = CONTROL(CAR( lc ));
                stmt            = control_statement( ctl );
                insert_stmts    = loop_normalize_of_statement(stmt, fst,
                                                              ell, etl,
                                                              swfl,
                                                              Gcount_nlc);
                before_stmt     = STATEMENT(CAR( insert_stmts ));
                after_stmt      = STATEMENT(CAR(CDR( insert_stmts )));
 
           if (!undefined_statement_list_p( insert_stmts )) {
                if( before_stmt != statement_undefined)
                        ADD_ELEMENT_TO_LIST( head, STATEMENT, before_stmt );
                ADD_ELEMENT_TO_LIST( head, STATEMENT, stmt );
                if (after_stmt != statement_undefined )
                        ADD_ELEMENT_TO_LIST( head, STATEMENT, after_stmt );
                /*stmt = make_block_with_stmt( stmt );*/
                stmt = make_block_with_stmt_if_not_already(stmt);
                instruction_block(statement_instruction( stmt )) = head;
                head = NIL;
           }
        }
 
        gen_free_list(blocs);
        pips_debug(2, "end UNSTRUCTURED\n");
}

References ADD_ELEMENT_TO_LIST, CAR, CDR, CONTROL, control_map_get_blocs(), control_statement, Gcount_nlc, gen_free_list(), gen_nreverse(), instruction_block, loop_normalize_of_statement(), make_block_with_stmt_if_not_already(), NIL, pips_debug, STATEMENT, statement_instruction, statement_undefined, undefined_statement_list_p(), and unstructured_control.

Referenced by loop_normalize_of_statement().

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_code_static_control()

bool print_code_static_control

(

const string

module_name

)

cproto-generated files

prettyprint.c

cproto-generated files

void print_code_static_control((char*) module_name) AL 05/93 Prettyprints a static_control mapping attached to a module_name.

Parameters

module_name

odule_name

Definition at line 87 of file prettyprint.c.

{
    entity      module;
    statement   module_stat;
    text        txt = make_text(NIL);
    bool success;
 
    debug_on( "PRINT_STATIC_CONTROL_DEBUG_LEVEL" );
 
    ifdebug(1)
           user_log("\n\n *** PRINTING STATIC CONTROL for %s\n",
                                 module_name);
 
    module = local_name_to_top_level_entity(module_name);
    module_stat = (statement)
        db_get_memory_resource(DBR_CODE, module_name, true);
    Gsc_map = (statement_mapping)
        db_get_memory_resource( DBR_STATIC_CONTROL, module_name, true);
    init_prettyprint(text_static_control);
 
/*
    filename = strdup(concatenate(db_get_current_workspace_directory(),
                                  "/", module_name, ".stco", NULL));
    fd = safe_fopen(filename, "w");
*/
 
    MERGE_TEXTS(txt, text_module(module, module_stat));
 
/*
    print_text(fd, txt);
    safe_fclose(fd, filename);
    DB_PUT_FILE_RESOURCE(DBR_PRINTED_FILE, strdup(module_name),
                                filename);
*/
 
    success = make_text_resource(module_name,
                                 DBR_PRINTED_FILE,
                                 CODE_WITH_STATIC_CONTROLIZE_EXT,
                                 txt);
 
    close_prettyprint();
 
    debug_off();
 
    return(success);
}

References close_prettyprint(), CODE_WITH_STATIC_CONTROLIZE_EXT, db_get_memory_resource(), debug_off, debug_on, Gsc_map, ifdebug, init_prettyprint(), local_name_to_top_level_entity(), make_text(), make_text_resource(), MERGE_TEXTS, module, module_name(), NIL, text_module(), text_static_control(), and user_log().

Here is the call 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:

static_controlize()

bool static_controlize

(

string

mod_name

)

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

void static_controlize((char*) mod_name) AL 05/93 Computes the static_control attached to module-name : mod_name.

HAS TO BE REMOVED AS SOON AS POSSIBLE: as the IOs are not treated as they would, all the instructions containing IOs are put inside comments. AP, oct 9th 1995

Normalization of all loops

Modification: loop_normalize_of_statement is used instead of

loop_normalize_of_unstructured since we cannot ensure that

mod_inst is an unstructured –11th Dec 1995, DB

oop_normalize_of_statement(mod_stat, Gforward_substitute_table, &Genclosing_loops, &Genclosing_tests, &Gscalar_written_forward, &Gcount_nlc);

The code has been modified, so the orderings are recomputed.

We compute the static control infos for each instruction.

Same remark as before –DB

Parameters

mod_name

od_name

Definition at line 495 of file static_controlize.c.

{
        statement       mod_stat;
        instruction     mod_inst;
        entity          ent;
        list            formal_integers;
        static_control  sc;
 
        debug_on("STATIC_CONTROLIZE_DEBUG_LEVEL");
 
        ifdebug(2)
          user_log("\n\n *** STATIC CONTROLIZE CODE for %s\n", mod_name);
 
        /*
         * Set the current language
         */
        entity module = module_name_to_entity(mod_name);
 
 
        value mv = entity_initial(module);
        if(value_code_p(mv)) {
          code c = value_code(mv);
          set_prettyprint_language_from_property(language_tag(code_language(c)));
        }
 
        Gcount_nsp = 0;
        Gcount_nub = 0;
        Gstructure_parameters   = (list) NIL;
        Genclosing_loops        = (list) NIL;
        Genclosing_tests        = (list) NIL;
        Gscalar_written_forward = (list) NIL;
        Gforward_substitute_table = hash_table_make( hash_pointer, 0 );
        hash_warn_on_redefinition();
        Gstatic_control_map = MAKE_STATEMENT_MAPPING();
 
        ent = local_name_to_top_level_entity(mod_name);
        set_current_module_entity(ent);
        formal_integers = sc_entity_to_formal_integer_parameters( ent );
        pips_debug(7, "\n formal integers : %s \n",
                print_structurals( formal_integers ));
 
        mod_stat = (statement) db_get_memory_resource(DBR_CODE, mod_name, true);
 
        mod_inst = statement_instruction( mod_stat );
 
        /* HAS TO BE REMOVED AS SOON AS POSSIBLE: as the IOs are not
           treated as they would, all the instructions containing IOs are
           put inside comments. AP, oct 9th 1995 */
        gen_recurse(mod_inst, statement_domain, io_filter, gen_null);
        /* Normalization of all loops */
        /* Modification: loop_normalize_of_statement is used instead of */
        /* loop_normalize_of_unstructured since we cannot ensure that */
        /* mod_inst is an unstructured --11th Dec 1995, DB */
 
        /***
           D.K desactivate  the normalization of loops to preserve the
           original code
        */
 
        /*loop_normalize_of_statement(mod_stat,
                                       Gforward_substitute_table,
                                       &Genclosing_loops,
                                       &Genclosing_tests,
                                       &Gscalar_written_forward,
                                       &Gcount_nlc);
        */
 
 
 
 
        /* The code has been modified, so the orderings are recomputed. */
        module_reorder( mod_stat );
        verify_structural_parameters(formal_integers,
                                     &Gscalar_written_forward);
 
        Genclosing_loops      = (list) NIL;
        Genclosing_tests      = (list) NIL;
 
        /* We compute the static control infos for each instruction. */
        /* Same remark as before --DB */
 
        sc = static_controlize_statement(mod_stat);
        pips_assert("controlized statement mod_stat is consistent",
                    statement_consistent_p(mod_stat));
        pips_assert("static_control sc is consistent",
                    static_control_consistent_p(sc));
 
        stco_renumber_code( mod_stat, 0 );
 
        SET_STATEMENT_MAPPING( Gstatic_control_map, mod_stat, sc );
 
        DB_PUT_MEMORY_RESOURCE(DBR_CODE, strdup(mod_name), (char*) mod_stat);
        DB_PUT_MEMORY_RESOURCE(DBR_STATIC_CONTROL, strdup(mod_name),
                        (char*) Gstatic_control_map);
 
        ifdebug(2)
          user_log("\n\n *** STATIC CONTROLIZE CODE done\n");
 
        reset_current_module_entity();
 
        debug_off();
        // Reset of the assigned_var list after the phase is complete
        gen_free_list(assigned_var);
        assigned_var = NIL;
 
        return(true);
}

References assigned_var, code_language, db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, entity_initial, Gcount_nsp, Gcount_nub, gen_free_list(), gen_null(), gen_recurse, Genclosing_loops, Genclosing_tests, Gforward_substitute_table, Gscalar_written_forward, Gstatic_control_map, Gstructure_parameters, hash_pointer, hash_table_make(), hash_warn_on_redefinition(), ifdebug, io_filter(), language_tag, local_name_to_top_level_entity(), MAKE_STATEMENT_MAPPING, mod_stat, module, module_name_to_entity(), module_reorder(), NIL, pips_assert, pips_debug, print_structurals(), reset_current_module_entity(), sc_entity_to_formal_integer_parameters(), set_current_module_entity(), set_prettyprint_language_from_property(), SET_STATEMENT_MAPPING, statement_consistent_p(), statement_domain, statement_instruction, static_control_consistent_p(), static_controlize_statement(), stco_renumber_code(), strdup(), user_log(), value_code, value_code_p, and verify_structural_parameters().

Here is the call graph for this function:

static_controlize_call()

static_control static_controlize_call

(

call

c

)

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

static_control static_controlize_call( (call) c ) AL 05/93 It computes now just a static-control assignement if it is an ASSIGN statement.

_list_of_loop_dup( Genclosing_loops ),

_list_of_loop_dup( Genclosing_loops ),

Definition at line 95 of file static_controlize.c.

{
        static_control sc;
 
        pips_debug( 3, "begin CALL\n");
        pips_debug( 7,
                    "call : %s\n", entity_local_name( call_function(c) ) );
        entity e = call_function(c);
        tag tt;
            if ((tt = value_intrinsic_p(entity_initial(e))))
              {
                sc = make_static_control(false,
                                         sc_list_of_entity_dup( Gstructure_parameters ),
                                         /* _list_of_loop_dup(
                                            Genclosing_loops ),*/
                                         copy_loops( Genclosing_loops ),
                                         sc_list_of_exp_dup( Genclosing_tests ));
                static_control_yes( sc ) = splc_linear_access_to_arrays_p
                  (call_arguments(c),&Genclosing_loops);
              } 
            else
              {
                bool b = splc_linear_access_to_arrays_p(call_arguments(c),
                                                   &Genclosing_loops);
                
                sc = make_static_control(b,
                                         sc_list_of_entity_dup( Gstructure_parameters ),
                                         /* _list_of_loop_dup(
                                            Genclosing_loops ),*/
                                         copy_loops( Genclosing_loops ),
                                         sc_list_of_exp_dup( Genclosing_tests ));
              }
            pips_debug( 3, "end CALL\n");
            return sc;
}

References call_arguments, call_function, copy_loops(), entity_initial, entity_local_name(), Genclosing_loops, Genclosing_tests, Gstructure_parameters, make_static_control(), pips_debug, sc_list_of_entity_dup(), sc_list_of_exp_dup(), splc_linear_access_to_arrays_p(), static_control_yes, and value_intrinsic_p.

Referenced by static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

static_controlize_forloop()

static_control static_controlize_forloop

(

forloop

fl

)

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

static_control static_controlize_forloop( (forloop) fl ) It computes the forloop's static_control.

Parameters

fl

l

Definition at line 165 of file static_controlize.c.

{
  static_control        sc;
 
  pips_debug(3, "begin FORLOOP\n");
 
 
  sc = static_controlize_statement( forloop_body( fl ) );
  static_control_yes( sc ) = false;
 
  SET_STATEMENT_MAPPING(Gstatic_control_map, forloop_body(fl), sc);
 
  pips_debug(3, "end FORLOOP\n");
  return( sc );
}

References forloop_body, Gstatic_control_map, pips_debug, SET_STATEMENT_MAPPING, static_control_yes, and static_controlize_statement().

Referenced by static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

static_controlize_loop()

static_control static_controlize_loop

(

loop

l

)

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

static_control static_controlize_loop( (loop) l ) It computes the loop's static_control.

Definition at line 135 of file static_controlize.c.

{
  static_control        sc;
        expression      low, up;
 
        pips_debug(3, "begin LOOP\n");
 
        low = range_lower( loop_range( l ) );
        up  = range_upper( loop_range( l ) );
        ADD_ELEMENT_TO_LIST(Genclosing_loops, LOOP, l);
        sc = static_controlize_statement( loop_body( l ) );
        if (       !constant_step_loop_p(l)
                || !splc_feautrier_expression_p(low, &Genclosing_loops)
                || !splc_feautrier_expression_p(up, &Genclosing_loops)  ) {
                static_control_yes( sc ) = false;
        }
        SET_STATEMENT_MAPPING(Gstatic_control_map, loop_body(l), sc);
        gen_remove( &Genclosing_loops, l );
 
        pips_debug(3, "end LOOP\n");
        return( sc );
}

References ADD_ELEMENT_TO_LIST, constant_step_loop_p(), gen_remove(), Genclosing_loops, Gstatic_control_map, LOOP, loop_body, loop_range, pips_debug, range_lower, range_upper, SET_STATEMENT_MAPPING, splc_feautrier_expression_p(), static_control_yes, and static_controlize_statement().

Referenced by static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

static_controlize_statement()

static_control static_controlize_statement

(

statement

s

)

We put condition under a normal disjunctive form

ontinue_statement_p(s) ||

Definition at line 209 of file static_controlize.c.

{
  // Update of the list containing the variables assigned directly or indirectly by an array
  get_reference_assignments(s, &assigned_var);
  
  bool          is_static = true, static_test = false;
  instruction   inst = statement_instruction(s);
  static_control  sc, sc1, sc2;
  expression    exp, exp1, exp2;
 
  pips_debug(3, "begin STATEMENT\n");
  pips_debug(7, "statement_ordering = %zd \n", statement_ordering(s));
 
  switch(instruction_tag(inst))
    {
    case is_instruction_block :
      {
        FOREACH(STATEMENT, local_stmt, instruction_block(inst)) {
          sc1 = static_controlize_statement( local_stmt );
          SET_STATEMENT_MAPPING( Gstatic_control_map, local_stmt, sc1);
          //printf("s=%p, sc=%p\n", local_stmt, sc1);
          is_static = ( is_static && static_control_yes( sc1 ));
        }
        break;
      }
    case is_instruction_test :
      {
        test t = instruction_test(inst);
        forward_substitute_in_exp( &test_condition( t ),
                                   Gforward_substitute_table);
        
        /* We put condition under a normal disjunctive form */
        if ((exp = sc_conditional(test_condition(t), &Genclosing_loops)) !=
            expression_undefined || sp_feautrier_expression_p(test_condition(t))) {
          //DK, don't change the structure of conditions
          //test_condition( t ) = exp ;
          static_test = true;
        }
        ADD_ELEMENT_TO_LIST( Genclosing_tests, EXPRESSION, test_condition(t) );
        sc1 = static_controlize_statement(test_true(t));
        SET_STATEMENT_MAPPING( Gstatic_control_map, test_true( t ), sc1);
        gen_remove( &Genclosing_tests, (void*) test_condition( t ));
 
        exp1 = MakeUnaryCall( ENTITY_NOT, copy_expression( test_condition(t) ));
        if ( (exp2 = sc_conditional(exp1, &Genclosing_loops)) ==
             expression_undefined) {
          exp2 = exp1;
        }
        ADD_ELEMENT_TO_LIST( Genclosing_tests, EXPRESSION, exp2 );
        sc2 = static_controlize_statement(test_false(t));
        SET_STATEMENT_MAPPING( Gstatic_control_map, test_false( t ), sc2);
        gen_remove( &Genclosing_tests, (void *) exp2 );
        is_static = (  static_control_yes( sc1 )
                       && static_control_yes( sc2 )
                       && static_test );
        break;
      }
    case is_instruction_loop :
      {
        loop the_loop = instruction_loop( inst );
        forward_substitute_in_anyloop( instruction_loop( inst ),
                                       Gforward_substitute_table);
        sc1 = static_controlize_loop( the_loop );
        is_static = static_control_yes( sc1 );
        break;
      }
    case is_instruction_forloop :
      {
        forloop forl = instruction_forloop( inst );
        forward_substitute_in_anyloop( instruction_forloop( inst ),
                                       Gforward_substitute_table);
        sc1 = static_controlize_forloop( forl );
        is_static = static_control_yes( sc1 );
        break;
      }
    case  is_instruction_whileloop :
      {
        whileloop whilel = instruction_whileloop( inst );
        forward_substitute_in_anyloop( instruction_whileloop( inst ),
                                       Gforward_substitute_table);
        sc1 = static_controlize_whileloop( whilel );
        is_static = static_control_yes( sc1 );
        break;
      }
    case is_instruction_call :
      {
        if (!(/*continue_statement_p(s) ||*/ declaration_statement_p(s)))
          {
            call the_call = instruction_call( inst);
            forward_substitute_in_call( &the_call, Gforward_substitute_table );
            is_static = static_control_yes(static_controlize_call( the_call ));
          }
        else
          is_static = false;
        if (!get_bool_property("STATIC_CONTROLIZE_ACROSS_USER_CALLS"))
          {
            if (statement_contains_user_call_p(s)
                || io_intrinsic_p((call_function(instruction_call( inst)))))
              is_static = false;
          }
        break;
      }
 
    case is_instruction_goto :
      {
        pips_internal_error("No goto in code ressource\n");
        is_static = false;
        break;
      }
    case is_instruction_expression :
      {
        is_static = true;
        break;
      }
    case is_instruction_unstructured :
      {
        unstructured local_un = instruction_unstructured( inst );
        is_static =
          static_control_yes(static_controlize_unstructured( local_un ));
        break;
      }
    default :
      {
        pips_internal_error("Ill. instruction tag");
      }
    }
  //if (!(continue_statement_p(s) || declaration_statement_p(s)))
    sc = make_static_control(is_static,
                             sc_list_of_entity_dup(Gstructure_parameters),
                             sc_list_of_loop_dup(Genclosing_loops),
                             sc_list_of_exp_dup(Genclosing_tests) );
 
  pips_debug(7,
             " Returning static_control : \n bool   : %s \n params : %s \n loops  : %zd \n tests  : %zd \n ",
             ((is_static)?"TRUE":"FALSE"),
             print_structurals( Gstructure_parameters ),
             gen_length( Genclosing_loops ),
             gen_length( Genclosing_tests ) );
  pips_debug(3, "end STATEMENT\n");
           
  return sc;
 
}

References ADD_ELEMENT_TO_LIST, assigned_var, call_function, copy_expression(), declaration_statement_p(), ENTITY_NOT, exp, EXPRESSION, expression_undefined, FOREACH, forward_substitute_in_anyloop(), forward_substitute_in_call(), forward_substitute_in_exp(), gen_length(), gen_remove(), Genclosing_loops, Genclosing_tests, get_bool_property(), get_reference_assignments(), Gforward_substitute_table, Gstatic_control_map, Gstructure_parameters, instruction_block, instruction_call, instruction_forloop, instruction_loop, instruction_tag, instruction_test, instruction_unstructured, instruction_whileloop, io_intrinsic_p(), 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, make_static_control(), MakeUnaryCall(), pips_debug, pips_internal_error, print_structurals(), sc_conditional(), sc_list_of_entity_dup(), sc_list_of_exp_dup(), sc_list_of_loop_dup(), SET_STATEMENT_MAPPING, sp_feautrier_expression_p(), STATEMENT, statement_contains_user_call_p(), statement_instruction, statement_ordering, static_control_yes, static_controlize_call(), static_controlize_forloop(), static_controlize_loop(), static_controlize_unstructured(), static_controlize_whileloop(), test_condition, test_false, and test_true.

Referenced by static_controlize(), static_controlize_forloop(), static_controlize_loop(), static_controlize_unstructured(), and static_controlize_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

static_controlize_unstructured()

static_control static_controlize_unstructured

(

unstructured

u

)

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

static_control static_controlize_unstructered((unstructured) u) AL 05/93 Computes an unstructured's static_control

Definition at line 358 of file static_controlize.c.

{
        bool            is_static = true;
        list            blocs = NIL;
        static_control  sc, ret_sc = static_control_undefined;
 
        pips_debug(3, "begin UNSTRUCTURED\n");
        control_map_get_blocs(unstructured_control(u), &blocs ) ;
        blocs = gen_nreverse( blocs ) ;
 
        FOREACH(CONTROL, ctl, blocs) {
          statement stmt = control_statement(ctl);
          sc    = static_controlize_statement( stmt );
          pips_assert("stmt is consistent", statement_consistent_p(stmt));
          SET_STATEMENT_MAPPING( Gstatic_control_map, stmt, sc );
          //fprintf(stdout, "stmt=%p, sharing=%p\n", stmt, sc);
          is_static = is_static && static_control_yes( sc );
        }
 
        gen_free_list(blocs);
        ret_sc = make_static_control( is_static,
                                sc_list_of_entity_dup(Gstructure_parameters),
                                sc_list_of_loop_dup(Genclosing_loops),
                                sc_list_of_exp_dup(Genclosing_tests) );
 
        pips_debug(7,
"\n Returning static_control : \n bool   : %s \n params : %s \n loops  : %zd \n tests  : %zd \n ",
                 ((is_static)?"TRUE":"FALSE"),
                 print_structurals( Gstructure_parameters ),
                 gen_length( Genclosing_loops ),
                 gen_length( Genclosing_tests ) );
 
        pips_debug(3, "end UNSTRUCTURED\n");
        return( ret_sc );
}

References CONTROL, control_map_get_blocs(), control_statement, FOREACH, gen_free_list(), gen_length(), gen_nreverse(), Genclosing_loops, Genclosing_tests, Gstatic_control_map, Gstructure_parameters, make_static_control(), NIL, pips_assert, pips_debug, print_structurals(), sc_list_of_entity_dup(), sc_list_of_exp_dup(), sc_list_of_loop_dup(), SET_STATEMENT_MAPPING, statement_consistent_p(), static_control_undefined, static_control_yes, static_controlize_statement(), and unstructured_control.

Referenced by static_controlize_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

static_controlize_whileloop()

static_control static_controlize_whileloop

(

whileloop

wl

)

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

static_control static_controlize_whileloop( (whileloop) l ) It computes the whileloop's static_control.

Parameters

wl

l

Definition at line 185 of file static_controlize.c.

{
  static_control        sc;
 
  pips_debug(3, "begin WHILELOOP\n");
 
 
  sc = static_controlize_statement( whileloop_body( wl ) );
  static_control_yes( sc ) = false;
 
  SET_STATEMENT_MAPPING(Gstatic_control_map, whileloop_body(wl), sc);
 
  pips_debug(3, "end WHILELOOP\n");
  return( sc );
}

References Gstatic_control_map, pips_debug, SET_STATEMENT_MAPPING, static_control_yes, static_controlize_statement(), and whileloop_body.

Referenced by static_controlize_statement().

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

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:

store_sc_text_line()

text store_sc_text_line

(

static_control

sc

)

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

text store_sc_text_line((static_control) sc) AL 05/93 Stores a static_control prettyprinted.

pips_assert("store_text_line", sefs_list != NIL);

Parameters

sc

c

Definition at line 152 of file prettyprint.c.

{
    text sc_text = make_text(NIL);
    char *t = NULL;
    string comment;
 
    /* pips_assert("store_text_line", sefs_list != NIL); */
    if (get_prettyprint_language_tag() == is_language_c)
      comment = "//";
    else 
      comment = "C";
 
 
    t = concatenate(comment,"\t\t< is static >",
                (static_control_yes(sc)?" TRUE":" FALSE"), "\n", NULL);
        ADD_SENTENCE_TO_TEXT( sc_text,
                         make_sentence(is_sentence_formatted, strdup(t)));
        t = concatenate(comment,"\t\t< parameter >",
                 words_to_string(words_entity_list(static_control_params(sc))),
                                         "\n", NULL);
        ADD_SENTENCE_TO_TEXT( sc_text,
                         make_sentence(is_sentence_formatted, strdup(t)));
        t = concatenate(comment,"\t\t<   loops   >",
                words_to_string(words_loop_list(static_control_loops(sc))),
                                          NULL);
        ADD_SENTENCE_TO_TEXT( sc_text,
                        make_sentence(is_sentence_formatted, strdup(t)));
        t = concatenate(comment,"\t\t<   tests   >",
                words_to_string(words_test_list(static_control_tests(sc))),
                                          NULL);
        ADD_SENTENCE_TO_TEXT( sc_text,
                        make_sentence(is_sentence_formatted, strdup(t)));
 
    return ( sc_text );
}

References ADD_SENTENCE_TO_TEXT, comment(), concatenate(), get_prettyprint_language_tag(), is_language_c, is_sentence_formatted, make_sentence(), make_text(), NIL, static_control_loops, static_control_params, static_control_tests, static_control_yes, strdup(), words_entity_list(), words_loop_list(), words_test_list(), and words_to_string().

Referenced by text_static_control().

Here is the call graph for this function:

Here is the caller graph for this function:

text_static_control()

text text_static_control	(	entity	,
		int	,
		statement
	)

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:

words_entity_list()

list words_entity_list

(

list

obj

)

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

cons *words_entity_list((list) obj) AL 05/93 Returns a list of strings from a list of entities.

FI: Should be moved in ri-util/entity.c or entities.c when it exists

Parameters

obj

bj

Definition at line 265 of file prettyprint.c.

{
  list the_list = NIL;
  pips_debug(7, "doing \n");
  the_list = CHAIN_SWORD(the_list, " ");
  FOREACH(ENTITY, ent, obj)
  {
    string s = strdup(concatenate(entity_local_name(ent), ", ", NULL));
    ADD_ELEMENT_TO_LIST( the_list, STRING, s );
  }
        return the_list;
}

References ADD_ELEMENT_TO_LIST, CHAIN_SWORD, concatenate(), ENTITY, entity_local_name(), FOREACH, NIL, pips_debug, strdup(), and STRING.

Referenced by print_structurals(), and store_sc_text_line().

Here is the call graph for this function:

Here is the caller graph for this function:

words_loop_list()

cons* words_loop_list

(

list

obj

)

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

cons *words_loop_list((list) obj) AL 05/93 Returns a list of strings from a list of loops.

Parameters

obj

bj

Definition at line 226 of file prettyprint.c.

{
        cons*  ret_cons = NIL;
        string before_string = strdup(" ");
        string blank_string;
        if (get_prettyprint_language_tag() == is_language_c)
          blank_string = strdup("//                            ");
        else
          blank_string = strdup("C                             ");
 
 
        pips_debug(7, "doing \n");
        FOREACH(LOOP, l, obj) {
          cons* pc      = NIL;
          entity        ind     = loop_index( l );
          expression low  = range_lower(loop_range( l ));
          expression up   = range_upper(loop_range( l ));
          pc = CHAIN_SWORD(pc, strdup( before_string ));
          pc = gen_nconc(pc, Words_Expression(low));
          pc = CHAIN_SWORD(pc," <= ");
          pc = CHAIN_SWORD(pc, entity_local_name(ind));
          pc = CHAIN_SWORD(pc," <= ");
          pc = gen_nconc(pc, Words_Expression(up));
          pc = CHAIN_SWORD(pc,"\n") ;
          ret_cons = gen_nconc(ret_cons, gen_copy_seq(pc));
          before_string = blank_string;
        }
 
        if( ret_cons == NIL ) ret_cons = CHAIN_SWORD(ret_cons, "\n");
        return( ret_cons );
}

References CHAIN_SWORD, entity_local_name(), FOREACH, gen_copy_seq(), gen_nconc(), get_prettyprint_language_tag(), is_language_c, LOOP, loop_index, loop_range, NIL, pips_debug, range_lower, range_upper, strdup(), and Words_Expression().

Referenced by store_sc_text_line().

Here is the call graph for this function:

Here is the caller graph for this function:

words_test_list()

cons* words_test_list

(

list

obj

)

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

cons *words_test_list((list) obj) AL 05/93 Makes a list of strings from a list of test expressions.

Parameters

obj

bj

Definition at line 195 of file prettyprint.c.

{
        cons*  ret_cons = NIL;
        string before_string = strdup(" ");
        string blank_string;
        if (get_prettyprint_language_tag() == is_language_c)
          blank_string = strdup("//                            ");
        else
          blank_string = strdup("C                             ");
 
        pips_debug(7, "doing \n");
        MAPL( exp_ptr, {
            cons*       pc  = NIL;
                expression      exp = EXPRESSION(CAR(exp_ptr));
 
                pc = CHAIN_SWORD(pc, strdup( before_string ));
                pc = gen_nconc(pc, Words_Expression(exp));
                pc = CHAIN_SWORD(pc,"\n") ;
                ret_cons = gen_nconc(ret_cons, gen_copy_seq(pc));
                before_string = blank_string;
        }, obj);
 
        if( ret_cons == NIL ) ret_cons = CHAIN_SWORD(ret_cons, "\n");
        return( ret_cons );
}

References CAR, CHAIN_SWORD, exp, EXPRESSION, gen_copy_seq(), gen_nconc(), get_prettyprint_language_tag(), is_language_c, MAPL, NIL, pips_debug, strdup(), and Words_Expression().

Referenced by store_sc_text_line().

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.

Gcount_nlc

int Gcount_nlc

extern

Gcount_nsp

int Gcount_nsp

extern

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

Definition at line 158 of file misc_paf_utils.c.

Gcount_nub

int Gcount_nub

extern

Definition at line 160 of file misc_paf_utils.c.

Gstatic_control_map

statement_mapping Gstatic_control_map

extern

Definition at line 87 of file static_controlize.c.

Referenced by static_controlize(), static_controlize_forloop(), static_controlize_loop(), static_controlize_statement(), static_controlize_unstructured(), and static_controlize_whileloop().

Gstructure_parameters

list Gstructure_parameters

extern

static_controlize.c

static_controlize.c

Definition at line 81 of file static_controlize.c.