ss.c File Reference

#include "all.h"

Include dependency graph for ss.c:

Go to the source code of this file.

Macros
#define	LINE   0

Functions
Pvecteur	my_vect_var_subst (Pvecteur vect, Variable var, Pvecteur new_vect)
	{{ my vect var subst function More...
Pvecteur	my_vect_substract (Pvecteur pvec1, Pvecteur pvec2)
void	PrintCompRegions (list CompList)
	}} More...
void	PrintLinExpr (LinExpr Lin)
	}} More...
void	PrintSimp (comp_desc Dad)
	}} More...
void	DisplayDad (comp_desc TheDad)
void	DisplayRefTemp (simple_section Dad)
	}} More...
void	DisplaySimpleSection (simple_section Dad)
	}} More...
tag	GetRefTemp (simple_section Dad, _int DimNo)
	}} More...
void	PutRefTemp (simple_section Dad, int DimNo, tag Val)
	}} More...
LinExpr	GetBoundary (simple_section Dad, int DimNo, unsigned Low)
	}} More...
void	PutBoundPair (simple_section Dad, _int DimNo, LinExpr Low, LinExpr Up)
	}} More...
LinExpr	MinBoundary (LinExpr Lin1, LinExpr Lin2)
	}} More...
LinExpr	MaxBoundary (LinExpr Lin1, LinExpr Lin2)
	}} More...
LinExpr	MergeLinExprs (LinExpr Expr1, LinExpr Expr2, OpFlag Op)
	}} More...
unsigned int	ComputeIndex (unsigned int I, unsigned int J, unsigned int Rank)
	}} More...
LinExpr	CopyAccVec (LinExpr Expr)
	}} More...
bool	IsExprConst (LinExpr Expr)
	}} More...
bool	DivExists (loop Loop, LinExpr Lin)
	check whether loop index variable var is contained in LinExpr More...
expression	GetAccVec (unsigned No, const reference ref)
	return the n'th subscript expression More...
unsigned int	CardinalityOf (list gl)
dad_struct	AllocateDadStruct (int Rank)
	}} More...
simple_section	AllocateSimpleSection (reference ref)
void	ScanAllDims (loop Loop, comp_desc Desc)
	}} More...
void	ComputeRTandSS (expression Sub, unsigned DimNo, simple_section Dad, loop Loop)
	initialise reference template and shapes for inner most references More...
void	TranslateRefsToLoop (loop ThisLoop, list ListOfComps)
	}} More...
void	TranslateToLoop (loop ThisLoop, comp_desc Desc)
	}} More...
tVariants	TransRefTemp (loop ThisLoop, comp_desc Desc)
	}} More...
void	UpdateUnresolved (simple_section Dad, loop Loop)
	}} More...
void	ComputeBoundaries (simple_section Dad, loop Loop, LinExpr lbExpr, LinExpr ubExpr, unsigned Offset)
	compute both boundary expression and store in the tSS array More...
void	TransSimpSec (comp_desc Desc, loop Loop, tVariants *Vars)
LinExpr	Lbound (loop Loop, LinExpr Lin)
	}} More...
LinExpr	Ubound (loop Loop, LinExpr Lin)
simple_section	SimpUnion (simple_section S1, simple_section S2)
	}} More...

Macro Definition Documentation

LINE

#define LINE   0

Function Documentation

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:

ComputeBoundaries()

void ComputeBoundaries	(	simple_section	Dad,
		loop	Loop,
		LinExpr	lbExpr,
		LinExpr	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()

LinExpr 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:

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,
		LinExpr	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:

GetAccVec()

expression GetAccVec	(	unsigned	No,
		const reference	ref
	)

return the n'th subscript expression

Parameters

No	o
ref	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()

LinExpr 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:

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

LinExpr 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:

MaxBoundary()

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

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

LinExpr 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
	)

{{ my vect var subst function

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:

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:

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:

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:

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:

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

LinExpr Ubound	(	loop	Loop,
		LinExpr	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:

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: