Rose_STL_Container<SgInitializedName*>
buildListOfGlobalVariables ( SgSourceFile* file )
{
// This function builds a list of global variables (from a SgFile).
assert(file != NULL);
Rose_STL_Container<SgInitializedName*> globalVariableList;
SgGlobal* globalScope = file->get_globalScope();
assert(globalScope != NULL);
Rose_STL_Container<SgDeclarationStatement*>::iterator i = globalScope->get_declarations().begin();
while(i != globalScope->get_declarations().end())
{
SgVariableDeclaration *variableDeclaration = isSgVariableDeclaration(*i);
if (variableDeclaration != NULL)
{
Rose_STL_Container<SgInitializedName*> & variableList = variableDeclaration->get_variables();
Rose_STL_Container<SgInitializedName*>::iterator var = variableList.begin();
while(var != variableList.end())
{
globalVariableList.push_back(*var);
var++;
}
}
i++;
}
return globalVariableList;
}
void visitorTraversal::visit(SgNode* n)
{
SgGlobal* globalScope = isSgGlobal(n);
if (globalScope != NULL)
{
printf ("Looking for \"x\" in the global symbol table ... \n");
SgSymbol* symbol = globalScope->lookup_var_symbol("x");
ROSE_ASSERT(symbol != NULL);
// Iterate through the symbol table
SgSymbolTable::BaseHashType* hashTable = globalScope->get_symbol_table()->get_table();
SgSymbolTable::hash_iterator i = hashTable->begin();
while (i != hashTable->end())
{
printf ("hash tabel entry: i->first = %s \n",i->first.str());
i++;
}
}
#if 0
SgScopeStatement* scope = isSgScopeStatement(n);
if (scope != NULL)
{
printf ("Looking for \"x\" in the global symbol table ... \n");
SgSymbol* symbol = globalScope->lookup_var_symbol("x");
ROSE_ASSERT(symbol != NULL);
}
#endif
}
void InstrumentationFunction::buildDeclaration(SgProject* project) {
// *****************************************************
// Create the functionDeclaration
// *****************************************************
Sg_File_Info * file_info = Sg_File_Info::generateDefaultFileInfoForTransformationNode();
SgType *function_return_type = new SgTypeVoid();
type = new SgFunctionType(function_return_type, false);
SgFunctionDeclaration *functionDeclaration = new SgFunctionDeclaration(file_info, name, type);
// ********************************************************************
// Create the InitializedName for a parameter within the parameter list
// ********************************************************************
/*
SgName var1_name = "textString";
SgTypeChar * var1_type = new SgTypeChar();
SgPointerType *pointer_type = new SgPointerType(var1_type);
SgInitializer * var1_initializer = NULL;
SgInitializedName *var1_init_name = new SgInitializedName(var1_name, pointer_type, var1_initializer, NULL);
// Insert argument in function parameter list
ROSE_ASSERT(functionDeclaration != NULL);
ROSE_ASSERT(functionDeclaration->get_parameterList() != NULL);
ROSE_ASSERT(functionDeclaration->get_parameterList() != NULL);
functionDeclaration->get_parameterList()->append_arg(var1_init_name);
*/
SgSourceFile* sourceFile = isSgSourceFile(project->get_fileList()[0]);
ROSE_ASSERT(sourceFile != NULL);
SgGlobal* globalScope = sourceFile->get_globalScope();
ROSE_ASSERT(globalScope != NULL);
// Set the parent node in the AST (this could be done by the AstPostProcessing
functionDeclaration->set_parent(globalScope);
// Set the scope explicitly (since it could be different from the parent?)
// This can't be done by the AstPostProcessing (unless we relax some constraints)
functionDeclaration->set_scope(globalScope);
// If it is not a forward declaration then the unparser will skip the ";" at the end (need to fix this better)
functionDeclaration->setForward();
ROSE_ASSERT(functionDeclaration->isForward() == true);
// Mark function as extern "C"
functionDeclaration->get_declarationModifier().get_storageModifier().setExtern();
functionDeclaration->set_linkage("C"); // This mechanism could be improved!
// Add function declaration to global scope
globalScope->prepend_declaration(functionDeclaration);
symbol = new SgFunctionSymbol(functionDeclaration);
// All any modifications to be fixed up (parents etc)
// AstPostProcessing(project); // This is not allowed and should be fixed!
AstPostProcessing(globalScope);
}
int
main ( int argc, char * argv[] )
{
if (argc <= 1) {
PrintUsage(argv[0]);
return -1;
}
SgProject sageProject ( (int)argc,argv);
SageInterface::changeAllBodiesToBlocks(&sageProject);
CmdOptions::GetInstance()->SetOptions(argc, argv);
int filenum = sageProject.numberOfFiles();
for (int i = 0; i < filenum; ++i) {
SgSourceFile* sageFile = isSgSourceFile(sageProject.get_fileList()[i]);
ROSE_ASSERT(sageFile != NULL);
TestCFGWrap::AnalysisDomain t = UseOA(argc, argv)? TestCFGWrap::OA : TestCFGWrap::ROSE;
string filename = sageFile->getFileName();
#if 0 // Test harness uses stdout rather than a temporary file
string txtname = filename.substr(filename.rfind('/')+1) + ".outx";
TestCFGWrap_Text txtop(t,txtname);
#else
TestCFGWrap_Stdout txtop(t);
#endif
//string dotname = string(strrchr(sageFile.getFileName(),'/')+1) + ".dot";
string dotname = filename.substr(filename.rfind('/')+1) + ".dot";
TestCFGWrap_DOT dotop(t);
SgGlobal *root = sageFile->get_globalScope();
SgDeclarationStatementPtrList& declList = root->get_declarations ();
for (SgDeclarationStatementPtrList::iterator p = declList.begin(); p != declList.end(); ++p) {
SgFunctionDeclaration *func = isSgFunctionDeclaration(*p);
if (func == 0)
continue;
SgFunctionDefinition *defn = func->get_definition();
if (defn == 0)
continue;
SgNode* stmts = defn;
if (GenerateDOT(argc, argv)) {
dotop(stmts, dotname);
}
else {
txtop(stmts);
}
}
}
return 0;
}
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
}
int
main ( int argc, char * argv[] )
{
if (argc <= 1) {
PrintUsage(argv[0]);
return -1;
}
SgProject sageProject ( (int)argc,argv);
SageInterface::changeAllBodiesToBlocks(&sageProject);
CmdOptions::GetInstance()->SetOptions(argc, argv);
int filenum = sageProject.numberOfFiles();
for (int i = 0; i < filenum; ++i) {
SgSourceFile* sageFile = isSgSourceFile(sageProject.get_fileList()[i]);
ROSE_ASSERT(sageFile != NULL);
SgGlobal *root = sageFile->get_globalScope();
SgDeclarationStatementPtrList& declList = root->get_declarations ();
for (SgDeclarationStatementPtrList::iterator p = declList.begin(); p != declList.end(); ++p) {
SgFunctionDeclaration *func = isSgFunctionDeclaration(*p);
if (func == 0)
continue;
SgFunctionDefinition *defn = func->get_definition();
if (defn == 0)
continue;
SgBasicBlock *stmts = defn->get_body();
AstInterfaceImpl scope(stmts);
AstInterface fa(&scope);
StmtVarAliasCollect alias;
alias(fa, AstNodePtrImpl(defn));
if (GenerateDOT(argc, argv)) {
string name = string(strrchr(sageFile->getFileName().c_str(),'/')+1) + ".dot";
TestDUWrap_DOT op(alias);
op(fa, defn, name);
}
else {
string name = string(strrchr(sageFile->getFileName().c_str(),'/')+1) + ".outx";
#if 0 // Test harness uses stdout now rather than a temporary file [Robb P. Matzke 2013-02-25]
TestDUWrap_Text op(alias,name);
#else
TestDUWrap_Stdout op(alias);
#endif
op(fa, defn);
}
}
}
return 0;
}
/*
* Main Function
*/
int main(int argc, char * argv[]) {
// Build the AST used by ROSE
SgProject* sageProject = frontend(argc, argv);
// For each source file in the project
SgFilePtrList & ptr_list = sageProject->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();
SgDeclarationStatementPtrList& declList = root->get_declarations();
// Insert header file
insertHeader(sfile);
//For each function body in the scope
for (SgDeclarationStatementPtrList::iterator p = declList.begin(); p
!= declList.end(); ++p) {
SgFunctionDeclaration *func = isSgFunctionDeclaration(*p);
if (func == 0)
continue;
SgFunctionDefinition *defn = func->get_definition();
if (defn == 0)
continue;
//ignore functions in system headers, Can keep them to test robustness
if (defn->get_file_info()->get_filename()
!= sageFile->get_file_info()->get_filename())
continue;
SgBasicBlock *body = defn->get_body();
ROSE_ASSERT(body);
vector<SgForStatement*> loops = querySubTree<SgForStatement> (defn,
V_SgForStatement);
if (loops.size() == 0)
continue;
visitLoops(loops);
}
// Generate source code from AST and call the vendor's compiler
return backend(sageProject);
}
}
int main(int argc, char** argv)
{
SgProject* project = frontend(argc, argv);
AstTests::runAllTests(project);
// Copy a defining function declaration
SgFunctionDeclaration* func= findDeclarationStatement<SgFunctionDeclaration> (project, "bar", NULL, true);
ROSE_ASSERT (func != NULL);
SgFunctionDeclaration* func_copy = isSgFunctionDeclaration(copyStatement (func));
func_copy->set_name("bar_copy");
SgGlobal * glb = getFirstGlobalScope(project);
appendStatement (func_copy,glb);
#if 0 // this has been merged into fixStatement() called by appendStatement()
SgFunctionSymbol *func_symbol = glb->lookup_function_symbol ("bar_copy", func_copy->get_type());
if (func_symbol == NULL);
{
func_symbol = new SgFunctionSymbol (func_copy);
glb ->insert_symbol("bar_copy", func_symbol);
}
#endif
//copy a non-defining function declaration
SgFunctionDeclaration* nfunc= findDeclarationStatement<SgFunctionDeclaration> (project, "foo", NULL, false);
ROSE_ASSERT (nfunc != NULL);
func_copy = isSgFunctionDeclaration(copyStatement (nfunc));
glb = getFirstGlobalScope(project);
appendStatement (func_copy,glb);
//copy another non-defining function declaration
nfunc= findDeclarationStatement<SgFunctionDeclaration> (project, "bar", NULL, false);
ROSE_ASSERT (nfunc != NULL);
func_copy = isSgFunctionDeclaration(copyStatement (nfunc));
glb = getFirstGlobalScope(project);
appendStatement (func_copy,glb);
AstTests::runAllTests(project);
backend(project);
return 0;
}
DoxygenFile::DoxygenFile(SgProject *prj, string filename)
{
Sg_File_Info *info = new Sg_File_Info(filename, 0, 0);
SgInitializedName *iname = new SgInitializedName;
stringstream sname;
sname << "SAGE_Doxygen_Dummy_" << rand();
iname->set_name(sname.str());
iname->set_type(new SgTypeInt);
iname->set_file_info(info);
iname->get_storageModifier().setExtern();
SgVariableDeclaration *decl = new SgVariableDeclaration;
decl->get_variables().push_back(iname);
decl->set_startOfConstruct(info);
decl->set_endOfConstruct(info);
decl->get_declarationModifier().get_storageModifier().setExtern();
iname->set_parent(decl);
iname->set_prev_decl_item(iname);
// SgGlobal *glob = prj->get_file(0).get_globalScope();
SgSourceFile* sourceFile = isSgSourceFile(prj->get_fileList()[0]);
ROSE_ASSERT(sourceFile != NULL);
SgGlobal *glob = sourceFile->get_globalScope();
// glob->insertStatementInScope(decl, true);
glob->get_declarations().insert(glob->get_declarations().begin(),decl);
decl->set_parent(glob);
SgVariableSymbol* variableSymbol = new SgVariableSymbol(iname);
glob->insert_symbol(sname.str(),variableSymbol);
decl->set_parent(glob);
std::cout << "Before complete string." << std::endl;
//glob->append_declaration(decl);
iname->set_scope(glob);
decl->unparseToCompleteString();
std::cout << "After complete string." << std::endl;
commentParent = decl;
printf("commentParent = %p\n", commentParent);
}
int main(int argc, char *argv[]){
SgProject* sgproject = frontend(argc, argv);
// SgProject *sgproject_copy = static_cast<SgProject*>(sgproject->copy(SgTREE_COPY));
// This copy of the sgproject fails due to the copy function of the SgFile fails (aborts)
SgFile &file = sgproject->get_file(0);
// SgFile *file_copy = static_cast<SgFile*>(file.copy(SgTREE_COPY));
// Calling the copy function of SgFile fails:
// Before aborting the execution, the following error message is displayed:
// "This is the default constructor, use SgFile (argc,argv) instead"
SgGlobal *root = file.get_root();
SgGlobal *root_copy = static_cast<SgGlobal*>(root->copy(SgTREE_COPY));
// Copying the SgGlobal object is OK
// removing the return statement...from the copy!
list<SgNode*> returnstmt_list = NodeQuery::querySubTree(root_copy, V_SgReturnStmt);
SgStatement* stmt = isSgStatement(*returnstmt_list.begin());
LowLevelRewrite::remove(stmt);
sgproject->unparse(); // should output unmodified sgproject and it does. The deep copy
// mechanism works for the SgGlobal object.
// moving the output file to a new file, so that we can unparse the sgproject again without
// overwriting the results
char *outputfile = file.get_unparse_output_filename();
string move = "mv " + string(outputfile) + " orig_" + string(outputfile);
system(move.c_str());
// want to output modified sgproject
file.set_root(root_copy);
//sgproject->set_file(file);
sgproject->unparse(); // or use: file.unparse();?
// Unparsing the sgproject after adding the root_copy to the file-object (I want
// to unparse the modified copy...), gives me an error message:
// /home/hauge2/ROSE/src/backend/unparser/unparse_stmt.C:1047: void Unparser::unparseFuncDefnStmt(SgStatement*, SgUnparse_Info&): Assertion `funcdefn_stmt->get_declaration() != __null' failed.
return 0;
}
int
main ( int argc, char * argv[] )
{
int a;
if (argc <= 1) {
PrintUsage(argv[0]);
return -1;
}
DEBUG_ICFG = 1;
DEBUG_STMT = 0;
SgProject sageProject ( argc,argv);
SageInterface::changeAllBodiesToBlocks(&sageProject);
CmdOptions::GetInstance()->SetOptions(argc, argv);
// TestPtrAnal op;
//
ptr_Anal_ICFG_Creator op;
int filenum = sageProject.numberOfFiles();
for (int i = 0; i < filenum; ++i) {
SgFile &sageFile = sageProject.get_file(i);
SgGlobal *root = sageFile.get_root();
AstInterfaceImpl scope(root);
AstInterface fa(&scope);
SgDeclarationStatementPtrList& declList = root->get_declarations ();
for (SgDeclarationStatementPtrList::iterator p = declList.begin(); p != declList.end(); ++p) {
SgFunctionDeclaration *func = isSgFunctionDeclaration(*p);
if (func == 0)
continue;
SgFunctionDefinition *defn = func->get_definition();
if (defn == 0)
continue;
op(fa, defn);
}
}
op.draw("out.jpg");
return 0;
}
int
main ( int argc, char * argv[] )
{
if (argc <= 1) {
PrintUsage(argv[0]);
return -1;
}
SgProject sageProject ( argc,argv);
SageInterface::changeAllLoopBodiesToBlocks(&sageProject);
CmdOptions::GetInstance()->SetOptions(argc, argv);
TestPtrAnal op;
int filenum = sageProject.numberOfFiles();
for (int i = 0; i < filenum; ++i) {
SgSourceFile* sageFile = isSgSourceFile(sageProject.get_fileList()[i]);
ROSE_ASSERT(sageFile != NULL);
SgGlobal *root = sageFile->get_globalScope();
AstInterfaceImpl scope(root);
AstInterface fa(&scope);
SgDeclarationStatementPtrList& declList = root->get_declarations ();
for (SgDeclarationStatementPtrList::iterator p = declList.begin(); p != declList.end(); ++p) {
SgFunctionDeclaration *func = isSgFunctionDeclaration(*p);
if (func == 0)
continue;
SgFunctionDefinition *defn = func->get_definition();
if (defn == 0)
continue;
op(fa, defn);
}
}
return 0;
}
void postProcessingSupport (SgNode* node)
{
// DQ (5/24/2006): Added this test to figue out where Symbol parent pointers are being reset to NULL
// TestParentPointersOfSymbols::test();
// DQ (7/25/2005): It is presently an error to call this function with a SgProject
// or SgDirectory, since there is no way to compute the SgFile from such IR nodes
// (could be multiply defined).
// ROSE_ASSERT(isSgProject(node) == NULL && isSgDirectory(node) == NULL);
// GB (8/19/2009): Removed the assertion against calling this function on
// SgProject and SgDirectory nodes. Nothing below needs to compute a
// SgFile, as far as I can tell; also, calling the AstPostProcessing just
// once on an entire project is more efficient than calling it once per
// file.
// JJW (12/5/2008): Turn off C and C++ postprocessing steps when the new EDG
// interface is being used (it should produce correct, complete ASTs on its
// own and do its own fixups)
#ifdef ROSE_USE_NEW_EDG_INTERFACE
// Only do AST post-processing for C/C++
bool doPostprocessing = (SageInterface::is_Fortran_language() == true) ||
(SageInterface::is_PHP_language() == true) ||
(SageInterface::is_Python_language() == true);
// If this is C or C++ then we are using the new EDG translation and althrough fewer
// fixups should be required, some are still required.
if (doPostprocessing == false)
{
#ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
printf ("Postprocessing AST build using new EDG/Sage Translation Interface. \n");
#endif
#if 0
// DQ (4/26/2013): Debugging code.
printf ("In postProcessingSupport: Test 1: Calling postProcessingTestFunctionCallArguments() \n");
postProcessingTestFunctionCallArguments(node);
#endif
#ifndef ROSE_USE_CLANG_FRONTEND
// DQ (10/31/2012): Added fixup for EDG bug which drops variable declarations of some source sequence lists.
fixupEdgBugDuplicateVariablesInAST();
#endif
// DQ (5/1/2012): After EDG/ROSE translation, there should be no IR nodes marked as transformations.
// Liao 11/21/2012. AstPostProcessing() is called within both Frontend and Midend
// so we have to detect the mode first before asserting no transformation generated file info objects
if (SageBuilder::SourcePositionClassificationMode != SageBuilder::e_sourcePositionTransformation)
detectTransformations(node);
// DQ (8/12/2012): reset all of the type references (to intermediately generated types).
fixupTypeReferences();
// Reset and test and parent pointers so that it matches our definition
// of the AST (as defined by the AST traversal mechanism).
topLevelResetParentPointer(node);
// DQ (8/23/2012): Modified to take a SgNode so that we could compute the global scope for use in setting
// parents of template instantiations that have not be placed into the AST but exist in the memory pool.
// Another 2nd step to make sure that parents of even IR nodes not traversed can be set properly.
// resetParentPointersInMemoryPool();
resetParentPointersInMemoryPool(node);
// DQ (6/27/2005): fixup the defining and non-defining declarations referenced at each SgDeclarationStatement
// This is a more sophisticated fixup than that done by fixupDeclarations. See test2009_09.C for an example
// of a non-defining declaration appearing before a defining declaration and requiring a fixup of the
// non-defining declaration reference to the defining declaration.
fixupAstDefiningAndNondefiningDeclarations(node);
// DQ (6/11/2013): This corrects where EDG can set the scope of a friend declaration to be different from the defining declaration.
// We need it to be a rule in ROSE that the scope of the declarations are consistant between defining and all non-defining declaration).
fixupAstDeclarationScope(node);
// Fixup the symbol tables (in each scope) and the global function type
// symbol table. This is less important for C, but required for C++.
// But since the new EDG interface has to handle C and C++ we don't
// setup the global function type table there to be uniform.
fixupAstSymbolTables(node);
// DQ (4/14/2010): Added support for symbol aliases for C++
// This is the support for C++ "using declarations" which uses symbol aliases in the symbol table to provide
// correct visability of symbols included from alternative scopes (e.g. namespaces).
fixupAstSymbolTablesToSupportAliasedSymbols(node);
// DQ (2/12/2012): Added support for this, since AST_consistancy expects get_nameResetFromMangledForm() == true.
resetTemplateNames(node);
// **********************************************************************
// DQ (4/29/2012): Added some of the template fixup support for EDG 4.3 work.
// DQ (6/21/2005): This function now only marks the subtrees of all appropriate declarations as compiler generated.
// DQ (5/27/2005): mark all template instantiations (which we generate as template specializations) as compiler generated.
// This is required to make them pass the unparser and the phase where comments are attached. Some fixup of filenames
// and line numbers might also be required.
fixupTemplateInstantiations(node);
#if 0
// DQ (4/26/2013): Debugging code.
printf ("In postProcessingSupport: Test 2: Calling postProcessingTestFunctionCallArguments() \n");
postProcessingTestFunctionCallArguments(node);
#endif
// DQ (8/19/2005): Mark any template specialization (C++ specializations are template instantiations
// that are explicit in the source code). Such template specializations are marked for output only
// if they are present in the source file. This detail could effect handling of header files later on.
// Have this phase preceed the markTemplateInstantiationsForOutput() since all specializations should
// be searched for uses of (references to) instantiated template functions and member functions.
markTemplateSpecializationsForOutput(node);
// DQ (6/21/2005): This function marks template declarations for output by the unparser (it is part of a
// fixed point iteration over the AST to force find all templates that are required (EDG at the moment
// outputs only though template functions that are required, but this function solves the more general
// problem of instantiation of both function and member function templates (and static data, later)).
markTemplateInstantiationsForOutput(node);
// DQ (10/21/2007): Friend template functions were previously not properly marked which caused their generated template
// symbols to be added to the wrong symbol tables. This is a cause of numerous symbol table problems.
fixupFriendTemplateDeclarations();
// DQ (4/29/2012): End of new template fixup support for EDG 4.3 work.
// **********************************************************************
// DQ (5/14/2012): Fixup source code position information for the end of functions to match the largest values in their subtree.
// DQ (10/27/2007): Setup any endOfConstruct Sg_File_Info objects (report on where they occur)
fixupSourcePositionConstructs();
#if 0
// DQ (4/26/2013): Debugging code.
printf ("In postProcessingSupport: Test 3: Calling postProcessingTestFunctionCallArguments() \n");
postProcessingTestFunctionCallArguments(node);
#endif
// DQ (2/12/2012): This is a problem for test2004_35.C (debugging this issue).
// printf ("Exiting after calling resetTemplateNames() \n");
// ROSE_ASSERT(false);
// DQ (10/4/2012): Added this pass to support command line option to control use of constant folding
// (fixes bug pointed out by Liao).
// DQ (9/14/2011): Process the AST to remove constant folded values held in the expression trees.
// This step defines a consistent AST more suitable for analysis since only the constant folded
// values will be visited. However, the default should be to save the original expression trees
// and remove the constant folded values since this represents the original code.
#if 1
resetConstantFoldedValues(node);
#else
// DQ (10/11/2012): This is helpful to allow us to see both expression trees in the AST for debugging.
printf ("Skipping AST Postprocessing resetConstantFoldedValues() \n");
#endif
#if 0
// DQ (4/26/2013): Debugging code.
printf ("In postProcessingSupport: Test 4: Calling postProcessingTestFunctionCallArguments() \n");
postProcessingTestFunctionCallArguments(node);
#endif
// DQ (10/5/2012): Fixup known macros that might expand into a recursive mess in the unparsed code.
fixupSelfReferentialMacrosInAST(node);
// Make sure that frontend-specific and compiler-generated AST nodes are marked as such. These two must run in this
// order since checkIsCompilerGenerated depends on correct values of compiler-generated flags.
checkIsFrontendSpecificFlag(node);
checkIsCompilerGeneratedFlag(node);
// This resets the isModified flag on each IR node so that we can record
// where transformations are done in the AST. If any transformations on
// the AST are done, even just building it, this step should be the final
// step.
checkIsModifiedFlag(node);
// DQ (5/2/2012): After EDG/ROSE translation, there should be no IR nodes marked as transformations.
// Liao 11/21/2012. AstPostProcessing() is called within both Frontend and Midend
// so we have to detect the mode first before asserting no transformation generated file info objects
if (SageBuilder::SourcePositionClassificationMode !=SageBuilder::e_sourcePositionTransformation)
detectTransformations(node);
#if 0
// DQ (4/26/2013): Debugging code.
printf ("In postProcessingSupport: Test 10: Calling postProcessingTestFunctionCallArguments() \n");
postProcessingTestFunctionCallArguments(node);
#endif
// DQ (4/24/2013): Detect the correct function declaration to declare the use of default arguments.
// This can only be a single function and it can't be any function (this is a moderately complex issue).
fixupFunctionDefaultArguments(node);
// DQ (12/20/2012): We now store the logical and physical source position information.
// Although they are frequently the same, the use of #line directives causes them to be different.
// This is part of debugging the physical source position information which is used in the weaving
// of the comments and CPP directives into the AST. For this the consistancy check is more helpful
// if done befor it is used (here), instead of after the comment and CPP directive insertion in the
// AST Consistancy tests.
checkPhysicalSourcePosition(node);
#ifdef ROSE_DEBUG_NEW_EDG_ROSE_CONNECTION
printf ("DONE: Postprocessing AST build using new EDG/Sage Translation Interface. \n");
#endif
return;
}
#endif // ROSE_USE_NEW_EDG_INTERFACE -- do postprocessing unconditionally when the old EDG interface is used
// DQ (7/7/2005): Introduce tracking of performance of ROSE.
// TimingPerformance timer ("AST Fixup: time (sec) = ");
if ( SgProject::get_verbose() >= AST_POST_PROCESSING_VERBOSE_LEVEL )
cout << "/* AST Postprocessing started. */" << endl;
ROSE_ASSERT(node != NULL);
// DQ (7/19/2005): Moved to after parent pointer fixup!
// subTemporaryAstFixes(node);
// DQ (3/11/2006): Fixup NULL pointers left by users when building the AST
// (note that the AST translation fixes these directly). This step is
// provided as a way to make the AST build by users consistant with what
// is built elsewhere within ROSE.
fixupNullPointersInAST(node);
// DQ (8/9/2005): Some function definitions in Boost are build without
// a body (example in test2005_102.C, but it appears to work fine).
fixupFunctionDefinitions(node);
// DQ (8/10/2005): correct any template declarations mistakenly marked as compiler-generated
fixupTemplateDeclarations(node);
// Output progress comments for these relatively expensive operations on the AST
if ( SgProject::get_verbose() >= AST_POST_PROCESSING_VERBOSE_LEVEL )
cout << "/* AST Postprocessing reset parent pointers */" << endl;
topLevelResetParentPointer (node);
// DQ (6/10/2007): This is called later, but call it now to reset the parents in SgTemplateInstantiationDecl
// This is required (I think) so that resetTemplateNames() can compute template argument name qualification correctly.
// See test2005_28.C for where this is required.
// resetParentPointersInMemoryPool();
resetParentPointersInMemoryPool(node);
// Output progress comments for these relatively expensive operations on the AST
if ( SgProject::get_verbose() >= AST_POST_PROCESSING_VERBOSE_LEVEL )
cout << "/* AST Postprocessing reset parent pointers (done) */" << endl;
// DQ (7/19/2005): Moved to after parent pointer fixup!
// subTemporaryAstFixes(node);
removeInitializedNamePtr(node);
// DQ (3/17/2007): This should be empty
ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// DQ (12/1/2004): This should be done before the reset of template names (since that operation requires valid scopes!)
// DQ (11/29/2004): Added to support new explicit scope information on IR nodes
// initializeExplicitScopeData(node);
initializeExplicitScopes(node);
// DQ (5/28/2006): Fixup names in declarations that are inconsistent (e.g. where more than one non-defining declaration exists)
resetNamesInAST();
// DQ (3/17/2007): This should be empty
ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// Output progress comments for these relatively expensive operations on the AST
if ( SgProject::get_verbose() >= AST_POST_PROCESSING_VERBOSE_LEVEL )
cout << "/* AST Postprocessing reset template names */" << endl;
#if 0
// DQ (5/15/2011): I don't feel comfortable with this being called before the AST is finied being post processed.
// This used to be called in the unparser, but that is after resetTemplateNames() below and that is a problem
// because template names have already been generated.
void newBuildHiddenTypeAndDeclarationLists( SgNode* node );
printf ("Developing a new implementation of the name qualification support. \n");
newBuildHiddenTypeAndDeclarationLists(node);
printf ("DONE: new name qualification support built. \n");
printf ("Calling SgNode::clearGlobalMangledNameMap() \n");
SgNode::clearGlobalMangledNameMap();
#endif
// DQ (5/15/2011): This causes template names to be computed as strings and and without name qualification
// if we don't call the name qualification before here. Or we reset the template names after we do the
// analysis to support the name qualification.
// reset the names of template class declarations
resetTemplateNames(node);
// DQ (2/12/2012): This is a problem for test2004_35.C (debugging this issue).
// printf ("Exiting after calling resetTemplateNames() \n");
// ROSE_ASSERT(false);
// DQ (3/17/2007): This should be empty
ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// Output progress comments for these relatively expensive operations on the AST
if ( SgProject::get_verbose() >= AST_POST_PROCESSING_VERBOSE_LEVEL )
cout << "/* AST Postprocessing reset template names (done) */" << endl;
// DQ (6/26/2007): Enum values used before they are defined in a class can have NULL declaration pointers. This
// fixup handles this case and traverses just the SgEnumVal objects.
fixupEnumValues();
// DQ (4/7/2010): This was commented out to modify Fortran code, but I think it should NOT modify Fortran code.
// DQ (5/21/2008): This only make since for C and C++ (Error, this DOES apply to Fortran where the "parameter" attribute is used!)
if (SageInterface::is_Fortran_language() == false && SageInterface::is_Java_language() == false)
{
// DQ (3/20/2005): Fixup AST so that GNU g++ compile-able code will be generated
fixupInClassDataInitialization(node);
}
// DQ (3/24/2005): Fixup AST to generate code that works around GNU g++ bugs
fixupforGnuBackendCompiler(node);
// DQ (4/19/2005): fixup all definingDeclaration and NondefiningDeclaration pointers in SgDeclarationStatement IR nodes
// fixupDeclarations(node);
// DQ (5/20/2005): make the non-defining (forward) declarations added by EDG for static template
// specializations added under the "--instantiation local" option match the defining declarations.
fixupStorageAccessOfForwardTemplateDeclarations(node);
#if 0
// DQ (6/27/2005): fixup the defining and non-defining declarations referenced at each SgDeclarationStatement
fixupAstDefiningAndNondefiningDeclarations(node);
#endif
// DQ (6/21/2005): This function now only marks the subtrees of all appropriate declarations as compiler generated.
// DQ (5/27/2005): mark all template instantiations (which we generate as template specializations) as compiler generated.
// This is required to make them pass the unparser and the phase where comments are attached. Some fixup of filenames
// and line numbers might also be required.
fixupTemplateInstantiations(node);
// DQ (8/19/2005): Mark any template specialization (C++ specializations are template instantiations
// that are explicit in the source code). Such template specializations are marked for output only
// if they are present in the source file. This detail could effect handling of header files later on.
// Have this phase preceed the markTemplateInstantiationsForOutput() since all specializations should
// be searched for uses of (references to) instantiated template functions and member functions.
markTemplateSpecializationsForOutput(node);
// DQ (6/21/2005): This function marks template declarations for output by the unparser (it is part of a
// fixed point iteration over the AST to force find all templates that are required (EDG at the moment
// outputs only though template functions that are required, but this function solves the more general
// problem of instantiation of both function and member function templates (and static data, later)).
markTemplateInstantiationsForOutput(node);
// DQ (3/17/2007): This should be empty
ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// DQ (3/16/2006): fixup any newly added declarations (see if we can eliminate the first place where this is called, above)
// fixup all definingDeclaration and NondefiningDeclaration pointers in SgDeclarationStatement IR nodes
// driscoll6 (6/10/11): this traversal sets p_firstNondefiningDeclaration for defining declarations, which
// causes justifiable failures in AstConsistencyTests. Until this is resolved, skip this test for Python.
if (SageInterface::is_Python_language()) {
//cerr << "warning: python. Skipping fixupDeclarations() in astPostProcessing.C" << endl;
} else {
fixupDeclarations(node);
}
// DQ (3/17/2007): This should be empty
ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// DQ (2/12/2006): Moved to trail marking templates (as a test)
// DQ (6/27/2005): fixup the defining and non-defining declarations referenced at each SgDeclarationStatement
// This is a more sophisticated fixup than that done by fixupDeclarations.
fixupAstDefiningAndNondefiningDeclarations(node);
#if 0
ROSE_ASSERT(saved_declaration != NULL);
printf ("saved_declaration = %p saved_declaration->get_definingDeclaration() = %p saved_declaration->get_firstNondefiningDeclaration() = %p \n",
saved_declaration,saved_declaration->get_definingDeclaration(),saved_declaration->get_firstNondefiningDeclaration());
ROSE_ASSERT(saved_declaration->get_definingDeclaration() != saved_declaration->get_firstNondefiningDeclaration());
#endif
// DQ (10/21/2007): Friend template functions were previously not properly marked which caused their generated template
// symbols to be added to the wrong symbol tables. This is a cause of numerous symbol table problems.
fixupFriendTemplateDeclarations();
// DQ (3/17/2007): This should be the last point at which the globalMangledNameMap is empty
// The fixupAstSymbolTables will generate calls to function types that will be placed into
// the globalMangledNameMap.
ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// DQ (6/26/2005): The global function type symbol table should be rebuilt (since the names of templates
// used in qualified names of types have been reset (in post processing). Other local symbol tables should
// be initalized and constructed for any empty scopes (for consistancy, we want all scopes to have a valid
// symbol table pointer).
fixupAstSymbolTables(node);
// DQ (3/17/2007): At this point the globalMangledNameMap has been used in the symbol table construction. OK.
// ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// DQ (8/20/2005): Handle backend vendor specific template handling options
// (e.g. g++ options: -fno-implicit-templates and -fno-implicit-inline-templates)
processTemplateHandlingOptions(node);
// DQ (5/22/2005): relocate compiler generated forward template instantiation declarations to appear
// after the template declarations and before first use.
// relocateCompilerGeneratedTemplateInstantiationDeclarationsInAST(node);
// DQ (8/27/2005): This disables output of some template instantiations that would result in
// "ambiguous template specialization" in g++ (version 3.3.x, 3.4.x, and 4.x). See test2005_150.C
// for more detail.
markOverloadedTemplateInstantiations(node);
// DQ (9/5/2005): Need to mark all nodes in any subtree marked as a transformation
markTransformationsForOutput(node);
// DQ (3/5/2006): Mark functions that are provided for backend compatability as compiler generated by ROSE
#if 1
markBackendSpecificFunctionsAsCompilerGenerated(node);
#else
printf ("Warning: Skipped marking of backend specific functions ... \n");
#endif
// DQ (5/24/2006): Added this test to figure out where Symbol parent pointers are being reset to NULL
// TestParentPointersOfSymbols::test();
// DQ (5/24/2006): reset the remaining parents in IR nodes missed by the AST based traversals
// resetParentPointersInMemoryPool();
resetParentPointersInMemoryPool(node);
// DQ (3/17/2007): This should be empty
// ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// DQ (5/29/2006): Fixup types in declarations that are not shared (e.g. where more than one non-defining declaration exists)
resetTypesInAST();
// DQ (3/17/2007): This should be empty
// ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// DQ (3/10/2007): fixup name of any template classes that have been copied incorrectly into SgInitializedName
// list in base class constructor preinitialization lists (see test2004_156.C for an example).
resetContructorInitilizerLists();
// DQ (10/27/2007): Setup any endOfConstruct Sg_File_Info objects (report on where they occur)
fixupSourcePositionConstructs();
// DQ (1/19/2008): This can be called at nearly any point in the ast fixup.
markLhsValues(node);
#ifndef ROSE_USE_CLANG_FRONTEND
// DQ (2/21/2010): This normalizes an EDG trick (well documented) that replaces "__PRETTY_FUNCTION__" variable
// references with variable given the name of the function where the "__PRETTY_FUNCTION__" variable references
// was found. This is only seen when compiling ROSE using ROSE and was a mysterious property of ROSE for a long
// time until it was identified. This fixup traversal changes the name back to "__PRETTY_FUNCTION__" to make
// the code generated using ROSE when compiling ROSE source code the same as if GNU processed it (e.g. using CPP).
if (SageInterface::is_Java_language() == false) {
fixupPrettyFunctionVariables(node);
}
#endif
#if 0
// DQ (1/22/2008): Use this for the Fortran code to get more accurate source position information.
// DQ (4/16/2007): comment out to test how function declaration prototypes are reset or set wrong.
// DQ (11/1/2006): fixup source code position information for AST IR nodes.
fixupSourcePositionInformation(node);
#endif
#if 0
// DQ (11/10/2007): Moved computation of hidden list from astPostProcessing.C to unparseFile so that
// it will be called AFTER any transformations and immediately before code generation where it is
// really required. This part of a fix for Liao's outliner, but should be useful for numerous
// transformations.
// DQ (8/6/2007): Only compute the hidden lists if working with C++ code!
if (SageInterface::is_Cxx_language() == true)
{
// DQ (5/22/2007): Moved from SgProject::parse() function to here so that propagateHiddenListData() could be called afterward.
// DQ (5/8/2007): Now build the hidden lists for types and declarations (Robert Preissl's work)
Hidden_List_Computation::buildHiddenTypeAndDeclarationLists(node);
// DQ (6/5/2007): We actually need this now since the hidden lists are not pushed to lower scopes where they are required.
// DQ (5/22/2007): Added support for passing hidden list information about types, declarations and elaborated types to child scopes.
propagateHiddenListData(node);
}
#endif
// DQ (11/24/2007): Support for Fortran resolution of array vs. function references.
if (SageInterface::is_Fortran_language() == true)
{
// I think this is not used since I can always figure out if something is an
// array reference or a function call.
fixupFortranReferences(node);
// DQ (10/3/2008): This bug in OFP is now fixed so no fixup is required.
// This is the most reliable way to introduce the Fortran "contains" statement.
// insertFortranContainsStatement(node);
}
// DQ (9/26/2008): fixup the handling of use declarations (SgUseStatement).
// This also will fixup C++ using declarations.
fixupFortranUseDeclarations(node);
#if 0
ROSE_MemoryUsage memoryUsage1;
printf ("Test 1: memory_usage = %f \n",memoryUsage1.getMemoryUsageMegabytes());
#endif
// DQ (4/14/2010): Added support for symbol aliases for C++
// This is the support for C++ "using declarations" which uses symbol aliases in the symbol table to provide
// correct visability of symbols included from alternative scopes (e.g. namespaces).
fixupAstSymbolTablesToSupportAliasedSymbols(node);
#if 0
ROSE_MemoryUsage memoryUsage2;
printf ("Test 2: memory_usage = %f \n",memoryUsage2.getMemoryUsageMegabytes());
#endif
// DQ (6/24/2010): To support merge, we want to normalize the typedef lists for each type so that
// the names of the types will evaluate to be the same (and merge appropriately).
normalizeTypedefSequenceLists();
#if 0
ROSE_MemoryUsage memoryUsage3;
printf ("Test 3: memory_usage = %f \n",memoryUsage3.getMemoryUsageMegabytes());
#endif
// DQ (3/7/2010): Identify the fragments of the AST that are disconnected.
// Moved from astConsistancy tests (since it deletes nodes not connected to the AST).
// TestForDisconnectedAST::test(node);
// DQ (9/14/2011): Process the AST to remove constant folded values held in the expression trees.
// This step defines a consistant AST more suitable for analysis since only the constant folded
// values will be visited. However, the default should be to save the original expression trees
// and remove the constant folded values since this represents the original code. This mechanism
// will provide a default when it is more fully implemented.
resetConstantFoldedValues(node);
// Make sure that compiler-generated AST nodes are marked for Sg_File_Info::isCompilerGenerated().
checkIsCompilerGeneratedFlag(node);
// DQ (5/22/2005): Nearly all AST fixup should be done before this closing step
// QY: check the isModified flag
// CheckIsModifiedFlagSupport(node);
checkIsModifiedFlag(node);
#if 0
ROSE_MemoryUsage memoryUsage4;
printf ("Test 4: memory_usage = %f \n",memoryUsage4.getMemoryUsageMegabytes());
#endif
// ROSE_ASSERT(saved_declaration->get_definingDeclaration() != saved_declaration->get_firstNondefiningDeclaration());
// DQ (3/17/2007): This should be empty
// ROSE_ASSERT(SgNode::get_globalMangledNameMap().size() == 0);
// This is used for both of the fillowing tests.
SgSourceFile* sourceFile = isSgSourceFile(node);
#if 1
// DQ (9/11/2009): Added support for numbering of statements required to support name qualification.
if (sourceFile != NULL)
{
// DQ (9/11/2009): Added support for numbering of statements required to support name qualification.
// sourceFile->buildStatementNumbering();
SgGlobal* globalScope = sourceFile->get_globalScope();
ROSE_ASSERT(globalScope != NULL);
globalScope->buildStatementNumbering();
}
else
{
if (SgProject* project = isSgProject(node))
{
SgFilePtrList &files = project->get_fileList();
for (SgFilePtrList::iterator fileI = files.begin(); fileI != files.end(); ++fileI)
{
if ( (sourceFile = isSgSourceFile(*fileI)) )
{
SgGlobal* globalScope = sourceFile->get_globalScope();
ROSE_ASSERT(globalScope != NULL);
globalScope->buildStatementNumbering();
}
}
}
}
#endif
// DQ (4/4/2010): check that the global scope has statements.
// This was an error for Fortran and it appeared that everything
// was working when it was not. It appeared because of a strange
// error between versions of the OFP support files. So as a
// way to avoid this in the future, we issue a warning for Fortran
// code that has no statements in the global scope. It can still
// be a valid Fortran code (containing only comments). but this
// should help avoid our test codes appearing to work when they
// don't (in the future). For C/C++ files there should always be
// something in the global scope (because or ROSE defined functions),
// so this test should not be a problem.
if (sourceFile != NULL)
{
SgGlobal* globalScope = sourceFile->get_globalScope();
ROSE_ASSERT(globalScope != NULL);
if (globalScope->get_declarations().empty() == true)
{
printf ("WARNING: no statements in global scope for file = %s \n",sourceFile->getFileName().c_str());
}
}
else
{
if (SgProject* project = isSgProject(node))
{
SgFilePtrList &files = project->get_fileList();
for (SgFilePtrList::iterator fileI = files.begin(); fileI != files.end(); ++fileI)
{
if ( (sourceFile = isSgSourceFile(*fileI)) )
{
SgGlobal* globalScope = sourceFile->get_globalScope();
ROSE_ASSERT(globalScope != NULL);
if (globalScope->get_declarations().empty() == true)
{
printf ("WARNING: no statements in global scope for file = %s \n",(*fileI)->getFileName().c_str());
}
}
}
}
}
if ( SgProject::get_verbose() >= AST_POST_PROCESSING_VERBOSE_LEVEL )
cout << "/* AST Postprocessing finished */" << endl;
// DQ (5/3/2010): Added support for binary analysis specific post-processing.
SgProject* project = isSgProject(node);
if (project != NULL)
{
#if 0
// printf ("In postProcessingSupport(): project->get_exit_after_parser() = %s \n",project->get_exit_after_parser() ? "true" : "false");
// printf ("In postProcessingSupport(): project->get_binary_only() = %s \n",project->get_binary_only() ? "true" : "false");
if (project->get_binary_only() == true)
{
printf ("Inside of postProcessingSupport(): Processing binary project \n");
// ROSE_ASSERT(false);
// addEdgesInAST();
}
#endif
}
}
SynthesizedAttribute
Traversal::evaluateSynthesizedAttribute ( SgNode* astNode, InheritedAttribute inheritedAttribute, SynthesizedAttributesList childAttributes )
{
SynthesizedAttribute localResult;
// printf ("evaluateSynthesizedAttribute(): astNode = %p = %s inheritedAttribute.isFirstFile = %s \n",astNode,astNode->class_name().c_str(),inheritedAttribute.isFirstFile ? "true" : "false");
// Accumulate any valid pointer to main on a child node and pass it to the local synthesized attribute.
for (size_t i = 0; i < childAttributes.size(); i++)
{
if (childAttributes[i].main_function != NULL)
{
localResult.main_function = childAttributes[i].main_function;
}
}
if (inheritedAttribute.isFirstFile == true)
{
SgGlobal* globalScope = isSgGlobal(astNode);
if (globalScope != NULL)
{
// Gather all of the functions in global scope of the first file.
vector<SgDeclarationStatement*> globalScopeDeclarationsToMove = globalScope->get_declarations();
inheritedAttribute.statements_from_first_file = globalScopeDeclarationsToMove;
// printf ("evaluateSynthesizedAttribute(): Gather all of the functions in global scope of the first file inheritedAttribute.statements_from_first_file.size() = %zu \n",inheritedAttribute.statements_from_first_file.size());
// Erase the declarations in the global scope of the first file.
globalScope->get_declarations().clear();
}
SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(astNode);
if (declarationStatement != NULL && isSgGlobal(declarationStatement->get_parent()) != NULL)
{
// Mark as a transformation (recursively mark the whole subtree).
// printf ("*** Mark as a transformation: declarationStatement = %p \n",declarationStatement);
markAsTransformation(declarationStatement);
if (declarationStatement->get_firstNondefiningDeclaration() != NULL)
markAsTransformation(declarationStatement->get_firstNondefiningDeclaration());
}
}
else
{
SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(astNode);
if (functionDeclaration != NULL && functionDeclaration->get_name() == "main")
{
// Save the pointer to the main function (in the second file).
localResult.main_function = functionDeclaration;
// printf ("Found the main function ...(saved pointer) inheritedAttribute.main_function = %p \n",localResult.main_function);
}
// printf ("evaluateSynthesizedAttribute(): localResult.main_function = %p \n",localResult.main_function);
// Test for the selected insertion point in the 2nd file for the declarations gathered from the first file.
SgGlobal* globalScope = isSgGlobal(astNode);
if (globalScope != NULL && localResult.main_function != NULL)
{
printf ("evaluateSynthesizedAttribute(): Found the main function ...\n");
vector<SgDeclarationStatement*>::iterator i = find(globalScope->get_declarations().begin(),globalScope->get_declarations().end(),localResult.main_function);
globalScope->get_declarations().insert(i,inheritedAttribute.statements_from_first_file.begin(),inheritedAttribute.statements_from_first_file.end());
#if 0
// Set the parents of each declaration to match the new location (avoids warning that might later be an error).
for (size_t i = 0; i < inheritedAttribute.statements_from_first_file.size(); i++)
{
inheritedAttribute.statements_from_first_file[i]->set_parent(globalScope);
}
#endif
}
}
return localResult;
}
int
main ( int argc, char * argv[] )
{
//init_poet(); // initialize poet
if (argc <= 1) {
PrintUsage(argv[0]);
return -1;
}
#ifdef USE_OMEGA
std::stringstream buffer;
buffer << argv[argc-1] << std::endl;
DepStats.SetFileName(buffer.str());
#endif
vector<string> argvList(argv, argv + argc);
CmdOptions::GetInstance()->SetOptions(argvList);
ArrayAnnotation* array_annot = ArrayAnnotation::get_inst();
array_annot->register_annot();
//OperatorSideEffectAnnotation* funcAnnot=OperatorSideEffectAnnotation::get_inst();
//funcAnnot->register_annot();
LoopTransformInterface::set_sideEffectInfo(array_annot);
ArrayInterface anal(*array_annot);
LoopTransformInterface::set_arrayInfo(&anal);
ReadAnnotation::get_inst()->read();
if (DebugAnnot()) {
// funcAnnot->Dump();
array_annot->Dump();
}
AssumeNoAlias aliasInfo;
LoopTransformInterface::set_aliasInfo(&aliasInfo);
LoopTransformInterface::cmdline_configure(argvList);
SgProject *sageProject = new SgProject ( argvList);
FixFileInfo(sageProject);
// DQ (11/19/2013): Added AST consistency tests.
AstTests::runAllTests(sageProject);
int filenum = sageProject->numberOfFiles();
for (int i = 0; i < filenum; ++i) {
// DQ (11/19/2013): Added AST consistency tests.
AstTests::runAllTests(sageProject);
SgSourceFile* sageFile = isSgSourceFile(sageProject->get_fileList()[i]);
ROSE_ASSERT(sageFile != NULL);
std::string fname = sageFile->get_file_info()->get_raw_filename();
fname=fname.substr(fname.find_last_of('/')+1);
AutoTuningInterface tuning(fname);
LoopTransformInterface::set_tuningInterface(&tuning);
SgGlobal *root = sageFile->get_globalScope();
ROSE_ASSERT(root != NULL);
SgDeclarationStatementPtrList declList = root->get_declarations ();
// DQ (11/19/2013): Added AST consistency tests.
AstTests::runAllTests(sageProject);
for (SgDeclarationStatementPtrList::iterator p = declList.begin(); p != declList.end(); ++p)
{
SgFunctionDeclaration *func = isSgFunctionDeclaration(*p);
if (func == 0) continue;
SgFunctionDefinition *defn = func->get_definition();
if (defn == 0) continue;
SgBasicBlock *stmts = defn->get_body();
AstInterfaceImpl scope(stmts);
// DQ (11/19/2013): Added AST consistency tests.
AstTests::runAllTests(sageProject);
// DQ (11/19/2013): Added AST consistency tests.
AstTests::runAllTests(sageProject);
LoopTransformInterface::TransformTraverse(scope,AstNodePtrImpl(stmts));
#if 0
// DQ (11/19/2013): Added AST consistency tests (this fails).
AstTests::runAllTests(sageProject);
#endif
}
tuning.GenOutput();
#if 0
// DQ (11/19/2013): Added AST consistency tests (this fails).
AstTests::runAllTests(sageProject);
#endif
}
// if (CmdOptions::GetInstance()->HasOption("-fd")) {
// simpleIndexFiniteDifferencing(sageProject);
// }
// if (CmdOptions::GetInstance()->HasOption("-pre")) {
// partialRedundancyElimination(sageProject);
// }
#if 0
// DQ (11/19/2013): Added AST consistency tests (this fails).
AstTests::runAllTests(sageProject);
#endif
unparseProject(sageProject);
//backend(sageProject);
#ifdef USE_OMEGA
DepStats.SetDepChoice(0x1 | 0x2 | 0x4);
DepStats.PrintResults();
#endif
return 0;
}
SgFunctionSymbol*
SimpleInstrumentation::buildNewFunctionDeclaration ( SgStatement* statementLocation, SgFunctionType* previousFunctionType )
{
// *****************************************************
// Create the functionDeclaration
// *****************************************************
// Must mark the newly built node to be a part of a transformation so that it will be unparsed!
Sg_File_Info * file_info = new Sg_File_Info();
ROSE_ASSERT(file_info != NULL);
file_info->set_isPartOfTransformation(true);
SgName function_name = "contest_call";
ROSE_ASSERT(previousFunctionType != NULL);
SgFunctionDeclaration* functionDeclaration = new SgFunctionDeclaration(file_info, function_name, previousFunctionType);
ROSE_ASSERT(functionDeclaration != NULL);
ROSE_ASSERT(functionDeclaration->get_parameterList() != NULL);
// ********************************************************************
// Create the InitializedName for a parameter within the parameter list
// ********************************************************************
SgTypePtrList & argList = previousFunctionType->get_arguments();
SgTypePtrList::iterator i = argList.begin();
while ( i != argList.end() )
{
SgName var_name = "";
SgInitializer* var_initializer = NULL;
SgInitializedName *var_init_name = new SgInitializedName(var_name, *i, var_initializer, NULL);
functionDeclaration->get_parameterList()->append_arg(var_init_name);
i++;
}
// Add any additional function arguments here! Make sure that the function type is consistant.
// Get the scope
SgScopeStatement* scope = statementLocation->get_scope();
// Set the parent node in the AST (this could be done by the AstPostProcessing
functionDeclaration->set_parent(scope);
// Set the scope explicitly (since it could be different from the parent?)
functionDeclaration->set_scope(scope);
// If it is not a forward declaration then the unparser will skip the ";" at the end (need to fix this better)
functionDeclaration->setForward();
ROSE_ASSERT(functionDeclaration->isForward() == true);
// Mark function as extern "C"
functionDeclaration->get_declarationModifier().get_storageModifier().setExtern();
functionDeclaration->set_linkage("C"); // This mechanism could be improved!
bool inFront = true;
SgGlobal* globalScope = TransformationSupport::getGlobalScope(statementLocation);
SgFunctionDeclaration* functionDeclarationInGlobalScope =
TransformationSupport::getFunctionDeclaration(statementLocation);
ROSE_ASSERT(globalScope != NULL);
ROSE_ASSERT(functionDeclarationInGlobalScope != NULL);
globalScope->insert_statement(functionDeclarationInGlobalScope,functionDeclaration,inFront);
SgFunctionSymbol* functionSymbol = new SgFunctionSymbol(functionDeclaration);
ROSE_ASSERT(functionSymbol != NULL);
ROSE_ASSERT(functionSymbol->get_type() != NULL);
return functionSymbol;
}
POETCode* POETAstInterface::Ast2POET(const Ast& n)
{
static SgTemplateInstantiationFunctionDecl* tmp=0;
SgNode* input = (SgNode*) n;
if (input == 0) return EMPTY;
POETCode* res = POETAstInterface::find_Ast2POET(input);
if (res != 0) return res;
{
SgProject* sageProject=isSgProject(input);
if (sageProject != 0) {
int filenum = sageProject->numberOfFiles();
for (int i = 0; i < filenum; ++i) {
SgSourceFile* sageFile = isSgSourceFile(sageProject->get_fileList()[i]);
SgGlobal *root = sageFile->get_globalScope();
SgDeclarationStatementPtrList declList = root->get_declarations ();
POETCode* curfile = ROSE_2_POET_list(declList, 0, tmp);
curfile = new POETCode_ext(sageFile, curfile);
POETAstInterface::set_Ast2POET(sageFile, curfile);
res=LIST(curfile, res);
}
POETAstInterface::set_Ast2POET(sageProject,res);
return res;
} }
{
SgBasicBlock* block = isSgBasicBlock(input);
if (block != 0) {
res=ROSE_2_POET_list(block->get_statements(), res, tmp);
POETAstInterface::set_Ast2POET(block, res);
return res;
} }
{
SgExprListExp* block = isSgExprListExp(input);
if (block != 0) {
res=ROSE_2_POET_list(block->get_expressions(), 0, tmp);
POETAstInterface::set_Ast2POET(block, res);
return res;
} }
{
SgForStatement *f = isSgForStatement(input);
if (f != 0) {
POETCode* init = ROSE_2_POET_list(f->get_for_init_stmt()->get_init_stmt(),0, tmp);
POETCode* ctrl = new POETCode_ext(f, TUPLE3(init,Ast2POET(f->get_test_expr()), Ast2POET(f->get_increment())));
res = CODE_ACC("Nest", PAIR(ctrl,Ast2POET(f->get_loop_body())));
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
{
SgVarRefExp * v = isSgVarRefExp(input);
if (v != 0) {
res = STRING(v->get_symbol()->get_name().str());
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
{
SgMemberFunctionRefExp * v = isSgMemberFunctionRefExp(input);
if (v != 0) {
res = STRING(v->get_symbol()->get_name().str());
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
{
SgIntVal * v = isSgIntVal(input);
if (v != 0) {
res = ICONST(v->get_value());
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
{
SgInitializedName* var = isSgInitializedName(input);
if (var != 0) {
POETCode* name = STRING(var->get_name().str());
POETCode* init = Ast2POET(var->get_initializer());
res = new POETCode_ext(var, PAIR(name,init));
POETAstInterface::set_Ast2POET(input, res);
return res;
}
}
/*
{
std::string fname;
AstInterface::AstList params;
AstNodeType returnType;
AstNodePtr body;
if (AstInterface :: IsFunctionDefinition( input, &fname, ¶ms, (AstInterface::AstList*)0, &body, (AstInterface::AstTypeList*)0, &returnType)) {
if (body != AST_NULL)
std::cerr << "body not empty:" << fname << "\n";
POETCode* c = TUPLE4(STRING(fname), ROSE_2_POET_list(0,params,0),
STRING(AstInterface::GetTypeName(returnType)),
Ast2POET(body.get_ptr()));
res = new POETCode_ext(input, c);
POETAstInterface::set_Ast2POET(input,res);
return res;
} }
*/
AstInterface::AstList c = AstInterface::GetChildrenList(input);
switch (input->variantT()) {
case V_SgCastExp:
case V_SgAssignInitializer:
res = Ast2POET(c[0]);
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgDotExp:
{
POETCode* v1 = Ast2POET(c[1]);
if (dynamic_cast<POETString*>(v1)->get_content() == "operator()")
return Ast2POET(c[0]);
res = CODE_ACC("Bop",TUPLE3(STRING("."), Ast2POET(c[0]), v1)); return res;
}
case V_SgLessThanOp:
res = CODE_ACC("Bop",TUPLE3(STRING("<"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgSubtractOp:
res = CODE_ACC("Bop",TUPLE3(STRING("-"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgAddOp:
res = CODE_ACC("Bop",TUPLE3(STRING("+"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgMultiplyOp:
res = CODE_ACC("Bop",TUPLE3(STRING("*"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgDivideOp:
res = CODE_ACC("Bop",TUPLE3(STRING("/"),Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgAssignOp:
res = CODE_ACC("Assign",PAIR(Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
case V_SgFunctionCallExp:
res = CODE_ACC("FunctionCall",PAIR(Ast2POET(c[0]), Ast2POET(c[1])));
POETAstInterface::set_Ast2POET(input, res); return res;
}
POETCode * c2 = 0;
if (tmp == 0) tmp=isSgTemplateInstantiationFunctionDecl(input);
switch (c.size()) {
case 0: break;
case 1: c2 = Ast2POET(c[0]); break;
case 2: c2 = PAIR(Ast2POET(c[0]),Ast2POET(c[1])); break;
case 3: c2 = TUPLE3(Ast2POET(c[0]),Ast2POET(c[1]),Ast2POET(c[2])); break;
case 4: c2 = TUPLE4(Ast2POET(c[0]),Ast2POET(c[1]),Ast2POET(c[2]),Ast2POET(c[3])); break;
default:
//std::cerr << "too many children: " << c.size() << ":" << input->unparseToString() << "\n";
c2 = EMPTY;
}
if (tmp == input) tmp = 0;
res = new POETCode_ext(input, c2);
POETAstInterface::set_Ast2POET(input,res);
return res;
}
SgVariableSymbol*
putGlobalVariablesIntoClass (Rose_STL_Container<SgInitializedName*> & globalVariables, SgClassDeclaration* classDeclaration )
{
// This function iterates over the list of global variables and inserts them into the iput class definition
SgVariableSymbol* globalClassVariableSymbol = NULL;
for (Rose_STL_Container<SgInitializedName*>::iterator var = globalVariables.begin(); var != globalVariables.end(); var++)
{
// printf ("Appending global variable = %s to new globalVariableContainer \n",(*var)->get_name().str());
SgVariableDeclaration* globalVariableDeclaration = isSgVariableDeclaration((*var)->get_parent());
assert(globalVariableDeclaration != NULL);
// Get the global scope from the global variable directly
SgGlobal* globalScope = isSgGlobal(globalVariableDeclaration->get_scope());
assert(globalScope != NULL);
if (var == globalVariables.begin())
{
// This is the first time in this loop, replace the first global variable with
// the class declaration/definition containing all the global variables!
// Note that initializers in the global variable declarations require modification
// of the preinitialization list in the class's constructor! I am ignoring this for now!
globalScope->replace_statement(globalVariableDeclaration,classDeclaration);
// Build source position informaiton (marked as transformation)
Sg_File_Info* fileInfo = Sg_File_Info::generateDefaultFileInfoForTransformationNode();
assert(fileInfo != NULL);
// Add the variable of the class type to the global scope!
SgClassType* variableType = new SgClassType(classDeclaration->get_firstNondefiningDeclaration());
assert(variableType != NULL);
SgVariableDeclaration* variableDeclaration = new SgVariableDeclaration(fileInfo,"AMPI_globals",variableType);
assert(variableDeclaration != NULL);
globalScope->insert_statement(classDeclaration,variableDeclaration,false);
assert(variableDeclaration->get_variables().empty() == false);
SgInitializedName* variableName = *(variableDeclaration->get_variables().begin());
assert(variableName != NULL);
// DQ (9/8/2007): Need to set the scope of the new variable.
variableName->set_scope(globalScope);
// build the return value
globalClassVariableSymbol = new SgVariableSymbol(variableName);
// DQ (9/8/2007): Need to add the symbol to the global scope (new testing requires this).
globalScope->insert_symbol(variableName->get_name(),globalClassVariableSymbol);
ROSE_ASSERT(globalScope->lookup_variable_symbol(variableName->get_name()) != NULL);
}
else
{
// for all other iterations of this loop ...
// remove variable declaration from the global scope
globalScope->remove_statement(globalVariableDeclaration);
}
// add the variable declaration to the class definition
classDeclaration->get_definition()->append_member(globalVariableDeclaration);
}
return globalClassVariableSymbol;
}
void
TransformationSupport::getTransformationOptions ( SgNode* astNode, list<OptionDeclaration> & generatedList, string identifingTypeName )
{
// This function searches for variables of type ScopeBasedTransformationOptimization. Variables
// of type ScopeBasedTransformationOptimization are used to communicate optimizations from the
// application to the preprocessor. If called from a project or file object it traverses down to
// the global scope of the file and searches only the global scope, if called from and other
// location within the AST it searches the current scope and then traverses the parent nodes to
// find all enclosing scopes until in reaches the global scope. At each scope it searches for
// variables of type ScopeBasedTransformationOptimization.
// printf ("######################### START OF TRANSFORMATION OPTION QUERY ######################## \n");
ROSE_ASSERT (astNode != NULL);
ROSE_ASSERT (identifingTypeName.c_str() != NULL);
#if 0
printf ("In getTransformationOptions(): astNode->sage_class_name() = %s generatedList.size() = %d \n",
astNode->sage_class_name(),generatedList.size());
SgLocatedNode* locatedNode = isSgLocatedNode(astNode);
if (locatedNode != NULL)
{
printf (" locatedNode->get_file_info()->get_filename() = %s \n",locatedNode->get_file_info()->get_filename());
printf (" locatedNode->get_file_info()->get_line() = %d \n",locatedNode->get_file_info()->get_line());
}
#endif
switch (astNode->variant())
{
case ProjectTag:
{
SgProject* project = isSgProject(astNode);
ROSE_ASSERT (project != NULL);
//! Loop through all the files in the project and call the mainTransform function for each file
int i = 0;
for (i=0; i < project->numberOfFiles(); i++)
{
SgFile* file = &(project->get_file(i));
// printf ("Calling Query::traverse(SgFile,QueryFunctionType,QueryAssemblyFunctionType) \n");
getTransformationOptions ( file, generatedList, identifingTypeName );
}
break;
}
case SourceFileTag:
{
SgSourceFile* file = isSgSourceFile(astNode);
ROSE_ASSERT (file != NULL);
SgGlobal* globalScope = file->get_globalScope();
ROSE_ASSERT (globalScope != NULL);
ROSE_ASSERT (isSgGlobal(globalScope) != NULL);
getTransformationOptions ( globalScope, generatedList, identifingTypeName );
break;
}
// Global Scope
case GLOBAL_STMT:
{
SgGlobal* globalScope = isSgGlobal(astNode);
ROSE_ASSERT (globalScope != NULL);
SgSymbolTable* symbolTable = globalScope->get_symbol_table();
ROSE_ASSERT (symbolTable != NULL);
getTransformationOptions ( symbolTable, generatedList, identifingTypeName );
// printf ("Processed global scope, exiting .. \n");
// ROSE_ABORT();
break;
}
case SymbolTableTag:
{
// List the variable in each scope
// printf ("List all the variables in this symbol table! \n");
SgSymbolTable* symbolTable = isSgSymbolTable(astNode);
ROSE_ASSERT (symbolTable != NULL);
bool foundTransformationOptimizationSpecifier = false;
// printf ("Now print out the information in the symbol table for this scope: \n");
// symbolTable->print();
#if 0
// I don't know when a SymbolTable is given a name!
printf ("SymbolTable has a name = %s \n",
(symbolTable->get_no_name()) ? "NO: it has no name" : "YES: it does have a name");
if (!symbolTable->get_no_name())
printf ("SymbolTable name = %s \n",symbolTable->get_name().str());
else
ROSE_ASSERT (symbolTable->get_name().str() == NULL);
#endif
if (symbolTable->get_table() != NULL)
{
SgSymbolTable::hash_iterator i = symbolTable->get_table()->begin();
int counter = 0;
while (i != symbolTable->get_table()->end())
{
ROSE_ASSERT ( isSgSymbol( (*i).second ) != NULL );
// printf ("Initial info: number: %d pair.first (SgName) = %s pair.second (SgSymbol) sage_class_name() = %s \n",
// counter,(*i).first.str(),(*i).second->sage_class_name());
SgSymbol* symbol = isSgSymbol((*i).second);
ROSE_ASSERT ( symbol != NULL );
SgType* type = symbol->get_type();
ROSE_ASSERT ( type != NULL );
SgNamedType* namedType = isSgNamedType(type);
string typeName;
if (namedType != NULL)
{
SgName n = namedType->get_name();
typeName = namedType->get_name().str();
// char* nameString = namedType->get_name().str();
// printf ("Type is: (named type) = %s \n",nameString);
ROSE_ASSERT (identifingTypeName.c_str() != NULL);
// ROSE_ASSERT (typeName != NULL);
// printf ("In getTransformationOptions(): typeName = %s identifingTypeName = %s \n",typeName.c_str(),identifingTypeName.c_str());
// if ( (typeName != NULL) && ( typeName == identifingTypeName) )
if ( typeName == identifingTypeName )
{
// Now look at the parameter list to the constructor and save the
// values into the list.
// printf ("Now save the constructor arguments! \n");
SgVariableSymbol* variableSymbol = isSgVariableSymbol(symbol);
if ( variableSymbol != NULL )
{
SgInitializedName* initializedNameDeclaration = variableSymbol->get_declaration();
ROSE_ASSERT (initializedNameDeclaration != NULL);
SgDeclarationStatement* declarationStatement = initializedNameDeclaration->get_declaration();
ROSE_ASSERT (declarationStatement != NULL);
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(declarationStatement);
ROSE_ASSERT (variableDeclaration != NULL);
getTransformationOptionsFromVariableDeclarationConstructorArguments(variableDeclaration,generatedList);
foundTransformationOptimizationSpecifier = true;
// printf ("Exiting after saving the constructor arguments! \n");
// ROSE_ABORT();
}
else
{
#if 0
printf ("Not a SgVariableSymbol: symbol->sage_class_name() = %s \n",
symbol->sage_class_name());
#endif
}
}
else
{
#if 0
printf ("typeName != identifingTypeName : symbol->sage_class_name() = %s \n",
symbol->sage_class_name());
#endif
#if 0
// I don't think this should ever be NULL (but it is sometimes)
if (typeName != NULL)
printf ("typeName == NULL \n");
#endif
}
}
else
{
typeName = (char *)type->sage_class_name();
}
// printf ("In while loop at the base: counter = %d \n",counter);
i++;
counter++;
}
}
else
{
// printf ("Pointer to symbol table is NULL \n");
}
// printf ("foundTransformationOptimizationSpecifier = %s \n",foundTransformationOptimizationSpecifier ? "true" : "false");
// SgSymbolTable objects don't have a parent node (specifically they lack a get_parent
// member function in the interface)!
break;
}
case BASIC_BLOCK_STMT:
{
// List the variable in each scope
// printf ("List all the variables in this scope! \n");
SgBasicBlock* basicBlock = isSgBasicBlock(astNode);
ROSE_ASSERT (basicBlock != NULL);
SgSymbolTable* symbolTable = basicBlock->get_symbol_table();
ROSE_ASSERT (symbolTable != NULL);
getTransformationOptions ( symbolTable, generatedList, identifingTypeName );
// Next go (fall through this case) to the default case so that we traverse the parent
// of the SgBasicBlock.
// break;
}
default:
// Most cases will be the default (this is by design)
// printf ("default in switch found in globalQueryGetListOperandStringFunction() (sage_class_name = %s) \n",astNode->sage_class_name());
// Need to recursively backtrack through the parents until we reach the SgGlobal (global scope)
SgStatement* statement = isSgStatement(astNode);
if (statement != NULL)
{
SgNode* parentNode = statement->get_parent();
ROSE_ASSERT (parentNode != NULL);
// printf ("parent = %p parentNode->sage_class_name() = %s \n",parentNode,parentNode->sage_class_name());
SgStatement* parentStatement = isSgStatement(parentNode);
if (parentStatement == NULL)
{
printf ("parentStatement == NULL: statement (%p) is a %s \n",statement,statement->sage_class_name());
printf ("parentStatement == NULL: statement->get_file_info()->get_filename() = %s \n",statement->get_file_info()->get_filename());
printf ("parentStatement == NULL: statement->get_file_info()->get_line() = %d \n",statement->get_file_info()->get_line());
}
ROSE_ASSERT (parentStatement != NULL);
// Call this function recursively (directly rather than through the query mechanism)
getTransformationOptions ( parentStatement, generatedList, identifingTypeName );
}
else
{
// printf ("astNode is not a SgStatement! \n");
}
break;
}
#if 0
printf ("At BASE of getTransformationOptions(): astNode->sage_class_name() = %s size of generatedList = %d \n",
astNode->sage_class_name(),generatedList.size());
#endif
// printf ("######################### END OF TRANSFORMATION OPTION QUERY ######################## \n");
}
void instr(SgProject* project, Rose_STL_Container<SgType*> types)
{
SgGlobal* global = SI::getFirstGlobalScope(project);
std::string prefix("rtc_ti_"); //struct prefix
std::string ti_type_str("struct rtc_typeinfo*");
SgType* ti_type = SB::buildOpaqueType(ti_type_str,global);
//Insert declarations from the typechecking library.
//void minalloc_check(unsigned long long addr)
SgFunctionDeclaration* minalloc_check_decl = SB::buildNondefiningFunctionDeclaration(
SgName("minalloc_check"),
SgTypeVoid::createType(),
SB::buildFunctionParameterList(
SB::buildInitializedName("addr",SB::buildUnsignedLongLongType())),
global,NULL);
SI::prependStatement(minalloc_check_decl,global);
//void typetracker_add(unsigned long long addr, struct rtc_typeinfo* ti);
SgFunctionDeclaration* typetracker_add_decl = SB::buildNondefiningFunctionDeclaration(
SgName("typetracker_add"),
SgTypeVoid::createType(),
SB::buildFunctionParameterList(
SB::buildInitializedName("addr",SB::buildUnsignedLongLongType()),
SB::buildInitializedName("ti",ti_type)),
global,NULL);
SI::prependStatement(typetracker_add_decl,global);
//void setBaseType(rtc_typeinfo* ti, rtc_typeinfo* base)
SgFunctionDeclaration* setBaseType_decl = SB::buildNondefiningFunctionDeclaration(
SgName("setBaseType"),
SgTypeVoid::createType(),
SB::buildFunctionParameterList(
SB::buildInitializedName("ti",ti_type),
SB::buildInitializedName("base",ti_type)),
global,NULL);
SI::prependStatement(setBaseType_decl,global);
//struct rtc_typeinfo* ti_init(const char* a, size_t sz, int c)
SgFunctionDeclaration* ti_init_decl = SB::buildNondefiningFunctionDeclaration(
SgName("ti_init"),
ti_type,
SB::buildFunctionParameterList(
// SB::buildInitializedName("a",SB::buildPointerType(SB::buildConstType(SB::buildCharType()))),
SB::buildInitializedName("a",SB::buildPointerType(SB::buildCharType())),
// SB::buildInitializedName("sz", SB::buildOpaqueType("size_t",global)),
SB::buildInitializedName("sz", SB::buildLongLongType()),
SB::buildInitializedName("c", SB::buildIntType())),
global,NULL);
SI::prependStatement(ti_init_decl,global);
//void traverseAndPrint()
SgFunctionDeclaration* traverseAndPrint_decl = SB::buildNondefiningFunctionDeclaration(
SgName("traverseAndPrint"),SgTypeVoid::createType(),SB::buildFunctionParameterList(),global,NULL);
SI::prependStatement(traverseAndPrint_decl,global);
//non-defining declaration of rtc_init_typeinfo
SgName init_name("rtc_init_typeinfo");
SgFunctionDeclaration* init_nondef = SB::buildNondefiningFunctionDeclaration(init_name,SgTypeVoid::createType(),SB::buildFunctionParameterList(),global,NULL);
SI::prependStatement(init_nondef,global);
//call to rtc_init_typeinfo placed in main function.
SgFunctionDeclaration* maindecl = SI::findMain(project);
SgExprStatement* initcall = SB::buildFunctionCallStmt(init_name,SgTypeVoid::createType(),NULL,maindecl->get_definition());
maindecl->get_definition()->prepend_statement(initcall);
//defining declaration of rtc_init_typeinfo
SgFunctionDeclaration* init_definingDecl = new SgFunctionDeclaration(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),init_name,init_nondef->get_type(),NULL);
init_definingDecl->set_firstNondefiningDeclaration(init_nondef);
SgFunctionDefinition* init_definition = new SgFunctionDefinition(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),init_definingDecl,SB::buildBasicBlock());
init_definingDecl->set_definition(init_definition);
SI::appendStatement(init_definingDecl,global);
std::vector<std::string> lst;
for(unsigned int index = 0; index < types.size(); index++)
{
SgType* ptr = types[index];
ptr = ptr->stripTypedefsAndModifiers();
if(!shouldInstrumentType(ptr))
continue;
std::string nameStr = prefix + Util::getNameForType(ptr).getString();
if(!contains(lst,nameStr))
{
SgVariableDeclaration* decl = SB::buildVariableDeclaration(nameStr,ti_type,NULL,global);
SI::prependStatement(decl,global);
lst.push_back(nameStr);
}
}
for(unsigned int index = 0; index < types.size(); index++)
{
SgType* ptr = types[index];
ptr = ptr->stripTypedefsAndModifiers();
if(!shouldInstrumentType(ptr))
continue;
std::string typeNameStr = Util::getNameForType(ptr).getString();
std::string structNameStr = prefix + Util::getNameForType(ptr).getString();
if(contains(lst,structNameStr))
{
SgExpression* lhs;
SgExpression* rhs;
//In case of an anonymous struct or union, we create a local, named version of the declaration so we can know its size.
SgClassDeclaration* altDecl = NULL;
if(isSgNamedType(ptr) && isSgClassDeclaration(isSgNamedType(ptr)->get_declaration()) && isSgClassDeclaration(isSgNamedType(ptr)->get_declaration())->get_isUnNamed())
{
SgClassDeclaration* originalDecl = isSgClassDeclaration(isSgNamedType(ptr)->get_declaration()->get_definingDeclaration());
SgName altDecl_name(typeNameStr + "_def");
altDecl = new SgClassDeclaration(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),altDecl_name,originalDecl->get_class_type());
SgClassDefinition* altDecl_definition = SB::buildClassDefinition(altDecl);
SgDeclarationStatementPtrList originalMembers = originalDecl->get_definition()->get_members();
for(SgDeclarationStatementPtrList::iterator it = originalMembers.begin(); it != originalMembers.end(); it++)
{
SgDeclarationStatement* member = *it;
SgDeclarationStatement* membercpy = isSgDeclarationStatement(SI::copyStatement(member));
altDecl_definition->append_member(membercpy);
}
SgClassDeclaration* altDecl_nondef = new SgClassDeclaration(new Sg_File_Info(SI::getEnclosingFileNode(global)->getFileName()),altDecl_name,originalDecl->get_class_type());
altDecl_nondef->set_scope(global);
altDecl->set_scope(global);
altDecl->set_firstNondefiningDeclaration(altDecl_nondef);
altDecl_nondef->set_firstNondefiningDeclaration(altDecl_nondef);
altDecl->set_definingDeclaration(altDecl);
altDecl_nondef->set_definingDeclaration(altDecl);
SgClassType* altDecl_ct = SgClassType::createType(altDecl_nondef);
altDecl->set_type(altDecl_ct);
altDecl_nondef->set_type(altDecl_ct);
altDecl->set_isUnNamed(false);
altDecl_nondef->set_isUnNamed(false);
altDecl_nondef->set_forward(true);
SgSymbol* sym = new SgClassSymbol(altDecl_nondef);
global->insert_symbol(altDecl_name, sym);
altDecl->set_linkage("C");
altDecl_nondef->set_linkage("C");
ROSE_ASSERT(sym && sym->get_symbol_basis() == altDecl_nondef);
ROSE_ASSERT(altDecl->get_definingDeclaration() == altDecl);
ROSE_ASSERT(altDecl->get_firstNondefiningDeclaration() == altDecl_nondef);
ROSE_ASSERT(altDecl->search_for_symbol_from_symbol_table() == sym);
ROSE_ASSERT(altDecl->get_definition() == altDecl_definition);
ROSE_ASSERT(altDecl->get_scope() == global && altDecl->get_scope() == altDecl_nondef->get_scope());
ROSE_ASSERT(altDecl_ct->get_declaration() == altDecl_nondef);
//For some reason, this is not working...
//global->append_statement(altDecl);
//global->prepend_statement(altDecl_nondef);
//SI::setOneSourcePositionForTransformation(altDecl);
//SI::setOneSourcePositionForTransformation(altDecl_nondef);
}
SgType* baseType;
if(isSgPointerType(ptr))
baseType = ptr->dereference();
else
baseType = ptr->findBaseType();
baseType = baseType->stripTypedefsAndModifiers();
if(baseType == NULL || baseType == ptr)
{
//In this case, there is no base type.
rhs = SB::buildFunctionCallExp(SgName("ti_init"),SgTypeVoid::createType(),SB::buildExprListExp(
SB::buildStringVal(ptr->unparseToString()),
((altDecl == NULL && !isSgTypeVoid(ptr)) ? (SgExpression*) SB::buildSizeOfOp(types[index]) : (SgExpression*) SB::buildIntVal(-1)),
SB::buildIntVal(getClassification(ptr))
),init_definition);
}
else
{
//The type has a base type.
std::string baseStructNameStr = prefix + Util::getNameForType(baseType).getString();
rhs = SB::buildFunctionCallExp(SgName("ti_init"),ti_type,SB::buildExprListExp(
SB::buildStringVal(ptr->unparseToString()),
((altDecl == NULL && !isSgTypeVoid(ptr)) ? (SgExpression*) SB::buildSizeOfOp(types[index]) : (SgExpression*) SB::buildIntVal(-1)),
SB::buildIntVal(getClassification(ptr))
),init_definition);
SgExprStatement* set_BT = SB::buildFunctionCallStmt(SgName("setBaseType"),ti_type,SB::buildExprListExp(
SB::buildVarRefExp(structNameStr),
SB::buildVarRefExp(baseStructNameStr)),
init_definition);
init_definition->append_statement(set_BT);
}
lhs = SB::buildVarRefExp(structNameStr);
SgExprStatement* assignstmt = SB::buildAssignStatement(lhs,rhs);
init_definition->prepend_statement(assignstmt);
std::remove(lst.begin(),lst.end(),structNameStr);
}
}
}
//! Return an expression like 8*sizeof(int)+ 3*sizeof(float) + 5*sizeof(double) for a list of variables accessed (either read or write)
// For array variable, we should only count a single element access, not the entire array size
// Algorithm:
// Iterate on each variable in the set
// group them into buckets based on types, using a map<SgType*, int> to store this
// Iterate the list of buckets to generate count*sizeof(type) + .. expression
SgExpression* calculateBytes (std::set<SgInitializedName*>& name_set, SgScopeStatement* scope, bool isRead)
{
SgExpression* result = NULL;
if (name_set.size()==0) return result;
// the input is essentially the loop body, a scope statement
ROSE_ASSERT (scope != NULL);
// We need to record the associated loop info.
SgStatement* loop= NULL;
SgForStatement* forloop = isSgForStatement(scope->get_scope());
SgFortranDo* doloop = isSgFortranDo(scope->get_scope());
if (forloop)
loop = forloop;
else if (doloop)
loop = doloop;
else
{
cerr<<"Error in CountLoadStoreBytes (): input is not loop body type:"<< scope->class_name()<<endl;
assert(false);
}
std::map<SgType* , int> type_based_counters;
// get all processed variables by inner loops
std::set<SgInitializedName*> processed_var_set;
getVariablesProcessedByInnerLoops (scope, isRead, processed_var_set);
// fill in the type-based counters
std::set<SgInitializedName*>::iterator set_iter;
for (set_iter = name_set.begin(); set_iter != name_set.end(); set_iter++)
{
SgInitializedName* init_name = *set_iter;
// skip visited variable when processing inner loops
// some global variables may be visited by another function
// But we should count it when processing the current function!
//
// We group all references to a same variable into one reference for now
// if a variable is considered when processing inner loops, the variable
// will be skipped when processing outer loops.
if (isRead)
{
// if inner loops already processed it, skip it
if (processed_var_set.find(init_name) != processed_var_set.end())
continue;
else
LoopLoadVariables[loop].insert(init_name);
}
else
{
if (processed_var_set.find(init_name) != processed_var_set.end())
continue;
else
LoopStoreVariables[loop].insert(init_name);
}
// It is tricky here, TODO consider pointer, typedefs, reference, modifier types
SgType* stripped_type = (*set_iter)->get_type()->stripTypedefsAndModifiers();
SgType* base_type = NULL;
if (isScalarType(stripped_type))
base_type = stripped_type;
else if (isSgArrayType(stripped_type))
{ // we may have multi-dimensional arrays like int a[][][];
base_type = stripped_type;
do {
base_type = isSgArrayType(base_type)->get_base_type();
} while (isSgArrayType (base_type));
}
else
{
cerr<<"Error in calculateBytes(). Unhandled stripped type:"<<stripped_type->class_name()<<endl;
assert (false);
}
type_based_counters[base_type] ++;
} // end for
// use the type-based counters for byte calculation
std::map<SgType* , int>::iterator citer;
//It is possible now to have zero after filtering out redundant variables
//assert (type_based_counters.size()>0);
for (citer = type_based_counters.begin(); citer !=type_based_counters.end(); citer ++)
{
SgType* t = (*citer).first;
// at this point, we should not have array types any more
ROSE_ASSERT (isSgArrayType (t) == false);
int count = (*citer).second;
assert (t != NULL);
assert (count>0);
SgExpression* sizeof_exp = NULL;
if (is_Fortran_language())
{
#if 0 // this does not work. cannot find func symbol for sizeof()
// In Fortran sizeof() is a function call, not SgSizeOfOp.
// type name is a variable in the AST,
// Too much trouble to build
assert (scope !=NULL);
// This does not work
//SgFunctionSymbol* func_sym = lookupFunctionSymbolInParentScopes(SgName("sizeof"), scope);
SgGlobal* gscope = getGlobalScope (scope);
assert (gscope !=NULL);
SgFunctionSymbol* func_sym = gscope->lookup_function_symbol(SgName("sizeof"));
assert (func_sym!=NULL);
SgVarRefExp* type_var = buildVarRefExp( t->unparseToString(), scope );
assert (type_var !=NULL);
sizeof_exp = buildFunctionCallExp (func_sym, buildExprListExp(type_var));
#else
// sizeof is not an operator in Fortran, there is no unparsing support for this
// sizeof_exp = buildSizeOfOp(t);
// Directly obtain an integer size value
sizeof_exp = buildIntVal(getSizeOf(t));
#endif
}
else if (is_C_language() || is_C99_language() || is_Cxx_language())
{
sizeof_exp = buildSizeOfOp(t);
}
else
{
cerr<<"Error in calculateBytes(). Unsupported programming language other than C/Cxx and Fortran. "<<endl;
assert (false);
}
SgExpression* mop = buildMultiplyOp(buildIntVal(count), sizeof_exp);
if (result == NULL)
result = mop;
else
result = buildAddOp(result, mop);
}
return result;
}
int
main (int argc, char *argv[])
{
vector<string> argvList(argv, argv+argc);
//Processing debugging and annotation options
autopar_command_processing(argvList);
// enable parsing user-defined pragma if enable_diff is true
// -rose:openmp:parse_only
if (enable_diff)
argvList.push_back("-rose:openmp:parse_only");
SgProject *project = frontend (argvList);
ROSE_ASSERT (project != NULL);
#if 1 // This has to happen before analyses are called.
// For each loop
VariantVector vv (V_SgForStatement);
Rose_STL_Container<SgNode*> loops = NodeQuery::queryMemoryPool(vv);
// 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);
SageInterface::normalizeForLoopInitDeclaration(cur_loop);
}
#endif
//Prepare liveness analysis etc.
initialize_analysis (project,false);
// 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();
SgDeclarationStatementPtrList& declList = root->get_declarations ();
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)
{
SgFunctionDeclaration *func = isSgFunctionDeclaration(*p);
if (func == 0) continue;
SgFunctionDefinition *defn = func->get_definition();
if (defn == 0) continue;
//ignore functions in system headers, Can keep them to test robustness
if (defn->get_file_info()->get_filename()!=sageFile->get_file_info()->get_filename())
continue;
SgBasicBlock *body = defn->get_body();
// For each loop
Rose_STL_Container<SgNode*> loops = NodeQuery::querySubTree(defn,V_SgForStatement);
if (loops.size()==0) continue;
#if 0 // Moved to be executed before running liveness analysis.
// 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);
SageInterface::normalizeForLoopInitDeclaration(cur_loop);
}
#endif
// X. Replace operators with their equivalent counterparts defined
// in "inline" annotations
AstInterfaceImpl faImpl_1(body);
CPPAstInterface fa_body(&faImpl_1);
OperatorInlineRewrite()( fa_body, AstNodePtrImpl(body));
// Pass annotations to arrayInterface and use them to collect
// alias info. function info etc.
ArrayAnnotation* annot = ArrayAnnotation::get_inst();
ArrayInterface array_interface(*annot);
array_interface.initialize(fa_body, AstNodePtrImpl(defn));
array_interface.observe(fa_body);
//FR(06/07/2011): aliasinfo was not set which caused segfault
LoopTransformInterface::set_aliasInfo(&array_interface);
// X. Loop normalization for all loops within body
NormalizeForLoop(fa_body, AstNodePtrImpl(body));
for (Rose_STL_Container<SgNode*>::iterator iter = loops.begin();
iter!= loops.end(); iter++ )
{
SgNode* current_loop = *iter;
//X. Parallelize loop one by one
// getLoopInvariant() will actually check if the loop has canonical forms
// which can be handled by dependence analysis
SgInitializedName* invarname = getLoopInvariant(current_loop);
if (invarname != NULL)
{
hasOpenMP = ParallelizeOutermostLoop(current_loop, &array_interface, annot);
}
else // cannot grab loop index from a non-conforming loop, skip parallelization
{
if (enable_debug)
cout<<"Skipping a non-canonical loop at line:"<<current_loop->get_file_info()->get_line()<<"..."<<endl;
hasOpenMP = false;
}
}// end for loops
} // end for-loop for declarations
// insert omp.h if needed
if (hasOpenMP && !enable_diff)
{
SageInterface::insertHeader("omp.h",PreprocessingInfo::after,false,root);
if (enable_patch)
generatePatchFile(sfile);
}
// compare user-defined and compiler-generated OmpAttributes
if (enable_diff)
diffUserDefinedAndCompilerGeneratedOpenMP(sfile);
} //end for-loop of files
// Qing's loop normalization is not robust enough to pass all tests
//AstTests::runAllTests(project);
release_analysis();
//project->unparse();
return backend (project);
}
static
void set_rtedfunc(SgGlobal& n, const std::string& name, SgFunctionSymbol*& res)
{
res = n.lookup_function_symbol(rtedIdentifier(name));
presence_test(name, res);
}
int main( int argc, char *argv[] )
{
if( argc < 2 ) {
cout << "./amos: no input files " << endl;
cout << " " << endl;
cout << "Hi, this is Amos! " << endl;
cout << "It's my pleasure to serve you. " << endl;
cout << " " << endl;
cout << "Please type option '--help' to see guide " << endl;
cout << " " << endl;
return 0;
}
cout << "*************************************************************" << endl;
cout << "** **" << endl;
cout << "** Welcome to use OpenMP task validation system! **" << endl;
cout << "** **" << endl;
cout << "** editor: Amos Wang **" << endl;
cout << "*************************************************************\n" << endl;
vector<string> argvList( argv, argv+argc );
vector<string> argvList0( argv, argv+argc ); // keep original argv and argc
command_processing( argvList );
if( !parse_OmpTask( argvList ) ) {
cout << "\nAmos says: I am sorry that I could not find any OpenMP task !" << endl << endl;
return 0;
}
// for time counter
long t_start;
long t_end;
double time_program = 0.0;
t_start = usecs();
// for time counter
transform_Task2Loop( argvList );
SgProject *project = frontend(argvList);
ROSE_ASSERT( project != NULL );
#if 1
VariantVector vv( V_SgForStatement );
Rose_STL_Container<SgNode*> loops = NodeQuery::queryMemoryPool(vv);
for( Rose_STL_Container<SgNode*>::iterator iter = loops.begin(); iter!= loops.end(); iter++ ) {
SgForStatement* cur_loop = isSgForStatement(*iter);
ROSE_ASSERT(cur_loop);
SageInterface::normalizeForLoopInitDeclaration(cur_loop);
}
#endif
//initialize_analysis( project, false );
initialize_analysis( project, false );
//For each source file in the project
SgFilePtrList &ptr_list = project->get_fileList();
cout << "\n**** Amos' validation system running ****\n" << endl;
for( SgFilePtrList::iterator iter = ptr_list.begin(); iter != ptr_list.end(); iter++ ) {
cout << "temp source code: " << (*iter)->get_file_info()->get_filename() << endl << endl;
SgFile *sageFile = (*iter);
SgSourceFile *sfile = isSgSourceFile(sageFile);
ROSE_ASSERT(sfile);
SgGlobal *root = sfile->get_globalScope();
SgDeclarationStatementPtrList& declList = root->get_declarations ();
//cout << "Check point 2" << endl;
//For each function body in the scope
for( SgDeclarationStatementPtrList::iterator p = declList.begin(); p != declList.end(); ++p )
{
SgFunctionDeclaration *func = isSgFunctionDeclaration(*p);
if ( func == 0 ) continue;
SgFunctionDefinition *defn = func->get_definition();
if ( defn == 0 ) continue;
//ignore functions in system headers, Can keep them to test robustness
if ( defn->get_file_info()->get_filename() != sageFile->get_file_info()->get_filename() )
continue;
SgBasicBlock *body = defn->get_body();
// For each loop
Rose_STL_Container<SgNode*> loops = NodeQuery::querySubTree( defn, V_SgForStatement );
if( loops.size() == 0 ) continue;
// X. Replace operators with their equivalent counterparts defined
// in "inline" annotations
AstInterfaceImpl faImpl_1( body );
CPPAstInterface fa_body( &faImpl_1 );
OperatorInlineRewrite()( fa_body, AstNodePtrImpl(body) );
// Pass annotations to arrayInterface and use them to collect
// alias info. function info etc.
ArrayAnnotation* annot = ArrayAnnotation::get_inst();
ArrayInterface array_interface( *annot );
array_interface.initialize( fa_body, AstNodePtrImpl(defn) );
array_interface.observe( fa_body );
// X. Loop normalization for all loops within body
NormalizeForLoop(fa_body, AstNodePtrImpl(body));
//cout << "Check point 3" << endl;
for ( Rose_STL_Container<SgNode*>::iterator iter = loops.begin(); iter!= loops.end(); iter++ ) {
SgNode* current_loop = *iter;
SgInitializedName* invarname = getLoopInvariant( current_loop );
if( invarname != NULL ) {
if( invarname->get_name().getString().compare("__Amos_Wang__") == 0 ) {
//cout << "It's __Amos_Wang__." << endl;
//replace "for(__Amos_Wang__ = 0;__Amos_Wang__ <= 1 - 1;__Amos_Wang__ += 1)"
//to "#pragma omp task"
std::string strtemp = current_loop->unparseToString();
strtemp.replace( 0, 64, "#pragma omp task" );
cout << "task position at: " << current_loop->get_file_info()->get_line()
<< ", " << current_loop->get_file_info()->get_col() << endl;
cout << "context: " << strtemp.c_str() << endl;
TaskValidation( current_loop );
cout << "TaskValidation done...\n" << endl;
}
else continue;
}
}// end for loops
}//end loop for each function body
cout << "--------------------------------------------" << endl;
}//end loop for each source file
release_analysis();
//generateDOT( *project );
backend( project );
//generate final file with correct directive
amos_filter( argvList0 );
// for time counter
t_end = usecs();
time_program = ((double)(t_end - t_start))/1000000;
cout << "analysis time: " << time_program << " sec" << endl;
//
cout << endl << "***** Thank you for using Amos' compiler ! *****\n" << endl;
return 0;
}
void f2cTraversal::visit(SgNode* n)
{
/*
1. The following switch statement search for the Fortran-specific
AST nodes and transform them into C nodes.
2. The new C nodes are created first. Attributes and details
are then copied from original Fortran nodes. After the
copy, original Fortran nodes are deleted.
*/
switch(n->variantT())
{
case V_SgSourceFile:
{
SgFile* fileNode = isSgFile(n);
translateFileName(fileNode);
break;
}
case V_SgProgramHeaderStatement:
{
SgProgramHeaderStatement* ProgramHeaderStatement = isSgProgramHeaderStatement(n);
ROSE_ASSERT(ProgramHeaderStatement);
translateProgramHeaderStatement(ProgramHeaderStatement);
// Deep delete the original Fortran SgProgramHeaderStatement
removeList.push_back(ProgramHeaderStatement);
break;
}
case V_SgProcedureHeaderStatement:
{
SgProcedureHeaderStatement* procedureHeaderStatement = isSgProcedureHeaderStatement(n);
ROSE_ASSERT(procedureHeaderStatement);
translateProcedureHeaderStatement(procedureHeaderStatement);
// Deep delete the original Fortran procedureHeaderStatement.
removeList.push_back(procedureHeaderStatement);
break;
}
case V_SgFortranDo:
{
SgFortranDo* fortranDo = isSgFortranDo(n);
ROSE_ASSERT(fortranDo);
translateFortranDoLoop(fortranDo);
// Deep delete the original fortranDo .
removeList.push_back(fortranDo);
break;
}
case V_SgFunctionCallExp:
{
SgFunctionCallExp* functionCallExp = isSgFunctionCallExp(n);
ROSE_ASSERT(functionCallExp);
translateImplicitFunctionCallExp(functionCallExp);
break;
}
case V_SgExponentiationOp:
{
SgExponentiationOp* expOp = isSgExponentiationOp(n);
ROSE_ASSERT(expOp);
translateExponentiationOp(expOp);
break;
}
case V_SgFloatVal:
{
SgFloatVal* floatVal = isSgFloatVal(n);
ROSE_ASSERT(floatVal);
translateDoubleVal(floatVal);
break;
}
case V_SgCommonBlock:
{
SgCommonBlock* commonBlock = isSgCommonBlock(n);
ROSE_ASSERT(commonBlock);
//translateCommonBlock(commonBlock);
break;
}
case V_SgGlobal:
{
SgGlobal* global = isSgGlobal(n);
ROSE_ASSERT(global);
removeFortranMaxMinFunction(global);
PreprocessingInfo* defMaxInfo = new PreprocessingInfo(PreprocessingInfo::CpreprocessorDefineDeclaration,
"#define max(a,b) (((a)>(b))?(a):(b))",
"Transformation generated",
0, 0, 0, PreprocessingInfo::before);
defMaxInfo->set_file_info(global->get_file_info());
global->addToAttachedPreprocessingInfo(defMaxInfo,PreprocessingInfo::before);
PreprocessingInfo* defMinInfo = new PreprocessingInfo(PreprocessingInfo::CpreprocessorDefineDeclaration,
"#define min(a,b) (((a)<(b))?(a):(b))",
"Transformation generated",
0, 0, 0, PreprocessingInfo::before);
defMinInfo->set_file_info(global->get_file_info());
global->addToAttachedPreprocessingInfo(defMinInfo,PreprocessingInfo::before);
break;
}
default:
break;
}
}
int
main ( int argc, char * argv[] )
{
// Initialize and check compatibility. See rose::initialize
ROSE_INITIALIZE;
if (argc <= 1) {
PrintUsage(argv[0]);
return -1;
}
vector<string> argvList(argv, argv + argc);
CmdOptions::GetInstance()->SetOptions(argvList);
AssumeNoAlias aliasInfo;
LoopTransformInterface::cmdline_configure(argvList);
LoopTransformInterface::set_aliasInfo(&aliasInfo);
#ifdef USE_OMEGA
DepStats.SetFileName(buffer.str());
#endif
OperatorSideEffectAnnotation *funcInfo =
OperatorSideEffectAnnotation::get_inst();
funcInfo->register_annot();
ReadAnnotation::get_inst()->read();
if (DebugAnnot())
funcInfo->Dump();
LoopTransformInterface::set_sideEffectInfo(funcInfo);
SgProject *project = new SgProject ( argvList);
int filenum = project->numberOfFiles();
for (int i = 0; i < filenum; ++i) {
// SgFile &sageFile = sageProject->get_file(i);
// SgGlobal *root = sageFile.get_root();
SgSourceFile* file = isSgSourceFile(project->get_fileList()[i]);
SgGlobal *root = file->get_globalScope();
SgDeclarationStatementPtrList& declList = root->get_declarations ();
for (SgDeclarationStatementPtrList::iterator p = declList.begin(); p != declList.end(); ++p) {
SgFunctionDeclaration *func = isSgFunctionDeclaration(*p);
if (func == 0)
continue;
SgFunctionDefinition *defn = func->get_definition();
if (defn == 0)
continue;
SgBasicBlock *stmts = defn->get_body();
AstInterfaceImpl faImpl = AstInterfaceImpl(stmts);
LoopTransformInterface::TransformTraverse(faImpl, AstNodePtrImpl(stmts));
// JJW 10-29-2007 Adjust for iterator invalidation and possible changes to declList
p = std::find(declList.begin(), declList.end(), func);
assert (p != declList.end());
}
}
if (CmdOptions::GetInstance()->HasOption("-fd")) {
simpleIndexFiniteDifferencing(project);
}
if (CmdOptions::GetInstance()->HasOption("-pre")) {
PRE::partialRedundancyElimination(project);
}
#ifdef USE_OMEGA
DepStats.SetDepChoice(0x1 | 0x2 | 0x4);
DepStats.PrintResults();
#endif
//Qing's loop transformations are not robust enough to pass all tests.
//AstTests::runAllTests(sageProject);
unparseProject(project);
if (GenerateObj())
return project->compileOutput();
return 0;
}
int
main( int argc, char* argv[] )
{
// Initialize and check compatibility. See rose::initialize
ROSE_INITIALIZE;
SgProject* project = frontend(argc,argv);
AstTests::runAllTests(project);
#if 0
// Output the graph so that we can see the whole AST graph, for debugging.
generateAstGraph(project, 4000);
#endif
#if 1
printf ("Generate the dot output of the SAGE III AST \n");
generateDOT ( *project );
printf ("DONE: Generate the dot output of the SAGE III AST \n");
#endif
// There are lots of way to write this, this is one simple approach; get all the function calls.
std::vector<SgNode*> functionCalls = NodeQuery::querySubTree (project,V_SgFunctionCallExp);
// Find the SgFunctionSymbol for snprintf so that we can reset references to "sprintf" to "snprintf" instead.
// SgGlobal* globalScope = (*project)[0]->get_globalScope();
SgSourceFile* sourceFile = isSgSourceFile(project->get_fileList()[0]);
ROSE_ASSERT(sourceFile != NULL);
SgGlobal* globalScope = sourceFile->get_globalScope();
SgFunctionSymbol* snprintf_functionSymbol = globalScope->lookup_function_symbol("snprintf");
ROSE_ASSERT(snprintf_functionSymbol != NULL);
// Iterate over the function calls to find the calls to "sprintf"
for (unsigned long i = 0; i < functionCalls.size(); i++)
{
SgFunctionCallExp* functionCallExp = isSgFunctionCallExp(functionCalls[i]);
ROSE_ASSERT(functionCallExp != NULL);
SgFunctionRefExp* functionRefExp = isSgFunctionRefExp(functionCallExp->get_function());
if (functionRefExp != NULL)
{
SgFunctionSymbol* functionSymbol = functionRefExp->get_symbol();
if (functionSymbol != NULL)
{
SgName functionName = functionSymbol->get_name();
// printf ("Function being called: %s \n",functionName.str());
if (functionName == "sprintf")
{
// Now we have something to do!
functionRefExp->set_symbol(snprintf_functionSymbol);
// Now add the "n" argument
SgExprListExp* functionArguments = functionCallExp->get_args();
SgExpressionPtrList & functionArgumentList = functionArguments->get_expressions();
// "sprintf" shuld have exactly 2 arguments (I guess the "..." don't count)
printf ("functionArgumentList.size() = %zu \n",functionArgumentList.size());
// ROSE_ASSERT(functionArgumentList.size() == 2);
SgExpressionPtrList::iterator i = functionArgumentList.begin();
// printf ("(*i) = %p = %s = %s \n",*i,(*i)->class_name().c_str(),SageInterface::get_name(*i).c_str());
SgVarRefExp* variableRefExp = isSgVarRefExp(*i);
ROSE_ASSERT(variableRefExp != NULL);
// printf ("variableRefExp->get_type() = %p = %s = %s \n",variableRefExp->get_type(),variableRefExp->get_type()->class_name().c_str(),SageInterface::get_name(variableRefExp->get_type()).c_str());
SgType* bufferType = variableRefExp->get_type();
SgExpression* bufferLengthExpression = NULL;
switch(bufferType->variantT())
{
case V_SgArrayType:
{
SgArrayType* arrayType = isSgArrayType(bufferType);
bufferLengthExpression = arrayType->get_index();
break;
}
case V_SgPointerType:
{
// SgPointerType* pointerType = isSgPointerType(bufferType);
SgInitializedName* variableDeclaration = variableRefExp->get_symbol()->get_declaration();
ROSE_ASSERT(variableDeclaration != NULL);
SgExpression* initializer = variableDeclaration->get_initializer();
if (initializer != NULL)
{
SgAssignInitializer* assignmentInitializer = isSgAssignInitializer(initializer);
ROSE_ASSERT(assignmentInitializer != NULL);
// This is the rhs of the initialization of the pointer (likely a malloc through a cast).
// This assumes: buffer = (char*) malloc(bufferLengthExpression);
SgExpression* initializationExpression = assignmentInitializer->get_operand();
ROSE_ASSERT(initializationExpression != NULL);
SgCastExp* castExp = isSgCastExp(initializationExpression);
ROSE_ASSERT(castExp != NULL);
SgFunctionCallExp* functionCall = isSgFunctionCallExp(castExp->get_operand());
ROSE_ASSERT(functionCall != NULL);
SgExprListExp* functionArguments = isSgExprListExp(functionCall->get_args());
bufferLengthExpression = functionArguments->get_expressions()[0];
ROSE_ASSERT(bufferLengthExpression != NULL);
}
else
{
printf ("Initializer not found, so no value for n in snprintf can be computed currently \n");
}
break;
}
default:
{
printf ("Error: default reached in evaluation of buffer type = %p = %s \n",bufferType,bufferType->class_name().c_str());
ROSE_ASSERT(false);
}
}
ROSE_ASSERT(bufferLengthExpression != NULL);
// printf ("bufferLengthExpression = %p = %s = %s \n",bufferLengthExpression,bufferLengthExpression->class_name().c_str(),SageInterface::get_name(bufferLengthExpression).c_str());
// Jump over the first argument, the "n" is defined to be the 2nd argument (the rest are shifted one position).
i++;
// Build a deep copy of the expression used to define the static buffer (could be any complex expression).
SgTreeCopy copy_help;
SgExpression* bufferLengthExpression_copy = isSgExpression(bufferLengthExpression->copy(copy_help));
// Insert the "n" for the parameter list to work with "snprintf" instead of "sprintf"
functionArgumentList.insert(i,bufferLengthExpression_copy);
}
}
}
}
return backend(project);
}