virtual void
visit (SgNode * node)
{
SgExprStatement * isExprStatement = isSgExprStatement ( node );
if ( isExprStatement != NULL )
{
SgFunctionCallExp * functionCallExp = isSgFunctionCallExp ( isExprStatement->get_expression() );
if ( functionCallExp != NULL )
{
string const
calleeName =
functionCallExp->getAssociatedFunctionSymbol ()->get_name ().getString ();
Debug::getInstance ()->debugMessage ("Found function call in user subroutine "
+ calleeName + "'", Debug::OUTER_LOOP_LEVEL, __FILE__, __LINE__);
/*
* ======================================================
* As we are in fortran, all user subroutines must be
* SgProcedureHeaderStatements = subroutines and not
* functions. This might be extended to cover also
* functions in the future (?). Probably not in OP2
* ======================================================
*/
SgProcedureHeaderStatement * isProcedureHeaderStatement = isSgProcedureHeaderStatement (
functionCallExp->getAssociatedFunctionDeclaration() );
calledRoutines.push_back ( isProcedureHeaderStatement );
}
}
}
/*
* Fix op structure calls and inject debug names
*/
void OPSource::fixOpFunctions(SgNode *n)
{
SgName var_name;
SgFunctionCallExp *fn = isSgFunctionCallExp(n);
if(fn != NULL)
{
string fn_name = fn->getAssociatedFunctionDeclaration()->get_name().getString();
if(fn_name.compare("op_decl_const")==0)
{
SgExprListExp* exprList = fn->get_args();
SgExpressionPtrList &exprs = exprList->get_expressions();
if( isSgStringVal(exprs.back()) == NULL )
{
SgVarRefExp* varExp = isSgVarRefExp(exprs[1]);
if(!varExp)
{
varExp = isSgVarRefExp(isSgAddressOfOp(exprs[1])->get_operand_i());
}
if(varExp)
{
var_name = varExp->get_symbol()->get_name();
}
cout << "---Injecting Debug Name for const: " << var_name.getString() << "---" << endl;
exprList->append_expression(buildStringVal(var_name));
}
}
}
}
virtual void visit(SgNode *node) { /*override*/
SgFunctionCallExp *fcall = isSgFunctionCallExp(node);
SgFunctionDeclaration *fdecl = fcall ? fcall->getAssociatedFunctionDeclaration() : NULL;
std::string fname = fdecl ? fdecl->get_qualified_name().getString() : "";
if (SageInterface::is_Java_language()) {
if (0==fname.compare("System.getenv")) {
found.push_back(fcall);
CodeProperties::message(std::cout, fcall, "environment variable is read");
}
} else if (0==fname.compare("::getenv")) {
found.push_back(fcall);
CodeProperties::message(std::cout, fcall, "environment variable is read");
}
}
/*
* Replace the op_par_loop with respective kernel function
*/
void OPSource::fixParLoops(SgNode *n)
{
SgName kernel_name;
SgFunctionCallExp *fn = isSgFunctionCallExp(n);
if(fn != NULL)
{
string fn_name = fn->getAssociatedFunctionDeclaration()->get_name().getString();
if(fn_name.compare("op_par_loop_2")==0
|| fn_name.compare("op_par_loop_3")==0
|| fn_name.compare("op_par_loop_4")==0
|| fn_name.compare("op_par_loop_5")==0
|| fn_name.compare("op_par_loop_6")==0
|| fn_name.compare("op_par_loop_7")==0
|| fn_name.compare("op_par_loop_8")==0
|| fn_name.compare("op_par_loop_9")==0)
{
SgExprListExp* exprList = fn->get_args();
SgExpressionPtrList &exprs = exprList->get_expressions();
SgFunctionRefExp* varExp = isSgFunctionRefExp(exprs[0]);
if(varExp != NULL)
{
kernel_name = varExp->get_symbol()->get_name();
}
exprs.erase(exprs.begin());
SgExpressionPtrList::iterator it = exprs.begin() + op_par_loop_args::num_params - 1;
for(; it != exprs.end(); it += op_argument::num_params)
{
*it = buildCastExp( *it, buildPointerType(SgClassType::createType( buildStructDeclaration("op_dat<void>"))) );
}
// Inject Name
exprs.insert(exprs.begin(), buildStringVal(kernel_name));
// Fetch the declaration
SgName name = SgName("op_par_loop_") + kernel_name;
SgFunctionDeclaration *funcDecl = cudaFunctionDeclarations[kernel_name];
if(funcDecl)
{
SgFunctionRefExp* ref = isSgFunctionRefExp(fn->get_function());
SgFunctionSymbol *symbol = ref->get_symbol();
symbol->set_declaration(funcDecl);
ref->set_symbol(symbol);
fn->set_function(ref);
}
}
}
}
void visit(SgNode *n) {
switch (n->variantT()) {
case V_SgStatementExpression:
reportError("GNU extension 'statement expression' is not allowed.", n);
break;
case V_SgFunctionCallExp: {
SgFunctionCallExp *FCE = isSgFunctionCallExp(n);
SgFunctionDeclaration *calleeFD =
FCE->getAssociatedFunctionDeclaration();
if (!calleeFD) {
reportError("calls through function pointers are not allowed.", n);
}
break;
}
default:
break;
}
}
bool isHtThreadControlStmt(SgStatement *S)
{
SgExprStatement *es = isSgExprStatement(S);
SgFunctionCallExp *fce = 0;
if (es && (fce = isSgFunctionCallExp(es->get_expression()))) {
SgFunctionDeclaration *calleeFD = fce->getAssociatedFunctionDeclaration();
std::string fname = calleeFD->get_name().getString();
size_t pos = 0;
if (fname == "WriteMemPause" ||
fname == "ReadMemPause" ||
fname == "HtBarrier" ||
(((pos = fname.find("SendCall_")) != std::string::npos
/* || (pos = fname.find("SendCallFork_")) != std::string::npos */
|| (pos = fname.find("SendReturn_")) != std::string::npos
|| (pos = fname.find("RecvReturnJoin_")) != std::string::npos)
&& pos == 0)) {
return true;
}
}
return false;
}
void
FortranCUDAUserSubroutine::createStatements ()
{
using namespace SageInterface;
using boost::iequals;
using std::string;
using std::vector;
class TreeVisitor: public AstSimpleProcessing
{
private:
/*
* ======================================================
* The recursive visit of a user subroutine populates
* this vector with successive function calls which are
* then appended after the visit
* ======================================================
*/
vector < SgProcedureHeaderStatement * > calledRoutines;
public:
vector < SgProcedureHeaderStatement * > getCalledRoutinesInStatement()
{
return calledRoutines;
}
TreeVisitor ()
{
}
virtual void
visit (SgNode * node)
{
SgExprStatement * isExprStatement = isSgExprStatement ( node );
if ( isExprStatement != NULL )
{
SgFunctionCallExp * functionCallExp = isSgFunctionCallExp ( isExprStatement->get_expression() );
if ( functionCallExp != NULL )
{
string const
calleeName =
functionCallExp->getAssociatedFunctionSymbol ()->get_name ().getString ();
Debug::getInstance ()->debugMessage ("Found function call in user subroutine "
+ calleeName + "'", Debug::OUTER_LOOP_LEVEL, __FILE__, __LINE__);
/*
* ======================================================
* As we are in fortran, all user subroutines must be
* SgProcedureHeaderStatements = subroutines and not
* functions. This might be extended to cover also
* functions in the future (?). Probably not in OP2
* ======================================================
*/
SgProcedureHeaderStatement * isProcedureHeaderStatement = isSgProcedureHeaderStatement (
functionCallExp->getAssociatedFunctionDeclaration() );
calledRoutines.push_back ( isProcedureHeaderStatement );
}
}
}
};
Debug::getInstance ()->debugMessage ("User subroutine: outputting and modifying statements",
Debug::FUNCTION_LEVEL, __FILE__, __LINE__);
SgFunctionParameterList * originalParameters =
originalSubroutine->get_parameterList ();
vector <SgStatement *> originalStatements =
originalSubroutine->get_definition ()->get_body ()->get_statements ();
for (vector <SgStatement *>::iterator it = originalStatements.begin (); it
!= originalStatements.end (); ++it)
{
SgExprStatement * isExprStatement = isSgExprStatement ( *it );
if ( isExprStatement != NULL )
{
SgFunctionCallExp * functionCallExp = isSgFunctionCallExp ( isExprStatement->get_expression() );
if ( functionCallExp != NULL )
{
string const
calleeName =
functionCallExp->getAssociatedFunctionSymbol ()->get_name ().getString ();
Debug::getInstance ()->debugMessage ("Found function call in user subroutine "
+ calleeName + "'", Debug::OUTER_LOOP_LEVEL, __FILE__, __LINE__);
/*
* ======================================================
* As we are in fortran, all user subroutines must be
* SgProcedureHeaderStatements = subroutines and not
* functions. This might be extended to cover also
* functions in the future (probably not in OP2)
* ======================================================
*/
SgProcedureHeaderStatement * isProcedureHeaderStatement = isSgProcedureHeaderStatement (
functionCallExp->getAssociatedFunctionDeclaration() );
calledRoutines.push_back ( isProcedureHeaderStatement );
}
}
SgVariableDeclaration * isVariableDeclaration = isSgVariableDeclaration (
*it);
if (isVariableDeclaration == NULL)
{
/*
* ======================================================
* Do not append use statement, because other subroutines
* are directly appended to the CUDA module
* ======================================================
*/
SgUseStatement * isUseStmt = isSgUseStatement ( *it );
if (isUseStmt != NULL)
{
Debug::getInstance ()->debugMessage (
"Not appending use statement",
Debug::HIGHEST_DEBUG_LEVEL, __FILE__, __LINE__);
}
else
{
Debug::getInstance ()->debugMessage (
"Appending (non-variable-declaration) statement",
Debug::HIGHEST_DEBUG_LEVEL, __FILE__, __LINE__);
appendStatement (*it, subroutineScope);
/*
* ======================================================
* Recursively look for subroutine calls inside shallow
* nodes in the routines (e.g. when a call is inside an
* if). After the visit get the generated vector of names
* and append it to the userSubroutine vector
* ======================================================
*/
TreeVisitor * visitor = new TreeVisitor ();
visitor->traverse (*it, preorder);
Debug::getInstance ()->debugMessage ("Appending deep subroutine calls", Debug::OUTER_LOOP_LEVEL, __FILE__, __LINE__);
vector < SgProcedureHeaderStatement * > deepStatementCalls = visitor->getCalledRoutinesInStatement ();
vector < SgProcedureHeaderStatement * >::iterator itDeepCalls;
for (itDeepCalls = deepStatementCalls.begin(); itDeepCalls != deepStatementCalls.end(); ++itDeepCalls)
calledRoutines.push_back (*itDeepCalls);
Debug::getInstance ()->debugMessage ("Appending deep subroutine calls", Debug::OUTER_LOOP_LEVEL, __FILE__, __LINE__);
}
}
else
{
Debug::getInstance ()->debugMessage ("Appending variable declaration",
Debug::HIGHEST_DEBUG_LEVEL, __FILE__, __LINE__);
unsigned int OP_DAT_ArgumentGroup = 1;
for (SgInitializedNamePtrList::iterator variableIt =
isVariableDeclaration->get_variables ().begin (); variableIt
!= isVariableDeclaration->get_variables ().end (); ++variableIt)
{
string const variableName = (*variableIt)->get_name ().getString ();
SgType * type = (*variableIt)->get_typeptr ();
/*
* ======================================================
* Specification of "value" attribute is only
* for user kernels. Our call convention is that
* in all deeper level calls we always pass parameters
* by reference (see else branch below)
* ======================================================
*/
bool isFormalParamater = false;
for (SgInitializedNamePtrList::iterator paramIt =
originalParameters->get_args ().begin (); paramIt
!= originalParameters->get_args ().end (); ++paramIt, ++OP_DAT_ArgumentGroup)
{
string const formalParamterName = (*paramIt)->get_name ().getString ();
if (iequals (variableName, formalParamterName))
{
isFormalParamater = true;
if (parallelLoop->isIndirect (OP_DAT_ArgumentGroup)
&& parallelLoop->isRead (OP_DAT_ArgumentGroup))
{
Debug::getInstance ()->debugMessage ("'" + variableName
+ "' is an INDIRECT formal parameter which is READ",
Debug::HIGHEST_DEBUG_LEVEL, __FILE__, __LINE__);
SgVariableDeclaration * variableDeclaration;
if ( isUserKernel == true )
variableDeclaration =
FortranStatementsAndExpressionsBuilder::appendVariableDeclarationAsFormalParameter (
variableName, type, subroutineScope,
formalParameters, 0);
else
variableDeclaration =
FortranStatementsAndExpressionsBuilder::appendVariableDeclarationAsFormalParameter (
variableName, type, subroutineScope,
formalParameters, 0);
ROSE_ASSERT ( variableDeclaration != NULL );
}
else if (parallelLoop->isGlobal (OP_DAT_ArgumentGroup)
&& parallelLoop->isRead (OP_DAT_ArgumentGroup))
{
Debug::getInstance ()->debugMessage ("'" + variableName
+ "' is a GLOBAL formal parameter which is READ",
Debug::HIGHEST_DEBUG_LEVEL, __FILE__, __LINE__);
SgVariableDeclaration * variableDeclaration =
FortranStatementsAndExpressionsBuilder::appendVariableDeclarationAsFormalParameter (
variableName, type, subroutineScope, formalParameters, 0);
}
else
{
Debug::getInstance ()->debugMessage ("'" + variableName
+ "' is a formal parameter "
+ parallelLoop->getOpDatInformation (OP_DAT_ArgumentGroup),
Debug::HIGHEST_DEBUG_LEVEL, __FILE__, __LINE__);
if ( isUserKernel == true )
SgVariableDeclaration * variableDeclaration =
FortranStatementsAndExpressionsBuilder::appendVariableDeclarationAsFormalParameter (
variableName, type, subroutineScope, formalParameters, 0);
else
SgVariableDeclaration * variableDeclaration =
FortranStatementsAndExpressionsBuilder::appendVariableDeclarationAsFormalParameter (
variableName, type, subroutineScope, formalParameters, 0);
}
}
}
if (isFormalParamater == false)
{
Debug::getInstance ()->debugMessage ("'" + variableName
+ "' is NOT a formal parameter", Debug::HIGHEST_DEBUG_LEVEL,
__FILE__, __LINE__);
SgVariableDeclaration * variableDeclaration =
FortranStatementsAndExpressionsBuilder::appendVariableDeclaration (
variableName, type, subroutineScope);
}
}
}
}
}
InheritedAttribute
visitorTraversal::evaluateInheritedAttribute(SgNode* n, InheritedAttribute inheritedAttribute)
{
Sg_File_Info* s = n->get_startOfConstruct();
Sg_File_Info* e = n->get_endOfConstruct();
Sg_File_Info* f = n->get_file_info();
for(int x=0; x < inheritedAttribute.depth; ++x) {
printf(" ");
}
if(s != NULL && e != NULL && !isSgLabelStatement(n)) {
printf ("%s (%d, %d, %d)->(%d, %d): %s",n->sage_class_name(),s->get_file_id()+1,s->get_raw_line(),s->get_raw_col(),e->get_raw_line(),e->get_raw_col(), verbose ? n->unparseToString().c_str() : "" );
if(isSgAsmDwarfConstruct(n)) {
printf(" [DWARF construct name: %s]", isSgAsmDwarfConstruct(n)->get_name().c_str());
}
SgExprStatement * exprStmt = isSgExprStatement(n);
if(exprStmt != NULL) {
printf(" [expr type: %s]", exprStmt->get_expression()->sage_class_name());
SgFunctionCallExp * fcall = isSgFunctionCallExp(exprStmt->get_expression());
if(fcall != NULL) {
SgExpression * funcExpr = fcall->get_function();
if(funcExpr != NULL) {
printf(" [function expr: %s]", funcExpr->class_name().c_str());
}
SgFunctionDeclaration * fdecl = fcall->getAssociatedFunctionDeclaration();
if(fdecl != NULL) {
printf(" [called function: %s]", fdecl->get_name().str());
}
}
}
if(isSgFunctionDeclaration(n)) {
printf(" [declares function: %s]", isSgFunctionDeclaration(n)->get_name().str());
}
SgStatement * sgStmt = isSgStatement(n);
if(sgStmt != NULL) {
printf(" [scope: %s, %p]", sgStmt->get_scope()->sage_class_name(), sgStmt->get_scope());
}
//SgLabelStatement * lblStmt = isSgLabelStatement(n);
//if(lblStmt != NULL) {
// SgStatement * lblStmt2 = lblStmt->get_statement();
//}
} else if (f != NULL) {
SgInitializedName * iname = isSgInitializedName(n);
if(iname != NULL) {
SgType* inameType = iname->get_type();
printf("%s (%d, %d, %d): %s [type: %s", n->sage_class_name(),f->get_file_id()+1,f->get_raw_line(),f->get_raw_col(),n->unparseToString().c_str(),inameType->class_name().c_str());
SgDeclarationStatement * ds = isSgDeclarationStatement(iname->get_parent());
if(ds != NULL) {
if(ds->get_declarationModifier().get_storageModifier().isStatic()) {
printf(" static");
}
}
SgArrayType * art = isSgArrayType(iname->get_type());
if(art != NULL) {
printf(" %d", art->get_rank());
}
printf("]");
if(isSgAsmDwarfConstruct(n)) {
printf(" [DWARF construct name: %s]", isSgAsmDwarfConstruct(n)->get_name().c_str());
}
} else {
printf("%s (%d, %d, %d): %s", n->sage_class_name(),f->get_file_id()+1,f->get_raw_line(),f->get_raw_col(), verbose ? n->unparseToString().c_str() : "");
}
} else {
printf("%s : %s", n->sage_class_name(), verbose ? n->unparseToString().c_str() : "");
if(isSgAsmDwarfConstruct(n)) {
printf(" [DWARF construct name: %s]", isSgAsmDwarfConstruct(n)->get_name().c_str());
}
}
printf(" succ# %lu", n->get_numberOfTraversalSuccessors());
printf("\n");
return InheritedAttribute(inheritedAttribute.depth+1);
}