void DefUseAnalysis::printMultiMap(const multitype* multi) { cout<<"\tmultitype element count:" << multi->size() <<endl; for (multitype::const_iterator j = multi->begin(); j != multi->end(); ++j) { SgInitializedName* sgInitMM = (*j).first; SgNode* sgNodeMM = (*j).second; ROSE_ASSERT(sgInitMM); ROSE_ASSERT(sgNodeMM); cout <<"\t" <<sgInitMM->class_name()<<" "<<sgInitMM << " " << sgInitMM->get_qualified_name().str() << " id ( " << ToString(getIntForSgNode(sgInitMM)) <<" ) - "; if (sgInitMM!=sgNodeMM) cout <<sgNodeMM->class_name()<<" "<<sgNodeMM << " id ( " << ToString(getIntForSgNode(sgNodeMM)) <<" ) "<< endl; else cout << "same self node" <<endl; } }
StencilEvaluation_SynthesizedAttribute StencilEvaluationTraversal::evaluateSynthesizedAttribute (SgNode* astNode, StencilEvaluation_InheritedAttribute inheritedAttribute, SubTreeSynthesizedAttributes synthesizedAttributeList ) { StencilEvaluation_SynthesizedAttribute return_synthesizedAttribute; #if 0 printf ("In StencilEvaluationTraversal::evaluateSynthesizedAttribute(): astNode = %p = %s \n",astNode,astNode->class_name().c_str()); #endif bool foundStencilOffsetFSM = false; SgConstructorInitializer* constructorInitializer = isSgConstructorInitializer(astNode); if (constructorInitializer != NULL && inheritedAttribute.stencilOffsetFSM != NULL) { #if 0 printf ("Found pair<Shift,double>(x,y): set then in the synthesizedAttribute: astNode = %p = %s \n",astNode,astNode->class_name().c_str()); #endif return_synthesizedAttribute.stencilOffsetFSM = inheritedAttribute.stencilOffsetFSM; return_synthesizedAttribute.stencilCoeficientValue = inheritedAttribute.stencilCoeficientValue; #if 0 printf ("return_synthesizedAttribute.stencilCoeficientValue = %f \n",return_synthesizedAttribute.stencilCoeficientValue); #endif foundStencilOffsetFSM = true; } // There should only be a single child set with a pair<Shift,double>(x,y) object. for (size_t i = 0; i < synthesizedAttributeList.size(); i++) { if (synthesizedAttributeList[i].stencilOffsetFSM != NULL) { // Check that the return_synthesizedAttribute.stencilOffsetFSM has not already been set. // This could happend if we allows nesting of pair<Shift,double>(x,y) within itself (not allowed). #if 0 printf ("synthesizedAttributeList[i].stencilOffsetFSM != NULL \n"); #endif // ROSE_ASSERT(foundStencilOffsetFSM == false); if (foundStencilOffsetFSM == false) { #if 0 printf ("foundStencilOffsetFSM == false \n"); #endif // ROSE_ASSERT(return_synthesizedAttribute.stencilOffsetFSM == NULL); if (return_synthesizedAttribute.stencilOffsetFSM == NULL) { #if 0 printf ("return_synthesizedAttribute.stencilOffsetFSM != NULL \n"); #endif return_synthesizedAttribute.stencilOffsetFSM = synthesizedAttributeList[i].stencilOffsetFSM; return_synthesizedAttribute.stencilCoeficientValue = synthesizedAttributeList[i].stencilCoeficientValue; } foundStencilOffsetFSM = true; } } } // This allows us to find the variables of type vector<Point> and vector<double> used as an alternative way // to specify a stencil (using the Stencil constructor that takes these variables as input arguments). // It relies upon a previous traversal to have identified the inputs to Stencil constructor. // This support is incomplete while I focus on the alternative approach to the specification of the stencil // using intremental union of a stencil with a pair<Shift,double>() template instantiation. SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(astNode); if (variableDeclaration != NULL) { // Get the SgInitializedName from the SgVariableDeclaration. SgInitializedName* initializedName = SageInterface::getFirstInitializedName(variableDeclaration); #if 0 printf ("In evaluateInheritedAttribute(): case SgInitializedName from variable declaration: initializedName = %p name = %s \n",initializedName,initializedName->get_name().str()); #endif bool foundStencilDeclaration = false; if (find(stencilInputInitializedNameList.begin(),stencilInputInitializedNameList.end(),initializedName) != stencilInputInitializedNameList.end()) { #if 0 printf ("Found declaration associated with stencil input: initializedName = %p = %s name = %s \n",initializedName,initializedName->class_name().c_str(),initializedName->get_name().str()); #endif // Build the finite state machine for the stencil and add it to the map using the name (in SgInitializedName) as a key. // For now we assume that the stencil specification is using the default construction. if (initializedName->get_initptr() != NULL) { printf ("FIXME: This declaration of a stencil appears to have constrcutor arguments (this not the default constuctor as interprest below). \n"); #if 0 ROSE_ASSERT(false); #endif } foundStencilDeclaration = true; } else { // Verify that this is a Stencil declaration. SgClassType* classType = isSgClassType(initializedName->get_type()); if (classType != NULL) { // Check if this is associated with a template instantiation. SgTemplateInstantiationDecl* templateInstantiationDecl = isSgTemplateInstantiationDecl(classType->get_declaration()); if (templateInstantiationDecl != NULL) { #if 0 printf ("case SgTemplateInstaiationDecl: class name = %s \n",classType->get_name().str()); printf ("case SgTemplateInstaiationDecl: templateInstantiationDecl->get_templateName() = %s \n",templateInstantiationDecl->get_templateName().str()); #endif if (templateInstantiationDecl->get_templateName() == "Stencil") { #if 0 printf ("This is verified to be associated with the Stencil template class \n"); #endif foundStencilDeclaration = true; } } } } if (foundStencilDeclaration == true) { string name = initializedName->get_name(); ROSE_ASSERT(stencilMap.find(name) == stencilMap.end()); // stencilMap[name] = new StencilFSM(); StencilFSM* stencilFSM = new StencilFSM(); ROSE_ASSERT(stencilFSM != NULL); stencilMap[name] = stencilFSM; ROSE_ASSERT(stencilMap.find(name) != stencilMap.end()); #if 0 printf ("Added StencilFSM to stencilMap using name = %s \n",name.c_str()); #endif #if 0 printf ("Trigger an event on the stencilFSM ========================== %p \n",stencilFSM); printf (" --- Use the return_synthesizedAttribute.stencilOffsetFSM = %p \n",return_synthesizedAttribute.stencilOffsetFSM); #endif if (return_synthesizedAttribute.stencilOffsetFSM != NULL) { // Trigger the event to add the stencil offset to the stencil. // Trigger the event on the finite state machine using the elements saved in the synthesized attribute. StencilFSM stencil_rhs (*(return_synthesizedAttribute.stencilOffsetFSM),return_synthesizedAttribute.stencilCoeficientValue); // This reproduces the same semantics in our finite state machine as the Stencil class's operator+() // in the stencil specification. but this permits use to accumulate the state at compile time. stencilFSM->operator+(stencil_rhs); // We have now used these values so avoid letting then be used again. return_synthesizedAttribute.stencilOffsetFSM = NULL; return_synthesizedAttribute.stencilCoeficientValue = 0.0; } #if 0 stencilFSM->display("after FSM stencil default construction plus union event: StencilEvaluationTraversal::evaluateSynthesizedAttribute()"); #endif #if 0 printf ("Exiting as a test! \n"); ROSE_ASSERT(false); #endif } } // Recognize member function calls on "Stencil" objects so that we can trigger events on those associated finite state machines. bool isTemplateClass = true; bool isTemplateFunctionInstantiation = true; SgInitializedName* initializedNameUsedToCallMemberFunction = NULL; SgFunctionCallExp* functionCallExp = detectMemberFunctionOfSpecificClassType(astNode,initializedNameUsedToCallMemberFunction,"Stencil",isTemplateClass,"operator+",isTemplateFunctionInstantiation); if (return_synthesizedAttribute.stencilOffsetFSM != NULL && functionCallExp != NULL) { // This is the DSL specific part of the synthesized attribute evaluation. ROSE_ASSERT(initializedNameUsedToCallMemberFunction != NULL); string name = initializedNameUsedToCallMemberFunction->get_name(); #if 0 printf ("This is verified to be the operator+ member function of the Stencil templated class (so this corresponds to an event in the Stencil finite state machine) \n"); printf (" --- stencil object name = %s \n",name.c_str()); #endif // Lookup the stencil FSM in the map of stencil FSMs using the name as the key. ROSE_ASSERT(stencilMap.find(name) != stencilMap.end()); StencilFSM* stencilFSM = stencilMap[name]; ROSE_ASSERT(stencilFSM != NULL); #if 0 printf ("Trigger an event on the stencilFSM ========================== %p \n",stencilFSM); printf (" --- Use the return_synthesizedAttribute.stencilOffsetFSM = %p \n",return_synthesizedAttribute.stencilOffsetFSM); #endif // Make sure we have the input parameter for the stencil's finite state machine. ROSE_ASSERT(return_synthesizedAttribute.stencilOffsetFSM != NULL); // Trigger the event on the finite state machine using the elements saved in the synthesized attribute. StencilFSM stencil_rhs (*(return_synthesizedAttribute.stencilOffsetFSM),return_synthesizedAttribute.stencilCoeficientValue); // This reproduces the same semantics in our finite state machine as the Stencil class's operator+() // in the stencil specification. but this permits use to accumulate the state at compile time. stencilFSM->operator+(stencil_rhs); // We have now used these values so avoid letting then be used again. return_synthesizedAttribute.stencilOffsetFSM = NULL; return_synthesizedAttribute.stencilCoeficientValue = 0.0; #if 0 stencilFSM->display("after FSM stencil union event: StencilEvaluationTraversal::evaluateSynthesizedAttribute()"); #endif } #if 0 printf ("Leaving StencilEvaluationTraversal::evaluateSynthesizedAttribute(): return_synthesizedAttribute.stencilOffsetFSM = %p \n",return_synthesizedAttribute.stencilOffsetFSM); #endif #if 0 printf ("Leaving StencilEvaluationTraversal::evaluateSynthesizedAttribute(): return_synthesizedAttribute.stencilCoeficientValue = %f \n",return_synthesizedAttribute.stencilCoeficientValue); #endif return return_synthesizedAttribute; }
void visitorTraversal::visit(SgNode* n) { SgFile* file = isSgFile(n); if (file != NULL) { filename = file->get_sourceFileNameWithPath(); } // On each statement node and output it's position. SgStatement* statement = isSgStatement(n); bool outputStatement = (statement != NULL) ? true : false; // Check for the statement to exist in the input source file outputStatement = outputStatement && (statement->get_file_info()->get_filenameString() == filename); // Skip SgGlobal IR nodes outputStatement = outputStatement && (isSgGlobal(statement) == NULL); if (outputStatement == true) { AttachedPreprocessingInfoType* comments = statement->getAttachedPreprocessingInfo(); if (comments != NULL) { // printf ("Found attached comments (to IR node at %p of type: %s): \n",statement,statement->class_name().c_str()); // int counter = 0; AttachedPreprocessingInfoType::iterator i; for (i = comments->begin(); i != comments->end(); i++) { #if 0 printf (" Attached Comment #%d in file %s (relativePosition=%s): classification %s :\n%s\n", counter++,(*i)->get_file_info()->get_filenameString().c_str(), ((*i)->getRelativePosition() == PreprocessingInfo::before) ? "before" : "after", PreprocessingInfo::directiveTypeName((*i)->getTypeOfDirective()).c_str(), (*i)->getString().c_str()); #endif // Mark comments and CPP directives a few different colors. int startingLineNumber = (*i)->get_file_info()->get_line(); int startingColumnNumber = (*i)->get_file_info()->get_col(); // Subtract 1 from number of lines to avoid over counting the current line. int endingLineNumber = startingLineNumber + ((*i)->getNumberOfLines() - 1); int endingColumnNumber = (*i)->getColumnNumberOfEndOfString(); string color = directiveTypeColor((*i)->getTypeOfDirective()); #if 0 printf ("%d,%d,%s,%d,%d\n",startingLineNumber,startingColumnNumber,color.c_str(),endingLineNumber,endingColumnNumber); #endif dataFile << startingLineNumber << "," << startingColumnNumber << "," << color << "," << endingLineNumber << "," << endingColumnNumber << endl; } } else { // printf ("No attached comments (at %p of type: %s): \n",statement,statement->sage_class_name()); } ROSE_ASSERT(statement->get_startOfConstruct() != NULL); int startingLineNumber = statement->get_startOfConstruct()->get_line(); int startingColumnNumber = statement->get_startOfConstruct()->get_col(); if (statement->get_endOfConstruct() == NULL) { printf ("Error: statement->get_endOfConstruct() == NULL (statement = %p = %s) \n",statement,statement->class_name().c_str()); } ROSE_ASSERT(statement->get_endOfConstruct() != NULL); int endingLineNumber = statement->get_endOfConstruct()->get_line(); int endingColumnNumber = statement->get_endOfConstruct()->get_col(); // Catch errors (likely compiler generate IR node or NULL file) if (endingLineNumber == 0) { endingLineNumber = startingLineNumber; endingColumnNumber = startingColumnNumber; } #if 0 // Mark all statements blue string color = "blue"; if (isSgScopeStatement(statement) != NULL) color = "red"; #else string color = nodeColor(statement); #endif #if 0 printf ("%d,%d,%s,%d,%d %s = %p \n",startingLineNumber,startingColumnNumber,color.c_str(),endingLineNumber,endingColumnNumber,statement->class_name().c_str(),statement); #endif dataFile << startingLineNumber << "," << startingColumnNumber << "," << color << "," << endingLineNumber << "," << endingColumnNumber << endl; } // On each statement node and output it's position. SgExpression* expression = isSgExpression(n); bool outputExpression = (expression != NULL) ? true : false; // Check for the statement to exist in the input source file outputExpression = outputExpression && (expression->get_file_info()->get_filenameString() == filename); if (outputExpression == true) { // Currently we don't attach comments to expressions (as I recall). AttachedPreprocessingInfoType* comments = expression->getAttachedPreprocessingInfo(); ROSE_ASSERT(comments == NULL); ROSE_ASSERT(expression->get_startOfConstruct() != NULL); int startingLineNumber = expression->get_startOfConstruct()->get_line(); int startingColumnNumber = expression->get_startOfConstruct()->get_col(); // For expressions I would like to be a bit more tollerant of a few mistakes. if (expression->get_endOfConstruct() == NULL) { printf ("Error: expression->get_endOfConstruct() == NULL (expression = %p = %s) \n",expression,expression->class_name().c_str()); } // ROSE_ASSERT(expression->get_endOfConstruct() != NULL); int endingLineNumber = startingLineNumber; int endingColumnNumber = startingColumnNumber; if (expression->get_endOfConstruct() != NULL) { endingLineNumber = expression->get_endOfConstruct()->get_line(); endingColumnNumber = expression->get_endOfConstruct()->get_col(); } // Catch errors (likely compiler generate IR node or NULL file) if (endingLineNumber == 0) { endingLineNumber = startingLineNumber; endingColumnNumber = startingColumnNumber; } string color = nodeColor(expression); #if 0 printf ("%d,%d,%s,%d,%d %s = %p \n",startingLineNumber,startingColumnNumber,color.c_str(),endingLineNumber,endingColumnNumber,expression->class_name().c_str(),expression); #endif dataFile << startingLineNumber << "," << startingColumnNumber << "," << color << "," << endingLineNumber << "," << endingColumnNumber << endl; } // On each statement node and output it's position. SgInitializedName* initializedName = isSgInitializedName(n); bool outputInitializedName = (initializedName != NULL) ? true : false; // Check for the statement to exist in the input source file outputInitializedName = outputInitializedName && (initializedName->get_file_info()->get_filenameString() == filename); if (outputInitializedName == true) { // Currently we don't attach comments to SgInitializedName IR nodes (as I recall). // AttachedPreprocessingInfoType* comments = initializedName->getAttachedPreprocessingInfo(); // ROSE_ASSERT(comments == NULL); ROSE_ASSERT(initializedName->get_startOfConstruct() != NULL); int startingLineNumber = initializedName->get_startOfConstruct()->get_line(); int startingColumnNumber = initializedName->get_startOfConstruct()->get_col(); #if 0 // For SgInitializedName I would like to be a bit more tollerant of a few mistakes. if (initializedName->get_endOfConstruct() == NULL) { printf ("Note: initializedName->get_endOfConstruct() == NULL is OK (initializedName = %p = %s) \n",initializedName,initializedName->class_name().c_str()); } // ROSE_ASSERT(initializedName->get_endOfConstruct() != NULL); #endif int endingLineNumber = startingLineNumber; int endingColumnNumber = startingColumnNumber; if (initializedName->get_endOfConstruct() != NULL) { endingLineNumber = initializedName->get_endOfConstruct()->get_line(); endingColumnNumber = initializedName->get_endOfConstruct()->get_col(); } // Catch errors (likely compiler generate IR node or NULL file) if (endingLineNumber == 0) { endingLineNumber = startingLineNumber; endingColumnNumber = startingColumnNumber; } string color = nodeColor(initializedName); #if 0 // This is redundant I/O for debugging. printf ("%d,%d,%s,%d,%d %s = %p \n",startingLineNumber,startingColumnNumber,color.c_str(),endingLineNumber,endingColumnNumber,initializedName->class_name().c_str(),initializedName); #endif dataFile << startingLineNumber << "," << startingColumnNumber << "," << color << "," << endingLineNumber << "," << endingColumnNumber << endl; } }