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 }