for isBitcode More...

Namespaces
namespace	cppUtil

namespace	DOT

namespace	GraphProgram

namespace	LLVMUtil

namespace	SVFUtil

Classes
class	AbsExtAPI
	Handles external API calls and manages abstract states. More...

class	AbstractInterpretation
	AbstractInterpretation is same as Abstract Execution. More...

class	AbstractState

class	AbstractValue

class	AccessPath

class	ActualINSVFGNode

class	ActualOUTSVFGNode

class	ActualParmVFGNode

class	ActualRetVFGNode

class	AddrCGEdge

class	AddressValue

class	AddrStmt

class	AddrVFGNode

class	AEDetector
	Base class for all detectors. More...

class	AEException
	Exception class for handling errors in Abstract Execution. More...

class	AEStat
	AEStat: Statistic for AE. More...

class	AliasCFLGraphBuilder
	AliasCFLGraphBuilder: a CFLGraphBuilder specialized for handling aliasing. More...

class	AliasDDAClient

class	Andersen

class	AndersenBase

class	AndersenSCD

class	AndersenSFR

class	AndersenStat

class	AndersenWaveDiff

class	Annotator

class	ArgumentVFGNode

class	AssignStmt

class	BaseObjVar

class	BinaryOPStmt

class	BinaryOPVFGNode

class	BitVector

class	BoundedDouble

class	BoundedInt
	A class representing a bounded 64-bit integer. More...

class	BranchStmt

class	BranchVFGNode

class	BreakConstantGEPs

class	BufferOverflowBug

class	BufOverflowDetector
	Detector for identifying buffer overflow issues. More...

class	BVDataPTAImpl

class	CallCFGEdge

class	CallCHI

class	CallDirSVFGEdge

class	CallGraph

class	CallGraphBuilder

class	CallGraphEdge

class	CallGraphNode

class	CallICFGNode

class	CallIndSVFGEdge

class	CallMU

class	CallPE

class	CDG

class	CDGBuilder

class	CDGEdge

class	CDGNode

class	CFGNormalizer

class	CFGrammar

class	CFLAlias

class	CFLBase
	CFL Client Base Class. More...

class	CFLEdge

class	CFLFIFOWorkList

class	CFLGramGraphChecker

class	CFLGraph

class	CFLGraphBuilder

class	CFLNode

class	CFLSolver

class	CFLStat

class	CFLSVFGBuilder

class	CFLVF

class	CHEdge

class	CHGBuilder

class	CHGraph

class	CHNode

class	CmpStmt

class	CmpVFGNode

class	CommonCHGraph
	Common base for class hierarchy graph. Only implements what PointerAnalysis needs. More...

class	CondPointsToSet

class	CondPTAImpl

class	CondStdSet

class	CondVar

class	ConstraintEdge

class	ConstraintGraph

class	ConstraintNode

class	ContextCond

class	ContextDDA

class	CopyCGEdge

class	CopyStmt

class	CopyVFGNode

class	CoreBitVector

class	CSC

class	CxtDPItem

class	CxtProc

class	CxtStmt

class	CxtStmtDPItem

class	CxtThread

class	CxtThreadProc

class	CxtThreadStmt

class	DCHEdge

class	DCHGraph
	Dwarf based CHG. More...

class	DCHNode

class	DDAClient

class	DDAPass

class	DDAStat

class	DDAVFSolver

struct	DefaultDOTGraphTraits

class	DFPTData

class	DiffPTData

class	DirectSVFGEdge

class	DistinctMRG

struct	DOTGraphTraits

struct	DOTGraphTraits< CallGraph * >

struct	DOTGraphTraits< CFLGraph * >

struct	DOTGraphTraits< CHGraph * >

struct	DOTGraphTraits< ConstraintGraph * >

struct	DOTGraphTraits< ICFG * >

struct	DOTGraphTraits< IRGraph * >

struct	DOTGraphTraits< PTACallGraph * >

struct	DOTGraphTraits< SVF::CDG * >

struct	DOTGraphTraits< SVFG * >

struct	DOTGraphTraits< TCT * >

struct	DOTGraphTraits< VFG * >

class	DoubleFreeBug

class	DoubleFreeChecker

class	DPItem

class	DummyObjVar

class	DummyValVar

class	DummyVersionPropSVFGNode

class	EntryCHI

class	ExtAPI

class	FIFOWorkList

class	FileChecker

class	FileNeverCloseBug

class	FilePartialCloseBug

class	FILOWorkList

class	FlowDDA

class	FlowSensitive

class	FlowSensitiveStat

class	ForkJoinAnalysis

class	FormalINSVFGNode

class	FormalOUTSVFGNode

class	FormalParmVFGNode

class	FormalRetVFGNode

class	FullBufferOverflowBug

class	FullNullPtrDereferenceBug

class	FunEntryICFGNode

class	FunExitICFGNode

class	FunObjVar

class	FunptrDDAClient

class	FunValVar

class	GenericBug

class	GenericEdge

class	GenericGraph

class	GenericGraphReader

struct	GenericGraphTraits

struct	GenericGraphTraits< Inverse< Inverse< T > > >

struct	GenericGraphTraits< Inverse< SVF::CallGraphNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...

struct	GenericGraphTraits< Inverse< SVF::CDGNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse ICFGTraversal. More...

struct	GenericGraphTraits< Inverse< SVF::CFLNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...

struct	GenericGraphTraits< Inverse< SVF::CHNode * > >

struct	GenericGraphTraits< Inverse< SVF::ConstraintNode * > >
	Inverse GenericGraphTraits specializations for Value flow node, it is used for inverse traversal. More...

struct	GenericGraphTraits< Inverse< SVF::DCHNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...

struct	GenericGraphTraits< Inverse< SVF::GenericNode< NodeTy, EdgeTy > * > >

struct	GenericGraphTraits< Inverse< SVF::ICFGNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...

struct	GenericGraphTraits< Inverse< SVF::PTACallGraphNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...

struct	GenericGraphTraits< Inverse< SVF::SVFVar * > >
	Inverse GenericGraphTraits specializations for SVFIR node, it is used for inverse traversal. More...

struct	GenericGraphTraits< Inverse< SVF::TCTNode * > >
	Inverse GenericGraphTraits specializations for Value flow node, it is used for inverse traversal. More...

struct	GenericGraphTraits< Inverse< SVF::VFGNode * > >
	Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal. More...

struct	GenericGraphTraits< SVF::CallGraph * >

struct	GenericGraphTraits< SVF::CallGraphNode * >

struct	GenericGraphTraits< SVF::CDG * >

struct	GenericGraphTraits< SVF::CDGNode * >

struct	GenericGraphTraits< SVF::CFLGraph * >

struct	GenericGraphTraits< SVF::CFLNode * >

struct	GenericGraphTraits< SVF::CHGraph * >

struct	GenericGraphTraits< SVF::CHNode * >

struct	GenericGraphTraits< SVF::ConstraintGraph * >

struct	GenericGraphTraits< SVF::ConstraintNode * >

struct	GenericGraphTraits< SVF::DCHGraph * >

struct	GenericGraphTraits< SVF::DCHNode * >

struct	GenericGraphTraits< SVF::GenericGraph< NodeTy, EdgeTy > * >

struct	GenericGraphTraits< SVF::GenericNode< NodeTy, EdgeTy > * >

struct	GenericGraphTraits< SVF::ICFG * >

struct	GenericGraphTraits< SVF::ICFGNode * >

struct	GenericGraphTraits< SVF::IRGraph * >

struct	GenericGraphTraits< SVF::PTACallGraph * >

struct	GenericGraphTraits< SVF::PTACallGraphNode * >

struct	GenericGraphTraits< SVF::SVFG * >

struct	GenericGraphTraits< SVF::SVFVar * >

struct	GenericGraphTraits< SVF::TCT * >

struct	GenericGraphTraits< SVF::TCTNode * >

struct	GenericGraphTraits< SVF::VFG * >

struct	GenericGraphTraits< SVF::VFGNode * >

class	GenericGraphWriter

class	GenericNode

class	GepCGEdge

class	GepObjVar

class	GepStmt

class	GepValVar

class	GepVFGNode

class	GlobalICFGNode

class	GrammarBase

class	GrammarBuilder

class	GraphPrinter

class	GraphReachSolver

class	GraphWriter

class	HareParForEdge

struct	has_edgetype

struct	has_edgetype< T, std::void_t< typename T::EdgeType > >

struct	has_nodetype

struct	has_nodetype< T, std::void_t< typename T::NodeType > >

struct	Hash
	provide extra hash function for std::pair handling More...

struct	Hash< CoreBitVector >

struct	Hash< NodePair >

struct	Hash< std::pair< S, T > >

class	HeapObjVar
	Class representing a heap object variable in the SVFIR. More...

class	ICFG

class	ICFGBuilder

class	ICFGEdge

class	ICFGNode

class	ICFGReader

class	ICFGStat

class	ICFGWriter

class	ICFGWTO

class	IndirectSVFGEdge

class	InterDisjointMRG

class	InterICFGNode

class	InterMSSAPHISVFGNode

class	InterPHIVFGNode

class	IntervalValue

class	IntraCFGEdge

class	IntraDirSVFGEdge

class	IntraDisjointMRG

class	IntraICFGNode

class	IntraIndSVFGEdge

class	IntraMSSAPHISVFGNode

class	IntraPHIVFGNode

struct	Inverse

class	IRGraph

class	iter_adaptor_base

class	iter_facade_base

class	iter_range

struct	KindBaseHelper
	Type trait to get base type. Helper struct to detect inheritance from Node/Edge. More...

struct	LeadingZerosCounter

class	LeakChecker

class	List

class	LLVMLoopAnalysis

class	LLVMModuleSet

class	LoadCGEdge

class	LoadMU

class	LoadStmt

class	LoadVFGNode

class	LockAnalysis

class	mapped_iter

class	MemObj

class	MemRegion
	Memory Region class. More...

class	MemSSA

class	MemSSAStat

class	MergeFunctionRets

class	MHP

class	MRGenerator

class	MRSVFGNode

class	MRVer

class	MSSACHI

class	MSSADEF

class	MSSAMU

class	MSSAPHI

class	MSSAPHISVFGNode

class	MTA

class	MTAStat

class	MultiOpndStmt

class	MutableDFPTData

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	MutablePTData
	PTData implemented using points-to sets which are created once and updated continuously. More...

class	MutableVersionedPTData

class	NeverFreeBug

class	NodeIDAllocator

class	NormalGepCGEdge

class	NullPtrVFGNode

class	ObjTypeInference

class	ObjTypeInfo

class	ObjVar

class	Options
	Carries around command line options. More...

class	PAGBuilderFromFile

class	PartialBufferOverflowBug

class	PartialLeakBug

class	PartialNullPtrDereferenceBug

class	PersistentDFPTData
	DFPTData backed by a PersistentPointsToCache. More...

class	PersistentDiffPTData
	DiffPTData implemented with a persistent points-to backing. More...

class	PersistentIncDFPTData
	Incremental version of the persistent data-flow points-to data structure. More...

class	PersistentPointsToCache

class	PersistentPTData
	PTData backed by a PersistentPointsToCache. More...

class	PersistentVersionedPTData

class	PhiStmt

class	PHIVFGNode

class	POCRAlias

class	POCRHybrid

class	POCRHybridSolver
	Solver Utilize Hybrid Representation of Graph. More...

class	POCRSolver
	Solver Utilize CFLData. More...

struct	pointee_iter

class	pointer_iterator

class	PointerAnalysis

class	PointsTo

struct	PopulationCounter

struct	PopulationCounter< T, 8 >

class	ProgSlice

class	PTACallGraph

class	PTACallGraphEdge

class	PTACallGraphNode

class	PTAStat

class	PTData

class	ReaderIDToObjMap
	Keeps a map from IDs to T objects, such as XXNode. More...

class	ReaderPtrPool
	Reverse of WriterPtrPool where T is object type without ID field. More...

class	RelationSolver

class	RelExeState

class	RetCFGEdge

class	RetDirSVFGEdge

class	RetICFGNode

class	RetIndSVFGEdge

class	RetMU

class	RetPE

class	RetPN

class	SaberCheckerAPI

class	SaberCondAllocator

class	SaberSVFGBuilder

class	SCCDetection

class	SelectStmt

class	SparseBitVector

struct	SparseBitVectorElement

class	SrcSnkDDA

class	SrcSnkSolver

class	StackObjVar
	Represents a stack-allocated object variable in the SVFIR (SVF Intermediate Representation) @inherits BaseObjVar. More...

class	Steensgaard

class	StInfo

class	StmtDPItem

class	StmtVFGNode

class	StoreCGEdge

class	StoreCHI

class	StoreStmt

class	StoreVFGNode

class	SVFArgument

class	SVFArrayType

class	SVFBaseNode

class	SVFBasicBlock

class	SVFBlackHoleValue

class	SVFBugEvent

class	SVFBugReport

class	SVFCallInst

class	SVFConstant

class	SVFConstantData

class	SVFConstantFP

class	SVFConstantInt

class	SVFConstantNullPtr

class	SVFFunction

class	SVFFunctionType

class	SVFG

class	SVFGBuilder

class	SVFGlobalValue

class	SVFGOPT

class	SVFGStat

class	SVFInstruction

class	SVFIntegerType

class	SVFIR

class	SVFIRBuilder

class	SVFIRReader

class	SVFIRWriter

class	SVFLoop

class	SVFLoopAndDomInfo

class	SVFMetadataAsValue

class	SVFModule

class	SVFModuleReader

class	SVFModuleWriter

class	SVFOtherType

class	SVFOtherValue

class	SVFPointerType

class	SVFStat

class	SVFStmt

class	SVFStructType

class	SVFType

class	SVFValue

class	SVFVar

class	SymbolTableBuilder

class	SymbolTableInfo

class	SymbolTableInfoReader

class	TCT

class	TCTEdge

class	TCTNode

class	TDForkPE

class	TDJoinPE

class	ThreadAPI

class	ThreadCallGraph

class	ThreadForkEdge

class	ThreadJoinEdge

class	ThreadMHPIndSVFGEdge

struct	TrailingZerosCounter

class	TypeAnalysis

class	UnaryOPStmt

class	UnaryOPVFGNode

class	ValVar

class	VarArgPN

class	VariantGepCGEdge

class	VersionedFlowSensitive

class	VersionedFlowSensitiveStat

class	VersionedPTData

class	VFCFLGraphBuilder
	VFCFLGraphBuilder: a CFLGraphBuilder specialized for handling value-flow. More...

class	VFG

class	VFGEdge

class	VFGNode

class	WPAFSSolver

class	WPAMinimumSolver

class	WPAPass

class	WPASCCSolver

class	WPASolver

class	WriterPtrPool
	Bookkeeping class to keep track of the IDs of objects that doesn't have any ID. E.g., SVFValue, XXXEdge. More...

class	WTO

class	WTOComponent

class	WTOComponentVisitor

class	WTOCycle

class	WTOCycleDepth

class	WTONode

class	Z3Expr

Typedefs
typedef llvm::LLVMContext	LLVMContext

typedef llvm::GlobalObject	GlobalObject

typedef llvm::Use	Use

typedef llvm::ModulePass	ModulePass

typedef llvm::IRBuilder	IRBuilder

typedef llvm::UnifyFunctionExitNodes	UnifyFunctionExitNodes

typedef llvm::Value	Value
	LLVM Basic classes.

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::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::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::succ_const_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< CallGraphNode >	GenericCallGraphEdgeTy

typedef GenericNode< CallGraphNode, CallGraphEdge >	GenericCallGraphNodeTy

typedef GenericGraph< CallGraphNode, CallGraphEdge >	GenericCallGraphTy

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 SVFGlobalValue * >	VTableSet

typedef Set< const SVFFunction * >	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

typedef GenericEdge< PTACallGraphNode >	GenericPTACallGraphEdgeTy

typedef GenericNode< PTACallGraphNode, PTACallGraphEdge >	GenericPTACallGraphNodeTy

typedef GenericGraph< PTACallGraphNode, PTACallGraphEdge >	GenericPTACallGraphTy

typedef VFGEdge	SVFGEdge

typedef VFGNode	SVFGNode

typedef ActualParmVFGNode	ActualParmSVFGNode

typedef ActualRetVFGNode	ActualRetSVFGNode

typedef FormalParmVFGNode	FormalParmSVFGNode

typedef FormalRetVFGNode	FormalRetSVFGNode

typedef NullPtrVFGNode	NullPtrSVFGNode

typedef StmtVFGNode	StmtSVFGNode

typedef AddrVFGNode	AddrSVFGNode

typedef CopyVFGNode	CopySVFGNode

typedef StoreVFGNode	StoreSVFGNode

typedef LoadVFGNode	LoadSVFGNode

typedef GepVFGNode	GepSVFGNode

typedef PHIVFGNode	PHISVFGNode

typedef IntraPHIVFGNode	IntraPHISVFGNode

typedef InterPHIVFGNode	InterPHISVFGNode

typedef GenericGraph< VFGNode, VFGEdge >	GenericVFGTy

typedef GenericEdge< VFGNode >	GenericVFGEdgeTy

typedef GenericNode< VFGNode, VFGEdge >	GenericVFGNodeTy

typedef NodeID	MRID

typedef NodeID	MRVERID

typedef NodeID	MRVERSION

typedef GenericEdge< TCTNode >	GenericTCTEdgeTy

typedef GenericNode< TCTNode, TCTEdge >	GenericTCTNodeTy

typedef GenericGraph< TCTNode, TCTEdge >	GenericThreadCreateTreeTy

typedef GraphReachSolver< SVFG *, CxtDPItem >	CFLSrcSnkSolver

using	GenericICFGWriter = GenericGraphWriter< ICFGNode, ICFGEdge >

using	IRGraphWriter = GenericGraphWriter< SVFVar, SVFStmt >

using	CHGraphWriter = GenericGraphWriter< CHNode, CHEdge >

template<typename T >
using	KindBaseT = typename KindBaseHelper< T >::type

using	GenericICFGReader = GenericGraphReader< ICFGNode, ICFGEdge >

using	CHGraphReader = GenericGraphReader< CHNode, CHEdge >

using	IRGraphReader = GenericGraphReader< SVFVar, SVFStmt >

typedef SVFIR	PAG

typedef GenericEdge< SVFVar >	GenericPAGEdgeTy

typedef SVF::GraphPrinter	GraphPrinter
	LLVM Aliases and constants.

typedef GenericNode< SVFVar, SVFStmt >	GenericPAGNodeTy

typedef CondVar< ContextCond >	CxtVar

typedef CondStdSet< CxtVar >	CxtPtSet

typedef std::ostream	OutStream

typedef unsigned	u32_t

typedef signed	s32_t

typedef unsigned long long	u64_t

typedef signed long long	s64_t

typedef unsigned char	u8_t

typedef signed char	s8_t

typedef unsigned short	u16_t

typedef signed short	s16_t

typedef u32_t	NodeID

typedef u32_t	EdgeID

typedef unsigned	SymID

typedef unsigned	CallSiteID

typedef unsigned	ThreadID

typedef s64_t	APOffset

typedef SparseBitVector	NodeBS

typedef unsigned	PointsToID

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

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

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

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

typedef std::pair< NodeID, NodeID >	NodePair

typedef OrderedSet< NodeID >	OrderedNodeSet

typedef Set< NodeID >	NodeSet

typedef Set< NodePair >	NodePairSet

typedef Map< NodePair, NodeID >	NodePairMap

typedef std::vector< NodeID >	NodeVector

typedef std::vector< EdgeID >	EdgeVector

typedef std::stack< NodeID >	NodeStack

typedef std::list< NodeID >	NodeList

typedef std::deque< NodeID >	NodeDeque

typedef NodeSet	EdgeSet

typedef std::vector< u32_t >	CallStrCxt

typedef unsigned	Version

typedef Set< Version >	VersionSet

typedef std::pair< NodeID, Version >	VersionedVar

typedef Set< VersionedVar >	VersionedVarSet

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

typedef WPASolver< ConstraintGraph * >	WPAConstraintSolver

typedef SCCDetection< ConstraintGraph * >	CGSCC

typedef WPAFSSolver< SVFG * >	WPASVFGFSSolver

Enumerations
enum class	BuildDirection { plain , bidirection }

enum	ModRefInfo { ModRef , Ref , Mod , NoModRef }

enum	AliasResult { NoAlias , MayAlias , MustAlias , PartialAlias }

enum	ZeroBehavior { ZB_Undefined , ZB_Max , ZB_Width }
	The behavior an operation has on an input of 0. More...

Functions
IntervalValue	operator+ (const IntervalValue &lhs, const IntervalValue &rhs)
	Add IntervalValues.

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	jsonIsBool (const cJSON *item)

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

bool	jsonIsNumber (const cJSON *item)

bool	jsonIsString (const cJSON *item)

bool	jsonIsNullId (const cJSON *item)

bool	jsonIsArray (const cJSON *item)

bool	jsonIsMap (const cJSON *item)

bool	jsonIsObject (const cJSON *item)

bool	jsonKeyEquals (const cJSON item, const char key)

std::pair< const cJSON , const cJSON >	jsonUnpackPair (const cJSON *item)

double	jsonGetNumber (const cJSON *item)

cJSON *	jsonCreateNullId ()

cJSON *	jsonCreateObject ()

cJSON *	jsonCreateArray ()

cJSON *	jsonCreateString (const char *str)

cJSON *	jsonCreateIndex (size_t index)

cJSON *	jsonCreateBool (bool flag)

cJSON *	jsonCreateNumber (double num)

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

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

bool	jsonAddItemToArray (cJSON array, cJSON item)

bool	jsonAddNumberToObject (cJSON obj, const char name, double number)
	Helper function to write a number to a JSON object.

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

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

	KIND_BASE (SVFType, getKind)

	KIND_BASE (SVFValue, getKind)

	KIND_BASE (SVFVar, getNodeKind)

	KIND_BASE (SVFStmt, getEdgeKind)

	KIND_BASE (ICFGNode, getNodeKind)

	KIND_BASE (ICFGEdge, getEdgeKind)

	KIND_BASE (CHNode, getNodeKind)

	KIND_BASE (CHEdge, getEdgeKind)

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

std::string	dumpLLVMValue (const SVFValue *svfValue)

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

template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
iter_range< pointee_iter< WrappedIteratorT > >	make_pointee_range (RangeT &&Range)

template<typename RangeT , typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
iter_range< pointer_iterator< WrappedIteratorT > >	make_pointer_range (RangeT &&Range)

template<class T >
iter_range< T >	make_range (T x, T y)

template<typename T >
iter_range< T >	make_range (std::pair< T, T > p)

template<typename T >
unsigned	countTrailingZeros (T Val, ZeroBehavior ZB=ZB_Width)

template<typename T >
unsigned	countLeadingZeros (T Val, ZeroBehavior ZB=ZB_Width)

template<typename T >
unsigned	countPopulation (T Value)

template<unsigned ElementSize>
bool	operator\|= (SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > *RHS)

template<unsigned ElementSize>
bool	operator\|= (SparseBitVector< ElementSize > *LHS, const SparseBitVector< ElementSize > &RHS)

template<unsigned ElementSize>
bool	operator&= (SparseBitVector< ElementSize > *LHS, const SparseBitVector< ElementSize > &RHS)

template<unsigned ElementSize>
bool	operator&= (SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > *RHS)

template<unsigned ElementSize>
SparseBitVector< ElementSize >	operator\| (const SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > &RHS)

template<unsigned ElementSize>
SparseBitVector< ElementSize >	operator& (const SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > &RHS)

template<unsigned ElementSize>
SparseBitVector< ElementSize >	operator- (const SparseBitVector< ElementSize > &LHS, const SparseBitVector< ElementSize > &RHS)

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

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

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

template<typename SmallNumberType >
static void	readSmallNumber (const cJSON *obj, SmallNumberType &val)

template<typename BigNumberType , typename CStrToVal >
static void	readBigNumber (const cJSON *obj, BigNumberType &val, CStrToVal conv)

cJSON *	jsonCreateMap ()

	__attribute__ ((weak)) std

Detailed Description

for isBitcode

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

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

Hierarchy (square brackets indicate abstract class):

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

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

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

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

GraphTraits specialization for constraint graph

GraphTraits specialization

Typedef Documentation

◆ ActualParmSVFGNode

typedef ActualParmVFGNode SVF::ActualParmSVFGNode

Definition at line 44 of file SVFG.h.

◆ ActualRetSVFGNode

typedef ActualRetVFGNode SVF::ActualRetSVFGNode

Definition at line 45 of file SVFG.h.

◆ AddrSVFGNode

typedef AddrVFGNode SVF::AddrSVFGNode

Definition at line 51 of file SVFG.h.

◆ AllocaInst

typedef llvm::AllocaInst SVF::AllocaInst

Definition at line 150 of file BasicTypes.h.

◆ APOffset

typedef s64_t SVF::APOffset

Definition at line 60 of file GeneralType.h.

◆ Argument

typedef llvm::Argument SVF::Argument

Definition at line 145 of file BasicTypes.h.

◆ ArrayType

typedef llvm::ArrayType SVF::ArrayType

Definition at line 95 of file BasicTypes.h.

◆ AtomicCmpXchgInst

typedef llvm::AtomicCmpXchgInst SVF::AtomicCmpXchgInst

Definition at line 151 of file BasicTypes.h.

◆ AtomicRMWInst

typedef llvm::AtomicRMWInst SVF::AtomicRMWInst

Definition at line 152 of file BasicTypes.h.

◆ BasicBlock

typedef llvm::BasicBlock SVF::BasicBlock

Definition at line 86 of file BasicTypes.h.

◆ BinaryOperator

typedef llvm::BinaryOperator SVF::BinaryOperator

Definition at line 179 of file BasicTypes.h.

◆ BitCastInst

typedef llvm::BitCastInst SVF::BitCastInst

Definition at line 153 of file BasicTypes.h.

◆ BlockAddress

typedef llvm::BlockAddress SVF::BlockAddress

Definition at line 91 of file BasicTypes.h.

◆ BranchInst

typedef llvm::BranchInst SVF::BranchInst

Definition at line 154 of file BasicTypes.h.

◆ bridge_gep_iterator

typedef llvm::bridge_gep_iterator SVF::bridge_gep_iterator

Definition at line 252 of file BasicTypes.h.

◆ CallBase

typedef llvm::CallBase SVF::CallBase

Definition at line 146 of file BasicTypes.h.

◆ CallBrInst

typedef llvm::CallBrInst SVF::CallBrInst

Definition at line 156 of file BasicTypes.h.

◆ CallInst

typedef llvm::CallInst SVF::CallInst

Definition at line 147 of file BasicTypes.h.

◆ CallSiteID

typedef unsigned SVF::CallSiteID

Definition at line 58 of file GeneralType.h.

◆ CallStrCxt

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

Definition at line 122 of file GeneralType.h.

◆ CastInst

typedef llvm::CastInst SVF::CastInst

Definition at line 158 of file BasicTypes.h.

◆ CFLSrcSnkSolver

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

Definition at line 49 of file SrcSnkDDA.h.

◆ CGSCC

typedef SCCDetection<ConstraintGraph *> SVF::CGSCC

Definition at line 44 of file CSC.h.

◆ CHGraphReader

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

Definition at line 930 of file SVFFileSystem.h.

◆ CHGraphWriter

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

Definition at line 342 of file SVFFileSystem.h.

◆ CmpInst

typedef llvm::CmpInst SVF::CmpInst

Definition at line 159 of file BasicTypes.h.

◆ const_inst_iterator

typedef llvm::const_inst_iterator SVF::const_inst_iterator

Definition at line 250 of file BasicTypes.h.

◆ const_pred_iterator

typedef llvm::const_pred_iterator SVF::const_pred_iterator

Definition at line 254 of file BasicTypes.h.

◆ Constant

typedef llvm::Constant SVF::Constant

Definition at line 124 of file BasicTypes.h.

◆ ConstantAggregate

typedef llvm::ConstantAggregate SVF::ConstantAggregate

Definition at line 117 of file BasicTypes.h.

◆ ConstantAggregateZero

typedef llvm::ConstantAggregateZero SVF::ConstantAggregateZero

Definition at line 118 of file BasicTypes.h.

◆ ConstantArray

typedef llvm::ConstantArray SVF::ConstantArray

Definition at line 123 of file BasicTypes.h.

◆ ConstantData

typedef llvm::ConstantData SVF::ConstantData

Definition at line 116 of file BasicTypes.h.

◆ ConstantDataArray

typedef llvm::ConstantDataArray SVF::ConstantDataArray

Definition at line 121 of file BasicTypes.h.

◆ ConstantDataSequential

typedef llvm::ConstantDataSequential SVF::ConstantDataSequential

Definition at line 119 of file BasicTypes.h.

◆ ConstantExpr

typedef llvm::ConstantExpr SVF::ConstantExpr

Definition at line 120 of file BasicTypes.h.

◆ ConstantFP

typedef llvm::ConstantFP SVF::ConstantFP

Definition at line 126 of file BasicTypes.h.

◆ ConstantInt

typedef llvm::ConstantInt SVF::ConstantInt

Definition at line 125 of file BasicTypes.h.

◆ ConstantPointerNull

typedef llvm::ConstantPointerNull SVF::ConstantPointerNull

Definition at line 127 of file BasicTypes.h.

◆ ConstantStruct

typedef llvm::ConstantStruct SVF::ConstantStruct

Definition at line 106 of file BasicTypes.h.

◆ CopySVFGNode

typedef CopyVFGNode SVF::CopySVFGNode

Definition at line 52 of file SVFG.h.

◆ CxtLocDPItem

typedef CxtStmtDPItem<SVFGNode> SVF::CxtLocDPItem

Definition at line 49 of file ContextDDA.h.

◆ CxtPtSet

typedef CondStdSet<CxtVar> SVF::CxtPtSet

Definition at line 386 of file DPItem.h.

◆ CxtVar

typedef CondVar< ContextCond > SVF::CxtVar

Context-, flow- sensitive DPItem

Context DPItem

Definition at line 385 of file DPItem.h.

◆ DataLayout

typedef llvm::DataLayout SVF::DataLayout

Definition at line 108 of file BasicTypes.h.

◆ DebugInfoFinder

typedef llvm::DebugInfoFinder SVF::DebugInfoFinder

Definition at line 239 of file BasicTypes.h.

◆ DIBasicType

typedef llvm::DIBasicType SVF::DIBasicType

Definition at line 241 of file BasicTypes.h.

◆ DICompositeType

typedef llvm::DICompositeType SVF::DICompositeType

Definition at line 237 of file BasicTypes.h.

◆ DIDerivedType

typedef llvm::DIDerivedType SVF::DIDerivedType

Definition at line 238 of file BasicTypes.h.

◆ DINode

typedef llvm::DINode SVF::DINode

Definition at line 243 of file BasicTypes.h.

◆ DINodeArray

typedef llvm::DINodeArray SVF::DINodeArray

Definition at line 244 of file BasicTypes.h.

◆ DISubprogram

typedef llvm::DISubprogram SVF::DISubprogram

Definition at line 113 of file BasicTypes.h.

◆ DISubrange

typedef llvm::DISubrange SVF::DISubrange

Definition at line 242 of file BasicTypes.h.

◆ DISubroutineType

typedef llvm::DISubroutineType SVF::DISubroutineType

Definition at line 240 of file BasicTypes.h.

◆ DIType

typedef llvm::DIType SVF::DIType

Definition at line 236 of file BasicTypes.h.

◆ DITypeRefArray

typedef llvm::DITypeRefArray SVF::DITypeRefArray

Definition at line 245 of file BasicTypes.h.

◆ DominanceFrontier

typedef llvm::DominanceFrontier SVF::DominanceFrontier

Definition at line 135 of file BasicTypes.h.

◆ DominanceFrontierBase

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

Definition at line 137 of file BasicTypes.h.

◆ DominatorTree

typedef llvm::DominatorTree SVF::DominatorTree

LLVM Dominators.

Definition at line 133 of file BasicTypes.h.

◆ DomTreeNode

typedef llvm::DomTreeNode SVF::DomTreeNode

Definition at line 134 of file BasicTypes.h.

◆ EdgeID

typedef u32_t SVF::EdgeID

Definition at line 56 of file GeneralType.h.

◆ EdgeSet

typedef NodeSet SVF::EdgeSet

Definition at line 121 of file GeneralType.h.

◆ EdgeVector

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

Definition at line 117 of file GeneralType.h.

◆ ExtractElementInst

typedef llvm::ExtractElementInst SVF::ExtractElementInst

Definition at line 161 of file BasicTypes.h.

◆ ExtractValueInst

typedef llvm::ExtractValueInst SVF::ExtractValueInst

Definition at line 160 of file BasicTypes.h.

◆ FenceInst

typedef llvm::FenceInst SVF::FenceInst

Definition at line 168 of file BasicTypes.h.

◆ FormalParmSVFGNode

typedef FormalParmVFGNode SVF::FormalParmSVFGNode

Definition at line 46 of file SVFG.h.

◆ FormalRetSVFGNode

typedef FormalRetVFGNode SVF::FormalRetSVFGNode

Definition at line 47 of file SVFG.h.

◆ FreezeInst

typedef llvm::FreezeInst SVF::FreezeInst

Definition at line 169 of file BasicTypes.h.

◆ Function

typedef llvm::Function SVF::Function

Definition at line 85 of file BasicTypes.h.

◆ FunctionType

typedef llvm::FunctionType SVF::FunctionType

Definition at line 98 of file BasicTypes.h.

◆ GenericCallGraphEdgeTy

typedef GenericEdge<CallGraphNode> SVF::GenericCallGraphEdgeTy

Definition at line 50 of file CallGraph.h.

◆ GenericCallGraphNodeTy

typedef GenericNode<CallGraphNode, CallGraphEdge> SVF::GenericCallGraphNodeTy

Definition at line 113 of file CallGraph.h.

◆ GenericCallGraphTy

typedef GenericGraph<CallGraphNode, CallGraphEdge> SVF::GenericCallGraphTy

Pointer Analysis Call Graph used internally for various pointer analysis

Definition at line 170 of file CallGraph.h.

◆ GenericCDGEdgeTy

typedef GenericEdge<CDGNode> SVF::GenericCDGEdgeTy

Definition at line 40 of file CDG.h.

◆ GenericCDGNodeTy

typedef GenericNode<CDGNode, CDGEdge> SVF::GenericCDGNodeTy

Definition at line 87 of file CDG.h.

◆ GenericCDGTy

typedef GenericGraph<CDGNode, CDGEdge> SVF::GenericCDGTy

Definition at line 140 of file CDG.h.

◆ GenericCFLEdgeTy

typedef GenericEdge<CFLNode> SVF::GenericCFLEdgeTy

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

◆ GenericCHNodeTy

typedef GenericNode<CHNode, CHEdge> SVF::GenericCHNodeTy

Definition at line 107 of file CHG.h.

◆ GenericConsEdgeTy

typedef GenericEdge<ConstraintNode> SVF::GenericConsEdgeTy

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

Definition at line 47 of file ConsGEdge.h.

◆ GenericConsNodeTy

typedef GenericNode<ConstraintNode,ConstraintEdge> SVF::GenericConsNodeTy

Constraint node

Definition at line 39 of file ConsGNode.h.

◆ GenericICFGEdgeTy

typedef GenericEdge<ICFGNode> SVF::GenericICFGEdgeTy

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

Definition at line 43 of file ICFGEdge.h.

◆ GenericICFGNodeTy

typedef GenericNode<ICFGNode, ICFGEdge> SVF::GenericICFGNodeTy

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

Definition at line 52 of file ICFGNode.h.

◆ GenericICFGReader

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

Definition at line 929 of file SVFFileSystem.h.

◆ GenericICFGTy

typedef GenericGraph<ICFGNode,ICFGEdge> SVF::GenericICFGTy

Interprocedural Control-Flow Graph (ICFG)

Definition at line 46 of file ICFG.h.

◆ GenericICFGWriter

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

Definition at line 323 of file SVFFileSystem.h.

◆ GenericPAGEdgeTy

typedef GenericEdge<SVFVar> SVF::GenericPAGEdgeTy

Definition at line 50 of file SVFStatements.h.

◆ GenericPAGNodeTy

typedef GenericNode<SVFVar, SVFStmt> SVF::GenericPAGNodeTy

Definition at line 44 of file SVFVariables.h.

◆ GenericPTACallGraphEdgeTy

typedef GenericEdge<PTACallGraphNode> SVF::GenericPTACallGraphEdgeTy

Definition at line 51 of file PTACallGraph.h.

◆ GenericPTACallGraphNodeTy

typedef GenericNode<PTACallGraphNode, PTACallGraphEdge> SVF::GenericPTACallGraphNodeTy

Definition at line 174 of file PTACallGraph.h.

◆ GenericPTACallGraphTy

typedef GenericGraph<PTACallGraphNode, PTACallGraphEdge> SVF::GenericPTACallGraphTy

Pointer Analysis Call Graph used internally for various pointer analysis

Definition at line 235 of file PTACallGraph.h.

◆ GenericTCTEdgeTy

typedef GenericEdge<TCTNode> SVF::GenericTCTEdgeTy

Definition at line 49 of file TCT.h.

◆ GenericTCTNodeTy

typedef GenericNode<TCTNode, TCTEdge> SVF::GenericTCTNodeTy

Definition at line 84 of file TCT.h.

◆ GenericThreadCreateTreeTy

typedef GenericGraph<TCTNode, TCTEdge> SVF::GenericThreadCreateTreeTy

Pointer Analysis Call Graph used internally for various pointer analysis

Definition at line 152 of file TCT.h.

◆ GenericVFGEdgeTy

typedef GenericEdge<VFGNode> SVF::GenericVFGEdgeTy

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

Definition at line 43 of file VFGEdge.h.

◆ GenericVFGNodeTy

typedef GenericNode<VFGNode,VFGEdge> SVF::GenericVFGNodeTy

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

Definition at line 45 of file VFGNode.h.

◆ GenericVFGTy

typedef GenericGraph<VFGNode,VFGEdge> SVF::GenericVFGTy

Value Flow Graph (VFG)

Definition at line 49 of file VFG.h.

◆ gep_type_iterator

typedef llvm::gep_type_iterator SVF::gep_type_iterator

Definition at line 251 of file BasicTypes.h.

◆ GEPOperator

typedef llvm::GEPOperator SVF::GEPOperator

Definition at line 182 of file BasicTypes.h.

◆ GepSVFGNode

typedef GepVFGNode SVF::GepSVFGNode

Definition at line 55 of file SVFG.h.

◆ GetElementPtrInst

typedef llvm::GetElementPtrInst SVF::GetElementPtrInst

Definition at line 162 of file BasicTypes.h.

◆ GlobalAlias

typedef llvm::GlobalAlias SVF::GlobalAlias

Definition at line 128 of file BasicTypes.h.

◆ GlobalIFunc

typedef llvm::GlobalIFunc SVF::GlobalIFunc

Definition at line 129 of file BasicTypes.h.

◆ GlobalObject

typedef llvm::GlobalObject SVF::GlobalObject

Definition at line 71 of file BasicTypes.h.

◆ GlobalValue

typedef llvm::GlobalValue SVF::GlobalValue

Definition at line 88 of file BasicTypes.h.

◆ GlobalVariable

typedef llvm::GlobalVariable SVF::GlobalVariable

Definition at line 130 of file BasicTypes.h.

◆ GraphPrinter

typedef SVF::GraphPrinter SVF::GraphPrinter

LLVM Aliases and constants.

Definition at line 41 of file SVFValue.h.

◆ ICFGCycleWTO

typedef WTOCycle<ICFG> SVF::ICFGCycleWTO

Definition at line 45 of file ICFGWTO.h.

◆ ICFGSingletonWTO

typedef WTONode<ICFG> SVF::ICFGSingletonWTO

Definition at line 44 of file ICFGWTO.h.

◆ ICFGWTOComp

typedef WTOComponent<ICFG> SVF::ICFGWTOComp

Definition at line 43 of file ICFGWTO.h.

◆ InsertElementInst

typedef llvm::InsertElementInst SVF::InsertElementInst

Definition at line 171 of file BasicTypes.h.

◆ InsertValueInst

typedef llvm::InsertValueInst SVF::InsertValueInst

Definition at line 167 of file BasicTypes.h.

◆ inst_iterator

typedef llvm::inst_iterator SVF::inst_iterator

Definition at line 249 of file BasicTypes.h.

◆ Instruction

typedef llvm::Instruction SVF::Instruction

Definition at line 87 of file BasicTypes.h.

◆ IntegerType

typedef llvm::IntegerType SVF::IntegerType

Definition at line 97 of file BasicTypes.h.

◆ InterPHISVFGNode

typedef InterPHIVFGNode SVF::InterPHISVFGNode

Definition at line 58 of file SVFG.h.

◆ IntraPHISVFGNode

typedef IntraPHIVFGNode SVF::IntraPHISVFGNode

Definition at line 57 of file SVFG.h.

◆ IntToPtrInst

typedef llvm::IntToPtrInst SVF::IntToPtrInst

Definition at line 166 of file BasicTypes.h.

◆ InvokeInst

typedef llvm::InvokeInst SVF::InvokeInst

Definition at line 163 of file BasicTypes.h.

◆ IRBuilder

typedef llvm::IRBuilder SVF::IRBuilder

Definition at line 74 of file BasicTypes.h.

◆ IRGraphReader

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

Definition at line 931 of file SVFFileSystem.h.

◆ IRGraphWriter

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

Definition at line 341 of file SVFFileSystem.h.

◆ KindBaseT

template<typename T >

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

Definition at line 677 of file SVFFileSystem.h.

◆ Label

typedef GrammarBase::Symbol SVF::Label

Definition at line 41 of file CFLSolver.h.

◆ LandingPadInst

typedef llvm::LandingPadInst SVF::LandingPadInst

Definition at line 172 of file BasicTypes.h.

◆ LLVMContext

typedef llvm::LLVMContext SVF::LLVMContext

Definition at line 70 of file BasicTypes.h.

◆ LoadInst

typedef llvm::LoadInst SVF::LoadInst

Definition at line 149 of file BasicTypes.h.

◆ LoadSVFGNode

typedef LoadVFGNode SVF::LoadSVFGNode

Definition at line 54 of file SVFG.h.

◆ LocDPItem

typedef StmtDPItem<SVFGNode> SVF::LocDPItem

Definition at line 48 of file FlowDDA.h.

◆ Loop

typedef llvm::Loop SVF::Loop

LLVM Loop.

Definition at line 140 of file BasicTypes.h.

◆ LoopInfo

typedef llvm::LoopInfo SVF::LoopInfo

Definition at line 141 of file BasicTypes.h.

◆ Map

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

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

Definition at line 101 of file GeneralType.h.

◆ MDNode

typedef llvm::MDNode SVF::MDNode

Definition at line 112 of file BasicTypes.h.

◆ MDString

typedef llvm::MDString SVF::MDString

Definition at line 101 of file BasicTypes.h.

◆ MemoryLocation

typedef llvm::MemoryLocation SVF::MemoryLocation

Definition at line 107 of file BasicTypes.h.

◆ MetadataAsValue

typedef llvm::MetadataAsValue SVF::MetadataAsValue

Definition at line 102 of file BasicTypes.h.

◆ Module

typedef llvm::Module SVF::Module

Definition at line 84 of file BasicTypes.h.

◆ ModulePass

typedef llvm::ModulePass SVF::ModulePass

Definition at line 73 of file BasicTypes.h.

◆ MRID

typedef NodeID SVF::MRID

Definition at line 50 of file MemRegion.h.

◆ MRVERID

typedef NodeID SVF::MRVERID

Definition at line 51 of file MemRegion.h.

◆ MRVERSION

typedef NodeID SVF::MRVERSION

Definition at line 52 of file MemRegion.h.

◆ NamedMDNode

typedef llvm::NamedMDNode SVF::NamedMDNode

LLVM metadata and debug information.

Definition at line 111 of file BasicTypes.h.

◆ NodeBS

typedef SparseBitVector SVF::NodeBS

Definition at line 62 of file GeneralType.h.

◆ NodeDeque

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

Definition at line 120 of file GeneralType.h.

◆ NodeID

typedef u32_t SVF::NodeID

Definition at line 55 of file GeneralType.h.

◆ NodeList

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

Definition at line 119 of file GeneralType.h.

◆ NodePair

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

Definition at line 111 of file GeneralType.h.

◆ NodePairMap

typedef Map<NodePair, NodeID> SVF::NodePairMap

Definition at line 115 of file GeneralType.h.

◆ NodePairSet

typedef Set<NodePair> SVF::NodePairSet

Definition at line 114 of file GeneralType.h.

◆ NodePairVector

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

Definition at line 139 of file CDG.h.

◆ NodeSet

typedef Set<NodeID> SVF::NodeSet

Definition at line 113 of file GeneralType.h.

◆ NodeStack

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

Definition at line 118 of file GeneralType.h.

◆ NodeVector

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

Definition at line 116 of file GeneralType.h.

◆ NullPtrSVFGNode

typedef NullPtrVFGNode SVF::NullPtrSVFGNode

Definition at line 49 of file SVFG.h.

◆ OrderedMap

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

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

Definition at line 109 of file GeneralType.h.

◆ OrderedNodeSet

typedef OrderedSet<NodeID> SVF::OrderedNodeSet

Definition at line 112 of file GeneralType.h.

◆ OrderedSet

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

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

Definition at line 105 of file GeneralType.h.

◆ OutStream

typedef std::ostream SVF::OutStream

Definition at line 45 of file GeneralType.h.

◆ PAG

typedef SVFIR SVF::PAG

Definition at line 746 of file SVFIR.h.

◆ PAGEdge

typedef SVFStmt SVF::PAGEdge

Definition at line 43 of file IRGraph.h.

◆ PAGNode

typedef SVFVar SVF::PAGNode

Definition at line 42 of file IRGraph.h.

◆ PHINode

typedef llvm::PHINode SVF::PHINode

Definition at line 165 of file BasicTypes.h.

◆ PHISVFGNode

typedef PHIVFGNode SVF::PHISVFGNode

Definition at line 56 of file SVFG.h.

◆ PointerType

typedef llvm::PointerType SVF::PointerType

Definition at line 96 of file BasicTypes.h.

◆ PointsToID

typedef unsigned SVF::PointsToID

Definition at line 63 of file GeneralType.h.

◆ PostDominatorTree

typedef llvm::PostDominatorTree SVF::PostDominatorTree

Definition at line 136 of file BasicTypes.h.

◆ raw_fd_ostream

typedef llvm::raw_fd_ostream SVF::raw_fd_ostream

LLVM outputs.

Definition at line 264 of file BasicTypes.h.

◆ raw_pointer_iterator

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

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

Definition at line 402 of file iterator.h.

◆ ResumeInst

typedef llvm::ResumeInst SVF::ResumeInst

Definition at line 173 of file BasicTypes.h.

◆ ReturnInst

typedef llvm::ReturnInst SVF::ReturnInst

Definition at line 157 of file BasicTypes.h.

◆ s16_t

typedef signed short SVF::s16_t

Definition at line 53 of file GeneralType.h.

◆ s32_t

typedef signed SVF::s32_t

Definition at line 47 of file GeneralType.h.

◆ s64_t

typedef signed long long SVF::s64_t

Definition at line 49 of file GeneralType.h.

◆ s8_t

typedef signed char SVF::s8_t

Definition at line 51 of file GeneralType.h.

◆ ScalarEvolution

typedef llvm::ScalarEvolution SVF::ScalarEvolution

Definition at line 260 of file BasicTypes.h.

◆ ScalarEvolutionWrapperPass

typedef llvm::ScalarEvolutionWrapperPass SVF::ScalarEvolutionWrapperPass

Definition at line 257 of file BasicTypes.h.

◆ SCEV

typedef llvm::SCEV SVF::SCEV

Definition at line 261 of file BasicTypes.h.

◆ SCEVAddRecExpr

typedef llvm::SCEVAddRecExpr SVF::SCEVAddRecExpr

Definition at line 258 of file BasicTypes.h.

◆ SCEVConstant

typedef llvm::SCEVConstant SVF::SCEVConstant

Definition at line 259 of file BasicTypes.h.

◆ SelectInst

typedef llvm::SelectInst SVF::SelectInst

Definition at line 174 of file BasicTypes.h.

◆ Set

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

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

Definition at line 96 of file GeneralType.h.

◆ ShuffleVectorInst

typedef llvm::ShuffleVectorInst SVF::ShuffleVectorInst

Definition at line 164 of file BasicTypes.h.

◆ SMDiagnostic

typedef llvm::SMDiagnostic SVF::SMDiagnostic

Definition at line 90 of file BasicTypes.h.

◆ StmtSVFGNode

typedef StmtVFGNode SVF::StmtSVFGNode

Definition at line 50 of file SVFG.h.

◆ StoreInst

typedef llvm::StoreInst SVF::StoreInst

Definition at line 148 of file BasicTypes.h.

◆ StoreSVFGNode

typedef StoreVFGNode SVF::StoreSVFGNode

Definition at line 53 of file SVFG.h.

◆ StructLayout

typedef llvm::StructLayout SVF::StructLayout

Definition at line 105 of file BasicTypes.h.

◆ StructType

typedef llvm::StructType SVF::StructType

LLVM types.

Definition at line 94 of file BasicTypes.h.

◆ succ_const_iterator

typedef llvm::succ_const_iterator SVF::succ_const_iterator

LLVM Iterators.

Definition at line 276 of file BasicTypes.h.

◆ SuccBBAndCondValPair

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

Definition at line 185 of file BasicTypes.h.

◆ SuccBBAndCondValPairVec

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

Definition at line 186 of file BasicTypes.h.

◆ SVFGEdge

typedef VFGEdge SVF::SVFGEdge

Definition at line 42 of file SVFG.h.

◆ SVFGNode

typedef VFGNode SVF::SVFGNode

Definition at line 43 of file SVFG.h.

◆ SwitchInst

typedef llvm::SwitchInst SVF::SwitchInst

Definition at line 155 of file BasicTypes.h.

◆ SymID

typedef unsigned SVF::SymID

Definition at line 57 of file GeneralType.h.

◆ ThreadID

typedef unsigned SVF::ThreadID

Definition at line 59 of file GeneralType.h.

◆ Type

typedef llvm::Type SVF::Type

Definition at line 83 of file BasicTypes.h.

◆ u16_t

typedef unsigned short SVF::u16_t

Definition at line 52 of file GeneralType.h.

◆ u32_t

typedef unsigned SVF::u32_t

Definition at line 46 of file GeneralType.h.

◆ u64_t

typedef unsigned long long SVF::u64_t

Definition at line 48 of file GeneralType.h.

◆ u8_t

typedef unsigned char SVF::u8_t

Definition at line 50 of file GeneralType.h.

◆ UnaryOperator

typedef llvm::UnaryOperator SVF::UnaryOperator

Definition at line 180 of file BasicTypes.h.

◆ UndefValue

typedef llvm::UndefValue SVF::UndefValue

Definition at line 181 of file BasicTypes.h.

◆ UnifyFunctionExitNodes

typedef llvm::UnifyFunctionExitNodes SVF::UnifyFunctionExitNodes

Definition at line 78 of file BasicTypes.h.

◆ UnreachableInst

typedef llvm::UnreachableInst SVF::UnreachableInst

Definition at line 170 of file BasicTypes.h.

◆ Use

typedef llvm::Use SVF::Use

Definition at line 72 of file BasicTypes.h.

◆ User

typedef llvm::User SVF::User

Definition at line 142 of file BasicTypes.h.

◆ VAArgInst

typedef llvm::VAArgInst SVF::VAArgInst

Definition at line 175 of file BasicTypes.h.

◆ VACopyInst

typedef llvm::VACopyInst SVF::VACopyInst

Definition at line 176 of file BasicTypes.h.

◆ VAEndInst

typedef llvm::VAEndInst SVF::VAEndInst

Definition at line 177 of file BasicTypes.h.

◆ Value

typedef llvm::Value SVF::Value

LLVM Basic classes.

Definition at line 82 of file BasicTypes.h.

◆ VAStartInst

typedef llvm::VAStartInst SVF::VAStartInst

Definition at line 178 of file BasicTypes.h.

◆ VectorType

typedef llvm::VectorType SVF::VectorType

Definition at line 267 of file BasicTypes.h.

◆ Version

typedef unsigned SVF::Version

Definition at line 123 of file GeneralType.h.

◆ VersionedVar

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

Definition at line 125 of file GeneralType.h.

◆ VersionedVarSet

typedef Set<VersionedVar> SVF::VersionedVarSet

Definition at line 126 of file GeneralType.h.

◆ VersionSet

typedef Set<Version> SVF::VersionSet

Definition at line 124 of file GeneralType.h.

◆ VFunSet

typedef Set<const SVFFunction*> SVF::VFunSet

Definition at line 47 of file CHG.h.

◆ VTableSet

typedef Set<const SVFGlobalValue*> SVF::VTableSet

Definition at line 46 of file CHG.h.

◆ WPAConstraintSolver

typedef WPASolver< ConstraintGraph * > SVF::WPAConstraintSolver

Abstract class of inclusion-based Pointer Analysis

Equivalence-based Pointer Analysis

Definition at line 55 of file Andersen.h.

◆ WPASVFGFSSolver

typedef WPAFSSolver<SVFG*> SVF::WPASVFGFSSolver

Flow sensitive whole program pointer analysis

Definition at line 48 of file FlowSensitive.h.

Enumeration Type Documentation

◆ AliasResult

enum SVF::AliasResult

Enumerator
NoAlias
MayAlias
MustAlias
PartialAlias

Definition at line 526 of file SVFType.h.

{
    NoAlias,
    MayAlias,
    MustAlias,
    PartialAlias,
};

◆ BuildDirection

enum class SVF::BuildDirection

strong

Enumerator
plain
bidirection

Definition at line 40 of file CFLGraphBuilder.h.

{
    plain,
    bidirection,
};

◆ ModRefInfo

enum SVF::ModRefInfo

Enumerator
ModRef
Ref
Mod
NoModRef

Definition at line 518 of file SVFType.h.

{
    ModRef,
    Ref,
    Mod,
    NoModRef,
};

◆ ZeroBehavior

enum SVF::ZeroBehavior

The behavior an operation has on an input of 0.

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

Definition at line 36 of file SparseBitVector.h.

{
    ZB_Undefined,
    ZB_Max,
    ZB_Width
};

Function Documentation

◆ attribute()

SVF::__attribute__ ( (weak) )

Definition at line 10 of file SVFType.cpp.

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

◆ children()

template<class GraphType >

iter_range< typename GenericGraphTraits< GraphType >::ChildIteratorType > SVF::children ( const typename GenericGraphTraits< GraphType >::NodeRef & G )

Definition at line 126 of file GraphTraits.h.

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

◆ children_edges()

template<class GraphType >

iter_range< typename GenericGraphTraits< GraphType >::ChildEdgeIteratorType > SVF::children_edges ( const typename GenericGraphTraits< GraphType >::NodeRef & G )

Definition at line 142 of file GraphTraits.h.

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

◆ countLeadingZeros()

template<typename T >

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

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

Only unsigned integral types are allowed.

Parameters

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

Definition at line 211 of file SparseBitVector.h.

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

◆ countPopulation()

template<typename T >

unsigned SVF::countPopulation ( T Value )

inline

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

Definition at line 239 of file SparseBitVector.h.

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

◆ countTrailingZeros()

template<typename T >

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

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

Only unsigned integral types are allowed.

Parameters

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

Definition at line 119 of file SparseBitVector.h.

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

◆ createSVFType()

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

Definition at line 17 of file SVFFileSystem.cpp.

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

◆ createSVFValue()

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

static

Definition at line 45 of file SVFFileSystem.cpp.

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

◆ dump()

template<unsigned ElementSize>

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

Definition at line 1233 of file SparseBitVector.h.

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

◆ dumpLLVMValue()

std::string SVF::dumpLLVMValue ( const SVFValue * svfValue )

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

◆ inverse_children()

template<class GraphType >

iter_range< typename GenericGraphTraits< Inverse< GraphType > >::ChildIteratorType > SVF::inverse_children ( const typename GenericGraphTraits< GraphType >::NodeRef & G )

Definition at line 134 of file GraphTraits.h.

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

◆ inverse_nodes()

template<class GraphType >

iter_range< typename GenericGraphTraits< Inverse< GraphType > >::nodes_iterator > SVF::inverse_nodes ( const GraphType & G )

Definition at line 118 of file GraphTraits.h.

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

◆ jsonAddItemToArray()

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

Definition at line 936 of file SVFFileSystem.cpp.

{
    return cJSON_AddItemToArray(array, item);
}

◆ jsonAddItemToObject()

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

Definition at line 930 of file SVFFileSystem.cpp.

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

◆ jsonAddNumberToObject()

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

Helper function to write a number to a JSON object.

Definition at line 779 of file SVFFileSystem.cpp.

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

◆ jsonAddPairToMap()

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

Definition at line 921 of file SVFFileSystem.cpp.

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

◆ jsonAddStringToObject() [1/2]

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

Definition at line 785 of file SVFFileSystem.cpp.

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

◆ jsonAddStringToObject() [2/2]

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

Definition at line 791 of file SVFFileSystem.cpp.

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

◆ jsonCreateArray()

cJSON * SVF::jsonCreateArray ( )

Definition at line 886 of file SVFFileSystem.cpp.

{
    return cJSON_CreateArray();
}

◆ jsonCreateBool()

cJSON * SVF::jsonCreateBool ( bool flag )

Definition at line 910 of file SVFFileSystem.cpp.

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

◆ jsonCreateIndex()

cJSON * SVF::jsonCreateIndex ( size_t index )

Definition at line 902 of file SVFFileSystem.cpp.

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

◆ jsonCreateMap()

cJSON * SVF::jsonCreateMap ( )

Definition at line 891 of file SVFFileSystem.cpp.

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

◆ jsonCreateNullId()

cJSON * SVF::jsonCreateNullId ( )

Definition at line 875 of file SVFFileSystem.cpp.

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

◆ jsonCreateNumber()

cJSON * SVF::jsonCreateNumber ( double num )

Definition at line 916 of file SVFFileSystem.cpp.

{
    return cJSON_CreateNumber(num);
}

◆ jsonCreateObject()

cJSON * SVF::jsonCreateObject ( )

Definition at line 881 of file SVFFileSystem.cpp.

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

◆ jsonCreateString()

cJSON * SVF::jsonCreateString ( const char * str )

Definition at line 897 of file SVFFileSystem.cpp.

{
    return cJSON_CreateStringReference(str);
}

◆ jsonGetNumber()

double SVF::jsonGetNumber ( const cJSON * item )

Definition at line 869 of file SVFFileSystem.cpp.

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

◆ jsonIsArray()

bool SVF::jsonIsArray ( const cJSON * item )

Definition at line 838 of file SVFFileSystem.cpp.

{
    return cJSON_IsArray(item);
}

◆ jsonIsBool() [1/2]

bool SVF::jsonIsBool ( const cJSON * item )

Definition at line 796 of file SVFFileSystem.cpp.

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

◆ jsonIsBool() [2/2]

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

Definition at line 804 of file SVFFileSystem.cpp.

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

◆ jsonIsMap()

bool SVF::jsonIsMap ( const cJSON * item )

Definition at line 843 of file SVFFileSystem.cpp.

{
    return cJSON_IsArray(item);
}

◆ jsonIsNullId()

bool SVF::jsonIsNullId ( const cJSON * item )

Definition at line 832 of file SVFFileSystem.cpp.

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

◆ jsonIsNumber()

bool SVF::jsonIsNumber ( const cJSON * item )

Definition at line 822 of file SVFFileSystem.cpp.

{
    return cJSON_IsNumber(item);
}

◆ jsonIsObject()

bool SVF::jsonIsObject ( const cJSON * item )

Definition at line 848 of file SVFFileSystem.cpp.

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

◆ jsonIsString()

bool SVF::jsonIsString ( const cJSON * item )

Definition at line 827 of file SVFFileSystem.cpp.

{
    return cJSON_IsString(item);
}

◆ jsonKeyEquals()

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

Definition at line 853 of file SVFFileSystem.cpp.

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

◆ jsonUnpackPair()

std::pair< const cJSON *, const cJSON * > SVF::jsonUnpackPair ( const cJSON * item )

Definition at line 858 of file SVFFileSystem.cpp.

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

◆ KIND_BASE() [1/8]

SVF::KIND_BASE	(	CHEdge	,
		getEdgeKind
	)

◆ KIND_BASE() [2/8]

SVF::KIND_BASE	(	CHNode	,
		getNodeKind
	)

◆ KIND_BASE() [3/8]

SVF::KIND_BASE	(	ICFGEdge	,
		getEdgeKind
	)

◆ KIND_BASE() [4/8]

SVF::KIND_BASE	(	ICFGNode	,
		getNodeKind
	)

◆ KIND_BASE() [5/8]

SVF::KIND_BASE	(	SVFStmt	,
		getEdgeKind
	)

◆ KIND_BASE() [6/8]

SVF::KIND_BASE	(	SVFType	,
		getKind
	)

◆ KIND_BASE() [7/8]

SVF::KIND_BASE	(	SVFValue	,
		getKind
	)

◆ KIND_BASE() [8/8]

SVF::KIND_BASE	(	SVFVar	,
		getNodeKind
	)

◆ make_pointee_range()

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

iter_range< pointee_iter< WrappedIteratorT > > SVF::make_pointee_range ( RangeT && Range )

Definition at line 355 of file iterator.h.

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

◆ make_pointer_range()

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

iter_range< pointer_iterator< WrappedIteratorT > > SVF::make_pointer_range ( RangeT && Range )

Definition at line 391 of file iterator.h.

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

◆ make_range() [1/2]

template<typename T >

iter_range< T > SVF::make_range ( std::pair< T, T > p )

Definition at line 69 of file iterator_range.h.

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

◆ make_range() [2/2]

template<class T >

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

Convenience function for iterating over sub-ranges.

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

Definition at line 64 of file iterator_range.h.

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

◆ map_iter()

template<class ItTy , class FuncTy >

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

inline

Definition at line 721 of file GenericGraph.h.

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

◆ nodes()

template<class GraphType >

iter_range< typename GenericGraphTraits< GraphType >::nodes_iterator > SVF::nodes ( const GraphType & G )

Definition at line 111 of file GraphTraits.h.

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

◆ operator%()

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

inline

Divide IntervalValues.

Definition at line 645 of file IntervalValue.h.

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

◆ operator&() [1/3]

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

inline

Bitwise AND of IntervalValues.

Definition at line 962 of file IntervalValue.h.

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

◆ operator&() [2/3]

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

Returns a new lhs & rhs.

Definition at line 573 of file PointsTo.cpp.

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

◆ operator&() [3/3]

template<unsigned ElementSize>

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

inline

Definition at line 1213 of file SparseBitVector.h.

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

◆ operator&=() [1/2]

template<unsigned ElementSize>

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

inline

Definition at line 1193 of file SparseBitVector.h.

{
    return LHS &= *RHS;
}

◆ operator&=() [2/2]

template<unsigned ElementSize>

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

inline

Definition at line 1186 of file SparseBitVector.h.

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

◆ operator*()

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

inline

Multiply IntervalValues.

Definition at line 583 of file IntervalValue.h.

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

◆ operator+()

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

inline

Add IntervalValues.

Definition at line 547 of file IntervalValue.h.

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

◆ operator-() [1/3]

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

inline

Subtract IntervalValues.

Definition at line 565 of file IntervalValue.h.

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

◆ operator-() [2/3]

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

Returns a new lhs - rhs.

Definition at line 581 of file PointsTo.cpp.

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

◆ operator-() [3/3]

template<unsigned ElementSize>

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

inline

Definition at line 1223 of file SparseBitVector.h.

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

◆ operator/()

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

inline

Divide IntervalValues.

Definition at line 603 of file IntervalValue.h.

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

◆ operator<()

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

inline

Definition at line 736 of file IntervalValue.h.

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

◆ operator<<() [1/5]

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

inline

Left binary shift of IntervalValues.

Definition at line 888 of file IntervalValue.h.

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

◆ operator<<() [2/5]

template<typename F , typename S >

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

Definition at line 1036 of file SVFValue.h.

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

◆ operator<<() [3/5]

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

inline

Write an IntervalValue on a stream.

Definition at line 1047 of file IntervalValue.h.

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

◆ operator<<() [4/5]

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

Definition at line 811 of file MemRegion.cpp.

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

◆ operator<<() [5/5]

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

◆ operator<=()

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

inline

Definition at line 838 of file IntervalValue.h.

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

◆ operator>()

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

inline

Definition at line 685 of file IntervalValue.h.

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

◆ operator>=()

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

inline

Definition at line 788 of file IntervalValue.h.

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

◆ operator>>()

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

inline

Left binary shift of IntervalValues.

Definition at line 926 of file IntervalValue.h.

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

◆ operator^()

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

inline

Bitwise XOR of IntervalValues.

Definition at line 1018 of file IntervalValue.h.

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

◆ operator|() [1/3]

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

inline

Bitwise OR of IntervalValues.

Definition at line 989 of file IntervalValue.h.

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

◆ operator|() [2/3]

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

Returns a new lhs | rhs.

Definition at line 565 of file PointsTo.cpp.

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

◆ operator|() [3/3]

template<unsigned ElementSize>

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

inline

Definition at line 1203 of file SparseBitVector.h.

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

◆ operator|=() [1/2]

template<unsigned ElementSize>

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

inline

Definition at line 1172 of file SparseBitVector.h.

{
    return LHS |= *RHS;
}

◆ operator|=() [2/2]

template<unsigned ElementSize>

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

inline

Definition at line 1179 of file SparseBitVector.h.

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

◆ readBigNumber()

template<typename BigNumberType , typename CStrToVal >

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

inlinestatic

Definition at line 98 of file SVFFileSystem.cpp.

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

◆ readSmallNumber()

template<typename SmallNumberType >

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

inlinestatic

Definition at line 92 of file SVFFileSystem.cpp.

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

◆ ViewGraph()

template<typename GraphType >

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

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

Definition at line 371 of file GraphWriter.h.

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

◆ WriteGraph() [1/2]

template<typename GraphType >

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

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

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

Definition at line 345 of file GraphWriter.h.

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

◆ WriteGraph() [2/2]

template<typename GraphType >

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

Definition at line 328 of file GraphWriter.h.

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

◆ ActualParmSVFGNode

◆ ActualRetSVFGNode

◆ AddrSVFGNode

◆ AllocaInst

◆ APOffset

◆ Argument

◆ ArrayType

◆ AtomicCmpXchgInst

◆ AtomicRMWInst

◆ BasicBlock

◆ BinaryOperator

◆ BitCastInst

◆ BlockAddress

◆ BranchInst

◆ bridge_gep_iterator

◆ CallBase

◆ CallBrInst

◆ CallInst

◆ CallSiteID

◆ CallStrCxt

◆ CastInst

◆ CFLSrcSnkSolver

◆ CGSCC

◆ CHGraphReader

◆ CHGraphWriter

◆ CmpInst

◆ const_inst_iterator

◆ const_pred_iterator

◆ Constant

◆ ConstantAggregate

◆ ConstantAggregateZero

◆ ConstantArray

◆ ConstantData

◆ ConstantDataArray

◆ ConstantDataSequential

◆ ConstantExpr

◆ ConstantFP

◆ ConstantInt

◆ ConstantPointerNull

◆ ConstantStruct

◆ CopySVFGNode

◆ CxtLocDPItem

◆ CxtPtSet

◆ CxtVar

◆ DataLayout

◆ DebugInfoFinder

◆ DIBasicType

◆ DICompositeType

◆ DIDerivedType

◆ DINode

◆ DINodeArray

◆ DISubprogram

◆ DISubrange

◆ DISubroutineType

◆ DIType

◆ DITypeRefArray

◆ DominanceFrontier

◆ DominanceFrontierBase

◆ DominatorTree

◆ DomTreeNode

◆ EdgeID

◆ EdgeSet

◆ EdgeVector

◆ ExtractElementInst

◆ ExtractValueInst

◆ FenceInst

◆ FormalParmSVFGNode

◆ FormalRetSVFGNode

◆ FreezeInst

◆ Function

◆ FunctionType

◆ GenericCallGraphEdgeTy

◆ GenericCallGraphNodeTy