SVF::VFG Class Reference

#include <VFG.h>

Inheritance diagram for SVF::VFG:

Public Types
enum	VFGK { FULLSVFG , PTRONLYSVFG , FULLSVFG_OPT , PTRONLYSVFG_OPT }
	VFG kind. More...
typedef OrderedMap< NodeID, VFGNode * >	VFGNodeIDToNodeMapTy
typedef Set< VFGNode * >	VFGNodeSet
typedef Map< const ValVar *, NodeID >	ValVarToDefMapTy
typedef Map< std::pair< NodeID, const CallICFGNode * >, ActualParmVFGNode * >	SVFVarToActualParmMapTy
typedef Map< const SVFVar *, ActualRetVFGNode * >	SVFVarToActualRetMapTy
typedef Map< const SVFVar *, FormalParmVFGNode * >	SVFVarToFormalParmMapTy
typedef Map< const SVFVar *, FormalRetVFGNode * >	SVFVarToFormalRetMapTy
typedef Map< const SVFStmt *, StmtVFGNode * >	SVFStmtToStmtVFGNodeMapTy
typedef Map< const SVFVar *, IntraPHIVFGNode * >	SVFVarToPHIVFGNodeMapTy
typedef Map< const SVFVar *, BinaryOPVFGNode * >	SVFVarToBinaryOPVFGNodeMapTy
typedef Map< const SVFVar *, UnaryOPVFGNode * >	SVFVarToUnaryOPVFGNodeMapTy
typedef Map< const SVFVar *, BranchVFGNode * >	SVFVarToBranchVFGNodeMapTy
typedef Map< const SVFVar *, CmpVFGNode * >	SVFVarToCmpVFGNodeMapTy
typedef Map< const FunObjVar *, VFGNodeSet >	FunToVFGNodesMapTy
typedef FormalParmVFGNode::CallPESet	CallPESet
typedef FormalRetVFGNode::RetPESet	RetPESet
typedef VFGEdge::VFGEdgeSetTy	VFGEdgeSetTy
typedef VFGEdge::SVFGEdgeSetTy	SVFGEdgeSetTy
typedef VFGEdge::VFGEdgeSetTy::iterator	VFGNodeIter
typedef VFGNodeIDToNodeMapTy::iterator	iterator
typedef VFGNodeIDToNodeMapTy::const_iterator	const_iterator
typedef SVFIR::SVFStmtSet	SVFStmtSet
typedef Set< const VFGNode * >	GlobalVFGNodeSet
typedef Set< const SVFVar * >	SVFVarSet
Public Types inherited from SVF::GenericGraph< VFGNode, VFGEdge >
typedef VFGNode	NodeType
typedef VFGEdge	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
	VFG (CallGraph *callgraph, VFGK k=FULLSVFG)
	Constructor.
virtual	~VFG ()
	Destructor.
VFGK	getKind () const
	Get VFG kind.
bool	isPtrOnlySVFG () const
	Return true if this VFG only contains pointer related SVFGNodes for pointer analysis.
SVFIR *	getPAG () const
	Return SVFIR.
CallGraph *	getCallGraph () const
	Return PTACallGraph.
VFGNode *	getVFGNode (NodeID id) const
	Get a VFG node.
bool	hasVFGNode (NodeID id) const
	Whether has the VFGNode.
GlobalVFGNodeSet &	getGlobalVFGNodes ()
	Return global stores.
VFGEdge *	getIntraVFGEdge (const VFGNode *src, const VFGNode *dst, VFGEdge::VFGEdgeK 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 ()
	Dump graph into dot file.
void	updateCallGraph (PointerAnalysis *pta)
	Update VFG based on pointer analysis results.
virtual void	connectCallerAndCallee (const CallICFGNode *cs, const FunObjVar *callee, VFGEdgeSetTy &edges)
	Connect VFG nodes between caller and callee for indirect call site.
CallSiteID	getCallSiteID (const CallICFGNode *cs, const FunObjVar *func) const
	Get callsite given a callsiteID.
const CallICFGNode *	getCallSite (CallSiteID id) const
const VFGNode *	getDefVFGNode (const ValVar *valVar) const
	Given a valVar, return its definition site.
bool	hasLHSTopLevPtr (const VFGNode *node) const
const SVFVar *	getLHSTopLevPtr (const VFGNode *node) const
bool	hasStmtVFGNode (const SVFStmt *svfStmt) const
	Existence checks for VFGNodes.
bool	hasIntraPHIVFGNode (const SVFVar *svfVar) const
bool	hasBinaryOPVFGNode (const SVFVar *svfVar) const
bool	hasUnaryOPVFGNode (const SVFVar *svfVar) const
bool	hasBranchVFGNode (const SVFVar *svfVar) const
bool	hasCmpVFGNode (const SVFVar *svfVar) const
bool	hasActualParmVFGNode (const SVFVar *aparm, const CallICFGNode *cs) const
bool	hasActualRetVFGNode (const SVFVar *aret) const
bool	hasFormalParmVFGNode (const SVFVar *fparm) const
bool	hasFormalRetVFGNode (const SVFVar *fret) const
StmtVFGNode *	getStmtVFGNode (const SVFStmt *svfStmt) const
	Get an VFGNode.
IntraPHIVFGNode *	getIntraPHIVFGNode (const SVFVar *svfVar) const
BinaryOPVFGNode *	getBinaryOPVFGNode (const SVFVar *svfVar) const
UnaryOPVFGNode *	getUnaryOPVFGNode (const SVFVar *svfVar) const
BranchVFGNode *	getBranchVFGNode (const SVFVar *svfVar) const
CmpVFGNode *	getCmpVFGNode (const SVFVar *svfVar) const
ActualParmVFGNode *	getActualParmVFGNode (const SVFVar *aparm, const CallICFGNode *cs) const
ActualRetVFGNode *	getActualRetVFGNode (const SVFVar *aret) const
FormalParmVFGNode *	getFormalParmVFGNode (const SVFVar *fparm) const
FormalRetVFGNode *	getFormalRetVFGNode (const SVFVar *fret) const
const FunObjVar *	isFunEntryVFGNode (const VFGNode *node) const
	Whether a node is function entry VFGNode.
bool	hasBlackHoleConstObjAddrAsDef (const ValVar *valVar) const
	Whether a SVFVar has a blackhole or const object as its definition.
VFGEdge *	addIntraDirectVFEdge (NodeID srcId, NodeID dstId)
VFGEdge *	addCallEdge (NodeID srcId, NodeID dstId, CallSiteID csId)
VFGEdge *	addRetEdge (NodeID srcId, NodeID dstId, CallSiteID csId)
void	removeVFGEdge (VFGEdge *edge)
	Remove a SVFG edge.
void	removeVFGNode (VFGNode *node)
	Remove a VFGNode.
VFGEdge *	hasIntraVFGEdge (VFGNode *src, VFGNode *dst, VFGEdge::VFGEdgeK kind)
	Whether we has a SVFG edge.
VFGEdge *	hasInterVFGEdge (VFGNode *src, VFGNode *dst, VFGEdge::VFGEdgeK kind, CallSiteID csId)
VFGEdge *	hasThreadVFGEdge (VFGNode *src, VFGNode *dst, VFGEdge::VFGEdgeK kind)
bool	addVFGEdge (VFGEdge *edge)
	Add VFG edge.
VFGNodeSet &	getVFGNodes (const FunObjVar *fun)
bool	hasVFGNodes (const FunObjVar *fun) const
bool	VFGNodes (const FunObjVar *fun) const
VFGNodeSet::const_iterator	getVFGNodeBegin (const FunObjVar *fun) const
VFGNodeSet::const_iterator	getVFGNodeEnd (const FunObjVar *fun) const
Public Member Functions inherited from SVF::GenericGraph< VFGNode, VFGEdge >
	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 ()

Protected Member Functions
void	destroy ()
	Clean up memory.
void	checkIntraEdgeParents (const VFGNode *srcNode, const VFGNode *dstNode)
	sanitize Intra edges, verify that both nodes belong to the same function.
VFGEdge *	addInterEdgeFromAPToFP (ActualParmVFGNode *src, FormalParmVFGNode *dst, CallSiteID csId)
	Add inter VF edge from actual to formal parameters.
VFGEdge *	addInterEdgeFromFRToAR (FormalRetVFGNode *src, ActualRetVFGNode *dst, CallSiteID csId)
	Add inter VF edge from callee return to callsite receive parameter.
VFGEdge *	addInterEdgeFromAPToFP (NodeID src, NodeID dst, CallSiteID csId)
	Add inter VF edge from actual to formal parameters.
VFGEdge *	addInterEdgeFromFRToAR (NodeID src, NodeID dst, CallSiteID csId)
	Add inter VF edge from callee return to callsite receive parameter.
virtual void	connectAParamAndFParam (const ValVar *csArg, const ValVar *funArg, const CallICFGNode *cbn, CallSiteID csId, VFGEdgeSetTy &edges)
	Connect VFG nodes between caller and callee for indirect call site.
virtual void	connectFRetAndARet (const ValVar *funReturn, const ValVar *csReturn, CallSiteID csId, VFGEdgeSetTy &edges)
	Connect formal-ret and actual ret.
void	setDef (const ValVar *valVar, const VFGNode *node)
	Given a ValVar, set/get its def VFG node (definition of top level pointers).
NodeID	getDef (const ValVar *valVar) const
bool	hasDef (const ValVar *valVar) const
void	addVFGNodes ()
	Create VFG nodes.
virtual SVFStmt::SVFStmtSetTy &	getSVFStmtSet (SVFStmt::PEDGEK kind)
	Get SVFStmt set.
virtual bool	isInterestedSVFVar (const SVFVar *node) const
void	connectDirectVFGEdges ()
	Create edges between VFG nodes within a function.
void	addVFGInterEdges (const CallICFGNode *cs, const FunObjVar *callee)
	Create edges between VFG nodes across functions.
bool	isPhiCopyEdge (const SVFStmt *copy) const
virtual void	addVFGNode (VFGNode *vfgNode, ICFGNode *icfgNode)
	Add a VFG node.
void	addStmtVFGNode (StmtVFGNode *node, const SVFStmt *svfStmt)
	Add a VFG node for program statement.
void	addNullPtrVFGNode (const ValVar *svfVar)
void	addAddrVFGNode (const AddrStmt *addr)
	Add an Address VFG node.
void	addCopyVFGNode (const CopyStmt *copy)
	Add a Copy VFG node.
void	addGepVFGNode (const GepStmt *gep)
	Add a Gep VFG node.
void	addLoadVFGNode (const LoadStmt *load)
	Add a Load VFG node.
void	addStoreVFGNode (const StoreStmt *store)
void	addActualParmVFGNode (const ValVar *aparm, const CallICFGNode *cs)
void	addFormalParmVFGNode (const ValVar *fparm, const FunObjVar *fun, const CallPE *callPE)
	Add a formal parameter VFG node.
void	addFormalRetVFGNode (const ValVar *uniqueFunRet, const FunObjVar *fun, RetPESet &retPEs)
void	addActualRetVFGNode (const ValVar *ret, const CallICFGNode *cs)
	Add a callsite Receive VFG node.
void	addIntraPHIVFGNode (const MultiOpndStmt *edge)
	Add an llvm PHI VFG node.
void	addCmpVFGNode (const CmpStmt *edge)
	Add a Compare VFG node.
void	addBinaryOPVFGNode (const BinaryOPStmt *edge)
	Add a BinaryOperator VFG node.
void	addUnaryOPVFGNode (const UnaryOPStmt *edge)
	Add a UnaryOperator VFG node.
void	addBranchVFGNode (const BranchStmt *edge)
	Add a BranchVFGNode.

Protected Attributes
NodeID	totalVFGNode
ValVarToDefMapTy	ValVarToDefMap
	map a pag node to its definition SVG node
SVFVarToActualParmMapTy	SVFVarToActualParmMap
	map a SVFVar to an actual parameter
SVFVarToActualRetMapTy	SVFVarToActualRetMap
	map a SVFVar to an actual return
SVFVarToFormalParmMapTy	SVFVarToFormalParmMap
	map a SVFVar to a formal parameter
SVFVarToFormalRetMapTy	SVFVarToFormalRetMap
	map a SVFVar to a formal return
SVFVarToPHIVFGNodeMapTy	SVFVarToIntraPHIVFGNodeMap
	map a SVFVar to its PHIVFGNode
SVFVarToBinaryOPVFGNodeMapTy	SVFVarToBinaryOPVFGNodeMap
	map a SVFVar to its BinaryOPVFGNode
SVFVarToUnaryOPVFGNodeMapTy	SVFVarToUnaryOPVFGNodeMap
	map a SVFVar to its UnaryOPVFGNode
SVFVarToBranchVFGNodeMapTy	SVFVarToBranchVFGNodeMap
	map a SVFVar to its BranchVFGNode
SVFVarToCmpVFGNodeMapTy	SVFVarToCmpVFGNodeMap
	map a SVFVar to its CmpVFGNode
SVFStmtToStmtVFGNodeMapTy	SVFStmtToStmtVFGNodeMap
	map a SVFStmt to its StmtVFGNode
FunToVFGNodesMapTy	funToVFGNodesMap
	map a function to its VFGNodes;
GlobalVFGNodeSet	globalVFGNodes
	set of global store VFG nodes
CallGraph *	callgraph
SVFIR *	pag
VFGK	kind
Protected Attributes inherited from SVF::GenericGraph< VFGNode, VFGEdge >
IDToNodeMapTy	IDToNodeMap
	node map

Additional Inherited Members
Public Attributes inherited from SVF::GenericGraph< VFGNode, VFGEdge >
u32_t	edgeNum
	total num of node
u32_t	nodeNum
	total num of edge

Detailed Description

Definition at line 50 of file VFG.h.

Member Typedef Documentation

CallPESet

typedef FormalParmVFGNode::CallPESet SVF::VFG::CallPESet

Definition at line 75 of file VFG.h.

const_iterator

typedef VFGNodeIDToNodeMapTy::const_iterator SVF::VFG::const_iterator

Definition at line 81 of file VFG.h.

FunToVFGNodesMapTy

typedef Map<const FunObjVar*, VFGNodeSet > SVF::VFG::FunToVFGNodesMapTy

Definition at line 73 of file VFG.h.

GlobalVFGNodeSet

typedef Set<const VFGNode*> SVF::VFG::GlobalVFGNodeSet

Definition at line 83 of file VFG.h.

iterator

typedef VFGNodeIDToNodeMapTy::iterator SVF::VFG::iterator

Definition at line 80 of file VFG.h.

RetPESet

typedef FormalRetVFGNode::RetPESet SVF::VFG::RetPESet

Definition at line 76 of file VFG.h.

SVFGEdgeSetTy

typedef VFGEdge::SVFGEdgeSetTy SVF::VFG::SVFGEdgeSetTy

Definition at line 78 of file VFG.h.

SVFStmtSet

typedef SVFIR::SVFStmtSet SVF::VFG::SVFStmtSet

Definition at line 82 of file VFG.h.

SVFStmtToStmtVFGNodeMapTy

typedef Map<const SVFStmt*, StmtVFGNode*> SVF::VFG::SVFStmtToStmtVFGNodeMapTy

Definition at line 67 of file VFG.h.

SVFVarSet

typedef Set<const SVFVar*> SVF::VFG::SVFVarSet

Definition at line 84 of file VFG.h.

SVFVarToActualParmMapTy

typedef Map<std::pair<NodeID,const CallICFGNode*>, ActualParmVFGNode *> SVF::VFG::SVFVarToActualParmMapTy

Definition at line 63 of file VFG.h.

SVFVarToActualRetMapTy

typedef Map<const SVFVar*, ActualRetVFGNode *> SVF::VFG::SVFVarToActualRetMapTy

Definition at line 64 of file VFG.h.

SVFVarToBinaryOPVFGNodeMapTy

typedef Map<const SVFVar*, BinaryOPVFGNode*> SVF::VFG::SVFVarToBinaryOPVFGNodeMapTy

Definition at line 69 of file VFG.h.

SVFVarToBranchVFGNodeMapTy

typedef Map<const SVFVar*, BranchVFGNode*> SVF::VFG::SVFVarToBranchVFGNodeMapTy

Definition at line 71 of file VFG.h.

SVFVarToCmpVFGNodeMapTy

typedef Map<const SVFVar*, CmpVFGNode*> SVF::VFG::SVFVarToCmpVFGNodeMapTy

Definition at line 72 of file VFG.h.

SVFVarToFormalParmMapTy

typedef Map<const SVFVar*, FormalParmVFGNode *> SVF::VFG::SVFVarToFormalParmMapTy

Definition at line 65 of file VFG.h.

SVFVarToFormalRetMapTy

typedef Map<const SVFVar*, FormalRetVFGNode *> SVF::VFG::SVFVarToFormalRetMapTy

Definition at line 66 of file VFG.h.

SVFVarToPHIVFGNodeMapTy

typedef Map<const SVFVar*, IntraPHIVFGNode*> SVF::VFG::SVFVarToPHIVFGNodeMapTy

Definition at line 68 of file VFG.h.

SVFVarToUnaryOPVFGNodeMapTy

typedef Map<const SVFVar*, UnaryOPVFGNode*> SVF::VFG::SVFVarToUnaryOPVFGNodeMapTy

Definition at line 70 of file VFG.h.

ValVarToDefMapTy

typedef Map<const ValVar*, NodeID> SVF::VFG::ValVarToDefMapTy

Definition at line 62 of file VFG.h.

VFGEdgeSetTy

typedef VFGEdge::VFGEdgeSetTy SVF::VFG::VFGEdgeSetTy

Definition at line 77 of file VFG.h.

VFGNodeIDToNodeMapTy

typedef OrderedMap<NodeID, VFGNode *> SVF::VFG::VFGNodeIDToNodeMapTy

Definition at line 60 of file VFG.h.

VFGNodeIter

typedef VFGEdge::VFGEdgeSetTy::iterator SVF::VFG::VFGNodeIter

Definition at line 79 of file VFG.h.

VFGNodeSet

typedef Set<VFGNode*> SVF::VFG::VFGNodeSet

Definition at line 61 of file VFG.h.

Member Enumeration Documentation

VFGK

enum SVF::VFG::VFGK

VFG kind.

Enumerator
FULLSVFG
PTRONLYSVFG
FULLSVFG_OPT
PTRONLYSVFG_OPT

Definition at line 55 of file VFG.h.

    {
        FULLSVFG, PTRONLYSVFG, FULLSVFG_OPT, PTRONLYSVFG_OPT
    };

Constructor & Destructor Documentation

VFG()

VFG::VFG	(	CallGraph *	cg,
		VFGK	k = FULLSVFG )

Constructor.

Constructor

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

Definition at line 428 of file VFG.cpp.

                             : totalVFGNode(0), callgraph(cg), pag(SVFIR::getPAG()), kind(k)
{
 
    DBOUT(DGENERAL, outs() << pasMsg("\tCreate VFG Top Level Node\n"));
    addVFGNodes();
 
    DBOUT(DGENERAL, outs() << pasMsg("\tCreate SVFG Direct Edge\n"));
    connectDirectVFGEdges();
}

~VFG()

virtual SVF::VFG::~VFG ( )

inlinevirtual

Destructor.

Definition at line 115 of file VFG.h.

    {
        destroy();
    }

Member Function Documentation

addActualParmVFGNode()

void SVF::VFG::addActualParmVFGNode ( const ValVar * aparm, const CallICFGNode * cs )

inlineprotected

Add an actual parameter VFG node To be noted that multiple actual parameters may have same value (SVFVar) So we need to make a pair <SVFVarID,CallSiteID> to find the right VFGParmNode

do not set def here, this node is not a variable definition

Definition at line 592 of file VFG.h.

    {
        ActualParmVFGNode* sNode = new ActualParmVFGNode(totalVFGNode++,aparm,cs);
        addVFGNode(sNode, const_cast<CallICFGNode*>(cs));
        SVFVarToActualParmMap[std::make_pair(aparm->getId(),cs)] = sNode;
    }

addActualRetVFGNode()

void SVF::VFG::addActualRetVFGNode ( const ValVar * ret, const CallICFGNode * cs )

inlineprotected

Add a callsite Receive VFG node.

Definition at line 631 of file VFG.h.

    {
        ActualRetVFGNode* sNode = new ActualRetVFGNode(totalVFGNode++,ret,cs);
        addVFGNode(sNode, const_cast<RetICFGNode*>(cs->getRetICFGNode()));
        setDef(ret,sNode);
        SVFVarToActualRetMap[ret] = sNode;
    }

addAddrVFGNode()

void SVF::VFG::addAddrVFGNode ( const AddrStmt * addr )

inlineprotected

Add an Address VFG node.

Definition at line 554 of file VFG.h.

    {
        AddrVFGNode* sNode = new AddrVFGNode(totalVFGNode++,addr);
        addStmtVFGNode(sNode, addr);
        setDef(SVFUtil::cast<ValVar>(addr->getLHSVar()),sNode);
    }

addBinaryOPVFGNode()

void SVF::VFG::addBinaryOPVFGNode ( const BinaryOPStmt * edge )

inlineprotected

Add a BinaryOperator VFG node.

Definition at line 667 of file VFG.h.

    {
        BinaryOPVFGNode* sNode = new BinaryOPVFGNode(totalVFGNode++, edge->getRes());
        u32_t pos = 0;
        for(auto var : edge->getOpndVars())
        {
            sNode->setOpVer(pos, var);
            pos++;
        }
        addVFGNode(sNode,edge->getICFGNode());
        setDef(edge->getRes(),sNode);
        SVFVarToBinaryOPVFGNodeMap[edge->getRes()] = sNode;
    }

addBranchVFGNode()

void SVF::VFG::addBranchVFGNode ( const BranchStmt * edge )

inlineprotected

Add a BranchVFGNode.

Definition at line 690 of file VFG.h.

    {
        BranchVFGNode* sNode = new BranchVFGNode(totalVFGNode++, edge);
        addVFGNode(sNode,edge->getICFGNode());
        setDef(edge->getBranchInst(),sNode);
        SVFVarToBranchVFGNodeMap[edge->getBranchInst()] = sNode;
    }

addCallEdge()

VFGEdge * VFG::addCallEdge	(	NodeID	srcId,
		NodeID	dstId,
		CallSiteID	csId )

Add interprocedural call edges for top level pointers

Definition at line 669 of file VFG.cpp.

{
    VFGNode* srcNode = getVFGNode(srcId);
    VFGNode* dstNode = getVFGNode(dstId);
    VFGEdge* edge = hasInterVFGEdge(srcNode, dstNode, VFGEdge::CallDirVF, csId);
    if (edge != nullptr)
    {
        assert(edge->isCallDirectVFGEdge() && "this should be a direct value flow edge!");
        return nullptr;
    }
    else
    {
        CallDirSVFGEdge* callEdge = new CallDirSVFGEdge(srcNode,dstNode,csId);
        return (addVFGEdge(callEdge) ? callEdge : nullptr);
    }
}

addCmpVFGNode()

void SVF::VFG::addCmpVFGNode ( const CmpStmt * edge )

inlineprotected

Add a Compare VFG node.

Definition at line 653 of file VFG.h.

    {
        CmpVFGNode* sNode = new CmpVFGNode(totalVFGNode++, edge->getRes());
        u32_t pos = 0;
        for(auto var : edge->getOpndVars())
        {
            sNode->setOpVer(pos, var);
            pos++;
        }
        addVFGNode(sNode,edge->getICFGNode());
        setDef(edge->getRes(),sNode);
        SVFVarToCmpVFGNodeMap[edge->getRes()] = sNode;
    }

addCopyVFGNode()

void SVF::VFG::addCopyVFGNode ( const CopyStmt * copy )

inlineprotected

Add a Copy VFG node.

Definition at line 561 of file VFG.h.

    {
        CopyVFGNode* sNode = new CopyVFGNode(totalVFGNode++,copy);
        addStmtVFGNode(sNode, copy);
        setDef(copy->getLHSVar(),sNode);
    }

addFormalParmVFGNode()

void SVF::VFG::addFormalParmVFGNode ( const ValVar * fparm, const FunObjVar * fun, const CallPE * callPE )

inlineprotected

Add a formal parameter VFG node.

Definition at line 600 of file VFG.h.

    {
        FormalParmVFGNode* sNode = new FormalParmVFGNode(totalVFGNode++,fparm,fun);
        addVFGNode(sNode, pag->getICFG()->getFunEntryICFGNode(fun));
        sNode->setCallPE(callPE);
 
        setDef(fparm,sNode);
        SVFVarToFormalParmMap[fparm] = sNode;
    }

addFormalRetVFGNode()

void SVF::VFG::addFormalRetVFGNode ( const ValVar * uniqueFunRet, const FunObjVar * fun, RetPESet & retPEs )

inlineprotected

Add a callee Return VFG node To be noted that here we assume returns of a procedure have already been unified into one Otherwise, we need to handle formalRet using <SVFVarID,CallSiteID> pair to find FormalRetVFG node same as handling actual parameters

if this uniqueFunRet is a phi node, which means it will receive values from multiple return instructions of fun we will set this phi node's def later Ideally, every function uniqueFunRet should be a PhiNode (SVFIRBuilder.cpp), unless it does not have ret instruction

Definition at line 612 of file VFG.h.

    {
        FormalRetVFGNode *sNode = new FormalRetVFGNode(totalVFGNode++, uniqueFunRet, fun);
        addVFGNode(sNode, pag->getICFG()->getFunExitICFGNode(fun));
        for (RetPESet::const_iterator it = retPEs.begin(), eit = retPEs.end(); it != eit; ++it)
            sNode->addRetPE(*it);
 
        SVFVarToFormalRetMap[uniqueFunRet] = sNode;
        if (!pag->isPhiNode(uniqueFunRet))
        {
            std::string warn = fun->getName();
            SVFUtil::writeWrnMsg(warn + " does not have any ret instruction!");
            setDef(uniqueFunRet, sNode);
        }
    }

addGepVFGNode()

void SVF::VFG::addGepVFGNode ( const GepStmt * gep )

inlineprotected

Add a Gep VFG node.

Definition at line 568 of file VFG.h.

    {
        GepVFGNode* sNode = new GepVFGNode(totalVFGNode++,gep);
        addStmtVFGNode(sNode, gep);
        setDef(gep->getLHSVar(),sNode);
    }

addInterEdgeFromAPToFP() [1/2]

VFGEdge * SVF::VFG::addInterEdgeFromAPToFP ( ActualParmVFGNode * src, FormalParmVFGNode * dst, CallSiteID csId )

inlineprotected

Add inter VF edge from actual to formal parameters.

Definition at line 424 of file VFG.h.

    {
        return addCallEdge(src->getId(),dst->getId(),csId);
    }

addInterEdgeFromAPToFP() [2/2]

VFGEdge * SVF::VFG::addInterEdgeFromAPToFP ( NodeID src, NodeID dst, CallSiteID csId )

inlineprotected

Add inter VF edge from actual to formal parameters.

Definition at line 435 of file VFG.h.

    {
        return addCallEdge(src,dst,csId);
    }

addInterEdgeFromFRToAR() [1/2]

VFGEdge * SVF::VFG::addInterEdgeFromFRToAR ( FormalRetVFGNode * src, ActualRetVFGNode * dst, CallSiteID csId )

inlineprotected

Add inter VF edge from callee return to callsite receive parameter.

Definition at line 429 of file VFG.h.

    {
        return addRetEdge(src->getId(),dst->getId(),csId);
    }

addInterEdgeFromFRToAR() [2/2]

VFGEdge * SVF::VFG::addInterEdgeFromFRToAR ( NodeID src, NodeID dst, CallSiteID csId )

inlineprotected

Add inter VF edge from callee return to callsite receive parameter.

Definition at line 440 of file VFG.h.

    {
        return addRetEdge(src,dst,csId);
    }

addIntraDirectVFEdge()

VFGEdge * VFG::addIntraDirectVFEdge	(	NodeID	srcId,
		NodeID	dstId )

Add control-flow edges for top level pointers

Add def-use edges for top level pointers

Definition at line 643 of file VFG.cpp.

{
    VFGNode* srcNode = getVFGNode(srcId);
    VFGNode* dstNode = getVFGNode(dstId);
    checkIntraEdgeParents(srcNode, dstNode);
    VFGEdge* edge = hasIntraVFGEdge(srcNode, dstNode, VFGEdge::IntraDirectVF);
    if (edge != nullptr)
    {
        assert(edge->isDirectVFGEdge() && "this should be a direct value flow edge!");
        return nullptr;
    }
    else
    {
        if(srcNode!=dstNode)
        {
            IntraDirSVFGEdge* directEdge = new IntraDirSVFGEdge(srcNode,dstNode);
            return (addVFGEdge(directEdge) ? directEdge : nullptr);
        }
        else
            return nullptr;
    }
}

addIntraPHIVFGNode()

void SVF::VFG::addIntraPHIVFGNode ( const MultiOpndStmt * edge )

inlineprotected

Add an llvm PHI VFG node.

Definition at line 639 of file VFG.h.

    {
        IntraPHIVFGNode* sNode = new IntraPHIVFGNode(totalVFGNode++, edge->getRes());
        u32_t pos = 0;
        for(auto var : edge->getOpndVars())
        {
            sNode->setOpVerAndBB(pos, var, edge->getICFGNode());
            pos++;
        }
        addVFGNode(sNode,edge->getICFGNode());
        setDef(edge->getRes(),sNode);
        SVFVarToIntraPHIVFGNodeMap[edge->getRes()] = sNode;
    }

addLoadVFGNode()

void SVF::VFG::addLoadVFGNode ( const LoadStmt * load )

inlineprotected

Add a Load VFG node.

Definition at line 575 of file VFG.h.

    {
        LoadVFGNode* sNode = new LoadVFGNode(totalVFGNode++,load);
        addStmtVFGNode(sNode, load);
        setDef(load->getLHSVar(),sNode);
    }

addNullPtrVFGNode()

void SVF::VFG::addNullPtrVFGNode ( const ValVar * svfVar )

inlineprotected

Add a Dummy VFG node for null pointer definition To be noted for black hole pointer it has already has address edge connected

Definition at line 547 of file VFG.h.

    {
        NullPtrVFGNode* sNode = new NullPtrVFGNode(totalVFGNode++,svfVar);
        addVFGNode(sNode, pag->getICFG()->getGlobalICFGNode());
        setDef(svfVar,sNode);
    }

addRetEdge()

VFGEdge * VFG::addRetEdge	(	NodeID	srcId,
		NodeID	dstId,
		CallSiteID	csId )

Add interprocedural return edges for top level pointers

Definition at line 689 of file VFG.cpp.

{
    VFGNode* srcNode = getVFGNode(srcId);
    VFGNode* dstNode = getVFGNode(dstId);
    VFGEdge* edge = hasInterVFGEdge(srcNode, dstNode, VFGEdge::RetDirVF, csId);
    if (edge != nullptr)
    {
        assert(edge->isRetDirectVFGEdge() && "this should be a direct value flow edge!");
        return nullptr;
    }
    else
    {
        RetDirSVFGEdge* retEdge = new RetDirSVFGEdge(srcNode,dstNode,csId);
        return (addVFGEdge(retEdge) ? retEdge : nullptr);
    }
}

addStmtVFGNode()

void SVF::VFG::addStmtVFGNode ( StmtVFGNode * node, const SVFStmt * svfStmt )

inlineprotected

Add a VFG node for program statement.

Definition at line 539 of file VFG.h.

    {
        assert(SVFStmtToStmtVFGNodeMap.find(svfStmt)==SVFStmtToStmtVFGNodeMap.end() && "should not insert twice!");
        SVFStmtToStmtVFGNodeMap[svfStmt] = node;
        addVFGNode(node, svfStmt->getICFGNode());
    }

addStoreVFGNode()

void SVF::VFG::addStoreVFGNode ( const StoreStmt * store )

inlineprotected

Add a Store VFG node, To be noted store does not create a new pointer, we do not set def for any SVFIR node

Definition at line 583 of file VFG.h.

    {
        StoreVFGNode* sNode = new StoreVFGNode(totalVFGNode++,store);
        addStmtVFGNode(sNode, store);
    }

addUnaryOPVFGNode()

void SVF::VFG::addUnaryOPVFGNode ( const UnaryOPStmt * edge )

inlineprotected

Add a UnaryOperator VFG node.

Definition at line 681 of file VFG.h.

    {
        UnaryOPVFGNode* sNode = new UnaryOPVFGNode(totalVFGNode++, edge->getRes());
        sNode->setOpVer(0, edge->getOpVar());
        addVFGNode(sNode,edge->getICFGNode());
        setDef(edge->getRes(),sNode);
        SVFVarToUnaryOPVFGNodeMap[edge->getRes()] = sNode;
    }

addVFGEdge()

bool SVF::VFG::addVFGEdge ( VFGEdge * edge )

inline

Add VFG edge.

Definition at line 401 of file VFG.h.

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

addVFGInterEdges()

void SVF::VFG::addVFGInterEdges ( const CallICFGNode * cs, const FunObjVar * callee )

protected

Create edges between VFG nodes across functions.

addVFGNode()

virtual void SVF::VFG::addVFGNode ( VFGNode * vfgNode, ICFGNode * icfgNode )

inlineprotectedvirtual

Add a VFG node.

Definition at line 526 of file VFG.h.

    {
        addGNode(vfgNode->getId(), vfgNode);
        vfgNode->setICFGNode(icfgNode);
        icfgNode->addVFGNode(vfgNode);
 
        if(const FunObjVar* fun = icfgNode->getFun())
            funToVFGNodesMap[fun].insert(vfgNode);
        else
            globalVFGNodes.insert(vfgNode);
    }

addVFGNodes()

void VFG::addVFGNodes ( )

protected

Create VFG nodes.

Create VFG nodes for top level pointers

for external function we do not create acutalRet VFGNode they are in the formal of AddrVFGNode if the external function returns an allocated memory if fun has body, it may also exist in isExtCall, e.g., xmalloc() in bzip2, spec2000.

Definition at line 450 of file VFG.cpp.

{
 
    // initialize dummy definition null pointers in order to uniform the construction
    // to be noted for black hole pointer it has already has address edge connected,
    // and its definition will be set when processing addr SVFIR edge.
    addNullPtrVFGNode(pag->getValVar(pag->getNullPtr()));
 
    // initialize address nodes
    SVFStmt::SVFStmtSetTy& addrs = getSVFStmtSet(SVFStmt::Addr);
    for (SVFStmt::SVFStmtSetTy::iterator iter = addrs.begin(), eiter =
                addrs.end(); iter != eiter; ++iter)
    {
        addAddrVFGNode(SVFUtil::cast<AddrStmt>(*iter));
    }
 
    // initialize copy nodes
    SVFStmt::SVFStmtSetTy& copys = getSVFStmtSet(SVFStmt::Copy);
    for (SVFStmt::SVFStmtSetTy::iterator iter = copys.begin(), eiter =
                copys.end(); iter != eiter; ++iter)
    {
        const CopyStmt* edge = SVFUtil::cast<CopyStmt>(*iter);
        assert(!isPhiCopyEdge(edge) && "Copy edges can not be a PhiNode (or from PhiNode)");
        addCopyVFGNode(edge);
    }
 
    // initialize gep nodes
    SVFStmt::SVFStmtSetTy& ngeps = getSVFStmtSet(SVFStmt::Gep);
    for (SVFStmt::SVFStmtSetTy::iterator iter = ngeps.begin(), eiter =
                ngeps.end(); iter != eiter; ++iter)
    {
        addGepVFGNode(SVFUtil::cast<GepStmt>(*iter));
    }
 
    // initialize load nodes
    SVFStmt::SVFStmtSetTy& loads = getSVFStmtSet(SVFStmt::Load);
    for (SVFStmt::SVFStmtSetTy::iterator iter = loads.begin(), eiter =
                loads.end(); iter != eiter; ++iter)
    {
        addLoadVFGNode(SVFUtil::cast<LoadStmt>(*iter));
    }
 
    // initialize store nodes
    SVFStmt::SVFStmtSetTy& stores = getSVFStmtSet(SVFStmt::Store);
    for (SVFStmt::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                stores.end(); iter != eiter; ++iter)
    {
        addStoreVFGNode(SVFUtil::cast<StoreStmt>(*iter));
    }
 
    SVFStmt::SVFStmtSetTy& forks = getSVFStmtSet(SVFStmt::ThreadFork);
    for (SVFStmt::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                forks.end(); iter != eiter; ++iter)
    {
        TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
        for(u32_t i = 0; i < forkedge->getOpVarNum(); i++)
            addActualParmVFGNode(forkedge->getOpVar(i), forkedge->getOpCallICFGNode(i));
    }
 
    // initialize actual parameter nodes
    for(SVFIR::CSToArgsListMap::iterator it = pag->getCallSiteArgsMap().begin(), eit = pag->getCallSiteArgsMap().end(); it !=eit; ++it)
    {
 
        for(SVFIR::ValVarList::iterator pit = it->second.begin(), epit = it->second.end(); pit!=epit; ++pit)
        {
            const ValVar* svfVar = *pit;
            if (isInterestedSVFVar(svfVar))
                addActualParmVFGNode(svfVar,it->first);
        }
    }
 
    // initialize actual return nodes (callsite return)
    for(SVFIR::CSToRetMap::iterator it = pag->getCallSiteRets().begin(), eit = pag->getCallSiteRets().end(); it !=eit; ++it)
    {

        if(isInterestedSVFVar(it->second) == false || hasDef(it->second))
            continue;
 
        addActualRetVFGNode(it->second,it->first->getCallICFGNode());
    }
 
    // initialize formal parameter nodes
    for(SVFIR::FunToArgsListMap::iterator it = pag->getFunArgsMap().begin(), eit = pag->getFunArgsMap().end(); it !=eit; ++it)
    {
        const FunObjVar* func = it->first;
 
        for(SVFIR::ValVarList::iterator pit = it->second.begin(), epit = it->second.end(); pit!=epit; ++pit)
        {
            const ValVar* param = *pit;
            if (isInterestedSVFVar(param) == false || hasBlackHoleConstObjAddrAsDef(param))
                continue;
 
            const CallPE* callPE = pag->getCallPEForFormalParm(param);
            addFormalParmVFGNode(param,func,callPE);
        }
 
        if (func->isVarArg())
        {
            const ValVar* varParam = pag->getValVar(pag->getVarargNode(func));
            if (isInterestedSVFVar(varParam) == false || hasBlackHoleConstObjAddrAsDef(varParam))
                continue;
 
            const CallPE* varCallPE = pag->getCallPEForFormalParm(varParam);
            addFormalParmVFGNode(varParam,func,varCallPE);
        }
    }
 
    // initialize formal return nodes (callee return)
    for (SVFIR::FunToRetMap::iterator it = pag->getFunRets().begin(), eit = pag->getFunRets().end(); it != eit; ++it)
    {
        const FunObjVar* func = it->first;
 
        const ValVar* uniqueFunRetNode = it->second;
 
        RetPESet retPEs;
        if (uniqueFunRetNode->hasOutgoingEdges(SVFStmt::Ret))
        {
            for (SVFStmt::SVFStmtSetTy::const_iterator cit = uniqueFunRetNode->getOutgoingEdgesBegin(SVFStmt::Ret),
                    ecit = uniqueFunRetNode->getOutgoingEdgesEnd(SVFStmt::Ret);
                    cit != ecit; ++cit)
            {
                const RetPE* retPE = SVFUtil::cast<RetPE>(*cit);
                if (isInterestedSVFVar(retPE->getLHSVar()))
                    retPEs.insert(retPE);
            }
        }
 
        if(isInterestedSVFVar(uniqueFunRetNode))
            addFormalRetVFGNode(uniqueFunRetNode, func, retPEs);
    }
 
    // initialize llvm phi nodes (phi of top level pointers)
    SVFStmt::SVFStmtSetTy& phis = getSVFStmtSet(SVFStmt::Phi);
    for (SVFStmt::SVFStmtSetTy::iterator iter = phis.begin(), eiter =
                phis.end(); iter != eiter; ++iter)
    {
        const PhiStmt* edge = SVFUtil::cast<PhiStmt>(*iter);
        if(isInterestedSVFVar(edge->getRes()))
            addIntraPHIVFGNode(edge);
    }
    // initialize select statement
    SVFStmt::SVFStmtSetTy& selects = getSVFStmtSet(SVFStmt::Select);
    for (SVFStmt::SVFStmtSetTy::iterator iter = selects.begin(), eiter =
                selects.end(); iter != eiter; ++iter)
    {
        const MultiOpndStmt* edge = SVFUtil::cast<MultiOpndStmt>(*iter);
        if(isInterestedSVFVar(edge->getRes()))
            addIntraPHIVFGNode(edge);
    }
    // initialize llvm binary nodes (binary operators)
    SVFStmt::SVFStmtSetTy& binaryops = getSVFStmtSet(SVFStmt::BinaryOp);
    for (SVFStmt::SVFStmtSetTy::iterator iter = binaryops.begin(), eiter =
                binaryops.end(); iter != eiter; ++iter)
    {
        const BinaryOPStmt* edge = SVFUtil::cast<BinaryOPStmt>(*iter);
        if(isInterestedSVFVar(edge->getRes()))
            addBinaryOPVFGNode(edge);
    }
    // initialize llvm unary nodes (unary operators)
    SVFStmt::SVFStmtSetTy& unaryops = getSVFStmtSet(SVFStmt::UnaryOp);
    for (SVFStmt::SVFStmtSetTy::iterator iter = unaryops.begin(), eiter =
                unaryops.end(); iter != eiter; ++iter)
    {
        const UnaryOPStmt* edge = SVFUtil::cast<UnaryOPStmt>(*iter);
        if(isInterestedSVFVar(edge->getRes()))
            addUnaryOPVFGNode(edge);
    }
    // initialize llvm unary nodes (unary operators)
    SVFStmt::SVFStmtSetTy& brs = getSVFStmtSet(SVFStmt::Branch);
    for (SVFStmt::SVFStmtSetTy::iterator iter = brs.begin(), eiter =
                brs.end(); iter != eiter; ++iter)
    {
        const BranchStmt* edge = SVFUtil::cast<BranchStmt>(*iter);
        if(isInterestedSVFVar(edge->getBranchInst()))
            addBranchVFGNode(edge);
    }
    // initialize llvm cmp nodes (comparison)
    SVFStmt::SVFStmtSetTy& cmps = getSVFStmtSet(SVFStmt::Cmp);
    for (SVFStmt::SVFStmtSetTy::iterator iter = cmps.begin(), eiter =
                cmps.end(); iter != eiter; ++iter)
    {
        const CmpStmt* edge = SVFUtil::cast<CmpStmt>(*iter);
        if(isInterestedSVFVar(edge->getRes()))
            addCmpVFGNode(edge);
    }
}

checkIntraEdgeParents()

void SVF::VFG::checkIntraEdgeParents ( const VFGNode * srcNode, const VFGNode * dstNode )

inlineprotected

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

Definition at line 413 of file VFG.h.

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

connectAParamAndFParam()

virtual void SVF::VFG::connectAParamAndFParam ( const ValVar * csArg, const ValVar * funArg, const CallICFGNode * cbn, CallSiteID csId, VFGEdgeSetTy & edges )

inlineprotectedvirtual

Connect VFG nodes between caller and callee for indirect call site.

Connect actual-param and formal param

Reimplemented in SVF::SVFGOPT.

Definition at line 448 of file VFG.h.

    {
        NodeID actualParam = getActualParmVFGNode(csArg, cbn)->getId();
        NodeID formalParam = getFormalParmVFGNode(funArg)->getId();
        VFGEdge* edge = addInterEdgeFromAPToFP(actualParam, formalParam,csId);
        if (edge != nullptr)
            edges.insert(edge);
    }

connectCallerAndCallee()

void VFG::connectCallerAndCallee ( const CallICFGNode * callBlockNode, const FunObjVar * callee, VFGEdgeSetTy & edges )

virtual

Connect VFG nodes between caller and callee for indirect call site.

Connect actual params/return to formal params/return for top-level variables. Also connect indirect actual in/out and formal in/out.

Reimplemented in SVF::SVFG.

Definition at line 953 of file VFG.cpp.

{
    SVFIR * pag = SVFIR::getPAG();
    CallSiteID csId = getCallSiteID(callBlockNode, callee);
    const RetICFGNode* retBlockNode = callBlockNode->getRetICFGNode();
    // connect actual and formal param
    if (pag->hasCallSiteArgsMap(callBlockNode) && pag->hasFunArgsList(callee) &&
            matchArgs(callBlockNode, callee))
    {
        const SVFIR::ValVarList& csArgList = pag->getCallSiteArgsList(callBlockNode);
        const SVFIR::ValVarList& funArgList = pag->getFunArgsList(callee);
        SVFIR::ValVarList::const_iterator csArgIt = csArgList.begin(), csArgEit = csArgList.end();
        SVFIR::ValVarList::const_iterator funArgIt = funArgList.begin(), funArgEit = funArgList.end();
        for (; funArgIt != funArgEit && csArgIt != csArgEit; funArgIt++, csArgIt++)
        {
            const ValVar *cs_arg = *csArgIt;
            const ValVar *fun_arg = *funArgIt;
            if (isInterestedSVFVar(cs_arg) && isInterestedSVFVar(fun_arg))
                connectAParamAndFParam(cs_arg, fun_arg, callBlockNode, csId, edges);
        }
        assert(funArgIt == funArgEit && "function has more arguments than call site");
 
        if (callee->isVarArg())
        {
            NodeID varFunArg = pag->getVarargNode(callee);
            const ValVar* varFunArgNode = pag->getValVar(varFunArg);
            if (isInterestedSVFVar(varFunArgNode))
            {
                for (; csArgIt != csArgEit; csArgIt++)
                {
                    const ValVar *cs_arg = *csArgIt;
                    if (isInterestedSVFVar(cs_arg))
                        connectAParamAndFParam(cs_arg, varFunArgNode, callBlockNode, csId, edges);
                }
            }
        }
    }
 
    // connect actual return and formal return
    if (pag->funHasRet(callee) && pag->callsiteHasRet(retBlockNode))
    {
        const ValVar* cs_return = pag->getCallSiteRet(retBlockNode);
        const ValVar* fun_return = pag->getFunRet(callee);
        if (isInterestedSVFVar(cs_return) && isInterestedSVFVar(fun_return))
            connectFRetAndARet(fun_return, cs_return, csId, edges);
    }
}

connectDirectVFGEdges()

void VFG::connectDirectVFGEdges ( )

protected

Create edges between VFG nodes within a function.

Connect def-use chains for direct value-flow, (value-flow of top level pointers)

do not handle AddrSVFG node, as it is already the source of a definition

for all other cases, like copy/gep/load/ret, connect the RHS pointer to its def

for store, connect the RHS/LHS pointer to its def

connect formal ret to its definition node

connect formal ret to actual ret

Do not process FormalRetVFGNode, as they are connected by copy within callee We assume one procedure only has unique return

connect direct value-flow edges (parameter passing) for thread fork/join

add fork edge

add join edge

Definition at line 710 of file VFG.cpp.

{
 
    for(iterator it = begin(), eit = end(); it!=eit; ++it)
    {
        NodeID nodeId = it->first;
        VFGNode* node = it->second;
 
        if(StmtVFGNode* stmtNode = SVFUtil::dyn_cast<StmtVFGNode>(node))
        {
            if(SVFUtil::isa<AddrVFGNode>(stmtNode))
                continue;
            if (stmtNode->getSrcNode()->isConstDataOrAggDataButNotNullPtr() == false)
                // for ptr vfg, we skip src node of integer type if it is at a int2ptr copystmt
                if(isInterestedSVFVar(stmtNode->getSrcNode()))
                    addIntraDirectVFEdge(getDef(SVFUtil::cast<ValVar>(stmtNode->getSrcNode())), nodeId);
            if (const GepStmt* gepStmt = SVFUtil::dyn_cast<GepStmt>(stmtNode->getSVFStmt()))
            {
                for (const auto &varType: gepStmt->getOffsetVarAndGepTypePairVec())
                {
                    if(varType.first->isConstDataOrAggDataButNotNullPtr() || isInterestedSVFVar(varType.first) == false)
                        continue;
                    addIntraDirectVFEdge(getDef(varType.first), nodeId);
                }
            }
            if(SVFUtil::isa<StoreVFGNode>(stmtNode) && (stmtNode->getDstNode()->isConstDataOrAggDataButNotNullPtr() == false))
            {
                addIntraDirectVFEdge(getDef(SVFUtil::cast<ValVar>(stmtNode->getDstNode())), nodeId);
            }
 
        }
        else if(PHIVFGNode* phiNode = SVFUtil::dyn_cast<PHIVFGNode>(node))
        {
            for (PHIVFGNode::OPVers::const_iterator it = phiNode->opVerBegin(), eit = phiNode->opVerEnd(); it != eit; it++)
            {
                if (it->second->isConstDataOrAggDataButNotNullPtr() == false)
                    addIntraDirectVFEdge(getDef(it->second), nodeId);
            }
        }
        else if(BinaryOPVFGNode* binaryNode = SVFUtil::dyn_cast<BinaryOPVFGNode>(node))
        {
            for (BinaryOPVFGNode::OPVers::const_iterator it = binaryNode->opVerBegin(), eit = binaryNode->opVerEnd(); it != eit; it++)
            {
                if (it->second->isConstDataOrAggDataButNotNullPtr() == false)
                    addIntraDirectVFEdge(getDef(it->second), nodeId);
            }
        }
        else if(UnaryOPVFGNode* unaryNode = SVFUtil::dyn_cast<UnaryOPVFGNode>(node))
        {
            for (UnaryOPVFGNode::OPVers::const_iterator it = unaryNode->opVerBegin(), eit = unaryNode->opVerEnd(); it != eit; it++)
            {
                if (it->second->isConstDataOrAggDataButNotNullPtr() == false)
                    addIntraDirectVFEdge(getDef(it->second), nodeId);
            }
        }
        else if(CmpVFGNode* cmpNode = SVFUtil::dyn_cast<CmpVFGNode>(node))
        {
            for (CmpVFGNode::OPVers::const_iterator it = cmpNode->opVerBegin(), eit = cmpNode->opVerEnd(); it != eit; it++)
            {
                if (it->second->isConstDataOrAggDataButNotNullPtr() == false)
                    addIntraDirectVFEdge(getDef(it->second), nodeId);
            }
        }
        else if(BranchVFGNode* branchNode = SVFUtil::dyn_cast<BranchVFGNode>(node))
        {
            const ValVar* cond = branchNode->getBranchStmt()->getCondition();
            if (cond->isConstDataOrAggDataButNotNullPtr() == false)
                addIntraDirectVFEdge(getDef(cond), nodeId);
        }
        else if(ActualParmVFGNode* actualParm = SVFUtil::dyn_cast<ActualParmVFGNode>(node))
        {
            if (actualParm->getParam()->isConstDataOrAggDataButNotNullPtr() == false)
                addIntraDirectVFEdge(getDef(actualParm->getParam()), nodeId);
        }
        else if(FormalParmVFGNode* formalParm = SVFUtil::dyn_cast<FormalParmVFGNode>(node))
        {
            if(const CallPE* callPE = formalParm->getCallPE())
            {
                for(u32_t i = 0; i < callPE->getOpVarNum(); i++)
                {
                    if(isInterestedSVFVar(callPE->getOpVar(i)))
                    {
                        const CallICFGNode* cs = callPE->getOpCallICFGNode(i);
                        ActualParmVFGNode* acutalParm = getActualParmVFGNode(callPE->getOpVar(i), cs);
                        addInterEdgeFromAPToFP(acutalParm,formalParm,getCallSiteID(cs, formalParm->getFun()));
                    }
                }
            }
        }
        else if(FormalRetVFGNode* calleeRet = SVFUtil::dyn_cast<FormalRetVFGNode>(node))
        {
            addIntraDirectVFEdge(getDef(calleeRet->getRet()), nodeId);

            for(RetPESet::const_iterator it = calleeRet->retPEBegin(), eit = calleeRet->retPEEnd(); it!=eit; ++it)
            {
                ActualRetVFGNode* callsiteRev = getActualRetVFGNode((*it)->getLHSVar());
                const CallICFGNode* callBlockNode = (*it)->getCallSite();
                addInterEdgeFromFRToAR(calleeRet,callsiteRev, getCallSiteID(callBlockNode, calleeRet->getFun()));
            }
        }
    }

    if(Options::EnableThreadCallGraph())
    {
        SVFStmt::SVFStmtSetTy& forks = getSVFStmtSet(SVFStmt::ThreadFork);
        for (SVFStmt::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                    forks.end(); iter != eiter; ++iter)
        {
            TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
            FormalParmVFGNode* formalParm = getFormalParmVFGNode(forkedge->getRes());
            for(u32_t i = 0; i < forkedge->getOpVarNum(); i++)
            {
                if(isInterestedSVFVar(forkedge->getOpVar(i)))
                {
                    const CallICFGNode* cs = forkedge->getOpCallICFGNode(i);
                    ActualParmVFGNode* acutalParm = getActualParmVFGNode(forkedge->getOpVar(i), cs);
                    addInterEdgeFromAPToFP(acutalParm,formalParm,getCallSiteID(cs, formalParm->getFun()));
                }
            }
        }
        SVFStmt::SVFStmtSetTy& joins = getSVFStmtSet(SVFStmt::ThreadJoin);
        for (SVFStmt::SVFStmtSetTy::iterator iter = joins.begin(), eiter =
                    joins.end(); iter != eiter; ++iter)
        {
            TDJoinPE* joinedge = SVFUtil::cast<TDJoinPE>(*iter);
            NodeID callsiteRev = getDef(joinedge->getLHSVar());
            FormalRetVFGNode* calleeRet = getFormalRetVFGNode(joinedge->getRHSVar());
            addRetEdge(calleeRet->getId(),callsiteRev, getCallSiteID(joinedge->getCallSite(), calleeRet->getFun()));
        }
    }
}

connectFRetAndARet()

virtual void SVF::VFG::connectFRetAndARet ( const ValVar * funReturn, const ValVar * csReturn, CallSiteID csId, VFGEdgeSetTy & edges )

inlineprotectedvirtual

Connect formal-ret and actual ret.

Reimplemented in SVF::SVFGOPT.

Definition at line 457 of file VFG.h.

    {
        NodeID formalRet = getFormalRetVFGNode(funReturn)->getId();
        NodeID actualRet = getActualRetVFGNode(csReturn)->getId();
        VFGEdge* edge = addInterEdgeFromFRToAR(formalRet, actualRet,csId);
        if (edge != nullptr)
            edges.insert(edge);
    }

destroy()

void VFG::destroy ( )

protected

Clean up memory.

Memory has been cleaned up at GenericGraph

Definition at line 441 of file VFG.cpp.

{
    pag = nullptr;
}

dump()

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

Dump graph into dot file.

Dump VFG

Definition at line 917 of file VFG.cpp.

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

getActualParmVFGNode()

ActualParmVFGNode * SVF::VFG::getActualParmVFGNode ( const SVFVar * aparm, const CallICFGNode * cs ) const

inline

Definition at line 297 of file VFG.h.

    {
        SVFVarToActualParmMapTy::const_iterator it = SVFVarToActualParmMap.find(std::make_pair(aparm->getId(),cs));
        assert(it!=SVFVarToActualParmMap.end() && "actual parameter VFG node can not be found??");
        return it->second;
    }

getActualRetVFGNode()

ActualRetVFGNode * SVF::VFG::getActualRetVFGNode ( const SVFVar * aret ) const

inline

Definition at line 303 of file VFG.h.

    {
        SVFVarToActualRetMapTy::const_iterator it = SVFVarToActualRetMap.find(aret);
        assert(it!=SVFVarToActualRetMap.end() && "actual return VFG node can not be found??");
        return it->second;
    }

getBinaryOPVFGNode()

BinaryOPVFGNode * SVF::VFG::getBinaryOPVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 273 of file VFG.h.

    {
        SVFVarToBinaryOPVFGNodeMapTy::const_iterator it = SVFVarToBinaryOPVFGNodeMap.find(svfVar);
        assert(it != SVFVarToBinaryOPVFGNodeMap.end() && "BinaryOPVFGNode can not be found??");
        return it->second;
    }

getBranchVFGNode()

BranchVFGNode * SVF::VFG::getBranchVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 285 of file VFG.h.

    {
        SVFVarToBranchVFGNodeMapTy::const_iterator it = SVFVarToBranchVFGNodeMap.find(svfVar);
        assert(it != SVFVarToBranchVFGNodeMap.end() && "BranchVFGNode can not be found??");
        return it->second;
    }

getCallGraph()

CallGraph * SVF::VFG::getCallGraph ( ) const

inline

Return PTACallGraph.

Definition at line 139 of file VFG.h.

    {
        return callgraph;
    }

getCallSite()

const CallICFGNode * SVF::VFG::getCallSite ( CallSiteID id ) const

inline

Definition at line 182 of file VFG.h.

    {
        return callgraph->getCallSite(id);
    }

getCallSiteID()

CallSiteID SVF::VFG::getCallSiteID ( const CallICFGNode * cs, const FunObjVar * func ) const

inline

Get callsite given a callsiteID.

Definition at line 178 of file VFG.h.

    {
        return callgraph->getCallSiteID(cs, func);
    }

getCmpVFGNode()

CmpVFGNode * SVF::VFG::getCmpVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 291 of file VFG.h.

    {
        SVFVarToCmpVFGNodeMapTy::const_iterator it = SVFVarToCmpVFGNodeMap.find(svfVar);
        assert(it != SVFVarToCmpVFGNodeMap.end() && "CmpVFGNode can not be found??");
        return it->second;
    }

getDef()

NodeID SVF::VFG::getDef ( const ValVar * valVar ) const

inlineprotected

Definition at line 482 of file VFG.h.

    {
        ValVarToDefMapTy::const_iterator it = ValVarToDefMap.find(valVar);
        assert(it!=ValVarToDefMap.end() && "ValVar does not have a definition??");
        return it->second;
    }

getDefVFGNode()

const VFGNode * SVF::VFG::getDefVFGNode ( const ValVar * valVar ) const

inline

Given a valVar, return its definition site.

Definition at line 189 of file VFG.h.

    {
        return getVFGNode(getDef(valVar));
    }

getFormalParmVFGNode()

FormalParmVFGNode * SVF::VFG::getFormalParmVFGNode ( const SVFVar * fparm ) const

inline

Definition at line 309 of file VFG.h.

    {
        SVFVarToFormalParmMapTy::const_iterator it = SVFVarToFormalParmMap.find(fparm);
        assert(it!=SVFVarToFormalParmMap.end() && "formal parameter VFG node can not be found??");
        return it->second;
    }

getFormalRetVFGNode()

FormalRetVFGNode * SVF::VFG::getFormalRetVFGNode ( const SVFVar * fret ) const

inline

Definition at line 315 of file VFG.h.

    {
        SVFVarToFormalRetMapTy::const_iterator it = SVFVarToFormalRetMap.find(fret);
        assert(it!=SVFVarToFormalRetMap.end() && "formal return VFG node can not be found??");
        return it->second;
    }

getGlobalVFGNodes()

GlobalVFGNodeSet & SVF::VFG::getGlobalVFGNodes ( )

inline

Return global stores.

Definition at line 156 of file VFG.h.

    {
        return globalVFGNodes;
    }

getIntraPHIVFGNode()

IntraPHIVFGNode * SVF::VFG::getIntraPHIVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 267 of file VFG.h.

    {
        SVFVarToPHIVFGNodeMapTy::const_iterator it = SVFVarToIntraPHIVFGNodeMap.find(svfVar);
        assert(it != SVFVarToIntraPHIVFGNodeMap.end() && "PHIVFGNode can not be found??");
        return it->second;
    }

getIntraVFGEdge()

VFGEdge * VFG::getIntraVFGEdge	(	const VFGNode *	src,
		const VFGNode *	dst,
		VFGEdge::VFGEdgeK	kind )

Get a SVFG edge according to src and dst.

Return the corresponding VFGEdge

Definition at line 908 of file VFG.cpp.

{
    return hasIntraVFGEdge(const_cast<VFGNode*>(src),const_cast<VFGNode*>(dst),kind);
}

getKind()

VFGK SVF::VFG::getKind ( ) const

inline

Get VFG kind.

Definition at line 121 of file VFG.h.

    {
        return kind;
    }

getLHSTopLevPtr()

const SVFVar * VFG::getLHSTopLevPtr

(

const VFGNode *

node

)

const

Given a VFG node, return its left hand side top level pointer

Definition at line 1004 of file VFG.cpp.

{
 
    if(const AddrVFGNode* addr = SVFUtil::dyn_cast<AddrVFGNode>(node))
        return addr->getDstNode();
    else if(const CopyVFGNode* copy = SVFUtil::dyn_cast<CopyVFGNode>(node))
        return copy->getDstNode();
    else if(const GepVFGNode* gep = SVFUtil::dyn_cast<GepVFGNode>(node))
        return gep->getDstNode();
    else if(const LoadVFGNode* load = SVFUtil::dyn_cast<LoadVFGNode>(node))
        return load->getDstNode();
    else if(const PHIVFGNode* phi = SVFUtil::dyn_cast<PHIVFGNode>(node))
        return phi->getRes();
    else if(const CmpVFGNode* cmp = SVFUtil::dyn_cast<CmpVFGNode>(node))
        return cmp->getRes();
    else if(const BinaryOPVFGNode* bop = SVFUtil::dyn_cast<BinaryOPVFGNode>(node))
        return bop->getRes();
    else if(const UnaryOPVFGNode* uop = SVFUtil::dyn_cast<UnaryOPVFGNode>(node))
        return uop->getRes();
    else if(const ActualParmVFGNode* ap = SVFUtil::dyn_cast<ActualParmVFGNode>(node))
        return ap->getParam();
    else if(const FormalParmVFGNode*fp = SVFUtil::dyn_cast<FormalParmVFGNode>(node))
        return fp->getParam();
    else if(const ActualRetVFGNode* ar = SVFUtil::dyn_cast<ActualRetVFGNode>(node))
        return ar->getRev();
    else if(const FormalRetVFGNode* fr = SVFUtil::dyn_cast<FormalRetVFGNode>(node))
        return fr->getRet();
    else if(const NullPtrVFGNode* nullVFG = SVFUtil::dyn_cast<NullPtrVFGNode>(node))
        return nullVFG->getSVFVar();
    else
        assert(false && "unexpected node kind!");
    return nullptr;
}

getPAG()

SVFIR * SVF::VFG::getPAG ( ) const

inline

Return SVFIR.

Definition at line 133 of file VFG.h.

    {
        return pag;
    }

getStmtVFGNode()

StmtVFGNode * SVF::VFG::getStmtVFGNode ( const SVFStmt * svfStmt ) const

inline

Get an VFGNode.

Definition at line 261 of file VFG.h.

    {
        SVFStmtToStmtVFGNodeMapTy::const_iterator it = SVFStmtToStmtVFGNodeMap.find(svfStmt);
        assert(it != SVFStmtToStmtVFGNodeMap.end() && "StmtVFGNode can not be found??");
        return it->second;
    }

getSVFStmtSet()

virtual SVFStmt::SVFStmtSetTy & SVF::VFG::getSVFStmtSet ( SVFStmt::PEDGEK kind )

inlineprotectedvirtual

Get SVFStmt set.

Definition at line 498 of file VFG.h.

    {
        if (isPtrOnlySVFG())
            return pag->getPTASVFStmtSet(kind);
        else
            return pag->getSVFStmtSet(kind);
    }

getUnaryOPVFGNode()

UnaryOPVFGNode * SVF::VFG::getUnaryOPVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 279 of file VFG.h.

    {
        SVFVarToUnaryOPVFGNodeMapTy::const_iterator it = SVFVarToUnaryOPVFGNodeMap.find(svfVar);
        assert(it != SVFVarToUnaryOPVFGNodeMap.end() && "UnaryOPVFGNode can not be found??");
        return it->second;
    }

getVFGNode()

VFGNode * SVF::VFG::getVFGNode ( NodeID id ) const

inline

Get a VFG node.

Definition at line 145 of file VFG.h.

    {
        return getGNode(id);
    }

getVFGNodeBegin()

VFGNodeSet::const_iterator SVF::VFG::getVFGNodeBegin ( const FunObjVar * fun ) const

inline

Definition at line 360 of file VFG.h.

    {
        FunToVFGNodesMapTy::const_iterator it = funToVFGNodesMap.find(fun);
        assert(it != funToVFGNodesMap.end() && "this function does not have any VFGNode");
        return it->second.begin();
    }

getVFGNodeEnd()

VFGNodeSet::const_iterator SVF::VFG::getVFGNodeEnd ( const FunObjVar * fun ) const

inline

Definition at line 366 of file VFG.h.

    {
        FunToVFGNodesMapTy::const_iterator it = funToVFGNodesMap.find(fun);
        assert(it != funToVFGNodesMap.end() && "this function does not have any VFGNode");
        return it->second.end();
    }

getVFGNodes()

VFGNodeSet & SVF::VFG::getVFGNodes ( const FunObjVar * fun )

inline

Return all the VFGNodes of a function

Definition at line 348 of file VFG.h.

    {
        return funToVFGNodesMap[fun];
    }

hasActualParmVFGNode()

bool SVF::VFG::hasActualParmVFGNode ( const SVFVar * aparm, const CallICFGNode * cs ) const

inline

Definition at line 241 of file VFG.h.

    {
        return SVFVarToActualParmMap.find(std::make_pair(aparm->getId(),cs)) != SVFVarToActualParmMap.end();
    }

hasActualRetVFGNode()

bool SVF::VFG::hasActualRetVFGNode ( const SVFVar * aret ) const

inline

Definition at line 245 of file VFG.h.

    {
        return SVFVarToActualRetMap.find(aret) != SVFVarToActualRetMap.end();
    }

hasBinaryOPVFGNode()

bool SVF::VFG::hasBinaryOPVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 225 of file VFG.h.

    {
        return SVFVarToBinaryOPVFGNodeMap.find(svfVar) != SVFVarToBinaryOPVFGNodeMap.end();
    }

hasBlackHoleConstObjAddrAsDef()

bool SVF::VFG::hasBlackHoleConstObjAddrAsDef ( const ValVar * valVar ) const

inline

Whether a SVFVar has a blackhole or const object as its definition.

Definition at line 327 of file VFG.h.

    {
        if (hasDef(valVar))
        {
            const VFGNode* defNode = getVFGNode(getDef(valVar));
            if (const AddrVFGNode* addr = SVFUtil::dyn_cast<AddrVFGNode>(defNode))
            {
                if (SVFIR::getPAG()->isBlkObjOrConstantObj(addr->getSVFStmt()->getSrcID()))
                    return true;
            }
            else if(const CopyVFGNode* copy = SVFUtil::dyn_cast<CopyVFGNode>(defNode))
            {
                if (SVFIR::getPAG()->isNullPtr(copy->getSVFStmt()->getSrcID()))
                    return true;
            }
        }
        return false;
    }

hasBranchVFGNode()

bool SVF::VFG::hasBranchVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 233 of file VFG.h.

    {
        return SVFVarToBranchVFGNodeMap.find(svfVar) != SVFVarToBranchVFGNodeMap.end();
    }

hasCmpVFGNode()

bool SVF::VFG::hasCmpVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 237 of file VFG.h.

    {
        return SVFVarToCmpVFGNodeMap.find(svfVar) != SVFVarToCmpVFGNodeMap.end();
    }

hasDef()

bool SVF::VFG::hasDef ( const ValVar * valVar ) const

inlineprotected

Definition at line 488 of file VFG.h.

    {
        return (ValVarToDefMap.find(valVar) != ValVarToDefMap.end());
    }

hasFormalParmVFGNode()

bool SVF::VFG::hasFormalParmVFGNode ( const SVFVar * fparm ) const

inline

Definition at line 249 of file VFG.h.

    {
        return SVFVarToFormalParmMap.find(fparm) != SVFVarToFormalParmMap.end();
    }

hasFormalRetVFGNode()

bool SVF::VFG::hasFormalRetVFGNode ( const SVFVar * fret ) const

inline

Definition at line 253 of file VFG.h.

    {
        return SVFVarToFormalRetMap.find(fret) != SVFVarToFormalRetMap.end();
    }

hasInterVFGEdge()

VFGEdge * VFG::hasInterVFGEdge	(	VFGNode *	src,
		VFGNode *	dst,
		VFGEdge::VFGEdgeK	kind,
		CallSiteID	csId )

Whether we has an inter VFG edge

Definition at line 890 of file VFG.cpp.

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

hasIntraPHIVFGNode()

bool SVF::VFG::hasIntraPHIVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 221 of file VFG.h.

    {
        return SVFVarToIntraPHIVFGNodeMap.find(svfVar) != SVFVarToIntraPHIVFGNodeMap.end();
    }

hasIntraVFGEdge()

VFGEdge * VFG::hasIntraVFGEdge	(	VFGNode *	src,
		VFGNode *	dst,
		VFGEdge::VFGEdgeK	kind )

Whether we has a SVFG edge.

Whether we has an intra VFG edge

Definition at line 855 of file VFG.cpp.

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

hasLHSTopLevPtr()

bool SVF::VFG::hasLHSTopLevPtr ( const VFGNode * node ) const

inline

Definition at line 195 of file VFG.h.

    {
        return node && SVFUtil::isa<AddrVFGNode,
               CopyVFGNode,
               GepVFGNode,
               LoadVFGNode,
               PHIVFGNode,
               CmpVFGNode,
               BinaryOPVFGNode,
               UnaryOPVFGNode,
               ActualParmVFGNode,
               FormalParmVFGNode,
               ActualRetVFGNode,
               FormalRetVFGNode,
               NullPtrVFGNode>(node);
    }

hasStmtVFGNode()

bool SVF::VFG::hasStmtVFGNode ( const SVFStmt * svfStmt ) const

inline

Existence checks for VFGNodes.

Definition at line 217 of file VFG.h.

    {
        return SVFStmtToStmtVFGNodeMap.find(svfStmt) != SVFStmtToStmtVFGNodeMap.end();
    }

hasThreadVFGEdge()

VFGEdge * VFG::hasThreadVFGEdge	(	VFGNode *	src,
		VFGNode *	dst,
		VFGEdge::VFGEdgeK	kind )

Whether we has an thread VFG edge

Definition at line 873 of file VFG.cpp.

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

hasUnaryOPVFGNode()

bool SVF::VFG::hasUnaryOPVFGNode ( const SVFVar * svfVar ) const

inline

Definition at line 229 of file VFG.h.

    {
        return SVFVarToUnaryOPVFGNodeMap.find(svfVar) != SVFVarToUnaryOPVFGNodeMap.end();
    }

hasVFGNode()

bool SVF::VFG::hasVFGNode ( NodeID id ) const

inline

Whether has the VFGNode.

Definition at line 151 of file VFG.h.

    {
        return hasGNode(id);
    }

hasVFGNodes()

bool SVF::VFG::hasVFGNodes ( const FunObjVar * fun ) const

inline

Definition at line 352 of file VFG.h.

    {
        return funToVFGNodesMap.find(fun) != funToVFGNodesMap.end();
    }

isFunEntryVFGNode()

const FunObjVar * VFG::isFunEntryVFGNode

(

const VFGNode *

node

)

const

Whether a node is function entry VFGNode.

Whether this is an function entry VFGNode (formal parameter, formal In)

Definition at line 1041 of file VFG.cpp.

{
    if(const FormalParmVFGNode* fp = SVFUtil::dyn_cast<FormalParmVFGNode>(node))
    {
        return fp->getFun();
    }
    else if(const InterPHIVFGNode* phi = SVFUtil::dyn_cast<InterPHIVFGNode>(node))
    {
        if(phi->isFormalParmPHI())
            return phi->getFun();
    }
    return nullptr;
}

isInterestedSVFVar()

virtual bool SVF::VFG::isInterestedSVFVar ( const SVFVar * node ) const

inlineprotectedvirtual

Definition at line 506 of file VFG.h.

    {
        if (isPtrOnlySVFG())
            return node->isPointer();
        else
            return true;
    }

isPhiCopyEdge()

bool SVF::VFG::isPhiCopyEdge ( const SVFStmt * copy ) const

inlineprotected

Definition at line 520 of file VFG.h.

    {
        return pag->isPhiNode(copy->getDstNode());
    }

isPtrOnlySVFG()

bool SVF::VFG::isPtrOnlySVFG ( ) const

inline

Return true if this VFG only contains pointer related SVFGNodes for pointer analysis.

Definition at line 127 of file VFG.h.

    {
        return (kind == PTRONLYSVFG) || (kind == PTRONLYSVFG_OPT);
    }

removeVFGEdge()

void SVF::VFG::removeVFGEdge ( VFGEdge * edge )

inline

Remove a SVFG edge.

Definition at line 381 of file VFG.h.

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

removeVFGNode()

void SVF::VFG::removeVFGNode ( VFGNode * node )

inline

Remove a VFGNode.

Definition at line 388 of file VFG.h.

    {
        removeGNode(node);
    }

setDef()

void SVF::VFG::setDef ( const ValVar * valVar, const VFGNode * node )

inlineprotected

Given a ValVar, set/get its def VFG node (definition of top level pointers).

Definition at line 469 of file VFG.h.

    {
        ValVarToDefMapTy::iterator it = ValVarToDefMap.find(valVar);
        if(it == ValVarToDefMap.end())
        {
            ValVarToDefMap[valVar] = node->getId();
            assert(hasVFGNode(node->getId()) && "not in the map!!");
        }
        else
        {
            assert((it->second == node->getId()) && "a ValVar can only have unique definition ");
        }
    }

updateCallGraph()

void VFG::updateCallGraph

(

PointerAnalysis *

pta

)

Update VFG based on pointer analysis results.

Definition at line 931 of file VFG.cpp.

{
    VFGEdgeSetTy vfEdgesAtIndCallSite;
    CallGraph::CallEdgeMap::const_iterator iter = pta->getIndCallMap().begin();
    CallGraph::CallEdgeMap::const_iterator eiter = pta->getIndCallMap().end();
    for (; iter != eiter; iter++)
    {
        const CallICFGNode* newcs = iter->first;
        assert(newcs->isIndirectCall() && "this is not an indirect call?");
        const PointerAnalysis::FunctionSet & functions = iter->second;
        for (PointerAnalysis::FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
        {
            const FunObjVar*  func = *func_iter;
            connectCallerAndCallee(newcs, func, vfEdgesAtIndCallSite);
        }
    }
}

VFGNodes()

bool SVF::VFG::VFGNodes ( const FunObjVar * fun ) const

inline

Definition at line 356 of file VFG.h.

    {
        return funToVFGNodesMap.find(fun) != funToVFGNodesMap.end();
    }

view()

void VFG::view

(

)

Dump graph into dot file.

View VFG from the debugger.

Definition at line 925 of file VFG.cpp.

{
    SVF::ViewGraph(this, "Value Flow Graph");
}

Member Data Documentation

callgraph

CallGraph* SVF::VFG::callgraph

protected

Definition at line 103 of file VFG.h.

funToVFGNodesMap

FunToVFGNodesMapTy SVF::VFG::funToVFGNodesMap

protected

map a function to its VFGNodes;

Definition at line 100 of file VFG.h.

globalVFGNodes

GlobalVFGNodeSet SVF::VFG::globalVFGNodes

protected

set of global store VFG nodes

Definition at line 102 of file VFG.h.

kind

VFGK SVF::VFG::kind

protected

Definition at line 105 of file VFG.h.

pag

SVFIR* SVF::VFG::pag

protected

Definition at line 104 of file VFG.h.

SVFStmtToStmtVFGNodeMap

SVFStmtToStmtVFGNodeMapTy SVF::VFG::SVFStmtToStmtVFGNodeMap

protected

map a SVFStmt to its StmtVFGNode

Definition at line 99 of file VFG.h.

SVFVarToActualParmMap

SVFVarToActualParmMapTy SVF::VFG::SVFVarToActualParmMap

protected

map a SVFVar to an actual parameter

Definition at line 90 of file VFG.h.

SVFVarToActualRetMap

SVFVarToActualRetMapTy SVF::VFG::SVFVarToActualRetMap

protected

map a SVFVar to an actual return

Definition at line 91 of file VFG.h.

SVFVarToBinaryOPVFGNodeMap

SVFVarToBinaryOPVFGNodeMapTy SVF::VFG::SVFVarToBinaryOPVFGNodeMap

protected

map a SVFVar to its BinaryOPVFGNode

Definition at line 95 of file VFG.h.

SVFVarToBranchVFGNodeMap

SVFVarToBranchVFGNodeMapTy SVF::VFG::SVFVarToBranchVFGNodeMap

protected

map a SVFVar to its BranchVFGNode

Definition at line 97 of file VFG.h.

SVFVarToCmpVFGNodeMap

SVFVarToCmpVFGNodeMapTy SVF::VFG::SVFVarToCmpVFGNodeMap

protected

map a SVFVar to its CmpVFGNode

Definition at line 98 of file VFG.h.

SVFVarToFormalParmMap

SVFVarToFormalParmMapTy SVF::VFG::SVFVarToFormalParmMap

protected

map a SVFVar to a formal parameter

Definition at line 92 of file VFG.h.

SVFVarToFormalRetMap

SVFVarToFormalRetMapTy SVF::VFG::SVFVarToFormalRetMap

protected

map a SVFVar to a formal return

Definition at line 93 of file VFG.h.

SVFVarToIntraPHIVFGNodeMap

SVFVarToPHIVFGNodeMapTy SVF::VFG::SVFVarToIntraPHIVFGNodeMap

protected

map a SVFVar to its PHIVFGNode

Definition at line 94 of file VFG.h.

SVFVarToUnaryOPVFGNodeMap

SVFVarToUnaryOPVFGNodeMapTy SVF::VFG::SVFVarToUnaryOPVFGNodeMap

protected

map a SVFVar to its UnaryOPVFGNode

Definition at line 96 of file VFG.h.

totalVFGNode

NodeID SVF::VFG::totalVFGNode

protected

Definition at line 88 of file VFG.h.

ValVarToDefMap

ValVarToDefMapTy SVF::VFG::ValVarToDefMap

protected

map a pag node to its definition SVG node

Definition at line 89 of file VFG.h.

---

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

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