propagate.c File Reference

#include "all.h"
#include "prettyprint.h"

Include dependency graph for propagate.c:

Go to the source code of this file.

Macros
#define	IS_EG   TRUE
	{{{ banner More...
#define	NOT_EG   FALSE
#define	PHI_FIRST   TRUE
#define	NOT_PHI_FIRST   FALSE

Functions
void	CheckStride (loop __attribute__((unused)) Loop)
	global static variable local_regions_map, and its access functions More...
list	CompRegionsExactUnion (list l1, list l2, bool __attribute__((unused))(*union_combinable_p)(effect, effect))
	just concatentate list for now : change later More...
list	CompRegionsMayUnion (list l1, list l2, bool __attribute__((unused))(*union_combinable_p)(effect, effect))
	just concatentate list for now : change later More...
bool	comp_regions (const char *module_name)
	}}} More...
list	comp_regions_of_statement (statement s)
	}}} More...
list	comp_regions_of_instruction (instruction i, transformer t_inst, transformer context, list *plpropreg)
	}}} More...
list	comp_regions_of_block (list linst)
	}}} More...
list	comp_regions_of_test (test t, transformer context, list __attribute__((unused)) *plpropreg)
	}}} More...
list	comp_regions_of_loop (loop l, transformer __attribute__((unused)) loop_trans, transformer context, list __attribute__((unused)) *plpropreg)
	}}} More...
list	comp_regions_of_call (call c, transformer context, list *plpropreg)
	}}} More...
list	comp_regions_of_unstructured (unstructured u, transformer t_unst)
	}}} More...
list	comp_regions_of_range (range r, transformer context)
	}}} More...
list	comp_regions_of_syntax (syntax s, transformer context)
	}}} More...
list	comp_regions_of_expressions (list exprs, transformer context)
	}}} More...
list	comp_regions_of_expression (expression e, transformer context)
	{{{ comp_regions_of_expression More...
list	comp_regions_of_read (reference ref, transformer context)
	}}} More...
list	comp_regions_of_write (reference ref, transformer context)
	}}} More...

Macro Definition Documentation

IS_EG

#define IS_EG   TRUE

{{{ banner

package complementary sections : Manjunathaiah M , 18-4-96

This File contains the functions computing the regions of a module : proper, local and global. }}}

Definition at line 40 of file propagate.c.

NOT_EG

#define NOT_EG   FALSE

Definition at line 41 of file propagate.c.

NOT_PHI_FIRST

#define NOT_PHI_FIRST   FALSE

Definition at line 44 of file propagate.c.

PHI_FIRST

#define PHI_FIRST   TRUE

Definition at line 43 of file propagate.c.

Function Documentation

CheckStride()

void CheckStride

(

loop __attribute__((unused))

Loop

)

global static variable local_regions_map, and its access functions

{{{ auxilliary functions

expression Stride = range_increment(loop_range(Loop));

Definition at line 50 of file propagate.c.

{
    /* expression Stride = range_increment(loop_range(Loop)); */
 
}

comp_regions()

bool comp_regions

(

const char *

module_name

)

}}}

{{{ process the body of a procedure ===============================================================================

INTRAPROCEDURAL ARRAY REGIONS ANALYSIS

---

{{{ intra procedural entry point "complementary_sections" calls comp_regions {{{ comments bool regions(const char* module_name) input : the name of the current module output : nothing. modifies : computes the local regions of a module. comment : local regions can contain local variables. }}}

{{{ code

{{{ initialize

regions_init();

get the current properties concerning regions

Get the code of the module.

}}}

{{{ transformers and preconditions

Get the transformers and preconditions of the module.

}}}

{{{ predicates for purpose of debugging

predicates defining summary regions from callees have to be translated into variables local to module

}}}

}}}

Compute the regions of the module.

{{{ for dependence analysis : currently masked

set_proper_regions_map( MAKE_STATEMENT_MAPPING() );

}}}

{{{ code

{{{ debug stmts

if (op_statistics_p()) print_regions_op_statistics(module_name, R_RW);

}}}

{{{ store in database : modify later

DB_PUT_MEMORY_RESOURCE(DBR_PROPER_REGIONS, strdup(module_name), (char*) listmap_to_effectsmap(get_proper_regions_map()));

}}}

{{{ finalise

}}}

}}}

Parameters

module_name

odule_name

Definition at line 87 of file propagate.c.

{
  /* {{{  code*/
  /* {{{  initialize*/
  /* regions_init(); */
  
  /* get the current properties concerning regions */
  get_regions_properties();
  
  /* Get the code of the module. */
  set_current_module_statement( (statement)
        db_get_memory_resource(DBR_CODE, module_name, true) );
  /* }}} */
  /* {{{  transformers and preconditions*/
  /* Get the transformers and preconditions of the module. */
  set_transformer_map( (statement_mapping)
        db_get_memory_resource(DBR_TRANSFORMERS, module_name, true) );  
  set_precondition_map( (statement_mapping) 
        db_get_memory_resource(DBR_PRECONDITIONS, module_name, true) );
  /* }}} */
  /* {{{  predicates for purpose of debugging*/
  /* predicates defining summary regions from callees have to be 
     translated into variables local to module */
  set_current_module_entity( local_name_to_top_level_entity(module_name) );
  
  
  set_cumulated_rw_effects((statement_effects)
                db_get_memory_resource(DBR_CUMULATED_EFFECTS, module_name, true));
  set_proper_rw_effects((statement_effects)
                db_get_memory_resource(DBR_PROPER_EFFECTS, module_name, true));
  module_to_value_mappings(get_current_module_entity());
  
  debug_on("COMP_REGIONS_DEBUG_LEVEL");
  pips_debug(3, "begin\n");
  
  /* }}} */
  /* }}} */
  /* Compute the regions of the module. */
  set_local_comp_regions_map( MAKE_STATEMENT_MAPPING() );
  /* {{{  for dependence analysis : currently masked */
  /* set_proper_regions_map( MAKE_STATEMENT_MAPPING() ); */
  /* }}} */
  (void)comp_regions_of_statement(get_current_module_statement()); 
  /* {{{  code*/
  /* {{{  debug stmts*/
  /* if (op_statistics_p()) print_regions_op_statistics(module_name, R_RW); */
  
  pips_debug(3, "end\n");
  
  debug_off();
  /* }}} */
  /* {{{  store in database : modify later*/
  DB_PUT_MEMORY_RESOURCE(DBR_COMPSEC, 
                  strdup(module_name),
                  (char*) listmap_to_compsecs_map(get_local_comp_regions_map()) );
                  
  
  /* DB_PUT_MEMORY_RESOURCE(DBR_PROPER_REGIONS, 
                  strdup(module_name),
                  (char*) listmap_to_effectsmap(get_proper_regions_map()));
  */
  /* }}} */
  /* {{{  finalise*/
  reset_current_module_entity();
  reset_current_module_statement();
  reset_transformer_map();
  reset_precondition_map();
  reset_cumulated_rw_effects();
  reset_proper_rw_effects();
  free_local_comp_regions_map();
  /* }}} */
  /* }}} */
 
  return(true);
}

References comp_regions_of_statement(), db_get_memory_resource(), DB_PUT_MEMORY_RESOURCE, debug_off, debug_on, free_local_comp_regions_map(), get_current_module_entity(), get_current_module_statement(), get_local_comp_regions_map(), get_regions_properties(), listmap_to_compsecs_map(), local_name_to_top_level_entity(), MAKE_STATEMENT_MAPPING, module_name(), module_to_value_mappings(), pips_debug, reset_cumulated_rw_effects(), reset_current_module_entity(), reset_current_module_statement(), reset_precondition_map(), reset_proper_rw_effects(), reset_transformer_map(), set_cumulated_rw_effects(), set_current_module_entity(), set_current_module_statement(), set_local_comp_regions_map(), set_precondition_map(), set_proper_rw_effects(), set_transformer_map(), and strdup().

Referenced by complementary_sections().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_block()

list comp_regions_of_block

(

list

linst

)

}}}

{{{ comp_region_of_block {{{ comment list comp_regions_of_block(list linst) input : a list of instructions, representing a sequential block of instructions, and the context before the block. output : a list of regions modifies : linst. comment : calls itself recursively to calculate the list of regions.
}}}

{{{ init

}}}

{{{ Is it end of list ?

}}}

{{{ else process list

{{{ regions of CAR(linst)

}}}

{{{ any more statements in CDR(linst)

{{{ load transformer

}}}

{{{ perform union

{{{ don't know that this means ???

blocked : check later list current_transformer = load_statement_transformer(first_statement);
debug_regions_consistency(r_block_regions); project_regions_with_transformer_inverse(r_block_regions, current_transformer, NIL);

debug_regions_consistency(r_block_regions);

}}}

}}}

}}}

{{{ if not lres = first_s_regions

}}}

}}}

Parameters

linst

inst

Definition at line 301 of file propagate.c.

{
    /* {{{  init*/
    statement first_statement;
    list remaining_block, first_s_regions, lres = NIL;
    
    pips_debug(3, "begin\n");
    /* }}} */
 
    /* {{{  Is it end of list ? */
    if (ENDP(linst))
    {
            user_warning("regions_of_block", "empty block\n");
            lres = NIL;
    }
    /* }}} */
    /* {{{  else process list*/
    else
    {
            /* {{{  regions of CAR(linst)*/
            first_statement = STATEMENT(CAR(linst));
            remaining_block = CDR(linst);
                
            first_s_regions = comp_regions_of_statement(first_statement);
            /* }}} */
            /* {{{  any more statements in  CDR(linst)*/
            if (!ENDP(remaining_block))
            {
              /* {{{  load transformer*/
              list r_block_regions = NIL;
              
              /* }}} */
              r_block_regions = comp_regions_of_block(remaining_block);
              /* {{{  perform union*/
              /* {{{  don't know that this means ???*/
              /* blocked : check later
              list current_transformer = load_statement_transformer(first_statement);    
              debug_regions_consistency(r_block_regions);
               project_regions_with_transformer_inverse(r_block_regions, 
                                                     current_transformer, 
                                                     NIL); 
              
              debug_regions_consistency(r_block_regions);
              */
              /* }}} */
              lres = CompRegionsExactUnion(first_s_regions, r_block_regions, effects_same_action_p);          
              /*
              debug_regions_consistency(lres);
              */
              /* }}} */
            
            }
            /* }}} */
      /* {{{  if not  lres = first_s_regions*/
      else 
       lres = first_s_regions;
      /* }}} */
    
    }
    /* }}} */
 
    pips_debug(3, "end\n");
    return lres;
}

References CAR, CDR, comp_regions_of_block(), comp_regions_of_statement(), CompRegionsExactUnion(), effects_same_action_p(), ENDP, NIL, pips_debug, STATEMENT, and user_warning.

Referenced by comp_regions_of_block(), and comp_regions_of_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_call()

list comp_regions_of_call	(	call	c,
		transformer	context,
		list *	plpropreg
	)

}}}

{{{ comp_regions of call list comp_regions_of_call(call c, transformer context, list *plpropreg) input : a call, which can be a call to a subroutine, but also to an function, or to an intrinsic, or even an assignement. And a pointer that will be the proper regions of the call; NIL, except for an intrinsic (assignment or real FORTRAN intrinsic). output : the corresponding list of regions. modifies : nothing. comment :

{{{ code

masked now : change later

masked now : *plpropreg = regions_dup(le);

}}}

Parameters

context	ontext
plpropreg	lpropreg

Definition at line 510 of file propagate.c.

{
    list le = NIL;
    entity e = call_function(c);
    tag t = value_tag(entity_initial(e));
    const char* n = module_local_name(e);
    list pc = call_arguments(c);
 
    *plpropreg = NIL;
 
    pips_debug(3, "begin\n");
 
    switch (t)
    {
     /* {{{  code*/
     case is_value_code:
         pips_debug(3, "external function %s\n", n);
         /* masked now : change later */
         /*
          le = comp_regions_of_external(e, pc, context);
         */
         break;
     
     case is_value_intrinsic:
         pips_debug(3, "intrinsic function %s\n", n);
         le = comp_regions_of_intrinsic(e, pc, context);
               /* masked now : *plpropreg = regions_dup(le); */
         break;
     
     case is_value_symbolic:
               pips_debug(3, "symbolic\n");
               break;
     
     case is_value_constant:
               pips_debug(3, "constant\n");
         break;
     
     case is_value_unknown:
         pips_internal_error("unknown function %s", n);
         break;
     
     default:
         pips_internal_error("unknown tag %d", t);
     /* }}} */
    }
 
    pips_debug(3, "end\n");
 
    return(le);
}

References call_arguments, call_function, comp_regions_of_intrinsic(), entity_initial, is_value_code, is_value_constant, is_value_intrinsic, is_value_symbolic, is_value_unknown, module_local_name(), NIL, pips_debug, pips_internal_error, and value_tag.

Referenced by comp_regions_of_instruction(), and comp_regions_of_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_expression()

list comp_regions_of_expression	(	expression	e,
		transformer	context
	)

{{{ comp_regions_of_expression

list comp_regions_of_expression(expression e, transformer context) input : an expression and the current context output : the correpsonding list of regions. modifies : nothing. comment :

Parameters

context

ontext

Definition at line 701 of file propagate.c.

{
    return(comp_regions_of_syntax(expression_syntax(e), context));
}

References comp_regions_of_syntax(), and expression_syntax.

Referenced by affect_comp_regions(), comp_regions_of_expressions(), comp_regions_of_implied_do(), comp_regions_of_ioelem(), comp_regions_of_iolist(), comp_regions_of_range(), and comp_regions_of_test().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_expressions()

list comp_regions_of_expressions	(	list	exprs,
		transformer	context
	)

}}}

{{{ comp_regions_of_expressions list comp_regions_of_expressions(list exprs, transformer context) input : a list of expressions and the current context. output : the correpsonding list of regions. modifies : nothing. comment :

Parameters

exprs	xprs
context	ontext

Definition at line 678 of file propagate.c.

{
    list le = NIL;
 
    pips_debug(3, "begin\n");
 
    MAP(EXPRESSION, exp,
    {
            le = CompRegionsExactUnion(le, comp_regions_of_expression(exp, context), 
                              effects_same_action_p);
    },
          exprs);
 
    pips_debug(5, "end\n");
    return(le);
}

References comp_regions_of_expression(), CompRegionsExactUnion(), effects_same_action_p(), exp, EXPRESSION, MAP, NIL, and pips_debug.

Referenced by comp_regions_of_read(), comp_regions_of_write(), and no_write_comp_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_instruction()

list comp_regions_of_instruction	(	instruction	i,
		transformer	t_inst,
		transformer	context,
		list *	plpropreg
	)

}}}

{{{ comp_regions_of_instruction {{{ comments list comp_regions_of_instruction(instruction i, transformer t_inst, context, list *plpropreg) input : the current instruction and the corresponding transformer and context (i.e. precondition), and a pointer that will contain the proper regions of the instruction. output : the corresponding list of regions. modifies : nothing. }}}

{{{ init

}}}

{{{ code

{{{ code

}}}

{{{ code

}}}

{{{ code

}}}

{{{ code

}}}

{{{ code

}}}

{{{ code

}}}

}}}

Parameters

t_inst	_inst
context	ontext
plpropreg	lpropreg

Definition at line 224 of file propagate.c.

{
    /* {{{  init*/
    list lreg = NIL;
    
    *plpropreg = NIL;
    
    /* }}} */
    switch(instruction_tag(i))
    {
      /* {{{  code*/
      case is_instruction_goto:
              /* {{{  code*/
              pips_debug(3, "goto\n");
         break;
              /* }}} */
      case is_instruction_test:
              /* {{{  code*/
              ifdebug(3)
              {
                pips_debug(3, "test : %s\n",
                           expression_to_string(test_condition(instruction_test(i))));
              }
        lreg = comp_regions_of_test(instruction_test(i), context, plpropreg);
              break;
              /* }}} */
      case is_instruction_loop:
              /* {{{  code*/
              ifdebug(3)
              {
              pips_debug(3, "loop : index %s\n",
                         entity_local_name(loop_index(instruction_loop(i))));
              }
        lreg = comp_regions_of_loop(instruction_loop(i), t_inst, context, plpropreg);
        break;
              /* }}} */
      case is_instruction_call:
      /* {{{  code*/
      ifdebug(3)
      {
        pips_debug(3, "call : %s\n",
                 module_local_name(call_function(instruction_call(i))));
      }
      lreg = comp_regions_of_call(instruction_call(i), context, plpropreg);
      break;
      /* }}} */
      case is_instruction_unstructured: 
      /* {{{  code*/
      pips_debug(3, "unstructured\n");
      lreg = comp_regions_of_unstructured(instruction_unstructured( i ), t_inst);
      break ;
      /* }}} */
      case is_instruction_block: 
      /* {{{  code*/
      pips_debug(3, "inst block\n");
      lreg = comp_regions_of_block(instruction_block(i));
      break;
      /* }}} */
      default:
          pips_debug(3, "unexpected tag %d\n", instruction_tag(i));
      /* }}} */
    }
    
    return(lreg);
}

References call_function, comp_regions_of_block(), comp_regions_of_call(), comp_regions_of_loop(), comp_regions_of_test(), comp_regions_of_unstructured(), entity_local_name(), expression_to_string(), ifdebug, 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_index, module_local_name(), NIL, pips_debug, and test_condition.

Referenced by comp_regions_of_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_loop()

list comp_regions_of_loop	(	loop	l,
		transformer __attribute__((unused))	loop_trans,
		transformer	context,
		list __attribute__((unused)) *	plpropreg
	)

}}}

{{{ comp_regions of loop list comp_regions_of_loop(loop l, transfomer loop_trans, context, list *plpropreg) input : a loop, its transformer and its context, and a pointer toward a list, that will contain the proper regions of the loop, which are the regions of its range. output : the corresponding list of regions. modifies : nothing. comment :

{{{ init

}}}

CheckStride(l);

regions of loop index.

{{{ code

loop index is must-written but may-read because the loop might execute no iterations.

the loop index is must-written

FI, RK: the may-read effect on the index variable is masked by the intial unconditional write on it (see standard page 11-7, 11.10.3); if masking is not performed, the read may prevent privatization somewhere else in the module (12 March 1993)

}}}

{{{ regions of loop induction variable

regions of loop bound expressions.

}}}

regions of loop body statement.

insert code to eliminate private variables later

projection of regions along the variables modified by the loop; it includes the projection along the loop index

{{{ In simple sections it is called translation !!

}}}

Definition at line 416 of file propagate.c.

                                                               {
    /* {{{  init*/
    list index_reg, body_reg, le;
    /*
      list global_reg;
      entity i = loop_index(l);
    */
 
    pips_debug(3, "begin\n");
    /* }}} */
 
    /* CheckStride(l); */
    /* regions of loop index. */
    if( execution_sequential_p( loop_execution( l )))
    {
            /* {{{  code*/
            /* loop index is must-written but may-read because the loop might
               execute no iterations. */
            reference ref = make_reference(loop_index(l), NIL);
            
            index_reg = comp_regions_of_write(ref, context); /* the loop index is must-written */
            
            /* FI, RK: the may-read effect on the index variable is masked by
             * the intial unconditional write on it (see standard page 11-7, 11.10.3);
             * if masking is not performed, the read may prevent privatization
             * somewhere else in the module (12 March 1993)
             */
            /* }}} */
    }
    else 
            index_reg = NIL ;
 
    /* {{{  regions of  loop induction variable*/
    /* regions of loop bound expressions. */
    le = CompRegionsExactUnion(
           index_reg, 
           comp_regions_of_range(loop_range(l), context), 
           effects_same_action_p);
    /* }}} */
 
    /* *plpropreg = regions_dup(le); */
 
    /* regions of loop body statement. */
    body_reg = comp_regions_of_statement(loop_body(l));
 
    /* insert code to eliminate private variables later */
    
    /* projection of regions along the variables modified by the loop; it includes
     * the projection along the loop index */
 
     
    pips_debug(7, "elimination of variables modified by the loop.\n");
 
    /* {{{  In simple sections it is called translation !!*/
    /*
    project_regions_with_transformer_inverse(global_reg, 
                                             loop_trans, 
                                             CONS(ENTITY,i,NIL));
    project_regions_along_loop_index(global_reg, i, loop_range(l));
    */
    
    pips_debug(3, "Before Translations surrounding the loop index %s :\n",
             entity_local_name(loop_index(l)));
 
    (void) TranslateRefsToLoop(l, body_reg);
    
    le = CompRegionsExactUnion(le, body_reg, effects_same_action_p);
    
    ifdebug(3)  {
      pips_debug(3, "After Translations  surrounding the loop index %s :\n",
        entity_local_name(loop_index(l)));
      PrintCompRegions(le);
    }
 
    pips_debug(3, "end\n");
    /* }}} */
 
    return(le);
}

References comp_regions_of_range(), comp_regions_of_statement(), comp_regions_of_write(), CompRegionsExactUnion(), effects_same_action_p(), entity_local_name(), execution_sequential_p, ifdebug, loop_body, loop_execution, loop_index, loop_range, make_reference(), NIL, pips_debug, PrintCompRegions(), ref, and TranslateRefsToLoop().

Referenced by comp_regions_of_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_range()

list comp_regions_of_range	(	range	r,
		transformer	context
	)

}}}

{{{ comp_regions_of_range list comp_regions_of_range(range r, context) input : a loop range (bounds and stride) and the context. output : the corresponding list of regions. modifies : nothing. comment :

Parameters

context

ontext

Definition at line 610 of file propagate.c.

{
    list le;
    expression el = range_lower(r);
    expression eu = range_upper(r);
    expression ei = range_increment(r);
 
    pips_debug(3, "begin\n");
 
    le = comp_regions_of_expression(el, context);
    le = CompRegionsExactUnion(le, comp_regions_of_expression(eu, context), 
                               effects_same_action_p);
    le = CompRegionsExactUnion(le, comp_regions_of_expression(ei, context), 
                               effects_same_action_p);
 
    pips_debug(3, "end\n");
    return(le);
}

References comp_regions_of_expression(), CompRegionsExactUnion(), effects_same_action_p(), pips_debug, range_increment, range_lower, and range_upper.

Referenced by comp_regions_of_loop(), and comp_regions_of_syntax().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_read()

list comp_regions_of_read	(	reference	ref,
		transformer	context
	)

}}}

}}} {{{ comp_regions_of_read list comp_regions_of_read(reference ref, transformer context) input : a reference that is read, and the current context. output : the corresponding list of regions. modifies : nothing. comment :

{{{ init

}}}

{{{ code

{{{ this read reference

}}}

{{{ rest of the references in an expression

}}}

}}}

Parameters

ref	ef
context	ontext

Definition at line 715 of file propagate.c.

{
  /* {{{  init*/
  list inds = reference_indices(ref);
  list le = NIL;
  comp_desc Cdesc;
  entity e = reference_variable(ref);
  
  pips_debug(3, "begin\n");
  /* }}} */
    
           /* {{{  code*/
           /* {{{  this read reference*/
           if (! entity_scalar_p(e) )
           {
               Cdesc = InitCompDesc(ref, is_action_read);
               le = CONS(COMP_DESC, Cdesc, le);
           }
            /* }}} */
           /* {{{  rest of the references in an expression*/
           if (! ENDP(inds)) 
               le = CompRegionsExactUnion(le, comp_regions_of_expressions(inds, context), effects_same_action_p);
 
           /* }}} */
           /* }}} */
  
  pips_debug(3, "end\n");
  return(le);
}

References COMP_DESC, comp_regions_of_expressions(), CompRegionsExactUnion(), CONS, effects_same_action_p(), ENDP, entity_scalar_p(), InitCompDesc(), is_action_read, NIL, pips_debug, ref, reference_indices, and reference_variable.

Referenced by comp_regions_of_syntax(), and io_comp_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_statement()

list comp_regions_of_statement

(

statement

s

)

}}}

{{{ comp_regions_of_statement {{{ comments list comp_regions_of_statement(statement s) input : the current statement. output : a list of regions. modifies : the local regions_map. comment : computes the local regions of a statement and stores it in the local_regions_map. }}}

{{{ code

{{{ inits

}}}

{{{ transformer and preconditions

compute the regions on the instruction of the statement

}}}

}}}

{{{ code

{{{ store the result : currently masked, modify later

FI: make a copy to safely store that intermediate state in the mapping

debug_regions_consistency(lreg); debug_regions_consistency(lpropreg); store_statement_proper_regions(s, lpropreg);

}}}

}}}

Definition at line 173 of file propagate.c.

{
  /* {{{  code*/
  /* {{{  inits*/
  transformer t_stat, context;
  list lreg, lpropreg = NIL;
  
  ifdebug(3)
  {
          pips_debug(3, "begin\n\tComputation of regions of statement %03td\n", 
                 statement_number(s));
  }
  /* }}} */
  /* {{{  transformer and preconditions*/
    context = load_statement_precondition(s);
 
  /* compute the regions on the instruction of the statement */
    t_stat = load_statement_transformer(s);
 
  /* }}} */
  /* }}} */
 
  lreg = comp_regions_of_instruction(statement_instruction(s),
             t_stat, context, &lpropreg);
 
  /* {{{  code*/
  /* {{{  store the result : currently masked,  modify later*/
  /* FI: make a copy to safely store that intermediate state in the mapping */
  /* debug_regions_consistency(lreg);
  debug_regions_consistency(lpropreg);
  store_statement_proper_regions(s, lpropreg);
  */
  store_statement_local_comp_regions(s, comp_regions_dup(lreg) ); 
   /* }}} */
  /* }}} */
 
  return(lreg);
}

References comp_regions_dup(), comp_regions_of_instruction(), ifdebug, load_statement_precondition(), load_statement_transformer(), NIL, pips_debug, statement_instruction, statement_number, and store_statement_local_comp_regions().

Referenced by comp_regions(), comp_regions_of_block(), comp_regions_of_loop(), comp_regions_of_test(), and comp_regions_of_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_syntax()

list comp_regions_of_syntax	(	syntax	s,
		transformer	context
	)

}}}

{{{ comp_regions_of_syntax list comp_regions_of_syntax(syntax s, transformer context) input : output : modifies : comment :

{{{ code

comp_desc_free(lpropreg);

}}}

Parameters

context

ontext

Definition at line 636 of file propagate.c.

{
    list le = NIL, lpropreg = NIL;
 
    pips_debug(3, "begin\n");
 
    switch(syntax_tag(s))
    {
      /* {{{  code*/
      case is_syntax_reference:
          le = comp_regions_of_read(syntax_reference(s), context);
          break;
      case is_syntax_range:
          le = comp_regions_of_range(syntax_range(s), context);
          break;
      case is_syntax_call:
          le = comp_regions_of_call(syntax_call(s), context, &lpropreg);
                /* comp_desc_free(lpropreg);  */
          break;
      default:
          pips_internal_error("unexpected tag %d", syntax_tag(s));
      /* }}} */
    }
 
    ifdebug(3)
    {
            pips_debug(3, "Regions of expression  %s :\n",
                       words_to_string(Words_Syntax(s)));
            print_regions(le);
    }
 
    pips_debug(3, "end\n");
    return(le);
}

References comp_regions_of_call(), comp_regions_of_range(), comp_regions_of_read(), ifdebug, is_syntax_call, is_syntax_range, is_syntax_reference, NIL, pips_debug, pips_internal_error, print_regions(), syntax_call, syntax_range, syntax_reference, syntax_tag, Words_Syntax(), and words_to_string().

Referenced by comp_regions_of_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_test()

list comp_regions_of_test	(	test	t,
		transformer	context,
		list __attribute__((unused)) *	plpropreg
	)

}}}

{{{ comp_regions of test list regions_of_test(test t, transformer context, list *plpropreg) input : a test instruction, the context of the test, and a pointer toward a list that will contain the proper regions of the test, which are the regions of its conditionnal part. output : the corresponding list of regions. modifies : nothing.

{{{ init

}}}

{{{ if-then-else including if-condition

regions of the true branch

regions of the false branch

regions of the combination of both

regions of the condition

check later plpropreg = comp_regions_dup(lc);

}}}

{{{ union the regions : currently just add to the list

}}}

Definition at line 375 of file propagate.c.

                                                               {
    /* {{{  init*/
    list le, lt, lf, lc, lr;
    
    pips_debug(3, "begin\n");
    /* }}} */
 
    /* {{{  if-then-else including if-condition*/
      /* regions of the true branch */
    lt = comp_regions_of_statement(test_true(t));
      /* regions of the false branch */
    lf = comp_regions_of_statement(test_false(t));
      /* regions of the combination of both */
    le = CompRegionsMayUnion(lt, lf, effects_same_action_p);
    
      /* regions of the condition */
    lc = comp_regions_of_expression(test_condition(t), context);
    /* check later
    *plpropreg = comp_regions_dup(lc);
    */
    /* }}} */
    /* {{{  union the regions : currently just add to the list*/
    lr = CompRegionsExactUnion(le, lc, effects_same_action_p);
    pips_debug(3, "end\n");
    /* }}} */
 
    return(lr);
}

References comp_regions_of_expression(), comp_regions_of_statement(), CompRegionsExactUnion(), CompRegionsMayUnion(), effects_same_action_p(), pips_debug, test_condition, test_false, and test_true.

Referenced by comp_regions_of_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_unstructured()

list comp_regions_of_unstructured	(	unstructured	u,
		transformer	t_unst
	)

}}}

{{{ comp_regions of unstructured Computes the effects of the control graph. list comp_regions_of_unstructured( u , t_unst) input : an unstructured control flow graph and the corresponding transformer. output : the corresponding list of regions. modifies : nothing. comment :

there is only one statement in u; no need for a fix-point

Parameters

t_unst

_unst

Definition at line 571 of file propagate.c.

{
    control ct;
    list blocs = NIL ;
    list le = NIL ;
 
    pips_debug(3, "begin\n");
 
    ct = unstructured_control( u );
 
    if(control_predecessors(ct) == NIL && control_successors(ct) == NIL)
    {
            /* there is only one statement in u; no need for a fix-point */
            pips_debug(3, "unique node\n");
            le = comp_regions_of_statement(control_statement(ct));
    }
    else
    {   
            CONTROL_MAP(c,
                   {
                     le = CompRegionsMayUnion(comp_regions_of_statement(control_statement(c)), 
                                         le, effects_same_action_p) ;
                   },ct, blocs) ;       
             project_regions_along_parameters(le, transformer_arguments(t_unst));
             gen_free_list(blocs) ;
    }    
 
    pips_debug(3, "end\n");
 
    return( le ) ;
}

References comp_regions_of_statement(), CompRegionsMayUnion(), CONTROL_MAP, control_predecessors, control_statement, control_successors, effects_same_action_p(), gen_free_list(), NIL, pips_debug, project_regions_along_parameters(), transformer_arguments, and unstructured_control.

Referenced by comp_regions_of_instruction().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_write()

list comp_regions_of_write	(	reference	ref,
		transformer	context
	)

}}}

{{{ comp_regions_of_write regions of a reference that is written list comp_regions_of_write(reference ref, transformer context) input : a reference that is written, and the current context. output : the corresponding list of regions. modifies : nothing. comment :

{{{ init

}}}

{{{ this write

}}}

{{{ check for arrays in subscripts

}}}

Parameters

ref	ef
context	ontext

Definition at line 753 of file propagate.c.

{    
    /* {{{  init*/
    comp_desc Cdesc;
    list le = NIL;
    entity e = reference_variable(ref);
    list inds = reference_indices(ref);
    /* }}} */
 
    pips_debug(3, "begin\n");
 
    /* {{{  this write */
    if (! entity_scalar_p(e) )
    {
      Cdesc = InitCompDesc(ref, is_action_write);       
       le = CONS(COMP_DESC, Cdesc, le);
    }
    /* }}} */
    /* {{{  check for arrays in subscripts*/
    if (! ENDP(inds)) 
        le = CompRegionsExactUnion(le, comp_regions_of_expressions(inds, context), effects_same_action_p);
 
    /* }}} */
 
    pips_debug(3, "end\n");
 
    return(le);
}

References COMP_DESC, comp_regions_of_expressions(), CompRegionsExactUnion(), CONS, effects_same_action_p(), ENDP, entity_scalar_p(), InitCompDesc(), is_action_write, NIL, pips_debug, ref, reference_indices, and reference_variable.

Referenced by affect_comp_regions(), comp_regions_of_implied_do(), comp_regions_of_ioelem(), comp_regions_of_iolist(), comp_regions_of_loop(), and io_comp_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

CompRegionsExactUnion()

list CompRegionsExactUnion	(	list	l1,
		list	l2,
		bool __attribute__((unused))(*)(effect, effect)	union_combinable_p
	)

just concatentate list for now : change later

Definition at line 57 of file propagate.c.

{
   return(gen_nconc(l1,l2));
}

References gen_nconc().

Referenced by comp_regions_of_block(), comp_regions_of_expressions(), comp_regions_of_loop(), comp_regions_of_range(), comp_regions_of_read(), comp_regions_of_test(), and comp_regions_of_write().

Here is the call graph for this function:

Here is the caller graph for this function:

CompRegionsMayUnion()

list CompRegionsMayUnion	(	list	l1,
		list	l2,
		bool __attribute__((unused))(*)(effect, effect)	union_combinable_p
	)

just concatentate list for now : change later

Definition at line 63 of file propagate.c.

{
   return(gen_nconc(l1,l2));
}

References gen_nconc().

Referenced by comp_regions_of_test(), and comp_regions_of_unstructured().

Here is the call graph for this function:

Here is the caller graph for this function: