// This function is not used, but is useful for // generating the list of all global variables Rose_STL_Container<SgInitializedName*> buildListOfGlobalVariables ( SgProject* project ) { // This function builds a list of global variables (from a SgProject). Rose_STL_Container<SgInitializedName*> globalVariableList; const SgFilePtrList& fileList = project->get_fileList(); SgFilePtrList::const_iterator file = fileList.begin(); // Loop over the files in the project (multiple files exist // when multiple source files are placed on the command line). while(file != fileList.end()) { Rose_STL_Container<SgInitializedName*> fileGlobalVariableList = buildListOfGlobalVariables(isSgSourceFile(*file)); // DQ (9/26/2007): Moved from std::list to std::vector // globalVariableList.merge(fileGlobalVariableList); globalVariableList.insert(globalVariableList.begin(),fileGlobalVariableList.begin(),fileGlobalVariableList.end()); file++; } return globalVariableList; }
string CommandlineProcessing::generateStringFromArgList ( Rose_STL_Container<string> argList, bool skipInitialEntry, bool skipSourceFiles ) { string returnString; for (Rose_STL_Container<string>::iterator i = argList.begin(); i != argList.end(); ++i) { if (skipInitialEntry && i == argList.begin()) continue; if (skipSourceFiles == true) { string arg = *i; string suffix = ""; if (arg.length() > 2) suffix = arg.substr(arg.size() - 2); if (suffix == ".C" || arg.find("--edg:definition_list_file") == 0) { // DQ (5/13/2004): It was not a great idea to put this filter into this function // remove it and handle the filtering of definition_list_file better ... later! continue; } } // returnString += *i; returnString += *i + " "; } // printf ("In generateStringFromArgList(): returnString = %s \n",returnString.c_str()); return returnString; }
//! Convert a vector of string to a single string // std::string CommandlineProcessing::generateStringFromArgList( Rose_STL_Container<std::string> & argList) std::string CommandlineProcessing::generateStringFromArgList( const Rose_STL_Container<std::string> & argList) { string result; Rose_STL_Container<std::string>::const_iterator iter; for (iter = argList.begin(); iter != argList.end(); iter ++) { if (iter !=argList.begin()) result += " "; result += *iter; } return result; }
int main(int argc, char** argv) { //Parse command-line args ProgramOptions po(argc, argv); //Initialize the AST SgProject* project = new SgProject(argc, argv); ROSE_ASSERT(project); AstTests::runAllTests(project); //TODO switch on/off with command-line args //Set the folder containing the features string featureFolder = ""; bool defaultFeatures = po.getFeaturesFolder(featureFolder); if(!defaultFeatures) CallScheduler::setFeaturesFolder(featureFolder); //Loop through all partitioned kernels and add scheduling calls Rose_STL_Container<SgNode*> pragmas = querySubTree(project, V_SgPragmaDeclaration); Rose_STL_Container<SgNode*>::const_iterator pragmaIt = pragmas.begin(); SgPragmaDeclaration* pragma = NULL; SgFunctionDeclaration* funcDecl = NULL; SgStatement* stmt = NULL; for(pragmaIt = pragmas.begin(); pragmaIt != pragmas.end(); pragmaIt++) { pragma = isSgPragmaDeclaration(*pragmaIt); ROSE_ASSERT(pragma); PragmaParser pp(pragma); if(pp.isPopcornPragma() && pp.getPragmaType() == PARTITIONED) { stmt = getNextStatement(pragma); while(!isSgFunctionDeclaration(stmt)) stmt = getNextStatement(pragma); funcDecl = isSgFunctionDeclaration(stmt); ROSE_ASSERT(funcDecl); Pragmas pragmas(funcDecl); //Add scheduling calls CallScheduler cs(funcDecl, pragmas); cs.addSchedulerCalls(); //Insert the header //TODO this won't insert the header into files insertHeader(po.getSchedulerHeaderLocation(), PreprocessingInfo::after, false, getGlobalScope(funcDecl)); } } return backend(project); }
int main ( int argc, char* argv[] ) { ROSE_INITIALIZE; if (SgProject::get_verbose() > 0) printf ("In preprocessor.C: main() \n"); SgProject* project = frontend(argc,argv); ROSE_ASSERT (project != NULL); Rose_STL_Container<SgNode*> nodeList; nodeList = NodeQuery::querySubTree (project,V_SgForStatement); printf ("\nnodeList.size() = %zu \n",nodeList.size()); Rose_STL_Container<SgNode*>::iterator i = nodeList.begin(); while (i != nodeList.end()) { Sg_File_Info & fileInfo = *((*i)->get_file_info()); printf ("Query node = %p = %s in %s \n ----- at line %d on column %d \n", *i,(*i)->sage_class_name(),fileInfo.get_filename(), fileInfo.get_line(), fileInfo.get_col()); i++; } if (project->get_verbose() > 0) printf ("Calling the backend() \n"); return 0; }
int main(int argc, char *argv[]) { SgProject* sageProject = frontend(argc,argv); AstTests::runAllTests(sageProject); Rose_STL_Container <SgNode*> functions = NodeQuery::querySubTree(sageProject, V_SgFunctionDefinition); for (Rose_STL_Container <SgNode*>::const_iterator i = functions.begin(); i != functions.end(); ++i) { SgFunctionDefinition* proc = isSgFunctionDefinition(*i); ROSE_ASSERT (proc); string file_name = StringUtility::stripPathFromFileName(proc->get_file_info()->get_filename()); string file_func_name= file_name+ "_"+proc->get_mangled_name().getString(); string full_output = file_func_name +"_scfg.dot"; // Full CFG graph StaticCFG::CFG cfg(proc); cfg.buildFullCFG(); cfg.cfgToDot(proc, full_output); #if 0 // not ready string simple_output = file_func_name +"_simple_vcfg.dot"; std::ofstream simplegraph(simple_output.c_str()); // Simplified CFG suitable for most analyses // This will cause assertion failure //StaticCFG::cfgToDot(simplegraph, proc->get_declaration()->get_name(), StaticCFG::makeInterestingCfg(proc)); // This will generate identical graph as cfgToDotForDebugging () StaticCFG::cfgToDot(simplegraph, proc->get_declaration()->get_name(), proc->cfgForBeginning()); #endif } return 0; }
/****************************************** * Traversal over all functions * this needs to be improved... for correctness, the traversal must * be according to controlflow (otherwise global variables are incorrect) *****************************************/ bool DefUseAnalysis::start_traversal_of_functions() { if (DEBUG_MODE) cout << "START: Traversal over Functions" << endl; nrOfNodesVisited = 0; dfaFunctions.clear(); // Traverse through each FunctionDefinition and check for DefUse Rose_STL_Container<SgNode*> functions = NodeQuery::querySubTree(project, V_SgFunctionDefinition); DefUseAnalysisPF* defuse_perfunc = new DefUseAnalysisPF(DEBUG_MODE, this); bool abortme=false; for (Rose_STL_Container<SgNode*>::const_iterator i = functions.begin(); i != functions.end(); ++i) { SgFunctionDefinition* proc = isSgFunctionDefinition(*i); if (DEBUG_MODE) cout << "\t function Def@"<< proc->get_file_info()->get_filename() <<":" << proc->get_file_info()->get_line() << endl; FilteredCFGNode <IsDFAFilter> rem_source = defuse_perfunc->run(proc,abortme); nrOfNodesVisited += defuse_perfunc->getNumberOfNodesVisited(); //cout << nrOfNodesVisited << " ......... function " << proc->get_declaration()->get_name().str() << endl; if (rem_source.getNode()!=NULL) dfaFunctions.push_back(rem_source); } delete defuse_perfunc; if (DEBUG_MODE) { dfaToDOT(); } if (DEBUG_MODE) cout << "FINISH: Traversal over Functions" << endl; return abortme; }
int main( int argc, char * argv[] ) { // Build the AST used by ROSE SgProject* project = frontend(argc,argv); generatePDF ( *project ); Rose_STL_Container<SgNode*> functions = NodeQuery::querySubTree(project, V_SgFunctionDefinition); for (Rose_STL_Container<SgNode*>::const_iterator i = functions.begin(); i != functions.end(); ++i) { SgFunctionDefinition* curFunc = isSgFunctionDefinition(*i); ROSE_ASSERT(curFunc); SgBasicBlock *funcBody = curFunc->get_body(); InterestingNode funcCFGStart = (InterestingNode)funcBody->cfgForBeginning();; // output the CFG to a file ofstream fileCFG; fileCFG.open((curFunc->get_declaration()->get_name().getString()+"_cfg.dot").c_str()); cout << "writing to file "<<(curFunc->get_declaration()->get_name().getString()+"_cfg.dot")<<"\n"; VirtualCFG::cfgToDot(fileCFG, curFunc->get_declaration()->get_name(), funcCFGStart); fileCFG.close(); } // Unparse and compile the project (so this can be used for testing) return backend(project); }
// obtain read or write variables processed by all nested loops, if any void getVariablesProcessedByInnerLoops (SgScopeStatement* current_loop_body, bool isRead, std::set<SgInitializedName*>& var_set) { // AST query to find all loops // add all read/write variables into the var_set VariantVector vv; vv.push_back(V_SgForStatement); vv.push_back(V_SgFortranDo); Rose_STL_Container<SgNode*> nodeList = NodeQuery::querySubTree(current_loop_body, vv); for (Rose_STL_Container<SgNode *>::iterator i = nodeList.begin(); i != nodeList.end(); i++) { SgStatement* loop = isSgStatement(*i); if (debug) cout<< "Found nested loop at line:"<< loop->get_file_info()->get_line()<<endl; std::set<SgInitializedName*> src_var_set ; if (isRead) src_var_set = LoopLoadVariables[loop]; else src_var_set = LoopStoreVariables[loop]; std::set<SgInitializedName*>::iterator j; if (debug) cout<< "\t Insert processed variable:"<<endl; for (j= src_var_set.begin(); j!= src_var_set.end(); j++) { var_set.insert(*j); if (debug) cout<< "\t \t "<<(*j)->get_name()<<endl; } } }
int main(int argc, char* argv[]) { SgProject* project = frontend(argc, argv); std::vector<SgIfStmt*> ifs = SageInterface::querySubTree<SgIfStmt>(project, V_SgIfStmt); BOOST_FOREACH(SgIfStmt* if_stmt, ifs) { if (SgExpression *se = isSgExprStatement(if_stmt->get_conditional())->get_expression()) { cout << "--->" << se->unparseToString() << "<---" << endl; Rose_STL_Container<SgNode*> variableList = NodeQuery::querySubTree(se, V_SgVarRefExp); for (Rose_STL_Container<SgNode*>::iterator i = variableList.begin(), end = variableList.end(); i != end; i++) { SgVarRefExp *varRef = isSgVarRefExp(*i); SgVariableSymbol *currSym = varRef->get_symbol(); cout << "Looking at: --|" << currSym->get_name().str() << "|--" << endl; SgDeclarationStatement *decl = currSym->get_declaration()->get_declaration(); cout << "declaration: " << decl->unparseToString() << endl; SgConstVolatileModifier cvm = decl->get_declarationModifier().get_typeModifier().get_constVolatileModifier(); bool constness = cvm.isConst(); cout << "constness via isConst(): " << constness << endl; cout << cvm.displayString() << endl; } } } return 0; }
void CudaOptimizer::getArrayReferenceCounts(SgBasicBlock* kernel_body, std::map<SgInitializedName*, int>& varCount_map) { Rose_STL_Container<SgNode*> arrList = NodeQuery::querySubTree(kernel_body, V_SgPntrArrRefExp); Rose_STL_Container<SgNode*>::iterator arr; for(arr = arrList.begin(); arr != arrList.end(); arr++) { SgExpression* arrayName; vector<SgExpression*> subscripts; //first index is i if E[j][i] //index list are from right to left bool yes = MintArrayInterface::isArrayReference(isSgExpression(*arr), &arrayName, &subscripts); assert(yes); SgInitializedName *i_name = SageInterface::convertRefToInitializedName(isSgVarRefExp (arrayName)); //this is the first time the var appears if(varCount_map.find(i_name) == varCount_map.end()) varCount_map[i_name] = 0; varCount_map[i_name]++; int arrayDim = subscripts.size() ; arr = arr + arrayDim - 1; } }
void CFG::buildFullCFG() { // Before building a new CFG, make sure to clear all nodes built before. all_nodes_.clear(); clearNodesAndEdges(); std::set<VirtualCFG::CFGNode> explored; graph_ = new SgIncidenceDirectedGraph; if (SgProject* project = isSgProject(start_)) { Rose_STL_Container<SgNode*> functions = NodeQuery::querySubTree(project, V_SgFunctionDefinition); for (Rose_STL_Container<SgNode*>::const_iterator i = functions.begin(); i != functions.end(); ++i) { SgFunctionDefinition* proc = isSgFunctionDefinition(*i); if (proc) { buildCFG<VirtualCFG::CFGNode, VirtualCFG::CFGEdge> (proc->cfgForBeginning(), all_nodes_, explored); } } } else buildCFG<VirtualCFG::CFGNode, VirtualCFG::CFGEdge> (start_->cfgForBeginning(), all_nodes_, explored); }
void CFG::buildFilteredCFG() { all_nodes_.clear(); clearNodesAndEdges(); std::set<VirtualCFG::InterestingNode> explored; std::map<VirtualCFG::InterestingNode, SgGraphNode*> all_nodes; graph_ = new SgIncidenceDirectedGraph; if (SgProject* project = isSgProject(start_)) { Rose_STL_Container<SgNode*> functions = NodeQuery::querySubTree(project, V_SgFunctionDefinition); for (Rose_STL_Container<SgNode*>::const_iterator i = functions.begin(); i != functions.end(); ++i) { SgFunctionDefinition* proc = isSgFunctionDefinition(*i); if (proc) { buildCFG<VirtualCFG::InterestingNode, VirtualCFG::InterestingEdge> (VirtualCFG::makeInterestingCfg(proc), all_nodes, explored); } } } else buildCFG<VirtualCFG::InterestingNode, VirtualCFG::InterestingEdge> (VirtualCFG::makeInterestingCfg(start_), all_nodes, explored); typedef std::pair<VirtualCFG::InterestingNode, SgGraphNode*> pair_t; foreach (const pair_t& p, all_nodes) all_nodes_[VirtualCFG::CFGNode(p.first.getNode(), 0)] = p.second; }
static string chooseConstructor(SgProject* project) { static const char * const d_constructor_names[] = { "init", "initialize", "prepare", "ready", "outfit", NULL }; static FunctionNameSet functionNames; Rose_STL_Container<SgNode*> functionDeclarationList = NodeQuery::querySubTree(project, V_SgFunctionDeclaration); for(Rose_STL_Container<SgNode*>::iterator i = functionDeclarationList.begin(); i != functionDeclarationList.end(); ++i) { SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(*i); ROSE_ASSERT(functionDeclaration != NULL); functionNames.insert(functionDeclaration->get_name().str()); } FunctionNameSet::iterator notFound = functionNames.end(); for(const char * const *j = d_constructor_names; *j ; ++j) { string candidate = *j; if (functionNames.find(candidate) == notFound) return candidate; } return ""; }
int main(int argc, char *argv[]) { // Build the AST used by ROSE SgProject* sageProject = frontend(argc,argv); // Process all function definition bodies for static control flow graph generation Rose_STL_Container<SgNode*> functions = NodeQuery::querySubTree(sageProject, V_SgFunctionDefinition); for (Rose_STL_Container<SgNode*>::const_iterator i = functions.begin(); i != functions.end(); ++i) { SgFunctionDefinition* proc = isSgFunctionDefinition(*i); ROSE_ASSERT (proc != NULL); string fileName= StringUtility::stripPathFromFileName(proc->get_file_info()->get_filenameString()); string dotFileName1=fileName+"."+ proc->get_declaration()->get_name() +".debug.dot"; string dotFileName2=fileName+"."+ proc->get_declaration()->get_name() +".interesting.dot"; StaticCFG::CFG cfg(proc); // Dump out the full CFG, including bookkeeping nodes cfg.buildFullCFG(); cfg.cfgToDot(proc, dotFileName1); // Dump out only those nodes which are "interesting" for analyses cfg.buildFilteredCFG(); cfg.cfgToDot(proc, dotFileName2); } return 0; }
// normalize all loops within candidate function definitions void normalizeLoops (std::vector<SgFunctionDefinition* > candidateFuncDefs) { for (std::vector<SgFunctionDefinition* >::iterator iter = candidateFuncDefs.begin(); iter != candidateFuncDefs.end(); iter++) { SgFunctionDefinition* funcDef = *iter; ROSE_ASSERT (funcDef); // This has to happen before analyses are called. // For each loop VariantVector vv (V_SgForStatement); Rose_STL_Container<SgNode*> loops = NodeQuery::querySubTree(funcDef, vv); if (enable_debug) cout<<"Normalize loops queried from memory pool ...."<<endl; // normalize C99 style for (int i= x, ...) to C89 style: int i; (i=x, ...) // Liao, 10/22/2009. Thank Jeff Keasler for spotting this bug for (Rose_STL_Container<SgNode*>::iterator iter = loops.begin(); iter!= loops.end(); iter++ ) { SgForStatement* cur_loop = isSgForStatement(*iter); ROSE_ASSERT(cur_loop); if (enable_debug) cout<<"\t loop at:"<< cur_loop->get_file_info()->get_line() <<endl; // skip for (;;) , SgForStatement::get_test_expr() has a buggy assertion. SgStatement* test_stmt = cur_loop->get_test(); if (test_stmt!=NULL && isSgNullStatement(test_stmt)) { if (enable_debug) cout<<"\t skipped due to empty loop header like for (;;)"<<endl; continue; } // skip system header if (insideSystemHeader (cur_loop) ) { if (enable_debug) cout<<"\t skipped since the loop is inside a system header "<<endl; continue; } #if 0 // we now always normalize loops, then later undo some normalization 6/22/2016 // SageInterface::normalizeForLoopInitDeclaration(cur_loop); if (keep_c99_loop_init) { // 2/29/2016, disable for loop init declaration normalization // This is not used . No longer used. normalizeForLoopTest(cur_loop); normalizeForLoopIncrement(cur_loop); ensureBasicBlockAsBodyOfFor(cur_loop); constantFolding(cur_loop->get_test()); constantFolding(cur_loop->get_increment()); } else #endif SageInterface::forLoopNormalization(cur_loop); } // end for all loops } // end for all function defs }
Function::Function(string name) { //printf("Function::Function(string name) this=0x%x\n", this); //def = NULL; Rose_STL_Container<SgNode*> functions = NodeQuery::querySubTree(cfgUtils::project, V_SgFunctionDeclaration); for (Rose_STL_Container<SgNode*>::const_iterator it = functions.begin(); it != functions.end(); it++) { ROSE_ASSERT(isSgFunctionDeclaration(*it)); if(isSgFunctionDeclaration(*it)->get_name().getString() == name) { // decl will be initialized to the defining declaration of this function or // the first non-defining declaratio,n if there is no definition decl = getCanonicalDecl(isSgFunctionDeclaration(*it)); break; /*decls.insert(isSgFunctionDeclaration(*it)); if(isSgFunctionDeclaration(*it)->get_definition()) { // save the current function's definition inside def // ensure that either def has not been set yet or that there is a unique definition if(def==NULL) def = isSgFunctionDeclaration(*it)->get_definition(); else ROSE_ASSERT(def == isSgFunctionDeclaration(*it)->get_definition()); }*/ } } // every function must have at least one declaration //ROSE_ASSERT(decls.size()>0); ROSE_ASSERT(decl); }
void CompassAnalyses::SizeOfPointer::Traversal:: visit(SgNode* node) { int starCount; SgSizeOfOp *szOf = isSgSizeOfOp(node); if(!szOf) return; Rose_STL_Container<SgNode*> pointers = NodeQuery::querySubTree(node,V_SgPointerType); Rose_STL_Container<SgNode*> deRefs = NodeQuery::querySubTree(node,V_SgPointerDerefExp); Rose_STL_Container<SgNode*> varRefs = NodeQuery::querySubTree(node,V_SgVarRefExp); for (Rose_STL_Container<SgNode *>::iterator i = varRefs.begin(); i != varRefs.end(); i++) { SgVarRefExp *vRef = isSgVarRefExp((*i)); if (!vRef) return; SgType *t = vRef->get_type(); std::string typeName = t->unparseToString(); //std::cout << countStars(typeName) << std::endl; starCount = countStars(typeName); if (!starCount or (starCount == pointers.size() and deRefs.size() == (starCount - 1))) { //std::cout << "IT'S OK!" << std::endl; return; } } output->addOutput(new CheckerOutput(node)); } //End of the visit function.
NameQuerySynthesizedAttributeType NameQuery::queryNodeList ( Rose_STL_Container<SgNode*> nodeList, std::string targetNode, NameQuery::TypeOfQueryTypeTwoParameters elementReturnType ){ return AstQueryNamespace::queryRange(nodeList.begin(), nodeList.end(), std::bind2nd(getFunction(elementReturnType), targetNode)); };
NameQuerySynthesizedAttributeType NameQuery::queryNodeList ( Rose_STL_Container<SgNode*> nodeList, std::string targetNode, NameQuery::roseFunctionPointerTwoParameters querySolverFunction ){ return AstQueryNamespace::queryRange(nodeList.begin(), nodeList.end(), std::bind2nd(std::ptr_fun(querySolverFunction), targetNode)); // std::bind2nd(getFunction(elementReturnType),traversal), defineQueryType); };
void transformGlobalVariablesToUseStruct ( SgSourceFile *file ) { assert(file != NULL); // These are the global variables in the input program (provided as helpful information) Rose_STL_Container<SgInitializedName*> globalVariables = buildListOfGlobalVariables(file); #if OUTPUT_NAMES_OF_GLOBAL_VARIABLES printf ("global variables (declared in global scope): \n"); for (Rose_STL_Container<SgInitializedName*>::iterator var = globalVariables.begin(); var != globalVariables.end(); var++) { printf (" %s \n",(*var)->get_name().str()); } printf ("\n"); #endif // get the global scope within the first file (currently ignoring all other files) SgGlobal* globalScope = file->get_globalScope(); assert(globalScope != NULL); // Build the class declaration SgClassDeclaration* classDeclaration = buildClassDeclarationAndDefinition("AMPI_globals_t",globalScope); // Put the global variables intothe class SgVariableSymbol* globalClassVariableSymbol = putGlobalVariablesIntoClass(globalVariables,classDeclaration); // Their associated symbols will be located within the project's AST // (where they occur in variable reference expressions). Rose_STL_Container<SgVarRefExp*> variableReferenceList = buildListOfVariableReferenceExpressionsUsingGlobalVariables(file); #if OUTPUT_NAMES_OF_GLOBAL_VARIABLE_REFERENCES printf ("global variables appearing in the application: \n"); for (Rose_STL_Container<SgVarRefExp*>::iterator var = variableReferenceList.begin(); var != variableReferenceList.end(); var++) { printf (" %s \n",(*var)->get_symbol()->get_declaration()->get_name().str()); } printf ("\n"); #endif // Fixup all references to global variable to access the variable through the class ("x" --> "AMPI_globals.x") fixupReferencesToGlobalVariables(variableReferenceList,globalClassVariableSymbol); }
static bool ContainsNonSimpleCall(SgStatement *stmt) { static std::set< std::string > segDB ; bool containsUnknownCall = false ; if (segDB.empty()) { char funcName[128] ; FILE *fp ; if ((fp = fopen("SegDB.txt", "r")) != NULL) { while(fgets(funcName, 128, fp)) { funcName[strlen(funcName)-1] = 0 ; segDB.insert(funcName) ; } fclose(fp) ; } else { printf("File SEGDB.txt is absent. Sequential segment results degraded.\n") ; segDB.insert("_____") ; } } /* check to see if this statement contains any function calls */ Rose_STL_Container<SgNode*> calls = NodeQuery::querySubTree(stmt, V_SgFunctionCallExp) ; for (Rose_STL_Container<SgNode*>::iterator c_itr = calls.begin(); c_itr != calls.end(); ++c_itr) { SgFunctionCallExp *stmt = isSgFunctionCallExp(*c_itr) ; ROSE_ASSERT(stmt); SgFunctionRefExp *func = isSgFunctionRefExp(stmt->get_function()) ; if (func != NULL) { SgFunctionSymbol *funcName = func->get_symbol() ; if (segDB.find(funcName->get_name().getString()) == segDB.end()) { containsUnknownCall = true ; break ; } } else { /* Since I can't handle this case, assume the worst -- for now */ containsUnknownCall = true ; break ; } } return containsUnknownCall ; }
bool MintArrayInterface::isStencilArray(std::vector<SgExpression*> expList) { //takes all the references of an array in a exp list //returns if the accesses are to the north, south, east or west //Assumes arrays are not represented in 1-dim. (do I handle only 2D? ) //Example :expList contains E[i][j], E[i][j+1], E[i][j-1] then return "yes" it is stencil // :expList contains E[i][j], E[i][j], E[i][j] then return NO. //we need a better way to determine if an accesses is strided access. std::vector<SgExpression*>::iterator it; for(it = expList.begin(); it != expList.end(); it++) { SgExpression* exp = (*it); Rose_STL_Container<SgNode*> arrList = NodeQuery::querySubTree(exp, V_SgPntrArrRefExp); Rose_STL_Container<SgNode*>::iterator arr; for(arr = arrList.begin(); arr != arrList.end(); arr++) { SgExpression* arrayName; vector<SgExpression*> subscripts; //first index is i if E[j][i] //index list are from right to left bool yes = MintArrayInterface::isArrayReference(isSgExpression(*arr), &arrayName, &subscripts); assert(yes); vector<SgExpression*>::iterator indexExp; for(indexExp = subscripts.begin(); indexExp != subscripts.end(); indexExp++) { //looking for minus, plus 1s: i-1, j+1 Rose_STL_Container<SgNode*> constExp = NodeQuery::querySubTree(*indexExp, V_SgIntVal); Rose_STL_Container<SgNode*> indexVarExp = NodeQuery::querySubTree(*indexExp, V_SgVarRefExp); //should I check if it is 0 ? if(constExp.size() > 0 && indexVarExp.size()> 0){ return true; } } int arrayDim = subscripts.size() ; arr = arr + arrayDim - 1; } } return false; }
/* * Initialized the function interface object. */ FunctionInterface::FunctionInterface(SgFunctionDeclaration* p_function, SgGraphNode* p_node) : function(p_function), node(p_node), status(NOT_ANALYZED), shouldAnnotate(false) { //See if this function contains OpenMP pragmas - if so, annotate Rose_STL_Container<SgNode*> pragmas = querySubTree(p_function, V_SgPragmaDeclaration); Rose_STL_Container<SgNode*>::const_iterator pragmaIt = pragmas.begin(); SgPragmaDeclaration* pragma; for(pragmaIt = pragmas.begin(); pragmaIt != pragmas.end(); pragmaIt++) { pragma = isSgPragmaDeclaration(*pragmaIt); ROSE_ASSERT(pragma != NULL); if(extractPragmaKeyword(pragma) == "omp") { shouldAnnotate = true; break; } } }
void mlmTransform::insertHeaders(SgProject* project) { Rose_STL_Container<SgNode*> globalList = NodeQuery::querySubTree (project,V_SgGlobal); for(Rose_STL_Container<SgNode*>::iterator i = globalList.begin(); i != globalList.end(); i++) { SgGlobal* global = isSgGlobal(*i); ROSE_ASSERT(global); PreprocessingInfo* headerInfo = insertHeader("mlm.h",PreprocessingInfo::after,false,global); headerInfo->set_file_info(global->get_file_info()); } return; //assume always successful currently }
void printNodeList ( const Rose_STL_Container<SgNode*> & localList ) { // Supporting function for querySolverGrammarElementFromVariantVector int counter = 0; printf ("Output node list: \n"); for (Rose_STL_Container<SgNode*>::const_iterator i = localList.begin(); i != localList.end(); i++) { // printf ("Adding node to list! \n"); printf (" list element #%d = %s \n",counter,(*i)->sage_class_name()); counter++; } }
void mergeList ( NodeQuerySynthesizedAttributeType & nodeList, const Rose_STL_Container<SgNode*> & localList ) { // Supporting function for querySolverGrammarElementFromVariantVector unsigned localListSize = localList.size(); unsigned nodeListSize = nodeList.size(); for (Rose_STL_Container<SgNode*>::const_iterator i = localList.begin(); i != localList.end(); i++) { // printf ("Adding node to list (%s) \n",(*i)->sage_class_name()); nodeList.push_back(*i); } ROSE_ASSERT (nodeList.size() == nodeListSize+localListSize); }
//! Remove file names specified in filenameList from argv, except for 'exceptFilename' void CommandlineProcessing::removeAllFileNamesExcept ( vector<string> & argv, Rose_STL_Container<std::string> filenameList, std::string exceptFilename ) { #if 0 printf ("In CommandlineProcessing::removeAllFileNamesExcept exceptFilename = %s \n",exceptFilename.c_str()); printf ("In removeAllFileNamesExcept (at top): argv = \n%s \n",StringUtility::listToString(argv).c_str()); printf ("In removeAllFileNamesExcept (at top): filenameList = \n%s \n",StringUtility::listToString(filenameList).c_str()); #endif for (unsigned int i=0; i < argv.size(); i++) { string argString = argv[i]; #if 0 printf ("i = %u argString = %s \n",i,argString.c_str()); #endif Rose_STL_Container<std::string>::iterator filenameIterator = filenameList.begin(); while (filenameIterator != filenameList.end()) { #if 0 printf ("filenameIterator = %s \n",filenameIterator->c_str()); #endif // DQ (1/17/2009): This is a match with filenameIterator = a.out and argString = a.out.new! // I think we only want to do anything about exact matches. // if ( argString.substr(0,filenameIterator->size()) == *filenameIterator ) if ( argString == *filenameIterator ) { #if 0 printf ("Found a file name (removeAllFileNamesExcept): %s \n",argString.c_str()); #endif if (*filenameIterator != exceptFilename) { #if 0 printf ("*filenameIterator != exceptFilename so erase end of argv for i = %u \n",i); #endif // This is not an iterator invalidation error, but it is strange code! argv.erase(argv.begin() + i); --i; // To counteract the i++ in the loop header #if 0 printf ("After erase: i = %u argv = \n%s \n",i,StringUtility::listToString(argv).c_str()); #endif } } filenameIterator++; } } #if 0 printf ("Leaving removeAllFileNamesExcept (at bottom): argv = \n%s \n",StringUtility::listToString(argv).c_str()); #endif }
int main( int argc, char * argv[] ) { // Build the AST used by ROSE SgProject* project = frontend(argc,argv); ROSE_ASSERT(project != NULL); // Build a list of functions within the AST Rose_STL_Container<SgNode*> functionCallList = NodeQuery::querySubTree (project,V_SgFunctionCallExp); int functionCounter = 0; for (Rose_STL_Container<SgNode*>::iterator i = functionCallList.begin(); i != functionCallList.end(); i++) { SgExpression* functionExpression = isSgFunctionCallExp(*i)->get_function(); ROSE_ASSERT(functionExpression != NULL); SgFunctionRefExp* functionRefExp = isSgFunctionRefExp(functionExpression); SgFunctionSymbol* functionSymbol = NULL; if (functionRefExp != NULL) { // Case of non-member function functionSymbol = functionRefExp->get_symbol(); } else { // Case of member function (hidden in rhs of binary dot operator expression) SgDotExp* dotExp = isSgDotExp(functionExpression); ROSE_ASSERT(dotExp != NULL); functionExpression = dotExp->get_rhs_operand(); SgMemberFunctionRefExp* memberFunctionRefExp = isSgMemberFunctionRefExp(functionExpression); ROSE_ASSERT(memberFunctionRefExp != NULL); functionSymbol = memberFunctionRefExp->get_symbol(); } ROSE_ASSERT(functionSymbol != NULL); SgFunctionDeclaration* functionDeclaration = functionSymbol->get_declaration(); ROSE_ASSERT(functionDeclaration != NULL); // Output mapping of function calls to function declarations printf ("Location of function call #%d at line %d resolved by overloaded function declared at line %d \n", functionCounter++, isSgFunctionCallExp(*i)->get_file_info()->get_line(), functionDeclaration->get_file_info()->get_line()); } return 0; }
void CompassAnalyses::ExplicitTestForNonBooleanValue::Traversal:: visit(SgNode* node) { // Implement your traversal here. // 1. conditional expression if(NULL != isSgBasicBlock(node)) { Rose_STL_Container<SgNode*> conditionalExpList = NodeQuery::querySubTree(node, V_SgConditionalExp); for(Rose_STL_Container<SgNode*>::iterator i=conditionalExpList.begin(); i != conditionalExpList.end(); i++) { SgConditionalExp* conditionalExp = isSgConditionalExp(*i); //ROSE_ASSERT(conditionalExp != NULL); if(NULL != conditionalExp && NULL != isSgCastExp(conditionalExp->get_conditional_exp())) { output->addOutput(new CheckerOutput(conditionalExp)); } } } else { SgExprStatement* exprStatement = NULL; // 2. test statement in a if statement SgIfStmt* ifStmt = isSgIfStmt(node); if(NULL != ifStmt) exprStatement = isSgExprStatement(ifStmt->get_conditional()); // 3. test statement in a while statement SgWhileStmt* whileStmt = isSgWhileStmt(node); if(NULL != whileStmt) exprStatement = isSgExprStatement(whileStmt->get_condition()); // 4. test statement in a do-while statement SgDoWhileStmt* doWhileStmt = isSgDoWhileStmt(node); if(NULL != doWhileStmt) exprStatement = isSgExprStatement(doWhileStmt->get_condition()); // 5. test statement in a for statement SgForStatement* forStatement = isSgForStatement(node); if(NULL != forStatement) exprStatement = isSgExprStatement(forStatement->get_test()); if(NULL != exprStatement && NULL != isSgCastExp(exprStatement->get_expression())) { output->addOutput(new CheckerOutput(node)); } } } //End of the visit function.