RIFG.cpp

Go to the documentation of this file.

//************************** System Include Files ***************************

#ifdef NO_STD_CHEADERS
# include <assert.h>
# include <limits.h>
#else
# include <cassert>
# include <climits>
#endif

#include <inttypes.h>

//*************************** User Include Files ****************************

#include <OpenAnalysis/Utils/RIFG.hpp>
#include <OpenAnalysis/CFG/CFGInterface.hpp>

//*************************** Forward Declarations **************************

//***************************************************************************

//***************************************************************************
// Representation Independent Flowgraph
//***************************************************************************

namespace OA {

unsigned int RIFG::NIL = 0;

RIFG::RIFG(OA_ptr<DGraph::DGraphInterface> graph_, 
 OA_ptr<DGraph::NodeInterface> source,
 OA_ptr<DGraph::NodeInterface> sink)
 : graph(graph_), mSource(source), mSink(sink)
{
 // Sanity check
 assert(graph->getNumNodes() <= UINT_MAX);
 assert(graph->getNumEdges() <= UINT_MAX);
 
 // Initialize the node-id to node map: ids are 1...num_nodes
 highWaterMarkNodeId = graph->getNumNodes();
 OA::OA_ptr<OA::DGraph::NodesIteratorInterface> it1 = 
 graph->getNodesIterator();
 for (NodeId i = 1; it1->isValid(); ++(*it1), ++i) {
 OA::OA_ptr<OA::DGraph::NodeInterface> node = it1->current();
 node_to_id_map[node] = i;
 id_to_node_map[i] = node;
 }
 
 // Initialize the edge-id to edge map: ids are 1...num_edges
 highWaterMarkEdgeId = graph->getNumEdges();
 OA::OA_ptr<OA::DGraph::EdgesIteratorInterface> it2 = 
 graph->getEdgesIterator();
 for (NodeId i = 1; it2->isValid(); ++(*it2), ++i) {
 OA::OA_ptr<OA::DGraph::EdgeInterface> edge = it2->current();
 edge_to_id_map[edge] = i;
 id_to_edge_map[i] = edge;
 }
}


RIFG::~RIFG()
{
 node_to_id_map.clear();
 id_to_node_map.clear();
 edge_to_id_map.clear();
 id_to_edge_map.clear();
}


bool 
RIFG::isValid(RIFG::NodeId nid) const
{
 return true;
}


RIFG::NodeId 
RIFG::getSource() const
{
 return (getNodeId(mSource));
}


RIFG::NodeId 
RIFG::getSink() const
{
 return (getNodeId(mSink));
}

RIFG::NodeId 
RIFG::getEdgeSrc(RIFG::EdgeId eid) const
{
 OA::OA_ptr<OA::DGraph::EdgeInterface> e = getEdge(eid);
 OA::OA_ptr<OA::DGraph::NodeInterface> n = e->getSource();
 return (getNodeId(n));
}


RIFG::NodeId 
RIFG::getEdgeSink(RIFG::EdgeId eid) const
{
 OA::OA_ptr<OA::DGraph::EdgeInterface> e = getEdge(eid);
 OA::OA_ptr<OA::DGraph::NodeInterface> n = e->getSink();
 return (getNodeId(n));
}


OA_ptr<RIFG::NodesIterator>
RIFG::getNodesIterator() const
{
 OA_ptr<RIFG::NodesIterator> it;
 it = new NodesIterator(*this);
 return it;
}


OA_ptr<RIFG::IncomingEdgesIterator>
RIFG::getIncomingEdgesIterator(NodeId nid) const
{
 OA_ptr<RIFG::IncomingEdgesIterator> it;
 it = new IncomingEdgesIterator(*this, nid);
 return it;
}


OA_ptr<RIFG::OutgoingEdgesIterator>
RIFG::getOutgoingEdgesIterator(NodeId nid) const
{
 OA_ptr<RIFG::OutgoingEdgesIterator> it;
 it = new OutgoingEdgesIterator(*this, nid);
 return it;
}


void 
RIFG::dumpNode(std::ostream& os, RIFG::NodeId nid)
{
 // getNode(nid)->dump(os);
}


//***************************************************************************
// 
//***************************************************************************

OA_ptr<DGraph::NodeInterface> 
RIFG::getSourceNode(OA_ptr<DGraph::DGraphInterface> graph)
{
 if (graph.isa<OA::CFG::CFGInterface>()) {
 OA_ptr<OA::CFG::CFGInterface> g = graph.convert<OA::CFG::CFGInterface>();
 OA_ptr<OA::CFG::NodeInterface> n = g->getEntry();
 return n;
 }
 else {
 OA_ptr<DGraph::NodesIteratorInterface> it = 
 graph->getEntryNodesIterator();
 assert(it->isValid());
 OA_ptr<DGraph::NodeInterface> n = it->current();
 return n;
 }
}

OA_ptr<DGraph::NodeInterface> 
RIFG::getSinkNode(OA_ptr<DGraph::DGraphInterface> graph)
{
 if (graph.isa<OA::CFG::CFGInterface>()) {
 OA_ptr<OA::CFG::CFGInterface> g = graph.convert<OA::CFG::CFGInterface>();
 OA_ptr<OA::CFG::NodeInterface> n = g->getExit();
 return n;
 }
 else {
 OA_ptr<DGraph::NodesIteratorInterface> it = 
 graph->getExitNodesIterator();
 assert(it->isValid());
 OA_ptr<DGraph::NodeInterface> n = it->current();
 return n;
 }
}

} // end of namespace OA