void
ReportUnsharedDeclarationsTraversal::visit ( SgNode* node)
{
ROSE_ASSERT(node != NULL);
#if 0
printf ("ReportUnsharedDeclarationsTraversal::visit: node = %p = %s \n",node,node->class_name().c_str());
#endif
SgDeclarationStatement* declaration = isSgDeclarationStatement(node);
if (declaration != NULL)
{
bool skipTest = isSgFunctionParameterList(declaration) || isSgNamespaceDeclarationStatement(declaration) || isSgCtorInitializerList(declaration);
if (skipTest == false && declaration->get_startOfConstruct()->isShared() == false)
{
printf ("Found a declaration which is not shared declaration = %p = %s = %s \n",declaration,declaration->class_name().c_str(),SageInterface::get_name(declaration).c_str());
}
}
#if 0
SgSupport* support = isSgSupport(node);
if (support != NULL)
{
bool skipTest = !(isSgTemplateArgument(support));
if (skipTest == false && support->get_file_info()->isShared() == false)
{
printf ("Found a support IR node which is not shared = %p = %s = %s \n",support,support->class_name().c_str(),SageInterface::get_name(support).c_str());
}
}
#endif
#if 0
printf ("ReportUnsharedDeclarationsTraversal::visit(): node = %p = %s \n",node,node->class_name().c_str());
#endif
}
void
MangledNameMapTraversal::visit ( SgNode* node)
{
ROSE_ASSERT(node != NULL);
#if 0
printf ("MangledNameMapTraversal::visit: node = %s \n",node->class_name().c_str());
#endif
// Keep track of the number of IR nodes visited
numberOfNodes++;
// DQ (7/4/2010): Optimizations:
// 1) Only process each IR node once
// 2) Only process declarations that we want to share (can we be selective?).
// DQ (7/4/2010): To optimize performance, build a set of previously visited IR nodes
// so that we only test IR nodes once to add them into the mangled name map. This
// should be especially important where the AST is sharing nodes since shared nodes
// are visited multiple times (as if they were not shared).
// We need to tet if this actually optimizes the performance.
if (setOfNodesPreviouslyVisited.find(node) == setOfNodesPreviouslyVisited.end())
{
setOfNodesPreviouslyVisited.insert(node);
}
else
{
return;
}
bool sharable = shareableIRnode(node);
#if 0
printf ("MangledNameMapTraversal::visit: node = %p = %s sharable = %s \n",node,node->class_name().c_str(),sharable ? "true" : "false");
#endif
// DQ (7/10/2010): This is a test of the AST merge to investigate robustness.
#if 1
if (sharable == true)
{
// Initially we will only merge things in global scope! Then
// we will operate on namespaces! Then I think we are done!
// Basically we can simplify the problem by skipping merging of things in
// function definitions since if the function definitions are the same they
// will be merged directly.
// Keep track of the number of IR nodes that were considered sharable
numberOfNodesSharable++;
// Here is where we get much more specific about what is sharable!
switch (node->variantT())
{
// Since we abstract out the generation of the key we can simplify this code!
#if 1
// DQ (7/11/2010): This fails for tests/nonsmoke/functional/CompileTests/mergeAST_tests/mergeTest_06.C, I don't know why!
case V_SgFunctionDeclaration:
#endif
#if 1
// DQ (7/20/2010): Testing this case...
case V_SgVariableDeclaration:
case V_SgClassDeclaration:
// DQ (2/10/2007): These need to be shared (but I still see "xxxxx____Lnnnn" based names)
case V_SgTemplateInstantiationDecl:
// DQ (2/10/2007): These should be shared
case V_SgPragmaDeclaration:
case V_SgTemplateInstantiationDirectiveStatement:
case V_SgTypedefDeclaration:
case V_SgEnumDeclaration:
case V_SgTemplateDeclaration:
case V_SgUsingDeclarationStatement:
case V_SgUsingDirectiveStatement:
// DQ (2/3/2007): Added additional declarations that we should share
case V_SgMemberFunctionDeclaration:
case V_SgTemplateInstantiationFunctionDecl:
case V_SgTemplateInstantiationMemberFunctionDecl:
#endif
#if 1
// DQ (2/3/2007): Added support for symbols
case V_SgClassSymbol:
case V_SgEnumFieldSymbol:
case V_SgEnumSymbol:
case V_SgFunctionSymbol:
case V_SgMemberFunctionSymbol:
case V_SgLabelSymbol:
case V_SgNamespaceSymbol:
// DQ (2/10/2007): This case has been a problem previously
case V_SgTemplateSymbol:
case V_SgTypedefSymbol:
case V_SgVariableSymbol:
#endif
#if 0
// DQ (7/20/2010): These nodes are a problem to merge, but also not important to merge
// since they are contained within associated declarations.
// DQ (2/20/2007): Added to list so that it could be process to build the delete list
// statement fo the SgBasicBlock have to be considerd for the delete list. However,
// it is still not meaningful since we don't generate a unique name for the SgBasicBlock
// so it will never be shared.
// case V_SgBasicBlock:
case V_SgClassDefinition:
case V_SgTemplateInstantiationDefn:
case V_SgFunctionDefinition:
case V_SgVariableDefinition:
#endif
#if 1
// DQ (5/29/2006): Added support for types
case V_SgFunctionType:
case V_SgMemberFunctionType:
case V_SgModifierType:
case V_SgPointerType:
// DQ (5/29/2006): Added support for types
case V_SgClassType:
case V_SgEnumType:
case V_SgTypedefType:
// DQ (2/10/2007): Add this case
case V_SgTemplateArgument:
// DQ (3/17/2007): These should be shared, I think!
case V_SgPragma:
// DQ (5/20/2006): Initialized names are held in SgVariableDeclaration IR
// nodes or other sharable structures so we don't have to share these.
// But we have to permit them all to be shared because all pointers to
// them need to be reset they all need to be reset.
case V_SgInitializedName:
#endif
#if 1
{
// DQ (7/4/2010): To improve the performance avoid regenerating the unique name for the same IR nodes when it is revisited!
// Make the use of false in generateUniqueName() more clear. We need to
// distinguish between defining and non-defining declarations in the generation
// of unique names for the AST merge.
// string key = generateUniqueName(node,false);
bool ignoreDifferenceBetweenDefiningAndNondefiningDeclarations = false;
string key = SageInterface::generateUniqueName(node,ignoreDifferenceBetweenDefiningAndNondefiningDeclarations);
ROSE_ASSERT(key.empty() == false);
#if 1
SgDeclarationStatement* declaration = isSgDeclarationStatement(node);
if (declaration != NULL)
{
// ROSE_ASSERT(declaration->get_symbol_from_symbol_table() != NULL);
// DQ (7/4/2007): Some SgDeclarationStatement IR nodes don't have a representation
// in the symbol table (the list of SgInitializedName object have them instead).
if (isSgVariableDeclaration(declaration) == NULL &&
isSgVariableDefinition(declaration) == NULL &&
isSgUsingDeclarationStatement(declaration) == NULL &&
isSgUsingDirectiveStatement(declaration) == NULL &&
isSgTemplateInstantiationDirectiveStatement(declaration) == NULL &&
isSgPragmaDeclaration(declaration) == NULL)
{
// DQ (6/8/2010): Only do this test for non compiler generated variable...(e.g. __default_member_function_pointer_name
// is compiler generated to handle function pointers where no member function id specified).
if (declaration->get_startOfConstruct()->isCompilerGenerated() == false)
{
SgSymbol* symbol = declaration->search_for_symbol_from_symbol_table();
if (symbol == NULL)
{
// Output more information to support debugging!
printf ("declaration = %p = %s = %s \n",declaration,declaration->class_name().c_str(),SageInterface::get_name(declaration).c_str());
SgScopeStatement* scope = declaration->get_scope();
ROSE_ASSERT(scope != NULL);
printf (" scope = %p = %s = %s \n",scope,scope->class_name().c_str(),SageInterface::get_name(scope).c_str());
declaration->get_startOfConstruct()->display("declaration->search_for_symbol_from_symbol_table() == NULL");
}
ROSE_ASSERT(symbol != NULL);
}
}
#if 0
// DQ (6/23/2010): Added the base type of the typedef
SgTypedefDeclaration* typedefDeclaration = isSgTypedefDeclaration(declaration);
if (typedefDeclaration != NULL)
{
}
#endif
}
#endif
addToMap(key,node);
// Keep track of the number of IR nodes that were evaluated for mangled name matching
numberOfNodesEvaluated++;
break;
}
#endif
default:
{
// Nothing to do here
}
}
}
#endif
}