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;
}
}
