NodeQuerySynthesizedAttributeType NodeQuery::queryNodeClassDeclarationFromName(SgNode* node, SgNode* nameNode){
NodeQuerySynthesizedAttributeType returnList;
ROSE_ASSERT( nameNode != NULL );
ROSE_ASSERT( node != NULL );
//finds the name which should be matched to
SgName* sageName = isSgName(nameNode);
ROSE_ASSERT( sageName != NULL );
std::string nameToMatch = sageName->str();
ROSE_ASSERT( nameToMatch.length() > 0 );
SgClassDeclaration *sageClassDeclaration = isSgClassDeclaration (node);
if (sageClassDeclaration != NULL)
{
std::string name = sageClassDeclaration->get_name ().str ();
if( name == nameToMatch )
returnList.push_back(node);
}
return returnList;
} /* End function:queryNodeCLassDeclarationFromName() */
void visitorTraversal::analyzePath(vector<VertexID>& pth) {
std::vector<VertexID> pathR = pth;
std::vector<SgGraphNode*> path;
for (unsigned int j = 0; j < pathR.size(); j++) {
SgGraphNode* R = (*orig)[pathR[j]].sg;
path.push_back(R);
}
for (unsigned int k = 0; k < path.size(); k++) {
if (isSgFunctionRefExp(path[k]->get_SgNode())) {
SgFunctionRefExp* sfrd = isSgFunctionRefExp(path[k]->get_SgNode());
SgFunctionDeclaration* fd = sfrd->getAssociatedFunctionDeclaration();
fd = isSgFunctionDeclaration(fd->get_definingDeclaration());
assert(fd!=NULL);
SgFunctionDefinition* fdd = fd->get_definition();
SgName sname = fdd->get_mangled_name();
string sn = sname.getString();
if (find(defstr.begin(), defstr.end(), sn) == defstr.end()) {
defstr.push_back(sn);
defs.push_back(fdd);
std::cout << "found new sn: " << sn << std::endl;
}
else {
std::cout << "found old sn: " << sn << std::endl;
}
}
}
#pragma omp atomic
paths++;
}
/*
* The function
* queryNodePragmaDeclarationFromName()
* takes as a first parameter a SgNode*. As a second parameter it takes
* a SgNode* who must be of type SgName. The SgName contains a std::string which
* should be the same as the left side in the pragma or a part of the left
* side of the pragma. If the std::string is empty,
* there will be an error message.
*
* #pragma std::stringInSgNode = information
*
*/
Rose_STL_Container<SgNode*> NodeQuery::queryNodePragmaDeclarationFromName(SgNode* node, SgNode* nameNode){
ROSE_ASSERT( nameNode != NULL );
ROSE_ASSERT( node != NULL );
Rose_STL_Container<SgNode*> returnList;
//finds the name which should be matched to
SgName* sageName = isSgName(nameNode);
ROSE_ASSERT( sageName != NULL );
std::string nameToMatch = sageName->str();
ROSE_ASSERT( nameToMatch.length() > 0 );
if(node->variantT() == V_SgPragmaDeclaration){
SgPragmaDeclaration* sagePragmaDeclaration = isSgPragmaDeclaration(node);
ROSE_ASSERT( sagePragmaDeclaration );
ROSE_ASSERT( sagePragmaDeclaration->get_pragma() != NULL );
// ROSE_ASSERT( sagePragmaDeclaration->get_pragma()->get_pragma() );
std::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( nameToMatch ) != pragmaDeclarationString.length() ){
cout << pragmaDeclarationString << endl;
returnList.push_back(node);
}
}
return returnList;
}
SgName
mangleFunctionName (const SgName& n, const SgName& ret_type_name )
{
string s_mangled = mangleFunctionNameToString (n.getString (),
ret_type_name.str ());
SgName n_mangled (s_mangled.c_str ());
return n_mangled;
}
ScopExtractor::ScopExtractor(SgProject* project, PolyRoseOptions& polyopts)
{
// this->project = project;
this->polyoptions = polyopts;
isVerbose = ! polyopts.getQuiet();
if (isVerbose)
std::cout << "[PolyOpt] Using generic scop extractor" << std::endl;
SgFilePtrList& file_list = project->get_fileList();
SgFilePtrList::const_iterator file_iter;
// Iterate on all files of the project.
for (file_iter = file_list.begin(); file_iter != file_list.end(); file_iter++)
{
SgSourceFile* file = isSgSourceFile(*file_iter);
if (polyoptions.getScVerboseLevel())
cout << "[Extr] File: " << file->getFileName() << endl;
SgNodePtrList funcDefnList =
NodeQuery::querySubTree(file, V_SgFunctionDefinition);
SgNodePtrList::const_iterator iter;
// Iterate on all function defined in a file.
for (iter = funcDefnList.begin(); iter != funcDefnList.end(); ++iter)
{
SgFunctionDefinition *fun = isSgFunctionDefinition(*iter);
if (!fun)
{
cout << "[Extr] Warning: Expected SgFunctionDefinition in " <<
file->getFileName() << endl;
continue; // with the next function definition
}
SgName name = fun->get_declaration()->get_name();
if (polyoptions.getScVerboseLevel())
cout << "[Extr] Function: " << name.getString() << endl;
SgBasicBlock* body = fun->get_body();
// Ensure the function is a candidate (no (unsafe) function
// calls).
if (assertFunctionIsCandidate(project, body))
{
// Proceed recursively, bottom up.
inspectBottomUpFunctionBody(project, body);
}
}
}
if (isVerbose)
std::cout << "[ScopExtraction] Generic: done" << std::endl;
}
/**
* Do not reuse variable names in subscopes
*/
bool DCL01_C( const SgNode *node ) {
const SgInitializedName *varInitName = isSgInitializedName(node);
if (!varInitName)
return false;
const SgName varName = varInitName->get_name();
const SgScopeStatement *varScope = varInitName->get_scope();
assert(varScope);
while(!isSgGlobal(varScope)) {
varScope = varScope->get_scope();
if(varScope->symbol_exists(varName)) {
print_error(node, "DCL01-C", ("Do not reuse variable names in subscopes: " + varName.getString()).c_str(), true);
return true;
}
}
return false;
}
SgName
mangleTemplate (const SgName& templ_name,
const SgTemplateArgumentPtrList& templ_args,
const SgScopeStatement* scope)
{
string mangled_name = mangleTemplateToString(templ_name.getString(),templ_args,scope);
// printf ("In mangleTemplate(): mangled_name = %s \n",mangled_name.c_str());
return SgName (mangled_name.c_str());
}
void
Unparse_Jovial::unparseVarDecl(SgStatement* stmt, SgInitializedName* initializedName, SgUnparse_Info& info)
{
SgName name = initializedName->get_name();
SgType* type = initializedName->get_type();
SgInitializer* init = initializedName->get_initializer();
ROSE_ASSERT(type);
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(stmt);
ROSE_ASSERT(variableDeclaration != NULL);
#if 0
if (variableDeclaration->get_declarationModifier().get_typeModifier().isStatic() == true)
{
curprint("STATIC ");
}
#endif
switch (type->variantT())
{
case V_SgArrayType:
curprint("TABLE ");
curprint(name.str());
break;
default:
curprint("ITEM ");
curprint(name.str());
curprint(" ");
}
unparseType(type, info);
if (init != NULL)
{
curprint(" = ");
SgInitializer* initializer = isSgInitializer(init);
ROSE_ASSERT(initializer != NULL);
// TODO
// unparseExpression(initializer, info);
}
curprint(" ;\n");
}
NodeQuerySynthesizedAttributeType
queryNodeClassDeclarationFromTypedefName (SgNode * astNode,
SgNode * nameNode)
{
NodeQuerySynthesizedAttributeType returnList;
ROSE_ASSERT (nameNode != NULL);
ROSE_ASSERT (nameNode != NULL);
//finds the name which should be matched to
SgName *sageName = isSgName (nameNode);
ROSE_ASSERT (sageName != NULL);
string nameToMatch = sageName->str ();
ROSE_ASSERT (nameToMatch.length () > 0);
if (isSgType (astNode) != NULL)
{
/*SgTypedefType* sageTypedefType = isSgTypedefType(astNode);
string name = TransformationSupport::getTypeName(sageTypedefType);
ROSE_ASSERT( nameToMatch.length() > 0 );
cout << nameToMatch << endl; */
#ifdef DEBUG_CGRAPHPP
cout << TransformationSupport::getTypeName (isSgType (astNode)) << endl;
#endif
if (TransformationSupport::getTypeName (isSgType (astNode)) ==
nameToMatch)
{
returnList.push_back (astNode);
}
/*
if(nameToMatch == name){
SgClassDeclaration *sageClassDeclaration = isSgClassDeclaration (sageTypedefType->get_declaration());
ROSE_ASSERT( sageClassDeclaration != NULL );
returnList.push_back(sageClassDeclaration);
}*/
}
return returnList;
}
/**
* Create scops for a sub-tree.
*
*/
void
ScopExtractor::extractScops(SgNode* root)
{
if (isVerbose)
std::cout << "[PolyOpt] Using generic scop extractor" << std::endl;
SgNodePtrList funcDefnList =
NodeQuery::querySubTree(root, V_SgFunctionDefinition);
SgNodePtrList::const_iterator iter;
// Iterate on all functions defined in a sub-tree.
for (iter = funcDefnList.begin(); iter != funcDefnList.end(); ++iter)
{
SgFunctionDefinition *fun = isSgFunctionDefinition(*iter);
if (!fun)
{
cout << "[Extr] Warning: Expected SgFunctionDefinition" << endl;
continue; // with the next function definition
}
SgName name = fun->get_declaration()->get_name();
if (polyoptions.getScVerboseLevel())
cout << "[Extr] Function: " << name.getString() << endl;
SgBasicBlock* body = fun->get_body();
// Ensure the function is a candidate (no (unsafe) function
// calls).
if (assertFunctionIsCandidate(NULL, body))
{
// Proceed recursively, bottom up.
inspectBottomUpFunctionBody(NULL, body);
}
}
// If no function is defined in the subtree, simply process it
// as-is.
if (funcDefnList.size() == 0)
if (assertFunctionIsCandidate(NULL, root))
// Proceed recursively, bottom up.
inspectBottomUpFunctionBody(NULL, root);
if (isVerbose)
std::cout << "[ScopExtraction] Generic: done" << std::endl;
}
Rose_STL_Container<SgNode*> NodeQuery::queryNodeVariableDeclarationFromName(SgNode* astNode, SgNode* nameNode){
ROSE_ASSERT( nameNode != NULL );
ROSE_ASSERT( astNode != NULL );
Rose_STL_Container<SgNode*> returnList;
if(astNode->variantT() == V_SgVariableDeclaration){
SgName* sageName = isSgName(nameNode);
ROSE_ASSERT( sageName != NULL );
std::string nameToMatch = sageName->str();
ROSE_ASSERT( nameToMatch.length() > 0 );
SgVariableDeclaration* sageVariableDeclaration = isSgVariableDeclaration(astNode);
ROSE_ASSERT(sageVariableDeclaration != NULL);
ROSE_ASSERT( sageVariableDeclaration->get_definition() != NULL );
SgInitializedNamePtrList sageInitializedNameList = sageVariableDeclaration->get_variables ();
//see if this variable declaration fits the criteria
typedef SgInitializedNamePtrList::iterator variableIterator;
for (variableIterator k = sageInitializedNameList.begin ();
k != sageInitializedNameList.end(); ++k)
{
SgInitializedName* elmVar = *k;
std::string name = elmVar->get_name().str();
if(name == nameToMatch)
returnList.push_back(astNode);
}
}
return returnList;
}; /* End function: queryNodeVariableDeclarationFromName */
void
SimpleInstrumentation::visit ( SgNode* astNode )
{
// Demonstrate and test append mechanism for statements
// printf ("In assemblyFunction(): astNode->sage_class_name() = %s \n",astNode->sage_class_name());
if (isSgFunctionDeclaration(astNode) != NULL)
{
// printf ("Found a function declaration \n");
SgFunctionDeclaration* functionDeclarationStatement = isSgFunctionDeclaration(astNode);
SgName sageName = functionDeclarationStatement->get_name();
string functionNameString = sageName.str();
// Make sure this is the "main" function before we insert new code
if (functionNameString == "main")
{
string globalDeclarations = "int k;";
string functionSource = "";
string localDeclarations = "\
void myTimerFunctionStart(void) \n\
{ \n\
int xyzVariable; \n\
} \n\n\
SgName
joinMangledQualifiers (const SgName& base, const SgName& name)
{
#if 0
// DQ (8/25/2006): This is debugging code required to find a problem that
// results in a 480,000,000 character string used of a mangled name prefix
// within the boost_tests/test_boost_phoenix_v2.C
printf ("base.getString ().size() = %ld name.getString ().size() = %ld \n",base.getString().size(),name.getString().size());
const int MODERATE_SIZE = 1000;
if (base.getString().size() > MODERATE_SIZE)
printf ("base.getString() = %s \n",base.getString().c_str());
const int MAX_SIZE = 10000;
ROSE_ASSERT(base.getString().size() < MAX_SIZE);
ROSE_ASSERT(name.getString().size() < MAX_SIZE);
#endif
string mangled_name = joinMangledQualifiersToString (base.getString (),name.getString ());
return SgName (mangled_name.c_str ());
}
void fixupEdgBugDuplicateVariablesInAST()
{
// DQ (3/11/2006): Introduce tracking of performance of ROSE.
TimingPerformance timer1 ("Fixup known EDG bug where some variable declarations are dropped from the source sequence lists:");
std::set<SgVariableDeclaration*> declarations_to_remove;
// Loop over all variables added using the convert_field_use() function.
std::set<SgVariableDeclaration*>::iterator i = nodesAddedWithinFieldUseSet.begin();
while (i != nodesAddedWithinFieldUseSet.end())
{
SgVariableDeclaration* var_decl = *i;
SgName name = var_decl->get_variables()[0]->get_name();
SgClassDefinition* classDefinition = isSgClassDefinition(var_decl->get_parent());
ROSE_ASSERT(classDefinition != NULL);
std::vector<SgDeclarationStatement*> & members = classDefinition->get_members();
// Loop over all data members in the class.
std::vector<SgDeclarationStatement*>::iterator j = members.begin();
while (j != members.end())
{
SgVariableDeclaration* possible_matching_variable_declaration = isSgVariableDeclaration(*j);
if (possible_matching_variable_declaration != NULL && possible_matching_variable_declaration != var_decl)
{
if (possible_matching_variable_declaration->get_variables()[0]->get_name() == name)
{
#if 0
printf ("matching variable declaration found for name = %s \n",name.str());
#endif
declarations_to_remove.insert(var_decl);
}
}
j++;
}
i++;
}
// Now remove all of the variable declarations that we detected to be duplicates.
std::set<SgVariableDeclaration*>::iterator k = declarations_to_remove.begin();
while (k != declarations_to_remove.end())
{
SgDeclarationStatement* var_decl = *k;
SgClassDefinition* classDefinition = isSgClassDefinition(var_decl->get_parent());
ROSE_ASSERT(classDefinition != NULL);
std::vector<SgDeclarationStatement*> myvector;
myvector.push_back(*k);
std::vector<SgDeclarationStatement*> & members = classDefinition->get_members();
// members.erase(*k);
// members.erase(myvector.begin(),myvector.end());
// This is the remove/erase idiom.
members.erase(remove(members.begin(), members.end(), *k), members.end());
k++;
}
}
string
AST_Rewrite::AccumulatedDeclarationsAttribute::
generateDeclarationString ( SgDeclarationStatement* declaration ) const
{
// This function generates a string for a declaration. The string is required for
// the intermediate file to make sure that all transformation code will compile
// (since it could depend on declarations defined within the code).
// Details:
// 1) Only record declarations found within the source file (exclude all header files
// since they will be seen when the same header files are included).
// 2) Resort the variable declarations to remove redundent entries.
// WRONG: variable declarations could have dependences upon class declarations!
// 3) Don't sort all declarations since some could have dependences.
// a) class declarations
// b) typedefs
// c) function declarations
// d) template declarations
// e) variable definition???
ROSE_ASSERT (this != NULL);
ROSE_ASSERT ( declaration != NULL );
string declarationString;
// Build a SgUnparse_Info object to represent formatting options for
// this statement (use the default values).
SgUnparse_Info info;
// exclude comments
info.set_SkipComments();
// exclude all CPP directives (since they have already been evaluated by the front-end)
info.set_SkipCPPDirectives();
switch ( declaration->variantT() )
{
// Enum declarations should not skip their definition since
// this is where the constants are declared.
case V_SgEnumDeclaration:
case V_SgVariableDeclaration:
case V_SgTemplateDeclaration:
case V_SgTypedefDeclaration:
// Need to figure out if a forward declaration would work or be
// more conservative and always output the complete class definition.
// turn off output of initializer values
info.set_SkipInitializer();
// output the declaration as a string
declarationString = globalUnparseToString(declaration,&info);
break;
case V_SgClassDeclaration:
// Need to figure out if a forward declaration would work or be
// more conservative and always output the complete class definition.
// turn off the generation of the function definitions only
// (we still want the restof the class definition since these
// define all member data and member functions).
// info.set_SkipClassDefinition();
info.set_SkipFunctionDefinition();
info.set_AddSemiColonAfterDeclaration();
// output the declaration as a string
declarationString = globalUnparseToString(declaration,&info);
break;
// For functions just output the declaration and skip the definition
// (This also avoids the generation of redundent definitions since the
// function we are in when we generate all declarations would be included).
case V_SgMemberFunctionDeclaration:
case V_SgFunctionDeclaration:
{
// turn off the generation of the definition
info.set_SkipFunctionDefinition();
info.set_AddSemiColonAfterDeclaration();
// output the declaration as a string
declarationString = globalUnparseToString(declaration,&info);
break;
}
case V_SgFunctionParameterList:
{
// Handle generation of declaration strings this case differnetly from unparser
// since want to generate declaration strings and not function parameter lists
// (function parameter lists would be delimited by "," while declarations would
// be delimited by ";").
SgFunctionParameterList* parameterListDeclaration = dynamic_cast<SgFunctionParameterList*>(declaration);
ROSE_ASSERT (parameterListDeclaration != NULL);
SgInitializedNameList & argList = parameterListDeclaration->get_args();
SgInitializedNameList::iterator i;
for (i = argList.begin(); i != argList.end(); i++)
{
string typeNameString = (*i).get_type()->unparseToString();
// (9/8/2003) Bug Fix suggested by Nils
// string variableName = (*i).get_name().str();
string variableName;
SgName nodeName = (*i).get_name();
if(nodeName.str() != NULL)
variableName = nodeName.str();
else
variableName = "";
declarationString += typeNameString + " " + variableName + "; ";
}
break;
}
// ignore this case ... not really a declaration
case V_SgCtorInitializerList:
// printf ("Ignore the SgCtorInitializerList (constructor initializer list) \n");
break;
case V_SgVariableDefinition:
printf ("ERROR: SgVariableDefinition nodes not used in AST \n");
ROSE_ABORT();
break;
// default case should always be an error
default:
printf ("Default reached in AST_Rewrite::AccumulatedDeclarationsAttribute::generateDeclarationString() \n");
printf (" declaration->sage_class_name() = %s \n",declaration->sage_class_name());
ROSE_ABORT();
break;
}
// Add a space to make it easier to read (not required)
declarationString += " ";
// printf ("For this scope: declarationString = %s \n",declarationString.c_str());
return declarationString;
}
string
SIDL_TreeTraversal::generateSIDLFunctionDeclaration(SgFunctionDeclaration* functionDeclarationStatement )
{
ROSE_ASSERT (functionDeclarationStatement != NULL);
ROSE_ASSERT (functionDeclarationStatement->get_file_info() != NULL);
const SgSpecialFunctionModifier &functionModifier = functionDeclarationStatement->get_specialFunctionModifier();
string functionName = functionDeclarationStatement->get_name().str();
string sidlFunctionName ;
if (functionModifier.isConstructor()) {
if (functionDeclarationStatement->get_args().size() == 0) return ""; // skip empty constructor
sidlFunctionName = constructorName;
}
else {
sidlFunctionName = functionName;
}
// We have to force the mangled name to be generated before we access it (else we just get "defaultName")
string mangledFunctionName = functionDeclarationStatement->get_mangled_name().str();
sidlFunctionName = stringifyOperatorWithoutSymbols(sidlFunctionName);
// Get the class name
SgClassDefinition* classDefinition = isSgClassDefinition(functionDeclarationStatement->get_scope());
// DQ (1/7/2004): Modified for make EDG version 3.3 work (member function declarations's normalized by EDG)
if (classDefinition != NULL)
{
SgClassDeclaration* classDeclaration = classDefinition->get_declaration();
string className = classDeclaration->get_name().str();
overloadInformation info = isOverloaded(classDefinition,functionName,mangledFunctionName);
int orderofOverloadedFunction = info.get_order();
// If function is overloaded then append the number indicating the order of appearance in the
// class declaration
if (info.get_count() > 1)
{
vector<SgType*> types = info.get_types();
// SgInitializedNamePtrList &args = functionDeclarationStatement->get_args ();
int size = types.size();
if(size > 0)
{
if(size < 3)
{
sidlFunctionName += "[";
for(vector<SgType*>::iterator i = types.begin(); i!= types.end(); i++)
{
if(i != types.begin()) sidlFunctionName += "_";
if(isSgPointerType(*i) != NULL) sidlFunctionName += "P";
sidlFunctionName += sidlOverloadExtension(TransformationSupport::getTypeName(*i));
}
sidlFunctionName += "]";
}
else
sidlFunctionName += "["+numberToOverloadString(orderofOverloadedFunction)+"]";
}
}
}
else
{
printf ("EDG version 3.3 can return a null pointer to the member function definition \n");
}
SgFunctionType* functionType = functionDeclarationStatement->get_type();
ROSE_ASSERT(functionType != NULL);
// SgType* returnType = functionType->get_return_type();
// ROSE_ASSERT (returnType != NULL);
// string returnTypeName = TransformationSupport::getTypeName(returnType);
// printf ("function has_ellipses %s \n",(functionType->get_has_ellipses() != false) ? "true" : "false");
// showSgFunctionType(cout, functionType, "Called from generateSIDLFunctionDeclaration", 0 );
// printf ("Function return type = %s \n",returnTypeName.c_str());
#if 0
SgTypePtrList & argumentTypeList = functionType->get_arguments();
ROSE_ASSERT (argumentTypeList.size() >= 0);
SgTypePtrList::iterator argumentIterator = argumentTypeList.begin();
for (argumentIterator = argumentTypeList.begin(); argumentIterator != argumentTypeList.end(); argumentIterator++)
{
// showSgType(os,(*argumentIterator), label, depth+1);
string argumentTypeName = TransformationSupport::getTypeName(*argumentIterator);
printf ("-----> argument #%d argumentTypeName = %s \n",argumentCounter++,argumentTypeName.c_str());
}
#endif
//Determine the SIDL parameter passing mechanism (in,out,inout)
SgInitializedNamePtrList & argumentList = functionDeclarationStatement->get_args();
string parameterTypesAndNames;
SgInitializedNamePtrList::iterator i;
unsigned int argumentCounter = 0;
for (i = argumentList.begin(); i != argumentList.end(); i++)
{
SgType* type = (*i)->get_type();
ROSE_ASSERT (type != NULL);
string typeName = TransformationSupport::getTypeName(type);
ROSE_ASSERT (typeName.c_str() != NULL);
string sidlParameterPassingMechanim = "in";
//it seems like the has_ellipses value is wrong, so we'll set it
functionType->set_has_ellipses(false);
if(type->variantT() == V_SgTypeEllipse)
{
sidlParameterPassingMechanim = "inout";
functionType->set_has_ellipses(true);
}
//else if (type->variantT() == V_SgTypeVoid)
/*else if (rose::stringDuplicate(type->sage_class_name()) == "SgTypeVoid")
{
printf("found a void\n");
//void type is only viable for a pointer. foo(void) will just become foo()
if(isSgPointerType(type) != NULL)
{
printf("found a void pointer\n");
sidlParameterPassingMechanim ="inout opaque";
}
}*/
else if (isSgReferenceType(type) != NULL)
{
sidlParameterPassingMechanim = "inout";
}
else if (isSgPointerType(type) != NULL)
{
sidlParameterPassingMechanim = "inout";
}
else if (isSgArrayType(type) != NULL)
{
SgArrayType array = isSgArrayType(type);
sidlParameterPassingMechanim = "inout Array<";
SgType* baseType = array.get_base_type();
sidlParameterPassingMechanim += TransformationSupport::getTypeName(baseType);
sidlParameterPassingMechanim += ",1>";
//FIXME: I don't see a way to determine the dimention of the array
}
// Build the substring for each parameter
parameterTypesAndNames += sidlParameterPassingMechanim;
parameterTypesAndNames += " ";
//if(type->variantT() != V_SgTypeGlobalVoid)
//{
if(type->variantT() == V_SgTypeEllipse)
{
parameterTypesAndNames += "Array<BabelBaseType,1> "; //FIXME: need to include a declaration for BaseType
parameterTypesAndNames += "elips" + argumentCounter; //this fails to actually append the counter, but I don't think it will matter: kmk
}
else
{
SgName name = (*i)->get_name();
string nameString = name.str();
string typeName = TransformationSupport::getTypeName(type);
if(typeName == "void")
{
if(nameString!="")
{
parameterTypesAndNames += "opaque ";
parameterTypesAndNames += nameString;
}
}
else
{
parameterTypesAndNames += typeName;
parameterTypesAndNames += " ";
if(nameString != "") //will be empty if the function declaration doesn't provide a name
parameterTypesAndNames += nameString;
}
}
// Add a "," to the string if there are more parameters in the list
if ( argumentCounter < argumentList.size()-1 )
parameterTypesAndNames += ",";
//}else printf("avoiding the void\n");
argumentCounter++;
}
SgType* returnType = functionType->get_return_type();
ROSE_ASSERT (returnType != NULL);
string returnTypeName = "void";
if(returnType->variantT() != V_SgTypeVoid)
returnTypeName = TransformationSupport::getTypeName(returnType);
string sidlMemberFunctionDeclaration = " $RETURN_TYPE $FUNCTION_NAME($PARAMETERS);\n";
sidlMemberFunctionDeclaration = StringUtility::copyEdit ( sidlMemberFunctionDeclaration, "$RETURN_TYPE" , returnTypeName );
sidlMemberFunctionDeclaration = StringUtility::copyEdit ( sidlMemberFunctionDeclaration, "$FUNCTION_NAME" , sidlFunctionName );
sidlMemberFunctionDeclaration = StringUtility::copyEdit ( sidlMemberFunctionDeclaration, "$PARAMETERS" , parameterTypesAndNames );
return sidlMemberFunctionDeclaration;
}
//! search for all possible (virtual) function calls
vector<SgMemberFunctionDeclaration*>
Classhierarchy::searchMemberFunctionCalls(SgMemberFunctionDeclaration* mfCall)
{
vector<SgMemberFunctionDeclaration*> retvec;
property_map< dbgType, boost::vertex_classhierarchy_t>::type chMap = boost::get( boost::vertex_classhierarchy, *this );
SgClassDefinition *classDef = mfCall->get_scope();
SgName classname = classDef->get_qualified_name(); // MANGLE
string cnamestr = classname.str();
graph_traits< dbgType >::vertex_iterator vi,vend;
dbgVertex vdesc = *vi;
bool foundVertex = false;
tie(vi,vend) = vertices( *this );
for(; vi!=vend; vi++) {
//cerr << " BCH v i"<< get(vertex_index,*this,*vi)<< " i1" << get(vertex_index1, *this, *vi)<<","<< get(vertex_name, *this, *vi) << endl;
if( get(vertex_dbg_data, *this, *vi).get_typeName() == cnamestr ) {
//cerr << " SMF srch "<< cnamestr <<" vi "<< get(vertex_index,*this,*vi)<< " i1" << get(vertex_index1, *this, *vi)<<","<< get(vertex_name, *this, *vi) << endl;
vdesc = *vi;
foundVertex = true;
break;
}
}
if(!foundVertex) { cerr << " SMF srch "<< cnamestr <<" vi "<< get(vertex_index,*this,*vi)<< " i1" << get(vertex_index1, *this, *vi)<<","<< get(vertex_name, *this, *vi) << endl; }
assert( foundVertex );
set<dbgVertex> treeset;
treeset.insert( vdesc );
// first find "highest" class in CH that still provides this MF
dbgVertex vhighest = vdesc; // first assume its the current one
graph_traits<dbgType>::out_edge_iterator oi,oend;
tie(oi,oend) = out_edges( vdesc, *this);
for(; oi!=oend; oi++) {
//cerr << " SMF inherits from "<< get(vertex_index,*this,target(*oi,*this))<< " i1" << get(vertex_index1, *this, target(*oi,*this))<<","<< get(vertex_name, *this, target(*oi,*this)) << endl;
// does any of the base classes implement the member function?
bool noParentImpl = true;
// check if this base class also implements MF
for(set<SgNode*>::iterator chd= chMap[target(*oi,*this)].inherited.begin();
chd!= chMap[target(*oi,*this)].inherited.end(); chd++) {
SgFunctionDeclaration *inhFunc = isSgFunctionDeclaration( *chd );
bool virt = false;
//cerr << " TOPO v srch1" << endl;
if(inhFunc->isVirtual()) virt = true;
if( (virt) && (compareFunctionDeclarations(inhFunc,mfCall)) ) {
// remeber for traversal
treeset.insert( target(*oi, *this) );
noParentImpl = false;
}
}
if(noParentImpl) {
// we found it
vhighest = target(*oi, *this);
break;
}
}
//cerr << " SMF high "<< cnamestr <<" vi "<< get(vertex_index,*this,vhighest)<< " i1" << get(vertex_index1, *this, vhighest)<<","<< get(vertex_name, *this, vhighest) << endl;
// now traverse class hierachy downwards, for all children that implement this function, add to set
set<dbgVertex> tovisit;
set<dbgVertex> visited;
tovisit.insert( vhighest );
//hier weiter
while( tovisit.size() > 0 ) {
dbgVertex currVert = *(tovisit.begin());
tovisit.erase( currVert );
visited.insert( currVert );
//cerr << " SMF visi "<< get(vertex_index,*this,currVert)<< " i1" << get(vertex_index1, *this, currVert)<<","<< get(vertex_name, *this, currVert) << endl;
for(set<SgNode*>::iterator chd= chMap[currVert].defined.begin(); chd!= chMap[currVert].defined.end(); chd++) {
SgMemberFunctionDeclaration*inhFunc = isSgMemberFunctionDeclaration( *chd );
if(compareFunctionDeclarations(inhFunc,mfCall)) {
retvec.push_back( inhFunc );
}
}
graph_traits<dbgType>::in_edge_iterator ii,iend;
tie(ii,iend) = in_edges( currVert, *this);
for(; ii!=iend; ii++) {
dbgVertex child = source(*ii, *this);
// only insert of not already visited
set<dbgVertex>::iterator found = visited.find( child );
if(found == visited.end())
tovisit.insert( child );
}
}
//retvec.push_back( mfCall );
return retvec;
}
NodeQuerySynthesizedAttributeType NodeQuery::queryNodeClassDeclarationsFromTypeName(SgNode* node, SgNode* nameNode)
{
NodeQuerySynthesizedAttributeType returnList;
ROSE_ASSERT( nameNode != NULL );
ROSE_ASSERT( node != NULL );
// finds the name which should be matched to
SgName* sageName = isSgName(nameNode);
ROSE_ASSERT( sageName != NULL );
std::string nameToMatch = sageName->str();
ROSE_ASSERT( nameToMatch.length() > 0 );
SgClassDeclaration *sageClassDeclaration = isSgClassDeclaration (node);
if (sageClassDeclaration != NULL)
{
if(TransformationSupport::getTypeName(sageClassDeclaration->get_type()) == nameToMatch)
returnList.push_back(node);
else
{
SgClassDefinition* classDefinition = isSgClassDefinition(sageClassDeclaration->get_definition());
ROSE_ASSERT( classDefinition != NULL );
// SgBaseClassList baseClassList = classDefinition->get_inheritances();
SgBaseClassPtrList baseClassList = classDefinition->get_inheritances();
typedef SgBaseClassPtrList::iterator SgBaseClassPtrListIterator;
for( SgBaseClassPtrListIterator baseClassElm = baseClassList.begin();
baseClassElm != baseClassList.end(); ++baseClassElm)
{
// SgBaseClass baseClass = *baseClassElm;
SgBaseClass* baseClass = *baseClassElm;
// sageClassDeclaration = baseClass.get_base_class();
sageClassDeclaration = baseClass->get_base_class();
std::string typeName = TransformationSupport::getTypeName ( sageClassDeclaration->get_type() );
if( typeName == nameToMatch )
returnList.push_back(node);
}
}
/*
SgType* typeNode = sageClassDeclaration->get_type ();
ROSE_ASSERT (typeNode != NULL);
string currentTypeName = "";
string previousTypeName = "";
do{
previousTypeName = currentTypeName;
currentTypeName = TransformationSupport::getTypeName (typeNode);
typeNode = typeNode->findBaseType();
ROSE_ASSERT( typeNode != NULL );
if( currentTypeName == nameToMatch ){
returnList.push_back(node);
break;
}
cout<< "\n\n The typenames is : " << currentTypeName << "\n\n" << previousTypeName << "\n\n";
}while( previousTypeName != currentTypeName);
*/
}
return returnList;
} /* End function:queryNodeCLassDeclarationFromName() */
// Constructs _A_pointer[SC_A(_1,_2)]
SgPntrArrRefExp* buildAPPArrayRef(SgNode* astNode,
ArrayAssignmentStatementQueryInheritedAttributeType & arrayAssignmentStatementQueryInheritedData,
OperandDataBaseType & operandDataBase, SgScopeStatement* scope, SgExprListExp* parameterExpList) {
#if DEBUG
printf("Contructing A++ array reference object \n");
#endif
string returnString;
SgVarRefExp* varRefExp = isSgVarRefExp(astNode);
ROSE_ASSERT(varRefExp != NULL);
SgVariableSymbol* variableSymbol = varRefExp->get_symbol();
ROSE_ASSERT(variableSymbol != NULL);
SgInitializedName* initializedName = variableSymbol->get_declaration();
ROSE_ASSERT(initializedName != NULL);
SgName variableName = initializedName->get_name();
vector<SgExpression*> parameters;
// Figure out the dimensionality of the statement globally
int maxNumberOfIndexOffsets = 6; // default value for A++/P++ arrays
ROSE_ASSERT(arrayAssignmentStatementQueryInheritedData.arrayStatementDimensionDefined == TRUE);
if (arrayAssignmentStatementQueryInheritedData.arrayStatementDimensionDefined == TRUE) {
// The the globally computed array dimension from the arrayAssignmentStatementQueryInheritedData
maxNumberOfIndexOffsets = arrayAssignmentStatementQueryInheritedData.arrayStatementDimension;
}
// Then we want the minimum of all the dimensions accesses (or is it the maximum?)
for (int n = 0; n < maxNumberOfIndexOffsets; n++) {
parameters.push_back(buildVarRefExp("_" + StringUtility::numberToString(n + 1), scope));
}
// Make a reference to the global operand database
//OperandDataBaseType & operandDataBase = accumulatorValue.operandDataBase;
SgType* type = variableSymbol->get_type();
ROSE_ASSERT(type != NULL);
string typeName = TransformationSupport::getTypeName(type);
ROSE_ASSERT(typeName.c_str() != NULL);
// Copy the string from the SgName object to a string object
string variableNameString = variableName.str();
// Setup an intry in the synthesized attribute data base for this variable any
// future results from analysis could be place there at this point as well
// record the name in the synthesized attribute
ROSE_ASSERT(operandDataBase.transformationOption > ArrayTransformationSupport::UnknownIndexingAccess);
ArrayOperandDataBase arrayOperandDB = operandDataBase.setVariableName(variableNameString);
// We could have specified in the inherited attribute that this array variable was
// index and if so leave the value of $IDENTIFIER_STRING to be modified later in
// the assembly of the operator() and if not do the string replacement on
// $IDENTIFIER_STRING here (right now).
returnString = string("$IDENTIFIER_STRING") + string("_pointer[SC") + string("$MACRO_NAME_SUBSTRING") + string("(")
+ string("$OFFSET") + string(")]");
string functionSuffix = "";
SgPntrArrRefExp* pntrRefExp;
cout << " arrayAssignmentStatementQueryInheritedData.getIsIndexedArrayOperand() "
<< arrayAssignmentStatementQueryInheritedData.getIsIndexedArrayOperand() << endl;
// The inherited attribute mechanism is not yet implimented
if (arrayAssignmentStatementQueryInheritedData.getIsIndexedArrayOperand() == FALSE)
//if(true)
{
// do the substitution of $OFFSET here since it our last chance
// (offsetString is the list of index values "index1,index2,...,indexn")
//returnString = StringUtility::copyEdit(returnString,"$OFFSET",offsetString);
string operandIdentifier = arrayOperandDB.generateIdentifierString();
// do the substitution of $IDENTIFIER_STRING here since it our last chance
// if variable name is "A", generate: A_pointer[SC_A(index1,...)]
// returnString = StringUtility::copyEdit (returnString,"$IDENTIFIER_STRING",variableNameString);
ROSE_ASSERT(arrayOperandDB.indexingAccessCode > ArrayTransformationSupport::UnknownIndexingAccess);
// Edit into place the name of the data pointer
returnString = StringUtility::copyEdit(returnString, "$IDENTIFIER_STRING", operandIdentifier);
// Optimize the case of uniform or unit indexing to generate a single subscript macro definition
if ((arrayOperandDB.indexingAccessCode == ArrayTransformationSupport::UniformSizeUnitStride)
|| (arrayOperandDB.indexingAccessCode == ArrayTransformationSupport::UniformSizeUniformStride))
returnString = StringUtility::copyEdit(returnString, "$MACRO_NAME_SUBSTRING", "");
else {
returnString = StringUtility::copyEdit(returnString, "$MACRO_NAME_SUBSTRING", operandIdentifier);
functionSuffix = operandIdentifier;
}
/*
* Create SgPntrArrRefExp lhs is VarRefExp and rhs is SgFunctionCallExp
*/
SgVarRefExp* newVarRefExp = buildVarRefExp(operandIdentifier + "_pointer", scope);
string functionName = "SC" + functionSuffix;
SgFunctionCallExp* functionCallExp;
if (parameterExpList == NULL)
functionCallExp = buildFunctionCallExp(functionName, buildIntType(), buildExprListExp(parameters), scope);
else
functionCallExp = buildFunctionCallExp(functionName, buildIntType(), parameterExpList, scope);
pntrRefExp = buildPntrArrRefExp(newVarRefExp, functionCallExp);
#if DEBUG
cout << " pntrArrRefExp = " << pntrRefExp->unparseToString() << endl;
#endif
}
return pntrRefExp;
}
// Do finite differencing on one expression within one context. The expression
// must be defined and valid within the entire body of root. The rewrite rules
// are used to simplify expressions. When a variable var is updated from
// old_value to new_value, an expression of the form (var, (old_value,
// new_value)) is created and rewritten. The rewrite rules may either produce
// an arbitrary expression (which will be used as-is) or one of the form (var,
// (something, value)) (which will be changed to (var = value)).
void doFiniteDifferencingOne(SgExpression* e,
SgBasicBlock* root,
RewriteRule* rules)
{
SgStatementPtrList& root_stmts = root->get_statements();
SgStatementPtrList::iterator i;
for (i = root_stmts.begin(); i != root_stmts.end(); ++i)
{
if (expressionComputedIn(e, *i))
break;
}
if (i == root_stmts.end())
return; // Expression is not used within root, so quit
vector<SgVariableSymbol*> used_symbols = SageInterface::getSymbolsUsedInExpression(e);
SgName cachename = "cache_fd__"; cachename << ++SageInterface::gensym_counter;
SgVariableDeclaration* cachedecl = new SgVariableDeclaration(SgNULL_FILE, cachename, e->get_type(),0 /* new SgAssignInitializer(SgNULL_FILE, e) */);
SgInitializedName* cachevar = cachedecl->get_variables().back();
ROSE_ASSERT (cachevar);
root->get_statements().insert(i, cachedecl);
cachedecl->set_parent(root);
cachedecl->set_definingDeclaration(cachedecl);
cachevar->set_scope(root);
SgVariableSymbol* sym = new SgVariableSymbol(cachevar);
root->insert_symbol(cachename, sym);
SgVarRefExp* vr = new SgVarRefExp(SgNULL_FILE, sym);
vr->set_endOfConstruct(SgNULL_FILE);
replaceCopiesOfExpression(e, vr, root);
vector<SgExpression*> modifications_to_used_symbols;
FdFindModifyingStatementsVisitor(used_symbols, modifications_to_used_symbols).go(root);
cachedecl->addToAttachedPreprocessingInfo(
new PreprocessingInfo(PreprocessingInfo::CplusplusStyleComment,(string("// Finite differencing: ") +
cachename.str() + " is a cache of " +
e->unparseToString()).c_str(),"Compiler-Generated in Finite Differencing",0, 0, 0, PreprocessingInfo::before));
if (modifications_to_used_symbols.size() == 0)
{
SgInitializer* cacheinit = new SgAssignInitializer(SgNULL_FILE, e);
e->set_parent(cacheinit);
cachevar->set_initializer(cacheinit);
cacheinit->set_parent(cachevar);
}
else
{
for (unsigned int i = 0; i < modifications_to_used_symbols.size(); ++i)
{
SgExpression* modstmt = modifications_to_used_symbols[i];
#ifdef FD_DEBUG
cout << "Updating cache after " << modstmt->unparseToString() << endl;
#endif
SgExpression* updateCache = 0;
SgVarRefExp* varref = new SgVarRefExp(SgNULL_FILE, sym);
varref->set_endOfConstruct(SgNULL_FILE);
SgTreeCopy tc;
SgExpression* eCopy = isSgExpression(e->copy(tc));
switch (modstmt->variantT())
{
case V_SgAssignOp:
{
SgAssignOp* assignment = isSgAssignOp(modstmt);
assert (assignment);
SgExpression* lhs = assignment->get_lhs_operand();
SgExpression* rhs = assignment->get_rhs_operand();
replaceCopiesOfExpression(lhs, rhs, eCopy);
}
break;
case V_SgPlusAssignOp:
case V_SgMinusAssignOp:
case V_SgAndAssignOp:
case V_SgIorAssignOp:
case V_SgMultAssignOp:
case V_SgDivAssignOp:
case V_SgModAssignOp:
case V_SgXorAssignOp:
case V_SgLshiftAssignOp:
case V_SgRshiftAssignOp:
{
SgBinaryOp* assignment = isSgBinaryOp(modstmt);
assert (assignment);
SgExpression* lhs = assignment->get_lhs_operand();
SgExpression* rhs = assignment->get_rhs_operand();
SgTreeCopy tc;
SgExpression* rhsCopy = isSgExpression(rhs->copy(tc));
SgExpression* newval = 0;
switch (modstmt->variantT())
{
#define DO_OP(op, nonassignment) \
case V_##op: { \
newval = new nonassignment(SgNULL_FILE, lhs, rhsCopy); \
newval->set_endOfConstruct(SgNULL_FILE); \
} \
break
DO_OP(SgPlusAssignOp, SgAddOp);
DO_OP(SgMinusAssignOp, SgSubtractOp);
DO_OP(SgAndAssignOp, SgBitAndOp);
DO_OP(SgIorAssignOp, SgBitOrOp);
DO_OP(SgMultAssignOp, SgMultiplyOp);
DO_OP(SgDivAssignOp, SgDivideOp);
DO_OP(SgModAssignOp, SgModOp);
DO_OP(SgXorAssignOp, SgBitXorOp);
DO_OP(SgLshiftAssignOp, SgLshiftOp);
DO_OP(SgRshiftAssignOp, SgRshiftOp);
#undef DO_OP
default: break;
}
assert (newval);
replaceCopiesOfExpression(lhs, newval, eCopy);
}
break;
case V_SgPlusPlusOp:
{
SgExpression* lhs = isSgPlusPlusOp(modstmt)->get_operand();
SgIntVal* one = new SgIntVal(SgNULL_FILE, 1);
one->set_endOfConstruct(SgNULL_FILE);
SgAddOp* add = new SgAddOp(SgNULL_FILE, lhs, one);
add->set_endOfConstruct(SgNULL_FILE);
lhs->set_parent(add);
one->set_parent(add);
replaceCopiesOfExpression(lhs,add,eCopy);
}
break;
case V_SgMinusMinusOp:
{
SgExpression* lhs = isSgMinusMinusOp(modstmt)->get_operand();
SgIntVal* one = new SgIntVal(SgNULL_FILE, 1);
one->set_endOfConstruct(SgNULL_FILE);
SgSubtractOp* sub = new SgSubtractOp(SgNULL_FILE, lhs, one);
sub->set_endOfConstruct(SgNULL_FILE);
lhs->set_parent(sub);
one->set_parent(sub);
replaceCopiesOfExpression(lhs,sub,eCopy);
}
break;
default:
cerr << modstmt->sage_class_name() << endl;
assert (false);
break;
}
#ifdef FD_DEBUG
cout << "e is " << e->unparseToString() << endl;
cout << "eCopy is " << eCopy->unparseToString() << endl;
#endif
updateCache = doFdVariableUpdate(rules, varref, e, eCopy);
#ifdef FD_DEBUG
cout << "updateCache is " << updateCache->unparseToString() << endl;
#endif
if (updateCache)
{
ROSE_ASSERT(modstmt != NULL);
SgNode* ifp = modstmt->get_parent();
SgCommaOpExp* comma = new SgCommaOpExp(SgNULL_FILE, updateCache, modstmt);
modstmt->set_parent(comma);
updateCache->set_parent(comma);
if (ifp == NULL)
{
printf ("modstmt->get_parent() == NULL modstmt = %p = %s \n",modstmt,modstmt->class_name().c_str());
modstmt->get_startOfConstruct()->display("modstmt->get_parent() == NULL: debug");
}
ROSE_ASSERT(ifp != NULL);
#ifdef FD_DEBUG
cout << "New expression is " << comma->unparseToString() << endl;
cout << "IFP is " << ifp->sage_class_name() << ": " << ifp->unparseToString() << endl;
#endif
if (isSgExpression(ifp))
{
isSgExpression(ifp)->replace_expression(modstmt, comma);
comma->set_parent(ifp);
}
else
{
// DQ (12/16/2006): Need to handle cases that are not SgExpression (now that SgExpressionRoot is not used!)
// cerr << ifp->sage_class_name() << endl;
// assert (!"Bad parent type for inserting comma expression");
SgStatement* statement = isSgStatement(ifp);
if (statement != NULL)
{
#ifdef FD_DEBUG
printf ("Before statement->replace_expression(): statement = %p = %s modstmt = %p = %s \n",statement,statement->class_name().c_str(),modstmt,modstmt->class_name().c_str());
SgExprStatement* expresionStatement = isSgExprStatement(statement);
if (expresionStatement != NULL)
{
SgExpression* expression = expresionStatement->get_expression();
printf ("expressionStatement expression = %p = %s \n",expression,expression->class_name().c_str());
}
#endif
statement->replace_expression(modstmt, comma);
comma->set_parent(statement);
}
else
{
ROSE_ASSERT(ifp != NULL);
printf ("Error: parent is neither a SgExpression nor a SgStatement ifp = %p = %s \n",ifp,ifp->class_name().c_str());
ROSE_ASSERT(false);
}
}
#ifdef FD_DEBUG
cout << "IFP is now " << ifp->unparseToString() << endl;
#endif
}
}
}
}
//-----------------------------------------------------------------------------------
// int UnparseOrigFormat::special_cases
//
// Handles and calculates the length to subtract from the total number of spaces
// to indent. The column information returned from a declaration is designated
// at the name. Thus, the length of the type must be found to subtract from the
// column number of the name.
//-----------------------------------------------------------------------------------
int
UnparseOrigFormat::special_cases(SgLocatedNode* node)
{
// column length to subtract
int subcol = 0;
if (isSgVariableDeclaration(node))
{
SgVariableDeclaration* vardecl_stmt = isSgVariableDeclaration(node);
assert(vardecl_stmt != NULL);
SgInitializedNamePtrList initname_list = vardecl_stmt->get_variables();
// SgInitializedNamePtrList::const_iterator iter = initname_list.begin();
SgInitializedNamePtrList::iterator iter = initname_list.begin();
if (iter != initname_list.end())
{
ROSE_ASSERT ((*iter) != NULL);
SgType* tmp_type = (*iter)->get_type();
assert(tmp_type != NULL);
// adding one since there's a space in between the type and name
subcol += get_type_len(tmp_type) + 1;
}
}
else
{
if (isSgMemberFunctionDeclaration(node))
{
SgMemberFunctionDeclaration* mfuncdecl_stmt = isSgMemberFunctionDeclaration(node);
assert(mfuncdecl_stmt != NULL);
SgType* rtype = NULL;
if ( !( mfuncdecl_stmt->get_specialFunctionModifier().isConstructor() ||
mfuncdecl_stmt->get_specialFunctionModifier().isDestructor() ||
mfuncdecl_stmt->get_specialFunctionModifier().isConversion() ) )
{
// this means that the function has a return type, so calculate the length of this type
if (mfuncdecl_stmt->get_orig_return_type())
rtype = mfuncdecl_stmt->get_orig_return_type();
else
rtype = mfuncdecl_stmt->get_type()->get_return_type();
subcol += get_type_len(rtype) + 1;
}
if ( !isSgClassDefinition(mfuncdecl_stmt->get_parent()) )
{
// this means that the function is not in a class structure, so we must get
// the length of the class name <class>::<function name>
SgName scopename;
// DQ (11/17/2004): Interface modified, use get_class_scope() if we want a
// SgClassDefinition, else use get_scope() if we want a SgScopeStatement.
// scopename = mfuncdecl_stmt->get_scope()->get_declaration()->get_qualified_name();
scopename = mfuncdecl_stmt->get_class_scope()->get_declaration()->get_qualified_name();
subcol += strlen(scopename.str()) + 2; // 2 extra spaces from the "::"
}
}
else
{
if (isSgFunctionDeclaration(node))
{
SgFunctionDeclaration* funcdecl_stmt = isSgFunctionDeclaration(node);
assert(funcdecl_stmt != NULL);
SgType* tmp_type = funcdecl_stmt->get_type()->get_return_type();
assert(tmp_type != NULL);
subcol += get_type_len(tmp_type) + 1;
}
else
{
if (isSgClassDeclaration(node))
{
SgClassDeclaration* classdecl_stmt = isSgClassDeclaration(node);
assert(classdecl_stmt != NULL);
subcol += 6; //for "class "
}
else
{
if (isSgCaseOptionStmt(node))
{
SgCaseOptionStmt* case_stmt = isSgCaseOptionStmt(node);
assert(case_stmt != NULL);
subcol += 5; //for "case "
}
else
{
if (isSgLabelStatement(node))
{
SgLabelStatement* label_stmt = isSgLabelStatement(node);
assert(label_stmt != NULL);
// assert(label_stmt->get_label().str() != NULL);
subcol += strlen(label_stmt->get_label().str());
}
else
{
if (isSgTypedefDeclaration(node))
{
SgTypedefDeclaration* typedef_stmt = isSgTypedefDeclaration(node);
assert(typedef_stmt != NULL);
subcol += 8; //for "typedef "
SgType* tmp_type = typedef_stmt->get_base_type();
subcol += get_type_len(tmp_type) + 1;
}
}
}
}
}
}
}
// may need to take care of more special cases here
return subcol;
}
//-----------------------------------------------------------------------------------
// int UnparseOrigFormat::get_type_len
//
// Auxiliary function used by special_cases to determine the length of
// the given type. This length is then subtracted from the amount to indent.
//-----------------------------------------------------------------------------------
int
UnparseOrigFormat::get_type_len(SgType* type)
{
assert(type != NULL);
switch(type->variant())
{
case T_UNKNOWN: return 0;
case T_CHAR: return 4;
case T_SIGNED_CHAR: return 11;
case T_UNSIGNED_CHAR: return 13;
case T_SHORT: return 5;
case T_SIGNED_SHORT: return 12;
case T_UNSIGNED_SHORT: return 14;
case T_INT: return 3;
case T_SIGNED_INT: return 10;
case T_UNSIGNED_INT: return 12;
case T_LONG: return 4;
case T_SIGNED_LONG: return 11;
case T_UNSIGNED_LONG: return 13;
case T_VOID: return 4;
case T_GLOBAL_VOID: return 11;
case T_WCHAR: return 5;
case T_FLOAT: return 5;
case T_DOUBLE: return 6;
case T_LONG_LONG: return 9;
case T_UNSIGNED_LONG_LONG: return 18;
case T_LONG_DOUBLE: return 11;
case T_STRING: return 6;
case T_BOOL: return 4;
case T_COMPLEX: return 7;
case T_DEFAULT:
{
// (*os) << "T_DEFAULT not implemented" << endl;
// printf ("In Unparser::get_type_len(): T_DEFAULT not implemented (returning 0) \n");
// ROSE_ABORT();
return 0;
break;
}
case T_POINTER:
{
SgPointerType* ptr_type = isSgPointerType(type);
assert(ptr_type != NULL);
return 1 + get_type_len(ptr_type->get_base_type());
}
case T_MEMBER_POINTER:
{
// (*os) << "T_MEMBER_POINTER not implemented" << endl;
cerr << "In Unparser::get_type_len(): T_MEMBER_POINTER not implemented (returning 0)" << endl;
// ROSE_ABORT();
return 0;
break;
}
case T_REFERENCE: { // not sure
SgReferenceType* ref_type = isSgReferenceType(type);
assert(ref_type != NULL);
return 1 + get_type_len(ref_type->get_base_type());
}
case T_NAME: {
cerr << "T_NAME not implemented" << endl;
break;
}
case T_CLASS: {
int length = 0;
SgClassType* class_type = isSgClassType(type);
assert (class_type != NULL);
SgName qn = class_type->get_name();
// We can't force all SgName objects to have a valid string!
// assert (qn.str() != NULL);
if (qn.str() != NULL)
length += strlen(qn.str());
return length;
}
case T_ENUM: {
SgEnumType* enum_type = isSgEnumType(type);
assert (enum_type != NULL);
SgName qn = enum_type->get_name();
return strlen(qn.str());
}
case T_TYPEDEF: {
SgTypedefType* typedef_type = isSgTypedefType(type);
SgName nm = typedef_type->get_name();
return strlen(nm.str());
}
case T_MODIFIER: {
SgModifierType* mod_type = isSgModifierType(type);
assert(mod_type != NULL);
int length = 0;
if (mod_type->get_typeModifier().get_constVolatileModifier().isConst()) length += 5;
if (mod_type->get_typeModifier().get_constVolatileModifier().isVolatile()) length += 8;
// DQ (4/22/2004): Removed CC++ support
// if (mod_type->isSync()) length += 0;
// if (mod_type->isGlobal()) length += 0;
if (mod_type->get_typeModifier().isRestrict()) length += 8;
if (mod_type->get_typeModifier().get_constVolatileModifier().isConst() &&
mod_type->get_typeModifier().get_constVolatileModifier().isVolatile())
length += 1;
return length + get_type_len(mod_type->get_base_type()) + 1;
}
case T_FUNCTION: {
SgFunctionType* func_type = isSgFunctionType(type);
assert(func_type != NULL);
SgType* ret_type = func_type->get_return_type();
assert(ret_type != NULL);
return get_type_len(ret_type);
}
case T_MEMBERFUNCTION: {
SgMemberFunctionType* mfunc_type = isSgMemberFunctionType(type);
assert(mfunc_type != NULL);
int length = 0;
SgClassDefinition* class_stmt = mfunc_type->get_struct_name();
assert(class_stmt != NULL);
length += get_type_len(class_stmt->get_declaration()->get_type());
SgType* ret_type = mfunc_type->get_return_type();
assert(ret_type != NULL);
length += 2; //space for "::"
return length + get_type_len(ret_type);
}
case T_PARTIAL_FUNCTION: {
cerr << "T_PARTIAL_FUNCTION not implemented" << endl;
break;
}
case T_ARRAY: {
SgArrayType* array_type = isSgArrayType(type);
assert(array_type != NULL);
SgType* base_type = array_type->get_base_type();
return get_type_len(base_type);
}
case T_ELLIPSE:{
cerr << "T_ELLIPSE not implemented" << endl;
break;
}
default: return 0;
}
return 0;
}
ATerm convertNodeToAterm(SgNode* n)
{
if (n == NULL)
{
#if 0
printf ("convertNodeToAterm(): n = %p = %s \n",n,"NULL");
#endif
return ATmake("NULL");
}
ROSE_ASSERT(n != NULL);
#if 0
printf ("convertNodeToAterm(): n = %p = %s \n",n,n->class_name().c_str());
#endif
ATerm term;
switch (n->variantT())
{
// case V_SgFile:
case V_SgSourceFile:
// Special case needed to include file name
// term = ATmake("File(<str>, <term>)", isSgFile(n)->getFileName(), convertNodeToAterm(isSgFile(n)->get_root()));
term = ATmake("File(<str>, <term>)", isSgSourceFile(n)->getFileName().c_str(), convertNodeToAterm(isSgSourceFile(n)->get_globalScope()));
break;
case V_SgPlusPlusOp:
case V_SgMinusMinusOp:
// Special cases needed to include prefix/postfix status
term = ATmake("<appl(<appl>, <term>)>",
getShortVariantName((VariantT)(n->variantT())).c_str(),
(isSgUnaryOp(n)->get_mode() == SgUnaryOp::prefix ? "Prefix" :
isSgUnaryOp(n)->get_mode() == SgUnaryOp::postfix ? "Postfix" :
"Unknown"),
convertNodeToAterm(isSgUnaryOp(n)->get_operand()));
break;
case V_SgExpressionRoot:
// Special case to remove this node
term = convertNodeToAterm(isSgExpressionRoot(n)->get_operand());
break;
case V_SgCastExp:
// Special case needed to include type
term = ATmake("Cast(<term>, <term>)>",
convertNodeToAterm(isSgUnaryOp(n)->get_operand()),
convertNodeToAterm(isSgCastExp(n)->get_type()));
break;
case V_SgVarRefExp:
// Special case needed to include id
term = ATmake("Var(<str>)",
uniqueId(isSgVarRefExp(n)->get_symbol()->get_declaration()).c_str());
break;
case V_SgFunctionRefExp:
// Special case needed to include id
term = ATmake(
"Func(<str>)",
uniqueId(isSgFunctionRefExp(n)->get_symbol()->get_declaration()).c_str());
break;
case V_SgIntVal:
// Special case needed to include value
term = ATmake("IntC(<int>)", isSgIntVal(n)->get_value());
break;
case V_SgUnsignedIntVal:
term = ATmake("UnsignedIntC(<int>)", isSgUnsignedIntVal(n)->get_value());
break;
case V_SgUnsignedLongVal: {
ostringstream s;
s << isSgUnsignedLongVal(n)->get_value();
term = ATmake("UnsignedLongC(<str>)", s.str().c_str());
}
break;
case V_SgUnsignedLongLongIntVal: {
ostringstream s;
s << isSgUnsignedLongLongIntVal(n)->get_value();
term = ATmake("UnsignedLongLongC(<str>)", s.str().c_str());
}
break;
case V_SgDoubleVal:
term = ATmake("DoubleC(<real>)", isSgDoubleVal(n)->get_value());
break;
case V_SgInitializedName:
{
// Works around double initname problem
SgInitializer* initializer = isSgInitializedName(n)->get_initializer();
const SgName& name = isSgInitializedName(n)->get_name();
SgType* type = isSgInitializedName(n)->get_type();
ROSE_ASSERT(type != NULL);
#if 0
printf ("convertNodeToAterm(): case V_SgInitializedName: name = %s initializer = %p type = %p = %s \n",name.str(),initializer,type,type->class_name().c_str());
#endif
// Works around fact that ... is not really an initname and shouldn't be a type either
if (isSgTypeEllipse(type))
{
term = ATmake("Ellipses");
}
else
{
std::string uniqueIdString = uniqueId(n);
#if 0
printf ("uniqueIdString = %s \n",uniqueIdString.c_str());
printf ("Calling generate ATerm for SgInitializedName->get_name() name = %s \n",name.str());
ATerm name_aterm = ATmake("Name(<str>)",name.str());
// ATerm name_aterm = ATmake(name.str());
printf ("Calling convertNodeToAterm(type) \n");
ATerm type_aterm = convertNodeToAterm(type);
printf ("Calling convertNodeToAterm(initializer) \n");
#endif
ATerm initializer_aterm = convertNodeToAterm(initializer);
#if 0
printf ("Calling ATmake() \n");
#endif
#if 1
term = ATmake("InitName(<str>, <term>, <term>) {[id, <str>]}",
(name.str() ? name.str() : ""),
convertNodeToAterm(type),
convertNodeToAterm(initializer),
uniqueId(n).c_str());
// uniqueIdString.c_str());
#else
term = ATmake("InitName(<term>,<term>)",
//(name.str() ? name.str() : ""),
// name_aterm,
type_aterm,
initializer_aterm
// uniqueId(n).c_str());
// uniqueIdString.c_str());
);
#endif
#if 0
printf ("Calling ATsetAnnotation() \n");
#endif
term = ATsetAnnotation(term, ATmake("id"), ATmake("<str>", uniqueId(n).c_str()));
#if 0
printf ("DONE: Calling ATsetAnnotation() \n");
#endif
}
break;
}
case V_SgFunctionDeclaration: {
// Special case needed to include name
SgFunctionDeclaration* fd = isSgFunctionDeclaration(n);
term = ATmake("Function(<str>, <term>, <term>, <term>)",
fd->get_name().str(),
convertNodeToAterm(fd->get_orig_return_type()),
convertSgNodeRangeToAterm(fd->get_args().begin(),
fd->get_args().end()),
convertNodeToAterm(fd->get_definition()));
term = ATsetAnnotation(term, ATmake("id"),
ATmake("<str>", uniqueId(n).c_str()));
}
break;
case V_SgClassDeclaration: {
// Special case needed to distinguish forward/full definitions and to
// include class name
SgClassDeclaration* decl = isSgClassDeclaration(n);
assert (decl);
SgName sname = decl->get_name();
const char* name = sname.str();
// Suggestion: have a field named local_definition in each class
// declaration that is 0 whenever the current declaration doesn't
// have a definition attached, even if there is another declaration
// which does have a definition attached.
SgClassDefinition* defn = decl->get_definition();
// cout << "defn = 0x" << hex << defn << endl << dec;
if (decl->isForward())
defn = 0;
if (defn)
term = ATmake("Class(<str>, <term>)",
(name ? name : ""), // Will be simpler when SgName
// becomes string
convertNodeToAterm(defn));
else
term = ATmake("ClassFwd(<str>)", (name ? name : ""));
term = ATsetAnnotation(term, ATmake("id"),
ATmake("<str>", uniqueId(n).c_str()));
}
break;
case V_SgEnumDeclaration: {
// Special case to include enum name and enumerator names which are not
// traversal children
SgName sname = isSgEnumDeclaration(n)->get_name();
const char* name = sname.str();
const SgInitializedNamePtrList& enumerators =
isSgEnumDeclaration(n)->get_enumerators();
term = ATmake("Enum(<str>, <term>)",
(name ? name : "{anonymous}"),
convertSgNodeRangeToAterm(enumerators.begin(),
enumerators.end()));
term = ATsetAnnotation(term, ATmake("id"),
ATmake("<str>", uniqueId(n).c_str()));
}
break;
case V_SgPointerType: {
// Special case because types can't be traversed yet
SgType* type = isSgPointerType(n)->get_base_type();
ATerm t = convertNodeToAterm(type);
term = ATmake("Pointer(<term>)", t);
}
break;
case V_SgReferenceType: {
// Special case because types can't be traversed yet
SgType* type = isSgReferenceType(n)->get_base_type();
ATerm t = convertNodeToAterm(type);
term = ATmake("Reference(<term>)", t);
}
break;
case V_SgModifierType: {
// Special case for type traversal and to prettify modifier names
SgType* type = isSgModifierType(n)->get_base_type();
SgTypeModifier& modifier = isSgModifierType(n)->get_typeModifier();
SgConstVolatileModifier& cvmod = modifier.get_constVolatileModifier();
term = convertNodeToAterm(type);
if (cvmod.isConst())
term = ATmake("Const(<term>)", term);
if (cvmod.isVolatile())
term = ATmake("Volatile(<term>)", term);
}
break;
case V_SgArrayType: {
// Special case because types can't be traversed yet, and to get length
SgType* type = isSgArrayType(n)->get_base_type();
ATerm t = convertNodeToAterm(type);
term = ATmake("Array(<term>, <term>)", t, (isSgArrayType(n)->get_index() ? convertNodeToAterm((n->get_traversalSuccessorContainer())[4]) : ATmake("<str>", "NULL")));
assert (term);
}
break;
case V_SgFunctionType: {
// Special case to allow argument list to be traversed
SgFunctionType* ft = isSgFunctionType(n);
ATerm ret = convertNodeToAterm(ft->get_return_type());
ATerm args_list = convertSgNodeRangeToAterm(ft->get_arguments().begin(),
ft->get_arguments().end());
term = ATmake("FunctionType(<term>, <term>)", ret, args_list);
}
break;
case V_SgEnumType:
case V_SgClassType:
case V_SgTypedefType: {
// Special cases to optionally put in type definition instead of
// reference
SgNamedType* nt = isSgNamedType(n);
assert (nt);
SgName sname = nt->get_name();
// char* name = sname.str();
SgDeclarationStatement* decl = nt->get_declaration();
assert (decl);
SgClassDefinition* defn = isSgClassDeclaration(decl) ?
isSgClassDeclaration(decl)->get_definition() :
0;
term = ATmake("Type(<term>)",
(nt->get_autonomous_declaration() || !defn ?
ATmake("id(<str>)", uniqueId(decl).c_str()) :
convertNodeToAterm(nt->get_declaration())));
}
break;
case V_SgLabelStatement: {
// Special case to put in label id
const char* name = isSgLabelStatement(n)->get_name().str();
term = ATmake("Label(<str>)", (name ? name : ""));
term = ATsetAnnotation(term, ATmake("id"),
ATmake("<str>", uniqueId(n).c_str()));
}
break;
case V_SgGotoStatement: {
// Special case to put in label id
term = ATmake("Goto(<str>)",
uniqueId(isSgGotoStatement(n)->get_label()).c_str());
}
break;
case V_SgTypedefDeclaration: {
// Special case to put in typedef name
const SgName& name = isSgTypedefDeclaration(n)->get_name();
SgType* type = isSgTypedefDeclaration(n)->get_base_type();
term = ATmake("Typedef(<str>, <term>)", (name.str() ? name.str() : ""),
convertNodeToAterm(type));
term = ATsetAnnotation(term, ATmake("id"),
ATmake("<str>", uniqueId(n).c_str()));
}
break;
case V_SgTemplateDeclaration: {
// Traversal doesn't work for these
SgTemplateDeclaration* td = isSgTemplateDeclaration(n);
ROSE_ASSERT (td);
// SgTemplateParameterPtrListPtr paramsPtr = td->get_templateParameters();
// SgTemplateParameterPtrList & paramsPtr = td->get_templateParameters();
// SgTemplateParameterPtrList params = paramsPtr ? *paramsPtr : SgTemplateParameterPtrList();
SgTemplateParameterPtrList & params = td->get_templateParameters();
string templateKindString;
switch (td->get_template_kind()) {
case SgTemplateDeclaration::e_template_none:
templateKindString = "None"; break;
case SgTemplateDeclaration::e_template_class:
templateKindString = "Class"; break;
case SgTemplateDeclaration::e_template_m_class:
templateKindString = "MemberClass"; break;
case SgTemplateDeclaration::e_template_function:
templateKindString = "Function"; break;
case SgTemplateDeclaration::e_template_m_function:
templateKindString = "MemberFunction"; break;
case SgTemplateDeclaration::e_template_m_data:
templateKindString = "MemberData"; break;
default: templateKindString = "Unknown"; break;
}
term = ATmake("TemplateDeclaration(<appl>, <str>, <term>, <str>)",
templateKindString.c_str(),
td->get_name().str(),
convertSgNodeRangeToAterm(params.begin(), params.end()),
td->get_string().str());
}
break;
case V_SgTemplateInstantiationDecl: {
// Traversal doesn't work for these
SgTemplateInstantiationDecl* td = isSgTemplateInstantiationDecl(n);
ROSE_ASSERT (td);
// SgTemplateArgumentPtrListPtr argsPtr = td->get_templateArguments();
// SgTemplateArgumentPtrList args = argsPtr ? *argsPtr : SgTemplateArgumentPtrList();
SgTemplateArgumentPtrList & args = td->get_templateArguments();
term = ATmake("TemplateInstantiationDecl(<str>, <term>)", td->get_templateDeclaration()->get_name().str(), convertSgNodeRangeToAterm(args.begin(), args.end()));
}
break;
case V_SgTemplateParameter: {
// Traversal doesn't work for these
SgTemplateParameter* tp = isSgTemplateParameter(n);
ROSE_ASSERT (tp);
switch (tp->get_parameterType()) {
case SgTemplateParameter::parameter_undefined: {
term = ATmake("Undefined");
}
break;
case SgTemplateParameter::type_parameter: {
term = ATmake("Type(<term>)",
convertNodeToAterm(tp->get_defaultTypeParameter()));
}
break;
case SgTemplateParameter::nontype_parameter: {
term = ATmake("Nontype(<term>, <term>)",
convertNodeToAterm(tp->get_type()),
convertNodeToAterm(tp->get_defaultExpressionParameter()));
}
break;
case SgTemplateParameter::template_parameter: {
term = ATmake("Template");
}
break;
default: term = ATmake("Unknown"); break;
}
}
break;
case V_SgTemplateArgument: {
// Traversal doesn't work for these
SgTemplateArgument* ta = isSgTemplateArgument(n);
ROSE_ASSERT (ta);
switch (ta->get_argumentType()) {
case SgTemplateArgument::argument_undefined:
term = ATmake("Undefined");
break;
case SgTemplateArgument::type_argument:
term = ATmake("Type(<term>)",
convertNodeToAterm(ta->get_type()));
break;
case SgTemplateArgument::nontype_argument:
term = ATmake("Nontype(<term>)",
convertNodeToAterm(ta->get_expression()));
break;
// case SgTemplateArgument::template_argument:
// term = ATmake("Template");
// break;
default: term = ATmake("Unknown"); break;
}
}
break;
default: {
bool isContainer =
(AstTests::numSuccContainers(n) == 1) ||
(!isSgType(n) && (n->get_traversalSuccessorContainer().size() == 0));
term = ATmake((isContainer ? "<appl(<term>)>" : "<appl(<list>)>"),
getShortVariantName((VariantT)(n->variantT())).c_str(),
(isSgType(n) ? ATmake("[]") : getTraversalChildrenAsAterm(n)));
// Special case for types is because of traversal problems
}
break;
}
#if 0
printf ("Base of switch statement in convertNodeToAterm(): n = %p = %s \n",n,n->class_name().c_str());
#endif
assert (term);
term = ATsetAnnotation(term, ATmake("ptr"), pointerAsAterm(n));
#if 1
if (n->get_file_info() != NULL)
{
term = ATsetAnnotation(term, ATmake("location"),convertFileInfoToAterm(n->get_file_info()));
}
if (isSgExpression(n))
term = ATsetAnnotation(term, ATmake("type"), convertNodeToAterm(isSgExpression(n)->get_type()));
#endif
#if 0
printf ("Leaving convertNodeToAterm(): n = %p = %s \n",n,n->class_name().c_str());
#endif
#if 0
printf ("--- n->class_name() = %s ATwriteToString(term) = %s \n",n->class_name().c_str(),ATwriteToString(term));
#endif
// cout << n->sage_class_name() << " -> " << ATwriteToString(term) << endl;
return term;
}
void
Unparse_Java::unparseEnumType(SgEnumType* type, SgUnparse_Info& info)
{
SgEnumType* enum_type = isSgEnumType(type);
ROSE_ASSERT(enum_type);
if (info.isTypeSecondPart() == false)
{
SgEnumDeclaration *edecl = isSgEnumDeclaration(enum_type->get_declaration());
SgClassDefinition *cdefn = NULL;
SgNamespaceDefinitionStatement* namespaceDefn = NULL;
ROSE_ASSERT(edecl != NULL);
// Build reference to any possible enclosing scope represented by a SgClassDefinition or SgNamespaceDefinition
// to be used check if name qualification is required.
unp->u_exprStmt->initializeDeclarationsFromParent ( edecl, cdefn, namespaceDefn );
if (info.isTypeFirstPart() == true && info.SkipEnumDefinition() == false)
{
unp->u_exprStmt->unparseAttachedPreprocessingInfo(edecl, info, PreprocessingInfo::before);
}
curprint ( "enum ");
SgNamedType *ptype = NULL;
if (cdefn != NULL)
{
ptype = isSgNamedType(cdefn->get_declaration()->get_type());
}
if (SageInterface::is_C_language() == true || SageInterface::is_C99_language() == true)
{
curprint ( enum_type->get_name().getString() + " ");
}
else
{
// DQ (7/20/2011): Test compilation without the generateNameQualifier() functions.
// The C++ support is more complex and can require qualified names!
// SgName nameQualifier = unp->u_name->generateNameQualifier( edecl , info );
SgName nameQualifier;
// printf ("nameQualifier (from unp->u_name->generateNameQualifier function) = %s \n",nameQualifier.str());
// curprint ( "\n/* nameQualifier (from unp->u_name->generateNameQualifier function) = " + nameQualifier + " */ \n ";
curprint ( nameQualifier.str());
SgName nm = enum_type->get_name();
if (nm.getString() != "")
{
// printf ("Output qualifier of current types to the name = %s \n",nm.str());
curprint ( nm.getString() + " ");
}
}
}
if (info.isTypeFirstPart() == true)
{
// info.display("info before constructing ninfo");
SgUnparse_Info ninfo(info);
// don't skip the semicolon in the output of the statement in the class definition
ninfo.unset_SkipSemiColon();
ninfo.set_isUnsetAccess();
// printf ("info.SkipEnumDefinition() = %s \n",(info.SkipEnumDefinition() == true) ? "true" : "false");
if ( info.SkipEnumDefinition() == false)
{
SgUnparse_Info ninfo(info);
ninfo.set_inEnumDecl();
SgInitializer *tmp_init = NULL;
SgName tmp_name;
SgEnumDeclaration *enum_stmt = isSgEnumDeclaration(enum_type->get_declaration());
ROSE_ASSERT(enum_stmt != NULL);
// This permits support of the empty enum case! "enum x{};"
curprint ( "{");
SgInitializedNamePtrList::iterator p = enum_stmt->get_enumerators().begin();
if (p != enum_stmt->get_enumerators().end())
{
// curprint ( "{";
while (1)
{
unp->u_exprStmt->unparseAttachedPreprocessingInfo(*p, info, PreprocessingInfo::before);
tmp_name=(*p)->get_name();
tmp_init=(*p)->get_initializer();
curprint ( tmp_name.str());
if(tmp_init)
{
curprint ( "=");
unp->u_exprStmt->unparseExpression(tmp_init, ninfo);
}
p++;
if (p != enum_stmt->get_enumerators().end())
{
curprint ( ",");
}
else
break;
}
// curprint ( "}";
}
// Putting the "inside" info right here is just a wild guess as to where it might really belong.
unp->u_exprStmt->unparseAttachedPreprocessingInfo(enum_stmt, info, PreprocessingInfo::inside);
curprint ( "}");
unp->u_exprStmt->unparseAttachedPreprocessingInfo(enum_stmt, info, PreprocessingInfo::after);
}
}
}
void
TransformationSupport::getTransformationOptionsFromVariableDeclarationConstructorArguments (
SgVariableDeclaration* variableDeclaration,
list<OptionDeclaration> & returnEnumValueList )
{
ROSE_ASSERT (variableDeclaration != NULL);
SgInitializedNamePtrList & variableList = variableDeclaration->get_variables();
printf ("Inside of getTransformationOptionsFromVariableDeclarationConstructorArguments() \n");
for (SgInitializedNamePtrList::iterator i = variableList.begin(); i != variableList.end(); i++)
{
// We don't care about the name
// SgName & name = (*i).get_name();
ROSE_ASSERT ((*i) != NULL);
// QY 11/10/04 removed named_item in SgInitializedName
// printf ("Processing a variable in the list \n");
// if ((*i)->get_named_item() != NULL)
// {
// ROSE_ASSERT ((*i)->get_named_item() != NULL);
// SgInitializer *initializerOther = (*i)->get_named_item()->get_initializer();
SgInitializer *initializerOther = (*i)->get_initializer();
// This is not always a valid pointer
// ROSE_ASSERT (initializerOther != NULL);
// printf ("Test for initialized in variable \n");
if (initializerOther != NULL)
{
// There are other things we could ask of the initializer
ROSE_ASSERT (initializerOther != NULL);
// printf ("Found a valid initialized in variable \n");
SgConstructorInitializer* constructorInitializer = isSgConstructorInitializer(initializerOther);
ROSE_ASSERT (constructorInitializer != NULL);
SgExprListExp* argumentList = constructorInitializer->get_args();
ROSE_ASSERT (argumentList != NULL);
SgExpressionPtrList & expressionPtrList = argumentList->get_expressions();
ROSE_ASSERT(expressionPtrList.empty() == false);
SgExpressionPtrList::iterator i = expressionPtrList.begin();
ROSE_ASSERT (*i != NULL);
// First value is a char* identifying the option
SgStringVal* charString = isSgStringVal(*i);
ROSE_ASSERT (charString != NULL);
#if 1
string optionString;
string valueString;
int counter = 0;
while (i != expressionPtrList.end())
{
// printf ("Expression List Element #%d of %d (total) (*i)->sage_class_name() = %s \n",
// counter,expressionPtrList.size(),(*i)->sage_class_name());
switch ( (*i)->variant() )
{
case ENUM_VAL:
{
SgEnumVal* enumVal = isSgEnumVal(*i);
ROSE_ASSERT (enumVal != NULL);
// int enumValue = enumVal->get_value();
SgName enumName = enumVal->get_name();
// printf ("Name = %s value = %d \n",enumName.str(),enumValue);
// printf ("Name = %s \n",enumName.str());
string name = enumName.str();
// char* name = rose::stringDuplicate( enumName.str() );
// Put the value at the start of the list so that the list can be processed in
// consecutive order to establish options for consecutive scopes (root to
// child scope). Order is not important if we are only ORing the operands!
// returnEnumValueList.push_front (name);
// returnEnumValueList.push_front (enumValue);
ROSE_ASSERT (counter == 0);
break;
}
case STRING_VAL:
{
// ROSE_ASSERT (counter == 1);
// printf ("Found a SgStringVal expression! \n");
SgStringVal* stringVal = isSgStringVal(*i);
ROSE_ASSERT (stringVal != NULL);
if (counter == 0)
{
optionString = stringVal->get_value();
valueString = "";
// printf ("optionString = %s \n",optionString);
}
if (counter == 1)
{
valueString = stringVal->get_value();
// printf ("valueString = %s \n",valueString);
}
break;
}
case DOUBLE_VAL:
{
ROSE_ASSERT (counter == 1);
// printf ("Found a SgStringVal expression! \n");
SgDoubleVal* doubleVal = isSgDoubleVal(*i);
ROSE_ASSERT (doubleVal != NULL);
valueString = StringUtility::numberToString(doubleVal->get_value()).c_str();
// printf ("valueString = %s \n",valueString);
break;
}
default:
{
printf ("Default reached in switch in getTransformationOptionsFromVariableDeclarationConstructorArguments() (*i)->sage_class_name() = %s \n",(*i)->sage_class_name());
ROSE_ABORT();
break;
}
}
i++;
counter++;
}
// printf ("optionString = %s valueString = %s \n",optionString,valueString);
OptionDeclaration optionSpecification(optionString.c_str(),valueString.c_str());
returnEnumValueList.push_front (optionSpecification);
#endif
}
else
{
// printf ("Valid initializer not found in variable \n");
}
/*
}
else
{
// printf ("Warning: In getTransformationOptionsFromVariableDeclarationConstructorArguments(): (*i).get_named_item() = NULL \n");
}
*/
}
}
// first visits the VarRef and then creates entry in operandDatabase which is
// useful in expressionStatement transformation. Thus, we replace the VarRef
// at the end of the traversal and insert loops during traversal
ArrayAssignmentStatementQuerySynthesizedAttributeType ArrayAssignmentStatementTransformation::evaluateSynthesizedAttribute(
SgNode* astNode,
ArrayAssignmentStatementQueryInheritedAttributeType arrayAssignmentStatementQueryInheritedData,
SubTreeSynthesizedAttributes synthesizedAttributeList) {
// This function assembles the elements of the input list (a list of char*) to form the output (a single char*)
#if DEBUG
printf ("\n$$$$$ TOP of evaluateSynthesizedAttribute (astNode = %s) (synthesizedAttributeList.size() = %d) \n",
astNode->sage_class_name(),synthesizedAttributeList.size());
//cout << " Ast node string: " << astNode->unparseToString() << endl;
#endif
// Build the return value for this function
ArrayAssignmentStatementQuerySynthesizedAttributeType returnSynthesizedAttribute(astNode);
// Iterator used within several error checking loops (not sure we should declare it here!)
vector<ArrayAssignmentStatementQuerySynthesizedAttributeType>::iterator i;
// Make a reference to the global operand database
OperandDataBaseType & operandDataBase = accumulatorValue.operandDataBase;
// Make sure the data base has been setup properly
ROSE_ASSERT(operandDataBase.transformationOption > ArrayTransformationSupport::UnknownIndexingAccess);
ROSE_ASSERT(operandDataBase.dimension > -1);
// Build up a return string
string returnString = "";
string operatorString;
// Need to handle all unary and binary operators and variables (but not much else)
switch (astNode->variant()) {
case FUNC_CALL: {
// Error checking: Verify that we have a SgFunctionCallExp object
SgFunctionCallExp* functionCallExpression = isSgFunctionCallExp(astNode);
ROSE_ASSERT(functionCallExpression != NULL);
string operatorName = TransformationSupport::getFunctionName(functionCallExpression);
ROSE_ASSERT(operatorName.c_str() != NULL);
string functionTypeName = TransformationSupport::getFunctionTypeName(functionCallExpression);
if ((functionTypeName != "doubleArray") && (functionTypeName != "floatArray") && (functionTypeName
!= "intArray")) {
// Use this query to handle only A++ function call expressions
// printf ("Break out of overloaded operator processing since type = %s is not to be processed \n",functionTypeName.c_str());
break;
} else {
// printf ("Processing overloaded operator of type = %s \n",functionTypeName.c_str());
}
ROSE_ASSERT((functionTypeName == "doubleArray") || (functionTypeName == "floatArray") || (functionTypeName
== "intArray"));
// printf ("CASE FUNC_CALL: Overloaded operator = %s \n",operatorName.c_str());
// Get the number of parameters to this function
SgExprListExp* exprListExp = functionCallExpression->get_args();
ROSE_ASSERT(exprListExp != NULL);
SgExpressionPtrList & expressionPtrList = exprListExp->get_expressions();
int numberOfParameters = expressionPtrList.size();
TransformationSupport::operatorCodeType operatorCodeVariant =
TransformationSupport::classifyOverloadedOperator(operatorName.c_str(), numberOfParameters);
// printf ("CASE FUNC_CALL: numberOfParameters = %d operatorCodeVariant = %d \n",
// numberOfParameters,operatorCodeVariant);
ROSE_ASSERT(operatorName.length() > 0);
// Separating this case into additional cases makes up to some
// extent for using a more specific higher level grammar.
switch (operatorCodeVariant) {
case TransformationSupport::ASSIGN_OPERATOR_CODE: {
vector<ArrayOperandDataBase>::iterator lhs = operandDataBase.arrayOperandList.begin();
vector<ArrayOperandDataBase>::iterator rhs = lhs;
rhs++;
while (rhs != operandDataBase.arrayOperandList.end()) {
// look at the operands on the rhs for a match with the one on the lhs
if ((*lhs).arrayVariableName == (*rhs).arrayVariableName) {
// A loop dependence has been identified
// Mark the synthesized attribute to record
// the loop dependence within this statement
returnSynthesizedAttribute.setLoopDependence(TRUE);
}
rhs++;
}
break;
}
default:
break;
}
break;
}
case EXPR_STMT: {
printf("Found a EXPR STMT expression %s\n", astNode->unparseToString().c_str());
// The assembly associated with the SgExprStatement is what
// triggers the generation of the transformation string
SgExprStatement* expressionStatement = isSgExprStatement(astNode);
ROSE_ASSERT(expressionStatement != NULL);
ArrayAssignmentStatementQuerySynthesizedAttributeType innerLoopTransformation =
synthesizedAttributeList[SgExprStatement_expression];
// Call another global support
// Create appropriate macros, nested loops, etc
expressionStatementTransformation(expressionStatement, arrayAssignmentStatementQueryInheritedData,
innerLoopTransformation, operandDataBase);
break;
}
// case TransformationSupport::PARENTHESIS_OPERATOR_CODE: {
// ROSE_ASSERT (operatorName == "operator()");
// // printf ("Indexing of InternalIndex objects in not implemented yet! \n");
//
// // Now get the operands out and search for the offsets in the index objects
//
// // We only want to pass on the transformationOptions as inherited attributes
// // to the indexOffsetQuery
// // list<int> & transformationOptionList = arrayAssignmentStatementQueryInheritedData.getTransformationOptions();
//
// // string offsetString;
// string indexOffsetString[6]; // = {NULL,NULL,NULL,NULL,NULL,NULL};
//
// // retrieve the variable name from the data base (so that we can add the associated index object names)
// // printf ("WARNING (WHICH OPERAND TO SELECT): operandDataBase.size() = %d \n",operandDataBase.size());
// // ROSE_ASSERT (operandDataBase.size() == 1);
// // string arrayVariableName = returnSynthesizedAttribute.arrayOperandList[0].arrayVariableName;
// int lastOperandInDataBase = operandDataBase.size() - 1;
// ArrayOperandDataBase & arrayOperandDB = operandDataBase.arrayOperandList[lastOperandInDataBase];
// // string arrayVariableName =
// // operandDataBase.arrayOperandList[operandDataBase.size()-1].arrayVariableName;
// string arrayVariableName = arrayOperandDB.arrayVariableName;
//
// string arrayDataPointerNameSubstring = string("_") + arrayVariableName;
//
// // printf ("***** WARNING: Need to get identifier from the database using the ArrayOperandDataBase::generateIdentifierString() function \n");
//
// if (expressionPtrList.size() == 0) {
// // Case of A() (index object with no offset integer expression) Nothing to do here (I think???)
// printf("Special case of Indexing with no offset! exiting ... \n");
// ROSE_ABORT();
//
// returnString = "";
// } else {
// // Get the value of the offsets (start the search from the functionCallExp)
// SgExprListExp* exprListExp = functionCallExpression->get_args();
// ROSE_ASSERT (exprListExp != NULL);
//
// SgExpressionPtrList & expressionPtrList = exprListExp->get_expressions();
// SgExpressionPtrList::iterator i = expressionPtrList.begin();
//
// // Case of indexing objects used within operator()
// int counter = 0;
// while (i != expressionPtrList.end()) {
// // printf ("Looking for the offset on #%d of %d (total) \n",counter,expressionPtrList.size());
//
// // Build up the name of the final index variable (or at least give
// // it a unique number by dimension)
// string counterString = StringUtility::numberToString(counter + 1);
//
// // Call another transformation mechanism to generate string for the index
// // expression (since we don't have an unparser mechanism in ROSE yet)
// indexOffsetString[counter] = IndexOffsetQuery::transformation(*i);
//
// ROSE_ASSERT (indexOffsetString[counter].c_str() != NULL);
// // printf ("indexOffsetString [%d] = %s \n",counter,indexOffsetString[counter].c_str());
//
// // Accumulate a list of all the InternalIndex, Index, and Range objects
// printf(" Warning - Need to handle indexNameList from the older code \n");
//
// i++;
// counter++;
// }
// Added VAR_REF case (moved from the local function)
case VAR_REF: {
// A VAR_REF has to output a string (the variable name)
#if DEBUG
printf ("Found a variable reference expression \n");
#endif
// Since we are at a leaf in the traversal of the AST this attribute list should a size of 0.
ROSE_ASSERT(synthesizedAttributeList.size() == 0);
SgVarRefExp* varRefExp = isSgVarRefExp(astNode);
ROSE_ASSERT(varRefExp != NULL);
SgVariableSymbol* variableSymbol = varRefExp->get_symbol();
ROSE_ASSERT(variableSymbol != NULL);
SgInitializedName* initializedName = variableSymbol->get_declaration();
ROSE_ASSERT(initializedName != NULL);
SgName variableName = initializedName->get_name();
string buffer;
string indexOffsetString;
// Now compute the offset to the index objects (form a special query for this???)
SgType* type = variableSymbol->get_type();
ROSE_ASSERT(type != NULL);
string typeName = TransformationSupport::getTypeName(type);
ROSE_ASSERT(typeName.c_str() != NULL);
// Recognize only these types at present
if (typeName == "intArray" || typeName == "floatArray" || typeName == "doubleArray") {
// Only define the variable name if we are using an object of array type
// Copy the string from the SgName object to a string object
string variableNameString = variableName.str();
#if DEBUG
printf("Handle case of A++ array object VariableName: %s \n", variableNameString.c_str());
#endif
if (arrayAssignmentStatementQueryInheritedData.arrayStatementDimensionDefined == TRUE) {
cout << " Dim: " << arrayAssignmentStatementQueryInheritedData.arrayStatementDimension << endl;
// The the globally computed array dimension from the arrayAssignmentStatementQueryInheritedData
dimensionList.push_back(arrayAssignmentStatementQueryInheritedData.arrayStatementDimension);
} else {
dimensionList.push_back(6); // Default dimension for A++/P++
}
nodeList.push_back(isSgExpression(varRefExp));
//processArrayRefExp(varRefExp, arrayAssignmentStatementQueryInheritedData);
// Setup an intry in the synthesized attribute data base for this variable any
// future results from analysis could be place there at this point as well
// record the name in the synthesized attribute
ROSE_ASSERT(operandDataBase.transformationOption > ArrayTransformationSupport::UnknownIndexingAccess);
ArrayOperandDataBase arrayOperandDB = operandDataBase.setVariableName(variableNameString);
}
break;
}
default: {
break;
}
} // End of main switch statement
#if DEBUG
printf ("$$$$$ BOTTOM of arrayAssignmentStatementAssembly::evaluateSynthesizedAttribute (astNode = %s) \n",astNode->sage_class_name());
printf (" BOTTOM: returnString = \n%s \n",returnString.c_str());
#endif
return returnSynthesizedAttribute;
}
/*
* returns string of functions name
*/
string MigrationOutliner::getFunctionName(SgFunctionDeclaration *func){
const SgName name = func->get_name();
return name.getString();
}//end getFunctionName
// Do partial redundancy elimination, looking for copies of one expression expr
// within the basic block root. A control flow graph for root must be provided
// in cfg, with a map from nodes to their statements in node_statements, a map
// from edges to their CFG edge types in edge_type, and a map from edges to
// their insertion points in edge_insertion_point. The algorithm used is that
// of Paleri, Srikant, and Shankar ("Partial redundancy elimination: a simple,
// pragmatic, and provably correct algorithm", Science of Computer Programming
// 48 (2003) 1--20).
void PRE::partialRedundancyEliminationOne( SgExpression* expr, SgBasicBlock* root, const myControlFlowGraph& cfg)
{
// SgBasicBlock* myFunctionBody = getFunctionDefinition(expr)->get_body();
// DQ (3/16/2006): Added assertions
ROSE_ASSERT(expr != NULL);
ROSE_ASSERT(root != NULL);
vector<SgVariableSymbol*> symbols_in_expression = SageInterface::getSymbolsUsedInExpression(expr);
if (anyOfListPotentiallyModifiedIn(symbols_in_expression, expr))
{
// This expression updates its own arguments, and so is not idempotent
// Return immediately
return;
}
// Simple or not user-definable expressions
if (isSgVarRefExp(expr)) return;
if (isSgValueExp(expr)) return;
if (isSgFunctionRefExp(expr)) return;
if (isSgExprListExp(expr)) return;
if (isSgInitializer(expr)) return;
#if 0
if ( (isSgAddOp(expr) || isSgSubtractOp(expr)) &&
(isSgVarRefExp(isSgBinaryOp(expr)->get_lhs_operand()) ||
isSgValueExp(isSgBinaryOp(expr)->get_lhs_operand())) &&
(isSgVarRefExp(isSgBinaryOp(expr)->get_rhs_operand()) ||
isSgValueExp(isSgBinaryOp(expr)->get_rhs_operand())))
return;
#endif
// Expressions which do not keep a consistent value each time they are used
if (!expressionTreeEqual(expr, expr))
return;
// cerr << "Trying to do PRE using expression " << expr->unparseToString() << " whose type is " << expr->sage_class_name() << endl;
VertexIter i = cfg.graph.vertices().begin(),
end = cfg.graph.vertices().end();
// cerr << "CFG has " << distance(i, end) << " nodes" << endl;
bool needToMakeCachevar = false;
set<SgNode*> replacements;
vector<pair<SgNode*, bool /* before */> > insertions;
vector<bool> transp(cfg.graph.vertices().size()),
comp(cfg.graph.vertices().size()),
antloc(cfg.graph.vertices().size());
vector<SgNode*> first_computation(cfg.graph.vertices().size()),
last_computation(cfg.graph.vertices().size());
// Set values of local node properties
for (i = cfg.graph.vertices().begin(); i != end; ++i)
{
const vector<SgNode*>& stmts = cfg.node_statements[*i];
// Precompute test values for each statement
vector<bool> argumentsModifiedInStatement(stmts.size());
vector<int> expressionComputedInStatement(stmts.size());
for (unsigned int j = 0; j < stmts.size(); ++j)
{
if (anyOfListPotentiallyModifiedIn(symbols_in_expression, stmts[j]))
argumentsModifiedInStatement[j] = true;
expressionComputedInStatement[j] = countComputationsOfExpressionIn(expr, stmts[j]);
}
// Compute transp
transp[*i] = true;
for (unsigned int j = 0; j < stmts.size(); ++j)
if (argumentsModifiedInStatement[j])
transp[*i] = false;
// Compute comp and do local redundancy elimination
comp[*i] = false;
SgNode* firstComputationInChain = 0;
bool needToInsertComputation = false;
bool computationInsertedOrUsed = false;
// cout << "In node " << *i << endl;
for (unsigned int j = 0; j < stmts.size(); ++j)
{
// cout << "In stmt " << j << ", expressionComputedInStatement = " << expressionComputedInStatement[j]
// << ", argumentsModifiedInStatement = " << argumentsModifiedInStatement[j] << endl;
if (expressionComputedInStatement[j] && !argumentsModifiedInStatement[j] && comp[*i] /* from last iter */)
{
// Do local redundancy elimination
if (firstComputationInChain && needToInsertComputation)
{
insertions.push_back(make_pair(firstComputationInChain, true));
replacements.insert(firstComputationInChain);
needToInsertComputation = false;
}
replacements.insert(stmts[j]);
computationInsertedOrUsed = true;
needToMakeCachevar = true;
}
if (expressionComputedInStatement[j])
{
comp[*i] = true;
if (!firstComputationInChain)
{
firstComputationInChain = stmts[j];
needToInsertComputation = true;
if (expressionComputedInStatement[j] >= 2)
{
insertions.push_back(make_pair(stmts[j], true));
needToMakeCachevar = true;
needToInsertComputation = false;
computationInsertedOrUsed = true;
replacements.insert(stmts[j]);
}
}
last_computation[*i] = stmts[j];
}
if (argumentsModifiedInStatement[j])
{
comp[*i] = false; // Must come after expressionComputedInStatement check
firstComputationInChain = 0;
needToInsertComputation = false;
}
}
assert (!computationInsertedOrUsed || needToMakeCachevar);
// Compute antloc
antloc[*i] = false;
for (unsigned int j = 0; j < stmts.size(); ++j)
{
if (expressionComputedInStatement[j] && !argumentsModifiedInStatement[j])
{
antloc[*i] = true;
first_computation[*i] = stmts[j];
break;
}
if (argumentsModifiedInStatement[j])
{
antloc[*i] = false;
break;
}
}
}
// #define PRINT_PROPERTY(p) // for (i = cfg.graph.vertices().begin(); i != end; ++i) if (p[*i]) cerr << #p ": " << *i << endl;
#define PRINT_PROPERTY(p) // for (i = cfg.graph.vertices().begin(); i != end; ++i) if (p[*i]) cerr << #p ": " << *i << endl;
PRINT_PROPERTY(transp);
PRINT_PROPERTY(comp);
PRINT_PROPERTY(antloc);
int (simpleGraph::*source_ptr)(int) const = &simpleGraph::source;
int (simpleGraph::*target_ptr)(int) const = &simpleGraph::target;
vector<bool> avin(cfg.graph.vertices().size(), true);
vector<bool> avout(cfg.graph.vertices().size(), true);
FIXPOINT_BEGIN(cfg)
FIXPOINT_OUTPUT_BEGIN(avin, cfg);
FIXPOINT_OUTPUT_BEGIN(avout, cfg);
avin[v] = accumulate_neighbors(cfg, v, avout,cfg.graph.in_edges(v),&simpleGraph::source, logical_and<bool>(), true, false);
avout[v] = comp[v] || (avin[v] && transp[v]);
FIXPOINT_OUTPUT_END(avout, <=, cfg);
FIXPOINT_OUTPUT_END(avin, <=, cfg);
FIXPOINT_END(cfg, out_edges, OutEdgeIter)
PRINT_PROPERTY(avin);
PRINT_PROPERTY(avout);
vector<bool> antin(cfg.graph.vertices().size(), true);
vector<bool> antout(cfg.graph.vertices().size(), true);
FIXPOINT_BEGIN(cfg)
FIXPOINT_OUTPUT_BEGIN(antin, cfg);
FIXPOINT_OUTPUT_BEGIN(antout, cfg);
antout[v] = accumulate_neighbors(cfg, v, antin, cfg.graph.out_edges(v), target_ptr, logical_and<bool>(), true, false);
antin[v] = antloc[v] || (antout[v] && transp[v]);
FIXPOINT_OUTPUT_END(antout, <=, cfg);
FIXPOINT_OUTPUT_END(antin, <=, cfg);
FIXPOINT_END(cfg, in_edges, InEdgeIter)
PRINT_PROPERTY(antin);
PRINT_PROPERTY(antout);
vector<bool> safein(cfg.graph.vertices().size()), safeout(cfg.graph.vertices().size());
for (i = cfg.graph.vertices().begin(); i != end; ++i)
{
safein[*i] = avin[*i] || antin[*i];
safeout[*i] = avout[*i] || antout[*i];
}
PRINT_PROPERTY(safein);
PRINT_PROPERTY(safeout);
vector<bool> spavin(cfg.graph.vertices().size(), false);
vector<bool> spavout(cfg.graph.vertices().size(), false);
FIXPOINT_BEGIN(cfg)
FIXPOINT_OUTPUT_BEGIN(spavin, cfg);
FIXPOINT_OUTPUT_BEGIN(spavout, cfg);
spavin[v] = safein[v] && accumulate_neighbors(cfg, v, spavout, cfg.graph.in_edges(v), source_ptr, logical_or<bool>(), false, false);
spavout[v] = safeout[v] && (comp[v] || (spavin[v] && transp[v]));
FIXPOINT_OUTPUT_END(spavout, >=, cfg);
FIXPOINT_OUTPUT_END(spavin, >=, cfg);
FIXPOINT_END(cfg, out_edges, OutEdgeIter)
PRINT_PROPERTY(spavin);
PRINT_PROPERTY(spavout);
vector<bool> spantin(cfg.graph.vertices().size(), false);
vector<bool> spantout(cfg.graph.vertices().size(), false);
FIXPOINT_BEGIN(cfg)
FIXPOINT_OUTPUT_BEGIN(spantin, cfg);
FIXPOINT_OUTPUT_BEGIN(spantout, cfg);
spantout[v] = safeout[v] && accumulate_neighbors(cfg, v, spantin, cfg.graph.out_edges(v), target_ptr, logical_or<bool>(), false, false);
spantin[v] = safein[v] && (antloc[v] || (spantout[v] && transp[v]));
FIXPOINT_OUTPUT_END(spantout, >=, cfg);
FIXPOINT_OUTPUT_END(spantin, >=, cfg);
FIXPOINT_END(cfg, in_edges, InEdgeIter)
PRINT_PROPERTY(spantin);
PRINT_PROPERTY(spantout);
#undef PRINT_PROPERTY
vector<bool> node_insert(cfg.graph.vertices().size());
vector<bool> replacef(cfg.graph.vertices().size());
vector<bool> replacel(cfg.graph.vertices().size());
// printf ("Intermediate test 1: needToMakeCachevar = %s \n",needToMakeCachevar ? "true" : "false");
for (i = cfg.graph.vertices().begin(); i != end; ++i)
{
node_insert[*i] = comp[*i] && spantout[*i] && (!transp[*i] || !spavin[*i]);
replacef[*i] = antloc[*i] && (spavin[*i] || (transp[*i] && spantout[*i]));
replacel[*i] = comp[*i] && (spantout[*i] || (transp[*i] && spavin[*i]));
if (node_insert[*i])
{
needToMakeCachevar = true;
insertions.push_back(make_pair(last_computation[*i], true));
// cerr << "Insert computation of " << expr->unparseToString() << " just before last computation in " << *i << endl;
}
if (replacef[*i])
{
needToMakeCachevar = true;
replacements.insert(first_computation[*i]);
// cerr << "Replace first computation of " << *i << endl;
}
if (replacel[*i])
{
needToMakeCachevar = true;
replacements.insert(last_computation[*i]);
// cerr << "Replace last computation of " << *i << endl;
}
}
vector<bool> edge_insert(cfg.graph.edges().size());
// printf ("Intermediate test 2: needToMakeCachevar = %s \n",needToMakeCachevar ? "true" : "false");
EdgeIter j = cfg.graph.edges().begin(), jend = cfg.graph.edges().end();
for (; j != jend; ++j)
{
edge_insert[*j] = !spavout[cfg.graph.source(*j)] && spavin[cfg.graph.target(*j)] && spantin[cfg.graph.target(*j)];
// printf ("edge_insert[*j] = %s \n",edge_insert[*j] ? "true" : "false");
if (edge_insert[*j])
{
needToMakeCachevar = true;
// cerr << "Insert computation of " << expr->unparseToString() << " on edge from "
// << cfg.graph.source(*j) << " to " << cfg.graph.target(*j) << endl;
}
}
// printf ("Before final test: needToMakeCachevar = %s \n",needToMakeCachevar ? "true" : "false");
// Add cache variable if necessary
SgVarRefExp* cachevar = 0;
if (needToMakeCachevar)
{
SgName cachevarname = "cachevar__";
cachevarname << ++SageInterface::gensym_counter;
// printf ("Building variable name = %s \n",cachevarname.str());
SgType* type = expr->get_type();
if (isSgArrayType(type))
type = new SgPointerType(isSgArrayType(type)->get_base_type());
assert (SageInterface::isDefaultConstructible(type));
// FIXME: assert (isAssignable(type));
SgVariableDeclaration* decl = new SgVariableDeclaration(SgNULL_FILE, cachevarname, type, NULL);
decl->set_definingDeclaration(decl);
SgInitializedName* initname = decl->get_variables().back();
// DQ (10/5/2007): Added an assertion.
ROSE_ASSERT(initname != NULL);
decl->addToAttachedPreprocessingInfo(
new PreprocessingInfo(PreprocessingInfo::CplusplusStyleComment,
(string("// Partial redundancy elimination: ") + cachevarname.str() +
" is a cache of " + expr->unparseToString()).c_str(),
"Compiler-Generated in PRE", 0, 0, 0, PreprocessingInfo::before));
SgVariableSymbol* cachevarsym = new SgVariableSymbol(initname);
decl->set_parent(root);
// DQ (10/5/2007): Added scope (suggested by Jeremiah).
initname->set_scope(root);
root->get_statements().insert(root->get_statements().begin(),decl);
root->insert_symbol(cachevarname, cachevarsym);
cachevar = new SgVarRefExp(SgNULL_FILE, cachevarsym);
cachevar->set_endOfConstruct(SgNULL_FILE);
}
// Do expression computation replacements
for (set<SgNode*>::iterator i = replacements.begin(); i != replacements.end(); ++i)
{
ReplaceExpressionWithVarrefVisitor(expr, cachevar).traverse(*i, postorder);
}
// Do edge insertions
// int count = 0;
bool failAtEndOfFunction = false;
for (j = cfg.graph.edges().begin(); j != jend; ++j)
{
// printf ("Build the insertion list! count = %d \n",count++);
if (edge_insert[*j])
{
#if 0
// DQ (3/13/2006): Compiler warns that "src" is unused, so I have commented it out!
Vertex src = cfg.graph.source(*j), tgt = cfg.graph.target(*j);
cerr << "Doing insertion between " << src << " and " << tgt << endl;
#endif
pair<SgNode*, bool> insert_point = cfg.edge_insertion_point[*j];
if (insert_point.first)
{
insertions.push_back(insert_point);
}
else
{
// DQ (3/16/2006): This is a visited when we fixup the NULL pointer to the initializer in a SgForStatment.
cerr << "Warning: no insertion point found" << endl; //FIXME was assert
printf ("Need to figure out what to do here! cfg.edge_insertion_point[*j] = %p \n",&(cfg.edge_insertion_point[*j]));
failAtEndOfFunction = true;
ROSE_ASSERT(false);
}
}
}
// Do within-node insertions
// printf ("At start of loop: insertions.size() = %zu \n",insertions.size());
for (vector<pair<SgNode*, bool> >::iterator i = insertions.begin(); i != insertions.end(); ++i)
{
SgTreeCopy tc1, tc2;
SgVarRefExp* cachevarCopy = isSgVarRefExp(cachevar->copy(tc1));
ROSE_ASSERT (cachevarCopy);
cachevarCopy->set_lvalue(true);
SgExpression* operation = new SgAssignOp(SgNULL_FILE, cachevarCopy, isSgExpression(expr->copy(tc2)));
#if 0
printf ("Inside of loop: insertions.size() = %zu \n",insertions.size());
printf ("\n\ni->first = %p = %s = %s \n",i->first,i->first->class_name().c_str(),i->first->unparseToString().c_str());
printf ("operation = %p = %s = %s \n",operation,operation->class_name().c_str(),operation->unparseToString().c_str());
#endif
if (isSgExpression(i->first) && !i->second)
{
SgNode* ifp = i->first->get_parent();
SgCommaOpExp* comma = new SgCommaOpExp(SgNULL_FILE, isSgExpression(i->first), operation);
operation->set_parent(comma);
comma->set_parent(ifp);
i->first->set_parent(comma);
if (isSgForStatement(ifp))
{
isSgForStatement(ifp)->set_increment(comma);
}
else if (isSgBinaryOp(ifp) && isSgBinaryOp(ifp)->get_lhs_operand() == i->first)
{
isSgBinaryOp(ifp)->set_lhs_operand(comma);
}
else if (isSgBinaryOp(ifp) && isSgBinaryOp(ifp)->get_rhs_operand() == i->first)
{
isSgBinaryOp(ifp)->set_rhs_operand(comma);
}
else if (isSgUnaryOp(ifp) && isSgUnaryOp(ifp)->get_operand() == i->first)
{
isSgUnaryOp(ifp)->set_operand(comma);
}
else
{
cerr << ifp->sage_class_name() << endl;
assert (!"Bad parent type for inserting comma expression");
}
}
else
{
SgStatement* the_computation = new SgExprStatement(SgNULL_FILE, operation);
operation->set_parent(the_computation);
// printf ("In pre.C: the_computation = %p = %s \n",the_computation,the_computation->class_name().c_str());
if (isSgBasicBlock(i->first) && i->second)
{
isSgBasicBlock(i->first)->get_statements().insert(isSgBasicBlock(i->first)->get_statements().begin(),the_computation);
the_computation->set_parent(i->first);
}
else
{
#if 0
// DQ (3/14/2006): Bug here when SgExprStatement from SgForStatement test is used here!
printf ("Bug here when SgExprStatement from SgForStatement test is used: i->first = %s \n",i->first->class_name().c_str());
i->first->get_file_info()->display("Location i->first");
printf ("Bug here when SgExprStatement from SgForStatement test is used: TransformationSupport::getStatement(i->first) = %s \n",
TransformationSupport::getStatement(i->first)->class_name().c_str());
printf ("Bug here when SgExprStatement from SgForStatement test is used: the_computation = %s \n",the_computation->class_name().c_str());
the_computation->get_file_info()->display("Location the_computation: debug");
ROSE_ASSERT(i->first != NULL);
ROSE_ASSERT(i->first->get_parent() != NULL);
printf ("i->first->get_parent() = %s \n",i->first->get_parent()->class_name().c_str());
i->first->get_file_info()->display("Location i->first: debug");
#endif
SgForStatement* forStatement = isSgForStatement(i->first->get_parent());
if (forStatement != NULL)
{
// Make sure that both pointers are not equal because they are both NULL!
ROSE_ASSERT(forStatement->get_test() != NULL);
SgExprStatement* possibleTest = isSgExprStatement(i->first);
if ( forStatement->get_test() == possibleTest )
{
// This is a special case of a SgExpressionStatement as a target in a SgForStatement
// printf ("Found special case of target being the test of a SgForStatement \n");
forStatement->set_test(the_computation);
the_computation->set_parent(forStatement);
}
}
else
{
SgForInitStatement* forInitStatement = isSgForInitStatement(i->first->get_parent());
if (forInitStatement != NULL)
{
// printf ("Found the SgForInitStatement \n");
SgVariableDeclaration* possibleVariable = isSgVariableDeclaration(i->first);
SgExprStatement* possibleExpression = isSgExprStatement(i->first);
SgStatementPtrList & statementList = forInitStatement->get_init_stmt();
SgStatementPtrList::iterator i = statementList.begin();
bool addToForInitList = false;
while ( (addToForInitList == false) && (i != statementList.end()) )
{
// if ( *i == possibleVariable )
if ( *i == possibleVariable || *i == possibleExpression )
{
// This is a special case of a SgExpressionStatement as a target in a SgForStatement
// printf ("Found special case of SgForInitStatement transformation \n");
addToForInitList = true;
}
i++;
}
// Only modify the STL list outside of the loop over the list to avoid interator invalidation
if (addToForInitList == true)
{
// Add the the_computation statment to the list in the SgForInitStatement.
// Later if we abandon the SgForInitStatement then we would have to add it to
// the list of SgInitializedName objects in the SgVariableDeclaration OR modify
// the expression list to handle the extra expression (but I think this case in
// handled above).
// printf ("Adding the_computation to the list in the SgForInitStatement \n");
statementList.push_back(the_computation);
the_computation->set_parent(forInitStatement);
}
}
else
{
myStatementInsert(TransformationSupport::getStatement(i->first),the_computation,i->second,true);
the_computation->set_parent(TransformationSupport::getStatement(i->first));
}
}
}
}
}
// DQ (3/16/2006): debugging code to force failure at inspection point
if (failAtEndOfFunction == true)
{
printf ("Error: internal error detected \n");
ROSE_ASSERT(false);
}
}
void
FixupAstSymbolTablesToSupportAliasedSymbols::visit ( SgNode* node )
{
// DQ (11/24/2007): Output the current IR node for debugging the traversal of the Fortran AST.
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols::visit() (preorder AST traversal) node = %p = %s \n",node,node->class_name().c_str());
#endif
#if 0
// DQ (7/23/2011): New support for linking namespaces sharing the same name (mangled name).
// std::map<SgName,std::vector<SgNamespaceDefinition*> > namespaceMap;
SgNamespaceDefinitionStatement* namespaceDefinition = isSgNamespaceDefinitionStatement(node);
if (namespaceDefinition != NULL)
{
// DQ (7/23/2011): Assemble namespaces with the same name into vectors defined in the map
// accessed using the name of the namespace as a key.
#error "DEAD CODE"
SgName name = namespaceDefinition->get_namespaceDeclaration()->get_name();
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: namespace definition found for name = %s #symbols = %d \n",name.str(),namespaceDefinition->get_symbol_table()->size());
#endif
// It is important to use mangled names to define unique names when namespaces are nested.
SgName mangledNamespaceName = namespaceDefinition->get_namespaceDeclaration()->get_mangled_name();
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: namespace definition associated mangled name = %s \n",mangledNamespaceName.str());
#endif
// DQ (7/23/2011): Fixup the name we use as a key in the map to relect that some namespaces don't have a name.
if (name == "")
{
// Modify the mangled name to reflect the unnamed namespace...
#if ALIAS_SYMBOL_DEBUGGING
printf ("Warning in FixupAstSymbolTablesToSupportAliasedSymbols::visit(): Unnamed namespaces shuld be mangled to reflect the lack of a name \n");
#endif
mangledNamespaceName += "_unnamed_namespace";
}
#if ALIAS_SYMBOL_DEBUGGING
printf ("namespace definition associated mangled name = %s \n",mangledNamespaceName.str());
#endif
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: associated mangled name = %s namespaceMap size = %" PRIuPTR " \n",mangledNamespaceName.str(),namespaceMap.size());
#endif
std::map<SgName,std::vector<SgNamespaceDefinitionStatement*> >::iterator i = namespaceMap.find(mangledNamespaceName);
if (i != namespaceMap.end())
{
std::vector<SgNamespaceDefinitionStatement*> & namespaceVector = i->second;
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: (found an entry): Namespace vector size = %" PRIuPTR " \n",namespaceVector.size());
#endif
// Testing each entry...
for (size_t j = 0; j < namespaceVector.size(); j++)
{
ROSE_ASSERT(namespaceVector[j] != NULL);
SgName existingNamespaceName = namespaceVector[j]->get_namespaceDeclaration()->get_name();
#if ALIAS_SYMBOL_DEBUGGING
printf ("Existing namespace (SgNamespaceDefinitionStatement) %p = %s \n",namespaceVector[j],existingNamespaceName.str());
#endif
if (j > 0)
{
ROSE_ASSERT(namespaceVector[j]->get_previousNamespaceDefinition() != NULL);
}
if (namespaceVector.size() > 1 && j < namespaceVector.size() - 2)
{
ROSE_ASSERT(namespaceVector[j]->get_nextNamespaceDefinition() != NULL);
}
}
#error "DEAD CODE"
size_t namespaceListSize = namespaceVector.size();
if (namespaceListSize > 0)
{
size_t lastNamespaceIndex = namespaceListSize - 1;
// DQ (5/9/2013): Before setting these, I think they should be unset (to NULL values).
// ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == NULL);
// ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() == NULL);
// ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == NULL);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() != NULL);
// namespaceVector[lastNamespaceIndex]->set_nextNamespaceDefinition(namespaceDefinition);
#if 1
printf ("namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() = %p \n",namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition());
#endif
if (namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == NULL)
{
namespaceVector[lastNamespaceIndex]->set_nextNamespaceDefinition(namespaceDefinition);
}
else
{
// DQ (5/9/2013): If this is already set then make sure it was set to the correct value.
ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == namespaceDefinition);
}
#error "DEAD CODE"
// DQ (5/9/2013): If this is already set then make sure it was set to the correct value.
// namespaceDefinition->set_previousNamespaceDefinition(namespaceVector[lastNamespaceIndex]);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() != NULL);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() == namespaceVector[lastNamespaceIndex]);
// DQ (5/9/2013): I think I can assert this.
ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_namespaceDeclaration()->get_name() == namespaceDefinition->get_namespaceDeclaration()->get_name());
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() != NULL);
#if 1
printf ("namespaceDefinition = %p namespaceDefinition->get_nextNamespaceDefinition() = %p \n",namespaceDefinition,namespaceDefinition->get_nextNamespaceDefinition());
#endif
// ROSE_ASSERT(namespaceDefinition->get_nextNamespaceDefinition() == NULL);
// ROSE_ASSERT(namespaceVector[lastNamespaceIndex]->get_nextNamespaceDefinition() == NULL);
}
// Add the namespace matching a previous name to the list.
namespaceVector.push_back(namespaceDefinition);
#error "DEAD CODE"
// Setup scopes as sources and distinations of alias symbols.
SgNamespaceDefinitionStatement* referencedScope = namespaceDefinition->get_previousNamespaceDefinition();
ROSE_ASSERT(referencedScope != NULL);
SgNamespaceDefinitionStatement* currentScope = namespaceDefinition;
ROSE_ASSERT(currentScope != NULL);
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: Suppress injection of symbols from one namespace to the other for each reintrant namespace \n");
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: referencedScope #symbols = %d currentScope #symbols = %d \n",referencedScope->get_symbol_table()->size(),currentScope->get_symbol_table()->size());
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: referencedScope = %p currentScope = %p \n",referencedScope,currentScope);
#endif
#if 1
// Generate the alias symbols from the referencedScope and inject into the currentScope.
injectSymbolsFromReferencedScopeIntoCurrentScope(referencedScope,currentScope,SgAccessModifier::e_default);
#endif
}
else
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols: (entry NOT found): Insert namespace %p for name = %s into the namespaceMap \n",namespaceDefinition,mangledNamespaceName.str());
#endif
std::vector<SgNamespaceDefinitionStatement*> list(1);
ROSE_ASSERT(list.size() == 1);
#error "DEAD CODE"
list[0] = namespaceDefinition;
#if 0
// DQ (3/11/2012): New code, but maybe we should instead put the implicit "std" namespace into the global scope more directly.
if (mangledNamespaceName == "std" && false)
{
// This case has to be handled special since the implicit "std" namespace primary declaration was
// constructed but not added to the global scope. But maybe it should be.
}
else
{
// DQ (7/24/2011): get_nextNamespaceDefinition() == NULL is false in the case of the AST copy tests
// (see tests/nonsmoke/functional/CompileTests/copyAST_tests/copytest2007_30.C). Only get_nextNamespaceDefinition()
// appears to sometimes be non-null, so we reset them both to NULL just to make sure.
namespaceDefinition->set_nextNamespaceDefinition(NULL);
namespaceDefinition->set_previousNamespaceDefinition(NULL);
ROSE_ASSERT(namespaceDefinition->get_nextNamespaceDefinition() == NULL);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() == NULL);
}
#else
// DQ (7/24/2011): get_nextNamespaceDefinition() == NULL is false in the case of the AST copy tests
// (see tests/nonsmoke/functional/CompileTests/copyAST_tests/copytest2007_30.C). Only get_nextNamespaceDefinition()
// appears to sometimes be non-null, so we reset them both to NULL just to make sure.
namespaceDefinition->set_nextNamespaceDefinition(NULL);
namespaceDefinition->set_previousNamespaceDefinition(NULL);
ROSE_ASSERT(namespaceDefinition->get_nextNamespaceDefinition() == NULL);
ROSE_ASSERT(namespaceDefinition->get_previousNamespaceDefinition() == NULL);
#endif
namespaceMap.insert(std::pair<SgName,std::vector<SgNamespaceDefinitionStatement*> >(mangledNamespaceName,list));
#error "DEAD CODE"
#if ALIAS_SYMBOL_DEBUGGING
printf ("namespaceMap.size() = %" PRIuPTR " \n",namespaceMap.size());
#endif
}
}
#error "DEAD CODE"
#else
// DQ (5/23/2013): Commented out since we now have a newer and better namespace support for symbol handling.
// printf ("NOTE:: COMMENTED OUT old support for namespace declarations in FixupAstSymbolTablesToSupportAliasedSymbols traversal \n");
#endif
SgUseStatement* useDeclaration = isSgUseStatement(node);
if (useDeclaration != NULL)
{
// This must be done in the Fortran AST construction since aliased symbols must be inserted
// before they are looked up as part of name resolution of variable, functions, and types.
// For C++ we can be more flexible and support the construction of symbol aliases within
// post-processing.
}
// DQ (4/14/2010): Added this C++ specific support.
// In the future we may want to support the injection of alias symbols for C++ "using" directives and "using" declarations.
SgUsingDeclarationStatement* usingDeclarationStatement = isSgUsingDeclarationStatement(node);
if (usingDeclarationStatement != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("Found the SgUsingDeclarationStatement \n");
#endif
SgScopeStatement* currentScope = usingDeclarationStatement->get_scope();
ROSE_ASSERT(currentScope != NULL);
SgDeclarationStatement* declaration = usingDeclarationStatement->get_declaration();
SgInitializedName* initializedName = usingDeclarationStatement->get_initializedName();
// Only one of these can be non-null.
ROSE_ASSERT(initializedName != NULL || declaration != NULL);
ROSE_ASSERT( (initializedName != NULL && declaration != NULL) == false);
if (declaration != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols::visit(): declaration = %p = %s \n",declaration,declaration->class_name().c_str());
#endif
}
else
{
if (initializedName != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("In FixupAstSymbolTablesToSupportAliasedSymbols::visit(): initializedName = %s \n",initializedName->get_name().str());
#endif
}
else
{
printf ("Error: both declaration and initializedName in SgUsingDeclarationStatement are NULL \n");
ROSE_ASSERT(false);
}
}
#if 0
printf ("Exiting at the base of FixupAstSymbolTablesToSupportAliasedSymbols::visit() \n");
ROSE_ASSERT(false);
#endif
}
SgUsingDirectiveStatement* usingDirectiveStatement = isSgUsingDirectiveStatement(node);
if (usingDirectiveStatement != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("Found the SgUsingDirectiveStatement \n");
#endif
SgNamespaceDeclarationStatement* namespaceDeclaration = usingDirectiveStatement->get_namespaceDeclaration();
ROSE_ASSERT(namespaceDeclaration != NULL);
SgScopeStatement* currentScope = usingDirectiveStatement->get_scope();
// To be more specific this is really a SgNamespaceDefinitionStatement
SgScopeStatement* referencedScope = namespaceDeclaration->get_definition();
if (referencedScope == NULL)
{
// DQ (5/21/2010): Handle case of using "std" (predefined namespace in C++), but it not having been explicitly defined (see test2005_57.C).
if (namespaceDeclaration->get_name() != "std")
{
printf ("ERROR: namespaceDeclaration has no valid definition \n");
namespaceDeclaration->get_startOfConstruct()->display("ERROR: namespaceDeclaration has no valid definition");
// DQ (5/20/2010): Added assertion to trap this case.
printf ("Exiting because referencedScope could not be identified.\n");
ROSE_ASSERT(false);
}
}
// Note that "std", as a predefined namespace, can have a null definition, so we can't
// insist that we inject all symbols in namespaces that we can't see explicitly.
if (referencedScope != NULL)
{
ROSE_ASSERT(referencedScope != NULL);
ROSE_ASSERT(currentScope != NULL);
#if 0
printf ("Calling injectSymbolsFromReferencedScopeIntoCurrentScope() for usingDirectiveStatement = %p = %s \n",node,node->class_name().c_str());
#endif
injectSymbolsFromReferencedScopeIntoCurrentScope(referencedScope,currentScope,usingDirectiveStatement,SgAccessModifier::e_default);
}
#if 0
printf ("Exiting at the base of FixupAstSymbolTablesToSupportAliasedSymbols::visit() \n");
ROSE_ASSERT(false);
#endif
}
// DQ (5/6/2011): Added support to build SgAliasSymbols in derived class scopes that reference the symbols of the base classes associated with protected and public declarations.
SgClassDefinition* classDefinition = isSgClassDefinition(node);
if (classDefinition != NULL)
{
// Handle any derived classes.
SgBaseClassPtrList & baseClassList = classDefinition->get_inheritances();
SgBaseClassPtrList::iterator i = baseClassList.begin();
for ( ; i != baseClassList.end(); ++i)
{
// Check each base class.
SgBaseClass* baseClass = *i;
ROSE_ASSERT(baseClass != NULL);
/* skip processing for SgExpBaseClasses (which don't have to define p_base_class) */
if (baseClass->variantT() == V_SgExpBaseClass) {
continue;
}
// printf ("baseClass->get_baseClassModifier().displayString() = %s \n",baseClass->get_baseClassModifier().displayString().c_str());
// printf ("baseClass->get_baseClassModifier().get_accessModifier().displayString() = %s \n",baseClass->get_baseClassModifier().get_accessModifier().displayString().c_str());
// if (baseClass->get_modifier() == SgBaseClass::e_virtual)
if (baseClass->get_baseClassModifier().get_modifier() == SgBaseClassModifier::e_virtual)
{
// Not clear if virtual as a modifier effects the handling of alias symbols.
// printf ("Not clear if virtual as a modifier effects the handling of alias symbols. \n");
}
// DQ (6/22/2011): Define the access level for alias symbol's declarations to be included.
SgAccessModifier::access_modifier_enum accessLevel = baseClass->get_baseClassModifier().get_accessModifier().get_modifier();
SgClassDeclaration* tmpClassDeclaration = baseClass->get_base_class();
ROSE_ASSERT(tmpClassDeclaration != NULL);
#if 0
// ROSE_ASSERT(tmpClassDeclaration->get_definingDeclaration() != NULL);
SgClassDeclaration* targetClassDeclaration = isSgClassDeclaration(tmpClassDeclaration->get_definingDeclaration());
ROSE_ASSERT(targetClassDeclaration != NULL);
SgScopeStatement* referencedScope = targetClassDeclaration->get_definition();
// We need this function to restrict it's injection of symbol to just those that are associated with public and protected declarations.
injectSymbolsFromReferencedScopeIntoCurrentScope(referencedScope,classDefinition,accessLevel);
#else
// DQ (2/25/2012) We only want to inject the symbol where we have identified the defining scope.
if (tmpClassDeclaration->get_definingDeclaration() != NULL)
{
SgClassDeclaration* targetClassDeclaration = isSgClassDeclaration(tmpClassDeclaration->get_definingDeclaration());
ROSE_ASSERT(targetClassDeclaration != NULL);
SgScopeStatement* referencedScope = targetClassDeclaration->get_definition();
#if 0
printf ("Calling injectSymbolsFromReferencedScopeIntoCurrentScope() for classDefinition = %p = %s baseClass = %p accessLevel = %d \n",
node,node->class_name().c_str(),baseClass,accessLevel);
#endif
// DQ (7/12/2014): Use the SgBaseClass as the causal node that has triggered the insertion of the SgAliasSymbols.
// We need this function to restrict it's injection of symbol to just those that are associated with public and protected declarations.
injectSymbolsFromReferencedScopeIntoCurrentScope(referencedScope,classDefinition,baseClass,accessLevel);
}
else
{
// DQ (2/25/2012): Print a warning message when this happens (so far only test2012_08.C).
if (SgProject::get_verbose() > 0)
{
mprintf ("WARNING: In FixupAstSymbolTablesToSupportAliasedSymbols::visit(): Not really clear how to handle this case where tmpClassDeclaration->get_definingDeclaration() == NULL! \n");
}
}
#endif
}
}
SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(node);
if (functionDeclaration != NULL)
{
#if ALIAS_SYMBOL_DEBUGGING
printf ("Found a the SgFunctionDeclaration \n");
#endif
// SgScopeStatement* functionScope = functionDeclaration->get_scope();
SgScopeStatement* currentScope = isSgScopeStatement(functionDeclaration->get_parent());
SgClassDefinition* classDefinition = isSgClassDefinition(currentScope);
if (classDefinition != NULL)
{
// This is a function declared in a class definition, test of friend (forget why it is important to test for isOperator().
if (functionDeclaration->get_declarationModifier().isFriend() == true || functionDeclaration->get_specialFunctionModifier().isOperator() == true)
{
// printf ("Process all friend function with a SgAliasSymbol to where they are declared in another scope (usually global scope) \n");
#if 0
SgName name = functionDeclaration->get_name();
SgSymbol* symbol = functionDeclaration->search_for_symbol_from_symbol_table();
ROSE_ASSERT ( symbol != NULL );
SgAliasSymbol* aliasSymbol = new SgAliasSymbol (symbol);
// Use the current name and the alias to the symbol
currentScope->insert_symbol(name,aliasSymbol);
#endif
#if 0
printf ("Error: friend functions not processed yet! \n");
ROSE_ASSERT(false);
#endif
}
}
}
#if ALIAS_SYMBOL_DEBUGGING
printf ("Leaving FixupAstSymbolTablesToSupportAliasedSymbols::visit() (preorder AST traversal) node = %p = %s \n",node,node->class_name().c_str());
#endif
}
//-----------------------------------------------------------------------------
// Functions required by the tree traversal mechanism
ClasshierarchyInhAttr
ClasshierarchyTraversal::evaluateInheritedAttribute (
SgNode* astNode,
ClasshierarchyInhAttr inheritedAttribute )
{
GlobalDatabaseConnection *gdb; // db connection
//long funcId; // id of a function declaration
Classhierarchy *classhier = getClasshierarchy();
gdb = getDB();
switch(astNode->variantT())
{
case V_SgMemberFunctionDeclaration: {
SgMemberFunctionDeclaration *funcDec = isSgMemberFunctionDeclaration( astNode );
//funcDec = funcDef->get_declaration();
//if(isSgMemberFunctionDeclaration(funcDec)) {
// add to class hierarchy if member function definition
//if(isSgMemberFunctionDeclaration()) {
//cerr << " adding CHvinf for MembFunc " << endl;
SgClassDefinition *classDef = isSgClassDefinition( funcDec->get_scope() );
//assert(classDef);
if(classDef) {
string classname = classDef->get_qualified_name().str();
// get the classhier. vertex
Classhierarchy::dbgVertex chVert = 0; //?? init necessary
bool foundClass = false;
Classhierarchy::dbgVertexIterator chvi,chvend;
boost::tie(chvi,chvend) = boost::vertices( *getClasshierarchy() );
for(; chvi!=chvend; chvi++) {
if( boost::get( vertex_dbg_data, *getClasshierarchy() , *chvi).get_typeName() == classname ) {
chVert = *chvi;
foundClass = true;
}
}
if(foundClass) {
property_map< Classhierarchy::dbgType, boost::vertex_classhierarchy_t>::type chMap = boost::get( boost::vertex_classhierarchy, *getClasshierarchy() );
chMap[ chVert ].defined.insert( funcDec );
//get type?
//cerr << " added! "; // debug
}
}
//}
cerr << " found V_SgMemberFunctionDeclaration done for " <<funcDec->get_mangled_name().str()<< " " << endl; // debug
} break;
case V_SgClassDefinition: {
cerr << " found V_SgClassDef of "; // debug
SgClassDefinition *classDef = isSgClassDefinition( astNode );
assert( classDef );
SgName classname = classDef->get_qualified_name();
// make db entry
long typeId = UNKNOWNID;
typesTableAccess types( gdb );
typesRowdata newtype( typeId, getProjectId(), classname.str() );
typeId = types.retrieveCreateByColumn( &newtype, "typeName", newtype.get_typeName(), newtype.get_projectId() );
cerr << classname.str()<< ", id:" << newtype.get_id() << endl; // debug
//classhier->addNode( newtype, newtype.get_typeName() );
//classhier->insertWithName( newtype, newtype.get_typeName() );
classhier->insertVertex( newtype, newtype.get_typeName() );
SgBaseClassList inherits = classDef->get_inheritances();
for( SgBaseClassList::iterator i=inherits.begin(); i!=inherits.end(); i++) {
SgClassDeclaration *parentDecl = (*i).get_base_class();
cerr << " found inheritance from " ; // debug
assert( parentDecl );
// add new edge
typesRowdata partype( UNKNOWNID, getProjectId(), parentDecl->get_name().str() ); // MANGLE
long parentId = types.retrieveCreateByColumn( &partype, "typeName", partype.get_typeName(), partype.get_projectId() );
cerr << parentDecl->get_name().str() << ", id: " << parentId << endl;
// add to class hierarchy graph, allow only one edge per inheritance
//A classhier->addNode( partype, partype.get_typeName() );
//A classhier->addEdge( newtype, partype, false );
classhier->insertEdge( newtype, partype );
}
} break;
} // switch node type
// Note that we have to use a particular constructor (to pass on context information about source code position).
// This allows the Rewrite mechanism to position new source code relative to the current position using a simple interface.
ClasshierarchyInhAttr returnAttribute(inheritedAttribute,astNode);
// FIXME why not return inheritedAttribute???
return returnAttribute;
}
