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() */
/* * 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; }
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; }
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\
//----------------------------------------------------------------------------------- // 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; }
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() */
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; }
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 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 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; }
// 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); } }
// 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; }
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"); } */ } }
//----------------------------------------------------------------------------------- // 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; }
// 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 } } } }
//----------------------------------------------------------------------------- // 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; }
//! 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; }
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; }
// 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; }
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 }