void
CompassAnalyses::StaticConstructorInitialization::Traversal::
visit(SgNode* node)
{
// Test for static initialization of variables of type class, such initializations where they are
// static or appear in global scope can be called in an order dependent upon the compiler and this
// can lead to subtle bugs in large scale applications.
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(node);
if (variableDeclaration != NULL)
{
SgInitializedNamePtrList::iterator i = variableDeclaration->get_variables().begin();
while (i != variableDeclaration->get_variables().end())
{
SgInitializedName* initializedName = *i;
// Check the type and see if it is a class (check for typedefs too)
SgType* variableType = initializedName->get_type();
SgClassType *classType = isSgClassType(variableType);
if (classType != NULL)
{
// Now check if this is a global or namespace variable or an static class member
// This might also have to be a test for other scopes as well.
SgScopeStatement* scope = variableDeclaration->get_scope();
if (isSgGlobal(scope) != NULL || isSgNamespaceDefinitionStatement(scope) != NULL)
{
// printf ("Found a global variable defining a class = %p \n",initializedName);
// variableDeclaration->get_file_info()->display("global variable defining a class");
output->addOutput(new CheckerOutput(initializedName));
}
if (isSgClassDefinition(scope) != NULL)
{
// Now check if it is a static data member
if (variableDeclaration->get_declarationModifier().get_storageModifier().isStatic() == true)
{
// printf ("Found a static data member defining a class = %p \n",initializedName);
// variableDeclaration->get_file_info()->display("static data member defining a class");
output->addOutput(new CheckerOutput(initializedName));
}
}
}
// increment though the variables in the declaration (typically just one)
i++;
}
}
} //End of the visit function.
void
Traversal::visit(SgNode* node)
{
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(node);
// Look for variable declarations appearing in global scope!
// if (variableDeclaration != NULL && isSgGlobal(variableDeclaration->get_parent()) != NULL)
if (variableDeclaration != NULL)
{
SgInitializedNamePtrList::iterator i = variableDeclaration->get_variables().begin();
while (i != variableDeclaration->get_variables().end())
{
SgInitializedName* initializedName = *i;
// Check the type and see if it is a class (check for typedefs too)
SgType* variableType = initializedName->get_type();
SgClassType *classType = isSgClassType(variableType);
if (classType != NULL)
{
// Now check if this is a global variable or an static class member
SgScopeStatement* scope = variableDeclaration->get_scope();
if (isSgGlobal(scope) != NULL)
{
printf ("Found a global variable defining a class \n");
// variableDeclaration->get_file_info()->display("global variable defining a class");
outputPositionInformation(variableDeclaration);
}
if (isSgClassDefinition(scope) != NULL)
{
// Now check if it is a static data member
if (variableDeclaration->get_declarationModifier().get_storageModifier().isStatic() == true)
{
printf ("Found a static data member defining a class \n");
// variableDeclaration->get_file_info()->display("static data member defining a class");
outputPositionInformation(variableDeclaration);
}
}
}
// increment though the variables in the declaration (typically just one)
i++;
}
}
}
void
FixupTemplateArguments::visit ( SgNode* node )
{
ROSE_ASSERT(node != NULL);
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(node);
if (variableDeclaration != NULL)
{
// Check the type of the variable declaration, and any template arguments if it is a template type with template arguments.
// SgType* type = variableDeclaration->get_type();
// ROSE_ASSERT(type != NULL);
SgInitializedName* initializedName = SageInterface::getFirstInitializedName(variableDeclaration);
ROSE_ASSERT(initializedName != NULL);
SgType* type = initializedName->get_type();
ROSE_ASSERT(type != NULL);
#if 0
printf ("\n**************************************************************************** \n");
printf ("FixupTemplateArguments::visit(): variableDeclaration = %p = %s initializedName = %s \n",variableDeclaration,variableDeclaration->class_name().c_str(),initializedName->get_name().str());
printf (" --- type = %p = %s \n",type,type->class_name().c_str());
string filename = initializedName->get_file_info()->get_filename();
int linenumber = initializedName->get_file_info()->get_line();
printf (" --- filename = %s line = %d \n",filename.c_str(),linenumber);
#endif
SgScopeStatement* targetScope = variableDeclaration->get_scope();
ROSE_ASSERT(targetScope != NULL);
#if 0
printf ("In FixupTemplateArguments::visit(): targetScope for variableDeclaration = %p = %s \n",targetScope,targetScope->class_name().c_str());
#endif
// DQ (2/16/2017): Don't process code in template instantiations.
SgTemplateInstantiationDefn* templateInstantiationDefn = isSgTemplateInstantiationDefn(targetScope);
SgFunctionDeclaration* functionDeclaration = TransformationSupport::getFunctionDeclaration(targetScope);
SgTemplateInstantiationFunctionDecl* templateInstantiationFunctionDec = isSgTemplateInstantiationFunctionDecl(functionDeclaration);
SgTemplateInstantiationMemberFunctionDecl* templateInstantiationMemberFunctionDec = isSgTemplateInstantiationMemberFunctionDecl(functionDeclaration);
// if (templateInstantiationDefn == NULL)
if (templateInstantiationDefn == NULL && templateInstantiationFunctionDec == NULL && templateInstantiationMemberFunctionDec == NULL)
{
#if 1
// DQ (2/15/2017): When this is run, we cause transformations that cause ROSE to have an infinte loop.
// Since this is a second (redundant) invocaion, we likely should just not run this. But it is not
// clear if this truely fixes the problem that I am seeing.
bool result = contains_private_type(type,targetScope);
// DQ (3/25/2017): Added a trivial use to eliminate Clang warning about the return value not being used.
// But it might be that we should not run the function, however this is a complex subject from last month
// that I don't wish to revisit at the moment while being focused om eliminating warnings from Clang.
ROSE_ASSERT(result == true || result == false);
#endif
#if 0
if (result == true)
{
printf ("******** contains private type: variableDeclaration = %p = %s initializedName = %s \n",variableDeclaration,variableDeclaration->class_name().c_str(),initializedName->get_name().str());
}
#endif
}
#if 0
printf ("DONE: FixupTemplateArguments::visit(): variableDeclaration = %p = %s initializedName = %s \n",variableDeclaration,variableDeclaration->class_name().c_str(),initializedName->get_name().str());
#endif
#if 0
printf ("Exiting as a test! \n");
ROSE_ASSERT(false);
#endif
}
}
SgVariableSymbol*
putGlobalVariablesIntoClass (Rose_STL_Container<SgInitializedName*> & globalVariables, SgClassDeclaration* classDeclaration )
{
// This function iterates over the list of global variables and inserts them into the iput class definition
SgVariableSymbol* globalClassVariableSymbol = NULL;
for (Rose_STL_Container<SgInitializedName*>::iterator var = globalVariables.begin(); var != globalVariables.end(); var++)
{
// printf ("Appending global variable = %s to new globalVariableContainer \n",(*var)->get_name().str());
SgVariableDeclaration* globalVariableDeclaration = isSgVariableDeclaration((*var)->get_parent());
assert(globalVariableDeclaration != NULL);
// Get the global scope from the global variable directly
SgGlobal* globalScope = isSgGlobal(globalVariableDeclaration->get_scope());
assert(globalScope != NULL);
if (var == globalVariables.begin())
{
// This is the first time in this loop, replace the first global variable with
// the class declaration/definition containing all the global variables!
// Note that initializers in the global variable declarations require modification
// of the preinitialization list in the class's constructor! I am ignoring this for now!
globalScope->replace_statement(globalVariableDeclaration,classDeclaration);
// Build source position informaiton (marked as transformation)
Sg_File_Info* fileInfo = Sg_File_Info::generateDefaultFileInfoForTransformationNode();
assert(fileInfo != NULL);
// Add the variable of the class type to the global scope!
SgClassType* variableType = new SgClassType(classDeclaration->get_firstNondefiningDeclaration());
assert(variableType != NULL);
SgVariableDeclaration* variableDeclaration = new SgVariableDeclaration(fileInfo,"AMPI_globals",variableType);
assert(variableDeclaration != NULL);
globalScope->insert_statement(classDeclaration,variableDeclaration,false);
assert(variableDeclaration->get_variables().empty() == false);
SgInitializedName* variableName = *(variableDeclaration->get_variables().begin());
assert(variableName != NULL);
// DQ (9/8/2007): Need to set the scope of the new variable.
variableName->set_scope(globalScope);
// build the return value
globalClassVariableSymbol = new SgVariableSymbol(variableName);
// DQ (9/8/2007): Need to add the symbol to the global scope (new testing requires this).
globalScope->insert_symbol(variableName->get_name(),globalClassVariableSymbol);
ROSE_ASSERT(globalScope->lookup_variable_symbol(variableName->get_name()) != NULL);
}
else
{
// for all other iterations of this loop ...
// remove variable declaration from the global scope
globalScope->remove_statement(globalVariableDeclaration);
}
// add the variable declaration to the class definition
classDeclaration->get_definition()->append_member(globalVariableDeclaration);
}
return globalClassVariableSymbol;
}