static_controlize.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "genC.h"
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "ray_dte.h"
#include "sommet.h"
#include "sg.h"
#include "sc.h"
#include "polyedre.h"
#include "properties.h"
#include "matrix.h"
#include "ri.h"
#include "graph.h"
#include "paf_ri.h"
#include "database.h"
#include "ri-util.h"
#include "workspace-util.h"
#include "prettyprint.h"
#include "constants.h"
#include "misc.h"
#include "control.h"
#include "text-util.h"
#include "pipsdbm.h"
#include "resources.h"
#include "paf-util.h"
#include "static_controlize.h"

Include dependency graph for static_controlize.c:

Go to the source code of this file.

Data Structures
struct	IOIntrinsicDescriptor
	the following data structure describes an io intrinsic function: its name More...

Typedefs
typedef void *	arc_label
	Name : static_controlize.c package : static_controlize Author : Arnauld LESERVOT Date : May 93 Modified : Documents : "Implementation du Data Flow Graph dans Pips" Comments : More...
typedef void *	vertex_label
typedef struct IOIntrinsicDescriptor	IOIntrinsicDescriptor
	the following data structure describes an io intrinsic function: its name More...

Functions
static_control	static_controlize_call (call c)
	================================================================ More...
static_control	static_controlize_loop (loop l)
	================================================================= More...
static_control	static_controlize_forloop (forloop fl)
	================================================================= More...
static_control	static_controlize_whileloop (whileloop wl)
	================================================================= More...
static_control	static_controlize_statement (statement s)
static_control	static_controlize_unstructured (unstructured u)
	================================================================= More...
static bool	io_filter (statement st)
	====================================================================== More...
bool	static_controlize (string mod_name)
	================================================================= More...
list	loop_normalize_of_loop (loop l, hash_table fst, list *ell, list *etl, list *swfl, int *Gcount_nlc)
	================================================================= More...
list	loop_normalize_of_statement (statement s, hash_table fst, list *ell, list *etl, list *swfl, int *Gcount_nlc)
	================================================================= More...
void	loop_normalize_of_unstructured (unstructured u, hash_table fst, list *ell, list *etl, list *swfl, int *Gcount_nlc)
	================================================================= More...

Variables
list	Gstructure_parameters
	Global Variables More...
static list	Genclosing_loops
static list	Genclosing_tests
static list	Gscalar_written_forward
static hash_table	Gforward_substitute_table
statement_mapping	Gstatic_control_map
list	assigned_var = NIL
	================================================================= More...
static IOIntrinsicDescriptor	IOIntrinsicDescriptorTable []

Typedef Documentation

arc_label

typedef void* arc_label

Name : static_controlize.c package : static_controlize Author : Arnauld LESERVOT Date : May 93 Modified : Documents : "Implementation du Data Flow Graph dans Pips" Comments :

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

Definition at line 63 of file static_controlize.c.

IOIntrinsicDescriptor

typedef struct IOIntrinsicDescriptor IOIntrinsicDescriptor

the following data structure describes an io intrinsic function: its name

vertex_label

typedef void* vertex_label

Definition at line 64 of file static_controlize.c.

Function Documentation

io_filter()

static bool io_filter ( statement  st )

static

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

bool io_filter(st)

Tests if the statement is a call to an IO function. In such a case, we put the statement inside a comment.

AP, oct 9th 1995

There can be no statement inside a call, so gen_recurse() do not need to go further.

Do not forget to move forbidden information associated with block:

Definition at line 430 of file static_controlize.c.

{
  bool res_b;
  instruction ins;
 
  res_b = true;
  ins = statement_instruction(st);
 
  if(instruction_tag(ins) == is_instruction_call) {
    call ca = instruction_call(ins);
    entity e = call_function(ca);
 
    /* There can be no statement inside a call, so gen_recurse() do not
       need to go further. */
    res_b = false;
 
    if(value_tag(entity_initial(e)) == is_value_intrinsic) {
      const char* s = entity_local_name(e);
      IOIntrinsicDescriptor *pid = IOIntrinsicDescriptorTable;
      bool found = false;
 
      while ((pid->name != NULL) && (!found)) {
        if (strcmp(pid->name, s) == 0) {
          char         *comment;
          statement    stat;
          list lstat;
 
          // BUG: missing overflow checks
          comment = (char*) malloc(64);
          sprintf(comment, "C %s\n",
                  words_to_string(Words_Call(ca, 0, true, true)));
 
          pips_assert("no buffer overflow", strlen(comment)<64);
 
          stat = make_statement(entity_empty_label(),
                                STATEMENT_NUMBER_UNDEFINED,
                                STATEMENT_ORDERING_UNDEFINED,
                                comment,
                                make_instruction_block(NIL),
                                NIL, // No local declarations
                                NULL, // null or empty string...
                                empty_extensions (), make_synchronization_none());
          lstat = CONS(STATEMENT, stat, NIL);
 
          statement_instruction(st) = make_instruction_block(lstat);
          /* Do not forget to move forbidden information associated with
             block: */
          fix_sequence_statement_attributes(st);
 
          found = true;
        }
        pid += 1;
      }
    }
  }
 
  return(res_b);
}

References call_function, comment(), CONS, empty_extensions(), entity_empty_label(), entity_initial, entity_local_name(), fix_sequence_statement_attributes(), instruction_call, instruction_tag, IOIntrinsicDescriptorTable, is_instruction_call, is_value_intrinsic, make_instruction_block(), make_statement(), make_synchronization_none(), malloc(), IOIntrinsicDescriptor::name, NIL, pips_assert, STATEMENT, statement_instruction, STATEMENT_NUMBER_UNDEFINED, STATEMENT_ORDERING_UNDEFINED, value_tag, Words_Call(), and words_to_string().

Referenced by static_controlize().

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:

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:

Variable Documentation

assigned_var

list assigned_var = NIL

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

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

Definition at line 207 of file static_controlize.c.

Referenced by static_controlize(), and static_controlize_statement().

Genclosing_loops

list Genclosing_loops

static

Definition at line 82 of file static_controlize.c.

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

Genclosing_tests

list Genclosing_tests

static

Definition at line 83 of file static_controlize.c.

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

Gforward_substitute_table

hash_table Gforward_substitute_table

static

Definition at line 85 of file static_controlize.c.

Referenced by static_controlize(), and static_controlize_statement().

Gscalar_written_forward

list Gscalar_written_forward

static

Definition at line 84 of file static_controlize.c.

Referenced by static_controlize().

Gstatic_control_map

statement_mapping Gstatic_control_map

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

Global Variables

Global variables

static_controlize.c

Definition at line 81 of file static_controlize.c.

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

IOIntrinsicDescriptorTable

IOIntrinsicDescriptor IOIntrinsicDescriptorTable[]

static

Initial value:

= {
    {"WRITE"},
    {"REWIND"},
    {"BACKSPACE"},
    {"OPEN"},
    {"CLOSE"},
    {"READ"},
    {"BUFFERIN"},
    {"BUFFEROUT"},
    {"ENDFILE"},
    {"INQUIRE"},
    {IMPLIED_DO_NAME},
 
    {NULL}
}

Definition at line 404 of file static_controlize.c.

Referenced by io_filter().