void
CompassAnalyses::BinaryInterruptAnalysis::Traversal::getValueForDefinition(std::vector<uint64_t>& vec,
std::vector<uint64_t>& positions,
uint64_t& fpos,
SgGraphNode* node,
std::pair<X86RegisterClass, int> reg ) {
set <SgGraphNode*> defNodeSet = getDefFor(node, reg);
if (RoseBin_support::DEBUG_MODE())
cout << " size of found NodeSet = " << defNodeSet.size() <<endl;
set <SgGraphNode*>::const_iterator it = defNodeSet.begin();
for (;it!=defNodeSet.end();++it) {
SgGraphNode* defNode = *it;
if (RoseBin_support::DEBUG_MODE() && defNode)
cout << " investigating ... " << defNode->get_name() <<endl;
ROSE_ASSERT(defNode);
SgAsmx86Instruction* inst = isSgAsmx86Instruction(defNode->get_SgNode());
ROSE_ASSERT(inst);
positions.push_back(inst->get_address());
// the right hand side of the instruction is either a use or a value
bool memRef = false, regRef = false;
std::pair<X86RegisterClass, int> regRight =
check_isRegister(defNode, inst, true, memRef, regRef);
if (RoseBin_support::DEBUG_MODE()) {
string regName = unparseX86Register(RegisterDescriptor(reg.first, reg.second, 0, 64), NULL);
string regNameRight = unparseX86Register(RegisterDescriptor(regRight.first, regRight.second, 0, 64), NULL);
cout << " VarAnalysis: getValueForDef . " << regName << " right hand : " << regNameRight <<endl;
}
if (!regRef) {
// it is either a memref or a value
if (!memRef) {
// get value of right hand side instruction
uint64_t val = getValueOfInstr(inst, true);
vec.push_back(val);
fpos = inst->get_address();
if (RoseBin_support::DEBUG_MODE())
cout << " found valueOfInst = " << RoseBin_support::ToString(val) <<endl;
}
} else {
// it is a register reference. I.e we need to follow the usage edge to find the
// definition of that node
SgGraphNode* usageNode = g_algo->getDefinitionForUsage(vizzGraph,defNode);
if (usageNode && usageNode!=node) {
if (RoseBin_support::DEBUG_MODE() && usageNode)
cout << " following up usage for " << usageNode->get_name() <<endl;
getValueForDefinition(vec, positions, fpos, usageNode, regRight);
} else {
// we look at the same node.
cout << " ERROR :: Either following usage to itself or usageNode = NULL. " << usageNode << endl;
}
}
}
}
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_DataFlowAbstract::printDefTableToFile(
std::string fileName) {
std::ofstream myfile;
myfile.open(fileName.c_str());
vector<SgGraphNode*> sorted;
tabletype::iterator it2 = deftable.begin();
for (;it2!=deftable.end();++it2) {
SgGraphNode* node = it2->first;
sorted.push_back(node);
}
std::sort(sorted.begin(), sorted.end());
// tabletype::iterator it = deftable.begin();
//for (;it!=deftable.end();++it) {
vector<SgGraphNode*>::iterator it = sorted.begin();
for (;it!=sorted.end();++it) {
// SgGraphNode* node = it->first;
SgGraphNode* node = *it;
// const multitype& type = getDefinitionsFor(node);
const multitype& type = getDefMultiMapFor(node);
multitype::const_iterator itm = type.begin();
if (node) {
string line = ""+node->get_name()+" : \n";
for (;itm!=type.end();++itm) {
std::pair<X86RegisterClass, int> code = itm->first;
SgGraphNode* nodeDef = itm->second;
string registerName = unparseX86Register(RegisterDescriptor(code.first, code.second, 0, 64));
string def = registerName+" - "+nodeDef->get_name();
line+=" "+def+"\n";
}
myfile << line ;
}
}
myfile.close();
}
void
RoseBin_FlowAnalysis::getRootNodes(vector <SgGraphNode*>& rootNodes) {
nrOfFunctions=0;
ROSE_ASSERT(vizzGraph);
//cerr << " get Root nodes " << endl;
rose_graph_integer_node_hash_map::const_iterator itn = vizzGraph->get_node_index_to_node_map().begin();
for (; itn!=vizzGraph->get_node_index_to_node_map().end();++itn) {
// string hex_address = itn->first;
SgGraphNode* node = isSgGraphNode(itn->second);
string hex_address = node->get_name();
//ROSE_ASSERT(hex_address==hex_addr_tmp);
SgNode* internal = node->get_SgNode();
SgAsmFunction* func = isSgAsmFunction(internal);
if (func) {
rootNodes.push_back(node);
//cerr << " ............................. rootNode : " << hex_address << " " << node->get_name() << endl;
nrOfFunctions++;
}
}
}
void
RoseBin_GMLGraph::printNodes( bool dfg, RoseBin_FlowAnalysis* flow,bool forward_analysis,
std::ofstream& myfile, string& recursiveFunctionName) {
//bool firstFunc = true;
// traverse nodes and visualize results of graph
funcMap.clear();
nodesMap.clear();
//cerr << " Preparing graph - Nr of Nodes : " << nodes.size() << " edges : " << edges.size() << endl;
//SgGraphNodeList* gnodes = get_nodes();
// rose_graph_hash_multimap& nodes = get_nodes()->get_nodes();
rose_graph_integer_node_hash_map nodes = get_node_index_to_node_map();
int counter=nodes.size();
int count=0;
rose_graph_integer_node_hash_map::iterator itn2 = nodes.begin();
for (; itn2!=nodes.end();++itn2) {
counter++;
count++;
pair<int, SgGraphNode*> nt = *itn2;
// string hex_address = itn2->first;
SgGraphNode* node = isSgGraphNode(itn2->second);
string hex_address =node->get_name();
SgNode* internal = node->get_SgNode();
SgAsmFunction* func = isSgAsmFunction(internal);
if (func) {
vector<SgNode*> list;
FindInstructionsVisitorx86 vis;
#ifdef _MSC_VER
//#pragma message ("WARNING: Removed reference to AstQueryNamespace::querySubTree()")
// ROSE_ASSERT(false);
// CH (4/7/2010): Workaround for MSVC
vector<SgAsmX86Instruction*> temp_list;
AstQueryNamespace::querySubTree(func, std::bind2nd( vis, &temp_list ));
list.resize(temp_list.size());
std::copy(temp_list.begin(), temp_list.end(), list.begin());
#else
#if defined(__APPLE__) && defined(__MACH__)
//Pei-Hung (7/28/2016): OSX El Capitan has issue with bind2nd.
vector<SgAsmX86Instruction*> temp_list;
AstQueryNamespace::querySubTree(func, std::bind2nd( vis, &temp_list ));
list.resize(temp_list.size());
std::copy(temp_list.begin(), temp_list.end(), list.begin());
#else
AstQueryNamespace::querySubTree(func, std::bind2nd( vis, &list ));
#endif
#endif
int validInstructions = func->nrOfValidInstructions(list);
funcMap[func]=counter;
nodesMap[func]=count;
string name = func->get_name();
string text = "node [\n id " + RoseBin_support::ToString(counter) + "\n id_ " +
RoseBin_support::ToString(counter) + "\n label \"" + name + "\"\n ";
text +=" nrinstr_ "+RoseBin_support::ToString(validInstructions)+" \n";
text+= " isGroup 1\n isGroup_ 1\n ]\n";
if (name=="frame_dummy") {
//cerr << text << endl;
vector<SgNode*> succs = func->get_traversalSuccessorContainer();
vector<SgNode*>::iterator j = succs.begin();
//cerr << " ------------- free_dummy"<<endl;
int ii=0;
for (;j!=succs.end();j++) {
//SgNode* n = *j;
//cerr << " Node contained at pos:"<<ii<<" - " << n->class_name() << endl;
ii++;
}
//cerr << " number of validInstructions: " << validInstructions << endl;
}
if (grouping)
myfile << text;
}
SgAsmInstruction* bin_inst = isSgAsmInstruction(internal);
if (bin_inst)
nodesMap[bin_inst]=count;
}
//cerr << " Writing graph to GML - Nr of Nodes : " << nodes.size() << endl;
int pos=0;
rose_graph_integer_node_hash_map::iterator itn = nodes.begin();
for (; itn!=nodes.end();++itn) {
pos++;
// string hex_address = itn->first;
SgGraphNode* node = isSgGraphNode(itn->second);
string hex_address = node->get_name();
SgNode* internal = node->get_SgNode();
SgAsmFunction* func = isSgAsmFunction(internal);
string text="";
// specifies that this node has no destination address
nodest_jmp = false;
// specifies that there is a node that has a call error (calling itself)
error =false;
// specifies a call to a unknown location
nodest_call = false;
// specifies where its an int instruction
interrupt = false;
if (func) {
string name = func->get_name();
//cerr << " if part name : " << name << endl;
ROSE_ASSERT(node);
if (grouping==false) {
map < int , string> node_p = node->get_properties();
map < int , string>::iterator prop = node_p.begin();
string name = "noname";
string type = "removed";//node->get_type();
for (; prop!=node_p.end(); ++prop) {
int addr = prop->first;
//cerr << " gml : property for addr : " << addr << endl;
if (addr==SgGraph::nodest_jmp)
nodest_jmp = true;
else if (addr==SgGraph::itself_call)
error = true;
else if (addr==SgGraph::nodest_call)
nodest_call = true;
else if (addr==SgGraph::interrupt)
interrupt = true;
// else
// name = prop->second;
}
}
int parent = funcMap[func];
RoseBin_support::checkText(name);
int length = name.length();
text = "node [\n id " + RoseBin_support::ToString(pos) + "\n label \"" + name + "\"\n";
if (nodest_jmp) {
text += " graphics [ h 30.0 w " + RoseBin_support::ToString(length*7) + " type \"circle\" fill \"#FF0000\" ]\n";
text +=" Node_Color_ \"FF0000\" \n";
} else if (nodest_call) {
text += " graphics [ h 30.0 w " + RoseBin_support::ToString(length*7) + " type \"circle\" fill \"#FF9900\" ]\n";
text +=" Node_Color_ \"FF9900\" \n";
} else if (interrupt) {
text += " graphics [ h 30.0 w " + RoseBin_support::ToString(length*7) + " type \"circle\" fill \"#0000FF\" ]\n";
text +=" Node_Color_ \"0000FF\" \n";
} else if (error) {
text += " graphics [ h 30.0 w " + RoseBin_support::ToString(length*7) + " type \"circle\" fill \"#66FFFF\" ]\n";
text +=" Node_Color_ \"66FFFF\" \n";
}else {
text += " graphics [ h 30.0 w " + RoseBin_support::ToString(length*7) + " type \"circle\" fill \"#9933FF\" ]\n";
text +=" Node_Color_ \"9933FF\" \n";
}
text +=" gid "+RoseBin_support::ToString(parent)+" \n";
text +=" skip_ 1 \n";
text +=" gid_ "+RoseBin_support::ToString(parent)+" ]\n";
// skip functions for now
// if (skipFunctions)
// text ="";
} /*not a func*/ else {
SgAsmX86Instruction* bin_inst = isSgAsmX86Instruction(internal);
//cerr << " else part " << endl;
SgAsmFunction* funcDecl_parent = NULL;
if (bin_inst) {
funcDecl_parent = isSgAsmFunction(bin_inst->get_parent());
if (funcDecl_parent==NULL)
funcDecl_parent = isSgAsmFunction(bin_inst->get_parent()->get_parent());
}
if (funcDecl_parent==NULL) {
cerr << " ERROR : printNodes preparation . No parent found for node : " << bin_inst->class_name() <<
" " << hex_address << endl;
continue;
}
if ((pos % 10000)==0)
cout << " GMLGraph:: printing GML Nodes : " << pos << endl;
string name = getInternalNodes(node, forward_analysis,bin_inst);
int parent=0;
map <SgAsmFunction*, int>::iterator its = funcMap.find(funcDecl_parent);
if (its!=funcMap.end())
parent = funcMap[funcDecl_parent];
if (parent==0)
cerr << " GMLGraph parent == 0 " << endl;
if (onlyControlStructure && x86InstructionIsControlTransfer(bin_inst)) {
text = "node [\n id " + RoseBin_support::ToString(pos) + "\n" + name ;
int instrnr = funcDecl_parent->get_childIndex(bin_inst);
text +=" instrnr_ "+RoseBin_support::ToString(instrnr)+" \n";
text +=" gid_ "+RoseBin_support::ToString(parent)+" \n";
text +=" gid "+RoseBin_support::ToString(parent)+" ]\n";
} else {
text = "node [\n id " + RoseBin_support::ToString(pos) + "\n" + name ;
int instrnr = funcDecl_parent->get_childIndex(bin_inst);
text +=" instrnr_ "+RoseBin_support::ToString(instrnr)+" \n";
text +=" gid_ "+RoseBin_support::ToString(parent)+" \n";
text +=" gid "+RoseBin_support::ToString(parent)+" ]\n";
}
}
myfile << text;
// cerr << " this node : " << text << endl;
}
funcMap.clear();
}
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
}
