#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.

typedef IDToNodeMapTy::iterator	iterator
	Node Iterators.

typedef IDToNodeMapTy::const_iterator	const_iterator

Public Member Functions
	ICFG ()
	Constructor.

	~ICFG () override
	Destructor.

ICFGNode *	getICFGNode (NodeID id) const
	Get a ICFG node.

bool	hasICFGNode (NodeID id) const
	Whether has the ICFGNode.

ICFGEdge *	hasIntraICFGEdge (ICFGNode src, ICFGNode dst, ICFGEdge::ICFGEdgeK kind)
	Whether we has a SVFG edge.

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.

void	dump (const std::string &file, bool simple=false)
	Dump graph into dot file.

void	view ()
	View graph from the debugger.

void	updateCallGraph (PTACallGraph *callgraph)
	update ICFG for indirect calls

bool	isInLoop (const ICFGNode *node)
	Whether node is in a loop.

void	addNodeToSVFLoop (const ICFGNode node, const SVFLoop loop)
	Insert (node, loop) to icfgNodeToSVFLoopVec.

SVFLoopVec &	getSVFLoops (const ICFGNode *node)
	Get loops where a node resides.

const ICFGNodeToSVFLoopVec &	getIcfgNodeToSVFLoopVec () const

FunEntryICFGNode *	getFunEntryICFGNode (const SVFFunction *fun)
	Add a function entry node.

FunExitICFGNode *	getFunExitICFGNode (const SVFFunction *fun)
	Add a function exit node.

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.

virtual	~GenericGraph ()
	Destructor.

void	destroy ()
	Release memory.

iterator	begin ()
	Iterators.

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

void	addGNode (NodeID id, NodeType *node)
	Add a Node.

NodeType *	getGNode (NodeID id) const
	Get a node.

bool	hasGNode (NodeID id) const
	Has a node.

void	removeGNode (NodeType *node)
	Delete a node.

u32_t	getTotalNodeNum () const
	Get total number of node/edge.

u32_t	getTotalEdgeNum () const

void	incNodeNum ()
	Increase number of node/edge.

void	incEdgeNum ()

Public Attributes
NodeID	totalICFGNode

Public Attributes inherited from SVF::GenericGraph< NodeTy, EdgeTy >
u32_t	edgeNum
	total num of node

u32_t	nodeNum
	total num of edge

Protected Member Functions
ICFGEdge *	addIntraEdge (ICFGNode srcNode, ICFGNode dstNode)
	Add intraprocedural and interprocedural control-flow edges.

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.

void	removeICFGNode (ICFGNode *node)
	Remove a ICFGNode.

void	checkIntraEdgeParents (const ICFGNode srcNode, const ICFGNode dstNode)
	sanitize Intra edges, verify that both nodes belong to the same function.

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.

Private Member Functions
void	addSubNode (const ICFGNode rep, const ICFGNode sub)
	when ICFG is simplified, SubNode would merge repNode, then update the map

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

bool	addICFGEdge (ICFGEdge *edge)
	Add ICFG edge, only used by addIntraEdge, addCallEdge, addRetEdge etc.

FunEntryICFGNode *	getFunEntryBlock (const SVFFunction *fun)
	Get/Add a function entry node.

FunExitICFGNode *	getFunExitBlock (const SVFFunction *fun)
	Get/Add a function exit node.

Private Attributes
FunToFunEntryNodeMapTy	FunToFunEntryNodeMap
	map a function to its FunExitICFGNode

FunToFunExitNodeMapTy	FunToFunExitNodeMap
	map a function to its FunEntryICFGNode

GlobalICFGNode *	globalBlockNode
	unique basic block for all globals

ICFGNodeToSVFLoopVec	icfgNodeToSVFLoopVec
	map ICFG node to the SVF loops where it resides

Map< const ICFGNode , std::vector< const ICFGNode > >	_subNodes
	map a node(1st node of basicblock) to its subnodes

Map< const ICFGNode , const ICFGNode >	_repNode
	map a subnode to its representative node(1st node of basicblock)

Friends
class	ICFGBuilder

class	SVFIRWriter

class	SVFIRReader

class	ICFGSimplification

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

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 Symbol 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

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ const_iterator

◆ FunToFunEntryNodeMapTy

◆ FunToFunExitNodeMapTy

◆ ICFGEdgeSetTy

◆ ICFGNodeIDToNodeMapTy

◆ ICFGNodeToSVFLoopVec

◆ iterator

◆ SVFLoopVec

Constructor & Destructor Documentation

◆ ICFG()

◆ ~ICFG()

Member Function Documentation

◆ addCallEdge()

◆ addCallICFGNode()

◆ addConditionalIntraEdge()

◆ addFunEntryICFGNode()

◆ addFunExitICFGNode()

◆ addICFGEdge()

◆ addICFGNode()

◆ addIntraEdge()

◆ addIntraICFGNode()

◆ addNodeToSVFLoop()

◆ addRetEdge()

◆ addRetICFGNode()

◆ addSubNode()

◆ checkIntraEdgeParents()

◆ dump()

◆ getFunEntryBlock()

◆ getFunEntryICFGNode()

◆ getFunExitBlock()

◆ getFunExitICFGNode()

◆ getGlobalICFGNode()

◆ getICFGEdge()

◆ getICFGNode()

◆ getIcfgNodeToSVFLoopVec()

◆ getRepNode()

◆ getSubNodes()

◆ getSVFLoops()

◆ hasICFGNode()

◆ hasInterICFGEdge()

◆ hasIntraICFGEdge()

◆ hasThreadICFGEdge()

◆ isInLoop()

◆ removeICFGEdge()

◆ removeICFGNode()

◆ updateCallGraph()

◆ updateRepNode()

◆ updateSubAndRep()

◆ view()

Friends And Related Symbol Documentation

◆ ICFGBuilder

◆ ICFGSimplification

◆ SVFIRReader

◆ SVFIRWriter

Member Data Documentation

◆ _repNode

◆ _subNodes

◆ FunToFunEntryNodeMap

◆ FunToFunExitNodeMap

◆ globalBlockNode

◆ icfgNodeToSVFLoopVec

◆ totalICFGNode