SVF::ICFG Class Reference

#include <ICFG.h>

Inheritance diagram for SVF::ICFG:

Public Types
typedef OrderedMap< NodeID, ICFGNode * >	ICFGNodeIDToNodeMapTy
typedef ICFGEdge::ICFGEdgeSetTy	ICFGEdgeSetTy
typedef ICFGNodeIDToNodeMapTy::iterator	iterator
typedef ICFGNodeIDToNodeMapTy::const_iterator	const_iterator
typedef Map< const SVFFunction *, FunEntryICFGNode * >	FunToFunEntryNodeMapTy
typedef Map< const SVFFunction *, FunExitICFGNode * >	FunToFunExitNodeMapTy
typedef std::vector< const SVFLoop * >	SVFLoopVec
typedef Map< const ICFGNode *, SVFLoopVec >	ICFGNodeToSVFLoopVec
Public Types inherited from SVF::GenericGraph< NodeTy, EdgeTy >
typedef NodeTy	NodeType
typedef EdgeTy	EdgeType
typedef OrderedMap< NodeID, NodeType * >	IDToNodeMapTy
	NodeID to GenericNode map. More...
typedef IDToNodeMapTy::iterator	iterator
	Node Iterators. More...
typedef IDToNodeMapTy::const_iterator	const_iterator

Public Member Functions
	ICFG ()
	Constructor. More...
	~ICFG () override
	Destructor. More...
ICFGNode *	getICFGNode (NodeID id) const
	Get a ICFG node. More...
bool	hasICFGNode (NodeID id) const
	Whether has the ICFGNode. More...
ICFGEdge *	hasIntraICFGEdge (ICFGNode *src, ICFGNode *dst, ICFGEdge::ICFGEdgeK kind)
	Whether we has a SVFG edge. More...
ICFGEdge *	hasInterICFGEdge (ICFGNode *src, ICFGNode *dst, ICFGEdge::ICFGEdgeK kind)
ICFGEdge *	hasThreadICFGEdge (ICFGNode *src, ICFGNode *dst, ICFGEdge::ICFGEdgeK kind)
ICFGEdge *	getICFGEdge (const ICFGNode *src, const ICFGNode *dst, ICFGEdge::ICFGEdgeK kind)
	Get a SVFG edge according to src and dst. More...
void	dump (const std::string &file, bool simple=false)
	Dump graph into dot file. More...
void	view ()
	View graph from the debugger. More...
void	updateCallGraph (PTACallGraph *callgraph)
	update ICFG for indirect calls More...
bool	isInLoop (const ICFGNode *node)
	Whether node is in a loop. More...
void	addNodeToSVFLoop (const ICFGNode *node, const SVFLoop *loop)
	Insert (node, loop) to icfgNodeToSVFLoopVec. More...
SVFLoopVec &	getSVFLoops (const ICFGNode *node)
	Get loops where a node resides. More...
const ICFGNodeToSVFLoopVec &	getIcfgNodeToSVFLoopVec () const
FunEntryICFGNode *	getFunEntryICFGNode (const SVFFunction *fun)
	Add a function entry node. More...
FunExitICFGNode *	getFunExitICFGNode (const SVFFunction *fun)
	Add a function exit node. More...
GlobalICFGNode *	getGlobalICFGNode () const
const std::vector< const ICFGNode * > &	getSubNodes (const ICFGNode *node) const
const ICFGNode *	getRepNode (const ICFGNode *node) const
void	updateSubAndRep (const ICFGNode *rep, const ICFGNode *sub)
Public Member Functions inherited from SVF::GenericGraph< NodeTy, EdgeTy >
	GenericGraph ()
	Constructor. More...
virtual	~GenericGraph ()
	Destructor. More...
void	destroy ()
	Release memory. More...
iterator	begin ()
	Iterators. More...
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
void	addGNode (NodeID id, NodeType *node)
	Add a Node. More...
NodeType *	getGNode (NodeID id) const
	Get a node. More...
bool	hasGNode (NodeID id) const
	Has a node. More...
void	removeGNode (NodeType *node)
	Delete a node. More...
u32_t	getTotalNodeNum () const
	Get total number of node/edge. More...
u32_t	getTotalEdgeNum () const
void	incNodeNum ()
	Increase number of node/edge. More...
void	incEdgeNum ()

Public Attributes
NodeID	totalICFGNode
Public Attributes inherited from SVF::GenericGraph< NodeTy, EdgeTy >
u32_t	edgeNum
	total num of node More...
u32_t	nodeNum
	total num of edge More...

Protected Member Functions
ICFGEdge *	addIntraEdge (ICFGNode *srcNode, ICFGNode *dstNode)
	Add intraprocedural and interprocedural control-flow edges. More...
ICFGEdge *	addConditionalIntraEdge (ICFGNode *srcNode, ICFGNode *dstNode, s64_t branchCondVal)
ICFGEdge *	addCallEdge (ICFGNode *srcNode, ICFGNode *dstNode)
ICFGEdge *	addRetEdge (ICFGNode *srcNode, ICFGNode *dstNode)
void	removeICFGEdge (ICFGEdge *edge)
	Remove a ICFG edge. More...
void	removeICFGNode (ICFGNode *node)
	Remove a ICFGNode. More...
void	checkIntraEdgeParents (const ICFGNode *srcNode, const ICFGNode *dstNode)
	sanitize Intra edges, verify that both nodes belong to the same function. More...
virtual IntraICFGNode *	addIntraICFGNode (const SVFBasicBlock *bb, bool isRet)
virtual CallICFGNode *	addCallICFGNode (const SVFBasicBlock *bb, const SVFType *ty, const SVFFunction *calledFunc, bool isVararg, bool isvcall, s32_t vcallIdx, const std::string &funNameOfVcall)
virtual RetICFGNode *	addRetICFGNode (CallICFGNode *call)
virtual FunEntryICFGNode *	addFunEntryICFGNode (const SVFFunction *svfFunc)
virtual FunExitICFGNode *	addFunExitICFGNode (const SVFFunction *svfFunc)
virtual void	addICFGNode (ICFGNode *node)
	Add a ICFG node. More...

Private Member Functions
void	addSubNode (const ICFGNode *rep, const ICFGNode *sub)
	when ICFG is simplified, SubNode would merge repNode, then update the map More...
void	updateRepNode (const ICFGNode *rep, const ICFGNode *sub)
	when ICFG is simplified, some node would be removed, this map records the removed node to its rep node More...
bool	addICFGEdge (ICFGEdge *edge)
	Add ICFG edge, only used by addIntraEdge, addCallEdge, addRetEdge etc. More...
FunEntryICFGNode *	getFunEntryBlock (const SVFFunction *fun)
	Get/Add a function entry node. More...
FunExitICFGNode *	getFunExitBlock (const SVFFunction *fun)
	Get/Add a function exit node. More...

Private Attributes
FunToFunEntryNodeMapTy	FunToFunEntryNodeMap
	map a function to its FunExitICFGNode More...
FunToFunExitNodeMapTy	FunToFunExitNodeMap
	map a function to its FunEntryICFGNode More...
GlobalICFGNode *	globalBlockNode
	unique basic block for all globals More...
ICFGNodeToSVFLoopVec	icfgNodeToSVFLoopVec
	map ICFG node to the SVF loops where it resides More...
Map< const ICFGNode *, std::vector< const ICFGNode * > >	_subNodes
	map a node(1st node of basicblock) to its subnodes More...
Map< const ICFGNode *, const ICFGNode * >	_repNode
	map a subnode to its representative node(1st node of basicblock) More...

Friends
class	ICFGBuilder
class	SVFIRWriter
class	SVFIRReader
class	ICFGSimplification

Additional Inherited Members
Protected Attributes inherited from SVF::GenericGraph< NodeTy, EdgeTy >
IDToNodeMapTy	IDToNodeMap
	node map More...

Detailed Description

Definition at line 47 of file ICFG.h.

Member Typedef Documentation

const_iterator

typedef ICFGNodeIDToNodeMapTy::const_iterator SVF::ICFG::const_iterator

Definition at line 59 of file ICFG.h.

FunToFunEntryNodeMapTy

typedef Map<const SVFFunction*, FunEntryICFGNode *> SVF::ICFG::FunToFunEntryNodeMapTy

Definition at line 61 of file ICFG.h.

FunToFunExitNodeMapTy

typedef Map<const SVFFunction*, FunExitICFGNode *> SVF::ICFG::FunToFunExitNodeMapTy

Definition at line 62 of file ICFG.h.

ICFGEdgeSetTy

typedef ICFGEdge::ICFGEdgeSetTy SVF::ICFG::ICFGEdgeSetTy

Definition at line 57 of file ICFG.h.

ICFGNodeIDToNodeMapTy

typedef OrderedMap<NodeID, ICFGNode *> SVF::ICFG::ICFGNodeIDToNodeMapTy

Definition at line 56 of file ICFG.h.

ICFGNodeToSVFLoopVec

typedef Map<const ICFGNode *, SVFLoopVec> SVF::ICFG::ICFGNodeToSVFLoopVec

Definition at line 64 of file ICFG.h.

iterator

typedef ICFGNodeIDToNodeMapTy::iterator SVF::ICFG::iterator

Definition at line 58 of file ICFG.h.

SVFLoopVec

typedef std::vector<const SVFLoop *> SVF::ICFG::SVFLoopVec

Definition at line 63 of file ICFG.h.

Constructor & Destructor Documentation

ICFG()

ICFG::ICFG

(

)

Constructor.

Constructor

• Build ICFG 1) build ICFG nodes statements for top level pointers (PAGEdges) 2) connect ICFG edges between two statements (PAGEdges)

Definition at line 210 of file ICFG.cpp.

          : totalICFGNode(0), globalBlockNode(nullptr)
{
}

~ICFG()

ICFG::~ICFG ( )

override

Destructor.

Definition at line 214 of file ICFG.cpp.

{
    Set<const SVFLoop*> loops;
    for (const auto &it: icfgNodeToSVFLoopVec)
    {
        for (const auto &loop: it.second)
        {
            loops.insert(loop);
        }
    }
 
    for (const auto &it: loops)
    {
        delete it;
    }
    icfgNodeToSVFLoopVec.clear();
}

Member Function Documentation

addCallEdge()

ICFGEdge * ICFG::addCallEdge ( ICFGNode *  srcNode, ICFGNode *  dstNode  )

protected

Add interprocedural call edges between two nodes

Definition at line 366 of file ICFG.cpp.

{
    ICFGEdge* edge = hasInterICFGEdge(srcNode,dstNode, ICFGEdge::CallCF);
    if (edge != nullptr)
    {
        assert(edge->isCallCFGEdge() && "this should be a call CFG edge!");
        return nullptr;
    }
    else
    {
        CallCFGEdge* callEdge = new CallCFGEdge(srcNode,dstNode);
        return (addICFGEdge(callEdge) ? callEdge : nullptr);
    }
}

addCallICFGNode()

virtual CallICFGNode* SVF::ICFG::addCallICFGNode ( const SVFBasicBlock *  bb, const SVFType *  ty, const SVFFunction *  calledFunc, bool  isVararg, bool  isvcall, s32_t  vcallIdx, const std::string &  funNameOfVcall  )

inlineprotectedvirtual

Definition at line 183 of file ICFG.h.

    {
 
        CallICFGNode* callICFGNode =
            new CallICFGNode(totalICFGNode++, bb, ty, calledFunc, isVararg,
                             isvcall, vcallIdx, funNameOfVcall);
        addICFGNode(callICFGNode);
        return callICFGNode;
    }

addConditionalIntraEdge()

ICFGEdge * ICFG::addConditionalIntraEdge ( ICFGNode *  srcNode, ICFGNode *  dstNode, s64_t  branchCondVal  )

protected

Add conditional intraprocedural edges between two nodes

Definition at line 344 of file ICFG.cpp.

{
 
    checkIntraEdgeParents(srcNode, dstNode);
    ICFGEdge* edge = hasIntraICFGEdge(srcNode, dstNode, ICFGEdge::IntraCF);
    if (edge != nullptr)
    {
        assert(edge->isIntraCFGEdge() && "this should be an intra CFG edge!");
        return nullptr;
    }
    else
    {
        IntraCFGEdge* intraEdge = new IntraCFGEdge(srcNode,dstNode);
        intraEdge->setBranchCondVal(branchCondVal);
        return (addICFGEdge(intraEdge) ? intraEdge : nullptr);
    }
}

addFunEntryICFGNode()

virtual FunEntryICFGNode* SVF::ICFG::addFunEntryICFGNode ( const SVFFunction *  svfFunc )

inlineprotectedvirtual

Definition at line 204 of file ICFG.h.

    {
        FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,svfFunc);
        addICFGNode(sNode);
        return FunToFunEntryNodeMap[svfFunc] = sNode;
    }

addFunExitICFGNode()

virtual FunExitICFGNode* SVF::ICFG::addFunExitICFGNode ( const SVFFunction *  svfFunc )

inlineprotectedvirtual

Definition at line 211 of file ICFG.h.

    {
        FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, svfFunc);
        addICFGNode(sNode);
        return FunToFunExitNodeMap[svfFunc] = sNode;
    }

addICFGEdge()

bool SVF::ICFG::addICFGEdge ( ICFGEdge *  edge )

inlineprivate

Add ICFG edge, only used by addIntraEdge, addCallEdge, addRetEdge etc.

Definition at line 277 of file ICFG.h.

    {
        bool added1 = edge->getDstNode()->addIncomingEdge(edge);
        bool added2 = edge->getSrcNode()->addOutgoingEdge(edge);
        bool all_added = added1 && added2;
        assert(all_added && "ICFGEdge not added?");
        return all_added;
    }

addICFGNode()

virtual void SVF::ICFG::addICFGNode ( ICFGNode *  node )

inlineprotectedvirtual

Add a ICFG node.

Definition at line 219 of file ICFG.h.

    {
        addGNode(node->getId(),node);
        _repNode[node] = node;
        _subNodes[node].push_back(node);
    }

addIntraEdge()

ICFGEdge * ICFG::addIntraEdge ( ICFGNode *  srcNode, ICFGNode *  dstNode  )

protected

Add intraprocedural and interprocedural control-flow edges.

Add intraprocedural edges between two nodes

Definition at line 325 of file ICFG.cpp.

{
    checkIntraEdgeParents(srcNode, dstNode);
    ICFGEdge* edge = hasIntraICFGEdge(srcNode, dstNode, ICFGEdge::IntraCF);
    if (edge != nullptr)
    {
        assert(edge->isIntraCFGEdge() && "this should be an intra CFG edge!");
        return nullptr;
    }
    else
    {
        IntraCFGEdge* intraEdge = new IntraCFGEdge(srcNode,dstNode);
        return (addICFGEdge(intraEdge) ? intraEdge : nullptr);
    }
}

addIntraICFGNode()

virtual IntraICFGNode* SVF::ICFG::addIntraICFGNode ( const SVFBasicBlock *  bb, bool  isRet  )

inlineprotectedvirtual

Definition at line 175 of file ICFG.h.

    {
        IntraICFGNode* intraIcfgNode =
            new IntraICFGNode(totalICFGNode++, bb, isRet);
        addICFGNode(intraIcfgNode);
        return intraIcfgNode;
    }

addNodeToSVFLoop()

void SVF::ICFG::addNodeToSVFLoop ( const ICFGNode *  node, const SVFLoop *  loop  )

inline

Insert (node, loop) to icfgNodeToSVFLoopVec.

Definition at line 124 of file ICFG.h.

    {
        icfgNodeToSVFLoopVec[node].push_back(loop);
    }

addRetEdge()

ICFGEdge * ICFG::addRetEdge ( ICFGNode *  srcNode, ICFGNode *  dstNode  )

protected

Add interprocedural return edges between two nodes

Definition at line 384 of file ICFG.cpp.

{
    ICFGEdge* edge = hasInterICFGEdge(srcNode, dstNode, ICFGEdge::RetCF);
    if (edge != nullptr)
    {
        assert(edge->isRetCFGEdge() && "this should be a return CFG edge!");
        return nullptr;
    }
    else
    {
        RetCFGEdge* retEdge = new RetCFGEdge(srcNode,dstNode);
        return (addICFGEdge(retEdge) ? retEdge : nullptr);
    }
}

addRetICFGNode()

virtual RetICFGNode* SVF::ICFG::addRetICFGNode ( CallICFGNode *  call )

inlineprotectedvirtual

Definition at line 196 of file ICFG.h.

    {
        RetICFGNode* retICFGNode = new RetICFGNode(totalICFGNode++, call);
        call->setRetICFGNode(retICFGNode);
        addICFGNode(retICFGNode);
        return retICFGNode;
    }

addSubNode()

void SVF::ICFG::addSubNode ( const ICFGNode *  rep, const ICFGNode *  sub  )

inlineprivate

when ICFG is simplified, SubNode would merge repNode, then update the map

Definition at line 261 of file ICFG.h.

    {
        std::vector<const ICFGNode*>& subNodes = _subNodes[sub];
        if(std::find(subNodes.begin(), subNodes.end(), rep) == subNodes.end())
        {
            subNodes.push_back(rep);
        }
    }

checkIntraEdgeParents()

void SVF::ICFG::checkIntraEdgeParents ( const ICFGNode *  srcNode, const ICFGNode *  dstNode  )

inlineprotected

sanitize Intra edges, verify that both nodes belong to the same function.

Definition at line 165 of file ICFG.h.

    {
        const SVFFunction* srcfun = srcNode->getFun();
        const SVFFunction* dstfun = dstNode->getFun();
        if(srcfun != nullptr && dstfun != nullptr)
        {
            assert((srcfun == dstfun) && "src and dst nodes of an intra edge should in the same function!" );
        }
    }

dump()

void ICFG::dump	(	const std::string &	file,
		bool	simple = false
	)

Dump graph into dot file.

Dump ICFG

Definition at line 403 of file ICFG.cpp.

{
    GraphPrinter::WriteGraphToFile(outs(), file, this, simple);
}

getFunEntryBlock()

FunEntryICFGNode* SVF::ICFG::getFunEntryBlock ( const SVFFunction *  fun )

inlineprivate

Get/Add a function entry node.

Definition at line 287 of file ICFG.h.

    {
        FunToFunEntryNodeMapTy::const_iterator it = FunToFunEntryNodeMap.find(fun);
        if (it == FunToFunEntryNodeMap.end())
            return nullptr;
        return it->second;
    }

getFunEntryICFGNode()

FunEntryICFGNode * ICFG::getFunEntryICFGNode

(

const SVFFunction *

fun

)

Add a function entry node.

Get a basic block ICFGNode TODO:: need to fix the assertions

Definition at line 234 of file ICFG.cpp.

{
    FunEntryICFGNode* entry = getFunEntryBlock(fun);
    assert (entry && "fun entry not created in ICFGBuilder?");
    return entry;
}

getFunExitBlock()

FunExitICFGNode* SVF::ICFG::getFunExitBlock ( const SVFFunction *  fun )

inlineprivate

Get/Add a function exit node.

Definition at line 296 of file ICFG.h.

    {
        FunToFunExitNodeMapTy::const_iterator it = FunToFunExitNodeMap.find(fun);
        if (it == FunToFunExitNodeMap.end())
            return nullptr;
        return it->second;
    }

getFunExitICFGNode()

FunExitICFGNode * ICFG::getFunExitICFGNode

(

const SVFFunction *

fun

)

Add a function exit node.

Definition at line 241 of file ICFG.cpp.

{
    FunExitICFGNode* exit = getFunExitBlock(fun);
    assert (exit && "fun exit not created in ICFGBuilder?");
    return exit;
}

getGlobalICFGNode()

GlobalICFGNode* SVF::ICFG::getGlobalICFGNode ( ) const

inline

Definition at line 236 of file ICFG.h.

    {
        return globalBlockNode;
    }

getICFGEdge()

ICFGEdge * ICFG::getICFGEdge	(	const ICFGNode *	src,
		const ICFGNode *	dst,
		ICFGEdge::ICFGEdgeK	kind
	)

Get a SVFG edge according to src and dst.

Return the corresponding ICFGEdge

Definition at line 303 of file ICFG.cpp.

{
 
    ICFGEdge * edge = nullptr;
    u32_t counter = 0;
    for (ICFGEdge::ICFGEdgeSetTy::iterator iter = src->OutEdgeBegin();
            iter != src->OutEdgeEnd(); ++iter)
    {
        if ((*iter)->getDstID() == dst->getId() && (*iter)->getEdgeKind() == kind)
        {
            counter++;
            edge = (*iter);
        }
    }
    assert(counter <= 1 && "there's more than one edge between two ICFG nodes");
    return edge;
 
}

getICFGNode()

ICFGNode* SVF::ICFG::getICFGNode ( NodeID  id ) const

inline

Get a ICFG node.

Definition at line 86 of file ICFG.h.

    {
        return getGNode(id);
    }

getIcfgNodeToSVFLoopVec()

const ICFGNodeToSVFLoopVec& SVF::ICFG::getIcfgNodeToSVFLoopVec ( ) const

inline

Definition at line 137 of file ICFG.h.

    {
        return icfgNodeToSVFLoopVec;
    }

getRepNode()

const ICFGNode* SVF::ICFG::getRepNode ( const ICFGNode *  node ) const

inline

Definition at line 246 of file ICFG.h.

    {
        return _repNode.at(node);
    }

getSubNodes()

const std::vector<const ICFGNode*>& SVF::ICFG::getSubNodes ( const ICFGNode *  node ) const

inline

Definition at line 241 of file ICFG.h.

    {
        return _subNodes.at(node);
    }

getSVFLoops()

SVFLoopVec& SVF::ICFG::getSVFLoops ( const ICFGNode *  node )

inline

Get loops where a node resides.

Definition at line 130 of file ICFG.h.

    {
        auto it = icfgNodeToSVFLoopVec.find(node);
        assert(it != icfgNodeToSVFLoopVec.end() && "node not in loop");
        return it->second;
    }

hasICFGNode()

bool SVF::ICFG::hasICFGNode ( NodeID  id ) const

inline

Whether has the ICFGNode.

Definition at line 92 of file ICFG.h.

    {
        return hasGNode(id);
    }

hasInterICFGEdge()

ICFGEdge * ICFG::hasInterICFGEdge	(	ICFGNode *	src,
		ICFGNode *	dst,
		ICFGEdge::ICFGEdgeK	kind
	)

Whether we has an inter ICFG edge

Definition at line 268 of file ICFG.cpp.

{
    ICFGEdge edge(src,dst, kind);
    ICFGEdge* outEdge = src->hasOutgoingEdge(&edge);
    ICFGEdge* inEdge = dst->hasIncomingEdge(&edge);
    if (outEdge && inEdge)
    {
        assert(outEdge == inEdge && "edges not match");
        return outEdge;
    }
    else
        return nullptr;
}

hasIntraICFGEdge()

ICFGEdge * ICFG::hasIntraICFGEdge	(	ICFGNode *	src,
		ICFGNode *	dst,
		ICFGEdge::ICFGEdgeK	kind
	)

Whether we has a SVFG edge.

Whether we has an intra ICFG edge

Definition at line 251 of file ICFG.cpp.

{
    ICFGEdge edge(src,dst,kind);
    ICFGEdge* outEdge = src->hasOutgoingEdge(&edge);
    ICFGEdge* inEdge = dst->hasIncomingEdge(&edge);
    if (outEdge && inEdge)
    {
        assert(outEdge == inEdge && "edges not match");
        return outEdge;
    }
    else
        return nullptr;
}

hasThreadICFGEdge()

ICFGEdge * ICFG::hasThreadICFGEdge	(	ICFGNode *	src,
		ICFGNode *	dst,
		ICFGEdge::ICFGEdgeK	kind
	)

Whether we has an thread ICFG edge

Definition at line 285 of file ICFG.cpp.

{
    ICFGEdge edge(src,dst,kind);
    ICFGEdge* outEdge = src->hasOutgoingEdge(&edge);
    ICFGEdge* inEdge = dst->hasIncomingEdge(&edge);
    if (outEdge && inEdge)
    {
        assert(outEdge == inEdge && "edges not match");
        return outEdge;
    }
    else
        return nullptr;
}

isInLoop()

bool SVF::ICFG::isInLoop ( const ICFGNode *  node )

inline

Whether node is in a loop.

Definition at line 117 of file ICFG.h.

    {
        auto it = icfgNodeToSVFLoopVec.find(node);
        return it != icfgNodeToSVFLoopVec.end();
    }

removeICFGEdge()

void SVF::ICFG::removeICFGEdge ( ICFGEdge *  edge )

inlineprotected

Remove a ICFG edge.

Definition at line 151 of file ICFG.h.

    {
        edge->getDstNode()->removeIncomingEdge(edge);
        edge->getSrcNode()->removeOutgoingEdge(edge);
        delete edge;
    }

removeICFGNode()

void SVF::ICFG::removeICFGNode ( ICFGNode *  node )

inlineprotected

Remove a ICFGNode.

Definition at line 159 of file ICFG.h.

    {
        removeGNode(node);
    }

updateCallGraph()

void ICFG::updateCallGraph

(

PTACallGraph *

callgraph

)

update ICFG for indirect calls

Update ICFG for indirect calls

if this is an external function (no function body), connect calleeEntryNode to calleeExitNode

Remove callBlockNode to retBlockNode intraICFGEdge since we found at least one inter procedural edge

Definition at line 419 of file ICFG.cpp.

{
    PTACallGraph::CallEdgeMap::const_iterator iter = callgraph->getIndCallMap().begin();
    PTACallGraph::CallEdgeMap::const_iterator eiter = callgraph->getIndCallMap().end();
    for (; iter != eiter; iter++)
    {
        CallICFGNode* callBlockNode = const_cast<CallICFGNode*>(iter->first);
        assert(callBlockNode->isIndirectCall() && "this is not an indirect call?");
        const PTACallGraph::FunctionSet & functions = iter->second;
        for (PTACallGraph::FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
        {
            const SVFFunction*  callee = *func_iter;
            RetICFGNode* retBlockNode = const_cast<RetICFGNode*>(callBlockNode->getRetICFGNode());
            if (isExtCall(callee))
                addIntraEdge(callBlockNode, retBlockNode);
            else
            {
                FunEntryICFGNode* calleeEntryNode = getFunEntryBlock(callee);
                FunExitICFGNode* calleeExitNode = getFunExitBlock(callee);
                if(ICFGEdge* callEdge = addCallEdge(callBlockNode, calleeEntryNode))
                {
                    for (const SVFStmt *stmt : callBlockNode->getSVFStmts())
                    {
                        if(const CallPE *callPE = SVFUtil::dyn_cast<CallPE>(stmt))
                        {
                            if(callPE->getFunEntryICFGNode() == calleeEntryNode)
                                SVFUtil::cast<CallCFGEdge>(callEdge)->addCallPE(callPE);
                        }
                    }
                }
                if(ICFGEdge* retEdge = addRetEdge(calleeExitNode, retBlockNode))
                {
                    for (const SVFStmt *stmt : retBlockNode->getSVFStmts())
                    {
                        if(const RetPE *retPE = SVFUtil::dyn_cast<RetPE>(stmt))
                        {
                            if(retPE->getFunExitICFGNode() == calleeExitNode)
                                SVFUtil::cast<RetCFGEdge>(retEdge)->addRetPE(retPE);
                        }
                    }
                }
 
                if(ICFGEdge* edge = hasIntraICFGEdge(callBlockNode,retBlockNode, ICFGEdge::IntraCF))
                    removeICFGEdge(edge);
            }
 
        }
    }
    // dump ICFG
    if (Options::DumpICFG())
    {
        dump("icfg_final");
    }
}

updateRepNode()

void SVF::ICFG::updateRepNode ( const ICFGNode *  rep, const ICFGNode *  sub  )

inlineprivate

when ICFG is simplified, some node would be removed, this map records the removed node to its rep node

Definition at line 271 of file ICFG.h.

    {
        _repNode[rep] = sub;
    }

updateSubAndRep()

void SVF::ICFG::updateSubAndRep ( const ICFGNode *  rep, const ICFGNode *  sub  )

inline

Definition at line 252 of file ICFG.h.

    {
        addSubNode(rep, sub);
        updateRepNode(rep, sub);
    }

view()

void ICFG::view

(

)

View graph from the debugger.

View ICFG

Definition at line 411 of file ICFG.cpp.

{
    SVF::ViewGraph(this, "Interprocedural Control-Flow Graph");
}

Friends And Related Function Documentation

ICFGBuilder

friend class ICFGBuilder

friend

Definition at line 49 of file ICFG.h.

ICFGSimplification

friend class ICFGSimplification

friend

Definition at line 52 of file ICFG.h.

SVFIRReader

friend class SVFIRReader

friend

Definition at line 51 of file ICFG.h.

SVFIRWriter

friend class SVFIRWriter

friend

Definition at line 50 of file ICFG.h.

Member Data Documentation

_repNode

Map<const ICFGNode*, const ICFGNode*> SVF::ICFG::_repNode

private

map a subnode to its representative node(1st node of basicblock)

Definition at line 75 of file ICFG.h.

_subNodes

Map<const ICFGNode*, std::vector<const ICFGNode*> > SVF::ICFG::_subNodes

private

map a node(1st node of basicblock) to its subnodes

Definition at line 74 of file ICFG.h.

FunToFunEntryNodeMap

FunToFunEntryNodeMapTy SVF::ICFG::FunToFunEntryNodeMap

private

map a function to its FunExitICFGNode

Definition at line 69 of file ICFG.h.

FunToFunExitNodeMap

FunToFunExitNodeMapTy SVF::ICFG::FunToFunExitNodeMap

private

map a function to its FunEntryICFGNode

Definition at line 70 of file ICFG.h.

globalBlockNode

GlobalICFGNode* SVF::ICFG::globalBlockNode

private

unique basic block for all globals

Definition at line 71 of file ICFG.h.

icfgNodeToSVFLoopVec

ICFGNodeToSVFLoopVec SVF::ICFG::icfgNodeToSVFLoopVec

private

map ICFG node to the SVF loops where it resides

Definition at line 72 of file ICFG.h.

totalICFGNode

NodeID SVF::ICFG::totalICFGNode

Definition at line 66 of file ICFG.h.

---

The documentation for this class was generated from the following files:

• /home/runner/work/SVF/SVF/svf/include/Graphs/ICFG.h
• /home/runner/work/SVF/SVF/svf/lib/Graphs/ICFG.cpp