NameQuerySynthesizedAttributeType
NameQuery::queryNameUnionFieldNames (SgNode * astNode)
{
ROSE_ASSERT (astNode != 0);
NameQuerySynthesizedAttributeType returnNameList;
// SgNode *sageReturnNode = NULL;
SgClassDefinition *sageClassDefinition = isSgClassDefinition (astNode);
if (sageClassDefinition != NULL)
{
ROSE_ASSERT (sageClassDefinition->get_declaration () != NULL);
if (sageClassDefinition->get_declaration ()->get_class_type () ==
SgClassDeclaration::e_struct)
{
SgDeclarationStatementPtrList declarationStatementPtrList =
sageClassDefinition->get_members ();
typedef SgDeclarationStatementPtrList::iterator LI;
for (LI i = declarationStatementPtrList.begin ();
i != declarationStatementPtrList.end (); ++i)
{
SgNode *listElement = *i;
SgVariableDeclaration *sageVariableDeclaration =
isSgVariableDeclaration (listElement);
if (sageVariableDeclaration != NULL)
{
typedef SgInitializedNamePtrList::iterator INITLI;
SgInitializedNamePtrList sageInitializedNameList = sageVariableDeclaration->get_variables ();
for (INITLI i = sageInitializedNameList.begin ();
i != sageInitializedNameList.end (); ++i)
{
SgInitializedName* initializedListElement = *i;
ROSE_ASSERT (isSgInitializedName (initializedListElement) != NULL);
returnNameList.push_back (initializedListElement->get_name().str());
} /* End iteration over declarationStatementPtrList */
} /* End iteration over declarationStatementPtrList */
}
}
}
return returnNameList;
} /* End function queryUnionFieldNames() */
NodeQuerySynthesizedAttributeType
NodeQuery::querySolverClassFields (SgNode * astNode)
{
ROSE_ASSERT (astNode != 0);
NodeQuerySynthesizedAttributeType returnNodeList;
/* cout << "The name of the node is: \" " << astNode->sage_class_name() << "\"\n";
SgLocatedNode* sageLocatedNode = isSgLocatedNode(astNode);
if(sageLocatedNode != NULL){
cout << "The filename is: " << sageLocatedNode->getFileName() << " At line number :" << sageLocatedNode->get_file_info()->get_line() << "\n";
} */
// SgNode *sageReturnNode = NULL;
SgClassDefinition *sageClassDefinition = isSgClassDefinition (astNode);
if (sageClassDefinition != NULL)
{
ROSE_ASSERT (sageClassDefinition->get_declaration () != NULL);
if (sageClassDefinition->get_declaration ()->get_class_type () ==
SgClassDeclaration::e_class)
{
SgDeclarationStatementPtrList declarationStatementPtrList =
sageClassDefinition->get_members ();
typedef SgDeclarationStatementPtrList::iterator LI;
for (LI i = declarationStatementPtrList.begin ();
i != declarationStatementPtrList.end (); ++i)
{
SgNode *listElement = *i;
if (isSgVariableDeclaration (listElement) != NULL){
/* if(isSgVariableDeclaration(listElement)->get_name().str() != NULL)
cout << "The name of the variable declaration is: \"" << isSgVariableDeclaration(listElement)->get_name().str() << "\"\n";
else
cout << "The name of the variable declaration is: \"\"\n";*/
returnNodeList.push_back (listElement);
}
}
}
}
return returnNodeList;
} /* End function querySolverClassFields() */
NodeQuerySynthesizedAttributeType
NodeQuery::querySolverUnionFields (SgNode * astNode)
{
ROSE_ASSERT (astNode != 0);
NodeQuerySynthesizedAttributeType returnNodeList;
// SgNode *sageReturnNode = NULL;
SgClassDefinition *sageClassDefinition = isSgClassDefinition (astNode);
if (sageClassDefinition != NULL)
{
ROSE_ASSERT (sageClassDefinition->get_declaration () != NULL);
if (sageClassDefinition->get_declaration ()->get_class_type () ==
SgClassDeclaration::e_union)
{
SgDeclarationStatementPtrList declarationStatementPtrList =
sageClassDefinition->get_members ();
typedef SgDeclarationStatementPtrList::iterator LI;
for (LI i = declarationStatementPtrList.begin ();
i != declarationStatementPtrList.end (); ++i)
{
SgNode *listElement = *i;
if (isSgVariableDeclaration (listElement) != NULL)
returnNodeList.push_back (listElement);
}
}
}
return returnNodeList;
} /* End function querySolverUnionFields() */
SgClassDeclaration* RtedTransformation::instrumentClassDeclarationIntoTopOfAllSourceFiles(
SgProject* project, SgClassDeclaration* classDecl) {
// **********************
if (RTEDDEBUG) cerr <<"@@@ instrumenting into top "<< endl;
// deep copy the classdecl and make it unparseable
SgClassDeclaration* cd_copy = SageInterface::deepCopy(classDecl);
// cout << ">>>>>> Original ClassType :::: " << classDecl->get_type() << endl;
// cout << ">>>>>> Copied ClassType :::: " << cd_copy->get_type() << endl;
// SgClassType* type_copy = new SgClassType(cd_copy);
//cd_copy->set_type(type_copy);
ROSE_ASSERT(cd_copy);
const SgNodePtrList& nodes2 = NodeQuery::querySubTree(cd_copy, V_SgLocatedNode);
SgNodePtrList::const_iterator nodesIT2 = nodes2.begin();
for (; nodesIT2 != nodes2.end(); ++nodesIT2) {
SgLocatedNode* node = isSgLocatedNode(*nodesIT2);
ROSE_ASSERT(node);
Sg_File_Info* file_info = node->get_file_info();
file_info->setOutputInCodeGeneration();
//cerr << "copying node : " << node->class_name() << endl;
}
if (RTEDDEBUG) cerr << "deep copy of firstnondefining" << endl;
SgClassDeclaration* nondefDecl = isSgClassDeclaration(classDecl->get_firstNondefiningDeclaration());
SgClassDeclaration* cdn_copy = SageInterface::deepCopy(nondefDecl);
ROSE_ASSERT(cdn_copy);
const SgNodePtrList& nodes = NodeQuery::querySubTree(cdn_copy, V_SgLocatedNode);
SgNodePtrList::const_iterator nodesIT = nodes.begin();
for (; nodesIT != nodes.end(); ++nodesIT) {
SgLocatedNode* node = isSgLocatedNode(*nodesIT);
ROSE_ASSERT(node);
Sg_File_Info* file_info = node->get_file_info();
file_info->setOutputInCodeGeneration();
}
cd_copy->set_firstNondefiningDeclaration(cdn_copy);
SgClassType* cls_type = SgClassType::createType(cdn_copy);
cls_type->set_declaration(cdn_copy);
ROSE_ASSERT(cls_type != NULL);
ROSE_ASSERT (cls_type->get_declaration() == cdn_copy);
cdn_copy->set_type(cls_type);
cdn_copy->set_definingDeclaration(cd_copy);
cd_copy->set_type(cdn_copy->get_type());
if (RTEDDEBUG) {
cerr << "@@@@@@@@@@@@@@ Original Class classDecl : " << classDecl << " :: " << cd_copy << endl;
cerr << "@@@@@@@@@@@@@@ Original Class nondefining : " << classDecl->get_firstNondefiningDeclaration()<< " :: " << cdn_copy << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cd_copy->get_type() : " << cd_copy->get_type() << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cdn_copy->get_type() : " << cdn_copy->get_type() << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cd_copy->get_type()->declaration : " <<cd_copy->get_type()->get_declaration() << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cd_copy->definingDeclaration : " << cd_copy->get_definingDeclaration() << endl;
cerr << "@@@@@@@@@@@@@@@@@@ TYPE OF cd_copy->set_firstNondefiningDeclaration : " << cd_copy->get_firstNondefiningDeclaration() << endl;
}
// **********************
// add to top of each source file
// insert at top of all source files in reverse order
// only if the class has private members and if it is declared in a header file
std::vector<SgSourceFile*>::const_iterator aa = srcfiles.begin();
std::vector<SgSourceFile*>::const_iterator zz = srcfiles.end();
for (; aa != zz; ++aa)
{
SgSourceFile* sf = *aa;
assert( isInInstrumentedFile(sf) );
if (RTEDDEBUG) cerr << "Looking through sourcefile: " << sf -> get_file_info() -> get_filename() << endl;
// once we have the new class_decl inserted, we remove all functions and the constructor and destructor
const SgNodePtrList& remNodes = NodeQuery::querySubTree(cd_copy, V_SgFunctionDeclaration);
SgNodePtrList::const_iterator remNodesIt = remNodes.begin();
for (; remNodesIt != remNodes.end(); ++remNodesIt) {
SgFunctionDeclaration* node = isSgFunctionDeclaration(*remNodesIt);
ROSE_ASSERT(node);
SageInterface::removeStatement(node);
}
if (RTEDDEBUG) cerr << " changing privates to public" << endl;
// change each private: to public:
SgClassDefinition* cd_def = cd_copy->get_definition();
ROSE_ASSERT(cd_def);
SgDeclarationStatementPtrList decls = cd_def->get_members();
SgDeclarationStatementPtrList::const_iterator itDecls = decls.begin();
for (;itDecls!=decls.end();++itDecls) {
SgVariableDeclaration* node = isSgVariableDeclaration(*itDecls);
if (node) {
SgDeclarationModifier& mod = node->get_declarationModifier();
SgAccessModifier& am = mod.get_accessModifier();
if (am.isPrivate() || am.isProtected())
am.setPublic();
}
}
// get the namespace RTED to put new class into
if (RTEDDEBUG) cerr << "Finding Namespace RTED " << endl;
SourceFileRoseNMType::const_iterator pit = sourceFileRoseNamespaceMap.find(sf);
ROSE_ASSERT(pit!=sourceFileRoseNamespaceMap.end());
SgNamespaceDeclarationStatement* firstNamespace = pit->second;
// insert at top of file - after includes
if (RTEDDEBUG)
{
cerr << " Prepending to source file: " << sf -> get_file_info() -> get_filename()
<< " class : " << cd_copy->get_name().str()
<< endl;
}
// we prepend it to the top of the file and later move the include back up
SageInterface::prependStatement(cdn_copy,firstNamespace->get_definition());
SageInterface::appendStatement(cd_copy, firstNamespace->get_definition() );
ROSE_ASSERT(cdn_copy->get_symbol_from_symbol_table() != NULL);
classesInRTEDNamespace[classDecl->get_definition()] = cd_def;
}
return cd_copy;
}
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;
}
Rose_STL_Container<
ControlStructureContainer *
>queryFindCommentsInScope (const string stringPrefixToMatch,
const string stringToMatch,
SgScopeStatement * sageScopeStatement)
{
ROSE_ASSERT (stringPrefixToMatch.length () > 0);
ROSE_ASSERT (stringToMatch.length () > 0);
ROSE_ASSERT (sageScopeStatement != NULL);
Rose_STL_Container< ControlStructureContainer * >returnList;
//find all pragmas who match the stringToMatch
//cout << "Before pragma search" << endl;
/*list < SgNode * >pragmaStatements =
NodeQuery::querySubTree (sageScopeStatement,
new SgName (stringToMatch.c_str ()),
NodeQuery::PragmaDeclarationFromName);
*/
//list<SGNode*> pragmaStatements ;
//cout << "After pragma search" << endl;
/* cout << "BEFORE LIST" << endl;
list < SgNode * >pragmaStatements = queryNodePragmaStatementFromName2(sageScopeStatement,
new SgName(stringToMatch.c_str()));
cout << "AFTER LIST" << endl;*/
//return the pragmas in containers
/* for (list < SgNode * >::iterator i = pragmaStatements.begin ();
i != pragmaStatements.end (); ++i)
{
SgPragmaDeclaration *sagePragma = isSgPragmaDeclaration (*i);
ROSE_ASSERT (sagePragma);
ROSE_ASSERT (sagePragma->get_pragma () != NULL);
ROSE_ASSERT (sagePragma->get_pragma ()->get_pragma ());
ControlStructureContainer *container = new ControlStructureContainer ();
container->setPragmaString (sagePragma->get_pragma ()->get_pragma ());
container->setAssociatedStatement (sagePragma);
returnList.push_back (container);
}
*/
//find all statements in the current scope
if (sageScopeStatement->variantT () == V_SgClassDefinition)
{
SgDeclarationStatementPtrList statementsInScope =
sageScopeStatement->getDeclarationList ();
SgDeclarationStatementPtrList::iterator i;
for (i = statementsInScope.begin (); i != statementsInScope.end (); i++)
{
SgLocatedNode *locatedNode = isSgLocatedNode (*i);
ROSE_ASSERT (locatedNode != NULL);
//find all comments attached to current node.
AttachedPreprocessingInfoType *comments =
locatedNode->getAttachedPreprocessingInfo ();
if(locatedNode->variantT() == V_SgPragmaDeclaration){
SgPragmaDeclaration* sagePragmaDeclaration = isSgPragmaDeclaration(locatedNode);
ROSE_ASSERT( sagePragmaDeclaration );
ROSE_ASSERT( sagePragmaDeclaration->get_pragma() != NULL );
string pragmaDeclarationString = sagePragmaDeclaration->get_pragma()->get_pragma();
//extract the part before the leftmost = is pragmaDeclarationString
pragmaDeclarationString = pragmaDeclarationString.substr(0,pragmaDeclarationString.find("="));
//if the name-criteria is met accept node
if(pragmaDeclarationString.find( stringToMatch ) != string::npos ){
cout << pragmaDeclarationString << endl;
ControlStructureContainer *container = new ControlStructureContainer ();
container->setPragmaString (sagePragmaDeclaration->get_pragma ()->get_pragma ());
container->setAssociatedStatement (sagePragmaDeclaration);
returnList.push_back (container);
}
}
if (comments != NULL)
{
//We need to find comments which fits the criteria
printf ("Found attached comments (at %p of type: %s): \n",
locatedNode, locatedNode->sage_class_name ());
AttachedPreprocessingInfoType::iterator j;
for (j = comments->begin (); j != comments->end (); j++)
{
ROSE_ASSERT ((*j) != NULL);
string comment = (*j)->getString ();
//see if comment begins with stringPrefixToMatch
string tempString = comment.substr (0, comment.find (' '));
if (tempString == stringPrefixToMatch)
{ //+stringPrefixToMatch ){
//cout << "Found string" << endl;
comment =
StringUtility::copyEdit (comment, stringPrefixToMatch,
"");
//see if the comment has an element which matches the stringToMatch
if (comment.find (stringToMatch) != string::npos)
{
//puit the matching comment into a container
ControlStructureContainer *container =
new ControlStructureContainer ();
container->setPragmaString (comment);
container->setAssociatedStatement (locatedNode);
returnList.push_back (container);
}
}
// printf (" Attached Comment (relativePosition=%s):\n %s\n Next comment: \n",
// ((*j)->relativePosition == PreprocessingInfo::before) ? "before" : "after",(*j)->getString());
}
}
}
}
else
{
// AS 12/18/03 PS!! The same as the above, but a different iterator. Will replace this when a
// different solution has arisen. PS!!
SgStatementPtrList statementsInScope =
sageScopeStatement->getStatementList ();
SgStatementPtrList::iterator i;
for (i = statementsInScope.begin (); i != statementsInScope.end (); i++)
{
SgLocatedNode *locatedNode = isSgLocatedNode (*i);
ROSE_ASSERT (locatedNode != NULL);
if(locatedNode->variantT() == V_SgPragmaDeclaration){
SgPragmaDeclaration* sagePragmaDeclaration = isSgPragmaDeclaration(locatedNode);
ROSE_ASSERT( sagePragmaDeclaration );
ROSE_ASSERT( sagePragmaDeclaration->get_pragma() != NULL );
string pragmaDeclarationString = sagePragmaDeclaration->get_pragma()->get_pragma();
//extract the part before the leftmost = is pragmaDeclarationString
pragmaDeclarationString = pragmaDeclarationString.substr(0,pragmaDeclarationString.find("="));
//if the name-criteria is met accept node
if(pragmaDeclarationString.find( stringToMatch ) != string::npos ){
cout << pragmaDeclarationString << endl;
ControlStructureContainer *container = new ControlStructureContainer ();
container->setPragmaString (sagePragmaDeclaration->get_pragma ()->get_pragma ());
container->setAssociatedStatement (sagePragmaDeclaration);
returnList.push_back (container);
}
}
//find all comments attached to current node.
AttachedPreprocessingInfoType *comments =
locatedNode->getAttachedPreprocessingInfo ();
if (comments != NULL)
{
//We need to find comments which fits the criteria
//printf ("Found attached comments (at %p of type: %s): \n",locatedNode,locatedNode->sage_class_name());
AttachedPreprocessingInfoType::iterator j;
for (j = comments->begin (); j != comments->end (); j++)
{
ROSE_ASSERT ((*j) != NULL);
string comment = (*j)->getString ();
//see if comment begins with stringPrefixToMatch
string tempString = comment.substr (0, comment.find (' '));
if (tempString == stringPrefixToMatch)
{ //+stringPrefixToMatch ){
comment =
StringUtility::copyEdit (comment, stringPrefixToMatch,
"");
cout << "And the string is: " << comment << endl;
if (comment.find (stringToMatch) != string::npos)
{
cout << "And even the string is matched." << endl;
//ROSE_ASSERT(comment.find('=') != comment.length());
//string variableName = comment.substr(comment.find(stringToMatch), comment.find('='));
cout << "And the string is a match" << endl;
//puit the matching comment into a container
ControlStructureContainer *container =
new ControlStructureContainer ();
container->setPragmaString (comment);
container->setAssociatedStatement (locatedNode);
returnList.push_back (container);
}
}
/* printf
(" Attached Comment (relativePosition=%s):\n %s\n Next comment: \n",
((*j)->relativePosition ==
PreprocessingInfo::before) ? "before" : "after",
(*j)->getString ());*/
}
}
}
}
return returnList;
} /* End function: queryFindCommentsInScope() */
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);
}
}
}