SVF Namespace Reference

for isBitcode More...

Namespaces
namespace	cppUtil
namespace	LLVMUtil
namespace	DOT
namespace	GraphProgram
namespace	SVFUtil

Classes
class	BreakConstantGEPs
class	MergeFunctionRets
class	CHGBuilder
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	AbstractInterpretation
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	NullptrDerefDetector
class	AEStat
	AEStat: Statistic for AE. More...
class	AEWTO
class	SemiSparseAbstractInterpretation
class	FullSparseAbstractInterpretation
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	BasicBlockEdge
class	SVFBasicBlock
class	BasicBlockGraph
class	CallGraphEdge
class	CallGraphNode
class	CallGraph
struct	GenericGraphTraits< SVF::CallGraphNode * >
struct	GenericGraphTraits< Inverse< SVF::CallGraphNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...
struct	GenericGraphTraits< SVF::CallGraph * >
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	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	SCCDetection
class	SlicedICFGView
class	SlicedPAGView
class	SlicedThreadCallGraphView
class	SlicedSVFGView
class	SlicedSVFIRView
struct	SlicedNodeRef
struct	SlicedICFGEdgeRef
class	SlicedICFGEdgeIterImpl
class	SlicedICFGChildIterImpl
class	SlicedICFGNodeIter
struct	SlicedCallGraphEdgeRef
class	SlicedCGEdgeIterImpl
class	SlicedCGChildIterImpl
class	SlicedCGNodeIter
struct	SlicedPAGEdgeRef
class	SlicedPAGEdgeIterImpl
class	SlicedPAGChildIterImpl
class	SlicedPAGNodeIter
struct	SlicedSVFGEdgeRef
class	SlicedSVFGEdgeIterImpl
class	SlicedSVFGChildIterImpl
class	SlicedSVFGNodeIter
struct	GenericGraphTraits< const SlicedICFGView * >
struct	GenericGraphTraits< Inverse< const SlicedICFGView * > >
struct	GenericGraphTraits< const SlicedThreadCallGraphView * >
struct	GenericGraphTraits< Inverse< const SlicedThreadCallGraphView * > >
struct	GenericGraphTraits< const SlicedPAGView * >
struct	GenericGraphTraits< Inverse< const SlicedPAGView * > >
struct	GenericGraphTraits< const SlicedSVFGView * >
struct	GenericGraphTraits< Inverse< const SlicedSVFGView * > >
class	SparseObjEdge
	An edge carries the source packed Obj to the target ICFG location. More...
class	SparseObjNode
class	SparseObjGraph
struct	GenericGraphTraits< SparseObjNode * >
struct	GenericGraphTraits< Inverse< SparseObjNode * > >
struct	GenericGraphTraits< SparseObjGraph * >
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
struct	GenericGraphTraits< SVF::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	FSMPTA
class	LockAnalysis
class	MHP
class	ForkJoinAnalysis
class	MTA
class	SlicedMTA
struct	ValueFlowSlice
class	SlicedTCT
class	MTASlicerBase
class	MultiStageSlicer
class	SingleSlicer
class	ScopedPhaseTimer
class	MTAStat
class	MTASVFGBuilder
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	ObjTypeInfo
class	PAGBuilderFromFile
class	SVFIR
class	SVFStmt
class	AssignStmt
class	AddrStmt
class	CopyStmt
class	StoreStmt
class	LoadStmt
class	GepStmt
class	RetPE
class	MultiOpndStmt
class	CallPE
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
class	SVFValue
class	SVFVar
class	ValVar
class	ObjVar
class	ArgValVar
	Class representing a function argument variable in the SVFIR. More...
class	GepValVar
class	BaseObjVar
class	GepObjVar
class	HeapObjVar
	Class representing a heap object variable in the SVFIR. More...
class	StackObjVar
	Represents a stack-allocated object variable in the SVFIR (SVF Intermediate Representation) @inherits BaseObjVar. More...
class	FunObjVar
class	FunValVar
class	GlobalValVar
class	ConstDataValVar
class	BlackHoleValVar
class	ConstFPValVar
class	ConstIntValVar
class	ConstNullPtrValVar
class	GlobalObjVar
class	ConstDataObjVar
class	ConstFPObjVar
class	ConstIntObjVar
class	ConstNullPtrObjVar
class	RetValPN
class	VarArgValPN
class	DummyValVar
class	IntrinsicValVar
class	AsmPCValVar
class	DummyObjVar
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< NodePair >
class	GraphReachSolver
struct	Hash
	provide extra hash function for std::pair handling More...
struct	Hash< std::pair< S, T > >
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	SVFLoopAndDomInfo
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< CallGraph * >
struct	DOTGraphTraits< CFLGraph * >
struct	DOTGraphTraits< CHGraph * >
struct	DOTGraphTraits< ConstraintGraph * >
struct	DOTGraphTraits< ICFG * >
struct	DOTGraphTraits< IRGraph * >
struct	DOTGraphTraits< const SlicedICFGView * >
struct	DOTGraphTraits< const SlicedThreadCallGraphView * >
struct	DOTGraphTraits< const SlicedPAGView * >
struct	DOTGraphTraits< const SlicedSVFGView * >
struct	DOTGraphTraits< SparseObjGraph * >
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::UnifyFunctionExitNodesPass	UnifyFunctionExitNodes
typedef llvm::Value	Value
	LLVM Basic classes.
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.
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.
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::InlineAsm	InlineAsm
typedef llvm::DSOLocalEquivalent	DSOLocalEquivalent
typedef llvm::NoCFIValue	NoCFIValue
typedef llvm::GlobalAlias	GlobalAlias
typedef llvm::GlobalIFunc	GlobalIFunc
typedef llvm::GlobalVariable	GlobalVariable
typedef llvm::DominatorTree	DominatorTree
	LLVM Dominators.
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.
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::IntrinsicInst	IntrinsicInst
typedef llvm::DbgInfoIntrinsic	DbgInfoIntrinsic
typedef llvm::DbgVariableIntrinsic	DbgVariableIntrinsic
typedef llvm::DbgDeclareInst	DbgDeclareInst
typedef llvm::DbgValueInst	DbgValueInst
typedef llvm::DbgLabelInst	DbgLabelInst
typedef llvm::VPIntrinsic	VPIntrinsic
typedef llvm::ConstrainedFPIntrinsic	ConstrainedFPIntrinsic
typedef llvm::ConstrainedFPCmpIntrinsic	ConstrainedFPCmpIntrinsic
typedef llvm::MinMaxIntrinsic	MinMaxIntrinsic
typedef llvm::BinaryOpIntrinsic	BinaryOpIntrinsic
typedef llvm::WithOverflowInst	WithOverflowInst
typedef llvm::SaturatingInst	SaturatingInst
typedef llvm::AtomicMemIntrinsic	AtomicMemIntrinsic
typedef llvm::AtomicMemSetInst	AtomicMemSetInst
typedef llvm::AtomicMemTransferInst	AtomicMemTransferInst
typedef llvm::AtomicMemCpyInst	AtomicMemCpyInst
typedef llvm::AtomicMemMoveInst	AtomicMemMoveInst
typedef llvm::MemIntrinsic	MemIntrinsic
typedef llvm::MemSetInst	MemSetInst
typedef llvm::MemTransferInst	MemTransferInst
typedef llvm::MemCpyInst	MemCpyInst
typedef llvm::MemMoveInst	MemMoveInst
typedef llvm::MemCpyInlineInst	MemCpyInlineInst
typedef llvm::AnyMemIntrinsic	AnyMemIntrinsic
typedef llvm::AnyMemSetInst	AnyMemSetInst
typedef llvm::AnyMemTransferInst	AnyMemTransferInst
typedef llvm::AnyMemCpyInst	AnyMemCpyInst
typedef llvm::AnyMemMoveInst	AnyMemMoveInst
typedef llvm::InstrProfIncrementInst	InstrProfIncrementInst
typedef llvm::InstrProfIncrementInstStep	InstrProfIncrementInstStep
typedef llvm::InstrProfValueProfileInst	InstrProfValueProfileInst
typedef llvm::PseudoProbeInst	PseudoProbeInst
typedef llvm::NoAliasScopeDeclInst	NoAliasScopeDeclInst
typedef llvm::GCStatepointInst	GCStatepointInst
typedef llvm::GCProjectionInst	GCProjectionInst
typedef llvm::GCRelocateInst	GCRelocateInst
typedef llvm::GCResultInst	GCResultInst
typedef llvm::AssumeInst	AssumeInst
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.
typedef llvm::VectorType	VectorType
typedef llvm::FunctionCallee	FunctionCallee
typedef llvm::const_succ_iterator	succ_const_iterator
	LLVM Iterators.
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< SVFBasicBlock >	GenericBasicBlockEdgeTy
typedef GenericNode< SVFBasicBlock, BasicBlockEdge >	GenericBasicBlockNodeTy
typedef GenericGraph< SVFBasicBlock, BasicBlockEdge >	GenericBasicBlockGraphTy
typedef GenericEdge< CallGraphNode >	GenericPTACallGraphEdgeTy
typedef GenericNode< CallGraphNode, CallGraphEdge >	GenericPTACallGraphNodeTy
typedef GenericGraph< CallGraphNode, CallGraphEdge >	GenericPTACallGraphTy
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.
typedef Set< const GlobalObjVar * >	VTableSet
typedef Set< const FunObjVar * >	VFunSet
typedef GenericEdge< CHNode >	GenericCHEdgeTy
typedef GenericNode< CHNode, CHEdge >	GenericCHNodeTy
typedef GenericGraph< CHNode, CHEdge >	GenericCHGraphTy
	class hierarchy graph
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
using	SlicedICFGNodeRef = SlicedNodeRef<SlicedICFGView, ICFGNode>
using	SlicedCallGraphNodeRef = SlicedNodeRef<SlicedThreadCallGraphView, CallGraphNode>
using	SlicedPAGNodeRef = SlicedNodeRef<SlicedPAGView, SVFVar>
using	SlicedSVFGNodeRef = SlicedNodeRef<SlicedSVFGView, SVFGNode>
typedef GenericEdge< SparseObjNode >	GenericSparseObjEdgeTy
typedef GenericNode< SparseObjNode, SparseObjEdge >	GenericSparseObjNodeTy
typedef GenericGraph< SparseObjNode, SparseObjEdge >	GenericSparseObjGraphTy
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
typedef SVFIR	PAG
typedef GenericEdge< SVFVar >	GenericPAGEdgeTy
typedef GenericNode< SVFVar, SVFStmt >	GenericPAGNodeTy
typedef CondVar< ContextCond >	CxtVar
typedef CondStdSet< CxtVar >	CxtPtSet
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::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	CallSiteID
typedef unsigned	ThreadID
typedef s64_t	APOffset
typedef SparseBitVector	NodeBS
typedef unsigned	PointsToID
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
typedef WPASolver< ConstraintGraph * >	WPAConstraintSolver
typedef SCCDetection< ConstraintGraph * >	CGSCC
typedef WPAFSSolver< SVFG * >	WPASVFGFSSolver

Enumerations
enum class	TargetABI { Itanium , MSVC }
	C++ ABI inferred from the target triple. More...
enum class	BuildDirection { plain , bidirection }
enum	PTATY {   Andersen_BASE , Andersen_WPA , AndersenSCD_WPA , AndersenSFR_WPA ,   AndersenWaveDiff_WPA , Steensgaard_WPA , CSCallString_WPA , CSSummary_WPA ,   FSDATAFLOW_WPA , FSSPARSE_WPA , VFS_WPA , FSCS_WPA ,   CFLFICI_WPA , CFLFSCI_WPA , CFLFSCS_WPA , TypeCPP_WPA ,   FieldS_DDA , FlowS_DDA , PathS_DDA , Cxt_DDA ,   Default_PTA }
	Pointer analysis type list. More...
enum	PTAImplTy { BaseImpl , BVDataImpl , CondImpl }
	Implementation type: BVDataPTAImpl or CondPTAImpl. More...
enum	PTBackingType { Mutable , Persistent }
	How the PTData used is implemented. More...
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.
IntervalValue	operator- (const IntervalValue &lhs, const IntervalValue &rhs)
	Subtract IntervalValues.
IntervalValue	operator* (const IntervalValue &lhs, const IntervalValue &rhs)
	Multiply IntervalValues.
IntervalValue	operator/ (const IntervalValue &lhs, const IntervalValue &rhs)
	Divide IntervalValues.
IntervalValue	operator% (const IntervalValue &lhs, const IntervalValue &rhs)
	Divide IntervalValues.
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.
IntervalValue	operator>> (const IntervalValue &lhs, const IntervalValue &rhs)
	Left binary shift of IntervalValues.
IntervalValue	operator& (const IntervalValue &lhs, const IntervalValue &rhs)
	Bitwise AND of IntervalValues.
IntervalValue	operator| (const IntervalValue &lhs, const IntervalValue &rhs)
	Bitwise OR of IntervalValues.
IntervalValue	operator^ (const IntervalValue &lhs, const IntervalValue &rhs)
	Bitwise XOR of IntervalValues.
std::ostream &	operator<< (std::ostream &o, const IntervalValue &IntervalValue)
	Write an IntervalValue on a stream.
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.
PointsTo	operator& (const PointsTo &lhs, const PointsTo &rhs)
	Returns a new lhs & rhs.
PointsTo	operator- (const PointsTo &lhs, const PointsTo &rhs)
	Returns a new lhs - rhs.
std::ostream &	operator<< (std::ostream &o, const MRVer &mrver)
bool	isMTAStatEnabled ()
std::ostream &	operator<< (std::ostream &os, const SVFType &type)
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)

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 151 of file BasicTypes.h.

AnyMemCpyInst

typedef llvm::AnyMemCpyInst SVF::AnyMemCpyInst

Definition at line 222 of file BasicTypes.h.

AnyMemIntrinsic

typedef llvm::AnyMemIntrinsic SVF::AnyMemIntrinsic

Definition at line 219 of file BasicTypes.h.

AnyMemMoveInst

typedef llvm::AnyMemMoveInst SVF::AnyMemMoveInst

Definition at line 223 of file BasicTypes.h.

AnyMemSetInst

typedef llvm::AnyMemSetInst SVF::AnyMemSetInst

Definition at line 220 of file BasicTypes.h.

AnyMemTransferInst

typedef llvm::AnyMemTransferInst SVF::AnyMemTransferInst

Definition at line 221 of file BasicTypes.h.

APOffset

typedef s64_t SVF::APOffset

Definition at line 80 of file GeneralType.h.

Argument

typedef llvm::Argument SVF::Argument

Definition at line 146 of file BasicTypes.h.

ArrayType

typedef llvm::ArrayType SVF::ArrayType

Definition at line 93 of file BasicTypes.h.

AssumeInst

typedef llvm::AssumeInst SVF::AssumeInst

Definition at line 236 of file BasicTypes.h.

AtomicCmpXchgInst

typedef llvm::AtomicCmpXchgInst SVF::AtomicCmpXchgInst

Definition at line 152 of file BasicTypes.h.

AtomicMemCpyInst

typedef llvm::AtomicMemCpyInst SVF::AtomicMemCpyInst

Definition at line 208 of file BasicTypes.h.

AtomicMemIntrinsic

typedef llvm::AtomicMemIntrinsic SVF::AtomicMemIntrinsic

Definition at line 205 of file BasicTypes.h.

AtomicMemMoveInst

typedef llvm::AtomicMemMoveInst SVF::AtomicMemMoveInst

Definition at line 209 of file BasicTypes.h.

AtomicMemSetInst

typedef llvm::AtomicMemSetInst SVF::AtomicMemSetInst

Definition at line 206 of file BasicTypes.h.

AtomicMemTransferInst

typedef llvm::AtomicMemTransferInst SVF::AtomicMemTransferInst

Definition at line 207 of file BasicTypes.h.

AtomicRMWInst

typedef llvm::AtomicRMWInst SVF::AtomicRMWInst

Definition at line 153 of file BasicTypes.h.

BasicBlock

typedef llvm::BasicBlock SVF::BasicBlock

Definition at line 84 of file BasicTypes.h.

BinaryOperator

typedef llvm::BinaryOperator SVF::BinaryOperator

Definition at line 180 of file BasicTypes.h.

BinaryOpIntrinsic

typedef llvm::BinaryOpIntrinsic SVF::BinaryOpIntrinsic

Definition at line 201 of file BasicTypes.h.

BitCastInst

typedef llvm::BitCastInst SVF::BitCastInst

Definition at line 154 of file BasicTypes.h.

BlockAddress

typedef llvm::BlockAddress SVF::BlockAddress

Definition at line 89 of file BasicTypes.h.

BranchInst

typedef llvm::BranchInst SVF::BranchInst

Definition at line 155 of file BasicTypes.h.

bridge_gep_iterator

typedef llvm::bridge_gep_iterator SVF::bridge_gep_iterator

Definition at line 255 of file BasicTypes.h.

CallBase

typedef llvm::CallBase SVF::CallBase

Definition at line 147 of file BasicTypes.h.

CallBrInst

typedef llvm::CallBrInst SVF::CallBrInst

Definition at line 157 of file BasicTypes.h.

CallInst

typedef llvm::CallInst SVF::CallInst

Definition at line 148 of file BasicTypes.h.

CallSiteID

typedef unsigned SVF::CallSiteID

Definition at line 78 of file GeneralType.h.

CallStrCxt

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

Definition at line 96 of file GeneralType.h.

CastInst

typedef llvm::CastInst SVF::CastInst

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

CmpInst

typedef llvm::CmpInst SVF::CmpInst

Definition at line 160 of file BasicTypes.h.

const_inst_iterator

typedef llvm::const_inst_iterator SVF::const_inst_iterator

Definition at line 253 of file BasicTypes.h.

const_pred_iterator

typedef llvm::const_pred_iterator SVF::const_pred_iterator

Definition at line 257 of file BasicTypes.h.

Constant

typedef llvm::Constant SVF::Constant

Definition at line 122 of file BasicTypes.h.

ConstantAggregate

typedef llvm::ConstantAggregate SVF::ConstantAggregate

Definition at line 115 of file BasicTypes.h.

ConstantAggregateZero

typedef llvm::ConstantAggregateZero SVF::ConstantAggregateZero

Definition at line 116 of file BasicTypes.h.

ConstantArray

typedef llvm::ConstantArray SVF::ConstantArray

Definition at line 121 of file BasicTypes.h.

ConstantData

typedef llvm::ConstantData SVF::ConstantData

Definition at line 114 of file BasicTypes.h.

ConstantDataArray

typedef llvm::ConstantDataArray SVF::ConstantDataArray

Definition at line 119 of file BasicTypes.h.

ConstantDataSequential

typedef llvm::ConstantDataSequential SVF::ConstantDataSequential

Definition at line 117 of file BasicTypes.h.

ConstantExpr

typedef llvm::ConstantExpr SVF::ConstantExpr

Definition at line 118 of file BasicTypes.h.

ConstantFP

typedef llvm::ConstantFP SVF::ConstantFP

Definition at line 124 of file BasicTypes.h.

ConstantInt

typedef llvm::ConstantInt SVF::ConstantInt

Definition at line 123 of file BasicTypes.h.

ConstantPointerNull

typedef llvm::ConstantPointerNull SVF::ConstantPointerNull

Definition at line 125 of file BasicTypes.h.

ConstantStruct

typedef llvm::ConstantStruct SVF::ConstantStruct

Definition at line 104 of file BasicTypes.h.

ConstrainedFPCmpIntrinsic

typedef llvm::ConstrainedFPCmpIntrinsic SVF::ConstrainedFPCmpIntrinsic

Definition at line 199 of file BasicTypes.h.

ConstrainedFPIntrinsic

typedef llvm::ConstrainedFPIntrinsic SVF::ConstrainedFPIntrinsic

Definition at line 198 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 50 of file ContextDDA.h.

CxtPtSet

typedef CondStdSet<CxtVar> SVF::CxtPtSet

Definition at line 387 of file DPItem.h.

CxtVar

typedef CondVar< ContextCond > SVF::CxtVar

Context-, flow- sensitive DPItem

Context DPItem

Definition at line 386 of file DPItem.h.

DataLayout

typedef llvm::DataLayout SVF::DataLayout

Definition at line 106 of file BasicTypes.h.

DbgDeclareInst

typedef llvm::DbgDeclareInst SVF::DbgDeclareInst

Definition at line 193 of file BasicTypes.h.

DbgInfoIntrinsic

typedef llvm::DbgInfoIntrinsic SVF::DbgInfoIntrinsic

Definition at line 191 of file BasicTypes.h.

DbgLabelInst

typedef llvm::DbgLabelInst SVF::DbgLabelInst

Definition at line 196 of file BasicTypes.h.

DbgValueInst

typedef llvm::DbgValueInst SVF::DbgValueInst

Definition at line 195 of file BasicTypes.h.

DbgVariableIntrinsic

typedef llvm::DbgVariableIntrinsic SVF::DbgVariableIntrinsic

Definition at line 192 of file BasicTypes.h.

DebugInfoFinder

typedef llvm::DebugInfoFinder SVF::DebugInfoFinder

Definition at line 242 of file BasicTypes.h.

DIBasicType

typedef llvm::DIBasicType SVF::DIBasicType

Definition at line 244 of file BasicTypes.h.

DICompositeType

typedef llvm::DICompositeType SVF::DICompositeType

Definition at line 240 of file BasicTypes.h.

DIDerivedType

typedef llvm::DIDerivedType SVF::DIDerivedType

Definition at line 241 of file BasicTypes.h.

DINode

typedef llvm::DINode SVF::DINode

Definition at line 246 of file BasicTypes.h.

DINodeArray

typedef llvm::DINodeArray SVF::DINodeArray

Definition at line 247 of file BasicTypes.h.

DISubprogram

typedef llvm::DISubprogram SVF::DISubprogram

Definition at line 111 of file BasicTypes.h.

DISubrange

typedef llvm::DISubrange SVF::DISubrange

Definition at line 245 of file BasicTypes.h.

DISubroutineType

typedef llvm::DISubroutineType SVF::DISubroutineType

Definition at line 243 of file BasicTypes.h.

DIType

typedef llvm::DIType SVF::DIType

Definition at line 239 of file BasicTypes.h.

DITypeRefArray

typedef llvm::DITypeRefArray SVF::DITypeRefArray

Definition at line 248 of file BasicTypes.h.

DominanceFrontier

typedef llvm::DominanceFrontier SVF::DominanceFrontier

Definition at line 136 of file BasicTypes.h.

DominanceFrontierBase

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

Definition at line 138 of file BasicTypes.h.

DominatorTree

typedef llvm::DominatorTree SVF::DominatorTree

LLVM Dominators.

Definition at line 134 of file BasicTypes.h.

DomTreeNode

typedef llvm::DomTreeNode SVF::DomTreeNode

Definition at line 135 of file BasicTypes.h.

DSOLocalEquivalent

typedef llvm::DSOLocalEquivalent SVF::DSOLocalEquivalent

Definition at line 127 of file BasicTypes.h.

EdgeID

typedef u32_t SVF::EdgeID

Definition at line 77 of file GeneralType.h.

EdgeSet

typedef NodeSet SVF::EdgeSet

Definition at line 95 of file GeneralType.h.

EdgeVector

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

Definition at line 91 of file GeneralType.h.

ExtractElementInst

typedef llvm::ExtractElementInst SVF::ExtractElementInst

Definition at line 162 of file BasicTypes.h.

ExtractValueInst

typedef llvm::ExtractValueInst SVF::ExtractValueInst

Definition at line 161 of file BasicTypes.h.

FenceInst

typedef llvm::FenceInst SVF::FenceInst

Definition at line 169 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 170 of file BasicTypes.h.

Function

typedef llvm::Function SVF::Function

Definition at line 83 of file BasicTypes.h.

FunctionCallee

typedef llvm::FunctionCallee SVF::FunctionCallee

Definition at line 271 of file BasicTypes.h.

FunctionType

typedef llvm::FunctionType SVF::FunctionType

Definition at line 96 of file BasicTypes.h.

GCProjectionInst

typedef llvm::GCProjectionInst SVF::GCProjectionInst

Definition at line 233 of file BasicTypes.h.

GCRelocateInst

typedef llvm::GCRelocateInst SVF::GCRelocateInst

Definition at line 234 of file BasicTypes.h.

GCResultInst

typedef llvm::GCResultInst SVF::GCResultInst

Definition at line 235 of file BasicTypes.h.

GCStatepointInst

typedef llvm::GCStatepointInst SVF::GCStatepointInst

Definition at line 232 of file BasicTypes.h.

GenericBasicBlockEdgeTy

typedef GenericEdge<SVFBasicBlock> SVF::GenericBasicBlockEdgeTy

Definition at line 44 of file BasicBlockG.h.

GenericBasicBlockGraphTy

typedef GenericGraph<SVFBasicBlock, BasicBlockEdge> SVF::GenericBasicBlockGraphTy

Definition at line 301 of file BasicBlockG.h.

GenericBasicBlockNodeTy

typedef GenericNode<SVFBasicBlock, BasicBlockEdge> SVF::GenericBasicBlockNodeTy

Definition at line 69 of file BasicBlockG.h.

GenericCDGEdgeTy

typedef GenericEdge<CDGNode> SVF::GenericCDGEdgeTy

Definition at line 46 of file CDG.h.

GenericCDGNodeTy

typedef GenericNode<CDGNode, CDGEdge> SVF::GenericCDGNodeTy

Definition at line 93 of file CDG.h.

GenericCDGTy

typedef GenericGraph<CDGNode, CDGEdge> SVF::GenericCDGTy

Definition at line 146 of file CDG.h.

GenericCFLEdgeTy

typedef GenericEdge<CFLNode> SVF::GenericCFLEdgeTy

Definition at line 44 of file CFLGraph.h.

GenericCFLGraphTy

typedef GenericGraph<CFLNode,CFLEdge> SVF::GenericCFLGraphTy

Edge-labeled graph for CFL Reachability analysis.

Definition at line 171 of file CFLGraph.h.

GenericCFLNodeTy

typedef GenericNode<CFLNode,CFLEdge> SVF::GenericCFLNodeTy

Definition at line 74 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 239 of file CHG.h.

GenericCHNodeTy

typedef GenericNode<CHNode, CHEdge> SVF::GenericCHNodeTy

Definition at line 105 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 53 of file ICFGNode.h.

GenericICFGTy

typedef GenericGraph<ICFGNode,ICFGEdge> SVF::GenericICFGTy

Interprocedural Control-Flow Graph (ICFG)

Definition at line 47 of file ICFG.h.

GenericPAGEdgeTy

typedef GenericEdge<SVFVar> SVF::GenericPAGEdgeTy

Definition at line 54 of file SVFStatements.h.

GenericPAGNodeTy

typedef GenericNode<SVFVar, SVFStmt> SVF::GenericPAGNodeTy

Definition at line 53 of file SVFVariables.h.

GenericPTACallGraphEdgeTy

typedef GenericEdge<CallGraphNode> SVF::GenericPTACallGraphEdgeTy

Definition at line 50 of file CallGraph.h.

GenericPTACallGraphNodeTy

typedef GenericNode<CallGraphNode, CallGraphEdge> SVF::GenericPTACallGraphNodeTy

Definition at line 175 of file CallGraph.h.

GenericPTACallGraphTy

typedef GenericGraph<CallGraphNode, CallGraphEdge> SVF::GenericPTACallGraphTy

Pointer Analysis Call Graph used internally for various pointer analysis

Definition at line 234 of file CallGraph.h.

GenericSparseObjEdgeTy

typedef GenericEdge<SparseObjNode> SVF::GenericSparseObjEdgeTy

Definition at line 16 of file SparseObjGraph.h.

GenericSparseObjGraphTy

typedef GenericGraph<SparseObjNode, SparseObjEdge> SVF::GenericSparseObjGraphTy

Definition at line 52 of file SparseObjGraph.h.

GenericSparseObjNodeTy

typedef GenericNode<SparseObjNode, SparseObjEdge> SVF::GenericSparseObjNodeTy

Definition at line 28 of file SparseObjGraph.h.

GenericTCTEdgeTy

typedef GenericEdge<TCTNode> SVF::GenericTCTEdgeTy

Definition at line 51 of file TCT.h.

GenericTCTNodeTy

typedef GenericNode<TCTNode, TCTEdge> SVF::GenericTCTNodeTy

Definition at line 86 of file TCT.h.

GenericThreadCreateTreeTy

typedef GenericGraph<TCTNode, TCTEdge> SVF::GenericThreadCreateTreeTy

Pointer Analysis Call Graph used internally for various pointer analysis

Definition at line 154 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 254 of file BasicTypes.h.

GEPOperator

typedef llvm::GEPOperator SVF::GEPOperator

Definition at line 183 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 163 of file BasicTypes.h.

GlobalAlias

typedef llvm::GlobalAlias SVF::GlobalAlias

Definition at line 129 of file BasicTypes.h.

GlobalIFunc

typedef llvm::GlobalIFunc SVF::GlobalIFunc

Definition at line 130 of file BasicTypes.h.

GlobalObject

typedef llvm::GlobalObject SVF::GlobalObject

Definition at line 73 of file BasicTypes.h.

GlobalValue

typedef llvm::GlobalValue SVF::GlobalValue

Definition at line 86 of file BasicTypes.h.

GlobalVariable

typedef llvm::GlobalVariable SVF::GlobalVariable

Definition at line 131 of file BasicTypes.h.

ICFGCycleWTO

typedef WTOCycle<ICFG> SVF::ICFGCycleWTO

Definition at line 49 of file ICFGWTO.h.

ICFGSingletonWTO

typedef WTONode<ICFG> SVF::ICFGSingletonWTO

Definition at line 48 of file ICFGWTO.h.

ICFGWTOComp

typedef WTOComponent<ICFG> SVF::ICFGWTOComp

Definition at line 47 of file ICFGWTO.h.

InlineAsm

typedef llvm::InlineAsm SVF::InlineAsm

Definition at line 126 of file BasicTypes.h.

InsertElementInst

typedef llvm::InsertElementInst SVF::InsertElementInst

Definition at line 172 of file BasicTypes.h.

InsertValueInst

typedef llvm::InsertValueInst SVF::InsertValueInst

Definition at line 168 of file BasicTypes.h.

inst_iterator

typedef llvm::inst_iterator SVF::inst_iterator

Definition at line 252 of file BasicTypes.h.

InstrProfIncrementInst

typedef llvm::InstrProfIncrementInst SVF::InstrProfIncrementInst

Definition at line 227 of file BasicTypes.h.

InstrProfIncrementInstStep

typedef llvm::InstrProfIncrementInstStep SVF::InstrProfIncrementInstStep

Definition at line 228 of file BasicTypes.h.

InstrProfValueProfileInst

typedef llvm::InstrProfValueProfileInst SVF::InstrProfValueProfileInst

Definition at line 229 of file BasicTypes.h.

Instruction

typedef llvm::Instruction SVF::Instruction

Definition at line 85 of file BasicTypes.h.

IntegerType

typedef llvm::IntegerType SVF::IntegerType

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

IntrinsicInst

typedef llvm::IntrinsicInst SVF::IntrinsicInst

Definition at line 190 of file BasicTypes.h.

IntToPtrInst

typedef llvm::IntToPtrInst SVF::IntToPtrInst

Definition at line 167 of file BasicTypes.h.

InvokeInst

typedef llvm::InvokeInst SVF::InvokeInst

Definition at line 164 of file BasicTypes.h.

IRBuilder

typedef llvm::IRBuilder SVF::IRBuilder

Definition at line 76 of file BasicTypes.h.

Label

typedef GrammarBase::Symbol SVF::Label

Definition at line 42 of file CFLSolver.h.

LandingPadInst

typedef llvm::LandingPadInst SVF::LandingPadInst

Definition at line 173 of file BasicTypes.h.

LLVMContext

typedef llvm::LLVMContext SVF::LLVMContext

Definition at line 72 of file BasicTypes.h.

LoadInst

typedef llvm::LoadInst SVF::LoadInst

Definition at line 150 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 49 of file FlowDDA.h.

Loop

typedef llvm::Loop SVF::Loop

LLVM Loop.

Definition at line 141 of file BasicTypes.h.

LoopInfo

typedef llvm::LoopInfo SVF::LoopInfo

Definition at line 142 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 = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>

Definition at line 56 of file GeneralType.h.

MDNode

typedef llvm::MDNode SVF::MDNode

Definition at line 110 of file BasicTypes.h.

MDString

typedef llvm::MDString SVF::MDString

Definition at line 99 of file BasicTypes.h.

MemCpyInlineInst

typedef llvm::MemCpyInlineInst SVF::MemCpyInlineInst

Definition at line 217 of file BasicTypes.h.

MemCpyInst

typedef llvm::MemCpyInst SVF::MemCpyInst

Definition at line 214 of file BasicTypes.h.

MemIntrinsic

typedef llvm::MemIntrinsic SVF::MemIntrinsic

Definition at line 211 of file BasicTypes.h.

MemMoveInst

typedef llvm::MemMoveInst SVF::MemMoveInst

Definition at line 215 of file BasicTypes.h.

MemoryLocation

typedef llvm::MemoryLocation SVF::MemoryLocation

Definition at line 105 of file BasicTypes.h.

MemSetInst

typedef llvm::MemSetInst SVF::MemSetInst

Definition at line 212 of file BasicTypes.h.

MemTransferInst

typedef llvm::MemTransferInst SVF::MemTransferInst

Definition at line 213 of file BasicTypes.h.

MetadataAsValue

typedef llvm::MetadataAsValue SVF::MetadataAsValue

Definition at line 100 of file BasicTypes.h.

MinMaxIntrinsic

typedef llvm::MinMaxIntrinsic SVF::MinMaxIntrinsic

Definition at line 200 of file BasicTypes.h.

Module

typedef llvm::Module SVF::Module

Definition at line 82 of file BasicTypes.h.

ModulePass

typedef llvm::ModulePass SVF::ModulePass

Definition at line 75 of file BasicTypes.h.

MRID

typedef NodeID SVF::MRID

Definition at line 54 of file MemRegion.h.

MRVERID

typedef NodeID SVF::MRVERID

Definition at line 55 of file MemRegion.h.

MRVERSION

typedef NodeID SVF::MRVERSION

Definition at line 56 of file MemRegion.h.

NamedMDNode

typedef llvm::NamedMDNode SVF::NamedMDNode

LLVM metadata and debug information.

Definition at line 109 of file BasicTypes.h.

NoAliasScopeDeclInst

typedef llvm::NoAliasScopeDeclInst SVF::NoAliasScopeDeclInst

Definition at line 231 of file BasicTypes.h.

NoCFIValue

typedef llvm::NoCFIValue SVF::NoCFIValue

Definition at line 128 of file BasicTypes.h.

NodeBS

typedef SparseBitVector SVF::NodeBS

Definition at line 82 of file GeneralType.h.

NodeDeque

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

Definition at line 94 of file GeneralType.h.

NodeID

typedef u32_t SVF::NodeID

Definition at line 76 of file GeneralType.h.

NodeList

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

Definition at line 93 of file GeneralType.h.

NodePair

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

Definition at line 85 of file GeneralType.h.

NodePairMap

typedef Map<NodePair, NodeID> SVF::NodePairMap

Definition at line 89 of file GeneralType.h.

NodePairSet

typedef Set<NodePair> SVF::NodePairSet

Definition at line 88 of file GeneralType.h.

NodePairVector

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

Definition at line 145 of file CDG.h.

NodeSet

typedef Set<NodeID> SVF::NodeSet

Definition at line 87 of file GeneralType.h.

NodeStack

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

Definition at line 92 of file GeneralType.h.

NodeVector

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

Definition at line 90 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 = std::map<Key, Value, Compare, Allocator>

Definition at line 64 of file GeneralType.h.

OrderedNodeSet

typedef OrderedSet<NodeID> SVF::OrderedNodeSet

Definition at line 86 of file GeneralType.h.

OrderedSet

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

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

Definition at line 60 of file GeneralType.h.

OutStream

typedef std::ostream SVF::OutStream

Definition at line 66 of file GeneralType.h.

PAG

typedef SVFIR SVF::PAG

Definition at line 937 of file SVFIR.h.

PAGEdge

typedef SVFStmt SVF::PAGEdge

Definition at line 41 of file IRGraph.h.

PAGNode

typedef SVFVar SVF::PAGNode

Definition at line 40 of file IRGraph.h.

PHINode

typedef llvm::PHINode SVF::PHINode

Definition at line 166 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 94 of file BasicTypes.h.

PointsToID

typedef unsigned SVF::PointsToID

Definition at line 83 of file GeneralType.h.

PostDominatorTree

typedef llvm::PostDominatorTree SVF::PostDominatorTree

Definition at line 137 of file BasicTypes.h.

PseudoProbeInst

typedef llvm::PseudoProbeInst SVF::PseudoProbeInst

Definition at line 230 of file BasicTypes.h.

raw_fd_ostream

typedef llvm::raw_fd_ostream SVF::raw_fd_ostream

LLVM outputs.

Definition at line 267 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

Initial value:

 
    pointer_iterator<pointee_iter<WrappedIteratorT, T1>, T2>

Definition at line 402 of file iterator.h.

ResumeInst

typedef llvm::ResumeInst SVF::ResumeInst

Definition at line 174 of file BasicTypes.h.

ReturnInst

typedef llvm::ReturnInst SVF::ReturnInst

Definition at line 158 of file BasicTypes.h.

s16_t

typedef signed short SVF::s16_t

Definition at line 74 of file GeneralType.h.

s32_t

typedef signed SVF::s32_t

Definition at line 68 of file GeneralType.h.

s64_t

typedef signed long long SVF::s64_t

Definition at line 70 of file GeneralType.h.

s8_t

typedef signed char SVF::s8_t

Definition at line 72 of file GeneralType.h.

SaturatingInst

typedef llvm::SaturatingInst SVF::SaturatingInst

Definition at line 203 of file BasicTypes.h.

ScalarEvolution

typedef llvm::ScalarEvolution SVF::ScalarEvolution

Definition at line 263 of file BasicTypes.h.

ScalarEvolutionWrapperPass

typedef llvm::ScalarEvolutionWrapperPass SVF::ScalarEvolutionWrapperPass

Definition at line 260 of file BasicTypes.h.

SCEV

typedef llvm::SCEV SVF::SCEV

Definition at line 264 of file BasicTypes.h.

SCEVAddRecExpr

typedef llvm::SCEVAddRecExpr SVF::SCEVAddRecExpr

Definition at line 261 of file BasicTypes.h.

SCEVConstant

typedef llvm::SCEVConstant SVF::SCEVConstant

Definition at line 262 of file BasicTypes.h.

SelectInst

typedef llvm::SelectInst SVF::SelectInst

Definition at line 175 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 = std::unordered_set<Key, Hash, KeyEqual, Allocator>

Definition at line 51 of file GeneralType.h.

ShuffleVectorInst

typedef llvm::ShuffleVectorInst SVF::ShuffleVectorInst

Definition at line 165 of file BasicTypes.h.

SlicedCallGraphNodeRef

using SVF::SlicedCallGraphNodeRef = SlicedNodeRef<SlicedThreadCallGraphView, CallGraphNode>

Definition at line 655 of file SlicedGraphs.h.

SlicedICFGNodeRef

using SVF::SlicedICFGNodeRef = SlicedNodeRef<SlicedICFGView, ICFGNode>

Definition at line 413 of file SlicedGraphs.h.

SlicedPAGNodeRef

using SVF::SlicedPAGNodeRef = SlicedNodeRef<SlicedPAGView, SVFVar>

Definition at line 857 of file SlicedGraphs.h.

SlicedSVFGNodeRef

using SVF::SlicedSVFGNodeRef = SlicedNodeRef<SlicedSVFGView, SVFGNode>

Definition at line 1056 of file SlicedGraphs.h.

SMDiagnostic

typedef llvm::SMDiagnostic SVF::SMDiagnostic

Definition at line 88 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 149 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 103 of file BasicTypes.h.

StructType

typedef llvm::StructType SVF::StructType

LLVM types.

Definition at line 92 of file BasicTypes.h.

succ_const_iterator

typedef llvm::const_succ_iterator SVF::succ_const_iterator

LLVM Iterators.

Definition at line 274 of file BasicTypes.h.

SuccBBAndCondValPair

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

Definition at line 186 of file BasicTypes.h.

SuccBBAndCondValPairVec

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

Definition at line 187 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 156 of file BasicTypes.h.

ThreadID

typedef unsigned SVF::ThreadID

Definition at line 79 of file GeneralType.h.

Type

typedef llvm::Type SVF::Type

Definition at line 81 of file BasicTypes.h.

u16_t

typedef unsigned short SVF::u16_t

Definition at line 73 of file GeneralType.h.

u32_t

typedef unsigned SVF::u32_t

Definition at line 67 of file GeneralType.h.

u64_t

typedef unsigned long long SVF::u64_t

Definition at line 69 of file GeneralType.h.

u8_t

typedef unsigned char SVF::u8_t

Definition at line 71 of file GeneralType.h.

UnaryOperator

typedef llvm::UnaryOperator SVF::UnaryOperator

Definition at line 181 of file BasicTypes.h.

UndefValue

typedef llvm::UndefValue SVF::UndefValue

Definition at line 182 of file BasicTypes.h.

UnifyFunctionExitNodes

typedef llvm::UnifyFunctionExitNodesPass SVF::UnifyFunctionExitNodes

Definition at line 77 of file BasicTypes.h.

UnreachableInst

typedef llvm::UnreachableInst SVF::UnreachableInst

Definition at line 171 of file BasicTypes.h.

Use

typedef llvm::Use SVF::Use

Definition at line 74 of file BasicTypes.h.

User

typedef llvm::User SVF::User

Definition at line 143 of file BasicTypes.h.

VAArgInst

typedef llvm::VAArgInst SVF::VAArgInst

Definition at line 176 of file BasicTypes.h.

VACopyInst

typedef llvm::VACopyInst SVF::VACopyInst

Definition at line 177 of file BasicTypes.h.

VAEndInst

typedef llvm::VAEndInst SVF::VAEndInst

Definition at line 178 of file BasicTypes.h.

Value

typedef llvm::Value SVF::Value

LLVM Basic classes.

Definition at line 80 of file BasicTypes.h.

VAStartInst

typedef llvm::VAStartInst SVF::VAStartInst

Definition at line 179 of file BasicTypes.h.

VectorType

typedef llvm::VectorType SVF::VectorType

Definition at line 270 of file BasicTypes.h.

Version

typedef unsigned SVF::Version

Definition at line 97 of file GeneralType.h.

VersionedVar

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

Definition at line 99 of file GeneralType.h.

VersionedVarSet

typedef Set<VersionedVar> SVF::VersionedVarSet

Definition at line 100 of file GeneralType.h.

VersionSet

typedef Set<Version> SVF::VersionSet

Definition at line 98 of file GeneralType.h.

VFunSet

typedef Set<const FunObjVar*> SVF::VFunSet

Definition at line 47 of file CHG.h.

VPIntrinsic

typedef llvm::VPIntrinsic SVF::VPIntrinsic

Definition at line 197 of file BasicTypes.h.

VTableSet

typedef Set<const GlobalObjVar*> SVF::VTableSet

Definition at line 46 of file CHG.h.

WithOverflowInst

typedef llvm::WithOverflowInst SVF::WithOverflowInst

Definition at line 202 of file BasicTypes.h.

WPAConstraintSolver

typedef WPASolver< ConstraintGraph * > SVF::WPAConstraintSolver

Abstract class of inclusion-based Pointer Analysis

Equivalence-based Pointer Analysis

Definition at line 58 of file Andersen.h.

WPASVFGFSSolver

typedef WPAFSSolver<SVFG*> SVF::WPASVFGFSSolver

Flow sensitive whole program pointer analysis

Definition at line 46 of file FlowSensitive.h.

Enumeration Type Documentation

AliasResult

enum SVF::AliasResult

Enumerator
NoAlias
MayAlias
MustAlias
PartialAlias

Definition at line 618 of file SVFType.h.

{
    NoAlias,
    MayAlias,
    MustAlias,
    PartialAlias,
};

BuildDirection

enum class SVF::BuildDirection

strong

Enumerator
plain
bidirection

Definition at line 41 of file CFLGraphBuilder.h.

{
    plain,
    bidirection,
};

ModRefInfo

enum SVF::ModRefInfo

Enumerator
ModRef
Ref
Mod
NoModRef

Definition at line 610 of file SVFType.h.

{
    ModRef,
    Ref,
    Mod,
    NoModRef,
};

PTAImplTy

enum SVF::PTAImplTy

Implementation type: BVDataPTAImpl or CondPTAImpl.

Enumerator
BaseImpl	Represents PointerAnalaysis.
BVDataImpl	Represents BVDataPTAImpl.
CondImpl	Represents CondPTAImpl.

Definition at line 39 of file PTATY.h.

{
    BaseImpl,   
    BVDataImpl, 
    CondImpl,   
};

PTATY

enum SVF::PTATY

Pointer analysis type list.

Enumerator
Andersen_BASE	Base Andersen PTA.
Andersen_WPA	Andersen PTA.
AndersenSCD_WPA	Selective cycle detection andersen-style WPA.
AndersenSFR_WPA	Stride-based field representation.
AndersenWaveDiff_WPA	Diff wave propagation andersen-style WPA.
Steensgaard_WPA	Steensgaard PTA.
CSCallString_WPA	Call string based context sensitive WPA.
CSSummary_WPA	Summary based context sensitive WPA.
FSDATAFLOW_WPA	Traditional Dataflow-based flow sensitive WPA.
FSSPARSE_WPA	Sparse flow sensitive WPA.
VFS_WPA	Versioned sparse flow-sensitive WPA.
FSCS_WPA	Flow-, context- sensitive WPA.
CFLFICI_WPA	Flow-, context-, insensitive CFL-reachability-based analysis.
CFLFSCI_WPA	Flow-insensitive, context-sensitive CFL-reachability-based analysis.
CFLFSCS_WPA	Flow-, context-, CFL-reachability-based analysis.
TypeCPP_WPA	Type-based analysis for C++.
FieldS_DDA	Field sensitive DDA.
FlowS_DDA	Flow sensitive DDA.
PathS_DDA	Guarded value-flow DDA.
Cxt_DDA	context sensitive DDA
Default_PTA	default pta without any analysis

Definition at line 8 of file PTATY.h.

{
    // Whole program analysis
    Andersen_BASE,      
    Andersen_WPA,       
    AndersenSCD_WPA,    
    AndersenSFR_WPA,    
    AndersenWaveDiff_WPA,   
    Steensgaard_WPA,      
    CSCallString_WPA,   
    CSSummary_WPA,      
    FSDATAFLOW_WPA, 
    FSSPARSE_WPA,       
    VFS_WPA,        
    FSCS_WPA,           
    CFLFICI_WPA,        
    CFLFSCI_WPA,        
    CFLFSCS_WPA,    
    TypeCPP_WPA, 
 
    // Demand driven analysis
    FieldS_DDA,     
    FlowS_DDA,      
    PathS_DDA,      
    Cxt_DDA,        
 
 
    Default_PTA     
};

PTBackingType

enum SVF::PTBackingType

How the PTData used is implemented.

Enumerator
Mutable
Persistent

Definition at line 47 of file PTATY.h.

{
    Mutable,
    Persistent,
};

TargetABI

enum class SVF::TargetABI

strong

C++ ABI inferred from the target triple.

Enumerator
Itanium
MSVC

Definition at line 45 of file LLVMUtil.h.

{
    Itanium,
    MSVC,
};

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 38 of file SparseBitVector.h.

{
    ZB_Undefined,
    ZB_Max,
    ZB_Width
};

Function Documentation

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 213 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 241 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 121 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);
}

dump()

template<unsigned ElementSize>

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

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

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

isMTAStatEnabled()

bool SVF::isMTAStatEnabled ( )

inline

MTA's phase and slice reports are opt-in. PStat itself defaults to true in SVF, so its value alone does not indicate that the user requested -stat.

Definition at line 46 of file MTAStat.h.

{
    return Options::PStat.isSet() && Options::PStat();
}

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 492 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 949 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 585 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 1215 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 1195 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 1188 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 593 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 1225 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.

{
    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();
        // Zero stays zero for any admitted shift, even an unbounded one.
        if (lhs.equals(IntervalValue(0)))
            return lhs;
        // 1 << 31 overflows a signed 32-bit coefficient and may create an
        // invalid interval whose lower bound is greater than its upper bound.
        if (shift.ub().is_infinity() || shift.ub().getIntNumeral() >= 31)
            return IntervalValue::top();
        const s32_t low = static_cast<s32_t>(shift.lb().getIntNumeral());
        const s32_t high = static_cast<s32_t>(shift.ub().getIntNumeral());
        return lhs * IntervalValue(s64_t(1) << low, s64_t(1) << high);
    }
}

operator<<() [2/5]

template<typename F, typename S>

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

Definition at line 331 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 1034 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 812 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 )

Definition at line 17 of file SVFType.cpp.

{
    type.print(os);
    return os;
}

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 914 of file IntervalValue.h.

{
    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 1005 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 976 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 577 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 1205 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 1174 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 1181 of file SparseBitVector.h.

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

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 377 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 351 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 334 of file GraphWriter.h.

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