SVF Namespace Reference

for isBitcode More...

Namespaces
	cppUtil
	DOT
	GraphProgram
	LLVMUtil
	SVFUtil

Classes
class	BreakConstantGEPs
class	MergeFunctionRets
class	CHGBuilder
class	DCHEdge
class	DCHNode
class	DCHGraph
	Dwarf based CHG. More...
struct	GenericGraphTraits< SVF::DCHNode * >
struct	GenericGraphTraits< Inverse< SVF::DCHNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...
struct	GenericGraphTraits< SVF::DCHGraph * >
class	ICFGBuilder
class	LLVMLoopAnalysis
class	LLVMModuleSet
class	ObjTypeInference
class	SVFIRBuilder
class	SymbolTableBuilder
class	AbstractState
class	AbstractValue
class	AddressValue
class	ICFGWTO
class	IntervalValue
class	BoundedInt
	A class representing a bounded 64-bit integer. More...
class	BoundedDouble
class	RelationSolver
class	RelExeState
class	AbsExtAPI
	Handles external API calls and manages abstract states. More...
class	FILOWorkList
class	AEStat
	AEStat: Statistic for AE. More...
class	AbstractInterpretation
	AbstractInterpretation is same as Abstract Execution. More...
class	AEDetector
	Base class for all detectors. More...
class	AEException
	Exception class for handling errors in Abstract Execution. More...
class	BufOverflowDetector
	Detector for identifying buffer overflow issues. More...
class	CFGNormalizer
class	GrammarBase
class	CFGrammar
class	CFLFIFOWorkList
class	CFLAlias
class	POCRAlias
class	POCRHybrid
class	CFLBase
	CFL Client Base Class. More...
class	CFLGramGraphChecker
class	CFLGraphBuilder
class	AliasCFLGraphBuilder
	AliasCFLGraphBuilder: a CFLGraphBuilder specialized for handling aliasing. More...
class	VFCFLGraphBuilder
	VFCFLGraphBuilder: a CFLGraphBuilder specialized for handling value-flow. More...
class	CFLSolver
class	POCRSolver
	Solver Utilize CFLData. More...
class	POCRHybridSolver
	Solver Utilize Hybrid Representation of Graph. More...
class	CFLStat
class	CFLSVFGBuilder
class	CFLVF
class	GrammarBuilder
class	ContextDDA
class	DDAClient
class	FunptrDDAClient
class	AliasDDAClient
class	DDAPass
class	DDAStat
class	DDAVFSolver
class	FlowDDA
class	CDGEdge
class	CDGNode
class	CDG
struct	GenericGraphTraits< SVF::CDGNode * >
struct	GenericGraphTraits< Inverse< SVF::CDGNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse ICFGTraversal. More...
struct	GenericGraphTraits< SVF::CDG * >
struct	DOTGraphTraits< SVF::CDG * >
class	CFLEdge
class	CFLNode
class	CFLGraph
struct	GenericGraphTraits< SVF::CFLNode * >
struct	GenericGraphTraits< Inverse< SVF::CFLNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...
struct	GenericGraphTraits< SVF::CFLGraph * >
class	CommonCHGraph
	Common base for class hierarchy graph. Only implements what PointerAnalysis needs. More...
class	CHEdge
class	CHNode
class	CHGraph
struct	GenericGraphTraits< SVF::CHNode * >
struct	GenericGraphTraits< Inverse< SVF::CHNode * > >
struct	GenericGraphTraits< SVF::CHGraph * >
class	ConstraintGraph
struct	GenericGraphTraits< SVF::ConstraintNode * >
struct	GenericGraphTraits< Inverse< SVF::ConstraintNode * > >
	Inverse GenericGraphTraits specializations for Value flow node, it is used for inverse traversal. More...
struct	GenericGraphTraits< SVF::ConstraintGraph * >
class	ConstraintEdge
class	AddrCGEdge
class	CopyCGEdge
class	StoreCGEdge
class	LoadCGEdge
class	GepCGEdge
class	NormalGepCGEdge
class	VariantGepCGEdge
class	ConstraintNode
struct	DefaultDOTGraphTraits
struct	DOTGraphTraits
class	GenericGraphWriter
class	GenericGraphReader
class	GenericEdge
class	SVFBaseNode
class	GenericNode
class	GenericGraph
class	mapped_iter
struct	GenericGraphTraits< SVF::GenericNode< NodeTy, EdgeTy > * >
struct	GenericGraphTraits< Inverse< SVF::GenericNode< NodeTy, EdgeTy > * > >
struct	GenericGraphTraits< SVF::GenericGraph< NodeTy, EdgeTy > * >
class	GraphPrinter
struct	GenericGraphTraits
struct	Inverse
struct	GenericGraphTraits< Inverse< Inverse< T > > >
class	GraphWriter
class	ICFG
struct	GenericGraphTraits< SVF::ICFGNode * >
struct	GenericGraphTraits< Inverse< SVF::ICFGNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...
struct	GenericGraphTraits< SVF::ICFG * >
class	ICFGEdge
class	IntraCFGEdge
class	CallCFGEdge
class	RetCFGEdge
class	ICFGNode
class	GlobalICFGNode
class	IntraICFGNode
class	InterICFGNode
class	FunEntryICFGNode
class	FunExitICFGNode
class	CallICFGNode
class	RetICFGNode
class	ICFGStat
class	IRGraph
struct	GenericGraphTraits< SVF::SVFVar * >
struct	GenericGraphTraits< Inverse< SVF::SVFVar * > >
	Inverse GenericGraphTraits specializations for SVFIR node, it is used for inverse traversal. More...
struct	GenericGraphTraits< SVF::IRGraph * >
class	PTACallGraphEdge
class	PTACallGraphNode
class	PTACallGraph
struct	GenericGraphTraits< SVF::PTACallGraphNode * >
struct	GenericGraphTraits< Inverse< SVF::PTACallGraphNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...
struct	GenericGraphTraits< SVF::PTACallGraph * >
class	SCCDetection
class	SVFG
struct	GenericGraphTraits< SVF::SVFG * >
class	IndirectSVFGEdge
class	IntraIndSVFGEdge
class	CallIndSVFGEdge
class	RetIndSVFGEdge
class	ThreadMHPIndSVFGEdge
class	MRSVFGNode
class	FormalINSVFGNode
class	FormalOUTSVFGNode
class	ActualINSVFGNode
class	ActualOUTSVFGNode
class	MSSAPHISVFGNode
class	IntraMSSAPHISVFGNode
class	InterMSSAPHISVFGNode
class	DummyVersionPropSVFGNode
class	SVFGOPT
class	MemSSAStat
class	SVFGStat
class	ThreadForkEdge
class	ThreadJoinEdge
class	HareParForEdge
class	ThreadCallGraph
class	VFG
struct	GenericGraphTraits< SVF::VFGNode * >
struct	GenericGraphTraits< Inverse< SVF::VFGNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...
struct	GenericGraphTraits< SVF::VFG * >
class	VFGEdge
class	DirectSVFGEdge
class	IntraDirSVFGEdge
class	CallDirSVFGEdge
class	RetDirSVFGEdge
class	VFGNode
class	StmtVFGNode
class	LoadVFGNode
class	StoreVFGNode
class	CopyVFGNode
class	CmpVFGNode
class	BinaryOPVFGNode
class	UnaryOPVFGNode
class	BranchVFGNode
class	GepVFGNode
class	PHIVFGNode
class	IntraPHIVFGNode
class	AddrVFGNode
class	ArgumentVFGNode
class	ActualParmVFGNode
class	FormalParmVFGNode
class	ActualRetVFGNode
class	FormalRetVFGNode
class	InterPHIVFGNode
class	NullPtrVFGNode
class	WTO
class	WTONode
class	WTOCycle
class	WTOComponentVisitor
struct	has_nodetype
struct	has_nodetype< T, std::void_t< typename T::NodeType > >
struct	has_edgetype
struct	has_edgetype< T, std::void_t< typename T::EdgeType > >
class	WTOCycleDepth
class	WTOComponent
class	PTData
class	DiffPTData
class	DFPTData
class	VersionedPTData
class	AccessPath
class	CondVar
class	CondStdSet
class	CondPointsToSet
class	MutableDFPTData
class	MutablePTData
	PTData implemented using points-to sets which are created once and updated continuously. More...
class	MutableDiffPTData
	DiffPTData implemented with points-to sets which are updated continuously. More...
class	MutableIncDFPTData
	Incremental version of the mutable data-flow points-to data structure. More...
class	MutableVersionedPTData
class	PersistentPointsToCache
class	PersistentDFPTData
	DFPTData backed by a PersistentPointsToCache. More...
class	PersistentIncDFPTData
	Incremental version of the persistent data-flow points-to data structure. More...
class	PersistentVersionedPTData
class	PersistentPTData
	PTData backed by a PersistentPointsToCache. More...
class	PersistentDiffPTData
	DiffPTData implemented with a persistent points-to backing. More...
class	PointerAnalysis
class	BVDataPTAImpl
class	CondPTAImpl
class	PointsTo
class	SVFLoop
class	DistinctMRG
class	IntraDisjointMRG
class	InterDisjointMRG
class	MemRegion
	Memory Region class. More...
class	MRGenerator
class	MemSSA
class	MRVer
class	MSSAMU
class	LoadMU
class	CallMU
class	RetMU
class	MSSADEF
class	MSSACHI
class	StoreCHI
class	CallCHI
class	EntryCHI
class	MSSAPHI
class	SVFGBuilder
class	LockAnalysis
class	MHP
class	ForkJoinAnalysis
class	MTA
class	MTAStat
class	TCTEdge
class	TCTNode
class	TCT
struct	GenericGraphTraits< SVF::TCTNode * >
struct	GenericGraphTraits< Inverse< SVF::TCTNode * > >
	Inverse GenericGraphTraits specializations for Value flow node, it is used for inverse traversal. More...
struct	GenericGraphTraits< SVF::TCT * >
class	DoubleFreeChecker
class	FileChecker
class	LeakChecker
class	ProgSlice
class	SaberCheckerAPI
class	SaberCondAllocator
class	SaberSVFGBuilder
class	SrcSnkDDA
class	SrcSnkSolver
class	PAGBuilderFromFile
class	WriterPtrPool
	Bookkeeping class to keep track of the IDs of objects that doesn't have any ID. E.g., SVFValue, XXXEdge. More...
class	ICFGWriter
class	SVFModuleWriter
class	SVFIRWriter
struct	KindBaseHelper
	Type trait to get base type. Helper struct to detect inheritance from Node/Edge. More...
class	ReaderIDToObjMap
	Keeps a map from IDs to T objects, such as XXNode. More...
class	ReaderPtrPool
	Reverse of WriterPtrPool where T is object type without ID field. More...
class	SymbolTableInfoReader
class	ICFGReader
class	SVFModuleReader
class	SVFIRReader
class	SVFIR
class	SVFModule
class	SVFStmt
class	AssignStmt
class	AddrStmt
class	CopyStmt
class	StoreStmt
class	LoadStmt
class	GepStmt
class	CallPE
class	RetPE
class	MultiOpndStmt
class	PhiStmt
class	SelectStmt
class	CmpStmt
class	BinaryOPStmt
class	UnaryOPStmt
class	BranchStmt
class	TDForkPE
class	TDJoinPE
class	StInfo
class	SVFType
class	SVFPointerType
class	SVFIntegerType
class	SVFFunctionType
class	SVFStructType
class	SVFArrayType
class	SVFOtherType
struct	Hash< NodePair >
class	SVFLoopAndDomInfo
class	SVFValue
class	SVFFunction
class	SVFBasicBlock
class	SVFInstruction
class	SVFCallInst
class	SVFVirtualCallInst
class	SVFConstant
class	SVFGlobalValue
class	SVFArgument
class	SVFConstantData
class	SVFConstantInt
class	SVFConstantFP
class	SVFConstantNullPtr
class	SVFBlackHoleValue
class	SVFOtherValue
class	SVFMetadataAsValue
class	SVFVar
class	ValVar
class	ObjVar
class	GepValVar
class	GepObjVar
class	FIObjVar
class	RetPN
class	VarArgPN
class	DummyValVar
class	DummyObjVar
class	SymbolTableInfo
class	MemObj
class	ObjTypeInfo
class	Annotator
class	BitVector
class	CallGraphBuilder
class	CDGBuilder
class	CoreBitVector
struct	Hash< CoreBitVector >
class	CxtStmt
class	CxtThreadStmt
class	CxtThread
class	CxtProc
class	CxtThreadProc
class	DPItem
class	StmtDPItem
class	ContextCond
class	CxtStmtDPItem
class	CxtDPItem
class	ExtAPI
struct	Hash
	provide extra hash function for std::pair handling More...
struct	Hash< std::pair< S, T > >
class	GraphReachSolver
class	iter_facade_base
class	iter_adaptor_base
struct	pointee_iter
class	pointer_iterator
class	iter_range
class	NodeIDAllocator
class	Options
	Carries around command line options. More...
class	PTAStat
struct	TrailingZerosCounter
struct	PopulationCounter
struct	LeadingZerosCounter
struct	PopulationCounter< T, 8 >
struct	SparseBitVectorElement
class	SparseBitVector
class	SVFBugEvent
class	GenericBug
class	BufferOverflowBug
class	FullBufferOverflowBug
class	PartialBufferOverflowBug
class	NeverFreeBug
class	PartialLeakBug
class	DoubleFreeBug
class	FileNeverCloseBug
class	FilePartialCloseBug
class	FullNullPtrDereferenceBug
class	PartialNullPtrDereferenceBug
class	SVFBugReport
class	SVFStat
class	ThreadAPI
class	List
class	FIFOWorkList
class	Z3Expr
class	AndersenBase
class	Andersen
class	AndersenWaveDiff
class	AndersenSCD
class	AndersenSFR
class	CSC
class	FlowSensitive
class	Steensgaard
class	TypeAnalysis
class	VersionedFlowSensitive
class	WPAFSSolver
class	WPASCCSolver
class	WPAMinimumSolver
class	WPAPass
class	WPASolver
class	AndersenStat
class	FlowSensitiveStat
class	VersionedFlowSensitiveStat
struct	DOTGraphTraits< CFLGraph * >
struct	DOTGraphTraits< CHGraph * >
struct	DOTGraphTraits< ConstraintGraph * >
struct	DOTGraphTraits< ICFG * >
struct	DOTGraphTraits< IRGraph * >
struct	DOTGraphTraits< PTACallGraph * >
struct	DOTGraphTraits< SVFG * >
struct	DOTGraphTraits< VFG * >
struct	DOTGraphTraits< TCT * >

Typedefs
typedef llvm::LLVMContext	LLVMContext
typedef llvm::GlobalObject	GlobalObject
typedef llvm::Use	Use
typedef llvm::ModulePass	ModulePass
typedef llvm::IRBuilder	IRBuilder
typedef llvm::UnifyFunctionExitNodes	UnifyFunctionExitNodes
typedef llvm::Value	Value
	LLVM Basic classes. More...
typedef llvm::Type	Type
typedef llvm::Module	Module
typedef llvm::Function	Function
typedef llvm::BasicBlock	BasicBlock
typedef llvm::Instruction	Instruction
typedef llvm::GlobalValue	GlobalValue
typedef llvm::SMDiagnostic	SMDiagnostic
typedef llvm::BlockAddress	BlockAddress
typedef llvm::StructType	StructType
	LLVM types. More...
typedef llvm::ArrayType	ArrayType
typedef llvm::PointerType	PointerType
typedef llvm::IntegerType	IntegerType
typedef llvm::FunctionType	FunctionType
typedef llvm::MDString	MDString
typedef llvm::MetadataAsValue	MetadataAsValue
typedef llvm::StructLayout	StructLayout
typedef llvm::ConstantStruct	ConstantStruct
typedef llvm::MemoryLocation	MemoryLocation
typedef llvm::DataLayout	DataLayout
typedef llvm::NamedMDNode	NamedMDNode
	LLVM metadata and debug information. More...
typedef llvm::MDNode	MDNode
typedef llvm::DISubprogram	DISubprogram
typedef llvm::ConstantData	ConstantData
typedef llvm::ConstantAggregate	ConstantAggregate
typedef llvm::ConstantAggregateZero	ConstantAggregateZero
typedef llvm::ConstantDataSequential	ConstantDataSequential
typedef llvm::ConstantExpr	ConstantExpr
typedef llvm::ConstantDataArray	ConstantDataArray
typedef llvm::ConstantArray	ConstantArray
typedef llvm::Constant	Constant
typedef llvm::ConstantInt	ConstantInt
typedef llvm::ConstantFP	ConstantFP
typedef llvm::ConstantPointerNull	ConstantPointerNull
typedef llvm::GlobalAlias	GlobalAlias
typedef llvm::GlobalIFunc	GlobalIFunc
typedef llvm::GlobalVariable	GlobalVariable
typedef llvm::DominatorTree	DominatorTree
	LLVM Dominators. More...
typedef llvm::DomTreeNode	DomTreeNode
typedef llvm::DominanceFrontier	DominanceFrontier
typedef llvm::PostDominatorTree	PostDominatorTree
typedef llvm::DominanceFrontierBase< llvm::BasicBlock, false >	DominanceFrontierBase
typedef llvm::Loop	Loop
	LLVM Loop. More...
typedef llvm::LoopInfo	LoopInfo
typedef llvm::User	User
typedef llvm::Argument	Argument
typedef llvm::CallBase	CallBase
typedef llvm::CallInst	CallInst
typedef llvm::StoreInst	StoreInst
typedef llvm::LoadInst	LoadInst
typedef llvm::AllocaInst	AllocaInst
typedef llvm::AtomicCmpXchgInst	AtomicCmpXchgInst
typedef llvm::AtomicRMWInst	AtomicRMWInst
typedef llvm::BitCastInst	BitCastInst
typedef llvm::BranchInst	BranchInst
typedef llvm::SwitchInst	SwitchInst
typedef llvm::CallBrInst	CallBrInst
typedef llvm::ReturnInst	ReturnInst
typedef llvm::CastInst	CastInst
typedef llvm::CmpInst	CmpInst
typedef llvm::ExtractValueInst	ExtractValueInst
typedef llvm::ExtractElementInst	ExtractElementInst
typedef llvm::GetElementPtrInst	GetElementPtrInst
typedef llvm::InvokeInst	InvokeInst
typedef llvm::ShuffleVectorInst	ShuffleVectorInst
typedef llvm::PHINode	PHINode
typedef llvm::IntToPtrInst	IntToPtrInst
typedef llvm::InsertValueInst	InsertValueInst
typedef llvm::FenceInst	FenceInst
typedef llvm::FreezeInst	FreezeInst
typedef llvm::UnreachableInst	UnreachableInst
typedef llvm::InsertElementInst	InsertElementInst
typedef llvm::LandingPadInst	LandingPadInst
typedef llvm::ResumeInst	ResumeInst
typedef llvm::SelectInst	SelectInst
typedef llvm::VAArgInst	VAArgInst
typedef llvm::VACopyInst	VACopyInst
typedef llvm::VAEndInst	VAEndInst
typedef llvm::VAStartInst	VAStartInst
typedef llvm::BinaryOperator	BinaryOperator
typedef llvm::UnaryOperator	UnaryOperator
typedef llvm::UndefValue	UndefValue
typedef llvm::GEPOperator	GEPOperator
typedef std::pair< const BasicBlock *, const ConstantInt * >	SuccBBAndCondValPair
typedef std::vector< SuccBBAndCondValPair >	SuccBBAndCondValPairVec
typedef llvm::DIType	DIType
typedef llvm::DICompositeType	DICompositeType
typedef llvm::DIDerivedType	DIDerivedType
typedef llvm::DebugInfoFinder	DebugInfoFinder
typedef llvm::DISubroutineType	DISubroutineType
typedef llvm::DIBasicType	DIBasicType
typedef llvm::DISubrange	DISubrange
typedef llvm::DINode	DINode
typedef llvm::DINodeArray	DINodeArray
typedef llvm::DITypeRefArray	DITypeRefArray
typedef llvm::inst_iterator	inst_iterator
typedef llvm::const_inst_iterator	const_inst_iterator
typedef llvm::gep_type_iterator	gep_type_iterator
typedef llvm::bridge_gep_iterator	bridge_gep_iterator
typedef llvm::const_pred_iterator	const_pred_iterator
typedef llvm::ScalarEvolutionWrapperPass	ScalarEvolutionWrapperPass
typedef llvm::SCEVAddRecExpr	SCEVAddRecExpr
typedef llvm::SCEVConstant	SCEVConstant
typedef llvm::ScalarEvolution	ScalarEvolution
typedef llvm::SCEV	SCEV
typedef llvm::raw_fd_ostream	raw_fd_ostream
	LLVM outputs. More...
typedef llvm::VectorType	VectorType
typedef llvm::succ_const_iterator	succ_const_iterator
	LLVM Iterators. More...
typedef WTOComponent< ICFG >	ICFGWTOComp
typedef WTONode< ICFG >	ICFGSingletonWTO
typedef WTOCycle< ICFG >	ICFGCycleWTO
typedef GrammarBase::Symbol	Label
typedef CxtStmtDPItem< SVFGNode >	CxtLocDPItem
typedef StmtDPItem< SVFGNode >	LocDPItem
typedef GenericEdge< CDGNode >	GenericCDGEdgeTy
typedef GenericNode< CDGNode, CDGEdge >	GenericCDGNodeTy
typedef std::vector< std::pair< NodeID, NodeID > >	NodePairVector
typedef GenericGraph< CDGNode, CDGEdge >	GenericCDGTy
typedef GenericEdge< CFLNode >	GenericCFLEdgeTy
typedef GenericNode< CFLNode, CFLEdge >	GenericCFLNodeTy
typedef GenericGraph< CFLNode, CFLEdge >	GenericCFLGraphTy
	Edge-labeled graph for CFL Reachability analysis. More...
typedef Set< const SVFGlobalValue * >	VTableSet
typedef Set< const SVFFunction * >	VFunSet
typedef GenericEdge< CHNode >	GenericCHEdgeTy
typedef GenericNode< CHNode, CHEdge >	GenericCHNodeTy
typedef GenericGraph< CHNode, CHEdge >	GenericCHGraphTy
	class hierarchy graph More...
typedef GenericEdge< ConstraintNode >	GenericConsEdgeTy
typedef GenericNode< ConstraintNode, ConstraintEdge >	GenericConsNodeTy
typedef GenericGraph< ICFGNode, ICFGEdge >	GenericICFGTy
typedef GenericEdge< ICFGNode >	GenericICFGEdgeTy
typedef GenericNode< ICFGNode, ICFGEdge >	GenericICFGNodeTy
typedef SVFVar	PAGNode
typedef SVFStmt	PAGEdge
typedef GenericEdge< PTACallGraphNode >	GenericCallGraphEdgeTy
typedef GenericNode< PTACallGraphNode, PTACallGraphEdge >	GenericCallGraphNodeTy
typedef GenericGraph< PTACallGraphNode, PTACallGraphEdge >	GenericCallGraphTy
typedef VFGEdge	SVFGEdge
typedef VFGNode	SVFGNode
typedef ActualParmVFGNode	ActualParmSVFGNode
typedef ActualRetVFGNode	ActualRetSVFGNode
typedef FormalParmVFGNode	FormalParmSVFGNode
typedef FormalRetVFGNode	FormalRetSVFGNode
typedef NullPtrVFGNode	NullPtrSVFGNode
typedef StmtVFGNode	StmtSVFGNode
typedef AddrVFGNode	AddrSVFGNode
typedef CopyVFGNode	CopySVFGNode
typedef StoreVFGNode	StoreSVFGNode
typedef LoadVFGNode	LoadSVFGNode
typedef GepVFGNode	GepSVFGNode
typedef PHIVFGNode	PHISVFGNode
typedef IntraPHIVFGNode	IntraPHISVFGNode
typedef InterPHIVFGNode	InterPHISVFGNode
typedef GenericGraph< VFGNode, VFGEdge >	GenericVFGTy
typedef GenericEdge< VFGNode >	GenericVFGEdgeTy
typedef GenericNode< VFGNode, VFGEdge >	GenericVFGNodeTy
typedef NodeID	MRID
typedef NodeID	MRVERID
typedef NodeID	MRVERSION
typedef GenericEdge< TCTNode >	GenericTCTEdgeTy
typedef GenericNode< TCTNode, TCTEdge >	GenericTCTNodeTy
typedef GenericGraph< TCTNode, TCTEdge >	GenericThreadCreateTreeTy
typedef GraphReachSolver< SVFG *, CxtDPItem >	CFLSrcSnkSolver
using	GenericICFGWriter = GenericGraphWriter< ICFGNode, ICFGEdge >
using	IRGraphWriter = GenericGraphWriter< SVFVar, SVFStmt >
using	CHGraphWriter = GenericGraphWriter< CHNode, CHEdge >
template<typename T >
using	KindBaseT = typename KindBaseHelper< T >::type
using	GenericICFGReader = GenericGraphReader< ICFGNode, ICFGEdge >
using	CHGraphReader = GenericGraphReader< CHNode, CHEdge >
using	IRGraphReader = GenericGraphReader< SVFVar, SVFStmt >
typedef SVFIR	PAG
typedef GenericEdge< SVFVar >	GenericPAGEdgeTy
typedef SVF::GraphPrinter	GraphPrinter
	LLVM Aliases and constants. More...
typedef GenericNode< SVFVar, SVFStmt >	GenericPAGNodeTy
typedef CondVar< ContextCond >	CxtVar
typedef CondStdSet< CxtVar >	CxtPtSet
typedef std::ostream	OutStream
typedef unsigned	u32_t
typedef signed	s32_t
typedef unsigned long long	u64_t
typedef signed long long	s64_t
typedef unsigned char	u8_t
typedef signed char	s8_t
typedef unsigned short	u16_t
typedef signed short	s16_t
typedef u32_t	NodeID
typedef u32_t	EdgeID
typedef unsigned	SymID
typedef unsigned	CallSiteID
typedef unsigned	ThreadID
typedef s64_t	APOffset
typedef SparseBitVector	NodeBS
typedef unsigned	PointsToID
template<typename Key , typename Hash = Hash<Key>, typename KeyEqual = std::equal_to<Key>, typename Allocator = std::allocator<Key>>
using	Set = std::unordered_set< Key, Hash, KeyEqual, Allocator >
template<typename Key , typename Value , typename Hash = Hash<Key>, typename KeyEqual = std::equal_to<Key>, typename Allocator = std::allocator<std::pair<const Key, Value>>>
using	Map = std::unordered_map< Key, Value, Hash, KeyEqual, Allocator >
template<typename Key , typename Compare = std::less<Key>, typename Allocator = std::allocator<Key>>
using	OrderedSet = std::set< Key, Compare, Allocator >
template<typename Key , typename Value , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, Value>>>
using	OrderedMap = std::map< Key, Value, Compare, Allocator >
typedef std::pair< NodeID, NodeID >	NodePair
typedef OrderedSet< NodeID >	OrderedNodeSet
typedef Set< NodeID >	NodeSet
typedef Set< NodePair >	NodePairSet
typedef Map< NodePair, NodeID >	NodePairMap
typedef std::vector< NodeID >	NodeVector
typedef std::vector< EdgeID >	EdgeVector
typedef std::stack< NodeID >	NodeStack
typedef std::list< NodeID >	NodeList
typedef std::deque< NodeID >	NodeDeque
typedef NodeSet	EdgeSet
typedef std::vector< u32_t >	CallStrCxt
typedef unsigned	Version
typedef Set< Version >	VersionSet
typedef std::pair< NodeID, Version >	VersionedVar
typedef Set< VersionedVar >	VersionedVarSet
template<typename WrappedIteratorT , typename T1 = std::remove_reference_t<decltype( **std::declval<WrappedIteratorT>())>, typename T2 = std::add_pointer_t<T1>>
using	raw_pointer_iterator = pointer_iterator< pointee_iter< WrappedIteratorT, T1 >, T2 >
typedef WPASolver< ConstraintGraph * >	WPAConstraintSolver
typedef SCCDetection< ConstraintGraph * >	CGSCC
typedef WPAFSSolver< SVFG * >	WPASVFGFSSolver

Enumerations
enum class	BuildDirection { plain , bidirection }
enum	ModRefInfo { ModRef , Ref , Mod , NoModRef }
enum	AliasResult { NoAlias , MayAlias , MustAlias , PartialAlias }
enum	ZeroBehavior { ZB_Undefined , ZB_Max , ZB_Width }
	The behavior an operation has on an input of 0. More...

Functions
IntervalValue	operator+ (const IntervalValue &lhs, const IntervalValue &rhs)
	Add IntervalValues. More...
IntervalValue	operator- (const IntervalValue &lhs, const IntervalValue &rhs)
	Subtract IntervalValues. More...
IntervalValue	operator* (const IntervalValue &lhs, const IntervalValue &rhs)
	Multiply IntervalValues. More...
IntervalValue	operator/ (const IntervalValue &lhs, const IntervalValue &rhs)
	Divide IntervalValues. More...
IntervalValue	operator% (const IntervalValue &lhs, const IntervalValue &rhs)
	Divide IntervalValues. More...
IntervalValue	operator> (const IntervalValue &lhs, const IntervalValue &rhs)
IntervalValue	operator< (const IntervalValue &lhs, const IntervalValue &rhs)
IntervalValue	operator>= (const IntervalValue &lhs, const IntervalValue &rhs)
IntervalValue	operator<= (const IntervalValue &lhs, const IntervalValue &rhs)
IntervalValue	operator<< (const IntervalValue &lhs, const IntervalValue &rhs)
	Left binary shift of IntervalValues. More...
IntervalValue	operator>> (const IntervalValue &lhs, const IntervalValue &rhs)
	Left binary shift of IntervalValues. More...
IntervalValue	operator& (const IntervalValue &lhs, const IntervalValue &rhs)
	Bitwise AND of IntervalValues. More...
IntervalValue	operator| (const IntervalValue &lhs, const IntervalValue &rhs)
	Bitwise OR of IntervalValues. More...
IntervalValue	operator^ (const IntervalValue &lhs, const IntervalValue &rhs)
	Bitwise XOR of IntervalValues. More...
std::ostream &	operator<< (std::ostream &o, const IntervalValue &IntervalValue)
	Write an IntervalValue on a stream. More...
template<class ItTy , class FuncTy >
mapped_iter< ItTy, FuncTy >	map_iter (ItTy I, FuncTy F)
template<class GraphType >
iter_range< typename GenericGraphTraits< GraphType >::nodes_iterator >	nodes (const GraphType &G)
template<class GraphType >
iter_range< typename GenericGraphTraits< Inverse< GraphType > >::nodes_iterator >	inverse_nodes (const GraphType &G)
template<class GraphType >
iter_range< typename GenericGraphTraits< GraphType >::ChildIteratorType >	children (const typename GenericGraphTraits< GraphType >::NodeRef &G)
template<class GraphType >
iter_range< typename GenericGraphTraits< Inverse< GraphType > >::ChildIteratorType >	inverse_children (const typename GenericGraphTraits< GraphType >::NodeRef &G)
template<class GraphType >
iter_range< typename GenericGraphTraits< GraphType >::ChildEdgeIteratorType >	children_edges (const typename GenericGraphTraits< GraphType >::NodeRef &G)
template<typename GraphType >
std::ofstream &	WriteGraph (std::ofstream &O, const GraphType &G, bool ShortNames=false)
template<typename GraphType >
std::string	WriteGraph (const GraphType &G, bool ShortNames=false, std::string Filename="")
template<typename GraphType >
void	ViewGraph (const GraphType &G, const std::string &name, bool ShortNames=false, GraphProgram::Name Program=GraphProgram::DOT)
PointsTo	operator| (const PointsTo &lhs, const PointsTo &rhs)
	Returns a new lhs | rhs. More...
PointsTo	operator& (const PointsTo &lhs, const PointsTo &rhs)
	Returns a new lhs & rhs. More...
PointsTo	operator- (const PointsTo &lhs, const PointsTo &rhs)
	Returns a new lhs - rhs. More...
std::ostream &	operator<< (std::ostream &o, const MRVer &mrver)
bool	jsonIsBool (const cJSON *item)
bool	jsonIsBool (const cJSON *item, bool &flag)
bool	jsonIsNumber (const cJSON *item)
bool	jsonIsString (const cJSON *item)
bool	jsonIsNullId (const cJSON *item)
bool	jsonIsArray (const cJSON *item)
bool	jsonIsMap (const cJSON *item)
bool	jsonIsObject (const cJSON *item)
bool	jsonKeyEquals (const cJSON *item, const char *key)
std::pair< const cJSON *, const cJSON * >	jsonUnpackPair (const cJSON *item)
double	jsonGetNumber (const cJSON *item)
cJSON *	jsonCreateNullId ()
cJSON *	jsonCreateObject ()
cJSON *	jsonCreateArray ()
cJSON *	jsonCreateString (const char *str)
cJSON *	jsonCreateIndex (size_t index)
cJSON *	jsonCreateBool (bool flag)
cJSON *	jsonCreateNumber (double num)
bool	jsonAddPairToMap (cJSON *obj, cJSON *key, cJSON *value)
bool	jsonAddItemToObject (cJSON *obj, const char *name, cJSON *item)
bool	jsonAddItemToArray (cJSON *array, cJSON *item)
bool	jsonAddNumberToObject (cJSON *obj, const char *name, double number)
	Helper function to write a number to a JSON object. More...
bool	jsonAddStringToObject (cJSON *obj, const char *name, const char *str)
bool	jsonAddStringToObject (cJSON *obj, const char *name, const std::string &s)
	KIND_BASE (SVFType, getKind)
	KIND_BASE (SVFValue, getKind)
	KIND_BASE (SVFVar, getNodeKind)
	KIND_BASE (SVFStmt, getEdgeKind)
	KIND_BASE (ICFGNode, getNodeKind)
	KIND_BASE (ICFGEdge, getEdgeKind)
	KIND_BASE (CHNode, getNodeKind)
	KIND_BASE (CHEdge, getEdgeKind)
std::ostream &	operator<< (std::ostream &os, const SVFType &type)
std::string	dumpLLVMValue (const SVFValue *svfValue)
template<typename F , typename S >
OutStream &	operator<< (OutStream &o, const std::pair< F, S > &var)
template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
iter_range< pointee_iter< WrappedIteratorT > >	make_pointee_range (RangeT &&Range)
template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
iter_range< pointer_iterator< WrappedIteratorT > >	make_pointer_range (RangeT &&Range)
template<class T >
iter_range< T >	make_range (T x, T y)
template<typename T >
iter_range< T >	make_range (std::pair< T, T > p)
template<typename T >
unsigned	countTrailingZeros (T Val, ZeroBehavior ZB=ZB_Width)
template<typename T >
unsigned	countLeadingZeros (T Val, ZeroBehavior ZB=ZB_Width)
template<typename T >
unsigned	countPopulation (T Value)
template<unsigned ElementSize>
bool	operator|= (SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > *RHS)
template<unsigned ElementSize>
bool	operator|= (SparseBitVector< ElementSize > *LHS, const SparseBitVector< ElementSize > &RHS)
template<unsigned ElementSize>
bool	operator&= (SparseBitVector< ElementSize > *LHS, const SparseBitVector< ElementSize > &RHS)
template<unsigned ElementSize>
bool	operator&= (SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > *RHS)
template<unsigned ElementSize>
SparseBitVector< ElementSize >	operator| (const SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > &RHS)
template<unsigned ElementSize>
SparseBitVector< ElementSize >	operator& (const SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > &RHS)
template<unsigned ElementSize>
SparseBitVector< ElementSize >	operator- (const SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > &RHS)
template<unsigned ElementSize>
void	dump (const SparseBitVector< ElementSize > &LHS, std::ostream &out)
SVFType *	createSVFType (SVFType::GNodeK kind, bool isSingleValTy)
static SVFValue *	createSVFValue (SVFValue::GNodeK kind, const SVFType *type, std::string &&name)
template<typename SmallNumberType >
static void	readSmallNumber (const cJSON *obj, SmallNumberType &val)
template<typename BigNumberType , typename CStrToVal >
static void	readBigNumber (const cJSON *obj, BigNumberType &val, CStrToVal conv)
cJSON *	jsonCreateMap ()
	__attribute__ ((weak)) std

Detailed Description

for isBitcode

For a more detailed explanation of how External APIs are handled in SVF, please refer to the SVF Wiki: https://github.com/SVF-tools/SVF/wiki/Handling-External-APIs-with-extapi.c.

Contains abstract classes for: PTData: basic points-to data structure derived by all others. DiffPTData: PTData which only propagates new changes, not entire points-to sets. DFPTData: flow-sensitive PTData as defined by Hardekopf and Lin (CGO '11).

Hierarchy (square brackets indicate abstract class):

  +------------> [PTData] <----------------+---------------------+
  |                 ^                      |                     |
  |                 |                      |                     |

MutablePTData [DiffPTData] [DFPTData] [VersionedPTData] ^ ^ ^ | | | MutableDiffPTData MutableDFPTData MutableVersionedPTData ^ | MutableIncDFPTData

PTData (AbstractPointsToDS.h) implementations with a mutable backend. Each Key is given a points-to set which is itself updated till the analysis terminates.

PTData (AbstractPointsToDS.h) implementations with a persistent backend. Each Key is given a cheap points-to ID which refers to some real points-to set.

GraphTraits specialization for constraint graph

GraphTraits specialization

Typedef Documentation

ActualParmSVFGNode

typedef ActualParmVFGNode SVF::ActualParmSVFGNode

Definition at line 44 of file SVFG.h.

ActualRetSVFGNode

typedef ActualRetVFGNode SVF::ActualRetSVFGNode

Definition at line 45 of file SVFG.h.

AddrSVFGNode

typedef AddrVFGNode SVF::AddrSVFGNode

Definition at line 51 of file SVFG.h.

AllocaInst

typedef llvm::AllocaInst SVF::AllocaInst

Definition at line 150 of file BasicTypes.h.

APOffset

typedef s64_t SVF::APOffset

Definition at line 60 of file GeneralType.h.

Argument

typedef llvm::Argument SVF::Argument

Definition at line 145 of file BasicTypes.h.

ArrayType

typedef llvm::ArrayType SVF::ArrayType

Definition at line 95 of file BasicTypes.h.

AtomicCmpXchgInst

typedef llvm::AtomicCmpXchgInst SVF::AtomicCmpXchgInst

Definition at line 151 of file BasicTypes.h.

AtomicRMWInst

typedef llvm::AtomicRMWInst SVF::AtomicRMWInst

Definition at line 152 of file BasicTypes.h.

BasicBlock

typedef llvm::BasicBlock SVF::BasicBlock

Definition at line 86 of file BasicTypes.h.

BinaryOperator

typedef llvm::BinaryOperator SVF::BinaryOperator

Definition at line 179 of file BasicTypes.h.

BitCastInst

typedef llvm::BitCastInst SVF::BitCastInst

Definition at line 153 of file BasicTypes.h.

BlockAddress

typedef llvm::BlockAddress SVF::BlockAddress

Definition at line 91 of file BasicTypes.h.

BranchInst

typedef llvm::BranchInst SVF::BranchInst

Definition at line 154 of file BasicTypes.h.

bridge_gep_iterator

typedef llvm::bridge_gep_iterator SVF::bridge_gep_iterator

Definition at line 252 of file BasicTypes.h.

CallBase

typedef llvm::CallBase SVF::CallBase

Definition at line 146 of file BasicTypes.h.

CallBrInst

typedef llvm::CallBrInst SVF::CallBrInst

Definition at line 156 of file BasicTypes.h.

CallInst

typedef llvm::CallInst SVF::CallInst

Definition at line 147 of file BasicTypes.h.

CallSiteID

typedef unsigned SVF::CallSiteID

Definition at line 58 of file GeneralType.h.

CallStrCxt

typedef std::vector<u32_t> SVF::CallStrCxt

Definition at line 122 of file GeneralType.h.

CastInst

typedef llvm::CastInst SVF::CastInst

Definition at line 158 of file BasicTypes.h.

CFLSrcSnkSolver

typedef GraphReachSolver<SVFG*,CxtDPItem> SVF::CFLSrcSnkSolver

Definition at line 49 of file SrcSnkDDA.h.

CGSCC

typedef SCCDetection<ConstraintGraph *> SVF::CGSCC

Definition at line 44 of file CSC.h.

CHGraphReader

using SVF::CHGraphReader = typedef GenericGraphReader<CHNode, CHEdge>

Definition at line 932 of file SVFFileSystem.h.

CHGraphWriter

using SVF::CHGraphWriter = typedef GenericGraphWriter<CHNode, CHEdge>

Definition at line 343 of file SVFFileSystem.h.

CmpInst

typedef llvm::CmpInst SVF::CmpInst

Definition at line 159 of file BasicTypes.h.

const_inst_iterator

typedef llvm::const_inst_iterator SVF::const_inst_iterator

Definition at line 250 of file BasicTypes.h.

const_pred_iterator

typedef llvm::const_pred_iterator SVF::const_pred_iterator

Definition at line 254 of file BasicTypes.h.

Constant

typedef llvm::Constant SVF::Constant

Definition at line 124 of file BasicTypes.h.

ConstantAggregate

typedef llvm::ConstantAggregate SVF::ConstantAggregate

Definition at line 117 of file BasicTypes.h.

ConstantAggregateZero

typedef llvm::ConstantAggregateZero SVF::ConstantAggregateZero

Definition at line 118 of file BasicTypes.h.

ConstantArray

typedef llvm::ConstantArray SVF::ConstantArray

Definition at line 123 of file BasicTypes.h.

ConstantData

typedef llvm::ConstantData SVF::ConstantData

Definition at line 116 of file BasicTypes.h.

ConstantDataArray

typedef llvm::ConstantDataArray SVF::ConstantDataArray

Definition at line 121 of file BasicTypes.h.

ConstantDataSequential

typedef llvm::ConstantDataSequential SVF::ConstantDataSequential

Definition at line 119 of file BasicTypes.h.

ConstantExpr

typedef llvm::ConstantExpr SVF::ConstantExpr

Definition at line 120 of file BasicTypes.h.

ConstantFP

typedef llvm::ConstantFP SVF::ConstantFP

Definition at line 126 of file BasicTypes.h.

ConstantInt

typedef llvm::ConstantInt SVF::ConstantInt

Definition at line 125 of file BasicTypes.h.

ConstantPointerNull

typedef llvm::ConstantPointerNull SVF::ConstantPointerNull

Definition at line 127 of file BasicTypes.h.

ConstantStruct

typedef llvm::ConstantStruct SVF::ConstantStruct

Definition at line 106 of file BasicTypes.h.

CopySVFGNode

typedef CopyVFGNode SVF::CopySVFGNode

Definition at line 52 of file SVFG.h.

CxtLocDPItem

typedef CxtStmtDPItem<SVFGNode> SVF::CxtLocDPItem

Definition at line 49 of file ContextDDA.h.

CxtPtSet

typedef CondStdSet<CxtVar> SVF::CxtPtSet

Definition at line 386 of file DPItem.h.

CxtVar

typedef CondVar< ContextCond > SVF::CxtVar

Context-, flow- sensitive DPItem

Context DPItem

Definition at line 385 of file DPItem.h.

DataLayout

typedef llvm::DataLayout SVF::DataLayout

Definition at line 108 of file BasicTypes.h.

DebugInfoFinder

typedef llvm::DebugInfoFinder SVF::DebugInfoFinder

Definition at line 239 of file BasicTypes.h.

DIBasicType

typedef llvm::DIBasicType SVF::DIBasicType

Definition at line 241 of file BasicTypes.h.

DICompositeType

typedef llvm::DICompositeType SVF::DICompositeType

Definition at line 237 of file BasicTypes.h.

DIDerivedType

typedef llvm::DIDerivedType SVF::DIDerivedType

Definition at line 238 of file BasicTypes.h.

DINode

typedef llvm::DINode SVF::DINode

Definition at line 243 of file BasicTypes.h.

DINodeArray

typedef llvm::DINodeArray SVF::DINodeArray

Definition at line 244 of file BasicTypes.h.

DISubprogram

typedef llvm::DISubprogram SVF::DISubprogram

Definition at line 113 of file BasicTypes.h.

DISubrange

typedef llvm::DISubrange SVF::DISubrange

Definition at line 242 of file BasicTypes.h.

DISubroutineType

typedef llvm::DISubroutineType SVF::DISubroutineType

Definition at line 240 of file BasicTypes.h.

DIType

typedef llvm::DIType SVF::DIType

Definition at line 236 of file BasicTypes.h.

DITypeRefArray

typedef llvm::DITypeRefArray SVF::DITypeRefArray

Definition at line 245 of file BasicTypes.h.

DominanceFrontier

typedef llvm::DominanceFrontier SVF::DominanceFrontier

Definition at line 135 of file BasicTypes.h.

DominanceFrontierBase

typedef llvm::DominanceFrontierBase<llvm::BasicBlock, false> SVF::DominanceFrontierBase

Definition at line 137 of file BasicTypes.h.

DominatorTree

typedef llvm::DominatorTree SVF::DominatorTree

LLVM Dominators.

Definition at line 133 of file BasicTypes.h.

DomTreeNode

typedef llvm::DomTreeNode SVF::DomTreeNode

Definition at line 134 of file BasicTypes.h.

EdgeID

typedef u32_t SVF::EdgeID

Definition at line 56 of file GeneralType.h.

EdgeSet

typedef NodeSet SVF::EdgeSet

Definition at line 121 of file GeneralType.h.

EdgeVector

typedef std::vector<EdgeID> SVF::EdgeVector

Definition at line 117 of file GeneralType.h.

ExtractElementInst

typedef llvm::ExtractElementInst SVF::ExtractElementInst

Definition at line 161 of file BasicTypes.h.

ExtractValueInst

typedef llvm::ExtractValueInst SVF::ExtractValueInst

Definition at line 160 of file BasicTypes.h.

FenceInst

typedef llvm::FenceInst SVF::FenceInst

Definition at line 168 of file BasicTypes.h.

FormalParmSVFGNode

typedef FormalParmVFGNode SVF::FormalParmSVFGNode

Definition at line 46 of file SVFG.h.

FormalRetSVFGNode

typedef FormalRetVFGNode SVF::FormalRetSVFGNode

Definition at line 47 of file SVFG.h.

FreezeInst

typedef llvm::FreezeInst SVF::FreezeInst

Definition at line 169 of file BasicTypes.h.

Function

typedef llvm::Function SVF::Function

Definition at line 85 of file BasicTypes.h.

FunctionType

typedef llvm::FunctionType SVF::FunctionType

Definition at line 98 of file BasicTypes.h.

GenericCallGraphEdgeTy

typedef GenericEdge<PTACallGraphNode> SVF::GenericCallGraphEdgeTy

Definition at line 50 of file PTACallGraph.h.

GenericCallGraphNodeTy

typedef GenericNode<PTACallGraphNode, PTACallGraphEdge> SVF::GenericCallGraphNodeTy

Definition at line 173 of file PTACallGraph.h.

GenericCallGraphTy

typedef GenericGraph<PTACallGraphNode, PTACallGraphEdge> SVF::GenericCallGraphTy

Pointer Analysis Call Graph used internally for various pointer analysis

Definition at line 240 of file PTACallGraph.h.

GenericCDGEdgeTy

typedef GenericEdge<CDGNode> SVF::GenericCDGEdgeTy

Definition at line 40 of file CDG.h.

GenericCDGNodeTy

typedef GenericNode<CDGNode, CDGEdge> SVF::GenericCDGNodeTy

Definition at line 87 of file CDG.h.

GenericCDGTy

typedef GenericGraph<CDGNode, CDGEdge> SVF::GenericCDGTy

Definition at line 140 of file CDG.h.

GenericCFLEdgeTy

typedef GenericEdge<CFLNode> SVF::GenericCFLEdgeTy

Definition at line 45 of file CFLGraph.h.

GenericCFLGraphTy

typedef GenericGraph<CFLNode,CFLEdge> SVF::GenericCFLGraphTy

Edge-labeled graph for CFL Reachability analysis.

Definition at line 172 of file CFLGraph.h.

GenericCFLNodeTy

typedef GenericNode<CFLNode,CFLEdge> SVF::GenericCFLNodeTy

Definition at line 75 of file CFLGraph.h.

GenericCHEdgeTy

typedef GenericEdge<CHNode> SVF::GenericCHEdgeTy

Definition at line 77 of file CHG.h.

GenericCHGraphTy

typedef GenericGraph<CHNode, CHEdge> SVF::GenericCHGraphTy

class hierarchy graph

Definition at line 232 of file CHG.h.

GenericCHNodeTy

typedef GenericNode<CHNode, CHEdge> SVF::GenericCHNodeTy

Definition at line 107 of file CHG.h.

GenericConsEdgeTy

typedef GenericEdge<ConstraintNode> SVF::GenericConsEdgeTy

Self-defined edge for constraint resolution including add/remove/re-target, but all the operations do not affect original SVFIR Edges

Definition at line 47 of file ConsGEdge.h.

GenericConsNodeTy

typedef GenericNode<ConstraintNode,ConstraintEdge> SVF::GenericConsNodeTy

Constraint node

Definition at line 39 of file ConsGNode.h.

GenericICFGEdgeTy

typedef GenericEdge<ICFGNode> SVF::GenericICFGEdgeTy

Interprocedural control-flow and value-flow edge, representing the control- and value-flow dependence between two nodes

Definition at line 43 of file ICFGEdge.h.

GenericICFGNodeTy

typedef GenericNode<ICFGNode, ICFGEdge> SVF::GenericICFGNodeTy

Interprocedural control-flow graph node, representing different kinds of program statements including top-level pointers (ValVar) and address-taken objects (ObjVar)

Definition at line 52 of file ICFGNode.h.

GenericICFGReader

using SVF::GenericICFGReader = typedef GenericGraphReader<ICFGNode, ICFGEdge>

Definition at line 931 of file SVFFileSystem.h.

GenericICFGTy

typedef GenericGraph<ICFGNode,ICFGEdge> SVF::GenericICFGTy

Interprocedural Control-Flow Graph (ICFG)

Definition at line 46 of file ICFG.h.

GenericICFGWriter

using SVF::GenericICFGWriter = typedef GenericGraphWriter<ICFGNode, ICFGEdge>

Definition at line 324 of file SVFFileSystem.h.

GenericPAGEdgeTy

typedef GenericEdge<SVFVar> SVF::GenericPAGEdgeTy

Definition at line 50 of file SVFStatements.h.

GenericPAGNodeTy

typedef GenericNode<SVFVar, SVFStmt> SVF::GenericPAGNodeTy

Definition at line 44 of file SVFVariables.h.

GenericTCTEdgeTy

typedef GenericEdge<TCTNode> SVF::GenericTCTEdgeTy

Definition at line 49 of file TCT.h.

GenericTCTNodeTy

typedef GenericNode<TCTNode, TCTEdge> SVF::GenericTCTNodeTy

Definition at line 84 of file TCT.h.

GenericThreadCreateTreeTy

typedef GenericGraph<TCTNode, TCTEdge> SVF::GenericThreadCreateTreeTy

Pointer Analysis Call Graph used internally for various pointer analysis

Definition at line 152 of file TCT.h.

GenericVFGEdgeTy

typedef GenericEdge<VFGNode> SVF::GenericVFGEdgeTy

Interprocedural control-flow and value-flow edge, representing the control- and value-flow dependence between two nodes

Definition at line 43 of file VFGEdge.h.

GenericVFGNodeTy

typedef GenericNode<VFGNode,VFGEdge> SVF::GenericVFGNodeTy

Interprocedural control-flow graph node, representing different kinds of program statements including top-level pointers (ValVar) and address-taken objects (ObjVar)

Definition at line 45 of file VFGNode.h.

GenericVFGTy

typedef GenericGraph<VFGNode,VFGEdge> SVF::GenericVFGTy

Value Flow Graph (VFG)

Definition at line 49 of file VFG.h.

gep_type_iterator

typedef llvm::gep_type_iterator SVF::gep_type_iterator

Definition at line 251 of file BasicTypes.h.

GEPOperator

typedef llvm::GEPOperator SVF::GEPOperator

Definition at line 182 of file BasicTypes.h.

GepSVFGNode

typedef GepVFGNode SVF::GepSVFGNode

Definition at line 55 of file SVFG.h.

GetElementPtrInst

typedef llvm::GetElementPtrInst SVF::GetElementPtrInst

Definition at line 162 of file BasicTypes.h.

GlobalAlias

typedef llvm::GlobalAlias SVF::GlobalAlias

Definition at line 128 of file BasicTypes.h.

GlobalIFunc

typedef llvm::GlobalIFunc SVF::GlobalIFunc

Definition at line 129 of file BasicTypes.h.

GlobalObject

typedef llvm::GlobalObject SVF::GlobalObject

Definition at line 71 of file BasicTypes.h.

GlobalValue

typedef llvm::GlobalValue SVF::GlobalValue

Definition at line 88 of file BasicTypes.h.

GlobalVariable

typedef llvm::GlobalVariable SVF::GlobalVariable

Definition at line 130 of file BasicTypes.h.

GraphPrinter

typedef SVF::GraphPrinter SVF::GraphPrinter

LLVM Aliases and constants.

Definition at line 41 of file SVFValue.h.

ICFGCycleWTO

typedef WTOCycle<ICFG> SVF::ICFGCycleWTO

Definition at line 45 of file ICFGWTO.h.

ICFGSingletonWTO

typedef WTONode<ICFG> SVF::ICFGSingletonWTO

Definition at line 44 of file ICFGWTO.h.

ICFGWTOComp

typedef WTOComponent<ICFG> SVF::ICFGWTOComp

Definition at line 43 of file ICFGWTO.h.

InsertElementInst

typedef llvm::InsertElementInst SVF::InsertElementInst

Definition at line 171 of file BasicTypes.h.

InsertValueInst

typedef llvm::InsertValueInst SVF::InsertValueInst

Definition at line 167 of file BasicTypes.h.

inst_iterator

typedef llvm::inst_iterator SVF::inst_iterator

Definition at line 249 of file BasicTypes.h.

Instruction

typedef llvm::Instruction SVF::Instruction

Definition at line 87 of file BasicTypes.h.

IntegerType

typedef llvm::IntegerType SVF::IntegerType

Definition at line 97 of file BasicTypes.h.

InterPHISVFGNode

typedef InterPHIVFGNode SVF::InterPHISVFGNode

Definition at line 58 of file SVFG.h.

IntraPHISVFGNode

typedef IntraPHIVFGNode SVF::IntraPHISVFGNode

Definition at line 57 of file SVFG.h.

IntToPtrInst

typedef llvm::IntToPtrInst SVF::IntToPtrInst

Definition at line 166 of file BasicTypes.h.

InvokeInst

typedef llvm::InvokeInst SVF::InvokeInst

Definition at line 163 of file BasicTypes.h.

IRBuilder

typedef llvm::IRBuilder SVF::IRBuilder

Definition at line 74 of file BasicTypes.h.

IRGraphReader

using SVF::IRGraphReader = typedef GenericGraphReader<SVFVar, SVFStmt>

Definition at line 933 of file SVFFileSystem.h.

IRGraphWriter

using SVF::IRGraphWriter = typedef GenericGraphWriter<SVFVar, SVFStmt>

Definition at line 342 of file SVFFileSystem.h.

KindBaseT

template<typename T >

using SVF::KindBaseT = typedef typename KindBaseHelper<T>::type

Definition at line 679 of file SVFFileSystem.h.

Label

typedef GrammarBase::Symbol SVF::Label

Definition at line 41 of file CFLSolver.h.

LandingPadInst

typedef llvm::LandingPadInst SVF::LandingPadInst

Definition at line 172 of file BasicTypes.h.

LLVMContext

typedef llvm::LLVMContext SVF::LLVMContext

Definition at line 70 of file BasicTypes.h.

LoadInst

typedef llvm::LoadInst SVF::LoadInst

Definition at line 149 of file BasicTypes.h.

LoadSVFGNode

typedef LoadVFGNode SVF::LoadSVFGNode

Definition at line 54 of file SVFG.h.

LocDPItem

typedef StmtDPItem<SVFGNode> SVF::LocDPItem

Definition at line 48 of file FlowDDA.h.

Loop

typedef llvm::Loop SVF::Loop

LLVM Loop.

Definition at line 140 of file BasicTypes.h.

LoopInfo

typedef llvm::LoopInfo SVF::LoopInfo

Definition at line 141 of file BasicTypes.h.

Map

template<typename Key , typename Value , typename Hash = Hash<Key>, typename KeyEqual = std::equal_to<Key>, typename Allocator = std::allocator<std::pair<const Key, Value>>>

using SVF::Map = typedef std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>

Definition at line 101 of file GeneralType.h.

MDNode

typedef llvm::MDNode SVF::MDNode

Definition at line 112 of file BasicTypes.h.

MDString

typedef llvm::MDString SVF::MDString

Definition at line 101 of file BasicTypes.h.

MemoryLocation

typedef llvm::MemoryLocation SVF::MemoryLocation

Definition at line 107 of file BasicTypes.h.

MetadataAsValue

typedef llvm::MetadataAsValue SVF::MetadataAsValue

Definition at line 102 of file BasicTypes.h.

Module

typedef llvm::Module SVF::Module

Definition at line 84 of file BasicTypes.h.

ModulePass

typedef llvm::ModulePass SVF::ModulePass

Definition at line 73 of file BasicTypes.h.

MRID

typedef NodeID SVF::MRID

Definition at line 50 of file MemRegion.h.

MRVERID

typedef NodeID SVF::MRVERID

Definition at line 51 of file MemRegion.h.

MRVERSION

typedef NodeID SVF::MRVERSION

Definition at line 52 of file MemRegion.h.

NamedMDNode

typedef llvm::NamedMDNode SVF::NamedMDNode

LLVM metadata and debug information.

Definition at line 111 of file BasicTypes.h.

NodeBS

typedef SparseBitVector SVF::NodeBS

Definition at line 62 of file GeneralType.h.

NodeDeque

typedef std::deque<NodeID> SVF::NodeDeque

Definition at line 120 of file GeneralType.h.

NodeID

typedef u32_t SVF::NodeID

Definition at line 55 of file GeneralType.h.

NodeList

typedef std::list<NodeID> SVF::NodeList

Definition at line 119 of file GeneralType.h.

NodePair

typedef std::pair<NodeID, NodeID> SVF::NodePair

Definition at line 111 of file GeneralType.h.

NodePairMap

typedef Map<NodePair, NodeID> SVF::NodePairMap

Definition at line 115 of file GeneralType.h.

NodePairSet

typedef Set<NodePair> SVF::NodePairSet

Definition at line 114 of file GeneralType.h.

NodePairVector

typedef std::vector<std::pair<NodeID, NodeID> > SVF::NodePairVector

Definition at line 139 of file CDG.h.

NodeSet

typedef Set<NodeID> SVF::NodeSet

Definition at line 113 of file GeneralType.h.

NodeStack

typedef std::stack<NodeID> SVF::NodeStack

Definition at line 118 of file GeneralType.h.

NodeVector

typedef std::vector<NodeID> SVF::NodeVector

Definition at line 116 of file GeneralType.h.

NullPtrSVFGNode

typedef NullPtrVFGNode SVF::NullPtrSVFGNode

Definition at line 49 of file SVFG.h.

OrderedMap

template<typename Key , typename Value , typename Compare = std::less<Key>, typename Allocator = std::allocator<std::pair<const Key, Value>>>

using SVF::OrderedMap = typedef std::map<Key, Value, Compare, Allocator>

Definition at line 109 of file GeneralType.h.

OrderedNodeSet

typedef OrderedSet<NodeID> SVF::OrderedNodeSet

Definition at line 112 of file GeneralType.h.

OrderedSet

template<typename Key , typename Compare = std::less<Key>, typename Allocator = std::allocator<Key>>

using SVF::OrderedSet = typedef std::set<Key, Compare, Allocator>

Definition at line 105 of file GeneralType.h.

OutStream

typedef std::ostream SVF::OutStream

Definition at line 45 of file GeneralType.h.

PAG

typedef SVFIR SVF::PAG

Definition at line 700 of file SVFIR.h.

PAGEdge

typedef SVFStmt SVF::PAGEdge

Definition at line 43 of file IRGraph.h.

PAGNode

typedef SVFVar SVF::PAGNode

Definition at line 42 of file IRGraph.h.

PHINode

typedef llvm::PHINode SVF::PHINode

Definition at line 165 of file BasicTypes.h.

PHISVFGNode

typedef PHIVFGNode SVF::PHISVFGNode

Definition at line 56 of file SVFG.h.

PointerType

typedef llvm::PointerType SVF::PointerType

Definition at line 96 of file BasicTypes.h.

PointsToID

typedef unsigned SVF::PointsToID

Definition at line 63 of file GeneralType.h.

PostDominatorTree

typedef llvm::PostDominatorTree SVF::PostDominatorTree

Definition at line 136 of file BasicTypes.h.

raw_fd_ostream

typedef llvm::raw_fd_ostream SVF::raw_fd_ostream

LLVM outputs.

Definition at line 264 of file BasicTypes.h.

raw_pointer_iterator

template<typename WrappedIteratorT , typename T1 = std::remove_reference_t<decltype( **std::declval<WrappedIteratorT>())>, typename T2 = std::add_pointer_t<T1>>

using SVF::raw_pointer_iterator = typedef pointer_iterator<pointee_iter<WrappedIteratorT, T1>, T2>

Definition at line 402 of file iterator.h.

ResumeInst

typedef llvm::ResumeInst SVF::ResumeInst

Definition at line 173 of file BasicTypes.h.

ReturnInst

typedef llvm::ReturnInst SVF::ReturnInst

Definition at line 157 of file BasicTypes.h.

s16_t

typedef signed short SVF::s16_t

Definition at line 53 of file GeneralType.h.

s32_t

typedef signed SVF::s32_t

Definition at line 47 of file GeneralType.h.

s64_t

typedef signed long long SVF::s64_t

Definition at line 49 of file GeneralType.h.

s8_t

typedef signed char SVF::s8_t

Definition at line 51 of file GeneralType.h.

ScalarEvolution

typedef llvm::ScalarEvolution SVF::ScalarEvolution

Definition at line 260 of file BasicTypes.h.

ScalarEvolutionWrapperPass

typedef llvm::ScalarEvolutionWrapperPass SVF::ScalarEvolutionWrapperPass

Definition at line 257 of file BasicTypes.h.

SCEV

typedef llvm::SCEV SVF::SCEV

Definition at line 261 of file BasicTypes.h.

SCEVAddRecExpr

typedef llvm::SCEVAddRecExpr SVF::SCEVAddRecExpr

Definition at line 258 of file BasicTypes.h.

SCEVConstant

typedef llvm::SCEVConstant SVF::SCEVConstant

Definition at line 259 of file BasicTypes.h.

SelectInst

typedef llvm::SelectInst SVF::SelectInst

Definition at line 174 of file BasicTypes.h.

Set

template<typename Key , typename Hash = Hash<Key>, typename KeyEqual = std::equal_to<Key>, typename Allocator = std::allocator<Key>>

using SVF::Set = typedef std::unordered_set<Key, Hash, KeyEqual, Allocator>

Definition at line 96 of file GeneralType.h.

ShuffleVectorInst

typedef llvm::ShuffleVectorInst SVF::ShuffleVectorInst

Definition at line 164 of file BasicTypes.h.

SMDiagnostic

typedef llvm::SMDiagnostic SVF::SMDiagnostic

Definition at line 90 of file BasicTypes.h.

StmtSVFGNode

typedef StmtVFGNode SVF::StmtSVFGNode

Definition at line 50 of file SVFG.h.

StoreInst

typedef llvm::StoreInst SVF::StoreInst

Definition at line 148 of file BasicTypes.h.

StoreSVFGNode

typedef StoreVFGNode SVF::StoreSVFGNode

Definition at line 53 of file SVFG.h.

StructLayout

typedef llvm::StructLayout SVF::StructLayout

Definition at line 105 of file BasicTypes.h.

StructType

typedef llvm::StructType SVF::StructType

LLVM types.

Definition at line 94 of file BasicTypes.h.

succ_const_iterator

typedef llvm::succ_const_iterator SVF::succ_const_iterator

LLVM Iterators.

Definition at line 276 of file BasicTypes.h.

SuccBBAndCondValPair

typedef std::pair<const BasicBlock*, const ConstantInt*> SVF::SuccBBAndCondValPair

Definition at line 185 of file BasicTypes.h.

SuccBBAndCondValPairVec

typedef std::vector<SuccBBAndCondValPair> SVF::SuccBBAndCondValPairVec

Definition at line 186 of file BasicTypes.h.

SVFGEdge

typedef VFGEdge SVF::SVFGEdge

Definition at line 42 of file SVFG.h.

SVFGNode

typedef VFGNode SVF::SVFGNode

Definition at line 43 of file SVFG.h.

SwitchInst

typedef llvm::SwitchInst SVF::SwitchInst

Definition at line 155 of file BasicTypes.h.

SymID

typedef unsigned SVF::SymID

Definition at line 57 of file GeneralType.h.

ThreadID

typedef unsigned SVF::ThreadID

Definition at line 59 of file GeneralType.h.

Type

typedef llvm::Type SVF::Type

Definition at line 83 of file BasicTypes.h.

u16_t

typedef unsigned short SVF::u16_t

Definition at line 52 of file GeneralType.h.

u32_t

typedef unsigned SVF::u32_t

Definition at line 46 of file GeneralType.h.

u64_t

typedef unsigned long long SVF::u64_t

Definition at line 48 of file GeneralType.h.

u8_t

typedef unsigned char SVF::u8_t

Definition at line 50 of file GeneralType.h.

UnaryOperator

typedef llvm::UnaryOperator SVF::UnaryOperator

Definition at line 180 of file BasicTypes.h.

UndefValue

typedef llvm::UndefValue SVF::UndefValue

Definition at line 181 of file BasicTypes.h.

UnifyFunctionExitNodes

typedef llvm::UnifyFunctionExitNodes SVF::UnifyFunctionExitNodes

Definition at line 78 of file BasicTypes.h.

UnreachableInst

typedef llvm::UnreachableInst SVF::UnreachableInst

Definition at line 170 of file BasicTypes.h.

Use

typedef llvm::Use SVF::Use

Definition at line 72 of file BasicTypes.h.

User

typedef llvm::User SVF::User

Definition at line 142 of file BasicTypes.h.

VAArgInst

typedef llvm::VAArgInst SVF::VAArgInst

Definition at line 175 of file BasicTypes.h.

VACopyInst

typedef llvm::VACopyInst SVF::VACopyInst

Definition at line 176 of file BasicTypes.h.

VAEndInst

typedef llvm::VAEndInst SVF::VAEndInst

Definition at line 177 of file BasicTypes.h.

Value

typedef llvm::Value SVF::Value

LLVM Basic classes.

Definition at line 82 of file BasicTypes.h.

VAStartInst

typedef llvm::VAStartInst SVF::VAStartInst

Definition at line 178 of file BasicTypes.h.

VectorType

typedef llvm::VectorType SVF::VectorType

Definition at line 267 of file BasicTypes.h.

Version

typedef unsigned SVF::Version

Definition at line 123 of file GeneralType.h.

VersionedVar

typedef std::pair<NodeID, Version> SVF::VersionedVar

Definition at line 125 of file GeneralType.h.

VersionedVarSet

typedef Set<VersionedVar> SVF::VersionedVarSet

Definition at line 126 of file GeneralType.h.

VersionSet

typedef Set<Version> SVF::VersionSet

Definition at line 124 of file GeneralType.h.

VFunSet

typedef Set<const SVFFunction*> SVF::VFunSet

Definition at line 47 of file CHG.h.

VTableSet

typedef Set<const SVFGlobalValue*> SVF::VTableSet

Definition at line 46 of file CHG.h.

WPAConstraintSolver

typedef WPASolver< ConstraintGraph * > SVF::WPAConstraintSolver

Abstract class of inclusion-based Pointer Analysis

Equivalence-based Pointer Analysis

Definition at line 55 of file Andersen.h.

WPASVFGFSSolver

typedef WPAFSSolver<SVFG*> SVF::WPASVFGFSSolver

Flow sensitive whole program pointer analysis

Definition at line 48 of file FlowSensitive.h.

Enumeration Type Documentation

AliasResult

enum SVF::AliasResult

Enumerator
NoAlias
MayAlias
MustAlias
PartialAlias

Definition at line 526 of file SVFType.h.

{
    NoAlias,
    MayAlias,
    MustAlias,
    PartialAlias,
};

BuildDirection

enum SVF::BuildDirection

strong

Enumerator
plain
bidirection

Definition at line 40 of file CFLGraphBuilder.h.

{
    plain,
    bidirection,
};

ModRefInfo

enum SVF::ModRefInfo

Enumerator
ModRef
Ref
Mod
NoModRef

Definition at line 518 of file SVFType.h.

{
    ModRef,
    Ref,
    Mod,
    NoModRef,
};

ZeroBehavior

enum SVF::ZeroBehavior

The behavior an operation has on an input of 0.

Enumerator
ZB_Undefined	The returned value is undefined.
ZB_Max	The returned value is numeric_limits<T>::max()
ZB_Width	The returned value is numeric_limits<T>::digits.

Definition at line 36 of file SparseBitVector.h.

{
    ZB_Undefined,
    ZB_Max,
    ZB_Width
};

Function Documentation

__attribute__()

SVF::__attribute__

(

(weak)

)

Definition at line 10 of file SVFType.cpp.

{
    std::ostringstream os;
    print(os);
    return os.str();
}
 
std::ostream& operator<<(std::ostream& os, const SVFType& type)
{
    type.print(os);
    return os;
}

children()

template<class GraphType >

iter_range<typename GenericGraphTraits<GraphType>::ChildIteratorType> SVF::children

(

const typename GenericGraphTraits< GraphType >::NodeRef &

G

)

Definition at line 126 of file GraphTraits.h.

{
    return make_range(GenericGraphTraits<GraphType>::child_begin(G),
                      GenericGraphTraits<GraphType>::child_end(G));
}

children_edges()

template<class GraphType >

iter_range<typename GenericGraphTraits<GraphType>::ChildEdgeIteratorType> SVF::children_edges

(

const typename GenericGraphTraits< GraphType >::NodeRef &

G

)

Definition at line 142 of file GraphTraits.h.

{
    return make_range(GenericGraphTraits<GraphType>::child_edge_begin(G),
                      GenericGraphTraits<GraphType>::child_edge_end(G));
}

countLeadingZeros()

template<typename T >

unsigned SVF::countLeadingZeros	(	T	Val,
		ZeroBehavior	ZB = ZB_Width
	)

Count number of 0's from the most significant bit to the least stopping at the first 1.

Only unsigned integral types are allowed.

Parameters

ZB	the behavior on an input of 0. Only ZB_Width and ZB_Undefined are valid arguments.

Definition at line 211 of file SparseBitVector.h.

{
    static_assert(std::numeric_limits<T>::is_integer &&
                  !std::numeric_limits<T>::is_signed,
                  "Only unsigned integral types are allowed.");
    return LeadingZerosCounter<T, sizeof(T)>::count(Val, ZB);
}

countPopulation()

template<typename T >

unsigned SVF::countPopulation ( T  Value )

inline

Count the number of set bits in a value. Ex. countPopulation(0xF000F000) = 8 Returns 0 if the word is zero.

Definition at line 239 of file SparseBitVector.h.

{
    static_assert(std::numeric_limits<T>::is_integer &&
                  !std::numeric_limits<T>::is_signed,
                  "Only unsigned integral types are allowed.");
    return PopulationCounter<T, sizeof(T)>::count(Value);
}

countTrailingZeros()

template<typename T >

unsigned SVF::countTrailingZeros	(	T	Val,
		ZeroBehavior	ZB = ZB_Width
	)

Count number of 0's from the least significant bit to the most stopping at the first 1.

Only unsigned integral types are allowed.

Parameters

ZB	the behavior on an input of 0. Only ZB_Width and ZB_Undefined are valid arguments.

Definition at line 119 of file SparseBitVector.h.

{
    static_assert(std::numeric_limits<T>::is_integer &&
                  !std::numeric_limits<T>::is_signed,
                  "Only unsigned integral types are allowed.");
    return TrailingZerosCounter<T, sizeof(T)>::count(Val, ZB);
}

createSVFType()

SVFType* SVF::createSVFType	(	SVFType::GNodeK	kind,
		bool	isSingleValTy
	)

Definition at line 17 of file SVFFileSystem.cpp.

{
    switch (kind)
    {
    default:
        ABORT_MSG(kind << " is an impossible SVFTyKind in create()");
    case SVFType::SVFTy:
        ABORT_MSG("Creation of RAW SVFType isn't allowed");
    case SVFType::SVFPointerTy:
        ABORT_IFNOT(isSingleValTy, "Pointer type must be single-valued");
        return new SVFPointerType();
    case SVFType::SVFIntegerTy:
        ABORT_IFNOT(isSingleValTy, "Integer type must be single-valued");
        return new SVFIntegerType();
    case SVFType::SVFFunctionTy:
        ABORT_IFNOT(!isSingleValTy, "Function type must be multi-valued");
        return new SVFFunctionType(nullptr);
    case SVFType::SVFStructTy:
        ABORT_IFNOT(!isSingleValTy, "Struct type must be multi-valued");
        return new SVFStructType();
    case SVFType::SVFArrayTy:
        ABORT_IFNOT(!isSingleValTy, "Array type must be multi-valued");
        return new SVFArrayType();
    case SVFType::SVFOtherTy:
        return new SVFOtherType(isSingleValTy);
    }
}

createSVFValue()

static SVFValue* SVF::createSVFValue ( SVFValue::GNodeK  kind, const SVFType *  type, std::string &&  name  )

static

Definition at line 45 of file SVFFileSystem.cpp.

{
    auto creator = [=]() -> SVFValue*
    {
        switch (kind)
        {
        default:
            ABORT_MSG(kind << " is an impossible SVFValueKind in create()");
        case SVFValue::SVFVal:
            ABORT_MSG("Creation of RAW SVFValue isn't allowed");
        case SVFValue::SVFFunc:
            return new SVFFunction(type, {}, {}, {}, {}, {}, {});
        case SVFValue::SVFBB:
            return new SVFBasicBlock(type, {});
        case SVFValue::SVFInst:
            return new SVFInstruction(type, {}, {}, {});
        case SVFValue::SVFCall:
            return new SVFCallInst(type, {}, {}, {});
        case SVFValue::SVFVCall:
            return new SVFVirtualCallInst(type, {}, {}, {});
        case SVFValue::SVFGlob:
            return new SVFGlobalValue(type);
        case SVFValue::SVFArg:
            return new SVFArgument(type, {}, {}, {});
        case SVFValue::SVFConst:
            return new SVFConstant(type);
        case SVFValue::SVFConstData:
            return new SVFConstantData(type);
        case SVFValue::SVFConstInt:
            return new SVFConstantInt(type, {}, {});
        case SVFValue::SVFConstFP:
            return new SVFConstantFP(type, {});
        case SVFValue::SVFNullPtr:
            return new SVFConstantNullPtr(type);
        case SVFValue::SVFBlackHole:
            return new SVFBlackHoleValue(type);
        case SVFValue::SVFMetaAsValue:
            return new SVFMetadataAsValue(type);
        case SVFValue::SVFOther:
            return new SVFOtherValue(type);
        }
    };
    auto val = creator();
    val->setName(std::move(name));
    return val;
}

dump()

template<unsigned ElementSize>

void SVF::dump	(	const SparseBitVector< ElementSize > &	LHS,
		std::ostream &	out
	)

Definition at line 1233 of file SparseBitVector.h.

{
    out << "[";
 
    typename SparseBitVector<ElementSize>::iterator bi = LHS.begin(),
                                                    be = LHS.end();
    if (bi != be)
    {
        out << *bi;
        for (++bi; bi != be; ++bi)
        {
            out << " " << *bi;
        }
    }
    out << "]\n";
}

dumpLLVMValue()

std::string SVF::dumpLLVMValue

(

const SVFValue *

svfValue

)

[FOR DEBUG ONLY, DON'T USE IT UNSIDE svf!] Converts an SVFValue to corresponding LLVM::Value, then get the string representation of it. Use it only when you are debugging. Don't use it in any SVF algorithm because it relies on information stored in LLVM bc.

inverse_children()

template<class GraphType >

iter_range<typename GenericGraphTraits<Inverse<GraphType> >::ChildIteratorType> SVF::inverse_children

(

const typename GenericGraphTraits< GraphType >::NodeRef &

G

)

Definition at line 134 of file GraphTraits.h.

{
    return make_range(GenericGraphTraits<Inverse<GraphType>>::child_begin(G),
                      GenericGraphTraits<Inverse<GraphType>>::child_end(G));
}

inverse_nodes()

template<class GraphType >

iter_range<typename GenericGraphTraits<Inverse<GraphType> >::nodes_iterator> SVF::inverse_nodes

(

const GraphType &

G

)

Definition at line 118 of file GraphTraits.h.

{
    return make_range(GenericGraphTraits<Inverse<GraphType>>::nodes_begin(G),
                      GenericGraphTraits<Inverse<GraphType>>::nodes_end(G));
}

jsonAddItemToArray()

bool SVF::jsonAddItemToArray	(	cJSON *	array,
		cJSON *	item
	)

Definition at line 944 of file SVFFileSystem.cpp.

{
    return cJSON_AddItemToArray(array, item);
}

jsonAddItemToObject()

bool SVF::jsonAddItemToObject	(	cJSON *	obj,
		const char *	name,
		cJSON *	item
	)

Definition at line 938 of file SVFFileSystem.cpp.

{
    return humanReadableOption() ? cJSON_AddItemToObject(obj, name, item)
           : cJSON_AddItemToArray(obj, item);
}

jsonAddNumberToObject()

bool SVF::jsonAddNumberToObject	(	cJSON *	obj,
		const char *	name,
		double	number
	)

Helper function to write a number to a JSON object.

Definition at line 787 of file SVFFileSystem.cpp.

{
    cJSON* node = cJSON_CreateNumber(number);
    return jsonAddItemToObject(obj, name, node);
}

jsonAddPairToMap()

bool SVF::jsonAddPairToMap	(	cJSON *	obj,
		cJSON *	key,
		cJSON *	value
	)

Definition at line 929 of file SVFFileSystem.cpp.

{
    cJSON* pair = cJSON_CreateArray();
    jsonAddItemToArray(pair, key);
    jsonAddItemToArray(pair, value);
    jsonAddItemToArray(mapObj, pair);
    return pair;
}

jsonAddStringToObject() [1/2]

bool SVF::jsonAddStringToObject	(	cJSON *	obj,
		const char *	name,
		const char *	str
	)

Definition at line 793 of file SVFFileSystem.cpp.

{
    cJSON* node = cJSON_CreateStringReference(str);
    return jsonAddItemToObject(obj, name, node);
}

jsonAddStringToObject() [2/2]

bool SVF::jsonAddStringToObject	(	cJSON *	obj,
		const char *	name,
		const std::string &	s
	)

Definition at line 799 of file SVFFileSystem.cpp.

{
    return jsonAddStringToObject(obj, name, s.c_str());
}

jsonCreateArray()

cJSON * SVF::jsonCreateArray

(

)

Definition at line 894 of file SVFFileSystem.cpp.

{
    return cJSON_CreateArray();
}

jsonCreateBool()

cJSON * SVF::jsonCreateBool

(

bool

flag

)

Definition at line 918 of file SVFFileSystem.cpp.

{
    bool hr = humanReadableOption();
    return hr ? cJSON_CreateBool(flag) : cJSON_CreateNumber(flag);
}

jsonCreateIndex()

cJSON * SVF::jsonCreateIndex

(

size_t

index

)

Definition at line 910 of file SVFFileSystem.cpp.

{
    constexpr size_t maxPreciseIntInDouble = (1ull << 53);
    (void)maxPreciseIntInDouble; // silence unused warning
    assert(index <= maxPreciseIntInDouble);
    return cJSON_CreateNumber(index);
}

jsonCreateMap()

cJSON* SVF::jsonCreateMap

(

)

Definition at line 899 of file SVFFileSystem.cpp.

{
    // Don't use cJSON_CreateObject() here, because it only allows string keys.
    return cJSON_CreateArray();
}

jsonCreateNullId()

cJSON * SVF::jsonCreateNullId

(

)

Definition at line 883 of file SVFFileSystem.cpp.

{
    // TODO: optimize
    return cJSON_CreateNull();
}

jsonCreateNumber()

cJSON * SVF::jsonCreateNumber

(

double

num

)

Definition at line 924 of file SVFFileSystem.cpp.

{
    return cJSON_CreateNumber(num);
}

jsonCreateObject()

cJSON * SVF::jsonCreateObject

(

)

Definition at line 889 of file SVFFileSystem.cpp.

{
    return humanReadableOption() ? cJSON_CreateObject() : cJSON_CreateArray();
}

jsonCreateString()

cJSON * SVF::jsonCreateString

(

const char *

str

)

Definition at line 905 of file SVFFileSystem.cpp.

{
    return cJSON_CreateStringReference(str);
}

jsonGetNumber()

double SVF::jsonGetNumber

(

const cJSON *

item

)

Definition at line 877 of file SVFFileSystem.cpp.

{
    ABORT_IFNOT(jsonIsNumber(item), "Expected number for " << JSON_KEY(item));
    return item->valuedouble;
}

jsonIsArray()

bool SVF::jsonIsArray

(

const cJSON *

item

)

Definition at line 846 of file SVFFileSystem.cpp.

{
    return cJSON_IsArray(item);
}

jsonIsBool() [1/2]

bool SVF::jsonIsBool

(

const cJSON *

item

)

Definition at line 804 of file SVFFileSystem.cpp.

{
    return humanReadableOption()
           ? cJSON_IsBool(item)
           : cJSON_IsNumber(item) &&
           (item->valuedouble == 0 || item->valuedouble == 1);
}

jsonIsBool() [2/2]

bool SVF::jsonIsBool	(	const cJSON *	item,
		bool &	flag
	)

Definition at line 812 of file SVFFileSystem.cpp.

{
    if (humanReadableOption())
    {
        if (!cJSON_IsBool(item))
            return false;
        flag = cJSON_IsTrue(item);
        return true;
    }
    else
    {
        if (!cJSON_IsNumber(item))
            return false;
        flag = item->valuedouble == 1;
        return true;
    }
}

jsonIsMap()

bool SVF::jsonIsMap

(

const cJSON *

item

)

Definition at line 851 of file SVFFileSystem.cpp.

{
    return cJSON_IsArray(item);
}

jsonIsNullId()

bool SVF::jsonIsNullId

(

const cJSON *

item

)

Definition at line 840 of file SVFFileSystem.cpp.

{
    // TODO: optimize
    return cJSON_IsNull(item);
}

jsonIsNumber()

bool SVF::jsonIsNumber

(

const cJSON *

item

)

Definition at line 830 of file SVFFileSystem.cpp.

{
    return cJSON_IsNumber(item);
}

jsonIsObject()

bool SVF::jsonIsObject

(

const cJSON *

item

)

Definition at line 856 of file SVFFileSystem.cpp.

{
    return humanReadableOption() ? cJSON_IsObject(item) : cJSON_IsArray(item);
}

jsonIsString()

bool SVF::jsonIsString

(

const cJSON *

item

)

Definition at line 835 of file SVFFileSystem.cpp.

{
    return cJSON_IsString(item);
}

jsonKeyEquals()

bool SVF::jsonKeyEquals	(	const cJSON *	item,
		const char *	key
	)

Definition at line 861 of file SVFFileSystem.cpp.

{
    return item && !(humanReadableOption() && std::strcmp(item->string, key));
}

jsonUnpackPair()

std::pair< const cJSON *, const cJSON * > SVF::jsonUnpackPair

(

const cJSON *

item

)

Definition at line 866 of file SVFFileSystem.cpp.

{
    ABORT_IFNOT(jsonIsArray(item), "Expected array as pair");
    cJSON* child1 = item->child;
    ABORT_IFNOT(child1, "Missing first child of pair");
    cJSON* child2 = child1->next;
    ABORT_IFNOT(child2, "Missing first child of pair");
    ABORT_IFNOT(!child2->next, "Pair has more than two children");
    return {child1, child2};
}

KIND_BASE() [1/8]

SVF::KIND_BASE	(	CHEdge	,
		getEdgeKind
	)

KIND_BASE() [2/8]

SVF::KIND_BASE	(	CHNode	,
		getNodeKind
	)

KIND_BASE() [3/8]

SVF::KIND_BASE	(	ICFGEdge	,
		getEdgeKind
	)

KIND_BASE() [4/8]

SVF::KIND_BASE	(	ICFGNode	,
		getNodeKind
	)

KIND_BASE() [5/8]

SVF::KIND_BASE	(	SVFStmt	,
		getEdgeKind
	)

KIND_BASE() [6/8]

SVF::KIND_BASE	(	SVFType	,
		getKind
	)

KIND_BASE() [7/8]

SVF::KIND_BASE	(	SVFValue	,
		getKind
	)

KIND_BASE() [8/8]

SVF::KIND_BASE	(	SVFVar	,
		getNodeKind
	)

make_pointee_range()

template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>

iter_range<pointee_iter<WrappedIteratorT> > SVF::make_pointee_range

(

RangeT &&

Range

)

Definition at line 355 of file iterator.h.

{
    using PointeeIteratorT = pointee_iter<WrappedIteratorT>;
    return make_range(PointeeIteratorT(std::begin(std::forward<RangeT>(Range))),
                      PointeeIteratorT(std::end(std::forward<RangeT>(Range))));
}

make_pointer_range()

template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>

iter_range<pointer_iterator<WrappedIteratorT> > SVF::make_pointer_range

(

RangeT &&

Range

)

Definition at line 391 of file iterator.h.

{
    using PointerIteratorT = pointer_iterator<WrappedIteratorT>;
    return make_range(PointerIteratorT(std::begin(std::forward<RangeT>(Range))),
                      PointerIteratorT(std::end(std::forward<RangeT>(Range))));
}

make_range() [1/2]

template<typename T >

iter_range<T> SVF::make_range

(

std::pair< T, T >

p

)

Definition at line 69 of file iterator_range.h.

{
    return iter_range<T>(std::move(p.first), std::move(p.second));
}

make_range() [2/2]

template<class T >

iter_range<T> SVF::make_range	(	T	x,
		T	y
	)

Convenience function for iterating over sub-ranges.

This provides a bit of syntactic sugar to make using sub-ranges in for loops a bit easier. Analogous to std::make_pair().

Definition at line 64 of file iterator_range.h.

{
    return iter_range<T>(std::move(x), std::move(y));
}

map_iter()

template<class ItTy , class FuncTy >

mapped_iter<ItTy, FuncTy> SVF::map_iter ( ItTy  I, FuncTy  F  )

inline

Definition at line 748 of file GenericGraph.h.

{
    return mapped_iter<ItTy, FuncTy>(std::move(I), std::move(F));
}

nodes()

template<class GraphType >

iter_range<typename GenericGraphTraits<GraphType>::nodes_iterator> SVF::nodes

(

const GraphType &

G

)

Definition at line 111 of file GraphTraits.h.

{
    return make_range(GenericGraphTraits<GraphType>::nodes_begin(G),
                      GenericGraphTraits<GraphType>::nodes_end(G));
}

operator%()

IntervalValue SVF::operator% ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Divide IntervalValues.

Definition at line 645 of file IntervalValue.h.

{
    if (lhs.isBottom() || rhs.isBottom())
    {
        return IntervalValue::bottom();
    }
    else if (rhs.contains(0))
    {
        return lhs.is_zero() ? IntervalValue(0, 0) : IntervalValue::top();
    }
    else if (lhs.is_numeral() && rhs.is_numeral())
    {
        return IntervalValue(lhs.lb() % rhs.lb(), lhs.lb() % rhs.lb());
    }
    else
    {
        BoundedInt n_ub = max(abs(lhs.lb()), abs(lhs.ub()));
        BoundedInt d_ub = max(abs(rhs.lb()), rhs.ub()) - 1;
        BoundedInt ub = min(n_ub, d_ub);
 
        if (lhs.lb().getNumeral() < 0)
        {
            if (lhs.ub().getNumeral() > 0)
            {
                return IntervalValue(-ub, ub);
            }
            else
            {
                return IntervalValue(-ub, 0);
            }
        }
        else
        {
            return IntervalValue(0, ub);
        }
    }
}

operator&() [1/3]

IntervalValue SVF::operator& ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Bitwise AND of IntervalValues.

Definition at line 962 of file IntervalValue.h.

{
    if (lhs.isBottom() || rhs.isBottom())
        return IntervalValue::bottom();
    else if (lhs.is_numeral() && rhs.is_numeral())
    {
        return IntervalValue(lhs.lb() & rhs.lb());
    }
    else if (lhs.lb().getNumeral() >= 0 && rhs.lb().getNumeral() >= 0)
    {
        return IntervalValue((s64_t) 0, min(lhs.ub(), rhs.ub()));
    }
    else if (lhs.lb().getNumeral() >= 0)
    {
        return IntervalValue((s64_t) 0, lhs.ub());
    }
    else if (rhs.lb().getNumeral() >= 0)
    {
        return IntervalValue((s64_t) 0, rhs.ub());
    }
    else
    {
        return IntervalValue::top();
    }
}

operator&() [2/3]

PointsTo SVF::operator&	(	const PointsTo &	lhs,
		const PointsTo &	rhs
	)

Returns a new lhs & rhs.

Definition at line 573 of file PointsTo.cpp.

{
    // TODO: optimise.
    PointsTo result = lhs;
    result &= rhs;
    return result;
}

operator&() [3/3]

template<unsigned ElementSize>

SparseBitVector<ElementSize> SVF::operator& ( const SparseBitVector< ElementSize > &  LHS, const SparseBitVector< ElementSize > &  RHS  )

inline

Definition at line 1213 of file SparseBitVector.h.

{
    SparseBitVector<ElementSize> Result(LHS);
    Result &= RHS;
    return Result;
}

operator&=() [1/2]

template<unsigned ElementSize>

bool SVF::operator&= ( SparseBitVector< ElementSize > &  LHS, const SparseBitVector< ElementSize > *  RHS  )

inline

Definition at line 1193 of file SparseBitVector.h.

{
    return LHS &= *RHS;
}

operator&=() [2/2]

template<unsigned ElementSize>

bool SVF::operator&= ( SparseBitVector< ElementSize > *  LHS, const SparseBitVector< ElementSize > &  RHS  )

inline

Definition at line 1186 of file SparseBitVector.h.

{
    return LHS->operator&=(RHS);
}

operator*()

IntervalValue SVF::operator* ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Multiply IntervalValues.

Definition at line 583 of file IntervalValue.h.

{
    if (lhs.isBottom() || rhs.isBottom())
    {
        return IntervalValue::bottom();
    }
    else
    {
        BoundedInt ll = lhs.lb() * rhs.lb();
        BoundedInt lu = lhs.lb() * rhs.ub();
        BoundedInt ul = lhs.ub() * rhs.lb();
        BoundedInt uu = lhs.ub() * rhs.ub();
        std::vector<BoundedInt> vec{ll, lu, ul, uu};
        return IntervalValue(BoundedInt::min(vec),
                             BoundedInt::max(vec));
    }
}

operator+()

IntervalValue SVF::operator+ ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Add IntervalValues.

Definition at line 547 of file IntervalValue.h.

{
    if (lhs.isBottom() || rhs.isBottom())
    {
        return IntervalValue::bottom();
    }
    else if (lhs.isTop() || rhs.isTop())
    {
        return IntervalValue::top();
    }
    else
    {
        return IntervalValue(lhs.lb() + rhs.lb(), lhs.ub() + rhs.ub());
    }
}

operator-() [1/3]

IntervalValue SVF::operator- ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Subtract IntervalValues.

Definition at line 565 of file IntervalValue.h.

{
    if (lhs.isBottom() || rhs.isBottom())
    {
        return IntervalValue::bottom();
    }
    else if (lhs.isTop() || rhs.isTop())
    {
        return IntervalValue::top();
    }
    else
    {
        return IntervalValue(lhs.lb() - rhs.ub(), lhs.ub() - rhs.lb());
    }
}

operator-() [2/3]

PointsTo SVF::operator-	(	const PointsTo &	lhs,
		const PointsTo &	rhs
	)

Returns a new lhs - rhs.

Definition at line 581 of file PointsTo.cpp.

{
    // TODO: optimise.
    PointsTo result = lhs;
    result -= rhs;
    return result;
}

operator-() [3/3]

template<unsigned ElementSize>

SparseBitVector<ElementSize> SVF::operator- ( const SparseBitVector< ElementSize > &  LHS, const SparseBitVector< ElementSize > &  RHS  )

inline

Definition at line 1223 of file SparseBitVector.h.

{
    SparseBitVector<ElementSize> Result;
    Result.intersectWithComplement(LHS, RHS);
    return Result;
}

operator/()

IntervalValue SVF::operator/ ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Divide IntervalValues.

Definition at line 603 of file IntervalValue.h.

{
    if (lhs.isBottom() || rhs.isBottom())
    {
        return IntervalValue::bottom();
    }
    else if (rhs.contains(0))
    {
        IntervalValue lb = IntervalValue::create(rhs.lb(), -1);
        IntervalValue ub = IntervalValue::create(1, rhs.ub());
        IntervalValue l_res = lhs / lb;
        IntervalValue r_res = lhs / ub;
        l_res.join_with(r_res);
        return l_res;
    }
    else if (lhs.contains(0))
    {
        IntervalValue lb = IntervalValue::create(lhs.lb(), -1);
        IntervalValue ub = IntervalValue::create(1, lhs.ub());
        IntervalValue l_res = lb / rhs;
        IntervalValue r_res = ub / rhs;
        l_res.join_with(r_res);
        l_res.join_with(IntervalValue(0));
        return l_res;
    }
    else
    {
        // Neither the dividend nor the divisor contains 0
        BoundedInt ll = lhs.lb() / rhs.lb();
        BoundedInt lu = lhs.lb() / rhs.ub();
        BoundedInt ul = lhs.ub() / rhs.lb();
        BoundedInt uu = lhs.ub() / rhs.ub();
        std::vector<BoundedInt> vec{ll, lu, ul, uu};
 
        IntervalValue res =  IntervalValue(BoundedInt::min(vec),
                                           BoundedInt::max(vec));
        return res;
    }
}

operator<()

IntervalValue SVF::operator< ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Definition at line 736 of file IntervalValue.h.

{
    // If either lhs or rhs is bottom, the result is bottom
    if (lhs.isBottom() || rhs.isBottom())
    {
        return IntervalValue::bottom();
    }
    // If either lhs or rhs is top, the result is top
    else if (lhs.isTop() || rhs.isTop())
    {
        return IntervalValue::top();
    }
    else
    {
        // If both lhs and rhs are numerals (lb = ub), directly compare their values
        if (lhs.is_numeral() && rhs.is_numeral())
        {
            // It means lhs.lb() < rhs.lb()? true: false
            return lhs.lb().geq(rhs.lb()) ? IntervalValue(0, 0) : IntervalValue(1, 1);
        }
        else
        {
            // Return [1,1] means lhs is totally less than rhs
            // When lhs.ub < rhs.lb, e.g., lhs:[1, 2] rhs:[3, 4]
            // lhs.ub(2) < rhs.lb(3)
            // It means lhs.ub() < rhs.lb()
            if (!lhs.ub().geq(rhs.lb()))
            {
                return IntervalValue(1, 1);
            }
            // Return [0,0] means lhs is totally impossible to be less than rhs
            // i.e., lhs is totally greater than or equal to rhs
            // When lhs.lb >= rhs.ub, e.g., lhs:[4,5] rhs:[3，4]
            // lhs.lb(4) >= rhs.ub(4)
            else if (lhs.lb().geq(rhs.ub()))
            {
                return IntervalValue(0, 0);
            }
            // For other cases, lhs can be less than rhs or not, depending on the values
            // e.g., lhs: [2,4], rhs: [1,3],
            // lhs can be less than rhs if lhs is 2, rhs is 3.
            // lhs can also not be less than rhs if lhs is 4 and rhs is 1
            else
            {
                return IntervalValue(0, 1);
            }
        }
    }
}

operator<<() [1/5]

IntervalValue SVF::operator<< ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Left binary shift of IntervalValues.

Definition at line 888 of file IntervalValue.h.

{
    //TODO: implement <<
    if (lhs.isBottom() || rhs.isBottom())
        return IntervalValue::bottom();
    if (lhs.isTop() && rhs.isTop())
        return IntervalValue::top();
    else
    {
        IntervalValue shift = rhs;
        shift.meet_with(IntervalValue(0, IntervalValue::plus_infinity()));
        if (shift.isBottom())
            return IntervalValue::bottom();
        BoundedInt lb = 0;
        // If the shift is greater than 32, the result is always 0
        if ((s32_t) shift.lb().getNumeral() >= 32 || shift.lb().is_infinity())
        {
            lb = IntervalValue::minus_infinity();
        }
        else
        {
            lb = (1 << (s32_t) shift.lb().getNumeral());
        }
        BoundedInt ub = 0;
        if (shift.ub().is_infinity())
        {
            ub = IntervalValue::plus_infinity();
        }
        else
        {
            ub = (1 << (s32_t) shift.ub().getNumeral());
        }
        IntervalValue coeff(lb, ub);
        return lhs * coeff;
    }
}

operator<<() [2/5]

template<typename F , typename S >

OutStream& SVF::operator<<	(	OutStream &	o,
		const std::pair< F, S > &	var
	)

Definition at line 1085 of file SVFValue.h.

{
    o << "<" << var.first << ", " << var.second << ">";
    return o;
}

operator<<() [3/5]

std::ostream& SVF::operator<< ( std::ostream &  o, const IntervalValue &  IntervalValue  )

inline

Write an IntervalValue on a stream.

Definition at line 1047 of file IntervalValue.h.

{
    IntervalValue.dump(o);
    return o;
}

operator<<() [4/5]

std::ostream & SVF::operator<<	(	std::ostream &	o,
		const MRVer &	mrver
	)

Definition at line 808 of file MemRegion.cpp.

{
    o << "MRVERID: " << mrver.getID() <<" MemRegion: " << mrver.getMR()->dumpStr() << " MRVERSION: " << mrver.getSSAVersion() << " MSSADef: " << mrver.getDef()->getType() << ", "
      << mrver.getDef()->getMR()->dumpStr() ;
    return o;
}

operator<<() [5/5]

std::ostream& SVF::operator<<	(	std::ostream &	os,
		const SVFType &	type
	)

operator<=()

IntervalValue SVF::operator<= ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Definition at line 838 of file IntervalValue.h.

{
    // If either lhs or rhs is bottom, the result is bottom
    if (lhs.isBottom() || rhs.isBottom())
    {
        return IntervalValue::bottom();
    }
    // If either lhs or rhs is top, the result is top
    else if (lhs.isTop() || rhs.isTop())
    {
        return IntervalValue::top();
    }
    else
    {
        // If both lhs and rhs are numerals (lb = ub), directly compare their values
        if (lhs.is_numeral() && rhs.is_numeral())
        {
            return lhs.lb().leq(rhs.lb()) ? IntervalValue(1, 1) : IntervalValue(0, 0);
        }
        else
        {
            // Return [1,1] means lhs is totally less than or equal to rhs
            // When lhs.ub <= rhs.lb, e.g., lhs:[1, 2] rhs:[2, 3]
            // lhs.ub(2) <= rhs.lb(2)
            if (lhs.ub().leq(rhs.lb()))
            {
                return IntervalValue(1, 1);
            }
            // Return [0,0] means lhs is totally impossible to be less than or equal to rhs
            // i.e., lhs is totally greater than rhs
            // When lhs.lb > rhs.ub, e.g., lhs:[3, 4] rhs:[1, 2]
            // lhs.lb(3) > rhs.ub(2)
            // It means lhs.lb() > rhs.ub()
            else if (!lhs.lb().leq(rhs.ub()))
            {
                return IntervalValue(0, 0);
            }
            // For other cases, lhs can be less than or equal to rhs or not, depending on the values
            // e.g., lhs: [2,4], rhs: [1,3],
            // lhs can be less than or equal to rhs if lhs is 3, rhs is 3.
            // lhs can also not be less than or equal to rhs if lhs is 3 and rhs is 2
            else
            {
                return IntervalValue(0, 1);
            }
        }
    }
}

operator>()

IntervalValue SVF::operator> ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Definition at line 685 of file IntervalValue.h.

{
    // If either lhs or rhs is bottom, the result is bottom
    if (lhs.isBottom() || rhs.isBottom())
    {
        return IntervalValue::bottom();
    }
    // If either lhs or rhs is top, the result is top
    else if (lhs.isTop() || rhs.isTop())
    {
        return IntervalValue::top();
    }
    else
    {
        // If both lhs and rhs are numerals (lb = ub), directly compare their values
        if (lhs.is_numeral() && rhs.is_numeral())
        {
            // It means lhs.lb() > rhs.lb()? true: false
            return lhs.lb().leq(rhs.lb()) ? IntervalValue(0, 0) : IntervalValue(1, 1);
        }
        else
        {
            // Return [1,1] means lhs is totally greater than rhs
            // When lhs.lb > rhs.ub, e.g., lhs:[3, 4] rhs:[1, 2]
            // lhs.lb(3) > rhs.ub(2)
            // It means lhs.lb() > rhs.ub()
            if (!lhs.lb().leq(rhs.ub()))
            {
                return IntervalValue(1, 1);
            }
            // Return [0,0] means lhs is totally impossible to be greater than rhs
            // i.e., lhs is totally less than or equal to rhs
            // When lhs.ub <= rhs.lb, e.g., lhs:[3, 4] rhs:[4，5]
            // lhs.ub(4) <= rhs.lb(4)
            else if (lhs.ub().leq(rhs.lb()))
            {
                return IntervalValue(0, 0);
            }
            // For other cases, lhs can be greater than or not, depending on the values
            // e.g., lhs: [2,4], rhs: [1,3],
            // lhs can be greater than rhs if lhs is 4 and rhs is 1.
            // lhs can also not be greater than rhs if lhs is 2 and rhs is 3
            else
            {
                return IntervalValue(0, 1);
            }
        }
    }
}

operator>=()

IntervalValue SVF::operator>= ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Definition at line 788 of file IntervalValue.h.

{
    // If either lhs or rhs is bottom, the result is bottom
    if (lhs.isBottom() || rhs.isBottom())
    {
        return IntervalValue::bottom();
    }
    // If either lhs or rhs is top, the result is top
    else if (lhs.isTop() || rhs.isTop())
    {
        return IntervalValue::top();
    }
    else
    {
        // If both lhs and rhs are numerals (lb = ub), directly compare their values
        if (lhs.is_numeral() && rhs.is_numeral())
        {
            return lhs.lb().geq(rhs.lb()) ? IntervalValue(1, 1) : IntervalValue(0, 0);
        }
        else
        {
            // Return [1,1] means lhs is totally greater than or equal to rhs
            // When lhs.lb >= rhs.ub, e.g., lhs:[2, 3] rhs:[1, 2]
            // lhs.lb(2) >= rhs.ub(2)
            if (lhs.lb().geq(rhs.ub()))
            {
                return IntervalValue(1, 1);
            }
            // Return [0,0] means lhs is totally impossible to be greater than or equal to rhs
            // i.e., lhs is totally less than rhs
            // When lhs.ub < rhs.lb, e.g., lhs:[1, 2] rhs:[3, 4]
            // lhs.ub(2) < rhs.lb(3)
            // It means lhs.ub() < rhs.lb()
            else if (!lhs.ub().geq(rhs.lb()))
            {
                return IntervalValue(0, 0);
            }
            // For other cases, lhs can be greater than or equal to rhs or not, depending on the values
            // e.g., lhs: [2,4], rhs: [1,3],
            // lhs can be greater than or equal to rhs if lhs is 3, rhs is 2.
            // lhs can also not be greater than or equal to rhs if lhs is 2 and rhs is 3
            else
            {
                return IntervalValue(0, 1);
            }
        }
    }
}

operator>>()

IntervalValue SVF::operator>> ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Left binary shift of IntervalValues.

Definition at line 926 of file IntervalValue.h.

{
    //TODO: implement >>
    if (lhs.isBottom() || rhs.isBottom())
        return IntervalValue::bottom();
    else if (lhs.isTop() && rhs.isTop())
        return IntervalValue::top();
    else
    {
        IntervalValue shift = rhs;
        shift.meet_with(IntervalValue(0, IntervalValue::plus_infinity()));
        if (shift.isBottom())
            return IntervalValue::bottom();
        if (lhs.contains(0))
        {
            IntervalValue l = IntervalValue::create(lhs.lb(), -1);
            IntervalValue u = IntervalValue::create(1, lhs.ub());
            IntervalValue tmp = l >> rhs;
            tmp.join_with(u >> rhs);
            tmp.join_with(IntervalValue(0));
            return tmp;
        }
        else
        {
            BoundedInt ll = lhs.lb() >> shift.lb();
            BoundedInt lu = lhs.lb() >> shift.ub();
            BoundedInt ul = lhs.ub() >> shift.lb();
            BoundedInt uu = lhs.ub() >> shift.ub();
            std::vector<BoundedInt> vec{ll, lu, ul, uu};
            return IntervalValue(BoundedInt::min(vec),
                                 BoundedInt::max(vec));
        }
    }
}

operator^()

IntervalValue SVF::operator^ ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Bitwise XOR of IntervalValues.

Definition at line 1018 of file IntervalValue.h.

{
    auto next_power_of_2 = [](s64_t num)
    {
        int i = 1;
        while ((num >> i) != 0)
        {
            ++i;
        }
        return 1 << i;
    };
    if (lhs.isBottom() || rhs.isBottom())
        return IntervalValue::bottom();
    else if (lhs.is_numeral() && rhs.is_numeral())
        return IntervalValue(lhs.lb() ^ rhs.lb());
    else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
             rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
    {
        s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
        s64_t ub = next_power_of_2(s64_t(m)) - 1;
        return IntervalValue((s64_t) 0, (s64_t) ub);
    }
    else
    {
        return IntervalValue::top();
    }
}

operator|() [1/3]

IntervalValue SVF::operator| ( const IntervalValue &  lhs, const IntervalValue &  rhs  )

inline

Bitwise OR of IntervalValues.

Definition at line 989 of file IntervalValue.h.

{
    auto next_power_of_2 = [](s64_t num)
    {
        int i = 1;
        while ((num >> i) != 0)
        {
            ++i;
        }
        return 1 << i;
    };
    if (lhs.isBottom() || rhs.isBottom())
        return IntervalValue::bottom();
    else if (lhs.is_numeral() && rhs.is_numeral())
        return IntervalValue(lhs.lb() | rhs.lb());
    else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
             rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
    {
        s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
        s64_t ub = next_power_of_2(s64_t(m)) - 1;
        return IntervalValue((s64_t) 0, (s64_t) ub);
    }
    else
    {
        return IntervalValue::top();
    }
}

operator|() [2/3]

PointsTo SVF::operator|	(	const PointsTo &	lhs,
		const PointsTo &	rhs
	)

Returns a new lhs | rhs.

Definition at line 565 of file PointsTo.cpp.

{
    // TODO: optimise.
    PointsTo result = lhs;
    result |= rhs;
    return result;
}

operator|() [3/3]

template<unsigned ElementSize>

SparseBitVector<ElementSize> SVF::operator| ( const SparseBitVector< ElementSize > &  LHS, const SparseBitVector< ElementSize > &  RHS  )

inline

Definition at line 1203 of file SparseBitVector.h.

{
    SparseBitVector<ElementSize> Result(LHS);
    Result |= RHS;
    return Result;
}

operator|=() [1/2]

template<unsigned ElementSize>

bool SVF::operator|= ( SparseBitVector< ElementSize > &  LHS, const SparseBitVector< ElementSize > *  RHS  )

inline

Definition at line 1172 of file SparseBitVector.h.

{
    return LHS |= *RHS;
}

operator|=() [2/2]

template<unsigned ElementSize>

bool SVF::operator|= ( SparseBitVector< ElementSize > *  LHS, const SparseBitVector< ElementSize > &  RHS  )

inline

Definition at line 1179 of file SparseBitVector.h.

{
    return LHS->operator|=(RHS);
}

readBigNumber()

template<typename BigNumberType , typename CStrToVal >

static void SVF::readBigNumber ( const cJSON *  obj, BigNumberType &  val, CStrToVal  conv  )

inlinestatic

Definition at line 100 of file SVFFileSystem.cpp.

{
    ABORT_IFNOT(jsonIsString(obj),
                "Expect (number) string JSON for " << JSON_KEY(obj));
    val = conv(obj->valuestring);
}

readSmallNumber()

template<typename SmallNumberType >

static void SVF::readSmallNumber ( const cJSON *  obj, SmallNumberType &  val  )

inlinestatic

Definition at line 94 of file SVFFileSystem.cpp.

{
    val = static_cast<SmallNumberType>(jsonGetNumber(obj));
}

ViewGraph()

template<typename GraphType >

void SVF::ViewGraph	(	const GraphType &	G,
		const std::string &	name,
		bool	ShortNames = false,
		GraphProgram::Name	Program = GraphProgram::DOT
	)

ViewGraph - Emit a dot graph, run 'dot', run gv on the postscript file, then cleanup. For use from the debugger.

Definition at line 371 of file GraphWriter.h.

{
    SVF::WriteGraph(G, ShortNames);
}

WriteGraph() [1/2]

template<typename GraphType >

std::string SVF::WriteGraph	(	const GraphType &	G,
		bool	ShortNames = false,
		std::string	Filename = ""
	)

Writes graph into a provided Filename. If Filename is empty, generates a random one.

Returns

The resulting filename, or an empty string if writing failed.

Definition at line 345 of file GraphWriter.h.

{
 
    std::ofstream O(Filename);
 
    if (O.fail())
    {
        std::cerr << "error opening file '" << Filename << "' for writing!\n";
        O.close();
        return "";
    }
 
    SVF::WriteGraph(O, G, ShortNames);
    O.close();
 
    std::cerr << " done. \n";
 
    return Filename;
}

WriteGraph() [2/2]

template<typename GraphType >

std::ofstream& SVF::WriteGraph	(	std::ofstream &	O,
		const GraphType &	G,
		bool	ShortNames = false
	)

Definition at line 328 of file GraphWriter.h.

{
    // Start the graph emission process...
    GraphWriter<GraphType> W(O, G, ShortNames);
 
    // Emit the graph.
    W.writeGraph("");
 
    return O;
}