SVF::VFG Class Reference

#include <VFG.h>

Inheritance diagram for SVF::VFG:

Public Types
enum	VFGK { FULLSVFG , PTRONLYSVFG , FULLSVFG_OPT , PTRONLYSVFG_OPT }
	VFG kind. More...
typedef OrderedMap< NodeID, VFGNode * >	VFGNodeIDToNodeMapTy
typedef Set< VFGNode * >	VFGNodeSet
typedef Map< const 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 SVFFunction *, 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 (PTACallGraph *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.
PTACallGraph *	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 SVFFunction *callee, VFGEdgeSetTy &edges)
	Connect VFG nodes between caller and callee for indirect call site.
CallSiteID	getCallSiteID (const CallICFGNode *cs, const SVFFunction *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.
const PAGNode *	getLHSTopLevPtr (const VFGNode *node) 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 SVFFunction *	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 SVFFunction *fun)
bool	hasVFGNodes (const SVFFunction *fun) const
bool	VFGNodes (const SVFFunction *fun) const
VFGNodeSet::const_iterator	getVFGNodeBegin (const SVFFunction *fun) const
VFGNodeSet::const_iterator	getVFGNodeEnd (const SVFFunction *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 SVFFunction *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 SVFFunction *fun, CallPESet &callPEs)
	Add a formal parameter VFG node.
void	addFormalRetVFGNode (const PAGNode *uniqueFunRet, const SVFFunction *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
PTACallGraph *	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 SVFFunction*, 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	(	PTACallGraph *	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 441 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 530 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 571 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 492 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 607 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 630 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 701 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 593 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 499 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 SVFFunction *  fun, CallPESet &  callPEs  )

inlineprotected

Add a formal parameter VFG node.

Definition at line 538 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 SVFFunction *  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 552 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 506 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 362 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 373 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 367 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 378 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 675 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 579 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 513 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 485 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 721 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 477 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 521 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 621 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 339 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 SVFFunction *  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 464 of file VFG.h.

    {
        addGNode(vfgNode->getId(), vfgNode);
        vfgNode->setICFGNode(icfgNode);
        icfgNode->addVFGNode(vfgNode);
 
        if(const SVFFunction* 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 463 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 SVFFunction* 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 SVFFunction* 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 351 of file VFG.h.

    {
        const SVFFunction *srcfun = srcNode->getFun();
        const SVFFunction *dstfun = dstNode->getFun();
        if(srcfun != nullptr && dstfun != nullptr)
        {
            assert((srcfun == dstfun) && "src and dst nodes of an intra 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 386 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 SVFFunction *  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 973 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 742 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 395 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 454 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 937 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 235 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 241 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 211 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 223 of file VFG.h.

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

getCallGraph()

PTACallGraph * 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 SVFFunction *  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 229 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 420 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 247 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 253 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 205 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 928 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 1024 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 436 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 199 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 217 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 SVFFunction *  fun ) const

inline

Definition at line 298 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 SVFFunction *  fun ) const

inline

Definition at line 304 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 SVFFunction *  fun )

inline

Return all the VFGNodes of a function

Definition at line 286 of file VFG.h.

    {
        return funToVFGNodesMap[fun];
    }

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 265 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;
    }

hasDef()

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

inlineprotected

Definition at line 426 of file VFG.h.

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

hasInterVFGEdge()

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

Whether we has an inter VFG edge

Definition at line 910 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;
}

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 875 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;
}

hasThreadVFGEdge()

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

Whether we has an thread VFG edge

Definition at line 893 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;
}

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 SVFFunction *  fun ) const

inline

Definition at line 290 of file VFG.h.

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

isFunEntryVFGNode()

const SVFFunction * 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 1061 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 444 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 458 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 319 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 326 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 407 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 951 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 SVFFunction*  func = *func_iter;
            connectCallerAndCallee(newcs, func, vfEdgesAtIndCallSite);
        }
    }
}

VFGNodes()

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

inline

Definition at line 294 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 945 of file VFG.cpp.

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

Member Data Documentation

callgraph

PTACallGraph* 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