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); }
// 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 }
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; }
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.
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; }
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; }
// 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; } } }
/****************************************** * 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; }
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; } }
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; }
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); }
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; }
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); };
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; }
//! 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; }
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 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); }
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++; } }
//! 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 }
QStringList ProjectNode::getCommandLine() const { QStringList res; Rose_STL_Container<std::string> arglist; arglist = sgProject->get_originalCommandLineArgumentList(); Rose_STL_Container<std::string>::iterator iter; for(iter = arglist.begin(); iter != arglist.end(); ++iter ) res << iter->c_str(); return res; }
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[] ) { // 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 registerAstSubtreeIds (SgNode* root) { // We only care about located nodes for now since they are visible to users in source code // we have to include SgProject and SgSourceFile nodes also. VariantVector vv; vv.push_back(V_SgProject); vv.push_back(V_SgSourceFile); vv.push_back(V_SgLocatedNode); Rose_STL_Container <SgNode*> nodeList = NodeQuery::querySubTree (root, vv); for (Rose_STL_Container <SgNode*>::iterator iter = nodeList.begin(); iter != nodeList.end(); iter++) { SgNode* n = (*iter); setId (n); } }
void testOMPForSensitiveInsertion() { annotateAllOmpFors(project); Rose_STL_Container<SgNode*> iteratorUses = NodeQuery::querySubTree(project, V_SgInitializedName); OMPcfgRWTransaction trans; //VirtualCFG::cfgRWTransaction trans; trans.beginTransaction(); for(Rose_STL_Container<SgNode*>::iterator it = iteratorUses.begin(); it!=iteratorUses.end(); it++) { SgInitializedName *initName = isSgInitializedName(*it); ROSE_ASSERT(initName); //printf("initialized Name <%s | %s>\n", initName->get_parent()->unparseToString().c_str(), initName->get_parent()->class_name().c_str()); if(initName->get_name().getString() == "iterator") { //printf(" inserting1 at spot <%s | %s>\n", initName->get_parent()->unparseToString().c_str(), initName->get_parent()->class_name().c_str()); trans.insertBefore(initName, fooCallCreate()); trans.insertAfter(initName, fooCallCreate()); } } iteratorUses = NodeQuery::querySubTree(project, V_SgVarRefExp); for(Rose_STL_Container<SgNode*>::iterator it = iteratorUses.begin(); it!=iteratorUses.end(); it++) { SgVarRefExp *varRef = isSgVarRefExp(*it); ROSE_ASSERT(varRef); if(varRef->get_symbol()->get_name().getString() == "iterator") { //printf(" inserting2 at spot <%s | %s>\n", varRef->get_parent()->unparseToString().c_str(), varRef->get_parent()->class_name().c_str()); trans.insertBefore(varRef->get_parent(), fooCallCreate()); trans.insertAfter(varRef->get_parent(), fooCallCreate()); } } trans.commitTransaction(); }
int main (int argc, char *argv[]) { SgProject *project = frontend (argc, argv); Rose_STL_Container<SgNode*> nodeList = NodeQuery::querySubTree(project,V_SgVarRefExp); for (Rose_STL_Container<SgNode *>::iterator i = nodeList.begin(); i != nodeList.end(); i++) { SgVarRefExp *vRef = isSgVarRefExp((*i)); cout<<"Found a variable reference ! "<<endl; } ROSE_ASSERT (nodeList.size() != 0); return backend (project); }
int MintCudaMidend::insertHeaders(SgProject* project) { //cout << " INFO:Mint: Inserting runtime header cutil.h" << endl << endl ; Rose_STL_Container<SgNode*> globalScopeList = NodeQuery::querySubTree (project,V_SgGlobal); for (Rose_STL_Container<SgNode*>::iterator i = globalScopeList.begin(); i != globalScopeList.end(); i++) { SgGlobal* globalscope = isSgGlobal(*i); ROSE_ASSERT (globalscope != NULL); //SageInterface::insertHeader("cutil.h",PreprocessingInfo::after,false,globalscope); } return 0; //assume always successful currently }
void findCandidateFunctionDefinitions (SgProject* project, std::vector<SgFunctionDefinition* >& candidateFuncDefs) { ROSE_ASSERT (project != NULL); // For each source file in the project SgFilePtrList & ptr_list = project->get_fileList(); for (SgFilePtrList::iterator iter = ptr_list.begin(); iter!=ptr_list.end(); iter++) { SgFile* sageFile = (*iter); SgSourceFile * sfile = isSgSourceFile(sageFile); ROSE_ASSERT(sfile); // SgGlobal *root = sfile->get_globalScope(); if (enable_debug) cout<<"Processing each function within the files "<< sfile->get_file_info()->get_filename() <<endl; // cout<<"\t loop at:"<< cur_loop->get_file_info()->get_line() <<endl; // This is wrong, many functions in question are not top level declarations!! //SgDeclarationStatementPtrList& declList = root->get_declarations (); //VariantVector vv; Rose_STL_Container<SgNode*> defList = NodeQuery::querySubTree(sfile, V_SgFunctionDefinition); // bool hasOpenMP= false; // flag to indicate if omp.h is needed in this file //For each function body in the scope //for (SgDeclarationStatementPtrList::iterator p = declList.begin(); p != declList.end(); ++p) for (Rose_STL_Container<SgNode*>::iterator p = defList.begin(); p != defList.end(); ++p) { SgFunctionDefinition *defn = isSgFunctionDefinition(*p); ROSE_ASSERT (defn != NULL); SgFunctionDeclaration *func = defn->get_declaration(); ROSE_ASSERT (func != NULL); if (enable_debug) cout<<"\t considering function "<< func->get_name() << " at "<< func->get_file_info()->get_line()<<endl; //ignore functions in system headers, Can keep them to test robustness if (defn->get_file_info()->get_filename()!=sageFile->get_file_info()->get_filename()) { if (enable_debug) cout<<"\t Skipped since the function's associated file name does not match current file being considered. Mostly from a header. "<<endl; continue; } candidateFuncDefs.push_back(defn); } // end for def list } // end for file list }
int main(int argc, char* argv[]) { std::vector<std::string> pragma_values; SgProject* proj = frontend(argc,argv); ROSE_ASSERT(proj != NULL); SgFunctionDeclaration* mainDefDecl = SageInterface::findMain(proj); SgFunctionDefinition* mainDef = mainDefDecl->get_definition(); Rose_STL_Container<SgNode*> pragmaList = NodeQuery::querySubTree(proj,V_SgPragmaDeclaration); for (Rose_STL_Container<SgNode*>::iterator i = pragmaList.begin(); i != pragmaList.end(); i++) { SgPragmaDeclaration* prg = isSgPragmaDeclaration(*i); std::string prag_string = get_pragma_string(prg); if (isSMTGeneral(prag_string)) { std::string parsed = parseSMTGeneral(prag_string); std::cout << ";;SMTGeneral command found: " << parsed << std::endl; //continue; } else { //std::cout << "SMTGeneral command not found" << std::endl; std::string pos; pos = get_position(prag_string); if (pos == "define") { std::cout << "define:\n"; std::vector<std::pair<std::string, std::string> > pragma_values = get_vars(prag_string); for (std::vector<std::pair<std::string,std::string> >::iterator j = pragma_values.begin(); j != pragma_values.end(); j++) { std::cout << (*j).first << " " << (*j).second << std::endl; } } else if (pos == "assume") { std::cout << "assume:\n"; std::vector<std::string> assumptions = get_assumptions(prag_string); for (std::vector<std::string>::iterator i = assumptions.begin(); i != assumptions.end(); i++) { std::cout << (*i) << std::endl; } } else if (pos == "begin" || pos == "end") { std::cout << "position: " << pos << std::endl; } else { ROSE_ASSERT(false); } } } return 0; }