staticCFG.h

#ifndef STATIC_CFG_H 
#define STATIC_CFG_H 
 
#include <sage3basic.h>
#include "AstAttributeMechanism.h"
#include "virtualCFG.h"
#include <map>
#include <set>
#include <string>
 
 
class SgIncidenceDirectedGraph;
class SgGraphNode;
class SgDirectedGraphEdge;
 
 
namespace StaticCFG 
{
 
using VirtualCFG::CFGNode;
using VirtualCFG::CFGEdge;
 
 
class ROSE_DLL_API CFG
{
protected:
    SgIncidenceDirectedGraph* graph_;
 
    std::map<CFGNode, SgGraphNode*> all_nodes_;
 
    SgNode* start_;
 
    SgGraphNode* entry_;
 
    SgGraphNode* exit_;
 
    bool is_filtered_;
 
public:
    CFG() : graph_(NULL), start_(NULL), entry_(NULL), exit_(NULL) {}
 
    CFGNode toCFGNode(SgGraphNode* node);
    
    SgGraphNode *toGraphNode(CFGNode &n) { return ((all_nodes_.count(n)==0) ?  NULL : all_nodes_[n]);}
    
 
#if 0
    CFG(SgNode* node, bool is_filtered = false)
        : graph_(NULL), start_(node), entry_(NULL), exit_(NULL), is_filtered_(is_filtered)
    { buildCFG(); }
#else
    CFG(SgNode* node, bool is_filtered = false);
#endif
 
    SgIncidenceDirectedGraph* getGraph() const
    { return graph_; }
 
    virtual ~CFG()
    { clearNodesAndEdges(); }
 
 
    void setStart(SgNode* node) { start_ = node; }
 
    SgGraphNode* getEntry() const
    { return entry_; }
 
    SgGraphNode* getExit() const
    { return exit_; }
 
    bool isFilteredCFG() const { return is_filtered_; }
    void setFiltered(bool flag) { is_filtered_ = flag; }
 
 
    virtual void buildCFG()
    {
        if (is_filtered_) buildFilteredCFG();
        else buildFullCFG();
    }
 
    virtual void buildFullCFG();
 
    virtual void buildFilteredCFG();
    
 
#if 0
    std::vector<SgDirectedGraphEdge*> getOutEdges(SgNode* node, int index);
    std::vector<SgDirectedGraphEdge*> getInEdges(SgNode* node, int index);
#endif
 
    // The following four functions are for getting in/out edges of a given node.
    std::vector<SgDirectedGraphEdge*> getOutEdges(SgGraphNode* node);
    std::vector<SgDirectedGraphEdge*> getInEdges(SgGraphNode* node);
 
    // Provide the same interface to get the beginning/end graph node for a SgNode
    SgGraphNode* cfgForBeginning(SgNode* node);
    SgGraphNode* cfgForEnd(SgNode* node);
 
    static int getIndex(SgGraphNode* node);
 
    void cfgToDot(SgNode* node, const std::string& file_name);
 
protected:
    //void buildCFG(CFGNode n);
    template <class NodeT, class EdgeT>
    void buildCFG(NodeT n, std::map<NodeT, SgGraphNode*>& all_nodes, std::set<NodeT>& explored);
 
    void clearNodesAndEdges();
 
    
 
    // The following methods are used to build a DOT file.
    virtual void processNodes(std::ostream & o, SgGraphNode* n, std::set<SgGraphNode*>& explored);
    virtual void printNodePlusEdges(std::ostream & o, SgGraphNode* node);
    virtual void printNode(std::ostream & o, SgGraphNode* node);
    virtual void printEdge(std::ostream & o, SgDirectedGraphEdge* edge, bool isInEdge);
};
 
 
class CFGNodeAttribute : public AstAttribute
{
    int index_;
    SgIncidenceDirectedGraph* graph_;
 
public:
    CFGNodeAttribute(int idx = 0, SgIncidenceDirectedGraph* graph = NULL) 
        : index_(idx), graph_(graph) {}
 
    int getIndex() const { return index_; }
 
    void setIndex(int idx) { index_ = idx; }
 
    const SgIncidenceDirectedGraph* getGraph() const { return graph_; }
    SgIncidenceDirectedGraph* getGraph() { return graph_; }
 
    void setGraph(SgIncidenceDirectedGraph* graph)
    { graph_ = graph; }
};
 
template <class EdgeT>
class CFGEdgeAttribute : public AstAttribute
{
    EdgeT edge_;
public:
    CFGEdgeAttribute(const EdgeT& e) : edge_(e) {}
 
    void setEdge(const EdgeT& e)
    { edge_ = e; }
    
    EdgeT getEdge() const
    { return edge_; }
};
 
// The following are some auxiliary functions, since SgGraphNode cannot provide them.
std::vector<SgDirectedGraphEdge*> outEdges(SgGraphNode* node);
std::vector<SgDirectedGraphEdge*> inEdges(SgGraphNode* node);
 
} // end of namespace StaticCFG
 
#endif