SVF::SVFG Class Reference

#include <SVFG.h>

Inheritance diagram for SVF::SVFG:

Public Types
typedef VFGNodeIDToNodeMapTy	SVFGNodeIDToNodeMapTy
typedef Map< const ValVar *, NodeID >	ValVarToDefMapTy
typedef Map< const MRVer *, NodeID >	MSSAVarToDefMapTy
typedef NodeBS	ActualINSVFGNodeSet
typedef NodeBS	ActualOUTSVFGNodeSet
typedef NodeBS	FormalINSVFGNodeSet
typedef NodeBS	FormalOUTSVFGNodeSet
typedef Map< const CallICFGNode *, ActualINSVFGNodeSet >	CallSiteToActualINsMapTy
typedef Map< const CallICFGNode *, ActualOUTSVFGNodeSet >	CallSiteToActualOUTsMapTy
typedef Map< const FunObjVar *, FormalINSVFGNodeSet >	FunctionToFormalINsMapTy
typedef Map< const FunObjVar *, FormalOUTSVFGNodeSet >	FunctionToFormalOUTsMapTy
typedef MemSSA::MUSet	MUSet
typedef MemSSA::CHISet	CHISet
typedef MemSSA::PHISet	PHISet
typedef MemSSA::MU	MU
typedef MemSSA::CHI	CHI
typedef MemSSA::LOADMU	LOADMU
typedef MemSSA::STORECHI	STORECHI
typedef MemSSA::RETMU	RETMU
typedef MemSSA::ENTRYCHI	ENTRYCHI
typedef MemSSA::CALLCHI	CALLCHI
typedef MemSSA::CALLMU	CALLMU
Public Types inherited from SVF::VFG
enum	VFGK { FULLSVFG , PTRONLYSVFG , FULLSVFG_OPT , PTRONLYSVFG_OPT }
	VFG kind. More...
typedef OrderedMap< NodeID, VFGNode * >	VFGNodeIDToNodeMapTy
typedef Set< VFGNode * >	VFGNodeSet
typedef Map< const ValVar *, NodeID >	ValVarToDefMapTy
typedef Map< std::pair< NodeID, const CallICFGNode * >, ActualParmVFGNode * >	SVFVarToActualParmMapTy
typedef Map< const SVFVar *, ActualRetVFGNode * >	SVFVarToActualRetMapTy
typedef Map< const SVFVar *, FormalParmVFGNode * >	SVFVarToFormalParmMapTy
typedef Map< const SVFVar *, FormalRetVFGNode * >	SVFVarToFormalRetMapTy
typedef Map< const SVFStmt *, StmtVFGNode * >	SVFStmtToStmtVFGNodeMapTy
typedef Map< const SVFVar *, IntraPHIVFGNode * >	SVFVarToPHIVFGNodeMapTy
typedef Map< const SVFVar *, BinaryOPVFGNode * >	SVFVarToBinaryOPVFGNodeMapTy
typedef Map< const SVFVar *, UnaryOPVFGNode * >	SVFVarToUnaryOPVFGNodeMapTy
typedef Map< const SVFVar *, BranchVFGNode * >	SVFVarToBranchVFGNodeMapTy
typedef Map< const SVFVar *, CmpVFGNode * >	SVFVarToCmpVFGNodeMapTy
typedef Map< const FunObjVar *, VFGNodeSet >	FunToVFGNodesMapTy
typedef FormalParmVFGNode::CallPESet	CallPESet
typedef FormalRetVFGNode::RetPESet	RetPESet
typedef VFGEdge::VFGEdgeSetTy	VFGEdgeSetTy
typedef VFGEdge::SVFGEdgeSetTy	SVFGEdgeSetTy
typedef VFGEdge::VFGEdgeSetTy::iterator	VFGNodeIter
typedef VFGNodeIDToNodeMapTy::iterator	iterator
typedef VFGNodeIDToNodeMapTy::const_iterator	const_iterator
typedef SVFIR::SVFStmtSet	SVFStmtSet
typedef Set< const VFGNode * >	GlobalVFGNodeSet
typedef Set< const SVFVar * >	SVFVarSet
Public Types inherited from SVF::GenericGraph< VFGNode, VFGEdge >
typedef VFGNode	NodeType
typedef VFGEdge	EdgeType
typedef OrderedMap< NodeID, NodeType * >	IDToNodeMapTy
	NodeID to GenericNode map.
typedef IDToNodeMapTy::iterator	iterator
	Node Iterators.
typedef IDToNodeMapTy::const_iterator	const_iterator

Public Member Functions
virtual	~SVFG ()
	Destructor.
SVFGStat *	getStat () const
	Return statistics.
void	clearMSSA ()
	Clear MSSA.
MemSSA *	getMSSA () const
	Get SVFG memory SSA.
PointerAnalysis *	getPTA () const
	Get Pointer Analysis.
SVFGNode *	getSVFGNode (NodeID id) const
	Get a SVFG node.
bool	hasSVFGNode (NodeID id) const
	Whether has the SVFGNode.
void	getInterVFEdgesForIndirectCallSite (const CallICFGNode *cs, const FunObjVar *callee, SVFGEdgeSetTy &edges)
	Get all inter value flow edges of a indirect call site.
void	dump (const std::string &file, bool simple=false)
	Dump graph into dot file.
virtual void	connectCallerAndCallee (const CallICFGNode *cs, const FunObjVar *callee, SVFGEdgeSetTy &edges)
	Connect SVFG nodes between caller and callee for indirect call site.
const SVFGNode *	getDefSVFGNode (const ValVar *valVar) const
	Given a valVar, return its definition site.
bool	hasDefSVFGNode (const ValVar *valVar) const
	Given a valVar, return whether it has definition site.
const SVFGNode *	getDefSiteOfValVar (const ValVar *var) const
const Set< const SVFGNode * >	getDefSiteOfObjVar (const ObjVar *obj, const SVFGNode *node) const
const Set< const SVFGNode * >	getUseSitesOfValVar (const ValVar *var) const
const Set< const SVFGNode * >	getUseSitesOfObjVar (const ObjVar *obj, const SVFGNode *node) const
void	performStat ()
	Perform statistics.
bool	hasActualINSVFGNodes (const CallICFGNode *cs) const
	Has a SVFGNode.
bool	hasActualOUTSVFGNodes (const CallICFGNode *cs) const
bool	hasFormalINSVFGNodes (const FunObjVar *fun) const
bool	hasFormalOUTSVFGNodes (const FunObjVar *fun) const
ActualINSVFGNodeSet &	getActualINSVFGNodes (const CallICFGNode *cs)
	Get SVFGNode set.
ActualOUTSVFGNodeSet &	getActualOUTSVFGNodes (const CallICFGNode *cs)
FormalINSVFGNodeSet &	getFormalINSVFGNodes (const FunObjVar *fun)
FormalOUTSVFGNodeSet &	getFormalOUTSVFGNodes (const FunObjVar *fun)
const FunObjVar *	isFunEntrySVFGNode (const SVFGNode *node) const
	Whether a node is function entry SVFGNode.
const CallICFGNode *	isCallSiteRetSVFGNode (const SVFGNode *node) const
	Whether a node is callsite return SVFGNode.
void	removeSVFGEdge (SVFGEdge *edge)
	Remove a SVFG edge.
void	removeSVFGNode (SVFGNode *node)
	Remove a SVFGNode.
bool	addSVFGEdge (SVFGEdge *edge)
	Add SVFG edge.
u32_t	getSVFGNodeNum () const
	Return total SVFG node number.
const DummyVersionPropSVFGNode *	addDummyVersionPropSVFGNode (const NodeID object, const NodeID version)
virtual void	writeToFile (const std::string &filename)
virtual void	readFile (const std::string &filename)
virtual MRVer *	getMRVERFromString (const std::string &input)
Public Member Functions inherited from SVF::VFG
	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.
CallSiteID	getCallSiteID (const CallICFGNode *cs, const FunObjVar *func) const
	Get callsite given a callsiteID.
const CallICFGNode *	getCallSite (CallSiteID id) const
const VFGNode *	getDefVFGNode (const ValVar *valVar) const
	Given a valVar, return its definition site.
bool	hasLHSTopLevPtr (const VFGNode *node) const
const SVFVar *	getLHSTopLevPtr (const VFGNode *node) const
bool	hasStmtVFGNode (const SVFStmt *svfStmt) const
	Existence checks for VFGNodes.
bool	hasIntraPHIVFGNode (const SVFVar *svfVar) const
bool	hasBinaryOPVFGNode (const SVFVar *svfVar) const
bool	hasUnaryOPVFGNode (const SVFVar *svfVar) const
bool	hasBranchVFGNode (const SVFVar *svfVar) const
bool	hasCmpVFGNode (const SVFVar *svfVar) const
bool	hasActualParmVFGNode (const SVFVar *aparm, const CallICFGNode *cs) const
bool	hasActualRetVFGNode (const SVFVar *aret) const
bool	hasFormalParmVFGNode (const SVFVar *fparm) const
bool	hasFormalRetVFGNode (const SVFVar *fret) const
StmtVFGNode *	getStmtVFGNode (const SVFStmt *svfStmt) const
	Get an VFGNode.
IntraPHIVFGNode *	getIntraPHIVFGNode (const SVFVar *svfVar) const
BinaryOPVFGNode *	getBinaryOPVFGNode (const SVFVar *svfVar) const
UnaryOPVFGNode *	getUnaryOPVFGNode (const SVFVar *svfVar) const
BranchVFGNode *	getBranchVFGNode (const SVFVar *svfVar) const
CmpVFGNode *	getCmpVFGNode (const SVFVar *svfVar) const
ActualParmVFGNode *	getActualParmVFGNode (const SVFVar *aparm, const CallICFGNode *cs) const
ActualRetVFGNode *	getActualRetVFGNode (const SVFVar *aret) const
FormalParmVFGNode *	getFormalParmVFGNode (const SVFVar *fparm) const
FormalRetVFGNode *	getFormalRetVFGNode (const SVFVar *fret) const
const FunObjVar *	isFunEntryVFGNode (const VFGNode *node) const
	Whether a node is function entry VFGNode.
bool	hasBlackHoleConstObjAddrAsDef (const ValVar *valVar) const
	Whether a SVFVar has a blackhole or const object as its definition.
VFGEdge *	addIntraDirectVFEdge (NodeID srcId, NodeID dstId)
VFGEdge *	addCallEdge (NodeID srcId, NodeID dstId, CallSiteID csId)
VFGEdge *	addRetEdge (NodeID srcId, NodeID dstId, CallSiteID csId)
void	removeVFGEdge (VFGEdge *edge)
	Remove a SVFG edge.
void	removeVFGNode (VFGNode *node)
	Remove a VFGNode.
VFGEdge *	hasIntraVFGEdge (VFGNode *src, VFGNode *dst, VFGEdge::VFGEdgeK kind)
	Whether we has a SVFG edge.
VFGEdge *	hasInterVFGEdge (VFGNode *src, VFGNode *dst, VFGEdge::VFGEdgeK kind, CallSiteID csId)
VFGEdge *	hasThreadVFGEdge (VFGNode *src, VFGNode *dst, VFGEdge::VFGEdgeK kind)
bool	addVFGEdge (VFGEdge *edge)
	Add VFG edge.
VFGNodeSet &	getVFGNodes (const FunObjVar *fun)
bool	hasVFGNodes (const FunObjVar *fun) const
bool	VFGNodes (const FunObjVar *fun) const
VFGNodeSet::const_iterator	getVFGNodeBegin (const FunObjVar *fun) const
VFGNodeSet::const_iterator	getVFGNodeEnd (const FunObjVar *fun) const
Public Member Functions inherited from SVF::GenericGraph< VFGNode, VFGEdge >
	GenericGraph ()
	Constructor.
virtual	~GenericGraph ()
	Destructor.
void	destroy ()
	Release memory.
iterator	begin ()
	Iterators.
iterator	end ()
const_iterator	begin () const
const_iterator	end () const
void	addGNode (NodeID id, NodeType *node)
	Add a Node.
NodeType *	getGNode (NodeID id) const
	Get a node.
bool	hasGNode (NodeID id) const
	Has a node.
void	removeGNode (NodeType *node)
	Delete a node.
u32_t	getTotalNodeNum () const
	Get total number of node/edge.
u32_t	getTotalEdgeNum () const
void	incNodeNum ()
	Increase number of node/edge.
void	incEdgeNum ()

Protected Member Functions
void	destroy ()
	Clean up memory.
	SVFG (std::unique_ptr< MemSSA > mssa, VFGK k)
	Constructor.
virtual void	buildSVFG ()
	Start building SVFG.
SVFGEdge *	addIntraIndirectVFEdge (NodeID srcId, NodeID dstId, const NodeBS &cpts)
	Add indirect def-use edges of a memory region between two statements,.
SVFGEdge *	addCallIndirectVFEdge (NodeID srcId, NodeID dstId, const NodeBS &cpts, CallSiteID csId)
SVFGEdge *	addRetIndirectVFEdge (NodeID srcId, NodeID dstId, const NodeBS &cpts, CallSiteID csId)
SVFGEdge *	addThreadMHPIndirectVFEdge (NodeID srcId, NodeID dstId, const NodeBS &cpts)
SVFGEdge *	addInterIndirectVFCallEdge (const ActualINSVFGNode *src, const FormalINSVFGNode *dst, CallSiteID csId)
	Add inter VF edge from callsite mu to function entry chi.
SVFGEdge *	addInterIndirectVFRetEdge (const FormalOUTSVFGNode *src, const ActualOUTSVFGNode *dst, CallSiteID csId)
	Add inter VF edge from function exit mu to callsite chi.
virtual void	connectAInAndFIn (const ActualINSVFGNode *actualIn, const FormalINSVFGNode *formalIn, CallSiteID csId, SVFGEdgeSetTy &edges)
	Connect SVFG nodes between caller and callee for indirect call site.
virtual void	connectFOutAndAOut (const FormalOUTSVFGNode *formalOut, const ActualOUTSVFGNode *actualOut, CallSiteID csId, SVFGEdgeSetTy &edges)
	Connect formal-out and actual-out.
virtual void	getInterVFEdgeAtIndCSFromAPToFP (const ValVar *cs_arg, const ValVar *fun_arg, const CallICFGNode *, CallSiteID csId, SVFGEdgeSetTy &edges)
	Get inter value flow edges between indirect call site and callee.
virtual void	getInterVFEdgeAtIndCSFromFRToAR (const ValVar *fun_ret, const ValVar *cs_ret, CallSiteID csId, SVFGEdgeSetTy &edges)
virtual void	getInterVFEdgeAtIndCSFromAInToFIn (ActualINSVFGNode *actualIn, const FunObjVar *callee, SVFGEdgeSetTy &edges)
virtual void	getInterVFEdgeAtIndCSFromFOutToAOut (ActualOUTSVFGNode *actualOut, const FunObjVar *callee, SVFGEdgeSetTy &edges)
void	setDef (const ValVar *valVar, const SVFGNode *node)
	Given a ValVar, set/get its def SVFG node (definition of top level pointers).
NodeID	getDef (const ValVar *valVar) const
bool	hasDef (const ValVar *valVar) const
void	setDef (const MRVer *mvar, const SVFGNode *node)
	Given a MSSADef, set/get its def SVFG node (definition of address-taken variables).
NodeID	getDef (const MRVer *mvar) const
void	addSVFGNodesForAddrTakenVars ()
	Create SVFG nodes for address-taken variables.
void	connectIndirectSVFGEdges ()
	Connect direct SVFG edges between two SVFG nodes (value-flow of top address-taken variables).
void	connectFromGlobalToProgEntry ()
	Connect indirect SVFG edges from global initializers (store) to main function entry.
virtual void	addSVFGNode (SVFGNode *node, ICFGNode *icfgNode)
	Add SVFG node.
void	addFormalINSVFGNode (const FunEntryICFGNode *funEntry, const MRVer *resVer, const NodeID nodeId)
	Add memory Function entry chi SVFG node.
void	addFormalOUTSVFGNode (const FunExitICFGNode *funExit, const MRVer *ver, const NodeID nodeId)
	Add memory Function return mu SVFG node.
void	addActualINSVFGNode (const CallICFGNode *callsite, const MRVer *ver, const NodeID nodeId)
	Add memory callsite mu SVFG node.
void	addActualOUTSVFGNode (const CallICFGNode *callsite, const MRVer *resVer, const NodeID nodeId)
	Add memory callsite chi SVFG node.
void	addIntraMSSAPHISVFGNode (ICFGNode *BlockICFGNode, const Map< u32_t, const MRVer * >::const_iterator opVerBegin, const Map< u32_t, const MRVer * >::const_iterator opVerEnd, const MRVer *resVer, const NodeID nodeId)
	Add memory SSA PHI SVFG node.
bool	hasFuncEntryChi (const FunObjVar *func) const
	Has function for EntryCHI/RetMU/CallCHI/CallMU.
bool	hasFuncRetMu (const FunObjVar *func) const
bool	hasCallSiteChi (const CallICFGNode *cs) const
bool	hasCallSiteMu (const CallICFGNode *cs) const
Protected Member Functions inherited from SVF::VFG
void	destroy ()
	Clean up memory.
void	checkIntraEdgeParents (const VFGNode *srcNode, const VFGNode *dstNode)
	sanitize Intra edges, verify that both nodes belong to the same function.
VFGEdge *	addInterEdgeFromAPToFP (ActualParmVFGNode *src, FormalParmVFGNode *dst, CallSiteID csId)
	Add inter VF edge from actual to formal parameters.
VFGEdge *	addInterEdgeFromFRToAR (FormalRetVFGNode *src, ActualRetVFGNode *dst, CallSiteID csId)
	Add inter VF edge from callee return to callsite receive parameter.
VFGEdge *	addInterEdgeFromAPToFP (NodeID src, NodeID dst, CallSiteID csId)
	Add inter VF edge from actual to formal parameters.
VFGEdge *	addInterEdgeFromFRToAR (NodeID src, NodeID dst, CallSiteID csId)
	Add inter VF edge from callee return to callsite receive parameter.
virtual void	connectAParamAndFParam (const ValVar *csArg, const ValVar *funArg, const CallICFGNode *cbn, CallSiteID csId, VFGEdgeSetTy &edges)
	Connect VFG nodes between caller and callee for indirect call site.
virtual void	connectFRetAndARet (const ValVar *funReturn, const ValVar *csReturn, CallSiteID csId, VFGEdgeSetTy &edges)
	Connect formal-ret and actual ret.
void	setDef (const ValVar *valVar, const VFGNode *node)
	Given a ValVar, set/get its def VFG node (definition of top level pointers).
NodeID	getDef (const ValVar *valVar) const
bool	hasDef (const ValVar *valVar) const
void	addVFGNodes ()
	Create VFG nodes.
virtual SVFStmt::SVFStmtSetTy &	getSVFStmtSet (SVFStmt::PEDGEK kind)
	Get SVFStmt set.
virtual bool	isInterestedSVFVar (const SVFVar *node) const
void	connectDirectVFGEdges ()
	Create edges between VFG nodes within a function.
void	addVFGInterEdges (const CallICFGNode *cs, const FunObjVar *callee)
	Create edges between VFG nodes across functions.
bool	isPhiCopyEdge (const SVFStmt *copy) const
virtual void	addVFGNode (VFGNode *vfgNode, ICFGNode *icfgNode)
	Add a VFG node.
void	addStmtVFGNode (StmtVFGNode *node, const SVFStmt *svfStmt)
	Add a VFG node for program statement.
void	addNullPtrVFGNode (const ValVar *svfVar)
void	addAddrVFGNode (const AddrStmt *addr)
	Add an Address VFG node.
void	addCopyVFGNode (const CopyStmt *copy)
	Add a Copy VFG node.
void	addGepVFGNode (const GepStmt *gep)
	Add a Gep VFG node.
void	addLoadVFGNode (const LoadStmt *load)
	Add a Load VFG node.
void	addStoreVFGNode (const StoreStmt *store)
void	addActualParmVFGNode (const ValVar *aparm, const CallICFGNode *cs)
void	addFormalParmVFGNode (const ValVar *fparm, const FunObjVar *fun, const CallPE *callPE)
	Add a formal parameter VFG node.
void	addFormalRetVFGNode (const ValVar *uniqueFunRet, const FunObjVar *fun, RetPESet &retPEs)
void	addActualRetVFGNode (const ValVar *ret, const CallICFGNode *cs)
	Add a callsite Receive VFG node.
void	addIntraPHIVFGNode (const MultiOpndStmt *edge)
	Add an llvm PHI VFG node.
void	addCmpVFGNode (const CmpStmt *edge)
	Add a Compare VFG node.
void	addBinaryOPVFGNode (const BinaryOPStmt *edge)
	Add a BinaryOperator VFG node.
void	addUnaryOPVFGNode (const UnaryOPStmt *edge)
	Add a UnaryOperator VFG node.
void	addBranchVFGNode (const BranchStmt *edge)
	Add a BranchVFGNode.

Protected Attributes
MSSAVarToDefMapTy	MSSAVarToDefMap
	map a memory SSA operator to its definition SVFG node
CallSiteToActualINsMapTy	callSiteToActualINMap
CallSiteToActualOUTsMapTy	callSiteToActualOUTMap
FunctionToFormalINsMapTy	funToFormalINMap
FunctionToFormalOUTsMapTy	funToFormalOUTMap
SVFGStat *	stat
std::unique_ptr< MemSSA >	mssa
PointerAnalysis *	pta
Protected Attributes inherited from SVF::VFG
NodeID	totalVFGNode
ValVarToDefMapTy	ValVarToDefMap
	map a pag node to its definition SVG node
SVFVarToActualParmMapTy	SVFVarToActualParmMap
	map a SVFVar to an actual parameter
SVFVarToActualRetMapTy	SVFVarToActualRetMap
	map a SVFVar to an actual return
SVFVarToFormalParmMapTy	SVFVarToFormalParmMap
	map a SVFVar to a formal parameter
SVFVarToFormalRetMapTy	SVFVarToFormalRetMap
	map a SVFVar to a formal return
SVFVarToPHIVFGNodeMapTy	SVFVarToIntraPHIVFGNodeMap
	map a SVFVar to its PHIVFGNode
SVFVarToBinaryOPVFGNodeMapTy	SVFVarToBinaryOPVFGNodeMap
	map a SVFVar to its BinaryOPVFGNode
SVFVarToUnaryOPVFGNodeMapTy	SVFVarToUnaryOPVFGNodeMap
	map a SVFVar to its UnaryOPVFGNode
SVFVarToBranchVFGNodeMapTy	SVFVarToBranchVFGNodeMap
	map a SVFVar to its BranchVFGNode
SVFVarToCmpVFGNodeMapTy	SVFVarToCmpVFGNodeMap
	map a SVFVar to its CmpVFGNode
SVFStmtToStmtVFGNodeMapTy	SVFStmtToStmtVFGNodeMap
	map a SVFStmt to its StmtVFGNode
FunToVFGNodesMapTy	funToVFGNodesMap
	map a function to its VFGNodes;
GlobalVFGNodeSet	globalVFGNodes
	set of global store VFG nodes
CallGraph *	callgraph
SVFIR *	pag
VFGK	kind
Protected Attributes inherited from SVF::GenericGraph< VFGNode, VFGEdge >
IDToNodeMapTy	IDToNodeMap
	node map

Friends
class	SVFGBuilder
class	SaberSVFGBuilder
class	CFLSVFGBuilder
class	TaintSVFGBuilder
class	DDASVFGBuilder
class	MTASVFGBuilder
class	RcSvfgBuilder

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

Detailed Description

Sparse value flow graph Each node stands for a definition, each edge stands for value flow relations

Definition at line 65 of file SVFG.h.

Member Typedef Documentation

ActualINSVFGNodeSet

typedef NodeBS SVF::SVFG::ActualINSVFGNodeSet

Definition at line 79 of file SVFG.h.

ActualOUTSVFGNodeSet

typedef NodeBS SVF::SVFG::ActualOUTSVFGNodeSet

Definition at line 80 of file SVFG.h.

CALLCHI

typedef MemSSA::CALLCHI SVF::SVFG::CALLCHI

Definition at line 96 of file SVFG.h.

CALLMU

typedef MemSSA::CALLMU SVF::SVFG::CALLMU

Definition at line 97 of file SVFG.h.

CallSiteToActualINsMapTy

typedef Map<const CallICFGNode*, ActualINSVFGNodeSet> SVF::SVFG::CallSiteToActualINsMapTy

Definition at line 83 of file SVFG.h.

CallSiteToActualOUTsMapTy

typedef Map<const CallICFGNode*, ActualOUTSVFGNodeSet> SVF::SVFG::CallSiteToActualOUTsMapTy

Definition at line 84 of file SVFG.h.

CHI

typedef MemSSA::CHI SVF::SVFG::CHI

Definition at line 91 of file SVFG.h.

CHISet

typedef MemSSA::CHISet SVF::SVFG::CHISet

Definition at line 88 of file SVFG.h.

ENTRYCHI

typedef MemSSA::ENTRYCHI SVF::SVFG::ENTRYCHI

Definition at line 95 of file SVFG.h.

FormalINSVFGNodeSet

typedef NodeBS SVF::SVFG::FormalINSVFGNodeSet

Definition at line 81 of file SVFG.h.

FormalOUTSVFGNodeSet

typedef NodeBS SVF::SVFG::FormalOUTSVFGNodeSet

Definition at line 82 of file SVFG.h.

FunctionToFormalINsMapTy

typedef Map<const FunObjVar*, FormalINSVFGNodeSet> SVF::SVFG::FunctionToFormalINsMapTy

Definition at line 85 of file SVFG.h.

FunctionToFormalOUTsMapTy

typedef Map<const FunObjVar*, FormalOUTSVFGNodeSet> SVF::SVFG::FunctionToFormalOUTsMapTy

Definition at line 86 of file SVFG.h.

LOADMU

typedef MemSSA::LOADMU SVF::SVFG::LOADMU

Definition at line 92 of file SVFG.h.

MSSAVarToDefMapTy

typedef Map<const MRVer*, NodeID> SVF::SVFG::MSSAVarToDefMapTy

Definition at line 78 of file SVFG.h.

MU

typedef MemSSA::MU SVF::SVFG::MU

Definition at line 90 of file SVFG.h.

MUSet

typedef MemSSA::MUSet SVF::SVFG::MUSet

Definition at line 87 of file SVFG.h.

PHISet

typedef MemSSA::PHISet SVF::SVFG::PHISet

Definition at line 89 of file SVFG.h.

RETMU

typedef MemSSA::RETMU SVF::SVFG::RETMU

Definition at line 94 of file SVFG.h.

STORECHI

typedef MemSSA::STORECHI SVF::SVFG::STORECHI

Definition at line 93 of file SVFG.h.

SVFGNodeIDToNodeMapTy

typedef VFGNodeIDToNodeMapTy SVF::SVFG::SVFGNodeIDToNodeMapTy

Definition at line 76 of file SVFG.h.

ValVarToDefMapTy

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

Definition at line 77 of file SVFG.h.

Constructor & Destructor Documentation

SVFG()

SVFG::SVFG ( std::unique_ptr< MemSSA > mssa, VFGK k )

protected

Constructor.

Constructor

Definition at line 204 of file SVFG.cpp.

                                            : VFG(mssa->getPTA()->getCallGraph(),k),mssa(std::move(mssa)), pta(this->mssa->getPTA())
{
    stat = new SVFGStat(this);
}

~SVFG()

virtual SVF::SVFG::~SVFG ( )

inlinevirtual

Destructor.

Definition at line 120 of file SVFG.h.

    {
        destroy();
    }

Member Function Documentation

addActualINSVFGNode()

void SVF::SVFG::addActualINSVFGNode ( const CallICFGNode * callsite, const MRVer * ver, const NodeID nodeId )

inlineprotected

Add memory callsite mu SVFG node.

Definition at line 436 of file SVFG.h.

    {
        ActualINSVFGNode* sNode = new ActualINSVFGNode(nodeId, callsite, ver);
        addSVFGNode(sNode, const_cast<CallICFGNode*>(callsite));
        callSiteToActualINMap[callsite].set(sNode->getId());
    }

addActualOUTSVFGNode()

void SVF::SVFG::addActualOUTSVFGNode ( const CallICFGNode * callsite, const MRVer * resVer, const NodeID nodeId )

inlineprotected

Add memory callsite chi SVFG node.

Definition at line 444 of file SVFG.h.

    {
        ActualOUTSVFGNode* sNode = new ActualOUTSVFGNode(nodeId, callsite, resVer);
        addSVFGNode(sNode,const_cast<RetICFGNode*>(callsite->getRetICFGNode()));
        setDef(resVer,sNode);
        callSiteToActualOUTMap[callsite].set(sNode->getId());
    }

addCallIndirectVFEdge()

SVFGEdge * SVFG::addCallIndirectVFEdge ( NodeID srcId, NodeID dstId, const NodeBS & cpts, CallSiteID csId )

protected

Definition at line 505 of file SVFG.cpp.

{
    SVFGNode* srcNode = getSVFGNode(srcId);
    SVFGNode* dstNode = getSVFGNode(dstId);
    if(SVFGEdge* edge = hasInterVFGEdge(srcNode,dstNode,SVFGEdge::CallIndVF,csId))
    {
        assert(SVFUtil::isa<CallIndSVFGEdge>(edge) && "this should be a indirect value flow edge!");
        return (SVFUtil::cast<CallIndSVFGEdge>(edge)->addPointsTo(cpts) ? edge : nullptr);
    }
    else
    {
        CallIndSVFGEdge* callEdge = new CallIndSVFGEdge(srcNode,dstNode,csId);
        callEdge->addPointsTo(cpts);
        return (addSVFGEdge(callEdge) ? callEdge : nullptr);
    }
}

addDummyVersionPropSVFGNode()

const DummyVersionPropSVFGNode * SVF::SVFG::addDummyVersionPropSVFGNode ( const NodeID object, const NodeID version )

inline

Used only for Versioned FSPTA to encode propagation of versions in the worklist (allowing for breadth-first propagation). Returns the created node.

Definition at line 279 of file SVFG.h.

    {
        DummyVersionPropSVFGNode *dvpNode = new DummyVersionPropSVFGNode(totalVFGNode++, object, version);
        // Not going through add[S]VFGNode because we have no ICFG edge.
        addGNode(dvpNode->getId(), dvpNode);
        return dvpNode;
    }

addFormalINSVFGNode()

void SVF::SVFG::addFormalINSVFGNode ( const FunEntryICFGNode * funEntry, const MRVer * resVer, const NodeID nodeId )

inlineprotected

Add memory Function entry chi SVFG node.

Definition at line 419 of file SVFG.h.

    {
        FormalINSVFGNode* sNode = new FormalINSVFGNode(nodeId, resVer, funEntry);
        addSVFGNode(sNode, pag->getICFG()->getFunEntryICFGNode(funEntry->getFun()));
        setDef(resVer,sNode);
        funToFormalINMap[funEntry->getFun()].set(sNode->getId());
    }

addFormalOUTSVFGNode()

void SVF::SVFG::addFormalOUTSVFGNode ( const FunExitICFGNode * funExit, const MRVer * ver, const NodeID nodeId )

inlineprotected

Add memory Function return mu SVFG node.

Definition at line 428 of file SVFG.h.

    {
        FormalOUTSVFGNode* sNode = new FormalOUTSVFGNode(nodeId, ver, funExit);
        addSVFGNode(sNode,pag->getICFG()->getFunExitICFGNode(funExit->getFun()));
        funToFormalOUTMap[funExit->getFun()].set(sNode->getId());
    }

addInterIndirectVFCallEdge()

SVFGEdge * SVFG::addInterIndirectVFCallEdge ( const ActualINSVFGNode * src, const FormalINSVFGNode * dst, CallSiteID csId )

protected

Add inter VF edge from callsite mu to function entry chi.

Definition at line 545 of file SVFG.cpp.

{
    NodeBS cpts1 = src->getPointsTo();
    NodeBS cpts2 = dst->getPointsTo();
    if(cpts1.intersects(cpts2))
    {
        cpts1 &= cpts2;
        return addCallIndirectVFEdge(src->getId(),dst->getId(),cpts1,csId);
    }
    return nullptr;
}

addInterIndirectVFRetEdge()

SVFGEdge * SVFG::addInterIndirectVFRetEdge ( const FormalOUTSVFGNode * src, const ActualOUTSVFGNode * dst, CallSiteID csId )

protected

Add inter VF edge from function exit mu to callsite chi.

Add inter VF edge from function exit mu to callsite chi

Definition at line 560 of file SVFG.cpp.

{
 
    NodeBS cpts1 = src->getPointsTo();
    NodeBS cpts2 = dst->getPointsTo();
    if(cpts1.intersects(cpts2))
    {
        cpts1 &= cpts2;
        return addRetIndirectVFEdge(src->getId(),dst->getId(),cpts1,csId);
    }
    return nullptr;
}

addIntraIndirectVFEdge()

SVFGEdge * SVFG::addIntraIndirectVFEdge ( NodeID srcId, NodeID dstId, const NodeBS & cpts )

protected

Add indirect def-use edges of a memory region between two statements,.

Definition at line 463 of file SVFG.cpp.

{
    SVFGNode* srcNode = getSVFGNode(srcId);
    SVFGNode* dstNode = getSVFGNode(dstId);
    checkIntraEdgeParents(srcNode, dstNode);
    if(SVFGEdge* edge = hasIntraVFGEdge(srcNode,dstNode,SVFGEdge::IntraIndirectVF))
    {
        assert(SVFUtil::isa<IndirectSVFGEdge>(edge) && "this should be a indirect value flow edge!");
        return (SVFUtil::cast<IndirectSVFGEdge>(edge)->addPointsTo(cpts) ? edge : nullptr);
    }
    else
    {
        IntraIndSVFGEdge* indirectEdge = new IntraIndSVFGEdge(srcNode,dstNode);
        indirectEdge->addPointsTo(cpts);
        return (addSVFGEdge(indirectEdge) ? indirectEdge : nullptr);
    }
}

addIntraMSSAPHISVFGNode()

void SVF::SVFG::addIntraMSSAPHISVFGNode ( ICFGNode * BlockICFGNode, const Map< u32_t, const MRVer * >::const_iterator opVerBegin, const Map< u32_t, const MRVer * >::const_iterator opVerEnd, const MRVer * resVer, const NodeID nodeId )

inlineprotected

Add memory SSA PHI SVFG node.

Definition at line 453 of file SVFG.h.

    {
        IntraMSSAPHISVFGNode* sNode = new IntraMSSAPHISVFGNode(nodeId, resVer);
        addSVFGNode(sNode, BlockICFGNode);
        for(MemSSA::PHI::OPVers::const_iterator it = opVerBegin, eit=opVerEnd; it!=eit; ++it)
            sNode->setOpVer(it->first,it->second);
        setDef(resVer,sNode);
    }

addRetIndirectVFEdge()

SVFGEdge * SVFG::addRetIndirectVFEdge ( NodeID srcId, NodeID dstId, const NodeBS & cpts, CallSiteID csId )

protected

Definition at line 525 of file SVFG.cpp.

{
    SVFGNode* srcNode = getSVFGNode(srcId);
    SVFGNode* dstNode = getSVFGNode(dstId);
    if(SVFGEdge* edge = hasInterVFGEdge(srcNode,dstNode,SVFGEdge::RetIndVF,csId))
    {
        assert(SVFUtil::isa<RetIndSVFGEdge>(edge) && "this should be a indirect value flow edge!");
        return (SVFUtil::cast<RetIndSVFGEdge>(edge)->addPointsTo(cpts) ? edge : nullptr);
    }
    else
    {
        RetIndSVFGEdge* retEdge = new RetIndSVFGEdge(srcNode,dstNode,csId);
        retEdge->addPointsTo(cpts);
        return (addSVFGEdge(retEdge) ? retEdge : nullptr);
    }
}

addSVFGEdge()

bool SVF::SVFG::addSVFGEdge ( SVFGEdge * edge )

inline

Add SVFG edge.

Definition at line 265 of file SVFG.h.

    {
        return addVFGEdge(edge);
    }

addSVFGNode()

virtual void SVF::SVFG::addSVFGNode ( SVFGNode * node, ICFGNode * icfgNode )

inlineprotectedvirtual

Add SVFG node.

Definition at line 413 of file SVFG.h.

    {
        addVFGNode(node, icfgNode);
    }

addSVFGNodesForAddrTakenVars()

void SVFG::addSVFGNodesForAddrTakenVars ( )

protected

Create SVFG nodes for address-taken variables.

set defs for address-taken vars defined at phi/chi/call create corresponding def and use nodes for address-taken vars (a.k.a MRVers) initialize memory SSA phi nodes (phi of address-taken variables)

initialize memory SSA entry chi nodes

initialize memory SSA return mu nodes

initialize memory SSA callsite mu nodes

initialize memory SSA callsite chi nodes

Definition at line 255 of file SVFG.cpp.

{
 
    // set defs for address-taken vars defined at store statements
    SVFStmt::SVFStmtSetTy& stores = getSVFStmtSet(SVFStmt::Store);
    for (SVFStmt::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                stores.end(); iter != eiter; ++iter)
    {
        StoreStmt* store = SVFUtil::cast<StoreStmt>(*iter);
        const StmtSVFGNode* sNode = getStmtVFGNode(store);
        for(CHISet::iterator pi = mssa->getCHISet(store).begin(), epi = mssa->getCHISet(store).end(); pi!=epi; ++pi)
            setDef((*pi)->getResVer(),sNode);
    }

    for(MemSSA::BBToPhiSetMap::iterator it = mssa->getBBToPhiSetMap().begin(),
            eit = mssa->getBBToPhiSetMap().end(); it!=eit; ++it)
    {
        for(PHISet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi)
        {
            MemSSA::PHI* phi =  *pi;
            const ICFGNode* inst = phi->getBasicBlock()->front();
            addIntraMSSAPHISVFGNode(const_cast<ICFGNode*>(inst), phi->opVerBegin(), phi->opVerEnd(),phi->getResVer(), totalVFGNode++);
        }
    }
    for(MemSSA::FunToEntryChiSetMap::iterator it = mssa->getFunToEntryChiSetMap().begin(),
            eit = mssa->getFunToEntryChiSetMap().end(); it!=eit; ++it)
    {
        for(CHISet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi)
        {
            const MemSSA::ENTRYCHI* chi = SVFUtil::cast<ENTRYCHI>(*pi);
            addFormalINSVFGNode(pag->getICFG()->getFunEntryICFGNode(chi->getFunction()), chi->getResVer(), totalVFGNode++);
        }
    }
    for(MemSSA::FunToReturnMuSetMap::iterator it = mssa->getFunToRetMuSetMap().begin(),
            eit = mssa->getFunToRetMuSetMap().end(); it!=eit; ++it)
    {
        for(MUSet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi)
        {
            const MemSSA::RETMU* mu = SVFUtil::cast<RETMU>(*pi);
            addFormalOUTSVFGNode(pag->getICFG()->getFunExitICFGNode(mu->getFunction()), mu->getMRVer(), totalVFGNode++);
        }
    }
    for(MemSSA::CallSiteToMUSetMap::iterator it = mssa->getCallSiteToMuSetMap().begin(),
            eit = mssa->getCallSiteToMuSetMap().end();
            it!=eit; ++it)
    {
        for(MUSet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi)
        {
            const MemSSA::CALLMU* mu = SVFUtil::cast<CALLMU>(*pi);
            addActualINSVFGNode(mu->getCallSite(), mu->getMRVer(), totalVFGNode++);
        }
    }
    for(MemSSA::CallSiteToCHISetMap::iterator it = mssa->getCallSiteToChiSetMap().begin(),
            eit = mssa->getCallSiteToChiSetMap().end();
            it!=eit; ++it)
    {
        for(CHISet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi)
        {
            const MemSSA::CALLCHI* chi = SVFUtil::cast<CALLCHI>(*pi);
            addActualOUTSVFGNode(chi->getCallSite(), chi->getResVer(), totalVFGNode++);
        }
 
    }
}

addThreadMHPIndirectVFEdge()

SVFGEdge * SVFG::addThreadMHPIndirectVFEdge ( NodeID srcId, NodeID dstId, const NodeBS & cpts )

protected

Add def-use edges of a memory region between two may-happen-in-parallel statements for multithreaded program

Definition at line 485 of file SVFG.cpp.

{
    SVFGNode* srcNode = getSVFGNode(srcId);
    SVFGNode* dstNode = getSVFGNode(dstId);
    if(SVFGEdge* edge = hasThreadVFGEdge(srcNode,dstNode,SVFGEdge::TheadMHPIndirectVF))
    {
        assert(SVFUtil::isa<IndirectSVFGEdge>(edge) && "this should be a indirect value flow edge!");
        return (SVFUtil::cast<IndirectSVFGEdge>(edge)->addPointsTo(cpts) ? edge : nullptr);
    }
    else
    {
        ThreadMHPIndSVFGEdge* indirectEdge = new ThreadMHPIndSVFGEdge(srcNode,dstNode);
        indirectEdge->addPointsTo(cpts);
        return (addSVFGEdge(indirectEdge) ? indirectEdge : nullptr);
    }
}

buildSVFG()

void SVFG::buildSVFG ( )

protectedvirtual

Start building SVFG.

Build SVFG 1) build SVFG nodes a) statements for top level pointers (SVFStmts) b) operators of address-taken variables (MSSAPHI and MSSACHI) 2) connect SVFG edges a) between two statements (SVFStmts) b) between two memory SSA operators (MSSAPHI MSSAMU and MSSACHI)

Reimplemented in SVF::SVFGOPT.

Definition at line 228 of file SVFG.cpp.

{
    DBOUT(DGENERAL, outs() << pasMsg("Build Sparse Value-Flow Graph \n"));
 
    stat->startClk();
    if (!Options::ReadSVFG().empty())
    {
        readFile(Options::ReadSVFG());
    }
    else
    {
        DBOUT(DGENERAL, outs() << pasMsg("\tCreate SVFG Addr-taken Node\n"));
        stat->ATVFNodeStart();
        addSVFGNodesForAddrTakenVars();
        stat->ATVFNodeEnd();
        DBOUT(DGENERAL, outs() << pasMsg("\tCreate SVFG Indirect Edge\n"));
        stat->indVFEdgeStart();
        connectIndirectSVFGEdges();
        stat->indVFEdgeEnd();
        if (!Options::WriteSVFG().empty())
            writeToFile(Options::WriteSVFG());
    }
}

clearMSSA()

void SVF::SVFG::clearMSSA ( )

inline

Clear MSSA.

Definition at line 132 of file SVFG.h.

    {
        mssa = nullptr;
    }

connectAInAndFIn()

virtual void SVF::SVFG::connectAInAndFIn ( const ActualINSVFGNode * actualIn, const FormalINSVFGNode * formalIn, CallSiteID csId, SVFGEdgeSetTy & edges )

inlineprotectedvirtual

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

Connect actual-in and formal-in

Reimplemented in SVF::SVFGOPT.

Definition at line 309 of file SVFG.h.

    {
        SVFGEdge* edge = addInterIndirectVFCallEdge(actualIn, formalIn,csId);
        if (edge != nullptr)
            edges.insert(edge);
    }

connectCallerAndCallee()

void SVFG::connectCallerAndCallee ( const CallICFGNode * cs, const FunObjVar * callee, SVFGEdgeSetTy & edges )

virtual

Connect SVFG 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 from SVF::VFG.

Definition at line 658 of file SVFG.cpp.

{
    VFG::connectCallerAndCallee(cs,callee,edges);
 
    CallSiteID csId = getCallSiteID(cs, callee);
 
    // connect actual in and formal in
    if (hasFuncEntryChi(callee) && hasCallSiteMu(cs))
    {
        SVFG::ActualINSVFGNodeSet& actualInNodes = getActualINSVFGNodes(cs);
        const SVFG::FormalINSVFGNodeSet& formalInNodes = getFormalINSVFGNodes(callee);
        for(SVFG::ActualINSVFGNodeSet::iterator ai_it = actualInNodes.begin(),
                ai_eit = actualInNodes.end(); ai_it!=ai_eit; ++ai_it)
        {
            const ActualINSVFGNode * actualIn = SVFUtil::cast<ActualINSVFGNode>(getSVFGNode(*ai_it));
            for(SVFG::FormalINSVFGNodeSet::iterator fi_it = formalInNodes.begin(),
                    fi_eit = formalInNodes.end(); fi_it!=fi_eit; ++fi_it)
            {
                const FormalINSVFGNode* formalIn = SVFUtil::cast<FormalINSVFGNode>(getSVFGNode(*fi_it));
                connectAInAndFIn(actualIn, formalIn, csId, edges);
            }
        }
    }
 
    // connect actual out and formal out
    if (hasFuncRetMu(callee) && hasCallSiteChi(cs))
    {
        // connect formal out and actual out
        const SVFG::FormalOUTSVFGNodeSet& formalOutNodes = getFormalOUTSVFGNodes(callee);
        SVFG::ActualOUTSVFGNodeSet& actualOutNodes = getActualOUTSVFGNodes(cs);
        for(SVFG::FormalOUTSVFGNodeSet::iterator fo_it = formalOutNodes.begin(),
                fo_eit = formalOutNodes.end(); fo_it!=fo_eit; ++fo_it)
        {
            const FormalOUTSVFGNode * formalOut = SVFUtil::cast<FormalOUTSVFGNode>(getSVFGNode(*fo_it));
            for(SVFG::ActualOUTSVFGNodeSet::iterator ao_it = actualOutNodes.begin(),
                    ao_eit = actualOutNodes.end(); ao_it!=ao_eit; ++ao_it)
            {
                const ActualOUTSVFGNode* actualOut = SVFUtil::cast<ActualOUTSVFGNode>(getSVFGNode(*ao_it));
                connectFOutAndAOut(formalOut, actualOut, csId, edges);
            }
        }
    }
}

connectFOutAndAOut()

virtual void SVF::SVFG::connectFOutAndAOut ( const FormalOUTSVFGNode * formalOut, const ActualOUTSVFGNode * actualOut, CallSiteID csId, SVFGEdgeSetTy & edges )

inlineprotectedvirtual

Connect formal-out and actual-out.

Reimplemented in SVF::SVFGOPT.

Definition at line 316 of file SVFG.h.

    {
        SVFGEdge* edge = addInterIndirectVFRetEdge(formalOut, actualOut,csId);
        if (edge != nullptr)
            edges.insert(edge);
    }

connectFromGlobalToProgEntry()

void SVFG::connectFromGlobalToProgEntry ( )

protected

Connect indirect SVFG edges from global initializers (store) to main function entry.

Connect indirect SVFG edges from global initializers (store) to main function entry

connect this store to main function entry

add indirect value flow edge

Definition at line 428 of file SVFG.cpp.

{
    const FunObjVar* mainFunc = SVFUtil::getProgEntryFunction();
    FormalINSVFGNodeSet& formalIns = getFormalINSVFGNodes(mainFunc);
    if (formalIns.empty())
        return;
 
    for (GlobalVFGNodeSet::const_iterator storeIt = globalVFGNodes.begin(), storeEit = globalVFGNodes.end();
            storeIt != storeEit; ++storeIt)
    {
        if (const StoreSVFGNode* store = SVFUtil::dyn_cast<StoreSVFGNode>(*storeIt))
        {
            const NodeBS& storePts = mssa->getPTA()->getPts(store->getDstNodeID()).toNodeBS();
 
            for (FormalINSVFGNodeSet::iterator fiIt = formalIns.begin(), fiEit =
                        formalIns.end(); fiIt != fiEit; ++fiIt)
            {
                NodeID formalInID = *fiIt;
                NodeBS formalInPts = ((FormalINSVFGNode*) getSVFGNode(formalInID))->getPointsTo();
 
                formalInPts &= storePts;
                if (formalInPts.empty())
                    continue;

                addIntraIndirectVFEdge(store->getId(), formalInID, formalInPts);
            }
        }
    }
}

connectIndirectSVFGEdges()

void SVFG::connectIndirectSVFGEdges ( )

protected

Connect direct SVFG edges between two SVFG nodes (value-flow of top address-taken variables).

There's no need to connect actual out node to its definition site in the same function.

Definition at line 330 of file SVFG.cpp.

{
 
    for(iterator it = begin(), eit = end(); it!=eit; ++it)
    {
        NodeID nodeId = it->first;
        const SVFGNode* node = it->second;
        if(const LoadSVFGNode* loadNode = SVFUtil::dyn_cast<LoadSVFGNode>(node))
        {
            MUSet& muSet = mssa->getMUSet(SVFUtil::cast<LoadStmt>(loadNode->getSVFStmt()));
            for(MUSet::iterator it = muSet.begin(), eit = muSet.end(); it!=eit; ++it)
            {
                if(LOADMU* mu = SVFUtil::dyn_cast<LOADMU>(*it))
                {
                    NodeID def = getDef(mu->getMRVer());
                    addIntraIndirectVFEdge(def,nodeId, mu->getMRVer()->getMR()->getPointsTo());
                }
            }
        }
        else if(const StoreSVFGNode* storeNode = SVFUtil::dyn_cast<StoreSVFGNode>(node))
        {
            CHISet& chiSet = mssa->getCHISet(SVFUtil::cast<StoreStmt>(storeNode->getSVFStmt()));
            for(CHISet::iterator it = chiSet.begin(), eit = chiSet.end(); it!=eit; ++it)
            {
                if(STORECHI* chi = SVFUtil::dyn_cast<STORECHI>(*it))
                {
                    NodeID def = getDef(chi->getOpVer());
                    addIntraIndirectVFEdge(def,nodeId, chi->getOpVer()->getMR()->getPointsTo());
                }
            }
        }
        else if(const FormalINSVFGNode* formalIn = SVFUtil::dyn_cast<FormalINSVFGNode>(node))
        {
            CallGraphEdge::CallInstSet callInstSet;
            mssa->getPTA()->getCallGraph()->getDirCallSitesInvokingCallee(formalIn->getFun(),callInstSet);
            for(CallGraphEdge::CallInstSet::iterator it = callInstSet.begin(), eit = callInstSet.end(); it!=eit; ++it)
            {
                const CallICFGNode* cs = *it;
                if(!mssa->hasMU(cs))
                    continue;
                ActualINSVFGNodeSet& actualIns = getActualINSVFGNodes(cs);
                for(ActualINSVFGNodeSet::iterator ait = actualIns.begin(), aeit = actualIns.end(); ait!=aeit; ++ait)
                {
                    const ActualINSVFGNode* actualIn = SVFUtil::cast<ActualINSVFGNode>(getSVFGNode(*ait));
                    addInterIndirectVFCallEdge(actualIn,formalIn,getCallSiteID(cs, formalIn->getFun()));
                }
            }
        }
        else if(const FormalOUTSVFGNode* formalOut = SVFUtil::dyn_cast<FormalOUTSVFGNode>(node))
        {
            CallGraphEdge::CallInstSet callInstSet;
            // const MemSSA::RETMU* retMu = formalOut->getRetMU();
            mssa->getPTA()->getCallGraph()->getDirCallSitesInvokingCallee(formalOut->getFun(),callInstSet);
            for(CallGraphEdge::CallInstSet::iterator it = callInstSet.begin(), eit = callInstSet.end(); it!=eit; ++it)
            {
                const CallICFGNode* cs = *it;
                if(!mssa->hasCHI(cs))
                    continue;
                ActualOUTSVFGNodeSet& actualOuts = getActualOUTSVFGNodes(cs);
                for(ActualOUTSVFGNodeSet::iterator ait = actualOuts.begin(), aeit = actualOuts.end(); ait!=aeit; ++ait)
                {
                    const ActualOUTSVFGNode* actualOut = SVFUtil::cast<ActualOUTSVFGNode>(getSVFGNode(*ait));
                    addInterIndirectVFRetEdge(formalOut,actualOut,getCallSiteID(cs, formalOut->getFun()));
                }
            }
            NodeID def = getDef(formalOut->getMRVer());
            addIntraIndirectVFEdge(def,nodeId, formalOut->getMRVer()->getMR()->getPointsTo());
        }
        else if(const ActualINSVFGNode* actualIn = SVFUtil::dyn_cast<ActualINSVFGNode>(node))
        {
            const MRVer* ver = actualIn->getMRVer();
            NodeID def = getDef(ver);
            addIntraIndirectVFEdge(def,nodeId, ver->getMR()->getPointsTo());
        }
        else if(SVFUtil::isa<ActualOUTSVFGNode>(node))
        {
        }
        else if(const MSSAPHISVFGNode* phiNode = SVFUtil::dyn_cast<MSSAPHISVFGNode>(node))
        {
            for (MemSSA::PHI::OPVers::const_iterator it = phiNode->opVerBegin(), eit = phiNode->opVerEnd();
                    it != eit; it++)
            {
                const MRVer* op = it->second;
                NodeID def = getDef(op);
                addIntraIndirectVFEdge(def,nodeId, op->getMR()->getPointsTo());
            }
        }
    }
 
 
    connectFromGlobalToProgEntry();
}

destroy()

void SVFG::destroy ( )

protected

Clean up memory.

Memory has been cleaned up at GenericGraph

Definition at line 212 of file SVFG.cpp.

{
    delete stat;
    stat = nullptr;
    clearMSSA();
}

dump()

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

Dump graph into dot file.

Dump SVFG

Definition at line 576 of file SVFG.cpp.

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

getActualINSVFGNodes()

ActualINSVFGNodeSet & SVF::SVFG::getActualINSVFGNodes ( const CallICFGNode * cs )

inline

Get SVFGNode set.

Definition at line 226 of file SVFG.h.

    {
        return callSiteToActualINMap[cs];
    }

getActualOUTSVFGNodes()

ActualOUTSVFGNodeSet & SVF::SVFG::getActualOUTSVFGNodes ( const CallICFGNode * cs )

inline

Definition at line 231 of file SVFG.h.

    {
        return callSiteToActualOUTMap[cs];
    }

getDef() [1/2]

NodeID SVF::SVFG::getDef ( const MRVer * mvar ) const

inlineprotected

Definition at line 397 of file SVFG.h.

    {
        MSSAVarToDefMapTy::const_iterator it = MSSAVarToDefMap.find(mvar);
        assert(it!=MSSAVarToDefMap.end() && "memory SSA does not have a definition??");
        return it->second;
    }

getDef() [2/2]

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

inlineprotected

Definition at line 372 of file SVFG.h.

    {
        return VFG::getDef(valVar);
    }

getDefSiteOfObjVar()

const Set< const SVFGNode * > SVFG::getDefSiteOfObjVar	(	const ObjVar *	obj,
		const SVFGNode *	vNode ) const

Given an ObjVar and its use-site SVFGNode, find the definition-site ICFGNode by following incoming IndirectSVFGEdges whose pts contains the ObjVar (asserts unique definition)

Given an ObjVar and its use-site SVFGNode, find the definition-site SVFGNodes by following incoming IndirectSVFGEdges whose pts contains the ObjVar (asserts unique definition)

Definition at line 772 of file SVFG.cpp.

{
    Set<const SVFGNode*> defSites;
    for (auto it = vNode->InEdgeBegin(), eit = vNode->InEdgeEnd(); it != eit; ++it)
    {
        if (const IndirectSVFGEdge* indEdge = SVFUtil::dyn_cast<IndirectSVFGEdge>(*it))
        {
            if (indEdge->getPointsTo().test(obj->getId()))
            {
                defSites.insert(indEdge->getSrcNode());
            }
        }
    }
    return defSites;
}

getDefSiteOfValVar()

const SVFGNode * SVFG::getDefSiteOfValVar

(

const ValVar *

var

)

const

Given a ValVar and its SVFGNode, find the definition-site SVFGNode by following incoming direct VFGEdges (asserts unique definition)

Given a ValVar, find the definition-site SVFGNode by following incoming direct VFGEdges (asserts unique definition)

Definition at line 765 of file SVFG.cpp.

{
    return getDefSVFGNode(var);
}

getDefSVFGNode()

const SVFGNode * SVF::SVFG::getDefSVFGNode ( const ValVar * valVar ) const

inline

Given a valVar, return its definition site.

Definition at line 171 of file SVFG.h.

    {
        return getSVFGNode(getDef(valVar));
    }

getFormalINSVFGNodes()

FormalINSVFGNodeSet & SVF::SVFG::getFormalINSVFGNodes ( const FunObjVar * fun )

inline

Definition at line 236 of file SVFG.h.

    {
        return funToFormalINMap[fun];
    }

getFormalOUTSVFGNodes()

FormalOUTSVFGNodeSet & SVF::SVFG::getFormalOUTSVFGNodes ( const FunObjVar * fun )

inline

Definition at line 241 of file SVFG.h.

    {
        return funToFormalOUTMap[fun];
    }

getInterVFEdgeAtIndCSFromAInToFIn()

virtual void SVF::SVFG::getInterVFEdgeAtIndCSFromAInToFIn ( ActualINSVFGNode * actualIn, const FunObjVar * callee, SVFGEdgeSetTy & edges )

inlineprotectedvirtual

Definition at line 344 of file SVFG.h.

    {
        for (SVFGNode::const_iterator outIt = actualIn->OutEdgeBegin(), outEit = actualIn->OutEdgeEnd(); outIt != outEit; ++outIt)
        {
            SVFGEdge* edge = *outIt;
            if (edge->getDstNode()->getFun() == callee)
                edges.insert(edge);
        }
    }

getInterVFEdgeAtIndCSFromAPToFP()

virtual void SVF::SVFG::getInterVFEdgeAtIndCSFromAPToFP ( const ValVar * cs_arg, const ValVar * fun_arg, const CallICFGNode * , CallSiteID csId, SVFGEdgeSetTy & edges )

inlineprotectedvirtual

Get inter value flow edges between indirect call site and callee.

Definition at line 326 of file SVFG.h.

    {
        SVFGNode* actualParam = getSVFGNode(getDef(cs_arg));
        SVFGNode* formalParam = getSVFGNode(getDef(fun_arg));
        SVFGEdge* edge = hasInterVFGEdge(actualParam, formalParam, SVFGEdge::CallDirVF, csId);
        assert(edge != nullptr && "Can not find inter value flow edge from aparam to fparam");
        edges.insert(edge);
    }

getInterVFEdgeAtIndCSFromFOutToAOut()

virtual void SVF::SVFG::getInterVFEdgeAtIndCSFromFOutToAOut ( ActualOUTSVFGNode * actualOut, const FunObjVar * callee, SVFGEdgeSetTy & edges )

inlineprotectedvirtual

Definition at line 354 of file SVFG.h.

    {
        for (SVFGNode::const_iterator inIt = actualOut->InEdgeBegin(), inEit = actualOut->InEdgeEnd(); inIt != inEit; ++inIt)
        {
            SVFGEdge* edge = *inIt;
            if (edge->getSrcNode()->getFun() == callee)
                edges.insert(edge);
        }
    }

getInterVFEdgeAtIndCSFromFRToAR()

virtual void SVF::SVFG::getInterVFEdgeAtIndCSFromFRToAR ( const ValVar * fun_ret, const ValVar * cs_ret, CallSiteID csId, SVFGEdgeSetTy & edges )

inlineprotectedvirtual

Definition at line 335 of file SVFG.h.

    {
        SVFGNode* formalRet = getSVFGNode(getDef(fun_ret));
        SVFGNode* actualRet = getSVFGNode(getDef(cs_ret));
        SVFGEdge* edge = hasInterVFGEdge(formalRet, actualRet, SVFGEdge::RetDirVF, csId);
        assert(edge != nullptr && "Can not find inter value flow edge from fret to aret");
        edges.insert(edge);
    }

getInterVFEdgesForIndirectCallSite()

void SVFG::getInterVFEdgesForIndirectCallSite	(	const CallICFGNode *	callICFGNode,
		const FunObjVar *	callee,
		SVFGEdgeSetTy &	edges )

Get all inter value flow edges of a indirect call site.

Get all inter value flow edges at this indirect call site, including call and return edges.

Definition at line 584 of file SVFG.cpp.

{
    CallSiteID csId = getCallSiteID(callICFGNode, callee);
    const RetICFGNode* retICFGNode = callICFGNode->getRetICFGNode();
 
    // Find inter direct call edges between actual param and formal param.
    if (pag->hasCallSiteArgsMap(callICFGNode) && pag->hasFunArgsList(callee))
    {
        const SVFIR::ValVarList& csArgList = pag->getCallSiteArgsList(callICFGNode);
        const SVFIR::ValVarList& funArgList = pag->getFunArgsList(callee);
        SVFIR::ValVarList::const_iterator csArgIt = csArgList.begin(), csArgEit = csArgList.end();
        SVFIR::ValVarList::const_iterator funArgIt = funArgList.begin(), funArgEit = funArgList.end();
        for (; funArgIt != funArgEit && csArgIt != csArgEit; funArgIt++, csArgIt++)
        {
            const ValVar *cs_arg = *csArgIt;
            const ValVar *fun_arg = *funArgIt;
            if (isInterestedSVFVar(fun_arg) && isInterestedSVFVar(cs_arg))
                getInterVFEdgeAtIndCSFromAPToFP(cs_arg, fun_arg, callICFGNode, csId, edges);
        }
        assert(funArgIt == funArgEit && "function has more arguments than call site");
        if (callee->isVarArg())
        {
            NodeID varFunArg = pag->getVarargNode(callee);
            const ValVar* varFunArgNode = pag->getValVar(varFunArg);
            if (isInterestedSVFVar(varFunArgNode))
            {
                for (; csArgIt != csArgEit; csArgIt++)
                {
                    const ValVar *cs_arg = *csArgIt;
                    if (isInterestedSVFVar(cs_arg))
                        getInterVFEdgeAtIndCSFromAPToFP(cs_arg, varFunArgNode, callICFGNode, csId, edges);
                }
            }
        }
    }
 
    // Find inter direct return edges between actual return and formal return.
    if (pag->funHasRet(callee) && pag->callsiteHasRet(retICFGNode))
    {
        const ValVar* cs_return = pag->getCallSiteRet(retICFGNode);
        const ValVar* fun_return = pag->getFunRet(callee);
        if (isInterestedSVFVar(cs_return) && isInterestedSVFVar(fun_return))
            getInterVFEdgeAtIndCSFromFRToAR(fun_return, cs_return, csId, edges);
    }
 
    // Find inter indirect call edges between actual-in and formal-in svfg nodes.
    if (hasFuncEntryChi(callee) && hasCallSiteMu(callICFGNode))
    {
        SVFG::ActualINSVFGNodeSet& actualInNodes = getActualINSVFGNodes(callICFGNode);
        for(SVFG::ActualINSVFGNodeSet::iterator ai_it = actualInNodes.begin(),
                ai_eit = actualInNodes.end(); ai_it!=ai_eit; ++ai_it)
        {
            ActualINSVFGNode * actualIn = SVFUtil::cast<ActualINSVFGNode>(getSVFGNode(*ai_it));
            getInterVFEdgeAtIndCSFromAInToFIn(actualIn, callee, edges);
        }
    }
 
    // Find inter indirect return edges between actual-out and formal-out svfg nodes.
    if (hasFuncRetMu(callee) && hasCallSiteChi(callICFGNode))
    {
        SVFG::ActualOUTSVFGNodeSet& actualOutNodes = getActualOUTSVFGNodes(callICFGNode);
        for(SVFG::ActualOUTSVFGNodeSet::iterator ao_it = actualOutNodes.begin(),
                ao_eit = actualOutNodes.end(); ao_it!=ao_eit; ++ao_it)
        {
            ActualOUTSVFGNode* actualOut = SVFUtil::cast<ActualOUTSVFGNode>(getSVFGNode(*ao_it));
            getInterVFEdgeAtIndCSFromFOutToAOut(actualOut, callee, edges);
        }
    }
}

getMRVERFromString()

MRVer * SVFG::getMRVERFromString ( const std::string & input )

virtual

Definition at line 430 of file SVFGReadWrite.cpp.

{
    if(s == "")
    {
        return NULL;
    }
    string temp;
    size_t last = 0;
    size_t next = 0;
    MRVer* tempMRVer;
    MemRegion* tempMemRegion;
    MSSADEF* tempDef;
    //{create Memory Region object
    next = s.find("MemRegion: pts{") + 15;
    last = s.find("} MRVERSION: ");
    temp = s.substr(next, last-next);
    // convert string to PointsTo
    NodeBS dstPts;
    string point;
    stringstream ss(temp);
    while (getline(ss, point, ' '))
    {
        istringstream sss(point);
        NodeID obj;
        sss >> obj;
        dstPts.set(obj);
    }
    tempMemRegion = new MemRegion(dstPts);
    // create mssdef
    next = s.find("MSSADef: ") + 9;
    last = s.find("} >=");
    temp = s.substr(next, last-next);
    // convert string to deftype
    istringstream ss1(temp.substr(0, temp.find(", ")));
    int obj1;
    ss1 >> obj1;
    MSSADEF::DEFTYPE defType = static_cast<MSSADEF::DEFTYPE>(obj1);
    tempDef = new MSSADEF(defType, tempMemRegion);
    // mrversion
    next = s.find("MRVERSION: ") + 11;
    last = s.find(" MSSADef:");
    temp = s.substr(next, last-next);
    // convert mrversion to nodeid
    istringstream ss2(temp);
    NodeID obj2;
    ss2 >> obj2;
    // create mrver
    tempMRVer = new MRVer(tempMemRegion, obj2, tempDef);
    return tempMRVer;
}

getMSSA()

MemSSA * SVF::SVFG::getMSSA ( ) const

inline

Get SVFG memory SSA.

Definition at line 138 of file SVFG.h.

    {
        return mssa.get();
    }

getPTA()

PointerAnalysis * SVF::SVFG::getPTA ( ) const

inline

Get Pointer Analysis.

Definition at line 144 of file SVFG.h.

    {
        return pta;
    }

getStat()

SVFGStat * SVF::SVFG::getStat ( ) const

inline

Return statistics.

Definition at line 126 of file SVFG.h.

    {
        return stat;
    }

getSVFGNode()

SVFGNode * SVF::SVFG::getSVFGNode ( NodeID id ) const

inline

Get a SVFG node.

Definition at line 150 of file SVFG.h.

    {
        return getVFGNode(id);
    }

getSVFGNodeNum()

u32_t SVF::SVFG::getSVFGNodeNum ( ) const

inline

Return total SVFG node number.

Definition at line 271 of file SVFG.h.

    {
        return nodeNum;
    }

getUseSitesOfObjVar()

const Set< const SVFGNode * > SVFG::getUseSitesOfObjVar	(	const ObjVar *	obj,
		const SVFGNode *	vNode ) const

Given an ObjVar and its def-site SVFGNodes, find all use-site SVFGNodes by following outgoing IndirectSVFGEdges whose pts contains the ObjVar

Given an ObjVar and its def-site SVFGNode, find all use-site SVFGNodes by following outgoing IndirectSVFGEdges whose pts contains the ObjVar

Definition at line 807 of file SVFG.cpp.

{
    Set<const SVFGNode*> useSites;
    for (auto it = vNode->OutEdgeBegin(), eit = vNode->OutEdgeEnd(); it != eit; ++it)
    {
        if (const IndirectSVFGEdge* indEdge = SVFUtil::dyn_cast<IndirectSVFGEdge>(*it))
        {
            if (indEdge->getPointsTo().test(obj->getId()))
            {
                useSites.insert(indEdge->getDstNode());
            }
        }
    }
 
    return useSites;
}

getUseSitesOfValVar()

const Set< const SVFGNode * > SVFG::getUseSitesOfValVar

(

const ValVar *

var

)

const

Given a ValVar, find all use-site SVFGNodes by following outgoing direct VFGEdges from its unique definition SVFGNode

Given a ValVar, find all use-site ICFGNodes by following outgoing direct VFGEdges from its unique definition SVFGNode

Definition at line 790 of file SVFG.cpp.

{
    const SVFGNode* defNode = getDefSVFGNode(var);
    Set<const SVFGNode*> useSites;
    for (auto it = defNode->OutEdgeBegin(), eit = defNode->OutEdgeEnd(); it != eit; ++it)
    {
        const VFGEdge* edge = *it;
        if (edge->isDirectVFGEdge())
        {
            useSites.insert(edge->getDstNode());
        }
    }
    return useSites;
}

hasActualINSVFGNodes()

bool SVF::SVFG::hasActualINSVFGNodes ( const CallICFGNode * cs ) const

inline

Has a SVFGNode.

Definition at line 203 of file SVFG.h.

    {
        return callSiteToActualINMap.find(cs)!=callSiteToActualINMap.end();
    }

hasActualOUTSVFGNodes()

bool SVF::SVFG::hasActualOUTSVFGNodes ( const CallICFGNode * cs ) const

inline

Definition at line 208 of file SVFG.h.

    {
        return callSiteToActualOUTMap.find(cs)!=callSiteToActualOUTMap.end();
    }

hasCallSiteChi()

bool SVF::SVFG::hasCallSiteChi ( const CallICFGNode * cs ) const

inlineprotected

Definition at line 473 of file SVFG.h.

    {
        return (callSiteToActualOUTMap.find(cs) != callSiteToActualOUTMap.end());
    }

hasCallSiteMu()

bool SVF::SVFG::hasCallSiteMu ( const CallICFGNode * cs ) const

inlineprotected

Definition at line 477 of file SVFG.h.

    {
        return (callSiteToActualINMap.find(cs) != callSiteToActualINMap.end());
    }

hasDef()

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

inlineprotected

Definition at line 376 of file SVFG.h.

    {
        return VFG::hasDef(valVar);
    }

hasDefSVFGNode()

bool SVF::SVFG::hasDefSVFGNode ( const ValVar * valVar ) const

inline

Given a valVar, return whether it has definition site.

Definition at line 177 of file SVFG.h.

    {
        return hasDef(valVar) && hasSVFGNode(getDef(valVar));
    }

hasFormalINSVFGNodes()

bool SVF::SVFG::hasFormalINSVFGNodes ( const FunObjVar * fun ) const

inline

Definition at line 213 of file SVFG.h.

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

hasFormalOUTSVFGNodes()

bool SVF::SVFG::hasFormalOUTSVFGNodes ( const FunObjVar * fun ) const

inline

Definition at line 218 of file SVFG.h.

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

hasFuncEntryChi()

bool SVF::SVFG::hasFuncEntryChi ( const FunObjVar * func ) const

inlineprotected

Has function for EntryCHI/RetMU/CallCHI/CallMU.

Definition at line 465 of file SVFG.h.

    {
        return (funToFormalINMap.find(func) != funToFormalINMap.end());
    }

hasFuncRetMu()

bool SVF::SVFG::hasFuncRetMu ( const FunObjVar * func ) const

inlineprotected

Definition at line 469 of file SVFG.h.

    {
        return (funToFormalOUTMap.find(func) != funToFormalOUTMap.end());
    }

hasSVFGNode()

bool SVF::SVFG::hasSVFGNode ( NodeID id ) const

inline

Whether has the SVFGNode.

Definition at line 156 of file SVFG.h.

    {
        return hasVFGNode(id);
    }

isCallSiteRetSVFGNode()

const CallICFGNode * SVFG::isCallSiteRetSVFGNode

(

const SVFGNode *

node

)

const

Whether a node is callsite return SVFGNode.

Whether this is an callsite return SVFGNode (actual return, actual out)

Definition at line 732 of file SVFG.cpp.

{
    if(const ActualRetSVFGNode* ar = SVFUtil::dyn_cast<ActualRetSVFGNode>(node))
    {
        return ar->getCallSite();
    }
    else if(const InterPHISVFGNode* phi = SVFUtil::dyn_cast<InterPHISVFGNode>(node))
    {
        if(phi->isActualRetPHI())
            return phi->getCallSite();
    }
    else if(const ActualOUTSVFGNode* ao = SVFUtil::dyn_cast<ActualOUTSVFGNode>(node))
    {
        return ao->getCallSite();
    }
    else if(const InterMSSAPHISVFGNode* mphi = SVFUtil::dyn_cast<InterMSSAPHISVFGNode>(node))
    {
        if(mphi->isActualOUTPHI())
            return mphi->getCallSite();
    }
    return nullptr;
}

isFunEntrySVFGNode()

const FunObjVar * SVFG::isFunEntrySVFGNode

(

const SVFGNode *

node

)

const

Whether a node is function entry SVFGNode.

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

Definition at line 706 of file SVFG.cpp.

{
    if(const FormalParmSVFGNode* fp = SVFUtil::dyn_cast<FormalParmSVFGNode>(node))
    {
        return fp->getFun();
    }
    else if(const InterPHISVFGNode* phi = SVFUtil::dyn_cast<InterPHISVFGNode>(node))
    {
        if(phi->isFormalParmPHI())
            return phi->getFun();
    }
    else if(const FormalINSVFGNode* fi = SVFUtil::dyn_cast<FormalINSVFGNode>(node))
    {
        return fi->getFun();
    }
    else if(const InterMSSAPHISVFGNode* mphi = SVFUtil::dyn_cast<InterMSSAPHISVFGNode>(node))
    {
        if(mphi->isFormalINPHI())
            return mphi->getFun();
    }
    return nullptr;
}

performStat()

void SVFG::performStat

(

)

Perform statistics.

Perform Statistics

Definition at line 758 of file SVFG.cpp.

{
    stat->performStat();
}

readFile()

void SVFG::readFile ( const std::string & filename )

virtual

Definition at line 206 of file SVFGReadWrite.cpp.

{
    outs() << "Loading SVFG analysis results from '" << filename << "'...";
    ifstream F(filename.c_str());
    if (!F.is_open())
    {
        outs() << " error opening file for reading!\n";
        return;
    }
 
    SVFStmt::SVFStmtSetTy& stores = getSVFStmtSet(SVFStmt::Store);
    for (SVFStmt::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                stores.end(); iter != eiter; ++iter)
    {
        StoreStmt* store = SVFUtil::cast<StoreStmt>(*iter);
        const StmtSVFGNode* sNode = getStmtVFGNode(store);
        for(CHISet::iterator pi = mssa->getCHISet(store).begin(), epi = mssa->getCHISet(store).end(); pi!=epi; ++pi)
            setDef((*pi)->getResVer(),sNode);
    }
    //outer loop through each line in the file
    string line;
    // add nodes
    stat->ATVFNodeStart();
    while (F.good())
    {
        getline(F, line);
        if (line.empty())
            continue;
        if (line.find("__Edges__") != std::string::npos)
            break;
 
        std::string s = line;
        std::string delimiter = " >= ";
        string temp;
        int index = 0;
        //implement delimiter to split string using ">="
        size_t next = 0;
        size_t last = 0;
        size_t outer_last = 0;
        size_t nextTemp; //size_t lastTemp;
        NodeID id = 0;
        string type;
        string MR;
        string basicBlock;
        string opVer;
        //inner loop through to get each element in the line
        while ((next = s.find(delimiter, last)) != string::npos)
        {
            temp = s.substr(last, next-last);
            last = next + 4;
            outer_last = next + 4;
            if(index == 0)
            {
                nextTemp = temp.find("SVFGNodeID: ") + 12;
                id = atoi(temp.substr(nextTemp).c_str());
            }
            if(index == 1)
            {
                type = temp;
            }
            if(index > 1)
            {
                if(index == 2)
                {
                    MR = temp;
                }
                if(index == 3)
                {
                    basicBlock = temp;
                }
            }
            index++;
        }
        MRVer* tempMRVer;
        if(!MR.empty())
        {
            tempMRVer = getMRVERFromString(MR);
        }
        else
        {
            tempMRVer = getMRVERFromString("");
        }
        //add nodes using the variables we extracted
        if(type == "FormalINSVFGNode")
        {
            outer_last = s.find("ICFGNodeID: ") + 12;
            NodeID FunID = atoi(s.substr(outer_last).c_str());
            addFormalINSVFGNode(SVFUtil::dyn_cast<FunEntryICFGNode>(pag->getICFG()->getICFGNode(FunID)), tempMRVer, id);
        }
        else if(type == "FormalOUTSVFGNode")
        {
            outer_last = s.find("ICFGNodeID: ") + 12;
            NodeID FunID =  atoi(s.substr(outer_last).c_str());
            addFormalOUTSVFGNode(SVFUtil::dyn_cast<FunExitICFGNode>(pag->getICFG()->getICFGNode(FunID)), tempMRVer, id);
        }
        else if(type == "ActualINSVFGNode")
        {
            outer_last = s.find("ICFGNodeID: ") + 12;
            NodeID CallSiteID = atoi(s.substr(outer_last).c_str());
            addActualINSVFGNode(SVFUtil::dyn_cast<CallICFGNode>(pag->getICFG()->getICFGNode(CallSiteID)), tempMRVer, id);
        }
        else if(type == "ActualOUTSVFGNode")
        {
            outer_last = s.find("ICFGNodeID: ") + 12;
            NodeID CallSiteID = atoi(s.substr(outer_last).c_str());
            addActualOUTSVFGNode(SVFUtil::dyn_cast<CallICFGNode>(pag->getICFG()->getICFGNode(CallSiteID)), tempMRVer, id);
        }
        else if (type == "PHISVFGNode")
        {
            opVer =  s.substr(outer_last);
            next = opVer.find("{") + 1;
            last = opVer.find(",}");
            temp = opVer.substr(next, last);
            Map<u32_t,const MRVer*> OPVers;
            int index = 0;
            while ((next = temp.find("{") + 1) != string::npos)
            {
                if (temp == ",}")
                    break;
                last = temp.find("},");
                string temp1;
                temp1 = temp.substr(next, last-next);
                MRVer* tempOPVer = getMRVERFromString(temp1);
                OPVers.insert(make_pair(index, tempOPVer));
                temp = temp.substr(last + 1);
                index++;
            }
            next = basicBlock.find("ICFGNodeID: ") + 12;
            temp = basicBlock.substr(next);
            addIntraMSSAPHISVFGNode(pag->getICFG()->getICFGNode(atoi(temp.c_str())), OPVers.begin(), OPVers.end(), tempMRVer, id);
        }
        else
        {
        }
 
        if (totalVFGNode < id)
            totalVFGNode = id + 1;
    }
    stat->ATVFNodeEnd();
 
    stat->indVFEdgeStart();
    // Edges
    while (F.good())
    {
        getline(F, line);
        if (line.empty())
            continue;
 
        std::string s = line;
        std::string delimiter = " >= ";
        string temp;
        // int index = 0;
        size_t last = 0;
        size_t next = 0; // size_t outer_last = 0;
        string edge;
        string attributes;
 
        next = s.find(delimiter);
 
        edge = s.substr(0, next);
        attributes = s.substr(next + 4);
 
        // extract nodeIDs for src and dst nodes
        NodeID src;
        NodeID dst;
        next = edge.find("srcSVFGNodeID: ") + 15;
        last = edge.find(" => ");
        src = atoi(edge.substr(next, last-next).c_str());
        next = edge.find("dstSVFGNodeID: ") + 15;
        dst = atoi(edge.substr(next).c_str());
 
        string type;
        string attribute;
        if (attributes.find(" | ") == string::npos)
            type = attributes;
        else
        {
            next = attributes.find(" | ");
            type = attributes.substr(0, next);
            attribute = attributes.substr(next + 3);
        }
 
        if(type == "FormalINSVFGNode")
        {
            const FormalINSVFGNode* formalIn = SVFUtil::cast<FormalINSVFGNode>(getSVFGNode(src));
            const ActualINSVFGNode* actualIn = SVFUtil::cast<ActualINSVFGNode>(getSVFGNode(dst));
            addInterIndirectVFCallEdge(actualIn,formalIn, getCallSiteID(actualIn->getCallSite(), formalIn->getFun()));
        }
        else if(type == "FormalOUTSVFGNode")
        {
            const FormalOUTSVFGNode* formalOut = SVFUtil::cast<FormalOUTSVFGNode>(getSVFGNode(src));
            if (attribute.find("intra") != string::npos)
            {
                addIntraIndirectVFEdge(dst, src, formalOut->getMRVer()->getMR()->getPointsTo());
            }
            else
            {
                const ActualOUTSVFGNode* actualOut = SVFUtil::cast<ActualOUTSVFGNode>(getSVFGNode(dst));
                addInterIndirectVFRetEdge(formalOut,actualOut,getCallSiteID(actualOut->getCallSite(), formalOut->getFun()));
            }
        }
        else if(type == "ActualINSVFGNode")
        {
            const ActualINSVFGNode* actualIn = SVFUtil::cast<ActualINSVFGNode>(getSVFGNode(src));
            addIntraIndirectVFEdge(dst,src, actualIn->getMRVer()->getMR()->getPointsTo());
        }
        else if(type == "ActualOUTSVFGNode")
        {
            // There's no need to connect actual out node to its definition site in the same function.
        }
        else if (type == "StoreNode" || type == "LoadNode" || type == "PHISVFGNode")
        {
            MRVer* tempMRVer;
            tempMRVer = getMRVERFromString(attribute);
            addIntraIndirectVFEdge(dst,src, tempMRVer->getMR()->getPointsTo());
        }
        else
        {
        }
    }
    stat->indVFEdgeEnd();
    connectFromGlobalToProgEntry();
}

removeSVFGEdge()

void SVF::SVFG::removeSVFGEdge ( SVFGEdge * edge )

inline

Remove a SVFG edge.

Definition at line 254 of file SVFG.h.

    {
        removeVFGEdge(edge);
    }

removeSVFGNode()

void SVF::SVFG::removeSVFGNode ( SVFGNode * node )

inline

Remove a SVFGNode.

Definition at line 259 of file SVFG.h.

    {
        removeVFGNode(node);
    }

setDef() [1/2]

void SVF::SVFG::setDef ( const MRVer * mvar, const SVFGNode * node )

inlineprotected

Given a MSSADef, set/get its def SVFG node (definition of address-taken variables).

Definition at line 384 of file SVFG.h.

    {
        MSSAVarToDefMapTy::iterator it = MSSAVarToDefMap.find(mvar);
        if(it==MSSAVarToDefMap.end())
        {
            MSSAVarToDefMap[mvar] = node->getId();
            assert(hasSVFGNode(node->getId()) && "not in the map!!");
        }
        else
        {
            assert((it->second == node->getId()) && "a SVFIR node can only have unique definition ");
        }
    }

setDef() [2/2]

void SVF::SVFG::setDef ( const ValVar * valVar, const SVFGNode * node )

inlineprotected

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

Definition at line 368 of file SVFG.h.

    {
        VFG::setDef(valVar, node);
    }

writeToFile()

void SVFG::writeToFile ( const std::string & filename )

virtual

Definition at line 46 of file SVFGReadWrite.cpp.

{
    outs() << "Writing SVFG analysis to '" << filename << "'...";
    error_code err;
    std::fstream f(filename.c_str(), std::ios_base::out);
    if (!f.good())
    {
        outs() << "  error opening file for writing!\n";
        return;
    }
    f << "__Nodes__\n";
    // Iterate over nodes and write to file
    for(iterator it = begin(), eit = end(); it!=eit; ++it)
    {
        NodeID nodeId = it->first;
        const SVFGNode* node = it->second;
        if(const FormalINSVFGNode* formalIn = SVFUtil::dyn_cast<FormalINSVFGNode>(node))
        {
            //node
            f << "SVFGNodeID: " << nodeId << " >= " << "FormalINSVFGNode";
            f << " >= MVER: {";
            f << *formalIn->getMRVer() << "} >= ICFGNodeID: " << formalIn->getFunEntryNode()->getId() << "\n";
        }
        else if(const FormalOUTSVFGNode* formalOut = SVFUtil::dyn_cast<FormalOUTSVFGNode>(node))
        {
            //node
            f << "SVFGNodeID: " << nodeId << " >= " << "FormalOUTSVFGNode";
            f << " >= MVER: {";
            f << *formalOut->getMRVer() << "} >= ICFGNodeID: " <<  formalOut->getFunExitNode()->getId() << "\n";
        }
        else if(const ActualINSVFGNode* actualIn = SVFUtil::dyn_cast<ActualINSVFGNode>(node))
        {
            //node
            f << "SVFGNodeID: " << nodeId << " >= " << "ActualINSVFGNode";
            f << " >= MVER: {";
            f << *actualIn->getMRVer() << "} >= ICFGNodeID: " << actualIn->getCallSite()->getId() << "\n";
        }
        else if(const ActualOUTSVFGNode* actualOut = SVFUtil::dyn_cast<ActualOUTSVFGNode>(node))
        {
            //node
            f << "SVFGNodeID: " << nodeId << " >= " << "ActualOUTSVFGNode" << " >= MVER: {";
            f << *actualOut->getMRVer() << "} >= ICFGNodeID: "  <<  actualOut->getCallSite()->getId() << "\n";
        }
        else if(const MSSAPHISVFGNode* phiNode = SVFUtil::dyn_cast<MSSAPHISVFGNode>(node))
        {
            //node
            f << "SVFGNodeID: " << nodeId << " >= " << "PHISVFGNode";
            unordered_map<u32_t,const MRVer*> opvers;
            for (MemSSA::PHI::OPVers::const_iterator it = phiNode->opVerBegin(), eit = phiNode->opVerEnd();
                    it != eit; it++)
            {
                opvers.insert(make_pair(it->first, it->second));
            }
            // opvers
            f << " >= MVER: {";
            f << *phiNode->getResVer();
            const ICFGNode* inst = phiNode->getICFGNode()->getBB()->front();
            f << "} >= ICFGNodeID: " << inst->getId();
            f << " >= OPVers: {";
            for (auto x: opvers)
            {
                const MRVer* op = x.second;
                f << "{" << *op << "}" << ",";
            }
            f << "}\n";
        }
    }
 
    f << "\n\n__Edges__\n";
    // Iterate over edges and write to file
    for(iterator it = begin(), eit = end(); it!=eit; ++it)
    {
        NodeID nodeId = it->first;
        const SVFGNode* node = it->second;
        if(const LoadSVFGNode* loadNode = SVFUtil::dyn_cast<LoadSVFGNode>(node))
        {
            MUSet& muSet = mssa->getMUSet(SVFUtil::cast<LoadStmt>(loadNode->getSVFStmt()));
            for(MUSet::iterator it = muSet.begin(), eit = muSet.end(); it!=eit; ++it)
            {
                if(LOADMU* mu = SVFUtil::dyn_cast<LOADMU>(*it))
                {
                    NodeID def = getDef(mu->getMRVer());
                    f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= LoadNode | MVER: {" << *mu->getMRVer() << "}" << "\n";
                }
            }
        }
        else if(const StoreSVFGNode* storeNode = SVFUtil::dyn_cast<StoreSVFGNode>(node))
        {
            CHISet& chiSet = mssa->getCHISet(SVFUtil::cast<StoreStmt>(storeNode->getSVFStmt()));
            for(CHISet::iterator it = chiSet.begin(), eit = chiSet.end(); it!=eit; ++it)
            {
                if(STORECHI* chi = SVFUtil::dyn_cast<STORECHI>(*it))
                {
                    NodeID def = getDef(chi->getOpVer());
                    f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= StoreNode | MVER: {" << *chi->getOpVer() << "}" << "\n";
                }
            }
        }
        else if(const FormalINSVFGNode* formalIn = SVFUtil::dyn_cast<FormalINSVFGNode>(node))
        {
            CallGraphEdge::CallInstSet callInstSet;
            mssa->getPTA()->getCallGraph()->getDirCallSitesInvokingCallee(formalIn->getFun(),callInstSet);
            for(CallGraphEdge::CallInstSet::iterator it = callInstSet.begin(), eit = callInstSet.end(); it!=eit; ++it)
            {
                const CallICFGNode* cs = *it;
                if(!mssa->hasMU(cs))
                    continue;
                ActualINSVFGNodeSet& actualIns = getActualINSVFGNodes(cs);
                for(ActualINSVFGNodeSet::iterator ait = actualIns.begin(), aeit = actualIns.end(); ait!=aeit; ++ait)
                {
                    const ActualINSVFGNode* actualIn = SVFUtil::cast<ActualINSVFGNode>(getSVFGNode(*ait));
                    f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << actualIn->getId() << " >= FormalINSVFGNode" << "\n";
                }
            }
        }
        else if(const FormalOUTSVFGNode* formalOut = SVFUtil::dyn_cast<FormalOUTSVFGNode>(node))
        {
            CallGraphEdge::CallInstSet callInstSet;
            mssa->getPTA()->getCallGraph()->getDirCallSitesInvokingCallee(formalOut->getFun(),callInstSet);
            for(CallGraphEdge::CallInstSet::iterator it = callInstSet.begin(), eit = callInstSet.end(); it!=eit; ++it)
            {
                const CallICFGNode* cs = *it;
                if(!mssa->hasCHI(cs))
                    continue;
                ActualOUTSVFGNodeSet& actualOuts = getActualOUTSVFGNodes(cs);
                for(ActualOUTSVFGNodeSet::iterator ait = actualOuts.begin(), aeit = actualOuts.end(); ait!=aeit; ++ait)
                {
                    const ActualOUTSVFGNode* actualOut = SVFUtil::cast<ActualOUTSVFGNode>(getSVFGNode(*ait));
                    f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << actualOut->getId() << " >= FormalOUTSVFGNode" << "\n";
                }
            }
            NodeID def = getDef(formalOut->getMRVer());
            f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= FormalOUTSVFGNode | intra" << "\n";
        }
        else if(const ActualINSVFGNode* actualIn = SVFUtil::dyn_cast<ActualINSVFGNode>(node))
        {
            NodeID def = getDef(actualIn->getMRVer());
            f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= ActualINSVFGNode" << "\n";
 
        }
        else if(const MSSAPHISVFGNode* phiNode = SVFUtil::dyn_cast<MSSAPHISVFGNode>(node))
        {
            for (MemSSA::PHI::OPVers::const_iterator it = phiNode->opVerBegin(), eit = phiNode->opVerEnd();
                    it != eit; it++)
            {
                const MRVer* op = it->second;
                NodeID def = getDef(op);
                f << "srcSVFGNodeID: " << nodeId << " => " << "dstSVFGNodeID: " << def << " >= PHISVFGNode | MVER: {" << *op << "}" << "\n";
            }
        }
    }
    // Job finish and close file
    f.close();
    if (f.good())
    {
        outs() << "\n";
        return;
    }
}

Friends And Related Symbol Documentation

CFLSVFGBuilder

friend class CFLSVFGBuilder

friend

Definition at line 69 of file SVFG.h.

DDASVFGBuilder

friend class DDASVFGBuilder

friend

Definition at line 71 of file SVFG.h.

MTASVFGBuilder

friend class MTASVFGBuilder

friend

Definition at line 72 of file SVFG.h.

RcSvfgBuilder

friend class RcSvfgBuilder

friend

Definition at line 73 of file SVFG.h.

SaberSVFGBuilder

friend class SaberSVFGBuilder

friend

Definition at line 68 of file SVFG.h.

SVFGBuilder

friend class SVFGBuilder

friend

Definition at line 67 of file SVFG.h.

TaintSVFGBuilder

friend class TaintSVFGBuilder

friend

Definition at line 70 of file SVFG.h.

Member Data Documentation

callSiteToActualINMap

CallSiteToActualINsMapTy SVF::SVFG::callSiteToActualINMap

protected

Definition at line 101 of file SVFG.h.

callSiteToActualOUTMap

CallSiteToActualOUTsMapTy SVF::SVFG::callSiteToActualOUTMap

protected

Definition at line 102 of file SVFG.h.

funToFormalINMap

FunctionToFormalINsMapTy SVF::SVFG::funToFormalINMap

protected

Definition at line 103 of file SVFG.h.

funToFormalOUTMap

FunctionToFormalOUTsMapTy SVF::SVFG::funToFormalOUTMap

protected

Definition at line 104 of file SVFG.h.

mssa

std::unique_ptr<MemSSA> SVF::SVFG::mssa

protected

Definition at line 106 of file SVFG.h.

MSSAVarToDefMap

MSSAVarToDefMapTy SVF::SVFG::MSSAVarToDefMap

protected

map a memory SSA operator to its definition SVFG node

Definition at line 100 of file SVFG.h.

pta

PointerAnalysis* SVF::SVFG::pta

protected

Definition at line 107 of file SVFG.h.

stat

SVFGStat* SVF::SVFG::stat

protected

Definition at line 105 of file SVFG.h.

---

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

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