SAPFOR/Sapfor/projects/dvm/fdvm/trunk/InlineExpansion/inline.h

#include "user.h"

#define MAXTAGS 1000
#include "dvm_tag.h"


#ifdef IN_M_
#define EXTERN
#else
#define EXTERN extern
#endif

struct graph_node {
       int id;   //a number of node
       graph_node *next;
       graph_node *next_header_node; //???
       graph_node *Inext;
       SgFile *file;      
       SgStatement *st_header;
       SgSymbol *symb;              //??? st_header->symbol()
       struct edge *to_called;    //outcoming
       struct edge *from_calling; //incoming
       int split;     //flag
       int tmplt;     //flag
       int visited;   //flag for partition algorithm
       int clone;    //flag is clone node
       int count;    //counter of inline expansions
};

struct graph_node_list { 
       graph_node_list *next;
       graph_node *node;
};

struct edge {
       edge *next;
       graph_node *from;
       graph_node *to;
       int inlined; //1 - inlined, 0 - not inlined
};

struct edge_list {
       edge_list *next;
       edge *edg;
};


struct block_list {
       block_list *next;
       block_list *same_name;
       SgExpression *block;
};


struct distribute_list {
       distribute_list *next;
       SgStatement *stdis;
};

struct stmt_list {
       stmt_list *next;
       SgStatement *st;
};

struct label_list {
       label_list *next;
       SgLabel *lab;
       SgLabel *newlab;
};

struct dist_symb_list {
       dist_symb_list *next;
       SgSymbol *symb;
};


struct align {
       SgSymbol * symb;
       align * next;
       align * alignees;
       SgStatement * align_stmt;
};
struct mod_attr{
       SgSymbol *symb;
       SgSymbol *symb_list;
};
struct algn_attr {
       int type;
       align *ref;
};
struct rem_var {
       int index;
       int amv;
       int ncolon;
};
struct rem_acc {
       SgExpression *rml;
       SgStatement *rmout;
       int rmbuf_use[5];
       rem_acc *next;
};
struct group_name_list {
       group_name_list *next;
       SgSymbol *symb;
};
struct symb_list {
       symb_list *next;
       SgSymbol *symb;
};
struct base_list {
       base_list *next;
       SgSymbol *type_symbol;
       SgSymbol *base_symbol;
};
struct D_do_list {
       D_do_list *next;
       int No;
       int num_line;
       SgLabel *end_lab;
       SgSymbol *do_var;
};
struct interval_list {
       interval_list *prev;
       int No;
       SgStatement *begin_st;
};
struct D_fragment {
       D_fragment *next;
       int No;
};

struct fragment_list {
       int No;
       SgStatement *begin_st;
       int dlevel;
       int elevel;
       int dlevel_spec;
       int elevel_spec;
       fragment_list *next;
};
struct fragment_list_in {
       int N1;
       int N2;
       int level;
       fragment_list_in *next;
};
struct reduction_list {
       reduction_list *next;
       int red_op;
       SgExpression *red_var;
       int ind;
};
struct IND_ref_list {
       IND_ref_list *next;
       SgExpression *rmref;
       SgExpression *axis[7];
       SgExpression *coef[7];
       SgExpression *cons[7];
       int nc;
       int ind;
};

struct coeffs {
       SgSymbol *sc[10];
       int use;
};

struct heap_pointer_list {
       heap_pointer_list *next;
       SgSymbol *symb_heap;
       SgSymbol *symb_p;
};

struct filename_list {
       filename_list *next;
       char *name;
       SgSymbol *fns;
};

const int ROOT = 1;
const int NODE = 2;
const int GRAPH_NODE   = 1000;
const int PRE_BOUND = 1001;
const int CONSTANT_MAP = 1002;
const int ARRAY_MAP = 1003;
const int ARRAY_MAP_1 = 1004;
const int ARRAY_MAP_2 = 1005;
const int ADJUSTABLE_ = 1006;

const int MAX_INTRINSIC_NUM =300;

const int MAX_LOOP_LEVEL = 10; // 7 - maximal number of loops in parallel loop nest 
const int MAX_LOOP_NEST = 25;  // maximal number of nested loops
const int MAX_FILE_NUM = 100;  // maximal number of file reference in procedure
const int SIZE_IO_BUF = 262144; //4185600;   // IO buffer size in elements
const int ANTIDEP = 0;
const int FLOWDEP = 1;
#define FICT_INT  2000000000            /* -2147483648  0x7FFFFFFFL*/

//enum{ Integer, Real, Double, Complex, Logical, DoubleComplex};
enum {UNIT_,FMT_,REC_,ERR_,IOSTAT_,END_,NML_,EOR_,SIZE_,ADVANCE_};
enum {U_,FILE_,STATUS_,ER_,IOST_,ACCESS_,FORM_,RECL_,BLANK_,EXIST_,
OPENED_,NUMBER_,NAMED_,NAME_,SEQUENTIAL_,DIRECT_,NEXTREC_,FORMATTED_,
UNFORMATTED_,POSITION_,ACTION_,READWRITE_,READ_,WRITE_,DELIM_,PAD_};

enum {ICHAR, CHAR,INT,IFIX,IDINT,FLOAT,REAL,SNGL,DBLE,CMPLX,DCMPLX,AINT,DINT,ANINT,DNINT,NINT,IDNINT,ABS,IABS,DABS,CABS,
      MOD,AMOD,DMOD, SIGN,ISIGN, DSIGN, DIM,IDIM,DDIM, MAX,MAX0, AMAX1,DMAX1, AMAX0,MAX1, MIN,MIN0,
      AMIN1,DMIN1,AMIN0,MIN1,LEN,INDEX,AIMAG,DIMAG,CONJG,DCONJG,SQRT,DSQRT,CSQRT,EXP,DEXP,CEXP,LOG,ALOG,DLOG,CLOG,
      LOG10,ALOG10,DLOG10,SIN,DSIN,CSIN,COS,DCOS,CCOS,TAN,DTAN,ASIN,DASIN,ACOS,DACOS,ATAN,DATAN,
      ATAN2,DATAN2,SINH,DSINH,COSH,DCOSH,TANH,DTANH, LGE,LGT,LLE,LLT};
//universal: ANINT,NINT,ABS,  MOD,SIGN,DIM,MAX,MIN,SQRT,EXP,LOG,LOG10,SIN,COS,TAN,ASIN,ACOS,ATAN,ATAN2,SINH,COSH,TANH
//enum {SIZE,LBOUND,UBOUND,LEN,CHAR,KIND,F_INT,F_REAL,F_CHAR,F_LOGICAL,F_CMPLX}; //intrinsic functions of Fortran 90

const int Integer = 0;
const int Real = 1;
const int Double = 2;
const int Complex = 3;
const int Logical = 4;
const int DComplex = 5;



#define ATTR_NODE(A) ((graph_node **)(A)->attributeValue(0,GRAPH_NODE))
#define GRAPHNODE(A) (*((graph_node **)(A)->attributeValue(0,GRAPH_NODE)))
#define PREBOUND(A) ((SgExpression **)(A)->attributeValue(0,PRE_BOUND))
#define ARRAYMAP(A) ((SgExpression *)(A)->attributeValue(0,ARRAY_MAP_1))
#define ARRAYMAP2(A) ((SgExpression *)(A)->attributeValue(0,ARRAY_MAP_2))
#define CONSTANTMAP(A) ((SgExpression *)(A)->attributeValue(0,CONSTANT_MAP))
#define ADJUSTABLE(A) ((SgExpression *)(A)->attributeValue(0,ADJUSTABLE_))


#define HEADER(A)  ((int*)(ORIGINAL_SYMBOL(A))->attributeValue(0,ARRAY_HEADER))
#define INDEX(A) (*((int*)(ORIGINAL_SYMBOL(A))->attributeValue(0,ARRAY_HEADER)))
#define DVM000(N)   (new SgArrayRefExp(*dvmbuf, *new SgValueExp(N)))  
#define SH_GROUP(S)  (*((int *) (S) -> attributeValue(0, SHADOW_GROUP_IND)))
#define RED_GROUP(S)  (*((int *) (S) -> attributeValue(0, RED_GROUP_IND)))
#define SHADOW_(A) ((SgExpression **)(ORIGINAL_SYMBOL(A))->attributeValue(0,SHADOW_WIDTH))
#define POINTER_DIR(A) ((SgStatement **)(ORIGINAL_SYMBOL(A))->attributeValue(0,POINTER_))
#define DISTRIBUTE_DIRECTIVE(A) ((SgStatement **)(ORIGINAL_SYMBOL(A))->attributeValue(0,DISTRIBUTE_))
#define ARRAY_BASE_SYMBOL(A) ((SgSymbol **)(ORIGINAL_SYMBOL(A))->attributeValue(0,ARRAY_BASE))
#define INDEX_SYMBOL(A) ((SgSymbol **)(A)->attributeValue(0,INDEX_DELTA))
#define INIT_LOOP_VAR(A) ((SgSymbol **)(A)->attributeValue(0,INIT_LOOP))
#define CONSISTENT_HEADER(A) (*((SgSymbol **)(ORIGINAL_SYMBOL(A))->attributeValue(0,CONSISTENT_ARRAY_HEADER)))
#define POINTER_INDEX(A) (*((int *)(A)->attributeValue(0,HEAP_INDEX)))
#define BUFFER_INDEX(A) (*((int*)(ORIGINAL_SYMBOL(A))->attributeValue(0,BUFFER_COUNT)))
#define BUFFER_COUNT_PLUS_1(A) (*((int*)(ORIGINAL_SYMBOL(A))->attributeValue(0,BUFFER_COUNT))) =  (*((int*)(ORIGINAL_SYMBOL(A))->attributeValue(0,BUFFER_COUNT)))+1;
#define PS_INDEX(A) (*((int *)(A)->attributeValue(0,TASK_INDEX)))
#define DEBUG_INDEX(A) (*((int*)(ORIGINAL_SYMBOL(A))->attributeValue(0,DEBUG_AR_INDEX)))
#define TASK_SYMBOL(A) (*((SgSymbol **)(ORIGINAL_SYMBOL(A))->attributeValue(0,TSK_SYMBOL)))
#define AR_COEFFICIENTS(A)  ((coeffs *) (ORIGINAL_SYMBOL(A))->attributeValue(0,ARRAY_COEF))
#define MAX_DVM   maxdvm = (maxdvm < ndvm) ? ndvm-1 : maxdvm  
#define FREE_DVM(A)  maxdvm = (maxdvm < ndvm) ? ndvm-1 : maxdvm;  ndvm-=A  
#define SET_DVM(A)   maxdvm = (maxdvm < ndvm) ? ndvm-1 : maxdvm;  ndvm=A  
#define FREE_HPF(A)  maxhpf = (maxhpf < nhpf) ? nhpf-1 : maxhpf;  nhpf-=A  
#define SET_HPF(A)   maxhpf = (maxhpf < nhpf) ? nhpf-1 : maxhpf;  nhpf=A  
#define HPF000(N)   (new SgArrayRefExp(*hpfbuf, *new SgValueExp(N)))  
#define IS_DUMMY(A)  ((A)->thesymb->entry.var_decl.local == IO) 
#define IS_TEMPLATE(A)  ((A)->attributes() & TEMPLATE_BIT) 
#define IN_COMMON(A)  ((A)->attributes() & COMMON_BIT) 
#define IN_DATA(A)  ((A)->attributes() & DATA_BIT) 
#define IN_EQUIVALENCE(A)  ((A)->attributes() & EQUIVALENCE_BIT) 
#define IS_ARRAY(A)  ((A)->attributes() & DIMENSION_BIT)
#define IS_ALLOCATABLE(A)  ((A)->attributes() & ALLOCATABLE_BIT) 
#define IS_ALLOCATABLE_POINTER(A)  (((A)->attributes() & ALLOCATABLE_BIT) || ((A)->attributes() & POINTER_BIT))
#define IS_POINTER_F90(A)  ((A)->attributes() & POINTER_BIT) 
#define CURRENT_SCOPE(A)  (((A)->scope() == cur_func) && ((A)->thesymb->entry.var_decl.local != BY_USE) )
#define IS_BY_USE(A)  ((A)->thesymb->entry.Template.base_name != 0) 
/*#define ORIGINAL_SYMBOL(A) (OriginalSymbol(A)) */
#define ORIGINAL_SYMBOL(A) (IS_BY_USE(A) ? (A)->moduleSymbol() : (A))
#define IS_SAVE(A) (((A)->attributes() & SAVE_BIT) || (saveall && !IS_TEMPLATE(A) && !IN_COMMON(A) && !IS_DUMMY(A)) )
#define IS_POINTER(A)  ((A)->attributes() & DVM_POINTER_BIT) 
#define IS_SH_GROUP_NAME(A) ((A)->variant() == SHADOW_GROUP_NAME)
#define IS_RED_GROUP_NAME(A) ((A)->variant() == REDUCTION_GROUP_NAME)
#define IS_GROUP_NAME(A) (((A)->variant() == SHADOW_GROUP_NAME) || ((A)->variant() == REDUCTION_GROUP_NAME) || ((A)->variant() == REF_GROUP_NAME)) 
#define IS_DVM_ARRAY(A) (((A)->attributes() & DISTRIBUTE_BIT) || ((A)->attributes() & ALIGN_BIT) || ((A)->attributes() & INHERIT_BIT))
#define IS_DISTR_ARRAY(A) (((A)->attributes() & DISTRIBUTE_BIT) || ((A)->attributes() & ALIGN_BIT) || ((A)->attributes() & INHERIT_BIT))
#define IN_MODULE (cur_func->variant() == MODULE_STMT)
#define IN_MAIN_PROGRAM (cur_func->variant() == PROG_HEDR)
#define DVM_PROC_IN_MODULE(A) ((mod_attr *)(A)->attributeValue(0,MODULE_STR))
#define LINE_NUMBER_BEFORE(ST,WHERE)     doAssignStmtBefore(new SgValueExp((ST)->lineNumber()),WHERE); ndvm--; InsertNewStatementBefore((many_files ? D_FileLine(ndvm,ST) : D_Lnumb(ndvm)) ,WHERE)
#define LINE_NUMBER_STL_BEFORE(STL,ST,WHERE)     doAssignStmtBefore(new SgValueExp((ST)->lineNumber()),WHERE); ndvm--; InsertNewStatementBefore(STL= (many_files ? D_FileLine(ndvm,ST) :  D_Lnumb(ndvm)),WHERE)
#define LINE_NUMBER_AFTER(ST,WHERE)   InsertNewStatementAfter ((many_files ? D_FileLine(ndvm,ST) : D_Lnumb(ndvm)),WHERE,(WHERE)->controlParent());  doAssignStmtBefore(new SgValueExp((ST)->lineNumber()),cur_st); ndvm--
#define LINE_NUMBER_N_AFTER(N,WHERE,CP)  InsertNewStatementAfter((many_files ? D_FileLine(ndvm,CP): D_Lnumb(ndvm)),WHERE,CP);  doAssignStmtBefore(new SgValueExp(N),cur_st); ndvm--
#define LINE_NUMBER_NEXP_AFTER(NE,WHERE,CP)  InsertNewStatementAfter((many_files ? D_DummyFileLine(ndvm,"dvm_check"): D_Lnumb(ndvm)),WHERE,CP);  doAssignStmtBefore((NE),cur_st); ndvm--
#define ALIGN_RULE_INDEX(A) ((int*)(A)->attributeValue(0,ALIGN_RULE))
#define INTERVAL_LINE  (St_frag->begin_st->lineNumber())
#define INTERVAL_NUMBER  (St_frag->No)
#define GROUP_REF(S,I) (new SgArrayRefExp(*(S),*new SgValueExp(I)))
#define IS_DO_VARIABLE_USE(E) ((SgExpression **)(E)->attributeValue(0,DO_VARIABLE_USE))
#define HEADER_SIZE(A) (1+(maxbuf+1)*2*(Rank(A)+1))
#define HSIZE(R) (2*R + 2)
#define ARRAY_ELEMENT(A,I)  (new SgArrayRefExp(*A, *new SgValueExp(I)))
#define INTEGER_VALUE(E,C) ((E)->variant() == INT_VAL && (E)->valueInteger() == (C))
#define IS_INTRINSIC_TYPE(T) (!TYPE_RANGES((T)->thetype) && !TYPE_KIND_LEN((T)->thetype) && ((T)->variant() != T_DERIVED_TYPE))

//----------------------------------------------------------------------------------------

#define DECL(A)  ((A)->thesymb->decl) 
#define HEDR(A)  ((A)->thesymb->entry.Template.func_hedr)
#define PROGRAM_HEADER(A) ((A)->thesymb->entry.prog_decl.prog_hedr)

#define NON_CONFORMABLE   0
#define _IDENTICAL_       1
#define _CONSTANT_        2
#define _ARRAY_           3
#define SCALAR_ARRAYREF   4
#define VECTOR_ARRAYREF   5
#define _SUBARRAY_        6
         
EXTERN SgConstantSymb *Iconst[10];
EXTERN const char *tag[MAXTAGS];
EXTERN int ndvm;  // index for buffer array 'dvm000'	
EXTERN int maxdvm;  //  size of array 'dvm000' 
EXTERN int loc_distr;
EXTERN int send;  //set to 1 if I/O statement require 'send' operation
EXTERN char *fin_name; //input file name
EXTERN SgFile *current_file;    //current file
EXTERN SgStatement *where;//used in doAssignStmt: new statement is inserted before 'where' statement
EXTERN int nio;
EXTERN SgSymbol *bufIO[6];
EXTERN SgSymbol *loop_var[8]; // for generatig DO statements


EXTERN SgStatement *par_do;  // first DO statement of current parallel loop  
EXTERN int iplp; //dvm000 element number for storing ParLoopRef
EXTERN int irg;  //dvm000 element number for storing RedGroupRef
EXTERN int irgts;  //dvm000 element number for storing RedGroupRef(task_region)
EXTERN int idebrg;  //dvm000 element number for storing DebRedGroupRef
EXTERN SgExpression *redgref; // reduction group reference
EXTERN SgExpression *redgrefts; // reduction group reference for TASK_REGION
EXTERN SgExpression *debredgref; // debug reduction group reference
EXTERN SgExpression *red_list; // reduction operation list in FDVM program
EXTERN SgExpression *task_red_list; // reduction operation list (in TASK_REGION directive)
EXTERN int iconsg;  //dvm000 element number for storing ConsistGroupRef
EXTERN int iconsgts;  //dvm000 element number for storing ConsistGroupRef(task_region)
EXTERN int idebcg;  //dvm000 element number for storing DebRedGroupRef
EXTERN SgExpression *consgref; // consistent group reference
EXTERN SgExpression *consgrefts; // consistent group reference for TASK_REGION
EXTERN SgExpression *debconsgref; // debug reduction(consistent) group reference
EXTERN SgExpression *cons_list; // consistent array list in FDVM program
EXTERN SgExpression *task_cons_list; // consistent array list (in TASK_REGION directive)
EXTERN SgLabel *end_lab, *begin_lab; //labels for parallel loop nest
EXTERN D_do_list *cur_do;
EXTERN D_do_list *free_list;
EXTERN int Dloop_No;
EXTERN int pardo_No;
EXTERN int taskreg_No;
EXTERN int pardo_line;
EXTERN int D_end_do;
EXTERN int nfrag ; //counter of intervals for performance analizer 
EXTERN interval_list *St_frag ;
EXTERN interval_list *St_loop_first;
EXTERN interval_list *St_loop_last;
EXTERN int perf_analysis ; //set to 1 by -e1
EXTERN int close_loop_interval;
EXTERN stmt_list *goto_list;
EXTERN int len_int; //set by option -bind
EXTERN int len_long;//set by option -bind
EXTERN int bind;//set by option -bind
EXTERN int dvm_debug ;   //set to 1 by -d1  or -d2 or -d3 or -d4 flag
EXTERN int only_debug ;  //set to 1 by -s flag
EXTERN int level_debug ; //set to 1 by -d1, to 2 by -d2, ...
EXTERN fragment_list_in *debug_fragment; //set by option -d
EXTERN fragment_list_in *perf_fragment; //set by option -e
EXTERN int debug_regim; //set by option -d
EXTERN int check_regim; //set by option -dc
EXTERN int dbg_if_regim; //set by option -dbif
EXTERN  int IOBufSize; //set by option -bufio
EXTERN SgSymbol *dbg_var;
EXTERN int HPF_program;
EXTERN int rmbuf_size[6];
EXTERN int first_time;
EXTERN SgStatement *indep_st; //first INDEPENDENT directive of loop nest
EXTERN SgStatement *ins_st1, *ins_st2; // for INDEPENDENT loop
EXTERN SgSymbol *DoVar[MAX_LOOP_NEST], **IND_var, **IEX_var;
EXTERN int iarg; // for INDEPENDENT loop
//---------------------------------------------------------------------
EXTERN int errcnt;  // counter of errors in file 
EXTERN graph_node *first_node, *node_list, *first_header_node, *cur_node, *DAG_list, *top_node; 
EXTERN graph_node_list  *all_node_list, *header_node_list, *dead_node_list, *nobody_node_list;
EXTERN SgStatement *cur_func;  // current function
EXTERN SgSymbol *cur_symb, *top_symb_list, *sub_symb_list;
EXTERN int do_dummy, do_stmtfn; // flag for building call graph: by default do_dummy=0, do_stmtfn=0
EXTERN int gcount;
EXTERN SgStatement *cur_st;  // current statement  (for inserting)
EXTERN SgStatement *global_st;  // first statement of file (global_bfnd)
EXTERN stmt_list *entryst_list;
//EXTERN stmt_list  *DATA_list;
EXTERN int max_lab;  // maximal  label in file
EXTERN int num_lab;  // maximal(last)  new  label
EXTERN int vcounter;
EXTERN SgStatement *top_header, *top_last,* top_first_executable,*top_last_declaration, *top_global;
EXTERN label_list *format_labels, *top_labels, *proc_labels; 
EXTERN SgSymbol *do_var[10];
EXTERN symb_list *top_temp_vars;
EXTERN block_list *common_list, *common_list_l, *equiv_list, *equiv_list_l;
EXTERN block_list *top_common_list, *top_common_list_l, *top_equiv_list, *top_equiv_list_l;
EXTERN int modified;
EXTERN int intrinsic_type[MAX_INTRINSIC_NUM];
EXTERN const char *intrinsic_name[MAX_INTRINSIC_NUM];
EXTERN int deb_reg, with_cmnt;
//---------------------------------------------------------------------
/*  inl_exp.cpp   */
void initialize();
void InlinerDriver(SgFile *f);
void CallGraph(SgStatement *func);
void initVariantNames();
int isDummyArgument(SgSymbol *s);
int isStatementFunction(SgSymbol *s);
void FunctionCallSearch(SgExpression *e);
void FunctionCallSearch_Left(SgExpression *e);
void Arg_FunctionCallSearch(SgExpression *e);
stmt_list  *addToStmtList(stmt_list *pstmt, SgStatement *stat);
stmt_list  *delFromStmtList(stmt_list *pstmt);
graph_node_list  *addToNodeList(graph_node_list *pnode, graph_node *gnode);
graph_node_list  *delFromNodeList(graph_node_list *pnode, graph_node *gnode);
graph_node_list  *isInNodeList(graph_node_list *pnode, graph_node *gnode);
graph_node *CreateGraphNode(SgSymbol *s, SgStatement *header_st);
graph_node *NewGraphNode(SgSymbol *s, SgStatement *header_st);
void PrintGraphNode(graph_node *gnode);
void PrintGraphNodeWithAllEdges(graph_node *gnode);
void PrintWholeGraph();
void PrintWholeGraph_kind_2 ();
graph_node *NodeForSymbInGraph(SgSymbol *s, SgStatement *stheader);
void Call_Site(SgSymbol *s, int inlined);
edge *CreateOutcomingEdge(graph_node *gnode, int inlined);
edge *CreateIncomingEdge(graph_node *gnode, int inlined);
edge *NewEdge(graph_node *from, graph_node *to, int inlined);
void BuildingHeaderNodeList();
void RemovingDeadSubprograms();
int isHeaderNode(graph_node *gnode);
int isDeadNode(graph_node *gnode);
int isHeaderStmtSymbol(SgSymbol *s);
void DeleteIncomingEdgeFrom(graph_node *gnode, graph_node *from);
void ScanSymbolTable(SgFile *f);
void NoBodySubprograms();
void DeleteOutcomingEdgeTo(graph_node *gnode, graph_node *gto);
int isNoBodyNode(graph_node *gnode);
void ReseatEdges(graph_node *gnode, graph_node *newnode);
graph_node *SplittingNode(graph_node *gnode);
graph_node *CloneNode(graph_node *gnode);
void CopyOutcomingEdges(graph_node *gnode, graph_node *gnew);
void CopyIncomingEdges (graph_node *gnode, graph_node *gnew);
void RemovingUninlinedEdges();
void Partition();
void MoveEdgesPointTo(graph_node *gnode);
int unvisited_in(graph_node_list *interval);
int inInterval(graph_node *gnode,graph_node_list *interval);
int allPredecessorInInterval(graph_node *gnode,graph_node_list *interval);
void ReseatEdgesOutsideToNew(graph_node *gnode, graph_node *gnew,graph_node_list *interval);
void initIntrinsicNames();


/*  hlp.cpp */
SgLabel *  firstLabel(SgFile *f);
int isLabel(int num) ;
SgLabel * GetLabel();
SgLabel * GetNewLabel();
SgLabel * NewLabel();
//SgLabel * NewLabel(int lnum);
const char* header(int i);
char *UnparseExpr(SgExpression *e) ;
void printVariantName(int i);
void Error(const char *s, const char *t, int num, SgStatement *stmt);
void err(const char *s, int num, SgStatement *stmt);
void Err_g(const char *s, const char *t, int num);
void Warning(const char *s, const char *t, int num, SgStatement *stmt);
void warn(const char *s, int num, SgStatement *stmt);
void Warn_g(const char *s, const char *t, int num);
void errN(const char *s, int num, SgStatement *stmt);
void format_num (int num, char num3s[]);
SgExpression *ConnectList(SgExpression *el1, SgExpression *el2);
int is_integer_value(char *str);
void PrintSymbolTable(SgFile *f);
void printSymb(SgSymbol *s);
void printType(SgType *t);
void PrintTypeTable(SgFile *f);
int isSymbolNameInScope(char *name, SgStatement *scope);
int isSymbolName(char *name);
SgExpression *ReplaceIntegerParameter(SgExpression *e);
void SetScopeOfLabel(SgLabel *lab, SgStatement *scope);
SgLabel *isLabelWithScope(int num, SgStatement *stmt) ;
SgExpression *UpperBound(SgSymbol *ar, int i);
SgExpression *LowerBound(SgSymbol *ar, int i);
int Rank (SgSymbol *s);
symb_list  *AddToSymbList ( symb_list *ls, SgSymbol *s);
void MakeDeclarationForTempVarsInTop();
SgExpression *Calculate(SgExpression *er);
int ExpCompare(SgExpression *e1, SgExpression *e2);
SgExpression *Calculate_List(SgExpression *e);


/* inliner.cpp  */
void Inliner(graph_node *gtop);
void EntryPointList(SgFile *file);
void IntegerConstantSubstitution(SgStatement *header);
int isIntrinsicFunctionName(char *name);
char *ChangeIntrinsicFunctionName(char *name);
void RoutineCleaning(SgStatement *header);
void StatementCleaning(SgStatement *stmt);
SgSymbol *SearchFunction(SgExpression *e,SgStatement *stmt);
SgSymbol *PrecalculateFtoVar(SgExpression *e,SgStatement *stmt);
void PrecalculateActualParameters(SgSymbol *s,SgExpression *e,SgStatement *stmt);
void PrecalculateExpression(SgSymbol *sp,SgExpression *e,SgStatement *stmt);
void InsertNewStatementBefore (SgStatement *stat, SgStatement *current);
void InsertNewStatementAfter (SgStatement *stat, SgStatement *current, SgStatement *cp);
int ParameterType(SgExpression *e,SgStatement *stmt);
int TestSubscripts(SgExpression *e,SgStatement *stmt);
int TestRange(SgExpression *e,SgStatement *stmt);
SgSymbol *GetTempVarForF(SgSymbol *sf, SgType *t);
SgSymbol *GetTempVarForArg(int i, SgSymbol *sf, SgType *t);
SgSymbol *GetTempVarForSubscr(SgType *t);
SgSymbol *GetTempVarForBound(SgSymbol *sa);
SgStatement *InlineExpansion(graph_node *gtop, SgStatement *stmt, SgSymbol *sf, SgExpression *args);
int isInSymbolTable(SgSymbol *sym);
SgStatement * CreateTemplate(graph_node *gnode);
void SiteIndependentTransformation(graph_node *gnode); //(SgStatement *header);
void MoveToTopOfRoutine(SgStatement *entrystmt, SgStatement *first_executable);
void LogIf_to_IfThen(SgStatement *stmt);
void MoveToTopOfRoutine(SgStatement *entrystmt, SgStatement *first_executable);
SgStatement *ReplaceByGoToBottomOfRoutine(SgStatement *retstmt, SgLabel *lab_return);
void MoveFormatToTopOfRoutine(SgStatement *format_stmt, SgStatement *last_declaration);
int TestFormatLabel(SgLabel *lab);
int isInlinedCall(graph_node *gtop, graph_node *gnode);
void ReplaceReturnByContinue(SgStatement *return_st);
SgStatement *MoveFormatIntoTopLevel(SgStatement *format_stmt, int clone);
graph_node *getNodeForSymbol(graph_node *gtop,char *name);
int isInlinedCallSite(SgStatement *stmt);
graph_node *getAttrNodeForSymbol(SgSymbol *sf);
label_list  *addToLabelList(label_list *lablist, SgLabel *lab);
int isInLabelList(SgLabel *lab, label_list *lablist);
void ReplaceFormatLabelsInStmts(SgStatement *header);
int isLabelOfTop(SgLabel *lab);
void LabelList(SgStatement *header);
SgLabel *isInFormatMap(SgLabel *lab);
void SetScopeToLabels(SgStatement *header);
void AdjustableArrayBounds(SgStatement *header, SgStatement *after);
int isAdustableBound(SgExpression *bound);
int SearchVarRef(SgExpression *e);
void PrecalculateArrayBound(SgSymbol *ar,SgExpression *bound, SgStatement *after, SgStatement *header);
void ReplaceWholeArrayRefInIOStmts(SgStatement *header);
SgExpression *ImplicitLoop(SgSymbol *ar);
SgSymbol *GetImplicitDoVar(int j);
SgExpression * LowerLoopBound(SgSymbol *ar, int i);
SgExpression * UpperLoopBound(SgSymbol *ar, int i);
void RemapLocalVariables(SgStatement *header);
SgSymbol *CreateListOfLocalVariables(SgStatement *header);
void MakeDeclarationStmtInTop(SgSymbol *s);
SgSymbol *NextSymbol(SgSymbol *s);
SgSymbol *GetNewTopSymbol(SgSymbol *s);
int isInTopSymbList(SgSymbol *sym);
SgSymbol *GetImplicitDoVar(int j);
char *NewName(char *name);
SgSymbol *isTopName(char *name);
SgSymbol *isTopNameOfType(char *name, SgType *type);
void ReplaceIntegerParameterInTypeOfVars(SgStatement *header, SgStatement *last);
void ReplaceIntegerParameter_InType(SgType *t);
void MakeDeclarationStmtsForConstant(SgSymbol *s);
void RemapFunctionResultVar(SgExpression *topref, SgSymbol *sf);
SgStatement *TranslateSubprogramReferences(SgStatement *header);
//void TranslateExpression(SgExpression * e, int md[]);
SgExpression *TranslateExpression(SgExpression * e, int *md);
SgSymbol *SymbolMap(SgSymbol *s);
void InsertBlockAfter(SgStatement *after, SgStatement *first, SgStatement *last);
void ExtractSubprogramsOfCallGraph(graph_node *gtop);
int CompareConstants(SgSymbol *rs, SgSymbol *ts);
void RemapConstants(SgStatement *header,SgStatement *first_exec);
void RemapLocalObject(SgSymbol *s);
void CommonBlockList(SgStatement *stmt);
void TopCommonBlockList(SgStatement *stmt);
block_list *AddToBlockList(block_list *blist_last, SgExpression *eb);
void EquivBlockList(SgStatement *stmt);
void TranslateExpression_1(SgExpression *e);
void TranslateExpressionList(SgExpression *e) ;
SgStatement *DeclaringCommonBlock(SgExpression *bl);
void RemapCommonBlocks(SgStatement *header);
int isUnconflictingCommon(SgSymbol *s);
block_list *isConflictingCommon(SgSymbol *s);
SgType *BaseType(SgType *type);
block_list *isInCommonList(SgSymbol *s, block_list *blc );
int areOfSameType(SgSymbol *st, SgSymbol *sr);
int IntrinsicTypeSize(SgType *t);
int TypeSize(SgType *t);
int TypeLength(SgType *t);
void MakeRefsConformable(SgExpression *tref, SgExpression *ref);
void CalculateTopLevelRef(SgSymbol *tops,SgExpression *tref, SgExpression *ref);
void CreateTopCommonBlockList();
void RemapCommonObject(SgSymbol *s,SgSymbol *tops);
void RemapCommonList(SgExpression *el);
int CompareValues(PTR_LLND pe1,PTR_LLND pe2);
SgType * TypeOfResult(SgExpression *e); 
int is_IntrinsicFunction(SgSymbol *sf);
int IntrinsicInd(SgSymbol *sf);
SgType *TypeF(int indf,SgExpression *e);
SgType * SgTypeComplex(SgFile *f);
SgType * SgTypeDoubleComplex(SgFile *f);
void ConformActualAndFormalParameters(SgSymbol *scopy,SgExpression *args,SgStatement *parentSt);
SgSymbol *FirstDummy(SgSymbol *sf);
SgSymbol *NextDummy(SgSymbol *s);
int TestConformability(SgSymbol *darg, SgExpression *fact, SgStatement *parentSt);
int isScalar(SgSymbol *symb);
int SameType(SgSymbol *darg, SgExpression *fact);
int Same(SgType *ft,SgType *dt);
int isArray(SgSymbol *symb);
int TestShapes(SgArrayType *ftp, SgArrayType *dtp);
SgExpression *LowerBoundOfDim(SgExpression *e);
SgExpression *UpperBoundOfDim(SgExpression *e);
int IdenticalValues(SgExpression *e1, SgExpression *e2);
SgExpression *ArrayMap(SgSymbol *s);
//SgExpression *ArrayMap1(SgSymbol *s);
SgExpression *ArrayMap2(SgSymbol *s);
SgExpression *FirstIndexChange(SgExpression *e, SgExpression *index);
int SameShapes(SgArrayType *ftp, SgArrayType *dtp);
int is_NoExpansionFunction(SgSymbol *sf);
int isFormalProcedure(SgSymbol *symb);
int SameDims(SgExpression *fe,SgExpression *de); 
SgExpression *FirstIndexesChange(SgExpression *mape, SgExpression *re);
void ConformReferences(SgSymbol *darg, SgExpression *fact, SgStatement *parentSt);
void TranslateArrayTypeExpressions(SgSymbol *darg);
int isAdjustableArray(SgSymbol *param);
int TestBounds(SgExpression *fact, SgArrayType *ftp, SgArrayType *dtp);
void TransformForFortran77();
SgExpression *IndexChange(SgExpression *e, SgExpression *index, SgExpression *lbe);
int TestVector(SgExpression *fact, SgArrayType *ftp, SgArrayType *dtp);
SgType *TypeOfArgument(SgExpression *e);
void ReplaceContext(SgStatement *stmt);
int isDoEndStmt(SgStatement *stmt);
void ReplaceDoNestLabel(SgStatement *last_st, SgLabel *new_lab);
void EditExpressionList(SgExpression *e);
void Add_Comment(graph_node *g, SgStatement *stmt, int flag);
void PrintTopSymbList();
void PrintSymbList(SgSymbol *slist, SgStatement *header);

/*  driver.cpp */

//-----------------------------------------------------------------------

extern "C" char* funparse_bfnd(...);
extern "C" char* Tool_Unparse2_LLnode(...);
extern "C" void Init_Unparser(...);

//-----------------------------------------------------------------------
//extern SgLabel * LabelMapping(PTR_LABEL label);