#include <SVFG.h>

Inheritance diagram for SVF::SVFG:

Public Types
typedef VFGNodeIDToNodeMapTy	SVFGNodeIDToNodeMapTy

typedef Map< const PAGNode *, NodeID >	PAGNodeToDefMapTy

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 SVFFunction *, FormalINSVFGNodeSet >	FunctionToFormalINsMapTy

typedef Map< const SVFFunction *, 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 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
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 SVFFunction 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 SVFFunction callee, SVFGEdgeSetTy &edges)
	Connect SVFG nodes between caller and callee for indirect call site.

const SVFGNode *	getDefSVFGNode (const PAGNode *pagNode) const
	Given a pagNode, return its definition site.

bool	hasDefSVFGNode (const PAGNode *pagNode) const
	Given a pagNode, return whether it has definition site.

void	performStat ()
	Perform statistics.

bool	hasActualINSVFGNodes (const CallICFGNode *cs) const
	Has a SVFGNode.

bool	hasActualOUTSVFGNodes (const CallICFGNode *cs) const

bool	hasFormalINSVFGNodes (const SVFFunction *fun) const

bool	hasFormalOUTSVFGNodes (const SVFFunction *fun) const

ActualINSVFGNodeSet &	getActualINSVFGNodes (const CallICFGNode *cs)
	Get SVFGNode set.

ActualOUTSVFGNodeSet &	getActualOUTSVFGNodes (const CallICFGNode *cs)

FormalINSVFGNodeSet &	getFormalINSVFGNodes (const SVFFunction *fun)

FormalOUTSVFGNodeSet &	getFormalOUTSVFGNodes (const SVFFunction *fun)

const SVFFunction *	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 (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.

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.

	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 PAGNode cs_arg, const PAGNode fun_arg, const CallICFGNode *, CallSiteID csId, SVFGEdgeSetTy &edges)
	Get inter value flow edges between indirect call site and callee.

virtual void	getInterVFEdgeAtIndCSFromFRToAR (const PAGNode fun_ret, const PAGNode cs_ret, CallSiteID csId, SVFGEdgeSetTy &edges)

virtual void	getInterVFEdgeAtIndCSFromAInToFIn (ActualINSVFGNode actualIn, const SVFFunction callee, SVFGEdgeSetTy &edges)

virtual void	getInterVFEdgeAtIndCSFromFOutToAOut (ActualOUTSVFGNode actualOut, const SVFFunction callee, SVFGEdgeSetTy &edges)

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

NodeID	getDef (const PAGNode *pagNode) const

bool	hasDef (const PAGNode *pagNode) 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 SVFFunction *func) const
	Has function for EntryCHI/RetMU/CallCHI/CallMU.

bool	hasFuncRetMu (const SVFFunction *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 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
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

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

Friends
class	SVFGBuilder

class	SaberSVFGBuilder

class	CFLSVFGBuilder

class	TaintSVFGBuilder

class	DDASVFGBuilder

class	MTASVFGBuilder

class	RcSvfgBuilder

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

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 SVFFunction*, FormalINSVFGNodeSet> SVF::SVFG::FunctionToFormalINsMapTy

Definition at line 85 of file SVFG.h.

◆ FunctionToFormalOUTsMapTy

typedef Map<const SVFFunction*, 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.

◆ PAGNodeToDefMapTy

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

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

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 420 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 428 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 263 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 403 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 412 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 437 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 249 of file SVFG.h.

    {
        return addVFGEdge(edge);
    }

◆ addSVFGNode()

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

inlineprotectedvirtual

Add SVFG node.

Definition at line 397 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 = getPAGEdgeSet(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 (PAGEdges) b) operators of address-taken variables (MSSAPHI and MSSACHI) 2) connect SVFG edges a) between two statements (PAGEdges) 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 293 of file SVFG.h.

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

◆ connectCallerAndCallee()

void SVFG::connectCallerAndCallee	(	const CallICFGNode *	cs,
		const SVFFunction *	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 300 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 SVFFunction* 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->getPAGDstNodeID()).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->getPAGEdge()));
            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->getPAGEdge()));
            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))
        {
            PTACallGraphEdge::CallInstSet callInstSet;
            mssa->getPTA()->getCallGraph()->getDirCallSitesInvokingCallee(formalIn->getFun(),callInstSet);
            for(PTACallGraphEdge::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))
        {
            PTACallGraphEdge::CallInstSet callInstSet;
            // const MemSSA::RETMU* retMu = formalOut->getRetMU();
            mssa->getPTA()->getCallGraph()->getDirCallSitesInvokingCallee(formalOut->getFun(),callInstSet);
            for(PTACallGraphEdge::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 210 of file SVFG.h.

    {
        return callSiteToActualINMap[cs];
    }

◆ getActualOUTSVFGNodes()

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

inline

Definition at line 215 of file SVFG.h.

    {
        return callSiteToActualOUTMap[cs];
    }

◆ getDef() [1/2]

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

inlineprotected

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

inlineprotected

Definition at line 356 of file SVFG.h.

    {
        return VFG::getDef(pagNode);
    }

◆ getDefSVFGNode()

const SVFGNode * SVF::SVFG::getDefSVFGNode ( const PAGNode * pagNode ) const

inline

Given a pagNode, return its definition site.

Definition at line 171 of file SVFG.h.

    {
        return getSVFGNode(getDef(pagNode));
    }

◆ getFormalINSVFGNodes()

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

inline

Definition at line 220 of file SVFG.h.

    {
        return funToFormalINMap[fun];
    }

◆ getFormalOUTSVFGNodes()

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

inline

Definition at line 225 of file SVFG.h.

    {
        return funToFormalOUTMap[fun];
    }

◆ getInterVFEdgeAtIndCSFromAInToFIn()

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

inlineprotectedvirtual

Definition at line 328 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 PAGNode *	cs_arg,
		const PAGNode *	fun_arg,
		const CallICFGNode *	,
		CallSiteID	csId,
		SVFGEdgeSetTy &	edges
	)

inlineprotectedvirtual

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

Definition at line 310 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 SVFFunction *	callee,
		SVFGEdgeSetTy &	edges
	)

inlineprotectedvirtual

Definition at line 338 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 PAGNode *	fun_ret,
		const PAGNode *	cs_ret,
		CallSiteID	csId,
		SVFGEdgeSetTy &	edges
	)

inlineprotectedvirtual

Definition at line 319 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 SVFFunction *	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::SVFVarList& csArgList = pag->getCallSiteArgsList(callICFGNode);
        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(fun_arg) && isInterestedPAGNode(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 PAGNode* varFunArgNode = pag->getGNode(varFunArg);
            if (isInterestedPAGNode(varFunArgNode))
            {
                for (; csArgIt != csArgEit; csArgIt++)
                {
                    const PAGNode *cs_arg = *csArgIt;
                    if (isInterestedPAGNode(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 PAGNode* cs_return = pag->getCallSiteRet(retICFGNode);
        const PAGNode* fun_return = pag->getFunRet(callee);
        if (isInterestedPAGNode(cs_return) && isInterestedPAGNode(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 431 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 255 of file SVFG.h.

    {
        return nodeNum;
    }

◆ hasActualINSVFGNodes()

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

inline

Has a SVFGNode.

Definition at line 187 of file SVFG.h.

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

◆ hasActualOUTSVFGNodes()

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

inline

Definition at line 192 of file SVFG.h.

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

◆ hasCallSiteChi()

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

inlineprotected

Definition at line 457 of file SVFG.h.

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

◆ hasCallSiteMu()

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

inlineprotected

Definition at line 461 of file SVFG.h.

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

◆ hasDef()

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

inlineprotected

Definition at line 360 of file SVFG.h.

    {
        return VFG::hasDef(pagNode);
    }

◆ hasDefSVFGNode()

bool SVF::SVFG::hasDefSVFGNode ( const PAGNode * pagNode ) const

inline

Given a pagNode, return whether it has definition site.

Definition at line 177 of file SVFG.h.

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

◆ hasFormalINSVFGNodes()

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

inline

Definition at line 197 of file SVFG.h.

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

◆ hasFormalOUTSVFGNodes()

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

inline

Definition at line 202 of file SVFG.h.

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

◆ hasFuncEntryChi()

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

inlineprotected

Has function for EntryCHI/RetMU/CallCHI/CallMU.

Definition at line 449 of file SVFG.h.

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

◆ hasFuncRetMu()

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

inlineprotected

Definition at line 453 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 SVFFunction * 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 207 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;
    }
 
    PAGEdge::PAGEdgeSetTy& stores = getPAGEdgeSet(PAGEdge::Store);
    for (PAGEdge::PAGEdgeSetTy::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 238 of file SVFG.h.

    {
        removeVFGEdge(edge);
    }

◆ removeSVFGNode()

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

inline

Remove a SVFGNode.

Definition at line 243 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 368 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 PAGNode *	pagNode,
		const SVFGNode *	node
	)

inlineprotected

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

Definition at line 352 of file SVFG.h.

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

◆ writeToFile()

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

virtual

Definition at line 47 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->getPAGEdge()));
            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->getPAGEdge()));
            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))
        {
            PTACallGraphEdge::CallInstSet callInstSet;
            mssa->getPTA()->getCallGraph()->getDirCallSitesInvokingCallee(formalIn->getFun(),callInstSet);
            for(PTACallGraphEdge::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))
        {
            PTACallGraphEdge::CallInstSet callInstSet;
            mssa->getPTA()->getCallGraph()->getDirCallSitesInvokingCallee(formalOut->getFun(),callInstSet);
            for(PTACallGraphEdge::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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ActualINSVFGNodeSet

◆ ActualOUTSVFGNodeSet

◆ CALLCHI

◆ CALLMU

◆ CallSiteToActualINsMapTy

◆ CallSiteToActualOUTsMapTy

◆ CHI

◆ CHISet

◆ ENTRYCHI

◆ FormalINSVFGNodeSet

◆ FormalOUTSVFGNodeSet

◆ FunctionToFormalINsMapTy

◆ FunctionToFormalOUTsMapTy

◆ LOADMU

◆ MSSAVarToDefMapTy

◆ MU

◆ MUSet

◆ PAGNodeToDefMapTy

◆ PHISet

◆ RETMU

◆ STORECHI

◆ SVFGNodeIDToNodeMapTy

Constructor & Destructor Documentation

◆ SVFG()

◆ ~SVFG()

Member Function Documentation

◆ addActualINSVFGNode()

◆ addActualOUTSVFGNode()

◆ addCallIndirectVFEdge()

◆ addDummyVersionPropSVFGNode()

◆ addFormalINSVFGNode()

◆ addFormalOUTSVFGNode()

◆ addInterIndirectVFCallEdge()

◆ addInterIndirectVFRetEdge()

◆ addIntraIndirectVFEdge()

◆ addIntraMSSAPHISVFGNode()

◆ addRetIndirectVFEdge()

◆ addSVFGEdge()

◆ addSVFGNode()

◆ addSVFGNodesForAddrTakenVars()

◆ addThreadMHPIndirectVFEdge()

◆ buildSVFG()

◆ clearMSSA()

◆ connectAInAndFIn()

◆ connectCallerAndCallee()

◆ connectFOutAndAOut()

◆ connectFromGlobalToProgEntry()

◆ connectIndirectSVFGEdges()

◆ destroy()

◆ dump()

◆ getActualINSVFGNodes()

◆ getActualOUTSVFGNodes()

◆ getDef() [1/2]

◆ getDef() [2/2]

◆ getDefSVFGNode()

◆ getFormalINSVFGNodes()

◆ getFormalOUTSVFGNodes()

◆ getInterVFEdgeAtIndCSFromAInToFIn()

◆ getInterVFEdgeAtIndCSFromAPToFP()

◆ getInterVFEdgeAtIndCSFromFOutToAOut()

◆ getInterVFEdgeAtIndCSFromFRToAR()

◆ getInterVFEdgesForIndirectCallSite()

◆ getMRVERFromString()

◆ getMSSA()

◆ getPTA()

◆ getStat()

◆ getSVFGNode()

◆ getSVFGNodeNum()

◆ hasActualINSVFGNodes()

◆ hasActualOUTSVFGNodes()

◆ hasCallSiteChi()

◆ hasCallSiteMu()