void
GraphAlgorithms::getDirectCFGSuccessors(RoseBin_Graph* vizzGraph,
SgGraphNode* node, std::vector <SgGraphNode*>& vec ) {
//SgGraphEdgeList* gedges = vizzGraph->get_edges();
rose_graph_integer_edge_hash_multimap edges = vizzGraph->get_node_index_to_edge_multimap_edgesOut();
rose_graph_integer_edge_hash_multimap::iterator it1, it2;
pair <rose_graph_integer_edge_hash_multimap::iterator, rose_graph_integer_edge_hash_multimap::iterator> iter =
edges.equal_range(node->get_index());
it1 = iter.first;
it2 = iter.second;
//cerr << " DirectCFGSucc >>>>>>>>>>>>>>> getDirect - Outedges for node " << endl;
for (;it1!=it2; ++it1) {
SgDirectedGraphEdge* edge = isSgDirectedGraphEdge(it1->second);
ROSE_ASSERT(edge);
//cerr << " found edge = " << edge ;
if (edge) {
SgGraphNode* target = isSgGraphNode(edge->get_to());
//cerr << " with target node = " << target->get_name() << endl;
ROSE_ASSERT(target);
if (target) {
string type_n = vizzGraph->getProperty(SgGraph::type, edge);
if (type_n==RoseBin_support::ToString(SgGraph::cfg))
if (isDirectCFGEdge(target, node))
vec.push_back(target);
}
}
}
}
void
GraphAlgorithms::getDirectCFGPredecessors(RoseBin_Graph* vizzGraph,
SgGraphNode* node, std::vector <SgGraphNode*>& vec ) {
rose_graph_integer_edge_hash_multimap::iterator it1, it2;
pair <rose_graph_integer_edge_hash_multimap::iterator, rose_graph_integer_edge_hash_multimap::iterator> iter =
vizzGraph->get_node_index_to_edge_multimap_edgesIn().equal_range(node->get_index());
it1 = iter.first;
it2 = iter.second;
for (;it1!=it2; ++it1) {
SgDirectedGraphEdge* edge = isSgDirectedGraphEdge(it1->second);
if (edge) {
SgGraphNode* source = isSgGraphNode(edge->get_from());
if (source) {
string type_n = vizzGraph->getProperty(SgGraph::type, edge);
if (type_n==RoseBin_support::ToString(SgGraph::cfg))
if (isDirectCFGEdge(node, source))
vec.push_back(source);
}
}
}
}
SgGraphNode*
GraphAlgorithms::getDefinitionForUsage(RoseBin_Graph* vizzGraph,
SgGraphNode* node) {
rose_graph_integer_edge_hash_multimap::iterator it1, it2;
pair <rose_graph_integer_edge_hash_multimap::iterator, rose_graph_integer_edge_hash_multimap::iterator> iter =
vizzGraph->get_node_index_to_edge_multimap_edgesIn().equal_range(node->get_index());
it1 = iter.first;
it2 = iter.second;
for (;it1!=it2; ++it1) {
SgDirectedGraphEdge* edge = isSgDirectedGraphEdge(it1->second);
if (edge) {
SgGraphNode* source = isSgGraphNode(edge->get_from());
if (source) {
string type_n = vizzGraph->getProperty(SgGraph::type, edge);
//if (RoseBin_support::DEBUG_MODE())
//cout << " found a predecessor with type : " << type_n << endl;
if (type_n==RoseBin_support::ToString(SgGraph::usage))
return source;
}
}
}
return NULL;
}
void
RoseBin_DataFlowAnalysis::traverseEdges(RoseBin_DataFlowAbstract* analysis) {
if (RoseBin_support::DEBUG_MODE_MIN())
cerr << " >> Traversing over all edges and adding label ... " << endl;
//typedef rose_graph_integer_edge_hash_multimap edgesM;
rose_graph_integer_edge_hash_multimap edges = vizzGraph->get_node_index_to_edge_multimap_edgesOut();
rose_graph_integer_edge_hash_multimap::const_iterator it = edges.begin();
for (;it!=edges.end();++it) {
int index = it->first;
SgGraphNode* src = NULL;
rose_graph_integer_node_hash_map::iterator nIT = vizzGraph->get_node_index_to_node_map().find(index);
if (nIT!=vizzGraph->get_node_index_to_node_map().end())
src=nIT->second;
ROSE_ASSERT(src);
// SgGraphNode* src = it->first;
SgDirectedGraphEdge* edge = isSgDirectedGraphEdge(it->second);
SgGraphNode* trg = NULL;
if (edge)
trg = isSgGraphNode(edge->get_to());
if (g_algo->isValidCFGEdge(trg, src))
analysis->runEdge(src,trg);
}
}
void
AstDOTGeneration::writeIncidenceGraphToDOTFile(SgIncidenceDirectedGraph* graph, const std::string& filename)
{
// Output all nodes
rose_graph_integer_node_hash_map & nodes = graph->get_node_index_to_node_map ();
for( rose_graph_integer_node_hash_map::iterator it = nodes.begin(); it != nodes.end(); ++it )
{
SgGraphNode* node = it->second;
if( commentOutNodeInGraph(node) == false )
{
string nodeoption;
string nodelabel=string("\\n")+node->get_name();
nodelabel += additionalNodeInfo(node);
string additionalOptions = additionalNodeOptions(node);
string x;
string y;
x += additionalOptions;
nodeoption += additionalOptions;
// dotrep.addNode(node,dotrep.traceFormat(ia.tdTracePos)+nodelabel,nodeoption);
dotrep.addNode(node,nodelabel,nodeoption);
addAdditionalNodesAndEdges(node);
}
}
// Output edges
rose_graph_integer_edge_hash_multimap & outEdges = graph->get_node_index_to_edge_multimap_edgesOut ();
for( rose_graph_integer_edge_hash_multimap::const_iterator outEdgeIt = outEdges.begin(); outEdgeIt != outEdges.end(); ++outEdgeIt )
{
// if(debug) std::cerr << " add edge from node ... " << std::endl; // debug
SgDirectedGraphEdge* graphEdge = isSgDirectedGraphEdge(outEdgeIt->second);
ROSE_ASSERT(graphEdge!=NULL);
if ( commentOutNodeInGraph(graphEdge) == false )
{
string edgelabel=string("\\n")+graphEdge->get_name();
string edgeoption = additionalEdgeOptions(graphEdge->get_from(),graphEdge->get_to(),edgelabel);
dotrep.addEdge(graphEdge->get_from(),edgelabel,graphEdge->get_to(),edgeoption + "dir=forward");
addAdditionalNodesAndEdges(graphEdge);
}
}
dotrep.writeToFileAsGraph(filename);
}
void RoseBin_ControlFlowAnalysis::printGraph(std::string fileName, std::set<std::string>& filter) {
#if 1
ASSERT_not_reachable("no longer supported");
#else
std::set<std::string>::const_iterator it = filter.begin();
for (;it!=filter.end();++it) {
std::cerr << "CFG -- contains filter: ." << *it << "." << endl;
}
// typedef rose_hash::unordered_map <std::string, SgGraphNode*> nodeType;
// typedef rose_hash::unordered_map <string, SgGraphNode*,hash_stringptr> nodeType;
rose_graph_integer_node_hash_map result;
//rose_graph_hash_multimap& nodes = vizzGraph->get_node_index_to_node_map();
rose_graph_integer_node_hash_map nodes = vizzGraph->get_node_index_to_node_map();
rose_graph_integer_node_hash_map::iterator itn2 = nodes.begin();
for (; itn2 != nodes.end();++itn2) {
// string hex_address = itn2->first;
SgGraphNode* node = itn2->second;
string hex_address = node->get_name();
//string hex_addr_tmp = node->get_name();
//ROSE_ASSERT(hex_address==hex_addr_tmp);
SgNode* internal = node->get_SgNode();
SgAsmFunction* func = isSgAsmFunction(internal);
if (func) {
std::cerr << "ControlFlowAnalysis:: found function: ." << hex_address << "." <<endl;
std::set<std::string>::const_iterator it = filter.find(hex_address);
if (it!=filter.end()) {
//std::cerr << " ******************* match ********************* " << std::endl;
set<SgGraphNode*> gns;
set<std::string> names;
getCFGNodesForFunction(gns,names,node,hex_address);
if (debug)
cerr << " nodes in function: " << gns.size() << " " << names.size() <<endl;
ROSE_ASSERT(gns.size()==names.size());
set<SgGraphNode*>::const_iterator it2 = gns.begin();
set<std::string>::const_iterator it3 = names.begin();
for (;it2!=gns.end();++it2, ++it3) {
std::string name = *it3;
SgGraphNode* n = *it2;
if (debug)
cerr << " adding to result ."<<name<<"."<<endl;
result.insert(make_pair(itn2->first,n));
}
}
}
}
rose_graph_integer_node_hash_map nodesResult = nodes;
rose_graph_integer_node_hash_map::iterator itn23 = nodes.begin();
for (; itn23!=nodes.end();++itn23) {
//string hex_address = isSgGraphNode(itn23->second)->get_name();
int pos = itn23->first;
// rose_graph_integer_node_hash_map::iterator it = result.find(hex_address);
rose_graph_integer_node_hash_map::iterator it = result.find(pos);
if (it==result.end()) {
// not found in result, i.e. delete
//nodesResult.erase(hex_address);
nodesResult.erase(pos);
}
}
// vizzGraph->nodes=nodesResult;
#if 0
// vizzGraph->nodes=result;
// create file
bool forward_analysis=true;
bool multiedge=false;
std::ofstream myfile;
myfile.open(fileName.c_str());
string name = "ROSE Graph";
vizzGraph->printProlog(myfile, name);
string functionName="";
vizzGraph->setGrouping(true);
vizzGraph->printNodes(true, this, forward_analysis, myfile,functionName);
nrNodes=vizzGraph->nodes.size();
vizzGraph->printEdges(this,myfile, multiedge);
nrEdges=vizzGraph->get_node_index_to_edge_multimap_edgesOut().size();
vizzGraph->printEpilog(myfile);
myfile.close();
#endif
#if 1
RoseBin_Graph* gr = new RoseBin_DotGraph();
gr->graph = new SgIncidenceDirectedGraph("test");//SgDirectedGraph("test","test");
gr->get_node_index_to_node_map()=nodesResult;
//typedef SB_DirectedGraph::edgeType edgeType;
rose_graph_integer_edge_hash_multimap edges = vizzGraph->get_node_index_to_edge_multimap_edgesOut();
rose_graph_integer_edge_hash_multimap resultEdges;
rose_graph_integer_edge_hash_multimap::iterator itEdg = edges.begin();
for (; itEdg!=edges.end();++itEdg) {
int index = itEdg->first;
SgGraphNode* node = NULL;
rose_graph_integer_node_hash_map::iterator nIT = vizzGraph->get_node_index_to_node_map().find(index);
if (nIT!=vizzGraph->get_node_index_to_node_map().end())
node=nIT->second;
ROSE_ASSERT(node);
SgDirectedGraphEdge* edge = isSgDirectedGraphEdge(itEdg->second);
SgGraphNode* target = isSgGraphNode(edge->get_to());
rose_graph_integer_node_hash_map::iterator itn2 = nodesResult.begin();
bool foundS=false;
if (node)
foundS=true;
bool foundT=false;
for (; itn2!=nodesResult.end();++itn2) {
SgGraphNode* n = itn2->second;
//if (n==source) foundS=true;
if (n==target) foundT=true;
}
if (foundS==false || foundT==false) {
} else
resultEdges.insert(make_pair(node->get_index(),edge));
}
gr->get_node_index_to_edge_multimap_edgesOut()=resultEdges;
// create file
bool forward_analysis=true;
bool multiedge=false;
std::ofstream myfile;
myfile.open(fileName.c_str());
string name = "ROSE Graph";
gr->printProlog(myfile, name);
string functionName="";
gr->setGrouping(true);
gr->printNodes(true, this, forward_analysis, myfile,functionName);
nrNodes=gr->get_node_index_to_node_map().size();
ROSE_ASSERT(g_algo->info);
gr->printEdges(g_algo->info, this,myfile, multiedge);
nrEdges=gr->get_node_index_to_edge_multimap_edgesOut().size();
gr->printEpilog(myfile);
myfile.close();
#endif
#endif
}
void sortedCallGraphDump(string fileName, SgIncidenceDirectedGraph* cg)
{
//Opening output file
ofstream file;
file.open(fileName.c_str());
//Get all nodes of the current CallGraph
list<pair<SgGraphNode*, int> > cgNodes;
rose_graph_integer_node_hash_map & nodes = cg->get_node_index_to_node_map();
for (rose_graph_integer_node_hash_map::iterator it = nodes.begin(); it != nodes.end(); ++it)
{
cgNodes.push_back(pair<SgGraphNode*, int>(it->second, it->first));
}
cgNodes.sort(nodeCompareGraphPair);
cgNodes.unique();
for (list<pair<SgGraphNode *, int> >::iterator it = cgNodes.begin(); it != cgNodes.end(); it++)
{
//get list over the end-points for which this node points to
list<SgGraphNode*> calledNodes;
rose_graph_integer_edge_hash_multimap & outEdges = cg->get_node_index_to_edge_multimap_edgesOut ();
for (rose_graph_integer_edge_hash_multimap::const_iterator outEdgeIt = outEdges.begin();
outEdgeIt != outEdges.end(); ++outEdgeIt)
{
if (outEdgeIt->first == it->second)
{
SgDirectedGraphEdge* graphEdge = isSgDirectedGraphEdge(outEdgeIt->second);
ROSE_ASSERT(graphEdge != NULL);
calledNodes.push_back(graphEdge->get_to());
}
}
calledNodes.sort(nodeCompareGraph);
calledNodes.unique();
//Output the unique graph
SgFunctionDeclaration* cur_function = isSgFunctionDeclaration((it->first)->get_SgNode());
if (SgProject::get_verbose() >= DIAGNOSTICS_VERBOSE_LEVEL)
std::cout << "Node " << cur_function << " has " << calledNodes.size() << " calls to it." << std::endl;
if (calledNodes.size() == 0)
{
{
ROSE_ASSERT(cur_function != NULL);
file << stripGlobalModifer(cur_function->get_qualified_name().getString()) << " ->";
}
}
else
{
{
ROSE_ASSERT(cur_function != NULL);
file << stripGlobalModifer(cur_function->get_qualified_name().getString()) << " ->";
}
for (list<SgGraphNode *>::iterator j = calledNodes.begin(); j != calledNodes.end(); j++)
{
SgFunctionDeclaration* j_function = isSgFunctionDeclaration((*j)->get_SgNode());
file << " " << stripGlobalModifer(j_function->get_qualified_name().getString());
}
}
file << endl;
}
file.close();
};
