comp_sections.h File Reference

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

Go to the source code of this file.

Data Structures
struct	sSimpBound
	bounds are retained as high level tree structures to accommodate symbolic information in boundary expressions. More...
struct	DadComponent
	Simple Section part of DAD An array of type SimpBound struct allocated dynamically based on rank of array. More...
struct	Variants
	}} More...

Macros
#define	LIN_INVARIANT   2
	Warning! Do not modify this file that is automatically generated! More...
#define	LIN_VARIANT   1
#define	NON_LINEAR   -1
#define	LSEC(x, i)   GetBoundary(x,i,1)
	accessing DAD components More...
#define	USEC(x, i)   GetBoundary(x,i,0)
#define	PUT_NEST(d, val)   context_info_nest(simple_section_context(comp_sec_hull(comp_desc_section(d)))) = val
#define	GET_NEST(d)   context_info_nest(simple_section_context(comp_sec_hull(comp_desc_section(d))))
#define	MAX_RANK   8
	only used for in print routines. More...
#define	LinExpr   Pvecteur
	A linear expression in Pips ; Pvecteur is a pointer. More...
#define	SEQUENTIAL_COMPSEC_SUFFIX   ".csec"
#define	USER_COMPSEC_SUFFIX   ".ucsec"

Typedefs
typedef unsigned int	tRT
	{{ Dad definition More...
typedef struct sSimpBound	tSS
	bounds are retained as high level tree structures to accommodate symbolic information in boundary expressions. More...
typedef struct DadComponent	DadComp
	Simple Section part of DAD An array of type SimpBound struct allocated dynamically based on rank of array. More...
typedef struct Variants	tVariants
	}} More...
typedef simple_section	tDad
	}} More...

Enumerations
enum	BoundType {   LOWER , UPPER , LOWER , UPPER ,   LOWER , UPPER }
	}} More...
enum	RefType {   READ , WRITE , READ , WRITE ,   READ , WRITE }
enum	NestType {   ZERO , SINGLE , MULTI , ZERO ,   SINGLE , MULTI , ZERO , SINGLE ,   MULTI }
enum	OpFlag {   PLUS , MINUS , PLUS , MINUS ,   PLUS , MINUS }
	used for merging linear expressions More...

Functions
bool	summary_complementary_sections (const char *)
	cproto-generated files More...
bool	complementary_sections (const char *)
bool	print_code_complementary_sections (const char *)
bool	local_comp_regions_map_undefined_p (void)
	propagate.c More...
void	set_local_comp_regions_map (statement_mapping)
statement_mapping	get_local_comp_regions_map (void)
void	reset_local_comp_regions_map (void)
void	free_local_comp_regions_map (void)
void	make_local_comp_regions_map (void)
list	load_statement_local_comp_regions (statement)
void	delete_statement_local_comp_regions (statement)
bool	statement_local_comp_regions_undefined_p (statement)
void	store_statement_local_comp_regions (statement, list)
void	update_statement_local_comp_regions (statement, list)
void	CheckStride (loop)
list	CompRegionsExactUnion (list, list, bool(*)(effect, effect))
list	CompRegionsMayUnion (list, list, bool(*)(effect, effect))
bool	comp_regions (const char *)
	}}} More...
list	comp_regions_of_statement (statement)
	}}} More...
list	comp_regions_of_instruction (instruction, transformer, transformer, list *)
	}}} More...
list	comp_regions_of_block (list)
	}}} More...
list	comp_regions_of_test (test, transformer, list *)
list	comp_regions_of_loop (loop, transformer, transformer, list *)
list	comp_regions_of_call (call, transformer, list *)
	}}} More...
list	comp_regions_of_unstructured (unstructured, transformer)
	}}} More...
list	comp_regions_of_range (range, transformer)
	}}} More...
list	comp_regions_of_syntax (syntax, transformer)
	}}} More...
list	comp_regions_of_expressions (list, transformer)
	}}} More...
list	comp_regions_of_expression (expression, transformer)
	{{{ comp_regions_of_expression More...
list	comp_regions_of_read (reference, transformer)
	}}} More...
list	comp_regions_of_write (reference, transformer)
	}}} More...
Pvecteur	my_vect_var_subst (Pvecteur, Variable, Pvecteur)
	ss.c More...
Pvecteur	my_vect_substract (Pvecteur, Pvecteur)
void	PrintCompRegions (list)
	}} More...
void	PrintLinExpr (Pvecteur)
	}} More...
void	PrintSimp (comp_desc)
	}} More...
void	DisplayDad (comp_desc)
void	DisplayRefTemp (simple_section)
	}} More...
void	DisplaySimpleSection (simple_section)
	}} More...
tag	GetRefTemp (simple_section, _int)
	}} More...
void	PutRefTemp (simple_section, int, tag)
	}} More...
Pvecteur	GetBoundary (simple_section, int, unsigned)
	}} More...
void	PutBoundPair (simple_section, _int, Pvecteur, Pvecteur)
	}} More...
Pvecteur	MinBoundary (Pvecteur, Pvecteur)
	}} More...
Pvecteur	MaxBoundary (Pvecteur, Pvecteur)
	}} More...
Pvecteur	MergeLinExprs (Pvecteur, Pvecteur, OpFlag)
	}} More...
unsigned int	ComputeIndex (unsigned int, unsigned int, unsigned int)
	}} More...
Pvecteur	CopyAccVec (Pvecteur)
	}} More...
bool	IsExprConst (Pvecteur)
	}} More...
bool	DivExists (loop, Pvecteur)
	check whether loop index variable var is contained in LinExpr More...
expression	GetAccVec (unsigned, const reference)
	return the n'th subscript expression More...
unsigned int	CardinalityOf (list)
dad_struct	AllocateDadStruct (int)
	}} More...
simple_section	AllocateSimpleSection (reference)
void	ScanAllDims (loop, comp_desc)
	}} More...
void	ComputeRTandSS (expression, unsigned, simple_section, loop)
	initialise reference template and shapes for inner most references More...
void	TranslateRefsToLoop (loop, list)
	}} More...
void	TranslateToLoop (loop, comp_desc)
	}} More...
tVariants	TransRefTemp (loop, comp_desc)
	}} More...
void	UpdateUnresolved (simple_section, loop)
	}} More...
void	ComputeBoundaries (simple_section, loop, Pvecteur, Pvecteur, unsigned)
	compute both boundary expression and store in the tSS array More...
void	TransSimpSec (comp_desc, loop, tVariants *)
Pvecteur	Lbound (loop, Pvecteur)
	}} More...
Pvecteur	Ubound (loop, Pvecteur)
simple_section	SimpUnion (simple_section, simple_section)
	}} More...
comp_desc	InitCompDesc (reference, tag)
	operators.c More...
comp_sec	CompUnion (comp_sec, comp_sec)
bool	CompIntersection (comp_sec, comp_sec)
list	comp_regions_of_intrinsic (entity, list, transformer)
	myintrinsics.c More...
list	proper_comp_regions_of_intrinsic (entity, list, transformer)
	}} More...
list	no_write_comp_regions (entity, list, transformer)
list	affect_comp_regions (entity, list, transformer)
list	io_comp_regions (entity, list, transformer)
	}} More...
list	comp_regions_of_ioelem (expression, tag, transformer)
	}} More...
list	comp_regions_of_iolist (list, tag, transformer)
	}} More...
list	comp_regions_of_implied_do (expression, tag, transformer)
	}} More...
comp_desc_set	list_to_comp_secs (list)
	dbase.c More...
list	comp_desc_set_to_list (comp_desc_set)
statement_mapping	listmap_to_compsecs_map (statement_mapping)
statement_mapping	comp_secs_map_to_listmap (statement_mapping)
list	comp_regions_dup (list)
	REGIONS AND LISTS OF REGIONS MANIPULATION More...
comp_desc	comp_region_dup (comp_desc)
list	comp_region_add_to_regions (comp_desc, list)
	void region_add_to_regions(region reg, list l_reg) input : a region and a list of regions. More...
text	get_text_comp_regions (const char *)
	prettyprint.c More...
bool	print_source_comp_regions (const char *)
bool	print_code_comp_regions (const char *)
text	text_all_comp_regions (list)
	}} More...
text	text_comp_regions (list)
	}} More...
text	text_comp_region (effect)
	}} More...

Macro Definition Documentation

GET_NEST

#define GET_NEST

(

d

)

context_info_nest(simple_section_context(comp_sec_hull(comp_desc_section(d))))

Definition at line 44 of file comp_sections.h.

LIN_INVARIANT

#define LIN_INVARIANT   2

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

Modify src/Libs/comp_sections/comp_sections-local.h instead, to add your own modifications. header file built by cproto comp_sections-local.h {{ defines classifying subscript types for reference template done in newgen now

Definition at line 36 of file comp_sections.h.

LIN_VARIANT

#define LIN_VARIANT   1

Definition at line 37 of file comp_sections.h.

LinExpr

#define LinExpr   Pvecteur

A linear expression in Pips ; Pvecteur is a pointer.

Definition at line 67 of file comp_sections.h.

LSEC

#define LSEC	(		x,
			i
	)		GetBoundary(x,i,1)

accessing DAD components

Definition at line 41 of file comp_sections.h.

MAX_RANK

#define MAX_RANK   8

only used for in print routines.

The analysis does not pose any limit on the number of array dimensions

Definition at line 58 of file comp_sections.h.

NON_LINEAR

#define NON_LINEAR   -1

Definition at line 38 of file comp_sections.h.

PUT_NEST

#define PUT_NEST	(		d,
			val
	)		context_info_nest(simple_section_context(comp_sec_hull(comp_desc_section(d)))) = val

Definition at line 43 of file comp_sections.h.

SEQUENTIAL_COMPSEC_SUFFIX

#define SEQUENTIAL_COMPSEC_SUFFIX   ".csec"

Definition at line 110 of file comp_sections.h.

USEC

#define USEC	(		x,
			i
	)		GetBoundary(x,i,0)

Definition at line 42 of file comp_sections.h.

USER_COMPSEC_SUFFIX

#define USER_COMPSEC_SUFFIX   ".ucsec"

Definition at line 111 of file comp_sections.h.

Typedef Documentation

DadComp

typedef struct DadComponent DadComp

Simple Section part of DAD An array of type SimpBound struct allocated dynamically based on rank of array.

tDad

typedef simple_section tDad

}}

}}

Definition at line 107 of file comp_sections.h.

tRT

typedef unsigned int tRT

{{ Dad definition

data structures for data access descriptor Reference Template part of DAD, an array of integers allocated dynamically

Definition at line 64 of file comp_sections.h.

tSS

typedef struct sSimpBound tSS

bounds are retained as high level tree structures to accommodate symbolic information in boundary expressions.

When all the symbolic information gets resolved then the tree nodes are collapsed into a single instruction holding the constant value

tVariants

typedef struct Variants tVariants

}}

{{ Data structures required for computing Dads {{ structures for TranslateToLoop structure to hold both Old and New variants

Enumeration Type Documentation

BoundType

enum BoundType

}}

Enumerator
LOWER
UPPER
LOWER
UPPER
LOWER
UPPER

Definition at line 48 of file comp_sections.h.

{LOWER, UPPER};

NestType

enum NestType

Enumerator
ZERO
SINGLE
MULTI
ZERO
SINGLE
MULTI
ZERO
SINGLE
MULTI

Definition at line 50 of file comp_sections.h.

{ZERO, SINGLE, MULTI};

OpFlag

enum OpFlag

used for merging linear expressions

Enumerator
PLUS
MINUS
PLUS
MINUS
PLUS
MINUS

Definition at line 53 of file comp_sections.h.

{ PLUS, MINUS} OpFlag;

RefType

enum RefType

Enumerator
READ
WRITE
READ
WRITE
READ
WRITE

Definition at line 49 of file comp_sections.h.

{READ, WRITE};

Function Documentation

affect_comp_regions()

list affect_comp_regions	(	entity	,
		list	,
		transformer
	)

AllocateDadStruct()

dad_struct AllocateDadStruct

(

int

Rank

)

}}

{{ allocate simple section allocate a structure to hold Dad

initialize the reference template

initialize the shape

Parameters

Rank

ank

Definition at line 440 of file ss.c.

{
  dad_struct Dad;
  bound_pair Bounds;
  int cnt;
  list RefTempList = NIL;
  list BoundList = NIL;
  rtype Ref = make_rtype(is_rtype_nonlinear, UU);
 
  /* initialize the reference template */
  for (cnt = 0; cnt < Rank; cnt++) {
    RefTempList = gen_nconc(RefTempList, 
                  CONS(REF_TEMP,make_ref_temp(cnt, Ref), NIL));
  }
 
  /* initialize the shape */
  for (cnt = 0; cnt < Rank * Rank; cnt++) {
    Bounds = make_bound_pair(cnt, NULL, NULL);
    BoundList = gen_nconc(BoundList, CONS(BOUND_PAIR, Bounds, NIL));
  }
 
  Dad = make_dad_struct(RefTempList, BoundList);
 
  return (Dad);
}

References BOUND_PAIR, CONS, gen_nconc(), is_rtype_nonlinear, make_bound_pair(), make_dad_struct(), make_ref_temp(), make_rtype(), NIL, Ref, REF_TEMP, and UU.

Referenced by AllocateSimpleSection().

Here is the call graph for this function:

Here is the caller graph for this function:

AllocateSimpleSection()

simple_section AllocateSimpleSection

(

reference

ref

)

{{ intialize the data structure

}}

Parameters

ref

ef

Definition at line 467 of file ss.c.

{
#define LINE 0
  unsigned int Rank;
  context_info Context;
  dad_struct DadStruct;
  simple_section Dad;
  variable TmpVar;
 
  TmpVar = type_variable(entity_type(reference_variable(ref)));
 
  /*{{{  intialize the data structure */
  Rank = CardinalityOf(variable_dimensions(TmpVar));
  Context = make_context_info(LINE, Rank, ZERO);
  DadStruct = AllocateDadStruct(Rank);
  Dad = make_simple_section(Context, DadStruct);
  /*}}}*/
  return (Dad);
}

References AllocateDadStruct(), CardinalityOf(), entity_type, LINE, make_context_info(), make_simple_section(), ref, reference_variable, type_variable, variable_dimensions, and ZERO.

Referenced by InitCompDesc().

Here is the call graph for this function:

Here is the caller graph for this function:

CardinalityOf()

unsigned int CardinalityOf

(

list

gl

)

re-used Pips functional programs !!!

Parameters

gl

l

Definition at line 428 of file ss.c.

{
  /* re-used Pips functional programs !!! */
  return gen_length(gl);
}

References gen_length().

Referenced by AllocateSimpleSection(), and TransSimpSec().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckStride()

void CheckStride

(

loop

)

comp_desc_set_to_list()

list comp_desc_set_to_list

(

comp_desc_set

cset

)

Parameters

cset

set

Definition at line 40 of file dbase.c.

{
    list l_res = comp_desc_set_comp_descs(cset);
    return l_res;
}

References comp_desc_set_comp_descs.

Referenced by comp_secs_map_to_listmap(), and get_any_comp_regions_text().

Here is the caller graph for this function:

comp_region_add_to_regions()

list comp_region_add_to_regions	(	comp_desc	reg,
		list	l_reg
	)

void region_add_to_regions(region reg, list l_reg) input : a region and a list of regions.

output : nothing. modifies : l_reg. comment : adds reg at the end of l_reg.

Parameters

reg	eg
l_reg	_reg

Definition at line 111 of file dbase.c.

{
    return gen_nconc(l_reg, CONS(COMP_DESC, reg, NIL));
}

References COMP_DESC, CONS, gen_nconc(), and NIL.

Referenced by comp_regions_dup().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_region_dup()

comp_desc comp_region_dup

(

comp_desc

reg

)

debug_region_consistency(reg);

work around persistency of comp_desc reference

Parameters

reg

eg

Definition at line 95 of file dbase.c.

{
    comp_desc new_reg;
    
    /* debug_region_consistency(reg); */
    new_reg = copy_comp_desc(reg);
    /* work around persistency of comp_desc reference */
    comp_desc_reference(new_reg) = copy_reference(comp_desc_reference(reg)); 
    return(new_reg);
}

References comp_desc_reference, copy_comp_desc(), and copy_reference().

Referenced by comp_regions_dup().

Here is the call graph for this function:

Here is the caller graph for this function:

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

list comp_regions_dup

(

list

l_reg

)

REGIONS AND LISTS OF REGIONS MANIPULATION

list comp_regions_dup(list l_reg) input : a list of comp_regions. output : a new list of regions, in which each region of the initial list is duplicated. modifies : nothing.

Parameters

l_reg

_reg

Definition at line 82 of file dbase.c.

{
    list l_reg_dup = NIL;
    
    MAP(COMP_DESC, reg,
    {
        comp_desc reg_dup = comp_region_dup(reg);
        l_reg_dup = comp_region_add_to_regions(reg_dup, l_reg_dup);
    }, l_reg);
    
    return(l_reg_dup);
}

References COMP_DESC, comp_region_add_to_regions(), comp_region_dup(), MAP, and NIL.

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_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_implied_do()

list comp_regions_of_implied_do	(	expression	exp,
		tag	act,
		transformer	context
	)

}}

{{ comp_regions_of_implied_do an implied do is a call to an intrinsic function named IMPLIED-DO; its first argument is the loop index, the second one is a range, and the remaining ones are expressions to be written or references to be read, or another implied_do (BA).

loop index

range

regions of implied do index it is must_written but may read because the implied loop might execute no iteration.

the loop index is must-written

Read effects are masked by the first write to the implied-do loop variable

regions of implied-loop bounds and increment

the preconditions of the current statement don't include those induced by the implied_do, because they are local to the statement. But we need them to properly calculate the regions. the solution is to add to the current context the preconditions due to the current implied_do (think of nested implied_do). the regions are calculated, and projected along the index. BA, September 27, 1993.

on a un autre implied_do imbrique'

indices are removed from regions because this is a loop

Parameters

exp	xp
act	ct
context	ontext

Definition at line 544 of file myintrinsics.c.

{
    list le, lep, lr, args;
    transformer local_context;
    expression arg1, arg2; 
    entity index;
    range r;
    reference ref;
 
    pips_assert("comp_regions_of_implied_do", expression_implied_do_p(exp));
 
    debug(5, "comp_regions_of_implied_do", "begin\n");
 
    args = call_arguments(syntax_call(expression_syntax(exp)));
    arg1 = EXPRESSION(CAR(args));       /* loop index */
    arg2 = EXPRESSION(CAR(CDR(args)));  /* range */
    
    pips_assert("comp_regions_of_implied_do", 
                syntax_reference_p(expression_syntax(arg1)));
 
    pips_assert("comp_regions_of_implied_do", 
                syntax_range_p(expression_syntax(arg2)));
 
 
    index = reference_variable(syntax_reference(expression_syntax(arg1)));
    ref = make_reference(index, NIL);
 
    r = syntax_range(expression_syntax(arg2));
 
    /* regions of implied do index 
     * it is must_written but may read because the implied loop 
     * might execute no iteration. 
     */
 
    le = comp_regions_of_write(ref, context); /* the loop index is must-written */
    /* Read effects are masked by the first write to the implied-do loop variable */
        
    /* regions of implied-loop bounds and increment */
    le = CompRegionsExactUnion(comp_regions_of_expression(arg2,context), le, 
                          effects_same_action_p);
 
 
    /* the preconditions of the current statement don't include those
     * induced by the implied_do, because they are local to the statement.
     * But we need them to properly calculate the regions.
     * the solution is to add to the current context the preconditions 
     * due to the current implied_do (think of nested implied_do).
     * the regions are calculated, and projected along the index.
     * BA, September 27, 1993.
     */
 
    local_context = transformer_dup(context);
    local_context = add_index_range_conditions(local_context, index, r, 
                                               transformer_undefined);
    transformer_arguments(local_context) = 
        arguments_add_entity(transformer_arguments(local_context), 
                             entity_to_new_value(index)); 
 
    ifdebug(7) {
        debug(7, "comp_regions_of_implied_do", "local context : \n%s\n", 
              precondition_to_string(local_context));
    }
 
    MAP(EXPRESSION, expr, 
        { 
            syntax s = expression_syntax(expr);
            
            if (syntax_reference_p(s))
                if (act == is_action_write) 
                    lep = comp_regions_of_write(syntax_reference(s),local_context);
                else
                    lep = comp_regions_of_expression(expr, local_context);
            else
                /* on a un autre implied_do imbrique' */
                lep = comp_regions_of_implied_do(expr, act, local_context);
            
            
            /* indices are removed from regions because this is a loop */
            lr = NIL;
            MAP(REGION, reg,
                {            
                    if (region_entity(reg) != index)
                        lr =  region_add_to_regions(reg,lr);
                    else
                    {
                        debug(5, "comp_regions_of_implied_do", "index removed");
                        region_free(reg);
                    }
                }, lep);
            gen_free_list(lep);
            le = CompRegionsExactUnion(le, lr, effects_same_action_p);
            
        }, CDR(CDR(args)));
    
    ifdebug(7) {
        debug(7, "comp_regions_of_implied_do", "regions before projection :\n");
        print_regions(le);
        fprintf(stderr, "\n");
    }
    
    project_regions_along_loop_index(le, 
                                     entity_to_new_value(index), 
                                     r);
 
    ifdebug(6) {
        debug(6, "comp_regions_of_implied_do", "regions after projection :\n");
        print_regions(le);
        fprintf(stderr, "\n");
    }
 
 
    transformer_free(local_context);
    local_context = transformer_undefined;
    
    debug(5, "comp_regions_of_implied_do", "end\n");
 
    return(le);
}

References add_index_range_conditions(), arguments_add_entity(), call_arguments, CAR, CDR, comp_regions_of_expression(), comp_regions_of_implied_do(), comp_regions_of_write(), CompRegionsExactUnion(), debug(), effects_same_action_p(), entity_to_new_value(), exp, EXPRESSION, expression_implied_do_p(), expression_syntax, fprintf(), gen_free_list(), ifdebug, is_action_write, make_reference(), MAP, NIL, pips_assert, precondition_to_string(), print_regions(), project_regions_along_loop_index(), ref, reference_variable, REGION, region_add_to_regions(), region_entity, region_free(), syntax_call, syntax_range, syntax_range_p, syntax_reference, syntax_reference_p, transformer_arguments, transformer_dup(), transformer_free(), and transformer_undefined.

Referenced by comp_regions_of_implied_do(), and comp_regions_of_iolist().

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

list comp_regions_of_intrinsic	(	entity	e,
		list	args,
		transformer	context
	)

myintrinsics.c

myintrinsics.c

{{ comp_regions_of_intrinsic list comp_regions_of_intrinsic(entity e, list args, transformer context) input : a intrinsic function name, the list or arguments, and the calling context. output : the corresponding list of regions. modifies : nothing. comment :

Parameters

args	rgs
context	ontext

Definition at line 270 of file myintrinsics.c.

{
    return (proper_comp_regions_of_intrinsic(e, args, context));
}

References proper_comp_regions_of_intrinsic().

Referenced by comp_regions_of_call().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_ioelem()

list comp_regions_of_ioelem	(	expression	exp,
		tag	act,
		transformer	context
	)

}}

{{ comp_regions_of_io_element ==============================================================================

Parameters

exp	xp
act	ct
context	ontext

Definition at line 461 of file myintrinsics.c.

{   
    list lr;
 
    debug(5, "comp_regions_of_io_elem", "begin\n");
    if (act == is_action_write) {
        syntax s = expression_syntax(exp);
 
        debug(6, "comp_regions_of_io_elem", "is_action_write\n");
        pips_assert("comp_regions_of_ioelem", syntax_reference_p(s));
 
        lr = comp_regions_of_write(syntax_reference(s), context);
    }
    else {  
        debug(6, "comp_regions_of_io_elem", "is_action_read\n");  
        lr = comp_regions_of_expression(exp, context);
    }   
 
    debug(5, "comp_regions_of_elem", "end\n");
 
    return(lr);
}

References comp_regions_of_expression(), comp_regions_of_write(), debug(), exp, expression_syntax, is_action_write, pips_assert, syntax_reference, and syntax_reference_p.

Referenced by io_comp_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

comp_regions_of_iolist()

list comp_regions_of_iolist	(	list	exprs,
		tag	act,
		transformer	context
	)

}}

{{ comp_regions_of_io_list ==============================================================================

There is a bug with effects of io list

READ *,N,(T(I),I=1,N)

there is write effect on N but for the io list, we don't have this effect !

Cause : there is no loop for the list exprs !!! /NN:2000/

Parameters

exprs	xprs
act	ct
context	ontext

Definition at line 489 of file myintrinsics.c.

{
  list le = NIL;
  debug(5, "comp_regions_of_io_list", "begin\n");
  while (!ENDP(exprs))
    {
      expression exp = EXPRESSION(CAR(exprs));
      list lep = NIL;
        
      /* There is a bug with effects of io list  
       
         READ *,N,(T(I),I=1,N)
 
         there is write effect on N but for the io list, 
         we don't have this effect !
       
         Cause : there is no loop for the list exprs !!! /NN:2000/ */
 
      if (expression_implied_do_p(exp)) {
        lep = comp_regions_of_implied_do(exp, act, context);
      }
      else {
        if (act == is_action_write) {
          syntax s = expression_syntax(exp);
 
          debug(6, "comp_regions_of_io_list", "is_action_write");
          pips_assert("comp_regions_of_iolist", syntax_reference_p(s));
          lep = comp_regions_of_write(syntax_reference(s), context);
        }
        else {  
          debug(6, "comp_regions_of_io_elem", "is_action_read");
          lep = comp_regions_of_expression(exp, context);
        }
      }
      
      le = CompRegionsExactUnion(le, lep, effects_same_action_p);
      
      exprs = CDR(exprs);
    }
 
  debug(5, "comp_regions_of_io_list", "end\n");
 
  return(le);
}

References CAR, CDR, comp_regions_of_expression(), comp_regions_of_implied_do(), comp_regions_of_write(), CompRegionsExactUnion(), debug(), effects_same_action_p(), ENDP, exp, EXPRESSION, expression_implied_do_p(), expression_syntax, is_action_write, NIL, pips_assert, syntax_reference, and syntax_reference_p.

Referenced by io_comp_regions().

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	,
		transformer	,
		transformer	,
		list *
	)

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	,
		transformer	,
		list *
	)

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:

comp_secs_map_to_listmap()

statement_mapping comp_secs_map_to_listmap

(

statement_mapping

compsecs_map

)

Parameters

compsecs_map

ompsecs_map

Definition at line 60 of file dbase.c.

{
    statement_mapping l_map = MAKE_STATEMENT_MAPPING();
    
    STATEMENT_MAPPING_MAP(s,val,{
        hash_put((hash_table) l_map, (char *) s, (char *) comp_desc_set_to_list((comp_desc_set) val));
    }, compsecs_map);
 
    return l_map;
}

References comp_desc_set_to_list(), hash_put(), MAKE_STATEMENT_MAPPING, and STATEMENT_MAPPING_MAP.

Referenced by get_any_comp_regions_text().

Here is the call graph for this function:

Here is the caller graph for this function:

CompIntersection()

bool CompIntersection	(	comp_sec	,
		comp_sec
	)

complementary_sections()

bool complementary_sections

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 40 of file comp_sections.c.

{
    comp_regions(module_name);
    return(true);
}

References comp_regions(), and module_name().

Here is the call graph for this function:

CompRegionsExactUnion()

list CompRegionsExactUnion	(	list	,
		list	,
		bool(*)(effect, effect)
	)

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

Here is the caller graph for this function:

CompRegionsMayUnion()

list CompRegionsMayUnion	(	list	,
		list	,
		bool(*)(effect, effect)
	)

CompUnion()

comp_sec CompUnion	(	comp_sec	,
		comp_sec
	)

ComputeBoundaries()

void ComputeBoundaries	(	simple_section	Dad,
		loop	Loop,
		Pvecteur	lbExpr,
		Pvecteur	ubExpr,
		unsigned	Offset
	)

compute both boundary expression and store in the tSS array

{{ about

}}

Parameters

Dad	ad
Loop	oop
lbExpr	bExpr
ubExpr	bExpr
Offset	ffset

Definition at line 765 of file ss.c.

{
  LinExpr Low, Up;
 
  Low = lbExpr;
  Up = ubExpr;
 
  /*{{{  about */
  if (DivExists(Loop, lbExpr))
    Low = Lbound(Loop, lbExpr);
  if (DivExists(Loop, ubExpr))
    Up = Ubound(Loop, ubExpr);
  PutBoundPair(Dad, Offset, Low, Up);
  /*}}}*/
}

References DivExists(), Lbound(), PutBoundPair(), and Ubound().

Referenced by TransSimpSec().

Here is the call graph for this function:

Here is the caller graph for this function:

ComputeIndex()

unsigned int ComputeIndex	(	unsigned int	I,
		unsigned int	J,
		unsigned int	Rank
	)

}}

{{ ComputeIndex compute index of tSS array for a boundary

Parameters

Rank

ank

Definition at line 362 of file ss.c.

{
  unsigned int LoIndex, HiIndex, Index, i;
 
  LoIndex = (I < J) ? I : J;
  HiIndex = (I < J) ? J : I;
  Index = 0;
  for (i = 1; i < (LoIndex + 1); i++)
    Index = Index + (Rank - i);
  Index = Index + (HiIndex - LoIndex) - 1;
  return (Index);
}

References Index.

Referenced by TransSimpSec(), and UpdateUnresolved().

Here is the caller graph for this function:

ComputeRTandSS()

void ComputeRTandSS	(	expression	Sub,
		unsigned	DimNo,
		simple_section	Dad,
		loop	Loop
	)

initialise reference template and shapes for inner most references

for an access vector

{{ non-linear

}}

{{ linear

copy the subscript expression into the shape descriptor

linear subscripts : update if DIV exists

}}

Parameters

Sub	ub
DimNo	imNo
Dad	ad
Loop	oop

Definition at line 524 of file ss.c.

{
  normalized Nexpr;
 
  Nexpr = NORMALIZE_EXPRESSION(Sub);
 
  if (!normalized_linear_p(Nexpr)) {
    /*{{{  non-linear */
    /*
     * non linear subscripts if it is non-linear we don't bother to
     * distinguish between invariant and variant ; they are just non-linear
     */
    PutRefTemp(Dad, DimNo, is_rtype_nonlinear);
    /*}}}*/
  } 
  else {
    LinExpr Low, Up;
 
    /*{{{  linear */
    /* copy the subscript expression into the shape descriptor */
    Low = CopyAccVec(normalized_linear(Nexpr));
    Up = CopyAccVec(normalized_linear(Nexpr));
 
    PutBoundPair(Dad, DimNo, Low, Up);
 
    if(IsExprConst(normalized_linear(Nexpr)) == true ) {
      PutRefTemp(Dad, DimNo, is_rtype_linvariant);
    }
    else {
    /* linear subscripts : update if DIV exists */
      if (DivExists(Loop, normalized_linear(Nexpr))) {
        Low = Lbound(Loop, LSEC(Dad, DimNo));
        Up = Ubound(Loop, USEC(Dad, DimNo));
        PutBoundPair(Dad, DimNo, Low, Up);
        PutRefTemp(Dad, DimNo, is_rtype_linvariant);
      }
      else {
         PutRefTemp(Dad, DimNo, is_rtype_lininvariant);
      }
    }
    /*}}}*/
  }
}

References CopyAccVec(), DivExists(), is_rtype_lininvariant, is_rtype_linvariant, is_rtype_nonlinear, IsExprConst(), Lbound(), LSEC, NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, PutBoundPair(), PutRefTemp(), Ubound(), and USEC.

Referenced by ScanAllDims().

Here is the call graph for this function:

Here is the caller graph for this function:

CopyAccVec()

Pvecteur CopyAccVec

(

LinExpr

Expr

)

}}

{{ CopyAccVec

re-used function from alloc.c

Parameters

Expr

xpr

Definition at line 378 of file ss.c.

{
  /* re-used function from alloc.c */
  return (vect_dup(Expr));
}

References vect_dup().

Referenced by ComputeRTandSS(), Lbound(), TransSimpSec(), and Ubound().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_statement_local_comp_regions()

void delete_statement_local_comp_regions

(

statement

)

DisplayDad()

void DisplayDad

(

comp_desc

TheDad

)

Parameters

TheDad

heDad

Definition at line 107 of file ss.c.

{
  entity Var = reference_variable(comp_desc_reference(TheDad));
  simple_section Dad = comp_sec_hull(comp_desc_section(TheDad));
 
  fprintf(stderr, "\nData Access Descriptor for %s \n", entity_minimal_name(Var));
 
  DisplayRefTemp(Dad);
  DisplaySimpleSection(Dad);
  fprintf(stderr, "\n");
 
}

References comp_desc_reference, comp_desc_section, comp_sec_hull, DisplayRefTemp(), DisplaySimpleSection(), entity_minimal_name(), fprintf(), and reference_variable.

Referenced by PrintSimp().

Here is the call graph for this function:

Here is the caller graph for this function:

DisplayRefTemp()

void DisplayRefTemp

(

simple_section

Dad

)

}}

{{ DisplayRefTemp

Parameters

Dad

ad

Definition at line 123 of file ss.c.

{
  unsigned Rank;
  unsigned int i;
  tag RefType = tag_undefined;
 
  Rank = context_info_rank(simple_section_context(Dad));
 
  fprintf(stderr, "\nReference Template :: \n[ ");
  for (i = 0; i < Rank; i++) {
    RefType = GetRefTemp(Dad, i);
    switch (RefType) {
    case is_rtype_lininvariant:
      fprintf(stderr, "INV");
      break;
    case is_rtype_linvariant:
      fprintf(stderr, "VAR");
      break;
    case is_rtype_nonlinear:
      fprintf(stderr, "NON");
      break;
    default:
      fprintf(stderr, "NUL");
      break;
    }
 
    if (i < (Rank - 1))
      fprintf(stderr, ", ");
    else
      fprintf(stderr, " ]\n");
  }
  fprintf(stderr, "\n");
}

References context_info_rank, fprintf(), GetRefTemp(), is_rtype_lininvariant, is_rtype_linvariant, is_rtype_nonlinear, simple_section_context, and tag_undefined.

Referenced by DisplayDad().

Here is the call graph for this function:

Here is the caller graph for this function:

DisplaySimpleSection()

void DisplaySimpleSection

(

simple_section

Dad

)

}}

{{ DisplaySimpSec

{{ xi = c

}}

{{ Xi+Xj = c

{{ print

}}

{{ index

}}

}}

{{ Xi-Xj

}}

Parameters

Dad

ad

Definition at line 161 of file ss.c.

{
  unsigned int i, I, J, K;
  unsigned Rank = context_info_rank(simple_section_context(Dad));
 
  fprintf(stderr, "\nBoundary Pairs ::\n");
  /*{{{  xi = c */
 
  for (i = 0; i < Rank; i++) {
    PrintLinExpr(LSEC(Dad, i));
    fprintf(stderr, "                <= X%d         <= ", i);
    PrintLinExpr(USEC(Dad, i));
    fprintf(stderr, "\n");
  }
  /*}}}*/
 
  /*{{{  Xi+Xj = c */
  I = 0;
  K = Rank - I - 2;
  J = I + 1;
  for (; i < ((Rank * (Rank + 1)) / 2); i++) {
    /*{{{  print */
    PrintLinExpr(LSEC(Dad, i));
    fprintf(stderr, "            <= X%d + X%d       <= ", I, J);
    PrintLinExpr(USEC(Dad, i));
    fprintf(stderr, "\n");
    /*}}}*/
    /*{{{  index */
    if (K < 1) {
      I += 1;
      J = I + 1;
      K = Rank - I - 2;
    } else {
      K -= 1;
      J += 1;
    }
    /*}}}*/
  }
  /*}}}*/
  /*{{{  Xi-Xj */
  I = 0;
  K = Rank - I - 2;
  J = I + 1;
  for (; i < (Rank * Rank); i++) {
    PrintLinExpr(LSEC(Dad, i));
    fprintf(stderr, "            <= X%d - X%d       <= ", I, J);
    PrintLinExpr(USEC(Dad, i));
    fprintf(stderr, "\n");
    if (K < 1) {
      I += 1;
      J = I + 1;
      K = Rank - I - 2;
    } else {
      K -= 1;
      J += 1;
    }
  }
  /*}}}*/
 
  fprintf(stderr, "\n");
 
}

References context_info_rank, fprintf(), LSEC, PrintLinExpr(), simple_section_context, and USEC.

Referenced by DisplayDad().

Here is the call graph for this function:

Here is the caller graph for this function:

DivExists()

bool DivExists	(	loop	Loop,
		Pvecteur	Lin
	)

check whether loop index variable var is contained in LinExpr

Parameters

Loop	oop
Lin	in

Definition at line 396 of file ss.c.

{
  entity ent;
  Pvecteur Vec;
  bool Val;
 
  ent = loop_index(Loop);
  Vec = (Pvecteur) Lin;
  Val = vect_contains_variable_p(Vec, (Variable) ent);
  return (Val);
 
}

References loop_index, Val, and vect_contains_variable_p().

Referenced by ComputeBoundaries(), ComputeRTandSS(), TransRefTemp(), and UpdateUnresolved().

Here is the call graph for this function:

Here is the caller graph for this function:

free_local_comp_regions_map()

void free_local_comp_regions_map

(

void

)

Referenced by comp_regions(), and get_any_comp_regions_text().

Here is the caller graph for this function:

get_local_comp_regions_map()

statement_mapping get_local_comp_regions_map

(

void

)

Referenced by comp_regions().

Here is the caller graph for this function:

get_text_comp_regions()

text get_text_comp_regions

(

const char *

module_name

)

prettyprint.c

prettyprint.c

Parameters

module_name

odule_name

Definition at line 72 of file prettyprint.c.

{
    is_user_view_p = false;
    in_out_comp_regions_p = false;
 
    return get_any_comp_regions_text(module_name,
                                DBR_REGIONS,
                                DBR_SUMMARY_REGIONS,
                                false);
}

References get_any_comp_regions_text(), in_out_comp_regions_p, is_user_view_p, and module_name().

Here is the call graph for this function:

GetAccVec()

expression GetAccVec	(	unsigned	No,
		const	reference
	)

return the n'th subscript expression

Parameters

No	o
reference	ef

Definition at line 411 of file ss.c.

{
  unsigned Cur = 0;
  list inds = reference_indices(ref);
 
  MAP(EXPRESSION, index,
      {
    if (Cur == No)
      return (index);
    Cur++;
  }, inds);
 
  return (NULL);
 
}

References EXPRESSION, MAP, ref, and reference_indices.

Referenced by TransRefTemp().

Here is the caller graph for this function:

GetBoundary()

Pvecteur GetBoundary	(	simple_section	Dad,
		int	DimNo,
		unsigned	Low
	)

}}

{{ GetBoundaryPair return the lower or upper boundary

Parameters

Dad	ad
DimNo	imNo
Low	ow

Definition at line 266 of file ss.c.

{
  list BoundPair = dad_struct_shape(simple_section_dad(Dad));
  LinExpr Lin = NULL;
 
  MAP(BOUND_PAIR, bp,
  {
    if (bound_pair_index(bp) == DimNo) {
      if (Low == 1) {
        Lin = bound_pair_lb(bp);
      } else {
        Lin = bound_pair_ub(bp);
      }
      break;
    }
  }, BoundPair);
 
  return(Lin);
}

References BOUND_PAIR, bound_pair_index, bound_pair_lb, bound_pair_ub, dad_struct_shape, MAP, and simple_section_dad.

GetRefTemp()

tag GetRefTemp	(	simple_section	Dad,
		_int	DimNo
	)

}}

}} {{ auxilliary functions {{ GetRefTemp

Parameters

Dad	ad
DimNo	imNo

Definition at line 229 of file ss.c.

{
  list Rtemp = dad_struct_rtemps(simple_section_dad(Dad));
  tag ret_tag = tag_undefined;
 
  FOREACH(REF_TEMP, Ref, Rtemp)
      {
          if (ref_temp_index(Ref) == DimNo) {
             ret_tag = rtype_tag(ref_temp_rtype(Ref));
             break;
          }
  }
 
  return(ret_tag);
}

References dad_struct_rtemps, FOREACH, Ref, REF_TEMP, ref_temp_index, ref_temp_rtype, rtype_tag, simple_section_dad, and tag_undefined.

Referenced by DisplayRefTemp(), SimpUnion(), TransRefTemp(), and UpdateUnresolved().

Here is the caller graph for this function:

InitCompDesc()

comp_desc InitCompDesc	(	reference	ref,
		tag	ReadWrite
	)

operators.c

operators.c

precondition : this function should be called for array varaibles only

{{ code

{{ inits

}}

{{ code

}}

}}

Parameters

ref	ef
ReadWrite	eadWrite

Definition at line 30 of file operators.c.

{
  /* precondition : this function should be called
     for array varaibles only
  */
 
  /*{{{  code*/
  /*{{{  inits*/
  comp_desc Descriptor;
  simple_section Hull;
  reference DupRef;
  entity e;
  action DupAct;
  comp_sec DupSec;
  /*}}}*/
  
  pips_debug(3, "begin\n");
  DupRef = copy_reference(ref);
 
  e = reference_variable(DupRef);
  
  /*{{{  code*/
  if (entity_scalar_p(e)) {
    pips_debug(1, "InitCompDesc : scalar variable encountered \n ");
    return NULL;
  }
  
  pips_debug(3, "InitCompDesc : Array entity name %s \n ",func_entity_name(e) );
           
  Hull = AllocateSimpleSection(DupRef);
  DupAct = make_action(ReadWrite, UU);
  DupSec = make_comp_sec(Hull, NIL);
  Descriptor = make_comp_desc (DupRef, DupAct, DupSec) ;              
  /*}}}*/
  pips_debug(3, "end\n");
  
  return(Descriptor);
  /*}}}*/
}

References AllocateSimpleSection(), copy_reference(), entity_scalar_p(), func_entity_name(), make_action(), make_comp_desc(), make_comp_sec(), NIL, pips_debug, ref, reference_variable, and UU.

Referenced by comp_regions_of_read(), and comp_regions_of_write().

Here is the call graph for this function:

Here is the caller graph for this function:

io_comp_regions()

list io_comp_regions	(	entity	e,
		list	args,
		transformer	context
	)

}}

{{ io_comp_regions

regions effects on logical units - taken from effects/io.c

We simulate actions on files by read/write actions to a static integer array GO: It is necessary to do a read and and write action to the array, because it updates the file-pointer so it reads it and then writes it ...

Parameters

args	rgs
context	ontext

Definition at line 378 of file myintrinsics.c.

{
    list le = NIL, pc, lep;
 
    debug(5, "io_comp_regions", "begin\n");
 
    for (pc = args; pc != NIL; pc = CDR(pc)) {
        IoElementDescriptor *p;
        entity ci;
        syntax s = expression_syntax(EXPRESSION(CAR(pc)));
 
        pips_assert("io_comp_regions", syntax_call_p(s));
 
        ci = call_function(syntax_call(s));
        p = SearchIoElement(entity_local_name(e), entity_local_name(ci));
 
        pc = CDR(pc);
 
        if (strcmp(p->IoElementName, "IOLIST=") == 0) {
            lep = comp_regions_of_iolist(pc, p->ReadOrWrite, context);
        }
        else {
            lep = comp_regions_of_ioelem(EXPRESSION(CAR(pc)), 
                                    p->ReadOrWrite, context);
        }
 
        if (p->MayOrMust == is_approximation_may) 
        {
            MAP(REGION, reg, 
            {
                approximation_tag(effect_approximation(reg)) = 
                    is_approximation_may;
            }, lep);
        }
 
        le = CompRegionsExactUnion(le, lep, effects_same_action_p);
 
        /* regions effects on logical units - taken from effects/io.c */
        if ((get_bool_property ("PRETTYPRINT_IO_EFFECTS")) &&
            (pc != NIL) &&
            (strcmp(p->IoElementName, "UNIT=") == 0))
        {
            /* We simulate actions on files by read/write actions
               to a static integer array 
               GO:
               It is necessary to do a read and and write action to
               the array, because it updates the file-pointer so
               it reads it and then writes it ...*/
            entity private_io_entity;
            reference ref;
            list indices = NIL;
 
            indices = gen_nconc(indices,
                                CONS(EXPRESSION,
                                     EXPRESSION(CAR(pc)),NIL));
 
            private_io_entity = FindEntity(TOP_LEVEL_MODULE_NAME,
                 IO_EFFECTS_ARRAY_NAME);
 
            pips_assert("regions_effects", private_io_entity != entity_undefined);
 
            ref = make_reference(private_io_entity,indices);
            le = CompRegionsExactUnion(le, 
                                 comp_regions_of_read(ref, context), 
                                 effects_same_action_p);
            le = CompRegionsExactUnion(le, 
                                 comp_regions_of_write(ref, context), 
                                 effects_same_action_p);
            
        }
        
    }
 
    debug(5, "io_comp_regions", "end\n");
 
    return(le);
}    

References approximation_tag, call_function, CAR, CDR, comp_regions_of_ioelem(), comp_regions_of_iolist(), comp_regions_of_read(), comp_regions_of_write(), CompRegionsExactUnion(), CONS, debug(), effect_approximation, effects_same_action_p(), entity_local_name(), entity_undefined, EXPRESSION, expression_syntax, FindEntity(), gen_nconc(), get_bool_property(), indices, IO_EFFECTS_ARRAY_NAME, IoElementDescriptor::IoElementName, is_approximation_may, make_reference(), MAP, IoElementDescriptor::MayOrMust, NIL, pips_assert, IoElementDescriptor::ReadOrWrite, ref, REGION, SearchIoElement(), syntax_call, syntax_call_p, and TOP_LEVEL_MODULE_NAME.

Here is the call graph for this function:

IsExprConst()

bool IsExprConst

(

LinExpr

Expr

)

}}

check whether a given expresion is a constant

Parameters

Expr

xpr

Definition at line 388 of file ss.c.

{
  return (vect_constant_p(Expr));
}

References vect_constant_p().

Referenced by ComputeRTandSS(), and UpdateUnresolved().

Here is the call graph for this function:

Here is the caller graph for this function:

Lbound()

Pvecteur Lbound	(	loop	Loop,
		LinExpr	Lin
	)

}}

}} {{ lbound and ubound

only one step in pips ! it provides direct substitution functions

{{ substitution step

substitute with lower bound

substitute with upper bound

make a copy because vect_var_subst modifies NewVect

}}

Parameters

Loop	oop
Lin	in

Definition at line 910 of file ss.c.

{
  /*
   * preconditions : lbound is invoked only if DivExists and if only on
   * LinExprs
   */
 
  expression TmpExpr;
  normalized Nexpr;
  LinExpr NewLin, NewVect;
  entity Var = loop_index(Loop);
 
  /* only one step in pips ! it provides direct substitution functions */
  /*{{{  substitution step */
  /*
   * use the lower/upper bound of the index variable depending on the sign of
   * the coefficient
   */
  /*
   * this needs to be changed if the representation for linear expression is
   * changed to accommodate symbolic coefficients
   */
 
  int Val = vect_coeff((Variable) Var, Lin);
  if ((Val > 0)) {
    /* substitute with lower bound */
    TmpExpr = range_lower(loop_range(Loop));
  } else {
    /* substitute with upper bound */
    TmpExpr = range_upper(loop_range(Loop));
  }
 
  Nexpr  = NORMALIZE_EXPRESSION(TmpExpr);
  if (normalized_linear_p(Nexpr)) {
      /* make a copy because vect_var_subst modifies NewVect */
     NewVect = CopyAccVec(normalized_linear(Nexpr));     
     NewLin = my_vect_var_subst(Lin, (Variable) Var, NewVect);
  }
  else {
     NewLin = NULL;
  }
 
  /*}}}*/
  return (NewLin);
}

References CopyAccVec(), loop_index, loop_range, my_vect_var_subst(), NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, range_lower, range_upper, Val, and vect_coeff().

Referenced by ComputeBoundaries(), ComputeRTandSS(), and UpdateUnresolved().

Here is the call graph for this function:

Here is the caller graph for this function:

list_to_comp_secs()

comp_desc_set list_to_comp_secs

(

list

l_eff

)

dbase.c

dbase.c

---

---

Parameters

l_eff

_eff

Definition at line 33 of file dbase.c.

{
    comp_desc_set res = make_comp_desc_set(l_eff);
    return res;
}

References make_comp_desc_set().

Referenced by listmap_to_compsecs_map().

Here is the call graph for this function:

Here is the caller graph for this function:

listmap_to_compsecs_map()

statement_mapping listmap_to_compsecs_map

(

statement_mapping

l_map

)

Parameters

l_map

_map

Definition at line 47 of file dbase.c.

{
    statement_mapping comp_secs_map = MAKE_STATEMENT_MAPPING();
    
    STATEMENT_MAPPING_MAP(s,val,
      {
        hash_put((hash_table) comp_secs_map, (char *) s, (char *) list_to_comp_secs((list) val));
    }, l_map);
 
    return comp_secs_map;
}

References hash_put(), list_to_comp_secs(), MAKE_STATEMENT_MAPPING, and STATEMENT_MAPPING_MAP.

Referenced by comp_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

load_statement_local_comp_regions()

list load_statement_local_comp_regions

(

statement

)

Referenced by text_statement_array_comp_regions().

Here is the caller graph for this function:

local_comp_regions_map_undefined_p()

bool local_comp_regions_map_undefined_p

(

void

)

propagate.c

make_local_comp_regions_map()

void make_local_comp_regions_map

(

void

)

MaxBoundary()

Pvecteur MaxBoundary	(	LinExpr	Lin1,
		LinExpr	Lin2
	)

}}

{{ MaxBoundary substitute with new boundary

Parameters

Lin1	in1
Lin2	in2

Definition at line 335 of file ss.c.

{
  int Result;
 
  Result = vect_compare(&Lin1, &Lin2);
  if (Result > 0)
    return (vect_dup(Lin1));
  else
    return (vect_dup(Lin2));
}

References vect_compare(), and vect_dup().

Referenced by SimpUnion().

Here is the call graph for this function:

Here is the caller graph for this function:

MergeLinExprs()

Pvecteur MergeLinExprs	(	LinExpr	Expr1,
		LinExpr	Expr2,
		OpFlag	Op
	)

}}

{{ MergeLinExprs

must free Expr1 because vect_add will return a copy : check later

Parameters

Expr1	xpr1
Expr2	xpr2
Op	p

Definition at line 349 of file ss.c.

{
  /* must free Expr1 because vect_add will return a copy : check later */
  if (Op == PLUS)
    return (vect_add(Expr1, Expr2));
  else
    return (my_vect_substract(Expr1, Expr2));
}

References my_vect_substract(), PLUS, and vect_add().

Referenced by TransSimpSec(), and UpdateUnresolved().

Here is the call graph for this function:

Here is the caller graph for this function:

MinBoundary()

Pvecteur MinBoundary	(	LinExpr	Lin1,
		LinExpr	Lin2
	)

}}

{{ MinBoundary substitute with new boundary

Parameters

Lin1	in1
Lin2	in2

Definition at line 320 of file ss.c.

{
  int Result;
 
  Result = vect_compare(&Lin1, &Lin2);
  if (Result < 0)
    return (vect_dup(Lin1));
  else
    return (vect_dup(Lin2));
}

References vect_compare(), and vect_dup().

Referenced by SimpUnion().

Here is the call graph for this function:

Here is the caller graph for this function:

my_vect_substract()

Pvecteur my_vect_substract	(	Pvecteur	pvec1,
		Pvecteur	pvec2
	)

Pvecteur var_val; for (var_val = pvec2; var_val!= NIL; vect_add_elem (&dvec,var_of(var_val),-val_of(var_val)),var_val=var_val->succ);

Parameters

pvec1	vec1
pvec2	vec2

Definition at line 50 of file ss.c.

{
        int coeff;
        Pvecteur dvec = vect_dup (pvec1);
/*      Pvecteur var_val;
        for (var_val = pvec2; var_val!= NIL; 
            vect_add_elem (&dvec,var_of(var_val),-val_of(var_val)),var_val=var_val->succ);
            */
 
        Pvecteur v2 = pvec2;
        for ( ; v2!= NULL; v2=v2->succ) {
          coeff = 0-(val_of(v2));
          vect_add_elem (&dvec,var_of(v2), coeff);
        }
        
        return (dvec);
}

References Svecteur::succ, val_of, var_of, vect_add_elem(), and vect_dup().

Referenced by MergeLinExprs().

Here is the call graph for this function:

Here is the caller graph for this function:

my_vect_var_subst()

Pvecteur my_vect_var_subst	(	Pvecteur	vect,
		Variable	var,
		Pvecteur	new_vect
	)

ss.c

ss.c

mimicked this function from paf-tuil/utils.c because it was misbehaving !!

Parameters

vect	ect
var	ar
new_vect	ew_vect

Definition at line 35 of file ss.c.

{
 Pvecteur    vect_aux;
 Value       val;
 
 if ((val = vect_coeff(var,vect)) != 0)
    {
     vect_erase_var(&vect,var);
     vect_aux = vect_multiply(new_vect,val);
     vect = vect_add(vect, vect_aux);
    }
 
 return(vect);
}

References vect_add(), vect_aux, vect_coeff(), vect_erase_var(), and vect_multiply().

Referenced by Lbound(), and Ubound().

Here is the call graph for this function:

Here is the caller graph for this function:

no_write_comp_regions()

list no_write_comp_regions	(	entity	,
		list	,
		transformer
	)

print_code_comp_regions()

bool print_code_comp_regions

(

const char *

)

Referenced by print_code_complementary_sections().

Here is the caller graph for this function:

print_code_complementary_sections()

bool print_code_complementary_sections

(

const char *

module_name

)

Parameters

module_name

odule_name

Definition at line 46 of file comp_sections.c.

{
    print_code_comp_regions(module_name);
    return(true);
}

References module_name(), and print_code_comp_regions().

Here is the call graph for this function:

print_source_comp_regions()

bool print_source_comp_regions

(

const char *

)

PrintCompRegions()

void PrintCompRegions

(

list

CompList

)

}}

{{ PrintSimpleSection {{ PrintCompRegions

Parameters

CompList

ompList

Definition at line 74 of file ss.c.

{
  if (CompList != NIL) {
    MAP(COMP_DESC, Cdesc,
        {
      PrintSimp(Cdesc);
    }, CompList);
  }
}

References COMP_DESC, MAP, NIL, and PrintSimp().

Referenced by comp_regions_of_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

PrintLinExpr()

void PrintLinExpr

(

LinExpr

Lin

)

}}

{{ PrintLinExpr

call the approprite print routine : check later

Parameters

Lin

in

Definition at line 87 of file ss.c.

{
  /* call the approprite print routine : check later */
  if (Lin != NULL)
    vect_debug(Lin);
  else
    fprintf(stderr, "NULL");
}

References fprintf(), and vect_debug().

Referenced by DisplaySimpleSection(), and PutBoundPair().

Here is the call graph for this function:

Here is the caller graph for this function:

PrintSimp()

void PrintSimp

(

comp_desc

Dad

)

}}

{{ PrintSimp

Parameters

Dad

ad

Definition at line 99 of file ss.c.

{
  fprintf(stderr, "*********************************************************************\n");
  DisplayDad(Dad);
  fprintf(stderr, "---------------------------------------------------------------------\n");
}

References DisplayDad(), and fprintf().

Referenced by PrintCompRegions().

Here is the call graph for this function:

Here is the caller graph for this function:

proper_comp_regions_of_intrinsic()

list proper_comp_regions_of_intrinsic	(	entity	e,
		list	args,
		transformer	context
	)

}}

{{ proper_comp_regions_of_intrinsic list proper_comp_regions_of_intrinsic(entity e, list args, transformer context) input : a intrinsic function name, the list or arguments, and the calling context. output : the corresponding list of regions. modifies : nothing. comment :

Parameters

args	rgs
context	ontext

Definition at line 286 of file myintrinsics.c.

{
    const char* s = entity_local_name(e);
    IntrinsicEffectDescriptor *pid = IntrinsicDescriptorTable;
    list lr;
 
    debug(3, "proper_comp_regions_of_intrinsic", "begin\n");
 
    while (pid->name != NULL) {
        if (strcmp(pid->name, s) == 0) {
                lr = (*(pid->f))(e, args, context);
                      debug(3, "proper_comp_regions_of_intrinsic", "end\n");
                return(lr);
            }
 
        pid += 1;
    }
 
    pips_internal_error("unknown intrinsic %s", s);
 
    return(NIL);
}

References debug(), entity_local_name(), IntrinsicEffectDescriptor::f, IntrinsicDescriptorTable, IntrinsicEffectDescriptor::name, NIL, and pips_internal_error.

Referenced by comp_regions_of_intrinsic().

Here is the call graph for this function:

Here is the caller graph for this function:

PutBoundPair()

void PutBoundPair	(	simple_section	Dad,
		_int	DimNo,
		LinExpr	Low,
		LinExpr	Up
	)

}}

{{ PutBoundryPair substitute with new boundary

check later vect_rm(bound_pair_lb(bp));

check later vect_rm(bound_pair_ub(bp));

Parameters

Dad	ad
DimNo	imNo
Low	ow
Up	p

Definition at line 290 of file ss.c.

{
  list BoundPair = dad_struct_shape(simple_section_dad(Dad));
 
  ifdebug(5) {
    pips_debug(5, "PutBoundPair : dump Low and Up vectors \n");
    PrintLinExpr(Low);
    PrintLinExpr(Up);
  }
 
  MAP(BOUND_PAIR, bp,
      {
    if (bound_pair_index(bp) == DimNo) {
      if (Low != NULL) {
          /* check later vect_rm(bound_pair_lb(bp));  */
          bound_pair_lb_(bp) = (Pvecteur) Low;
      }
      if (Up != NULL) {
          /* check later vect_rm(bound_pair_ub(bp)); */
          bound_pair_ub_(bp) = (Pvecteur) Up;
      }
      return;
    }
  }, BoundPair);
}

References BOUND_PAIR, bound_pair_index, bound_pair_lb_, bound_pair_ub_, dad_struct_shape, ifdebug, MAP, pips_debug, PrintLinExpr(), and simple_section_dad.

Referenced by ComputeBoundaries(), ComputeRTandSS(), SimpUnion(), and UpdateUnresolved().

Here is the call graph for this function:

Here is the caller graph for this function:

PutRefTemp()

void PutRefTemp	(	simple_section	Dad,
		int	DimNo,
		tag	Val
	)

}}

{{ PutRefTemp

Parameters

Dad	ad
DimNo	imNo
Val	al

Definition at line 248 of file ss.c.

{
  list Rtemp = dad_struct_rtemps(simple_section_dad(Dad));
 
  MAP(REF_TEMP, rt,
      {
    if (ref_temp_index(rt) == DimNo) {
      rtype_tag(ref_temp_rtype(rt)) = Val;
      return;
    }
  }, Rtemp);
 
}

References dad_struct_rtemps, MAP, REF_TEMP, ref_temp_index, ref_temp_rtype, rtype_tag, simple_section_dad, and Val.

Referenced by ComputeRTandSS(), SimpUnion(), and TransRefTemp().

Here is the caller graph for this function:

reset_local_comp_regions_map()

void reset_local_comp_regions_map

(

void

)

ScanAllDims()

void ScanAllDims	(	loop	Loop,
		comp_desc	Desc
	)

}}

{{ translate inner most references

{{ init RT and SS

}}

Parameters

Loop	oop
Desc	esc

Definition at line 490 of file ss.c.

{
  /*
   * unfortunately an access vector cannot tell to which dimension it
   * corresponds hence this round about of explicitly tracking the dimension
   * number
   */
  unsigned int DimNo;
  expression exp_ind;
  simple_section Dad;
  reference ref;
  list inds;
 
  pips_debug(3, "begin\n");
 
  Dad = comp_sec_hull(comp_desc_section(Desc));
  ref = comp_desc_reference(Desc);
 
  inds = reference_indices(ref);
 
  for (DimNo = 0; inds != NIL; DimNo++, inds = CDR(inds)) {
    /*{{{  init RT and SS */
    exp_ind = EXPRESSION(CAR(inds));
    ComputeRTandSS(exp_ind, DimNo, Dad, Loop);
    /*}}}*/
  }
 
  pips_debug(3, "end\n");
 
}

References CAR, CDR, comp_desc_reference, comp_desc_section, comp_sec_hull, ComputeRTandSS(), EXPRESSION, NIL, pips_debug, ref, and reference_indices.

Referenced by TranslateToLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

set_local_comp_regions_map()

void set_local_comp_regions_map

(

statement_mapping

)

Referenced by comp_regions(), and get_any_comp_regions_text().

Here is the caller graph for this function:

SimpUnion()

simple_section SimpUnion	(	simple_section	S1,
		simple_section	S2
	)

}}

{{ SimpUnion

SG: i am unsure this is a valid init

allocate a simple_section

{{ update reference template

update reference template

if a subscript is invariant or boundary expression is not constant

then whole dimension is assumed to be used

}}

{{ update simple sections

scan all boundary pairs

later insert code for releasing the space of LSEC and USEC

compute new lower boundary in the union

compute new upper boundary in the union

}}

Parameters

S1	1
S2	2

Definition at line 1013 of file ss.c.

{
/* SG: i am unsure this is a valid init */
  simple_section UnionDad = make_simple_section(context_info_undefined,make_dad_struct(NIL,NIL));
  tag Variant;
  size_t i;
  LinExpr Low = NULL, Up = NULL;
  size_t Rank = context_info_rank(simple_section_context(S1));
 
  /* allocate a simple_section */
 
  /*{{{  update reference template */
  /* update reference template */
  /* if a subscript is invariant or boundary expression is not constant */
  /* then whole dimension is assumed to be used */
  for (i = 0; i < Rank; i++) {
    Variant = ((GetRefTemp(S1, i) == is_rtype_linvariant) &&
               (GetRefTemp(S2, i) == is_rtype_linvariant)) ?
      is_rtype_linvariant : is_rtype_nonlinear;
    PutRefTemp(UnionDad, i, Variant);
  }
  /*}}}*/
  /*{{{  update simple sections */
  /* scan all boundary pairs */
  for (i = 0; i < (Rank * Rank); i++) {
    /* later insert code for releasing the space of LSEC and USEC */
    if ((LSEC(S1, i) != NULL) && (LSEC(S2, i) != NULL)) {
      /* compute new lower boundary in the union */
      Low = MinBoundary(LSEC(S1, i), LSEC(S2, i));
    }
    if ((USEC(S1, i) != NULL) && (USEC(S2, i) != NULL)) {
      /* compute new upper boundary in the union */
      Up = MaxBoundary(USEC(S1, i), USEC(S2, i));
    }
    PutBoundPair(UnionDad, i, Low, Up);
  }
  /*}}}*/
 
  return (UnionDad);
}

References context_info_rank, context_info_undefined, GetRefTemp(), is_rtype_linvariant, is_rtype_nonlinear, LSEC, make_dad_struct(), make_simple_section(), MaxBoundary(), MinBoundary(), NIL, PutBoundPair(), PutRefTemp(), simple_section_context, and USEC.

Here is the call graph for this function:

statement_local_comp_regions_undefined_p()

bool statement_local_comp_regions_undefined_p

(

statement

)

store_statement_local_comp_regions()

void store_statement_local_comp_regions	(	statement	,
		list
	)

Referenced by comp_regions_of_statement().

Here is the caller graph for this function:

summary_complementary_sections()

bool summary_complementary_sections

(

const char *

module_name

)

cproto-generated files

comp_sections.c

cproto-generated files

}}

omp_global_regions(module_name);

Parameters

module_name

odule_name

Definition at line 31 of file comp_sections.c.

{
    /*comp_global_regions(module_name);*/
    DB_PUT_MEMORY_RESOURCE(DBR_SUMMARY_COMPSEC,
                        strdup(module_name),
                      (char*) make_comp_desc_set(NIL));
    return(true);
}

References DB_PUT_MEMORY_RESOURCE, make_comp_desc_set(), module_name(), NIL, and strdup().

Here is the call graph for this function:

text_all_comp_regions()

text text_all_comp_regions

(

list

l_reg

)

}}

{{ text all comp_regions text text_all_comp_regions(list l_reg) input : a list of comp_regions output : a text representing this list (with non-array comp_regions)

Parameters

l_reg

_reg

Definition at line 329 of file prettyprint.c.

{
    text reg_text = make_text(NIL);
 
    MAP(EFFECT, reg,
    {
        MERGE_TEXTS(reg_text, text_region(reg));
    },
        l_reg);
    return(reg_text);
}

References EFFECT, make_text(), MAP, MERGE_TEXTS, NIL, and text_region().

Here is the call graph for this function:

text_comp_region()

text text_comp_region

(

effect

reg

)

}}

{{ text region text text_region(effect reg) input : a region output : a text consisting of several lines of commentaries, representing the region modifies : nothing

Parameters

reg

eg

Definition at line 375 of file prettyprint.c.

{
    text t_reg = make_text(NIL);
    bool foresys = get_bool_property("PRETTYPRINT_FOR_FORESYS");
    string str_prefix;
 
    if (foresys)
        str_prefix = REGION_FORESYS_PREFIX;
    else
        str_prefix = PIPS_NORMAL_PREFIX;
    
    if(reg == effect_undefined)
    {
        ADD_SENTENCE_TO_TEXT(t_reg, 
                             make_pred_commentary_sentence(strdup("<REGION_UNDEFINED>"),
                                                           str_prefix));
        user_log("[region_to_string] unexpected effect undefined\n");
    }
    else
    {
        free_text(t_reg);
        t_reg = words_predicate_to_commentary(words_effect(reg), str_prefix);
    }
 
    return(t_reg);   
}

References ADD_SENTENCE_TO_TEXT, effect_undefined, free_text(), get_bool_property(), make_pred_commentary_sentence(), make_text(), NIL, PIPS_NORMAL_PREFIX, REGION_FORESYS_PREFIX, strdup(), user_log(), words_effect(), and words_predicate_to_commentary().

Referenced by text_comp_regions().

Here is the call graph for this function:

Here is the caller graph for this function:

text_comp_regions()

text text_comp_regions

(

list

l_reg

)

}}

{{ text comp_regions text text_comp_regions(list l_reg) input : a list of comp_regions output : a text representing this list (with non-array comp_regions)

change later

Parameters

l_reg

_reg

Definition at line 347 of file prettyprint.c.

{
 
    text reg_text = make_text(NIL);
  /* change later */
    return(reg_text);
 
    MAP(EFFECT, reg,
    {
        entity ent = effect_entity(reg);
        if (! entity_scalar_p(ent)) 
        {           
            MERGE_TEXTS(reg_text, text_comp_region(reg));
        }       
    },
        l_reg);       
 
   return(reg_text);
}

References EFFECT, effect_entity(), entity_scalar_p(), make_text(), MAP, MERGE_TEXTS, NIL, and text_comp_region().

Here is the call graph for this function:

TranslateRefsToLoop()

void TranslateRefsToLoop	(	loop	ThisLoop,
		list	ListOfComps
	)

}}

{{ translate to outer loop comp list {{ translate the set to the outer loop

Parameters

ThisLoop	hisLoop
ListOfComps	istOfComps

Definition at line 577 of file ss.c.

{
  MAP(COMP_DESC, Desc,
      {
    TranslateToLoop(ThisLoop, Desc);
  }, ListOfComps);
 
}

References COMP_DESC, MAP, and TranslateToLoop().

Referenced by comp_regions_of_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

TranslateToLoop()

void TranslateToLoop	(	loop	ThisLoop,
		comp_desc	Desc
	)

}}

{{ translate to loop

Parameters

ThisLoop	hisLoop
Desc	esc

Definition at line 589 of file ss.c.

{
  tVariants Vars;
  simple_section Dad;
 
  if (GET_NEST(Desc) == ZERO)  {
    ScanAllDims(ThisLoop, Desc);
    PUT_NEST(Desc,SINGLE);
  }
  else  {
    Vars  = TransRefTemp(ThisLoop, Desc);
    TransSimpSec(Desc, ThisLoop, &Vars);
    PUT_NEST(Desc,MULTI);
  }
 
  Dad = comp_sec_hull(comp_desc_section(Desc));
  UpdateUnresolved(Dad, ThisLoop); 
 
}

References comp_desc_section, comp_sec_hull, GET_NEST, MULTI, PUT_NEST, ScanAllDims(), SINGLE, TransRefTemp(), TransSimpSec(), UpdateUnresolved(), and ZERO.

Referenced by TranslateRefsToLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

TransRefTemp()

tVariants TransRefTemp	(	loop	ThisLoop,
		comp_desc	Desc
	)

}}

{{ TransRefTemp

iterate through all entries of reference template

process only linear elements

Pass only normalized expression into Divexists

variant w.r.t this loop index

Parameters

ThisLoop	hisLoop
Desc	esc

Definition at line 612 of file ss.c.

{
  tVariants Vars;
  simple_section Dad;
  _int DimNo, Rank;
  normalized Nexpr;
  expression TmpExpr;
  list OldList, NewList, NewEle;
 
  
  comp_sec Csec = comp_desc_section(Desc);
  reference Ref = comp_desc_reference(Desc);
 
  Dad = comp_sec_hull(Csec);
  Rank = context_info_rank(simple_section_context(Dad));
 
  pips_debug(3, "begin\n");
 
  OldList = NIL;
  NewList = NIL;
 
  /* iterate through all entries of reference template */
  for (DimNo = 0; DimNo < Rank; DimNo++) {
    /* process only linear elements */
    if (!(GetRefTemp(Dad, DimNo) == is_rtype_nonlinear)) {
      /* Pass only normalized expression into Divexists */
      TmpExpr = GetAccVec(DimNo, Ref);
      Nexpr = NORMALIZE_EXPRESSION(TmpExpr);
 
      if (DivExists(ThisLoop,  normalized_linear(Nexpr))) {
        /* variant w.r.t this loop index */
        NewEle = CONS(INT, DimNo, NIL);
        NewList = gen_nconc(NewList, NewEle);
        PutRefTemp(Dad, DimNo, is_rtype_linvariant);
      } else {
        /*
         * invariant w.r.t. this loop index; but variant w.r.t. previous loop
         * constant subscripts will also get included in the old list
         */
        if (GetRefTemp(Dad, DimNo) == is_rtype_linvariant)
          OldList =  gen_nconc(OldList, CONS(INT, DimNo, NIL));
      }
    }
  }
 
  Vars.Old = OldList;
  Vars.New = NewList;
 
  pips_debug(3, "end\n");
  return (Vars);
}

References comp_desc_reference, comp_desc_section, comp_sec_hull, CONS, context_info_rank, DivExists(), gen_nconc(), GetAccVec(), GetRefTemp(), INT, is_rtype_linvariant, is_rtype_nonlinear, Variants::New, NIL, NORMALIZE_EXPRESSION, normalized_linear, Variants::Old, pips_debug, PutRefTemp(), Ref, and simple_section_context.

Referenced by TranslateToLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

TransSimpSec()

void TransSimpSec	(	comp_desc	Desc,
		loop	Loop,
		tVariants *	Vars
	)

{{ declarations

}}

{{ Diagonal Boundaries for old and new

{{ compute offset in the tSS array to store diagonal boundaries

}}

{{ compute diagonal boundaries Xi + Xj

compute index for tSS array

copying done inside MergeLinExprs lbExpr = CopyAccVec(LSEC(Dad, I)); TmpExpr1 = CopyAccVec(LSEC(Dad, J));

ubExpr = CopyAccVec(USEC(Dad, I)); TmpExpr2 = CopyAccVec(USEC(Dad, J));

}}

{{ compute diagonal boundaries Xi - Xj

compute index for tSS array

}}

}}

{{ Compute parallel boundaries only for new variants

{{ compute Xi = c

bug unsigned Offset = J;

}}

}}

{{ Compute diagonal boundaries for new variants

set size must be atleast 2

{{ compute diagonals

set an iterator for the newvar

{{ iterators 1 and 2

set this iterator to next element in the first list

}}

{{ compute index for storing in tSS array

}}

{{ compute diagonal boundary Xi + Xj

}}

{{ compute diagonal boundary Xi - Xj

}}

}}

}}

Parameters

Desc	esc
Loop	oop
Vars	ars

Definition at line 782 of file ss.c.

{
  /*{{{  declarations */
  unsigned Index, Offset;
  LinExpr lbExpr, ubExpr, TmpExpr1, TmpExpr2;
 
  simple_section Dad = comp_sec_hull(comp_desc_section(Desc));
  unsigned Rank = context_info_rank(simple_section_context(Dad));
  list Old = Vars->Old;
  list New = Vars->New;
  /*}}}*/
 
  pips_debug(3, "begin\n");
 
  /*{{{  Diagonal Boundaries for old and new */
  MAP(INT, I,
      {
    MAP(INT, J,
        {
      /*{{{  compute offset in the tSS array  to store diagonal boundaries */
      Index = ComputeIndex(I, J, Rank);
      /*}}}*/
      /*{{{  compute diagonal boundaries Xi + Xj */
      /* compute index for tSS array */
      Offset = Rank + Index;
      /* copying done inside MergeLinExprs 
      lbExpr = CopyAccVec(LSEC(Dad, I));
      TmpExpr1 = CopyAccVec(LSEC(Dad, J));
      */
      lbExpr = LSEC(Dad, I);
      TmpExpr1 = LSEC(Dad, J);
      lbExpr = MergeLinExprs(lbExpr, TmpExpr1, PLUS);
      /* 
      ubExpr = CopyAccVec(USEC(Dad, I));
      TmpExpr2 = CopyAccVec(USEC(Dad, J));
      */
      ubExpr = USEC(Dad, I);
      TmpExpr2 = USEC(Dad, J);
      ubExpr = MergeLinExprs(ubExpr, TmpExpr2, PLUS);
      ComputeBoundaries(Dad, Loop, lbExpr, ubExpr, Offset);
      /*}}}*/
      /*{{{  compute diagonal boundaries Xi - Xj */
      /* compute index for tSS array */
      Offset = (Rank * (Rank + 1)) / 2 + Index;
      /*
      lbExpr = CopyAccVec(LSEC(Dad, I));
      TmpExpr1 = CopyAccVec(USEC(Dad, J));
      */
      lbExpr = LSEC(Dad, I);
      TmpExpr1 = USEC(Dad, J);
      lbExpr = MergeLinExprs(lbExpr, TmpExpr1, MINUS);
      /*
      ubExpr = CopyAccVec(USEC(Dad, I));
      TmpExpr2 = CopyAccVec(LSEC(Dad, J));
      */
      ubExpr = USEC(Dad, I);
      TmpExpr2 = LSEC(Dad, J);
      ubExpr = MergeLinExprs(ubExpr, TmpExpr2, MINUS);
      ComputeBoundaries(Dad, Loop, lbExpr, ubExpr, Offset);
      /*}}}*/
    }, New);
  }, Old);
  /*}}}*/
  /*{{{  Compute parallel boundaries only for new variants */
  MAP(INT, J,
      {
    /*{{{  compute Xi = c */
          /* bug unsigned Offset = J; */
    lbExpr = CopyAccVec(LSEC(Dad, J));
    ubExpr = CopyAccVec(USEC(Dad, J));
    ComputeBoundaries(Dad, Loop, lbExpr, ubExpr, J);
    /*}}}*/
  }, New);
  /*}}}*/
  /*{{{  Compute diagonal boundaries for new variants */
  /* set size must be atleast 2 */
  if (CardinalityOf(New) > 1) {
    int I, J;
 
    /*{{{  compute diagonals */
    /* set an  iterator for the newvar */
    list New_iter1;
    list New_iter2;
    New_iter1 = Vars->New;
    for (; !ENDP(New_iter1); (New_iter1 = CDR(New_iter1))) {
      /*{{{  iterators 1 and 2 */
      I = INT(CAR(New_iter1));
      /* set this iterator to next element in the first list */
      New_iter2 = CDR(New_iter1);
      /*}}}*/
      for (; !ENDP(New_iter2); New_iter2 = CDR(New_iter2)) {
        J = INT(CAR(New_iter2));
        /*{{{  compute index for storing in tSS array */
        Index = ComputeIndex(I, J, Rank);
        /*}}}*/
        /*{{{  compute diagonal boundary Xi + Xj */
        Offset = Rank + Index;
        TmpExpr1 = LSEC(Dad, J);
        lbExpr = MergeLinExprs(LSEC(Dad, I), TmpExpr1, PLUS);
        TmpExpr2 = USEC(Dad, J);
        ubExpr = MergeLinExprs(USEC(Dad, I), TmpExpr2, PLUS);
        ComputeBoundaries(Dad, Loop, lbExpr, ubExpr, Offset);
        /*}}}*/
        /*{{{  compute diagonal boundary Xi - Xj */
        Offset = ((Rank * (Rank + 1)) / 2) + Index;
        TmpExpr1 = USEC(Dad, J);
        lbExpr = MergeLinExprs(LSEC(Dad, I), TmpExpr1, MINUS);
        TmpExpr2 = LSEC(Dad, J);
        ubExpr = MergeLinExprs(USEC(Dad, I), TmpExpr2, MINUS);
        ComputeBoundaries(Dad, Loop, lbExpr, ubExpr, Offset);
        /*}}}*/
      }
    }
    /*}}}*/
  }
  /*}}}*/
 
  pips_debug(3, "end\n");
}

References CAR, CardinalityOf(), CDR, comp_desc_section, comp_sec_hull, ComputeBoundaries(), ComputeIndex(), context_info_rank, CopyAccVec(), ENDP, Index, INT, LSEC, MAP, MergeLinExprs(), MINUS, Variants::New, New, Variants::Old, pips_debug, PLUS, simple_section_context, and USEC.

Referenced by TranslateToLoop().

Here is the call graph for this function:

Here is the caller graph for this function:

Ubound()

Pvecteur Ubound	(	loop	Loop,
		Pvecteur	Lin
	)

only one step in pips ! it provides direct substitution functions

{{ substitution step

substitute with lower bound

substitute with upper bound

make a copy because vect_var_subst modifies NewVect

}}

Parameters

Loop	oop
Lin	in

Definition at line 961 of file ss.c.

{
  /*
   * preconditions : Ubound is invoked only if DivExists and only on LinExprs
   */
  expression TmpExpr;
  LinExpr NewLin, NewVect;  
  normalized Nexpr;
 
  entity Var = loop_index(Loop);
 
  /* only one step in pips ! it provides direct substitution functions */
  /*{{{  substitution step */
  /*
   * use the lower/upper bound of the index variable depending on the sign of
   * the coefficient
   */
  /*
   * this needs to be changed if the representation for linear expression is
   * changed to accommodate symbolic coefficients
   */
 
  int Val = vect_coeff((Variable) Var, Lin);
  if ((Val < 0)) {
    /* substitute with lower bound */
    TmpExpr = range_lower(loop_range(Loop));
  } else {
    /* substitute with upper bound */
    TmpExpr = range_upper(loop_range(Loop));
  }
 
  Nexpr  = NORMALIZE_EXPRESSION(TmpExpr);
  if (normalized_linear_p(Nexpr) ) {
     /* make a copy because vect_var_subst modifies NewVect */
     NewVect = CopyAccVec(normalized_linear(Nexpr));     
     NewLin = my_vect_var_subst(Lin, (Variable) Var, NewVect);
  }
  else {
     NewLin = NULL;
  }
 
  /*}}}*/
  return (NewLin);
}

References CopyAccVec(), loop_index, loop_range, my_vect_var_subst(), NORMALIZE_EXPRESSION, normalized_linear, normalized_linear_p, range_lower, range_upper, Val, and vect_coeff().

Referenced by ComputeBoundaries(), ComputeRTandSS(), and UpdateUnresolved().

Here is the call graph for this function:

Here is the caller graph for this function:

update_statement_local_comp_regions()

void update_statement_local_comp_regions	(	statement	,
		list
	)

UpdateUnresolved()

void UpdateUnresolved	(	simple_section	Dad,
		loop	Loop
	)

}}

{{ TransSimpSec

{{ declarations

}}

{{ Update unresolved boundaries

{{ update parallel or diagonal boundaries with induction variable

{{ scan all dimensions

ComputeBoundaries(Dad, Loop, lbExpr, ubExpr, ZhiExprNo);

}}

}}

{{ update diagonal boundaries whose parallel components are constants

{{ process only linear subscripts

{{ compute index

}}

{{ update diagonals

{{ update Xi + Xj

lower boundary

bug fix : check boundary otherwise it will get overwritten

{{ update

copy done in MergeLinExpr lbExpr = CopyAccVec(LSEC(Dad, I));

LSEC(Dad,PlusOffset) = lbExpr;

}}

upper boundary

{{ update

USEC(PlusOffset) = ubExpr;

}}

}}

{{ update Xi - Xj

lower boundary

{{ upate

lbExpr = CopyAccVec(LSEC(J));

LSEC(MinusOffset) = lbExpr;

}}

upper boundary

{{ update

ubExpr = CopyAccVec(USEC(J));

USEC(MinusOffset) = ubExpr;

}}

}}

}}

}}

}}

}}

Parameters

Dad	ad
Loop	oop

Definition at line 667 of file ss.c.

{
  /*{{{  declarations */
  unsigned Index, I, J;
  LinExpr lbExpr, ubExpr;
  unsigned ZhiExprNo;
  unsigned Rank = context_info_rank(simple_section_context(Dad));
  /*}}}*/
  /*{{{  Update unresolved boundaries */
  /*{{{  update parallel or diagonal boundaries with induction variable */
  if (Loop != NULL) {
    /*{{{  scan all dimensions */
    for (ZhiExprNo = 0; ZhiExprNo < Rank; ZhiExprNo++) {
      lbExpr = LSEC(Dad, ZhiExprNo);
      ubExpr = USEC(Dad, ZhiExprNo);
      if (DivExists(Loop, lbExpr))
        lbExpr = Lbound(Loop, lbExpr);
      if (DivExists(Loop, ubExpr))
        ubExpr = Ubound(Loop, ubExpr);
      PutBoundPair(Dad, ZhiExprNo, lbExpr, ubExpr);
 
      /* ComputeBoundaries(Dad, Loop, lbExpr, ubExpr, ZhiExprNo); */
 
    }
    /*}}}*/
  }
  /*}}}*/
  /*{{{  update diagonal boundaries whose parallel components are constants */
  for (I = 0; I < Rank; I++) {
    for (J = I + 1; J < Rank; J++) {
      if ((GetRefTemp(Dad, I) != is_rtype_nonlinear) && (GetRefTemp(Dad, J) != is_rtype_nonlinear)) {
        /*{{{  process only linear subscripts */
        /*{{{  compute index */
        int PlusOffset, MinusOffset;
        Index = ComputeIndex(I, J, Rank);
        PlusOffset = Rank + Index;
        MinusOffset = ((Rank * (Rank + 1)) / 2) + Index;
        /*}}}*/
        /*{{{  update diagonals */
        /*{{{  update Xi + Xj */
        /* lower boundary */
        /* bug fix : check boundary otherwise it will get overwritten */
        if (LSEC(Dad, PlusOffset) == NULL) {
          /*{{{  update */
          if (IsExprConst(LSEC(Dad, I)) && IsExprConst(LSEC(Dad, J))) {
            /* copy done in MergeLinExpr lbExpr = CopyAccVec(LSEC(Dad, I)); */
            lbExpr = MergeLinExprs(LSEC(Dad, I), LSEC(Dad, J), PLUS);
            /* LSEC(Dad,PlusOffset) = lbExpr; */
            PutBoundPair(Dad, PlusOffset, lbExpr, NULL);
          }
          /*}}}*/
        }
        /* upper boundary */
        if (USEC(Dad, PlusOffset) == NULL) {
          /*{{{  update */
          if (IsExprConst(USEC(Dad, I)) && IsExprConst(USEC(Dad, J))) {
            ubExpr = MergeLinExprs(USEC(Dad, I), USEC(Dad, J), PLUS);
            /* USEC(PlusOffset) = ubExpr; */
            PutBoundPair(Dad, PlusOffset, NULL, ubExpr);
          }
          /*}}}*/
        }
        /*}}}*/
        /*{{{  update Xi - Xj */
        /* lower boundary */
        if (LSEC(Dad, MinusOffset) == NULL) {
          /*{{{  upate */
          if (IsExprConst(LSEC(Dad, J)) && IsExprConst(USEC(Dad, I))) {
            /* lbExpr = CopyAccVec(LSEC(J)); */
            lbExpr = MergeLinExprs(LSEC(Dad, J), USEC(Dad, I),  MINUS);
            /* LSEC(MinusOffset) = lbExpr; */
            PutBoundPair(Dad, MinusOffset, lbExpr, NULL);
          }
          /*}}}*/
        }
        /* upper boundary */
        if (USEC(Dad, MinusOffset) == NULL) {
          /*{{{  update */
          if (IsExprConst(USEC(Dad, J)) && IsExprConst(LSEC(Dad, I))) {
            /* ubExpr = CopyAccVec(USEC(J)); */
            ubExpr = MergeLinExprs(USEC(Dad, J), LSEC(Dad, I), MINUS);
            /* USEC(MinusOffset) = ubExpr; */
            PutBoundPair(Dad, MinusOffset, NULL, ubExpr);
          }
          /*}}}*/
        }
        /*}}}*/
        /*}}}*/
        /*}}}*/
      }
    }
  }
  /*}}}*/
  /*}}}*/
}

References ComputeIndex(), context_info_rank, DivExists(), GetRefTemp(), Index, is_rtype_nonlinear, IsExprConst(), Lbound(), LSEC, MergeLinExprs(), MINUS, PLUS, PutBoundPair(), simple_section_context, Ubound(), and USEC.

Referenced by TranslateToLoop().

Here is the call graph for this function:

Here is the caller graph for this function: