#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 PAGNode *, NodeID >	PAGNodeToDefMapTy

typedef Map< std::pair< NodeID, const CallICFGNode * >, ActualParmVFGNode * >	PAGNodeToActualParmMapTy

typedef Map< const PAGNode , ActualRetVFGNode >	PAGNodeToActualRetMapTy

typedef Map< const PAGNode , FormalParmVFGNode >	PAGNodeToFormalParmMapTy

typedef Map< const PAGNode , FormalRetVFGNode >	PAGNodeToFormalRetMapTy

typedef Map< const PAGEdge , StmtVFGNode >	PAGEdgeToStmtVFGNodeMapTy

typedef Map< const PAGNode , IntraPHIVFGNode >	PAGNodeToPHIVFGNodeMapTy

typedef Map< const PAGNode , BinaryOPVFGNode >	PAGNodeToBinaryOPVFGNodeMapTy

typedef Map< const PAGNode , UnaryOPVFGNode >	PAGNodeToUnaryOPVFGNodeMapTy

typedef Map< const PAGNode , BranchVFGNode >	PAGNodeToBranchVFGNodeMapTy

typedef Map< const PAGNode , CmpVFGNode >	PAGNodeToCmpVFGNodeMapTy

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 PAGNode * >	PAGNodeSet

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 PAGNode *pagNode) const
	Given a pagNode, return its definition site.

bool	hasLHSTopLevPtr (const VFGNode *node) const

const PAGNode *	getLHSTopLevPtr (const VFGNode *node) const

bool	hasStmtVFGNode (const PAGEdge *pagEdge) const
	Existence checks for VFGNodes.

bool	hasIntraPHIVFGNode (const PAGNode *pagNode) const

bool	hasBinaryOPVFGNode (const PAGNode *pagNode) const

bool	hasUnaryOPVFGNode (const PAGNode *pagNode) const

bool	hasBranchVFGNode (const PAGNode *pagNode) const

bool	hasCmpVFGNode (const PAGNode *pagNode) const

bool	hasActualParmVFGNode (const PAGNode aparm, const CallICFGNode cs) const

bool	hasActualRetVFGNode (const PAGNode *aret) const

bool	hasFormalParmVFGNode (const PAGNode *fparm) const

bool	hasFormalRetVFGNode (const PAGNode *fret) const

StmtVFGNode *	getStmtVFGNode (const PAGEdge *pagEdge) const
	Get an VFGNode.

IntraPHIVFGNode *	getIntraPHIVFGNode (const PAGNode *pagNode) const

BinaryOPVFGNode *	getBinaryOPVFGNode (const PAGNode *pagNode) const

UnaryOPVFGNode *	getUnaryOPVFGNode (const PAGNode *pagNode) const

BranchVFGNode *	getBranchVFGNode (const PAGNode *pagNode) const

CmpVFGNode *	getCmpVFGNode (const PAGNode *pagNode) const

ActualParmVFGNode *	getActualParmVFGNode (const PAGNode aparm, const CallICFGNode cs) const

ActualRetVFGNode *	getActualRetVFGNode (const PAGNode *aret) const

FormalParmVFGNode *	getFormalParmVFGNode (const PAGNode *fparm) const

FormalRetVFGNode *	getFormalRetVFGNode (const PAGNode *fret) const

const FunObjVar *	isFunEntryVFGNode (const VFGNode *node) const
	Whether a node is function entry VFGNode.

bool	hasBlackHoleConstObjAddrAsDef (const PAGNode *pagNode) const
	Whether a PAGNode 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 PAGNode csArg, const PAGNode funArg, const CallICFGNode *cbn, CallSiteID csId, VFGEdgeSetTy &edges)
	Connect VFG nodes between caller and callee for indirect call site.

virtual void	connectFRetAndARet (const PAGNode funReturn, const PAGNode csReturn, CallSiteID csId, VFGEdgeSetTy &edges)
	Connect formal-ret and actual ret.

void	setDef (const PAGNode pagNode, const VFGNode node)
	Given a PAGNode, set/get its def VFG node (definition of top level pointers)

NodeID	getDef (const PAGNode *pagNode) const

bool	hasDef (const PAGNode *pagNode) const

void	addVFGNodes ()
	Create VFG nodes.

virtual SVFStmt::SVFStmtSetTy &	getPAGEdgeSet (SVFStmt::PEDGEK kind)
	Get PAGEdge set.

virtual bool	isInterestedPAGNode (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 PAGEdge *copy) const

virtual void	addVFGNode (VFGNode vfgNode, ICFGNode icfgNode)
	Add a VFG node.

void	addStmtVFGNode (StmtVFGNode node, const PAGEdge pagEdge)
	Add a VFG node for program statement.

void	addNullPtrVFGNode (const PAGNode *pagNode)

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 PAGNode aparm, const CallICFGNode cs)

void	addFormalParmVFGNode (const PAGNode fparm, const FunObjVar fun, CallPESet &callPEs)
	Add a formal parameter VFG node.

void	addFormalRetVFGNode (const PAGNode uniqueFunRet, const FunObjVar fun, RetPESet &retPEs)

void	addActualRetVFGNode (const PAGNode 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

PAGNodeToDefMapTy	PAGNodeToDefMap
	map a pag node to its definition SVG node

PAGNodeToActualParmMapTy	PAGNodeToActualParmMap
	map a PAGNode to an actual parameter

PAGNodeToActualRetMapTy	PAGNodeToActualRetMap
	map a PAGNode to an actual return

PAGNodeToFormalParmMapTy	PAGNodeToFormalParmMap
	map a PAGNode to a formal parameter

PAGNodeToFormalRetMapTy	PAGNodeToFormalRetMap
	map a PAGNode to a formal return

PAGNodeToPHIVFGNodeMapTy	PAGNodeToIntraPHIVFGNodeMap
	map a PAGNode to its PHIVFGNode

PAGNodeToBinaryOPVFGNodeMapTy	PAGNodeToBinaryOPVFGNodeMap
	map a PAGNode to its BinaryOPVFGNode

PAGNodeToUnaryOPVFGNodeMapTy	PAGNodeToUnaryOPVFGNodeMap
	map a PAGNode to its UnaryOPVFGNode

PAGNodeToBranchVFGNodeMapTy	PAGNodeToBranchVFGNodeMap
	map a PAGNode to its BranchVFGNode

PAGNodeToCmpVFGNodeMapTy	PAGNodeToCmpVFGNodeMap
	map a PAGNode to its CmpVFGNode

PAGEdgeToStmtVFGNodeMapTy	PAGEdgeToStmtVFGNodeMap
	map a PAGEdge 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.

◆ PAGEdgeToStmtVFGNodeMapTy

typedef Map<const PAGEdge*, StmtVFGNode*> SVF::VFG::PAGEdgeToStmtVFGNodeMapTy

Definition at line 67 of file VFG.h.

◆ PAGNodeSet

typedef Set<const PAGNode*> SVF::VFG::PAGNodeSet

Definition at line 84 of file VFG.h.

◆ PAGNodeToActualParmMapTy

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

Definition at line 63 of file VFG.h.

◆ PAGNodeToActualRetMapTy

typedef Map<const PAGNode*, ActualRetVFGNode *> SVF::VFG::PAGNodeToActualRetMapTy

Definition at line 64 of file VFG.h.

◆ PAGNodeToBinaryOPVFGNodeMapTy

typedef Map<const PAGNode*, BinaryOPVFGNode*> SVF::VFG::PAGNodeToBinaryOPVFGNodeMapTy

Definition at line 69 of file VFG.h.

◆ PAGNodeToBranchVFGNodeMapTy

typedef Map<const PAGNode*, BranchVFGNode*> SVF::VFG::PAGNodeToBranchVFGNodeMapTy

Definition at line 71 of file VFG.h.

◆ PAGNodeToCmpVFGNodeMapTy

typedef Map<const PAGNode*, CmpVFGNode*> SVF::VFG::PAGNodeToCmpVFGNodeMapTy

Definition at line 72 of file VFG.h.

◆ PAGNodeToDefMapTy

typedef Map<const PAGNode*, NodeID> SVF::VFG::PAGNodeToDefMapTy

Definition at line 62 of file VFG.h.

◆ PAGNodeToFormalParmMapTy

typedef Map<const PAGNode*, FormalParmVFGNode *> SVF::VFG::PAGNodeToFormalParmMapTy

Definition at line 65 of file VFG.h.

◆ PAGNodeToFormalRetMapTy

typedef Map<const PAGNode*, FormalRetVFGNode *> SVF::VFG::PAGNodeToFormalRetMapTy

Definition at line 66 of file VFG.h.

◆ PAGNodeToPHIVFGNodeMapTy

typedef Map<const PAGNode*, IntraPHIVFGNode*> SVF::VFG::PAGNodeToPHIVFGNodeMapTy

Definition at line 68 of file VFG.h.

◆ PAGNodeToUnaryOPVFGNodeMapTy

typedef Map<const PAGNode*, UnaryOPVFGNode*> SVF::VFG::PAGNodeToUnaryOPVFGNodeMapTy

Definition at line 70 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.

◆ 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 (PAGEdges) 2) connect VFG edges between two statements (PAGEdges)

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 PAGNode *	aparm,
		const CallICFGNode *	cs
	)

inlineprotected

Add an actual parameter VFG node To be noted that multiple actual parameters may have same value (PAGNode) So we need to make a pair <PAGNodeID,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));
        PAGNodeToActualParmMap[std::make_pair(aparm->getId(),cs)] = sNode;
    }

◆ addActualRetVFGNode()

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

inlineprotected

Add a callsite Receive VFG node.

Definition at line 633 of file VFG.h.

    {
        ActualRetVFGNode* sNode = new ActualRetVFGNode(totalVFGNode++,ret,cs);
        addVFGNode(sNode, const_cast<RetICFGNode*>(cs->getRetICFGNode()));
        setDef(ret,sNode);
        PAGNodeToActualRetMap[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(addr->getLHSVar(),sNode);
    }

◆ addBinaryOPVFGNode()

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

inlineprotected

Add a BinaryOperator VFG node.

Definition at line 669 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);
        PAGNodeToBinaryOPVFGNodeMap[edge->getRes()] = sNode;
    }

◆ addBranchVFGNode()

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

inlineprotected

Add a BranchVFGNode.

Definition at line 692 of file VFG.h.

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

◆ addCallEdge()

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

Add interprocedural call edges for top level pointers

Definition at line 685 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 655 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);
        PAGNodeToCmpVFGNodeMap[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 PAGNode *	fparm,
		const FunObjVar *	fun,
		CallPESet &	callPEs
	)

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));
        for(CallPESet::const_iterator it = callPEs.begin(), eit=callPEs.end();
                it!=eit; ++it)
            sNode->addCallPE(*it);
 
        setDef(fparm,sNode);
        PAGNodeToFormalParmMap[fparm] = sNode;
    }

◆ addFormalRetVFGNode()

void SVF::VFG::addFormalRetVFGNode	(	const PAGNode *	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 <PAGNodeID,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 614 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);
 
        PAGNodeToFormalRetMap[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 659 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 641 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);
        PAGNodeToIntraPHIVFGNodeMap[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 PAGNode * pagNode )

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++,pagNode);
        addVFGNode(sNode, pag->getICFG()->getGlobalICFGNode());
        setDef(pagNode,sNode);
    }

◆ addRetEdge()

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

Add interprocedural return edges for top level pointers

Definition at line 705 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 PAGEdge *	pagEdge
	)

inlineprotected

Add a VFG node for program statement.

Definition at line 539 of file VFG.h.

    {
        assert(PAGEdgeToStmtVFGNodeMap.find(pagEdge)==PAGEdgeToStmtVFGNodeMap.end() && "should not insert twice!");
        PAGEdgeToStmtVFGNodeMap[pagEdge] = node;
        addVFGNode(node, pagEdge->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 683 of file VFG.h.

    {
        UnaryOPVFGNode* sNode = new UnaryOPVFGNode(totalVFGNode++, edge->getRes());
        sNode->setOpVer(0, edge->getOpVar());
        addVFGNode(sNode,edge->getICFGNode());
        setDef(edge->getRes(),sNode);
        PAGNodeToUnaryOPVFGNodeMap[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->getGNode(pag->getNullPtr()));
 
    // initialize address nodes
    SVFStmt::SVFStmtSetTy& addrs = getPAGEdgeSet(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 = getPAGEdgeSet(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 = getPAGEdgeSet(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 = getPAGEdgeSet(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 = getPAGEdgeSet(SVFStmt::Store);
    for (SVFStmt::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                stores.end(); iter != eiter; ++iter)
    {
        addStoreVFGNode(SVFUtil::cast<StoreStmt>(*iter));
    }
 
    SVFStmt::SVFStmtSetTy& forks = getPAGEdgeSet(SVFStmt::ThreadFork);
    for (SVFStmt::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                forks.end(); iter != eiter; ++iter)
    {
        TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
        addActualParmVFGNode(forkedge->getRHSVar(),forkedge->getCallSite());
    }
 
    // initialize actual parameter nodes
    for(SVFIR::CSToArgsListMap::iterator it = pag->getCallSiteArgsMap().begin(), eit = pag->getCallSiteArgsMap().end(); it !=eit; ++it)
    {
 
        for(SVFIR::SVFVarList::iterator pit = it->second.begin(), epit = it->second.end(); pit!=epit; ++pit)
        {
            const PAGNode* pagNode = *pit;
            if (isInterestedPAGNode(pagNode))
                addActualParmVFGNode(pagNode,it->first);
        }
    }
 
    // initialize actual return nodes (callsite return)
    for(SVFIR::CSToRetMap::iterator it = pag->getCallSiteRets().begin(), eit = pag->getCallSiteRets().end(); it !=eit; ++it)
    {
 
        if(isInterestedPAGNode(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::SVFVarList::iterator pit = it->second.begin(), epit = it->second.end(); pit!=epit; ++pit)
        {
            const PAGNode* param = *pit;
            if (isInterestedPAGNode(param) == false || hasBlackHoleConstObjAddrAsDef(param))
                continue;
 
            CallPESet callPEs;
            if (param->hasIncomingEdges(SVFStmt::Call))
            {
                for (SVFStmt::SVFStmtSetTy::const_iterator cit = param->getIncomingEdgesBegin(SVFStmt::Call), ecit =
                            param->getIncomingEdgesEnd(SVFStmt::Call); cit != ecit; ++cit)
                {
                    CallPE* callPE = SVFUtil::cast<CallPE>(*cit);
                    if (isInterestedPAGNode(callPE->getRHSVar()))
                        callPEs.insert(callPE);
                }
            }
            addFormalParmVFGNode(param,func,callPEs);
        }
 
        if (func->isVarArg())
        {
            const PAGNode* varParam = pag->getGNode(pag->getVarargNode(func));
            if (isInterestedPAGNode(varParam) == false || hasBlackHoleConstObjAddrAsDef(varParam))
                continue;
 
            CallPESet callPEs;
            if (varParam->hasIncomingEdges(SVFStmt::Call))
            {
                for(SVFStmt::SVFStmtSetTy::const_iterator cit = varParam->getIncomingEdgesBegin(SVFStmt::Call),
                        ecit = varParam->getIncomingEdgesEnd(SVFStmt::Call); cit!=ecit; ++cit)
                {
                    CallPE* callPE = SVFUtil::cast<CallPE>(*cit);
                    if(isInterestedPAGNode(callPE->getRHSVar()))
                        callPEs.insert(callPE);
                }
            }
            addFormalParmVFGNode(varParam,func,callPEs);
        }
    }
 
    // 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 PAGNode* 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 (isInterestedPAGNode(retPE->getLHSVar()))
                    retPEs.insert(retPE);
            }
        }
 
        if(isInterestedPAGNode(uniqueFunRetNode))
            addFormalRetVFGNode(uniqueFunRetNode, func, retPEs);
    }
 
    // initialize llvm phi nodes (phi of top level pointers)
    SVFStmt::SVFStmtSetTy& phis = getPAGEdgeSet(SVFStmt::Phi);
    for (SVFStmt::SVFStmtSetTy::iterator iter = phis.begin(), eiter =
                phis.end(); iter != eiter; ++iter)
    {
        const PhiStmt* edge = SVFUtil::cast<PhiStmt>(*iter);
        if(isInterestedPAGNode(edge->getRes()))
            addIntraPHIVFGNode(edge);
    }
    // initialize select statement
    SVFStmt::SVFStmtSetTy& selects = getPAGEdgeSet(SVFStmt::Select);
    for (SVFStmt::SVFStmtSetTy::iterator iter = selects.begin(), eiter =
                selects.end(); iter != eiter; ++iter)
    {
        const MultiOpndStmt* edge = SVFUtil::cast<MultiOpndStmt>(*iter);
        if(isInterestedPAGNode(edge->getRes()))
            addIntraPHIVFGNode(edge);
    }
    // initialize llvm binary nodes (binary operators)
    SVFStmt::SVFStmtSetTy& binaryops = getPAGEdgeSet(SVFStmt::BinaryOp);
    for (SVFStmt::SVFStmtSetTy::iterator iter = binaryops.begin(), eiter =
                binaryops.end(); iter != eiter; ++iter)
    {
        const BinaryOPStmt* edge = SVFUtil::cast<BinaryOPStmt>(*iter);
        if(isInterestedPAGNode(edge->getRes()))
            addBinaryOPVFGNode(edge);
    }
    // initialize llvm unary nodes (unary operators)
    SVFStmt::SVFStmtSetTy& unaryops = getPAGEdgeSet(SVFStmt::UnaryOp);
    for (SVFStmt::SVFStmtSetTy::iterator iter = unaryops.begin(), eiter =
                unaryops.end(); iter != eiter; ++iter)
    {
        const UnaryOPStmt* edge = SVFUtil::cast<UnaryOPStmt>(*iter);
        if(isInterestedPAGNode(edge->getRes()))
            addUnaryOPVFGNode(edge);
    }
    // initialize llvm unary nodes (unary operators)
    SVFStmt::SVFStmtSetTy& brs = getPAGEdgeSet(SVFStmt::Branch);
    for (SVFStmt::SVFStmtSetTy::iterator iter = brs.begin(), eiter =
                brs.end(); iter != eiter; ++iter)
    {
        const BranchStmt* edge = SVFUtil::cast<BranchStmt>(*iter);
        if(isInterestedPAGNode(edge->getBranchInst()))
            addBranchVFGNode(edge);
    }
    // initialize llvm cmp nodes (comparison)
    SVFStmt::SVFStmtSetTy& cmps = getPAGEdgeSet(SVFStmt::Cmp);
    for (SVFStmt::SVFStmtSetTy::iterator iter = cmps.begin(), eiter =
                cmps.end(); iter != eiter; ++iter)
    {
        const CmpStmt* edge = SVFUtil::cast<CmpStmt>(*iter);
        if(isInterestedPAGNode(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 PAGNode *	csArg,
		const PAGNode *	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 957 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::SVFVarList& csArgList = pag->getCallSiteArgsList(callBlockNode);
        const SVFIR::SVFVarList& funArgList = pag->getFunArgsList(callee);
        SVFIR::SVFVarList::const_iterator csArgIt = csArgList.begin(), csArgEit = csArgList.end();
        SVFIR::SVFVarList::const_iterator funArgIt = funArgList.begin(), funArgEit = funArgList.end();
        for (; funArgIt != funArgEit && csArgIt != csArgEit; funArgIt++, csArgIt++)
        {
            const PAGNode *cs_arg = *csArgIt;
            const PAGNode *fun_arg = *funArgIt;
            if (isInterestedPAGNode(cs_arg) && isInterestedPAGNode(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 PAGNode* varFunArgNode = pag->getGNode(varFunArg);
            if (isInterestedPAGNode(varFunArgNode))
            {
                for (; csArgIt != csArgEit; csArgIt++)
                {
                    const PAGNode *cs_arg = *csArgIt;
                    if (isInterestedPAGNode(cs_arg))
                        connectAParamAndFParam(cs_arg, varFunArgNode, callBlockNode, csId, edges);
                }
            }
        }
    }
 
    // connect actual return and formal return
    if (pag->funHasRet(callee) && pag->callsiteHasRet(retBlockNode))
    {
        const PAGNode* cs_return = pag->getCallSiteRet(retBlockNode);
        const PAGNode* fun_return = pag->getFunRet(callee);
        if (isInterestedPAGNode(cs_return) && isInterestedPAGNode(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 726 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->getPAGSrcNode()->isConstDataOrAggDataButNotNullPtr() == false)
                // for ptr vfg, we skip src node of integer type if it is at a int2ptr copystmt
                if(isInterestedPAGNode(stmtNode->getPAGSrcNode()))
                    addIntraDirectVFEdge(getDef(stmtNode->getPAGSrcNode()), nodeId);
            if (const GepStmt* gepStmt = SVFUtil::dyn_cast<GepStmt>(stmtNode->getPAGEdge()))
            {
                for (const auto &varType: gepStmt->getOffsetVarAndGepTypePairVec())
                {
                    if(varType.first->isConstDataOrAggDataButNotNullPtr() || isInterestedPAGNode(varType.first) == false)
                        continue;
                    addIntraDirectVFEdge(getDef(varType.first), nodeId);
                }
            }
            if(SVFUtil::isa<StoreVFGNode>(stmtNode) && (stmtNode->getPAGDstNode()->isConstDataOrAggDataButNotNullPtr() == false))
            {
                addIntraDirectVFEdge(getDef(stmtNode->getPAGDstNode()), 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 SVFVar* 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))
        {
            for(CallPESet::const_iterator it = formalParm->callPEBegin(), eit = formalParm->callPEEnd();
                    it!=eit; ++it)
            {
                const CallICFGNode* cs = (*it)->getCallSite();
                ActualParmVFGNode* acutalParm = getActualParmVFGNode((*it)->getRHSVar(),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 = getPAGEdgeSet(SVFStmt::ThreadFork);
        for (SVFStmt::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                    forks.end(); iter != eiter; ++iter)
        {
            TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
            ActualParmVFGNode* acutalParm = getActualParmVFGNode(forkedge->getRHSVar(),forkedge->getCallSite());
            FormalParmVFGNode* formalParm = getFormalParmVFGNode(forkedge->getLHSVar());
            addInterEdgeFromAPToFP(acutalParm,formalParm,getCallSiteID(forkedge->getCallSite(), formalParm->getFun()));
        }
        SVFStmt::SVFStmtSetTy& joins = getPAGEdgeSet(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 PAGNode *	funReturn,
		const PAGNode *	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 921 of file VFG.cpp.

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

◆ getActualParmVFGNode()

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

inline

Definition at line 297 of file VFG.h.

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

◆ getActualRetVFGNode()

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

inline

Definition at line 303 of file VFG.h.

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

◆ getBinaryOPVFGNode()

BinaryOPVFGNode * SVF::VFG::getBinaryOPVFGNode ( const PAGNode * pagNode ) const

inline

Definition at line 273 of file VFG.h.

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

◆ getBranchVFGNode()

BranchVFGNode * SVF::VFG::getBranchVFGNode ( const PAGNode * pagNode ) const

inline

Definition at line 285 of file VFG.h.

    {
        PAGNodeToBranchVFGNodeMapTy::const_iterator it = PAGNodeToBranchVFGNodeMap.find(pagNode);
        assert(it != PAGNodeToBranchVFGNodeMap.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 PAGNode * pagNode ) const

inline

Definition at line 291 of file VFG.h.

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

◆ getDef()

NodeID SVF::VFG::getDef ( const PAGNode * pagNode ) const

inlineprotected

Definition at line 482 of file VFG.h.

    {
        PAGNodeToDefMapTy::const_iterator it = PAGNodeToDefMap.find(pagNode);
        assert(it!=PAGNodeToDefMap.end() && "SVFVar does not have a definition??");
        return it->second;
    }

◆ getDefVFGNode()

const VFGNode * SVF::VFG::getDefVFGNode ( const PAGNode * pagNode ) const

inline

Given a pagNode, return its definition site.

Definition at line 189 of file VFG.h.

    {
        return getVFGNode(getDef(pagNode));
    }

◆ getFormalParmVFGNode()

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

inline

Definition at line 309 of file VFG.h.

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

◆ getFormalRetVFGNode()

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

inline

Definition at line 315 of file VFG.h.

    {
        PAGNodeToFormalRetMapTy::const_iterator it = PAGNodeToFormalRetMap.find(fret);
        assert(it!=PAGNodeToFormalRetMap.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 PAGNode * pagNode ) const

inline

Definition at line 267 of file VFG.h.

    {
        PAGNodeToPHIVFGNodeMapTy::const_iterator it = PAGNodeToIntraPHIVFGNodeMap.find(pagNode);
        assert(it != PAGNodeToIntraPHIVFGNodeMap.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 912 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 PAGNode * VFG::getLHSTopLevPtr ( const VFGNode * node ) const

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

Definition at line 1008 of file VFG.cpp.

{
 
    if(const AddrVFGNode* addr = SVFUtil::dyn_cast<AddrVFGNode>(node))
        return addr->getPAGDstNode();
    else if(const CopyVFGNode* copy = SVFUtil::dyn_cast<CopyVFGNode>(node))
        return copy->getPAGDstNode();
    else if(const GepVFGNode* gep = SVFUtil::dyn_cast<GepVFGNode>(node))
        return gep->getPAGDstNode();
    else if(const LoadVFGNode* load = SVFUtil::dyn_cast<LoadVFGNode>(node))
        return load->getPAGDstNode();
    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->getPAGNode();
    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;
    }

◆ getPAGEdgeSet()

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

inlineprotectedvirtual

Get PAGEdge set.

Definition at line 498 of file VFG.h.

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

◆ getStmtVFGNode()

StmtVFGNode * SVF::VFG::getStmtVFGNode ( const PAGEdge * pagEdge ) const

inline

Get an VFGNode.

Definition at line 261 of file VFG.h.

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

◆ getUnaryOPVFGNode()

UnaryOPVFGNode * SVF::VFG::getUnaryOPVFGNode ( const PAGNode * pagNode ) const

inline

Definition at line 279 of file VFG.h.

    {
        PAGNodeToUnaryOPVFGNodeMapTy::const_iterator it = PAGNodeToUnaryOPVFGNodeMap.find(pagNode);
        assert(it != PAGNodeToUnaryOPVFGNodeMap.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 PAGNode *	aparm,
		const CallICFGNode *	cs
	)		const

inline

Definition at line 241 of file VFG.h.

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

◆ hasActualRetVFGNode()

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

inline

Definition at line 245 of file VFG.h.

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

◆ hasBinaryOPVFGNode()

bool SVF::VFG::hasBinaryOPVFGNode ( const PAGNode * pagNode ) const

inline

Definition at line 225 of file VFG.h.

    {
        return PAGNodeToBinaryOPVFGNodeMap.find(pagNode) != PAGNodeToBinaryOPVFGNodeMap.end();
    }

◆ hasBlackHoleConstObjAddrAsDef()

bool SVF::VFG::hasBlackHoleConstObjAddrAsDef ( const PAGNode * pagNode ) const

inline

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

Definition at line 327 of file VFG.h.

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

◆ hasBranchVFGNode()

bool SVF::VFG::hasBranchVFGNode ( const PAGNode * pagNode ) const

inline

Definition at line 233 of file VFG.h.

    {
        return PAGNodeToBranchVFGNodeMap.find(pagNode) != PAGNodeToBranchVFGNodeMap.end();
    }

◆ hasCmpVFGNode()

bool SVF::VFG::hasCmpVFGNode ( const PAGNode * pagNode ) const

inline

Definition at line 237 of file VFG.h.

    {
        return PAGNodeToCmpVFGNodeMap.find(pagNode) != PAGNodeToCmpVFGNodeMap.end();
    }

◆ hasDef()

bool SVF::VFG::hasDef ( const PAGNode * pagNode ) const

inlineprotected

Definition at line 488 of file VFG.h.

    {
        return (PAGNodeToDefMap.find(pagNode) != PAGNodeToDefMap.end());
    }

◆ hasFormalParmVFGNode()

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

inline

Definition at line 249 of file VFG.h.

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

◆ hasFormalRetVFGNode()

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

inline

Definition at line 253 of file VFG.h.

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

◆ hasInterVFGEdge()

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

Whether we has an inter VFG edge

Definition at line 894 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 PAGNode * pagNode ) const

inline

Definition at line 221 of file VFG.h.

    {
        return PAGNodeToIntraPHIVFGNodeMap.find(pagNode) != PAGNodeToIntraPHIVFGNodeMap.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 859 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 PAGEdge * pagEdge ) const

inline

Existence checks for VFGNodes.

Definition at line 217 of file VFG.h.

    {
        return PAGEdgeToStmtVFGNodeMap.find(pagEdge) != PAGEdgeToStmtVFGNodeMap.end();
    }

◆ hasThreadVFGEdge()

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

Whether we has an thread VFG edge

Definition at line 877 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 PAGNode * pagNode ) const

inline

Definition at line 229 of file VFG.h.

    {
        return PAGNodeToUnaryOPVFGNodeMap.find(pagNode) != PAGNodeToUnaryOPVFGNodeMap.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 1045 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;
}

◆ isInterestedPAGNode()

virtual bool SVF::VFG::isInterestedPAGNode ( 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 PAGEdge * 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 PAGNode *	pagNode,
		const VFGNode *	node
	)

inlineprotected

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

Definition at line 469 of file VFG.h.

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

◆ updateCallGraph()

void VFG::updateCallGraph ( PointerAnalysis * pta )

Update VFG based on pointer analysis results.

Definition at line 935 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 929 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.

◆ PAGEdgeToStmtVFGNodeMap

PAGEdgeToStmtVFGNodeMapTy SVF::VFG::PAGEdgeToStmtVFGNodeMap

protected

map a PAGEdge to its StmtVFGNode

Definition at line 99 of file VFG.h.

◆ PAGNodeToActualParmMap

PAGNodeToActualParmMapTy SVF::VFG::PAGNodeToActualParmMap

protected

map a PAGNode to an actual parameter

Definition at line 90 of file VFG.h.

◆ PAGNodeToActualRetMap

PAGNodeToActualRetMapTy SVF::VFG::PAGNodeToActualRetMap

protected

map a PAGNode to an actual return

Definition at line 91 of file VFG.h.

◆ PAGNodeToBinaryOPVFGNodeMap

PAGNodeToBinaryOPVFGNodeMapTy SVF::VFG::PAGNodeToBinaryOPVFGNodeMap

protected

map a PAGNode to its BinaryOPVFGNode

Definition at line 95 of file VFG.h.

◆ PAGNodeToBranchVFGNodeMap

PAGNodeToBranchVFGNodeMapTy SVF::VFG::PAGNodeToBranchVFGNodeMap

protected

map a PAGNode to its BranchVFGNode

Definition at line 97 of file VFG.h.

◆ PAGNodeToCmpVFGNodeMap

PAGNodeToCmpVFGNodeMapTy SVF::VFG::PAGNodeToCmpVFGNodeMap

protected

map a PAGNode to its CmpVFGNode

Definition at line 98 of file VFG.h.

◆ PAGNodeToDefMap

PAGNodeToDefMapTy SVF::VFG::PAGNodeToDefMap

protected

map a pag node to its definition SVG node

Definition at line 89 of file VFG.h.

◆ PAGNodeToFormalParmMap

PAGNodeToFormalParmMapTy SVF::VFG::PAGNodeToFormalParmMap

protected

map a PAGNode to a formal parameter

Definition at line 92 of file VFG.h.

◆ PAGNodeToFormalRetMap

PAGNodeToFormalRetMapTy SVF::VFG::PAGNodeToFormalRetMap

protected

map a PAGNode to a formal return

Definition at line 93 of file VFG.h.

◆ PAGNodeToIntraPHIVFGNodeMap

PAGNodeToPHIVFGNodeMapTy SVF::VFG::PAGNodeToIntraPHIVFGNodeMap

protected

map a PAGNode to its PHIVFGNode

Definition at line 94 of file VFG.h.

◆ PAGNodeToUnaryOPVFGNodeMap

PAGNodeToUnaryOPVFGNodeMapTy SVF::VFG::PAGNodeToUnaryOPVFGNodeMap

protected

map a PAGNode 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.

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

◆ PAGEdgeToStmtVFGNodeMapTy

◆ PAGNodeSet

◆ PAGNodeToActualParmMapTy

◆ PAGNodeToActualRetMapTy

◆ PAGNodeToBinaryOPVFGNodeMapTy

◆ PAGNodeToBranchVFGNodeMapTy

◆ PAGNodeToCmpVFGNodeMapTy

◆ PAGNodeToDefMapTy

◆ PAGNodeToFormalParmMapTy

◆ PAGNodeToFormalRetMapTy

◆ PAGNodeToPHIVFGNodeMapTy

◆ PAGNodeToUnaryOPVFGNodeMapTy

◆ RetPESet

◆ SVFGEdgeSetTy

◆ SVFStmtSet

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