void FixupTypesTraversal::visit ( SgNode* node) { ROSE_ASSERT(node != NULL); // printf ("FixupTypesTraversal::visit: node = %p = %s \n",node,node->class_name().c_str()); SgDeclarationStatement* declaration = isSgDeclarationStatement(node); if (declaration != NULL) { #if 0 printf ("FixupTypesTraversal::visit: declaration = %p = %s \n",declaration,declaration->class_name().c_str()); #endif NormalizeTypesTraversal::DeclarationTypeMultiMapType::iterator lowerBound = declarationTypeMultiMap.lower_bound(declaration); NormalizeTypesTraversal::DeclarationTypeMultiMapType::iterator upperBound = declarationTypeMultiMap.upper_bound(declaration); // Increment the upperBound just past the end // if (upperBound != declarationTypeMultiMap.end()) // upperBound++; // if ( lowerBound != declarationTypeMultiMap.end() ) #if 0 if ( upperBound != declarationTypeMultiMap.end() && (lowerBound != upperBound) ) { while (lowerBound != upperBound) { printf ("loop: lowerBound = %p = %s \n",lowerBound->second,lowerBound->second->class_name().c_str()); lowerBound++; } if (upperBound != declarationTypeMultiMap.end()) printf ("end: upperBound = %p = %s \n",upperBound->second,upperBound->second->class_name().c_str()); } #endif // if ( upperBound != declarationTypeMultiMap.end() && (lowerBound != upperBound) ) // if ( upperBound != declarationTypeMultiMap.end() ) NormalizeTypesTraversal::DeclarationTypeMultiMapType::iterator i = lowerBound; if ( i != declarationTypeMultiMap.end() ) { // There must be at least two reference to what we want to be a shared type // printf ("end: upperBound = %p = %s \n",upperBound->second,upperBound->second->class_name().c_str()); // printf ("loop: lowerBound = %p = %s \n",lowerBound->second,lowerBound->second->class_name().c_str()); while (i != upperBound) { #if 0 printf ("loop: i = %p = %s \n",i->second,i->second->class_name().c_str()); #endif i++; } } } }
int main(int argc, char* argv[]) { SgProject* proj = frontend(argc,argv); SgFunctionDeclaration* mainDecl = SageInterface::findMain(proj); SgFunctionDefinition* mainDef = mainDecl->get_definition(); // std::vector<SgNode*> dotExps = NodeQuery::querySubTree(mainDef, V_SgDotExp); std::vector<SgNode*> varRefs = NodeQuery::querySubTree(mainDef,V_SgVarRefExp); int classExps = 0; for (unsigned int i = 0; i < varRefs.size(); i++) { if (isSgClassType(isSgVarRefExp(varRefs[i])->get_type())) { SgClassType* ct = isSgClassType(isSgVarRefExp(varRefs[i])->get_type()); std::cout << "name of ref: " << isSgVarRefExp(varRefs[i])->get_symbol()->get_name().getString() << std::endl; if (SageInterface::isStructType(ct)) { SgDeclarationStatement* decl = isSgType(ct)->getAssociatedDeclaration(); SgDeclarationStatement* defining_decl = decl->get_definingDeclaration(); if (!(defining_decl->isNameOnly())) { if (isSgClassDeclaration(defining_decl)) { if (isSgClassDeclaration(defining_decl)->get_definition()) { SgDeclarationStatementPtrList member_stats = isSgClassDeclaration(defining_decl)->get_definition()->get_members(); SgDeclarationStatementPtrList::iterator j = member_stats.begin(); for (; j != member_stats.end(); j++) { SgDeclarationStatement* d = isSgDeclarationStatement(*j); std::cout << "decl stat name: " << d->class_name() << std::endl; SgInitializedNamePtrList init_lst = isSgVariableDeclaration(d)->get_variables(); SgInitializedNamePtrList::iterator k = init_lst.begin(); std::cout << "variables in initialized name ptr list..." << std::endl; for (; k != init_lst.end(); k++) { std::cout << isSgInitializedName(*k)->get_name().getString() << std::endl; std::cout << isSgInitializedName(*k)->get_type()->class_name() << std::endl; } } classExps+=1; } } } } } } std::cout << "num class_exp: " << classExps << std::endl; return 0; }
void FixupAstSymbolTables::visit ( SgNode* node ) { // DQ (6/27/2005): Output the local symbol table from each scope. // printf ("node = %s \n",node->sage_class_name()); SgScopeStatement* scope = isSgScopeStatement(node); if (scope != NULL) { #if 0 printf ("AST Fixup: Fixup Symbol Table for %p = %s at: \n",scope,scope->class_name().c_str()); #endif SgSymbolTable* symbolTable = scope->get_symbol_table(); if (symbolTable == NULL) { #if 0 printf ("AST Fixup: Fixup Symbol Table for %p = %s at: \n",scope,scope->class_name().c_str()); scope->get_file_info()->display("Symbol Table Location"); #endif SgSymbolTable* tempSymbolTable = new SgSymbolTable(); ROSE_ASSERT(tempSymbolTable != NULL); // name this table as compiler generated! The name is a static member used to store // state for the next_symbol() functions. It is meaningless to set these. // tempSymbolTable->set_name("compiler-generated symbol table"); scope->set_symbol_table(tempSymbolTable); // reset the symbolTable using the get_symbol_table() member function symbolTable = scope->get_symbol_table(); ROSE_ASSERT(symbolTable != NULL); // DQ (2/16/2006): Set this parent directly (now tested) symbolTable->set_parent(scope); ROSE_ASSERT(symbolTable->get_parent() != NULL); } ROSE_ASSERT(symbolTable != NULL); if (symbolTable->get_parent() == NULL) { printf ("Warning: Fixing up symbolTable, calling symbolTable->set_parent() (parent not previously set) \n"); symbolTable->set_parent(scope); } ROSE_ASSERT(symbolTable->get_parent() != NULL); // Make sure that the internal hash table used in the symbol table is also present! if (symbolTable->get_table() == NULL) { // DQ (6/27/2005): There are a lot of these built, perhaps more than we really need! #if 0 printf ("AST Fixup: Building internal Symbol Table hash table (rose_hash_multimap) for %p = %s at: \n", scope,scope->sage_class_name()); scope->get_file_info()->display("Symbol Table Location"); #endif rose_hash_multimap* internalHashTable = new rose_hash_multimap(); ROSE_ASSERT(internalHashTable != NULL); symbolTable->set_table(internalHashTable); } ROSE_ASSERT(symbolTable->get_table() != NULL); SgSymbolTable::BaseHashType* internalTable = symbolTable->get_table(); ROSE_ASSERT(internalTable != NULL); // DQ (6/23/2011): Note: Declarations that reference types that have not been seen yet may be placed into the // wronge scope, then later when we see the correct scope we have a symbol in two or more symbol tables. The // code below detects and fixes this problem. // DQ (6/16/2011): List of symbols we need to remove from symbol tables where they are multibily represented. std::vector<SgSymbol*> listOfSymbolsToRemove; // DQ (6/12/2011): Fixup symbol table by removing symbols that are not associated with a declaration in the current scope. int idx = 0; SgSymbolTable::hash_iterator i = internalTable->begin(); while (i != internalTable->end()) { // DQ: removed SgName casting operator to char* // cout << "[" << idx << "] " << (*i).first.str(); ROSE_ASSERT ( (*i).first.str() != NULL ); ROSE_ASSERT ( isSgSymbol( (*i).second ) != NULL ); // printf ("Symbol number: %d (pair.first (SgName) = %s) pair.second (SgSymbol) sage_class_name() = %s \n", // idx,(*i).first.str(),(*i).second->sage_class_name()); SgSymbol* symbol = isSgSymbol((*i).second); ROSE_ASSERT ( symbol != NULL ); // We have to look at each type of symbol separately! This is because there is no virtual function, // the reason for this is that each get_declaration() function returns a different type! // ROSE_ASSERT ( symbol->get_declaration() != NULL ); switch(symbol->variantT()) { case V_SgClassSymbol: { SgClassSymbol* classSymbol = isSgClassSymbol(symbol); ROSE_ASSERT(classSymbol != NULL); ROSE_ASSERT(classSymbol->get_declaration() != NULL); SgDeclarationStatement* declarationToFindInScope = NULL; // Search for the declaration in the associated scope. declarationToFindInScope = classSymbol->get_declaration(); ROSE_ASSERT(declarationToFindInScope != NULL); SgClassDeclaration* classDeclaration = isSgClassDeclaration(declarationToFindInScope); ROSE_ASSERT(classDeclaration != NULL); SgName name = classDeclaration->get_name(); // SgType* declarationType = declarationToFindInScope->get_type(); SgType* declarationType = classDeclaration->get_type(); ROSE_ASSERT(declarationType != NULL); if (declarationToFindInScope->get_definingDeclaration() != NULL) { declarationToFindInScope = declarationToFindInScope->get_definingDeclaration(); SgClassDeclaration* definingClassDeclaration = isSgClassDeclaration(declarationToFindInScope); ROSE_ASSERT(definingClassDeclaration != NULL); // SgType* definingDeclarationType = declarationToFindInScope->get_type(); SgType* definingDeclarationType = definingClassDeclaration->get_type(); ROSE_ASSERT(definingDeclarationType != NULL); // DQ (6/22/2011): This assertion fails for CompileTests/copyAST_tests/copytest2007_24.C // A simple rule that all declarations should follow (now that we have proper global type tables). // ROSE_ASSERT(definingDeclarationType == declarationType); if (definingDeclarationType != declarationType) { printf ("In fixupSymbolTables.C: Note that definingDeclarationType != declarationType \n"); } } SgNamedType* namedType = isSgNamedType(declarationType); ROSE_ASSERT(namedType != NULL); SgDeclarationStatement* declarationAssociatedToType = namedType->get_declaration(); ROSE_ASSERT(declarationAssociatedToType != NULL); #if 0 printf ("Found a symbol without a matching declaration in the current scope (declList): declarationToFindInScope = %p = %s \n",declarationToFindInScope,declarationToFindInScope->class_name().c_str()); printf ("Symbol number: %d (pair.first (SgName) = %s) pair.second (SgSymbol) class_name() = %s \n",idx,(*i).first.str(),(*i).second->class_name().c_str()); #endif SgScopeStatement* scopeOfDeclarationToFindInScope = declarationToFindInScope->get_scope(); SgScopeStatement* scopeOfDeclarationAssociatedWithType = declarationAssociatedToType->get_scope(); #if 0 printf ("declarationToFindInScope = %p declarationToFindInScope->get_scope() = %p = %s \n",declarationToFindInScope,declarationToFindInScope->get_scope(),declarationToFindInScope->get_scope()->class_name().c_str()); printf ("declarationAssociatedToType = %p declarationAssociatedToType->get_scope() = %p = %s \n",declarationAssociatedToType,declarationAssociatedToType->get_scope(),declarationAssociatedToType->get_scope()->class_name().c_str()); #endif if (scopeOfDeclarationToFindInScope != scopeOfDeclarationAssociatedWithType) { // DQ (6/12/2011): Houston, we have a problem! The trick is to fix it... // A symbol has been placed into a scope when we could not be certain which scope it should be placed. // We have a default of placing such symbols into the global scope, but it might be better to just have // a special scope where such symbols could be placed so that we could have them separate from the global // scope and then fix them up more clearly. // Note that test2011_80.C still fails but the AST is at least correct (I think). SgGlobal* scopeOfDeclarationToFindInScope_GlobalScope = isSgGlobal(scopeOfDeclarationToFindInScope); // SgGlobal* scopeOfDeclarationAssociatedWithType_GlobalScope = isSgGlobal(scopeOfDeclarationAssociatedWithType); if (scopeOfDeclarationToFindInScope_GlobalScope != NULL) { // In general which ever scope is the global scope is where the error is...??? // This is because when we don't know where to put a symbol (e.g. from a declaration of a pointer) we put it into global scope. // There is even an agrument that this is correct as a default for C/C++, but only if it must exist (see test2011_80.C). // Remove the symbol from the symbol table of the global scope. printf ("Remove the associated symbol in the current symbol table \n"); // DQ (6/22/2011): This assertion fails for CompileTests/copyAST_tests/copytest2007_24.C // ROSE_ASSERT (declarationToFindInScope->get_scope() == declarationAssociatedToType->get_scope()); if (declarationToFindInScope->get_scope() != declarationAssociatedToType->get_scope()) printf ("In fixupSymbolTables.C: Note that declarationToFindInScope->get_scope() != declarationAssociatedToType->get_scope() \n"); } else { listOfSymbolsToRemove.push_back(classSymbol); } } // ROSE_ASSERT (declarationToFindInScope->get_scope() == declarationAssociatedToType->get_scope()); break; } default: { // It night be there are are no other types of symbols to consider... // printf ("Ignoring non SgClassSymbols (fixupSymbolTables.C) symbol = %s \n",symbol->class_name().c_str()); // ROSE_ASSERT(false); } } // Increment iterator! i++; // Increment counter! idx++; } // DQ (6/18/2011): Now that we are through with the symbol table we can support removal of any // identified problematic symbol without worrying about STL iterator invalidation. for (size_t j = 0; j < listOfSymbolsToRemove.size(); j++) { // Remove these symbols. SgSymbol* removeSymbol = listOfSymbolsToRemove[j]; ROSE_ASSERT(removeSymbol != NULL); SgSymbolTable* associatedSymbolTable = isSgSymbolTable(removeSymbol->get_parent()); ROSE_ASSERT(associatedSymbolTable != NULL); ROSE_ASSERT(associatedSymbolTable == symbolTable); associatedSymbolTable->remove(removeSymbol); printf ("Redundant symbol removed...from symbol table \n"); // ROSE_ASSERT(false); } #if 0 // debugging symbolTable->print("In FixupAstSymbolTables::visit(): printing out the symbol tables"); #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 }
void fixupAstDeclarationScope( SgNode* node ) { // This function was designed to fixup what I thought were inconsistancies in how the // defining and some non-defining declarations associated with friend declarations had // their scope set. I now know this this was not a problem, but it is helpful to enforce the // consistancy. It might also be useful to process declarations with scopes set to // namespace definitions, so that the namespace definition can be normalized to be // consistant across all of the different re-entrant namespace definitions. This is // possible within the new namespace support in ROSE. TimingPerformance timer ("Fixup declaration scopes:"); // This simplifies how the traversal is called! FixupAstDeclarationScope astFixupTraversal; // DQ (1/29/2007): This traversal now uses the memory pool (so that we will visit declaration hidden in types (e.g. SgClassType) // SgClassType::traverseMemoryPoolNodes(v); astFixupTraversal.traverseMemoryPool(); // Now process the map of sets of declarations. std::map<SgDeclarationStatement*,std::set<SgDeclarationStatement*>* > & mapOfSets = astFixupTraversal.mapOfSets; #if 0 printf ("In fixupAstDeclarationScope(): mapOfSets.size() = %" PRIuPTR " \n",mapOfSets.size()); #endif std::map<SgDeclarationStatement*,std::set<SgDeclarationStatement*>* >::iterator i = mapOfSets.begin(); while (i != mapOfSets.end()) { SgDeclarationStatement* firstNondefiningDeclaration = i->first; // DQ (3/2/2015): Added assertion. ROSE_ASSERT(firstNondefiningDeclaration != NULL); // DQ (3/2/2015): Added assertion. ROSE_ASSERT(firstNondefiningDeclaration->get_firstNondefiningDeclaration() != NULL); // DQ (3/2/2015): Make this assertion a warning: fails in outlining example seq7a_test2006_78.C. // ROSE_ASSERT(firstNondefiningDeclaration == firstNondefiningDeclaration->get_firstNondefiningDeclaration()); if (firstNondefiningDeclaration != firstNondefiningDeclaration->get_firstNondefiningDeclaration()) { printf ("WARNING: In fixupAstDeclarationScope(): firstNondefiningDeclaration != firstNondefiningDeclaration->get_firstNondefiningDeclaration() \n"); printf (" --- firstNondefiningDeclaration = %p = %s \n", firstNondefiningDeclaration,firstNondefiningDeclaration->class_name().c_str()); printf (" --- firstNondefiningDeclaration->get_firstNondefiningDeclaration() = %p = %s \n", firstNondefiningDeclaration->get_firstNondefiningDeclaration(),firstNondefiningDeclaration->get_firstNondefiningDeclaration()->class_name().c_str()); } SgScopeStatement* correctScope = firstNondefiningDeclaration->get_scope(); ROSE_ASSERT(correctScope != NULL); #if 0 printf ("In FixupAstDeclarationScope::visit(): node = %p = %s firstNondefiningDeclaration = %p correctScope = %p = %s \n",node,node->class_name().c_str(),firstNondefiningDeclaration,correctScope,correctScope->class_name().c_str()); #endif std::set<SgDeclarationStatement*>* declarationSet = i->second; ROSE_ASSERT(declarationSet != NULL); #if 0 printf ("In fixupAstDeclarationScope(): mapOfSets[%p]->size() = %" PRIuPTR " \n",firstNondefiningDeclaration,mapOfSets[firstNondefiningDeclaration]->size()); #endif std::set<SgDeclarationStatement*>::iterator j = declarationSet->begin(); while (j != declarationSet->end()) { SgScopeStatement* associatedScope = (*j)->get_scope(); ROSE_ASSERT(associatedScope != NULL); // DQ (6/11/2013): This is triggered by namespace definition scopes that are different // due to re-entrant namespace declarations. We should maybe fix this. // TV (7/22/13): This is also triggered when for global scope accross files. if (associatedScope != correctScope) { // DQ (1/30/2014): Cleaning up some output spew. if (SgProject::get_verbose() > 0) { mprintf ("WARNING: This is the wrong scope (declaration = %p = %s): associatedScope = %p = %s correctScope = %p = %s \n", *j,(*j)->class_name().c_str(),associatedScope,associatedScope->class_name().c_str(),correctScope,correctScope->class_name().c_str()); } #if 0 printf ("Make this an error for now! \n"); ROSE_ASSERT(false); #endif } j++; } i++; } #if 0 printf ("Leaving fixupAstDeclarationScope() node = %p = %s \n",node,node->class_name().c_str()); #endif }
void FixupAstDeclarationScope::visit ( SgNode* node ) { // DQ (6/11/2013): This corrects where EDG can set the scope of a friend declaration to be different from the defining declaration. // We need it to be a rule in ROSE that the scope of the declarations are consistant between defining and all non-defining declaration). #if 0 printf ("In FixupAstDeclarationScope::visit(node = %p = %s) \n",node,node->class_name().c_str()); #endif SgDeclarationStatement* declaration = isSgDeclarationStatement(node); if (declaration != NULL) { // SgDeclarationStatement* definingDeclaration = declaration->get_definingDeclaration(); SgDeclarationStatement* firstNondefiningDeclaration = declaration->get_firstNondefiningDeclaration(); // Note that these declarations don't follow the same rules (namely the get_firstNondefiningDeclaration() can be NULL). if ( isSgFunctionParameterList(node) != NULL || isSgVariableDefinition(node) != NULL) { #if 0 printf ("In FixupAstDeclarationScope::visit(): node = %p = %s firstNondefiningDeclaration = %p (skipping this processing) \n",node,node->class_name().c_str(),firstNondefiningDeclaration); #endif } else { // DQ (6/15/2013): The older tutorial examples demonstrate addition of new functions using older rules that allows // there to not be a non-defining declaration. We need to remove these tutrial example in favor of the AST builder // API to build functions that will follow the newer AST constistancy rules. Until we do this work in the tutorial // we can't inforce this below else the older tutorial examples (e.g. addFunctionDeclaration.C) will fail. So I will // allow this for now and output a warning when (firstNondefiningDeclaration == NULL). // ROSE_ASSERT(firstNondefiningDeclaration != NULL); if (firstNondefiningDeclaration == NULL) { printf ("WARNING: In FixupAstDeclarationScope::visit(): firstNondefiningDeclaration == NULL for case of node = %p = %s (allowed for tutorial example transformations only) \n",node,node->class_name().c_str()); } else { if (mapOfSets.find(firstNondefiningDeclaration) == mapOfSets.end()) { std::set<SgDeclarationStatement*>* new_empty_set = new std::set<SgDeclarationStatement*>(); ROSE_ASSERT(new_empty_set != NULL); #if 0 printf ("In FixupAstDeclarationScope::visit(): Adding a set of declarations to the mapOfSets: new_empty_set = %p \n",new_empty_set); #endif // DQ (3/2/2015): Added assertion. ROSE_ASSERT(firstNondefiningDeclaration != NULL); mapOfSets.insert(std::pair<SgDeclarationStatement*,std::set<SgDeclarationStatement*>*>(firstNondefiningDeclaration,new_empty_set)); } ROSE_ASSERT(mapOfSets.find(firstNondefiningDeclaration) != mapOfSets.end()); // DQ (3/2/2015): Added assertion. ROSE_ASSERT(declaration != NULL); #if 0 printf ("In FixupAstDeclarationScope::visit(): Adding a declaration = %p = %s to a specific set in the mapOfSets: mapOfSets[firstNondefiningDeclaration=%p] = %p \n", declaration,declaration->class_name().c_str(),firstNondefiningDeclaration,mapOfSets[firstNondefiningDeclaration]); printf (" --- declaration->get_firstNondefiningDeclaration() = %p \n",declaration->get_firstNondefiningDeclaration()); #endif // DQ (3/2/2015): Added assertion. // ROSE_ASSERT(declaration == declaration->get_firstNondefiningDeclaration()); // mapOfSets[firstNondefiningDeclaration]->insert(firstNondefiningDeclaration); mapOfSets[firstNondefiningDeclaration]->insert(declaration); } } } }
string nodeColor( SgStatement* statement ) { /* color: colorCode:red:on color: colorCode:orange:on color: colorCode:yellow:on color: colorCode:blue:on color: colorCode:green:on color: colorCode:violet:on color: colorCode:brown:on color: colorCode:purple:on color: colorCode:lightblue:on color: colorCode:lightgreen:on color: colorCode:lightred:on color: colorCode:black:on color: colorCode:darkblue:on color: colorCode:grey:on color: colorCode:darkgrey:on color: colorCode:olivegreen:on color: colorCode:darkgreen:on */ string returnString; SgDeclarationStatement* declarationStatement = isSgDeclarationStatement(statement); if (declarationStatement != NULL) { switch (declarationStatement->variantT()) { case V_SgFunctionDeclaration: case V_SgMemberFunctionDeclaration: case V_SgTemplateInstantiationFunctionDecl: case V_SgTemplateInstantiationMemberFunctionDecl: returnString = "orange"; break; case V_SgClassDeclaration: case V_SgTemplateInstantiationDecl: returnString = "yellow"; break; case V_SgAsmStmt: case V_SgCtorInitializerList: case V_SgEnumDeclaration: case V_SgFunctionParameterList: case V_SgNamespaceAliasDeclarationStatement: case V_SgNamespaceDeclarationStatement: case V_SgPragmaDeclaration: case V_SgTemplateDeclaration: case V_SgTemplateInstantiationDirectiveStatement: case V_SgTypedefDeclaration: case V_SgUsingDeclarationStatement: case V_SgUsingDirectiveStatement: case V_SgVariableDeclaration: case V_SgVariableDefinition: returnString = "lightred"; break; // DQ (11/11/2012): Added support for newer IR nodes in edg4x work. case V_SgTemplateMemberFunctionDeclaration: case V_SgTemplateClassDeclaration: case V_SgTemplateFunctionDeclaration: case V_SgTemplateVariableDeclaration: returnString = "red"; break; default: returnString = "ERROR DEFAULT REACHED"; printf ("Default reached in nodeColor() exiting ... (%s) \n",declarationStatement->class_name().c_str()); ROSE_ASSERT(false); break; } } SgScopeStatement* scopeStatement = isSgScopeStatement(statement); if (scopeStatement != NULL) { switch (scopeStatement->variantT()) { case V_SgBasicBlock: returnString = "lightblue"; break; case V_SgClassDefinition: returnString = "lightblue"; break; case V_SgTemplateInstantiationDefn: case V_SgFunctionDefinition: returnString = "lightblue"; break; case V_SgWhileStmt: case V_SgDoWhileStmt: case V_SgForStatement: returnString = "darkblue"; break; case V_SgGlobal: case V_SgIfStmt: case V_SgNamespaceDefinitionStatement: case V_SgSwitchStatement: case V_SgCatchOptionStmt: returnString = "black"; break; // DQ (11/11/2012): Added support for newer IR nodes in edg4x work. case V_SgTemplateClassDefinition: case V_SgTemplateFunctionDefinition: returnString = "red"; break; default: returnString = "ERROR DEFAULT REACHED"; printf ("Default reached in nodeColor() exiting ... (%s) \n",scopeStatement->class_name().c_str()); ROSE_ASSERT(false); break; } } if (scopeStatement == NULL && declarationStatement == NULL) { switch (statement->variantT()) { case V_SgExprStatement: returnString = "violet"; break; case V_SgBreakStmt: case V_SgCaseOptionStmt: case V_SgCatchStatementSeq: case V_SgContinueStmt: case V_SgDefaultOptionStmt: case V_SgClinkageStartStatement: case V_SgForInitStatement: case V_SgFunctionTypeTable: case V_SgGotoStatement: case V_SgLabelStatement: case V_SgNullStatement: case V_SgReturnStmt: case V_SgSpawnStmt: case V_SgTryStmt: case V_SgVariantStatement: returnString = "brown"; break; default: returnString = "ERROR DEFAULT REACHED"; printf ("Default reached in nodeColor() exiting ... (%s) \n",statement->class_name().c_str()); ROSE_ASSERT(false); break; } } return returnString; }
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 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 }
IntermediateRepresentationNodeGraph::IntermediateRepresentationNodeGraph(ofstream & inputFile, SgProject* project, const std::vector<VariantT> & inputNodeKindList) : file(inputFile), nodeKindList(inputNodeKindList) { for (size_t i = 0; i < nodeKindList.size(); i++) { printf ("Adding nodeKindList[%" PRIuPTR "] = %d = %s to nodeKindSet \n",i,Cxx_GrammarTerminalNames[nodeKindList[i]].variant,Cxx_GrammarTerminalNames[nodeKindList[i]].name.c_str()); include_nodeKindSet.insert(nodeKindList[i]); } // Build a list of functions within the AST // Rose_STL_Container<SgNode*> functionDeclarationList = NodeQuery::querySubTree (project,V_SgFunctionDeclaration); // Rose_STL_Container<SgNode*> functionDeclarationList = NodeQuery::querySubTree (project,V_SgDeclarationStatement); Rose_STL_Container<SgNode*> functionDeclarationList = NodeQuery::querySubTree (project,V_SgStatement); // include_nodeSet.insert(functionDeclarationList.begin(),functionDeclarationList.end()); int maxNumberOfNodes = 5000; int numberOfNodes = (int)functionDeclarationList.size(); printf ("Number of IR nodes in IntermediateRepresentationNodeGraph = %d \n",numberOfNodes); #if 1 int counter = 0; for (Rose_STL_Container<SgNode*>::iterator i = functionDeclarationList.begin(); i != functionDeclarationList.end(); i++) { SgStatement* statement = isSgStatement(*i); SgDeclarationStatement* declaration = isSgDeclarationStatement(*i); SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(*i); SgTemplateInstantiationFunctionDecl* templateInstantiationFunctionDeclaration = isSgTemplateInstantiationFunctionDecl(*i); // if (declaration != NULL && declaration->get_file_info()->isCompilerGenerated() == false) if (statement != NULL && statement->get_file_info()->isCompilerGenerated() == false) { include_nodeSet.insert(statement); } if (templateInstantiationFunctionDeclaration != NULL) { include_nodeSet.insert(statement); } #if 0 // Build a pointer to the current type so that we can call the get_name() member function. SgFunctionDeclaration* functionDeclaration = isSgFunctionDeclaration(*i); if (functionDeclaration != NULL) { // DQ (3/5/2006): Only output the non-compiler generated IR nodes if ( (*i)->get_file_info()->isCompilerGenerated() == false) { // output the function number and the name of the function printf ("Function #%2d name is %s at line %d \n",counter++,functionDeclaration->get_name().str(),functionDeclaration->get_file_info()->get_line()); } else { // Output something about the compiler-generated builtin functions printf ("Compiler-generated (builtin) function #%2d name is %s \n",counter++,functionDeclaration->get_name().str()); } } else { SgDeclarationStatement* declaration = isSgDeclarationStatement(*i); ROSE_ASSERT(declaration != NULL); printf ("--- declaration #%2d is: %p = %s \n",counter++,declaration,declaration->class_name().c_str()); } #endif } #endif if (numberOfNodes <= maxNumberOfNodes) { // Ouput nodes. for (std::set<SgNode*>::iterator i = include_nodeSet.begin(); i != include_nodeSet.end(); i++) { SgNode* node = *i; file << "\"" << StringUtility::numberToString(node) << "\"[" << "label=\"" << node->class_name() << "\\n" << StringUtility::numberToString(node) << "\"];" << endl; } // Output edges for (std::set<SgNode*>::iterator i = include_nodeSet.begin(); i != include_nodeSet.end(); i++) { SgNode* node = *i; std::vector<std::pair<SgNode*,std::string> > listOfIRnodes = node->returnDataMemberPointers(); std::vector<std::pair<SgNode*,std::string> >::iterator j = listOfIRnodes.begin(); while (j != listOfIRnodes.end()) { if (include_nodeSet.find(j->first) != include_nodeSet.end()) { file << "\"" << StringUtility::numberToString(node) << "\" -> \"" << StringUtility::numberToString(j->first) << "\"[label=\"" << j->second << "\"];" << endl; } j++; } } } else { printf ("WARNING: IntermediateRepresentationNodeGraph is too large to generate: numberOfNodes = %d (max size = %d) \n",numberOfNodes,maxNumberOfNodes); } }