Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

finalyze moving

Browse Source
This commit is contained in:
Alexander
2025-03-12 14:28:04 +03:00
parent f840006398
commit 033bbce220
774 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
projects/dvm/fdvm/trunk/InlineExpansion/CMakeLists.txt Normal file
View File

@@ -0,0 +1,23 @@
set(INLINE_SOURCES inl_exp.cpp inliner.cpp hlp.cpp)
if(MSVC_IDE)
file(GLOB_RECURSE INLINE_HEADERS RELATIVE
${CMAKE_CURRENT_SOURCE_DIR} *.h)
foreach(DIR ${DVM_FORTRAN_INCLUDE_DIRS})
file(GLOB_RECURSE FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} "${DIR}/*.h")
set(INLINE_HEADERS ${INLINE_HEADERS} ${FILES})
endforeach()
endif()
add_executable(inl_exp ${INLINE_SOURCES} ${INLINE_HEADERS})
add_dependencies(inl_exp db sage sage++)
target_link_libraries(inl_exp db sage sage++)
target_include_directories(inl_exp PRIVATE "${DVM_FORTRAN_INCLUDE_DIRS}")
set_target_properties(inl_exp PROPERTIES
FOLDER "${DVM_TOOL_FOLDER}"
RUNTIME_OUTPUT_DIRECTORY ${DVM_BIN_DIR}
COMPILE_PDB_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>
PDB_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>
)

85
projects/dvm/fdvm/trunk/InlineExpansion/dvm_tag.h Normal file
View File

@@ -0,0 +1,85 @@
#define HPF_TEMPLATE_STAT 296
#define HPF_ALIGN_STAT 297
#define HPF_PROCESSORS_STAT 298
#define DVM_DISTRIBUTE_DIR 277
#define DVM_REDISTRIBUTE_DIR 299
#define DVM_PARALLEL_ON_DIR 211
#define DVM_SHADOW_START_DIR 212
#define DVM_SHADOW_GROUP_DIR 213
#define DVM_SHADOW_WAIT_DIR 214
#define DVM_REDUCTION_START_DIR 215
#define DVM_REDUCTION_GROUP_DIR 216
#define DVM_REDUCTION_WAIT_DIR 217
#define DVM_DYNAMIC_DIR 218
#define DVM_ALIGN_DIR 219
#define DVM_REALIGN_DIR 220
#define DVM_REALIGN_NEW_DIR 221
#define DVM_REMOTE_ACCESS_DIR 222
#define HPF_INDEPENDENT_DIR 223
#define DVM_SHADOW_DIR 224
#define DVM_NEW_VALUE_DIR 247
#define DVM_VAR_DECL 248
#define DVM_POINTER_DIR 249
#define DVM_DEBUG_DIR 146
#define DVM_ENDDEBUG_DIR 147
#define DVM_TRACEON_DIR 148
#define DVM_TRACEOFF_DIR 149
#define DVM_INTERVAL_DIR 128
#define DVM_ENDINTERVAL_DIR 129
#define DVM_TASK_REGION_DIR 605
#define DVM_END_TASK_REGION_DIR 606
#define DVM_ON_DIR 607
#define DVM_END_ON_DIR 608
#define DVM_TASK_DIR 609
#define DVM_MAP_DIR 610
#define DVM_PARALLEL_TASK_DIR 611
#define DVM_INHERIT_DIR 612
#define DVM_INDIRECT_GROUP_DIR 613
#define DVM_INDIRECT_ACCESS_DIR 614
#define DVM_REMOTE_GROUP_DIR 615
#define DVM_RESET_DIR 616
#define DVM_PREFETCH_DIR 617
#define DVM_OWN_DIR 618
#define DVM_HEAP_DIR 619
#define DVM_ASYNCID_DIR 620
#define DVM_ASYNCHRONOUS_DIR 621
#define DVM_ENDASYNCHRONOUS_DIR 622
#define DVM_ASYNCWAIT_DIR 623
#define DVM_F90_DIR 624
#define DVM_BARRIER_DIR 625
#define FORALL_STAT 626
#define DVM_CONSISTENT_GROUP_DIR 627
#define DVM_CONSISTENT_START_DIR 628
#define DVM_CONSISTENT_WAIT_DIR 629
#define DVM_CONSISTENT_DIR 630
#define BLOCK_OP 705
#define NEW_SPEC_OP 706
#define REDUCTION_OP 707
#define SHADOW_RENEW_OP 708
#define SHADOW_START_OP 709
#define SHADOW_WAIT_OP 710
#define DIAG_OP 711
#define REMOTE_ACCESS_OP 712
#define TEMPLATE_OP 713
#define PROCESSORS_OP 714
#define DYNAMIC_OP 715
#define ALIGN_OP 716
#define DISTRIBUTE_OP 717
#define SHADOW_OP 718
#define INDIRECT_ACCESS_OP 719
#define ACROSS_OP 720
#define NEW_VALUE_OP 721
#define SHADOW_COMP_OP 722
#define STAGE_OP 723
#define FORALL_OP 724
#define CONSISTENT_OP 725
#define SHADOW_GROUP_NAME 523
#define REDUCTION_GROUP_NAME 524
#define REF_GROUP_NAME 525
#define ASYNC_ID 526
#define CONSISTENT_GROUP_NAME 527

622
projects/dvm/fdvm/trunk/InlineExpansion/hlp.cpp Normal file
View File

@@ -0,0 +1,622 @@
/**************************************************************\
* Inline Expansion *
* *
* Miscellaneous help routines *
\**************************************************************/
#include "inline.h"
#include <ctype.h>
#include <stdlib.h>
#ifdef __SPF
#include <string>
#endif
//*************************************************************
/*
* Error - formats the error message then call "err" to print it
*
* input:
* s - string that specifies the conversion format
* t - string that to be formated according to s
* num - error message number
* stmt - pointer to the statement
*/
//*************************************************************
void Error(const char *s, const char *t, int num, SgStatement *stmt)
{
char *buff = new char[strlen(s) + strlen(t) + 32];
sprintf(buff, s, t);
err(buff, num, stmt);
delete[]buff;
}
/*
* Err_g - formats and prints the special kind error message (without statement reference)
*
* input:
* s - string that specifies the conversion format
* t - string that to be formated according to s
* num - error message number
*/
void Err_g(const char *s, const char *t, int num)
{
char *buff = new char[strlen(s) + strlen(t) + 32];
char num3s[16];
sprintf(buff, s, t);
format_num(num, num3s);
errcnt++;
(void)fprintf(stderr, "Error %s in %s of %s: %s\n", num3s, cur_func->symbol()->identifier(), cur_func->fileName(), buff);
delete[]buff;
}
/*
* err -- prints the error message
*
* input:
* s - string to be printed out
* num - error message number
* stmt - pointer to the statement
*/
void err(const char *s, int num, SgStatement *stmt)
{
char num3s[16];
format_num(num, num3s);
errcnt++;
// printf( "Error on line %d : %s\n", stmt->lineNumber(), s);
#ifdef __SPF
char message[256];
sprintf(message, "Error %d: %s", num, s);
std::string toPrint = "|";
toPrint += std::to_string(1) + " "; // ERROR
toPrint += std::string(stmt->fileName()) + " ";
toPrint += std::to_string(stmt->lineNumber()) + " ";
toPrint += std::to_string(0);
toPrint += "|" + std::string(message);
printf("@%s@\n", toPrint.c_str());
#else
(void)fprintf(stderr, "Error %s on line %d of %s: %s\n", num3s, stmt->lineNumber(), stmt->fileName(), s);
#endif
}
/*
* Warning -- formats a warning message then call "warn" to print it out
*
* input:
* s - string that specifies the conversion format
* t - string that to be converted according to s
* num - warning message number
* stmt - pointer to the statement
*/
void Warning(const char *s, const char *t, int num, SgStatement *stmt)
{
char *buff = new char[strlen(s) + strlen(t) + 32];
sprintf(buff, s, t);
warn(buff, num, stmt);
delete[]buff;
}
/*
* warn -- print the warning message if specified
*
* input:
* s - string to be printed
* num - warning message number
* stmt - pointer to the statement
*/
void warn(const char *s, int num, SgStatement *stmt)
{
char num3s[16];
format_num(num, num3s);
// printf( "Warning on line %d: %s\n", stmt->lineNumber(), s);
(void)fprintf(stderr, "Warning %s on line %d of %s: %s\n", num3s, stmt->lineNumber(), stmt->fileName(), s);
}
void Warn_g(const char *s, const char *t, int num)
{
char *buff = new char[strlen(s) + strlen(t) + 32];
char num3s[16];
format_num(num, num3s);
sprintf(buff, s, t);
(void)fprintf(stderr, "Warning %s in %s of %s: %s\n", num3s, cur_func->symbol()->identifier(), cur_func->fileName(), buff);
delete[]buff;
}
//*********************************************************************
void printVariantName(int i) {
if ((i >= 0 && i < MAXTAGS) && tag[i]) printf("%s", tag[i]);
else printf("not a known node variant");
}
//***********************************
char *UnparseExpr(SgExpression *e)
{
char *buf;
int l;
Init_Unparser();
buf = Tool_Unparse2_LLnode(e->thellnd);
l = strlen(buf);
char *ustr = new char[l + 1];
strcpy(ustr, buf);
//ustr[l] = ' ';
//ustr[l+1] = '\0';
return(ustr);
}
//************************************
const char* header(int i) {
switch (i) {
case(PROG_HEDR):
return("program");
case(PROC_HEDR):
return("subroutine");
case(FUNC_HEDR):
return("function");
default:
return("error");
}
}
SgLabel* firstLabel(SgFile *f)
{
SetCurrentFileTo(f->filept);
SwitchToFile(GetFileNumWithPt(f->filept));
return LabelMapping(PROJ_FIRST_LABEL());
}
int isLabel(int num) {
PTR_LABEL lab;
for (lab = PROJ_FIRST_LABEL(); lab; lab = LABEL_NEXT(lab))
if (num == LABEL_STMTNO(lab))
return 1;
return 0;
}
SgLabel *isLabelWithScope(int num, SgStatement *stmt) {
PTR_LABEL lab;
for (lab = PROJ_FIRST_LABEL(); lab; lab = LABEL_NEXT(lab))
//if( num == LABEL_STMTNO(lab) && LABEL_BODY(lab)->scope == stmt->thebif)
if (num == LABEL_STMTNO(lab) && LABEL_SCOPE(lab) == stmt->thebif)
return LabelMapping(lab);
return NULL;
}
SgLabel * GetLabel()
{
static int lnum = 90000;
if (lnum > max_lab)
return (new SgLabel(lnum--));
while (isLabel(lnum))
lnum--;
return (new SgLabel(lnum--));
}
SgLabel * GetNewLabel()
{
static int lnum = 99999;
if (lnum > max_lab) /* for current file must be set before first call GetNewLabel() :max_lab = getLastLabelId(); */
return (new SgLabel(lnum--));
while (isLabel(lnum))
lnum--;
return (new SgLabel(lnum--));
/*
int lnum;
if(max_lab <99999)
return(new SgLabel(++max_lab));
lnum = 1;
while(isLabel(lnum))
lnum++;
return(new SgLabel(lnum));
*/
}
SgLabel * NewLabel()
{
if (max_lab < 99999)
return(new SgLabel(++max_lab));
++num_lab;
while (isLabel(num_lab))
++num_lab;
return(new SgLabel(num_lab));
}
void SetScopeOfLabel(SgLabel *lab, SgStatement *scope)
{
LABEL_SCOPE(lab->thelabel) = scope->thebif;
}
/*
SgLabel * NewLabel(int lnum)
{
if(max_lab <99999)
return(new SgLabel(++max_lab));
while(isLabel(lnum))
++lnum;
return(new SgLabel(lnum));
}
*/
int isSymbolName(char *name)
//
{
SgSymbol *s;
for (s = current_file->firstSymbol(); s; s = s->next())
if (!strcmp(name, s->identifier()))
return 1;
return 0;
}
int isSymbolNameInScope(char *name, SgStatement *scope)
{
SgSymbol *s;
for (s = current_file->firstSymbol(); s; s = s->next())
if (scope == s->scope() && !strcmp(name, s->identifier()))
return 1;
return 0;
}
/*
{
PTR_SYMB sym;
for(sym=PROJ_FIRST_SYMB(); sym; sym=SYMB_NEXT(sym))
if( SYMB_SCOPE(sym) == scope->thebif && (!strcmp(name,SYMB_IDENT(sym)) ) )
return 1;
return 0;
}
*/
void format_num(int num, char num3s[])
{
if (num > 99)
num3s[sprintf(num3s, "%3d", num)] = 0;
else if (num > 9)
num3s[sprintf(num3s, "0%2d", num)] = 0;
else
num3s[sprintf(num3s, "00%1d", num)] = 0;
}
SgExpression *ConnectList(SgExpression *el1, SgExpression *el2)
{
SgExpression *el;
if (!el1)
return(el2);
if (!el2)
return(el1);
for (el = el1; el->rhs(); el = el->rhs())
;
el->setRhs(el2);
return(el1);
}
int is_integer_value(char *str)
{
char *p;
p = str;
for (; *str != '\0'; str++)
if (!isdigit(*str))
return 0;
return (atoi(p));
}
void PrintSymbolTable(SgFile *f)
{
SgSymbol *s;
printf("\nS Y M B O L T A B L E \n");
for (s = f->firstSymbol(); s; s = s->next())
//printf(" %s/%d/ ", s->identifier(), s->id() );
printSymb(s);
}
void printSymb(SgSymbol *s)
{
const char *head;
head = isHeaderStmtSymbol(s) ? "HEADER " : " ";
printf("SYMB[%3d] scope=STMT[%3d] : %s %s", s->id(), (s->scope()) ? (s->scope())->id() : -1, s->identifier(), head);
printType(s->type());
printf("\n");
}
void printType(SgType *t)
{
SgArrayType *arrayt;
/*SgExpression *e = new SgExpression(TYPE_RANGES(t->thetype));*/
int i, n;
if (!t) { printf("no type "); return; }
else printf("TYPE[%d]:", t->id());
if ((arrayt = isSgArrayType(t)) != 0)
{
printf("dimension(");
n = arrayt->dimension();
for (i = 0; i < n; i++)
{
(arrayt->sizeInDim(i))->unparsestdout();
if (i < n - 1) printf(", ");
}
printf(") ");
}
else
{
switch (t->variant())
{
case T_INT: printf("integer "); break;
case T_FLOAT: printf("real "); break;
case T_DOUBLE: printf("double precision "); break;
case T_CHAR: printf("character "); break;
case T_STRING: printf("Character ");
UnparseLLND(TYPE_RANGES(t->thetype));
/*if(t->length()) printf("[%d]",t->length()->variant());*/
/*((SgArrayType *) t)->getDimList()->unparsestdout();*/
break;
case T_BOOL: printf("logical "); break;
case T_COMPLEX: printf("complex "); break;
case T_DCOMPLEX: printf("double complex "); break;
default: break;
}
}
/* if(e) e->unparsestdout();*/
if (t->hasBaseType())
{
printf("of ");
printType(t->baseType());
}
}
void PrintTypeTable(SgFile *f)
{
SgType *t;
printf("\nT Y P E T A B L E \n");
for (t = f->firstType(); t; t = t->next())
{
printType(t); printf("\n");
}
}
SgExpression *ReplaceParameter(SgExpression *e)
{
if (!e)
return(e);
if (e->variant() == CONST_REF) {
SgConstantSymb * sc = isSgConstantSymb(e->symbol());
return(ReplaceParameter(&(sc->constantValue()->copy())));
}
e->setLhs(ReplaceParameter(e->lhs()));
e->setRhs(ReplaceParameter(e->rhs()));
return(e);
}
SgExpression *ReplaceIntegerParameter(SgExpression *e)
{
if (!e)
return(e);
if (e->variant() == CONST_REF && e->type()->variant() == T_INT) {
SgConstantSymb * sc = isSgConstantSymb(e->symbol());
return(ReplaceIntegerParameter(&(sc->constantValue()->copy())));
}
e->setLhs(ReplaceIntegerParameter(e->lhs()));
e->setRhs(ReplaceIntegerParameter(e->rhs()));
return(e);
}
/*
SgExpression *ReplaceFuncCall(SgExpression *e)
{
if(!e)
return(e);
if(isSgFunctionCallExp(e) && e->symbol()) {//function call
if( !e->lhs() && (!strcmp(e->symbol()->identifier(),"number_of_processors") || !strcmp(e->symbol()->identifier(),"actual_num_procs"))) { //NUMBER_OF_PROCESSORS() or
// ACTUAL_NUM_PROCS()
SgExprListExp *el1,*el2;
if(!strcmp(e->symbol()->identifier(),"number_of_processors"))
el1 = new SgExprListExp(*ParentPS());
else
el1 = new SgExprListExp(*CurrentPS());
el2 = new SgExprListExp(*ConstRef(0));
e->setSymbol(fdvm[GETSIZ]);
fmask[GETSIZ] = 1;
el1->setRhs(el2);
e->setLhs(el1);
return(e);
}
if( !e->lhs() && (!strcmp(e->symbol()->identifier(),"processors_rank"))) {
//PROCESSORS_RANK()
SgExprListExp *el1;
el1 = new SgExprListExp(*ParentPS());
e->setSymbol(fdvm[GETRNK]);
fmask[GETRNK] = 1;
e->setLhs(el1);
return(e);
}
if(!strcmp(e->symbol()->identifier(),"processors_size")) {
//PROCESSORS_SIZE()
SgExprListExp *el1;
el1 = new SgExprListExp(*ParentPS());
e->setSymbol(fdvm[GETSIZ]);
fmask[GETSIZ] = 1;
el1->setRhs(*(e->lhs())+(*ConstRef(0))); //el1->setRhs(e->lhs());
e->setLhs(el1);
return(e);
}
}
e->setLhs(ReplaceFuncCall(e->lhs()));
e->setRhs(ReplaceFuncCall(e->rhs()));
return(e);
}
*/
/* version from dvm.cpp
SgExpression *Calculate(SgExpression *e)
{ SgExpression *er;
er = ReplaceParameter( &(e->copy()));
if(er->isInteger())
return( new SgValueExp(er->valueInteger()));
else
return(e);
}
*/
/* new version */
SgExpression *Calculate(SgExpression *e)
{
if (e->isInteger())
return(new SgValueExp(e->valueInteger()));
else
return(e);
}
SgExpression *Calculate_List(SgExpression *e)
{
SgExpression *el;
for (el = e; el; el = el->rhs())
el->setLhs(Calculate(el->lhs()));
return(e);
}
int ExpCompare(SgExpression *e1, SgExpression *e2)
{//compares two expressions
// returns 1 if they are textually identical
if (!e1 && !e2) // both expressions are null
return(1);
if (!e1 || !e2) // one of them is null
return(0);
if (e1->variant() != e2->variant()) // variants are not equal
return(0);
switch (e1->variant()) {
case INT_VAL:
return(NODE_IV(e1->thellnd) == NODE_IV(e2->thellnd));
case FLOAT_VAL:
case DOUBLE_VAL:
case BOOL_VAL:
case CHAR_VAL:
case STRING_VAL:
return(!strcmp(NODE_STR(e1->thellnd), NODE_STR(e2->thellnd)));
case COMPLEX_VAL:
return(ExpCompare(e1->lhs(), e2->lhs()) && ExpCompare(e1->rhs(), e2->rhs()));
case CONST_REF:
case VAR_REF:
return(e1->symbol() == e2->symbol());
case ARRAY_REF:
case FUNC_CALL:
if (e1->symbol() == e2->symbol())
return(ExpCompare(e1->lhs(), e2->lhs())); // compares subscript/argument lists
else
return(0);
case EXPR_LIST:
{SgExpression *el1, *el2;
for (el1 = e1, el2 = e2; el1&&el2; el1 = el1->rhs(), el2 = el2->rhs())
if (!ExpCompare(el1->lhs(), el2->lhs())) // the corresponding elements of lists are not identical
return(0);
if (el1 || el2) //one list is shorter than other
return(0);
else
return(1);
}
case MINUS_OP: //unary operations
case NOT_OP:
return(ExpCompare(e1->lhs(), e2->lhs())); // compares operands
default:
return(ExpCompare(e1->lhs(), e2->lhs()) && ExpCompare(e1->rhs(), e2->rhs()));
}
}
SgExpression *LowerBound(SgSymbol *ar, int i)
// lower bound of i-nd dimension of array ar (i= 0,...,Rank(ar)-1)
{
SgArrayType *artype;
SgExpression *e;
SgSubscriptExp *sbe;
//if(IS_POINTER(ar))
// return(new SgValueExp(1));
artype = isSgArrayType(ar->type());
if (!artype)
return(NULL);
e = artype->sizeInDim(i);
if (!e)
return(NULL);
if ((sbe = isSgSubscriptExp(e)) != NULL) {
if (sbe->lbound())
return(sbe->lbound());
//else if(IS_ALLOCATABLE_POINTER(ar)){
// if(HEADER(ar))
// return(header_ref(ar,Rank(ar)+3+i));
// else
// return(LBOUNDFunction(ar,i+1));
//}
else
return(new SgValueExp(1));
}
else
return(new SgValueExp(1)); // by default lower bound = 1
}
int Rank(SgSymbol *s)
{
SgArrayType *artype;
//if(IS_POINTER(s))
// return(PointerRank(s));
artype = isSgArrayType(s->type());
if (artype)
return (artype->dimension());
else
return (0);
}
SgExpression *UpperBound(SgSymbol *ar, int i)
// upper bound of i-nd dimension of array ar (i= 0,...,Rank(ar)-1)
{
SgArrayType *artype;
SgExpression *e;
SgSubscriptExp *sbe;
artype = isSgArrayType(ar->type());
if (!artype)
return(NULL);
e = artype->sizeInDim(i);
if (!e)
return(NULL);
if ((sbe = isSgSubscriptExp(e)) != NULL) {
if (sbe->ubound())
return(sbe->ubound());
//else if(HEADER(ar))
// return(&(*GetSize(HeaderRefInd(ar,1),i+1)-*HeaderRefInd(ar,Rank(ar)+3+i)+*new SgValueExp(1)));
//else
// return(UBOUNDFunction(ar,i+1));
}
else
return(e);
// !!!! test case "*"
return(e);
}
symb_list *AddToSymbList(symb_list *ls, SgSymbol *s)
{
symb_list *l;
//adding the symbol 's' to symb_list 'ls'
if (!ls) {
ls = new symb_list;
ls->symb = s;
ls->next = NULL;
}
else {
l = new symb_list;
l->symb = s;
l->next = ls;
ls = l;
}
return(ls);
}

1750
projects/dvm/fdvm/trunk/InlineExpansion/inl_exp.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

643
projects/dvm/fdvm/trunk/InlineExpansion/inline.h Normal file
View File

@@ -0,0 +1,643 @@
#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);

2993
projects/dvm/fdvm/trunk/InlineExpansion/inliner.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

196
projects/dvm/fdvm/trunk/InlineExpansion/intrinsic.h Normal file
View File

@@ -0,0 +1,196 @@
intrinsic_type[ICHAR] = 1;
intrinsic_type[CHAR] = 7;
intrinsic_type[INT] = 1; //
intrinsic_type[IFIX] = 1;
intrinsic_type[IDINT] = 1;
intrinsic_type[FLOAT] = 3;
intrinsic_type[REAL] = 3; //
intrinsic_type[SNGL] = 3;
intrinsic_type[DBLE] = 4; //
intrinsic_type[CMPLX] = 5; //
intrinsic_type[DCMPLX]= 6;
intrinsic_type[AINT] = 3; //
intrinsic_type[DINT] = 4;
intrinsic_type[ANINT] = 3; //
intrinsic_type[DNINT] = 4;
intrinsic_type[NINT] = 1; //
intrinsic_type[IDNINT]= 1;
intrinsic_type[ABS] =-1; //3
intrinsic_type[IABS] = 1;
intrinsic_type[DABS] = 4;
intrinsic_type[CABS] = 5;
intrinsic_type[MOD] =-1; //1
intrinsic_type[AMOD] = 3;
intrinsic_type[DMOD] = 4;
intrinsic_type[SIGN] =-1; //3
intrinsic_type[ISIGN] = 1;
intrinsic_type[DSIGN] = 4;
intrinsic_type[DIM] =-1; //3
intrinsic_type[IDIM] = 1;
intrinsic_type[DDIM] = 4;
intrinsic_type[MAX] =-1;
intrinsic_type[MAX0] = 1;
intrinsic_type[AMAX1] = 3;
intrinsic_type[DMAX1] = 4;
intrinsic_type[AMAX0] = 3;
intrinsic_type[MAX1] = 1;
intrinsic_type[MIN] =-1; //
intrinsic_type[MIN0] = 1;
intrinsic_type[AMIN1] = 3;
intrinsic_type[DMIN1] = 4;
intrinsic_type[AMIN0] = 3;
intrinsic_type[MIN1] = 1;
intrinsic_type[LEN] = 1;
intrinsic_type[INDEX] = 1;
intrinsic_type[AIMAG] =-1; //3
intrinsic_type[DIMAG] = 4;
intrinsic_type[CONJG] =-1; //5
intrinsic_type[DCONJG]= 6;
intrinsic_type[SQRT] =-1; //3
intrinsic_type[DSQRT] = 4;
intrinsic_type[CSQRT] = 5;
intrinsic_type[EXP] =-1; //3
intrinsic_type[DEXP] = 4;
intrinsic_type[CEXP] = 5;
intrinsic_type[LOG] =-1; //
intrinsic_type[ALOG] = 3;
intrinsic_type[DLOG] = 4;
intrinsic_type[CLOG] = 5;
intrinsic_type[LOG10] =-1; //
intrinsic_type[ALOG10]= 3;
intrinsic_type[DLOG10]= 4;
intrinsic_type[SIN] =-1; //3
intrinsic_type[DSIN] = 4;
intrinsic_type[CSIN] = 5;
intrinsic_type[COS] =-1; //3
intrinsic_type[DCOS] = 4;
intrinsic_type[CCOS] = 5;
intrinsic_type[TAN] =-1; //3
intrinsic_type[DTAN] = 4;
intrinsic_type[ASIN] =-1; //3
intrinsic_type[DASIN] = 4;
intrinsic_type[ACOS] =-1; //3
intrinsic_type[DACOS] = 4;
intrinsic_type[ATAN] =-1; //3
intrinsic_type[DATAN] = 4;
intrinsic_type[ATAN2] =-1; //3
intrinsic_type[DATAN2]= 4;
intrinsic_type[SINH] =-1; //3
intrinsic_type[DSINH] = 4;
intrinsic_type[COSH] =-1; //3
intrinsic_type[DCOSH] = 4;
intrinsic_type[TANH] =-1; //3
intrinsic_type[DTANH] = 4;
intrinsic_type[LGE] = 2;
intrinsic_type[LGT] = 2;
intrinsic_type[LLE] = 2;
intrinsic_type[LLT] = 2;
//intrinsic_type[] = ;
//intrinsic_type[] = ;
//{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
//universal name - -1
//integer - 1
//logical - 2
//real - 3
//double precision - 4
//complex - 5
//complex*16 - 6
//character - 7
intrinsic_name[ICHAR] = "ichar";
intrinsic_name[CHAR] = "char";
intrinsic_name[INT] = "int"; //
intrinsic_name[IFIX] = "ifix";
intrinsic_name[IDINT] = "idint";
intrinsic_name[FLOAT] = "float";
intrinsic_name[REAL] = "real"; //
intrinsic_name[SNGL] = "sngl";
intrinsic_name[DBLE] = "dble"; //
intrinsic_name[CMPLX] = "cmplx"; //
intrinsic_name[DCMPLX]= "dcmplx";
intrinsic_name[AINT] = "aint"; //
intrinsic_name[DINT] = "dint";
intrinsic_name[ANINT] = "anint"; //
intrinsic_name[DNINT] = "dnint";
intrinsic_name[NINT] = "nint"; //
intrinsic_name[IDNINT]= "idnint";
intrinsic_name[ABS] = "abs"; //
intrinsic_name[IABS] = "iabs";
intrinsic_name[DABS] = "dabs";
intrinsic_name[CABS] = "cabs";
intrinsic_name[MOD] = "mod"; //
intrinsic_name[AMOD] = "amod";
intrinsic_name[DMOD] = "dmod";
intrinsic_name[SIGN] = "sign"; //
intrinsic_name[ISIGN] = "isign";
intrinsic_name[DSIGN] = "dsign";
intrinsic_name[DIM] = "dim"; //
intrinsic_name[IDIM] = "idim";
intrinsic_name[DDIM] = "ddim";
intrinsic_name[MAX] = "max";
intrinsic_name[MAX0] = "max0";
intrinsic_name[AMAX1] = "amax1";
intrinsic_name[DMAX1] = "dmax1";
intrinsic_name[AMAX0] = "amax0";
intrinsic_name[MAX1] = "max1";
intrinsic_name[MIN] = "min"; //
intrinsic_name[MIN0] = "min0";
intrinsic_name[AMIN1] = "amin1";
intrinsic_name[DMIN1] = "dmin1";
intrinsic_name[AMIN0] = "amin0";
intrinsic_name[MIN1] = "min1";
intrinsic_name[LEN] = "len";
intrinsic_name[INDEX] = "index";
intrinsic_name[AIMAG] = "AIMAG"; //
intrinsic_name[DIMAG] = "DIMAG";
intrinsic_name[CONJG] = "conjg"; //
intrinsic_name[DCONJG]= "dconjg";
intrinsic_name[SQRT] = "sqrt"; //
intrinsic_name[DSQRT] = "dsqrt";
intrinsic_name[CSQRT] = "csqrt";
intrinsic_name[EXP] = "exp"; //
intrinsic_name[DEXP] = "dexp";
intrinsic_name[CEXP] = "cexp";
intrinsic_name[LOG] = "log"; //
intrinsic_name[ALOG] = "alog";
intrinsic_name[DLOG] = "dlog";
intrinsic_name[CLOG] = "clog";
intrinsic_name[LOG10] = "log10"; //
intrinsic_name[ALOG10]= "alog10";
intrinsic_name[DLOG10]= "dlog10";
intrinsic_name[SIN] = "sin"; //
intrinsic_name[DSIN] = "dsin";
intrinsic_name[CSIN] = "csin";
intrinsic_name[COS] = "cos"; //
intrinsic_name[DCOS] = "dcos";
intrinsic_name[CCOS] = "ccos";
intrinsic_name[TAN] = "tan"; //
intrinsic_name[DTAN] = "dtan";
intrinsic_name[ASIN] = "asin"; //
intrinsic_name[DASIN] = "dasin";
intrinsic_name[ACOS] = "acos"; //
intrinsic_name[DACOS] = "dacos";
intrinsic_name[ATAN] = "atan"; //
intrinsic_name[DATAN] = "datan";
intrinsic_name[ATAN2] = "atan2"; //
intrinsic_name[DATAN2]= "datan2";
intrinsic_name[SINH] = "sinh"; //
intrinsic_name[DSINH] = "dsinh";
intrinsic_name[COSH] = "cosh"; //
intrinsic_name[DCOSH] = "dcosh";
intrinsic_name[TANH] = "tanh"; //
intrinsic_name[DTANH] = "dtanh";
intrinsic_name[LGE] = "lge";
intrinsic_name[LGT] = "lgt";
intrinsic_name[LLE] = "lle";
intrinsic_name[LLT] = "llt";

46
projects/dvm/fdvm/trunk/InlineExpansion/makefile.uni Normal file
View File

@@ -0,0 +1,46 @@
#echo#######################################################################
# Makefile for Fortran DVM transformator
#
#echo#######################################################################
# dvm/fdvm/fdvm_transform/makefile.uni
SAGEROOT = ../Sage
LIBDIR = ../lib
BINDIR = ../../bin
LIBINCLUDE = $(SAGEROOT)/lib/include
HINCLUDE = $(SAGEROOT)/h
DVMINCLUDE = ../include
EXECUTABLES = inl_exp
LOADER = $(LINKER)
INCL = -I. -I$(LIBINCLUDE) -I$(HINCLUDE) -I$(DVMINCLUDE)
CFLAGS = -c $(INCL) -Wall
LDFLAGS =
LIBS = $(LIBDIR)/libSage++.a $(LIBDIR)/libsage.a $(LIBDIR)/libdb.a
OBJS = inl_exp.o inliner.o hlp.o
$(BINDIR)/$(EXECUTABLES): $(OBJS)
$(LOADER) $(LDFLAGS) -o $(BINDIR)/$(EXECUTABLES) $(OBJS) $(LIBS)
all: $(BINDIR)/$(EXECUTABLES)
@echo "****** COMPILING $(EXECUTABLES) DONE ******"
clean:
rm -f $(OBJS)
cleanall:
rm -f $(OBJS)
############################# dependencies ############################
inl_exp.o: inl_exp.cpp inline.h
$(CXX) $(CFLAGS) inl_exp.cpp
inliner.o: inliner.cpp inline.h
$(CXX) $(CFLAGS) inliner.cpp
hlp.o: hlp.cpp inline.h
$(CXX) $(CFLAGS) hlp.cpp

61
projects/dvm/fdvm/trunk/InlineExpansion/makefile.win Normal file
View File

@@ -0,0 +1,61 @@
#######################################################################
## Copyright (C) 1999 ##
## Keldysh Institute of Appllied Mathematics ##
#######################################################################
# dvm/fdvm/fdvm_transform/makefile.win
OUTDIR = ..\obj
BINDIR = ..\..\bin
LIBDIR = ..\lib
SAGEROOT =..\Sage
LIBINCLUDE = $(SAGEROOT)\lib\include
HINCLUDE = $(SAGEROOT)\h
FDVMINCL = ..\include
EXECUTABLES = inl_exp
INCL = -I. -I$(LIBINCLUDE) -I$(HINCLUDE) -I$(FDVMINCL)
# -w don't issue warning now.
#CFLAGS=/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D SYS5 $(INCL) \
# /Fp"$(OUTDIR)/fdvm_transform.pch" /YX /Fo"$(OUTDIR)/" /Fd"$(OUTDIR)/" /c
CFLAGS=/nologo /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D SYS5 $(INCL) \
/Fp"$(OUTDIR)/fdvm_transform.pch" /Fo"$(OUTDIR)/" /Fd"$(OUTDIR)/" /c
.cpp{$(OUTDIR)/}.obj:
$(CXX) $(CFLAGS) $<
LINK=$(LINKER)
LINK_FLAGS=/nologo /subsystem:console /incremental:no\
/pdb:"$(OUTDIR)\$(EXECUTABLES).pdb" /out:"$(BINDIR)\$(EXECUTABLES).exe"
LINK_FLAGS=/nologo /subsystem:console /incremental:no\
/pdb:"$(OUTDIR)\$(EXECUTABLES).pdb" /out:"$(BINDIR)\$(EXECUTABLES).exe"
OBJS = $(OUTDIR)/inl_exp.obj $(OUTDIR)/inliner.obj $(OUTDIR)/hlp.obj
LIBS = $(LIBDIR)/libSage++.lib $(LIBDIR)\libsage.lib $(LIBDIR)\libdb.lib
$(BINDIR)/$(EXECUTABLES).exe: $(OBJS)
$(LINK) @<<
$(LINK_FLAGS) $(OBJS) $(LIBS)
<<
all: $(BINDIR)/$(EXECUTABLES).exe
@echo "*** COMPILING EXECUTABLE $(EXECUTABLES) DONE"
clean:
cleanall:
# ***********************************************************
inl_exp.obj: inl_exp.cpp inline.h
inliner.obj: inliner.cpp inline.h
hlp.obj: hlp.cpp inline.h