#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< 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
	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< 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 ()

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< NodeTy, EdgeTy >
IDToNodeMapTy	IDToNodeMap
	node map

Additional Inherited Members
Public Attributes inherited from SVF::GenericGraph< NodeTy, EdgeTy >
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 425 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 666 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 640 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 686 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 447 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 950 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 707 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 438 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 914 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 905 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 1001 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 887 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 852 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 870 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 1038 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 928 of file VFG.cpp.

{
    VFGEdgeSetTy vfEdgesAtIndCallSite;
    PointerAnalysis::CallEdgeMap::const_iterator iter = pta->getIndCallMap().begin();
    PointerAnalysis::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 922 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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ CallPESet

◆ const_iterator

◆ FunToVFGNodesMapTy

◆ GlobalVFGNodeSet

◆ iterator

◆ RetPESet

◆ SVFGEdgeSetTy

◆ SVFStmtSet

◆ SVFStmtToStmtVFGNodeMapTy

◆ SVFVarSet

◆ SVFVarToActualParmMapTy

◆ SVFVarToActualRetMapTy

◆ SVFVarToBinaryOPVFGNodeMapTy

◆ SVFVarToBranchVFGNodeMapTy

◆ SVFVarToCmpVFGNodeMapTy

◆ SVFVarToFormalParmMapTy

◆ SVFVarToFormalRetMapTy

◆ SVFVarToPHIVFGNodeMapTy

◆ SVFVarToUnaryOPVFGNodeMapTy

◆ ValVarToDefMapTy

◆ VFGEdgeSetTy

◆ VFGNodeIDToNodeMapTy

◆ VFGNodeIter

◆ VFGNodeSet

Member Enumeration Documentation

◆ VFGK

Constructor & Destructor Documentation

◆ VFG()

◆ ~VFG()

Member Function Documentation

◆ addActualParmVFGNode()

◆ addActualRetVFGNode()

◆ addAddrVFGNode()

◆ addBinaryOPVFGNode()

◆ addBranchVFGNode()

◆ addCallEdge()

◆ addCmpVFGNode()

◆ addCopyVFGNode()

◆ addFormalParmVFGNode()

◆ addFormalRetVFGNode()

◆ addGepVFGNode()

◆ addInterEdgeFromAPToFP() [1/2]

◆ addInterEdgeFromAPToFP() [2/2]

◆ addInterEdgeFromFRToAR() [1/2]

◆ addInterEdgeFromFRToAR() [2/2]

◆ addIntraDirectVFEdge()

◆ addIntraPHIVFGNode()

◆ addLoadVFGNode()

◆ addNullPtrVFGNode()

◆ addRetEdge()

◆ addStmtVFGNode()

◆ addStoreVFGNode()

◆ addUnaryOPVFGNode()

◆ addVFGEdge()

◆ addVFGInterEdges()

◆ addVFGNode()

◆ addVFGNodes()

◆ checkIntraEdgeParents()

◆ connectAParamAndFParam()

◆ connectCallerAndCallee()

◆ connectDirectVFGEdges()

◆ connectFRetAndARet()

◆ destroy()

◆ dump()

◆ getActualParmVFGNode()

◆ getActualRetVFGNode()

◆ getBinaryOPVFGNode()

◆ getBranchVFGNode()

◆ getCallGraph()

◆ getCallSite()

◆ getCallSiteID()

◆ getCmpVFGNode()

◆ getDef()