llvm Namespace Reference

Classes
class	AbstractTypeUser
	LLVM Abstract Type User Representation. More...
class	PATypeHandle
class	PATypeHolder
struct	simplify_type< PATypeHolder >
struct	simplify_type< const PATypeHolder >
class	APFloat
class	APInt
	Class for arbitrary precision integers. More...
class	APSInt
class	BitVector
struct	DenseMapInfo
struct	DenseMapInfo< T * >
struct	DenseMapInfo< unsigned >
struct	DenseMapInfo< unsigned long >
struct	DenseMapInfo< std::pair< T, U > >
class	DenseMap
class	DenseMapIterator
class	DenseMapConstIterator
class	DenseSet
class	df_iterator_storage
class	df_iterator_storage< SetType, true >
class	df_iterator
struct	df_ext_iterator
struct	idf_iterator
struct	idf_ext_iterator
class	EquivalenceClasses
class	FoldingSetImpl
struct	FoldingSetTrait
class	FoldingSetNodeID
class	FoldingSet
class	FoldingSetIteratorImpl
class	FoldingSetIterator
class	FoldingSetBucketIteratorImpl
class	FoldingSetBucketIterator
class	FoldingSetNodeWrapper
struct	FoldingSetTrait< T * >
struct	FoldingSetTrait< const T * >
struct	GraphTraits
struct	Inverse
struct	GraphTraits< Inverse< Inverse< T > > >
struct	ilist_nextprev_traits
struct	ilist_sentinel_traits
struct	ilist_default_traits
struct	ilist_traits
struct	ilist_traits< const Ty >
class	ilist_iterator
struct	simplify_type< ilist_iterator< NodeTy > >
struct	simplify_type< const ilist_iterator< NodeTy > >
class	iplist
struct	ilist
class	ilist_node
class	ImmutableListImpl
class	ImmutableList
class	ImmutableListFactory
struct	DenseMapInfo< ImmutableList< T > >
struct	ImutKeyValueInfo
class	ImmutableMap
class	ImutAVLTree
class	ImutAVLFactory
class	ImutAVLTreeGenericIterator
class	ImutAVLTreeInOrderIterator
struct	ImutProfileInfo
struct	ImutProfileInteger
	Profile traits for integers. More...
struct	ImutProfileInfo< T * >
struct	ImutContainerInfo
struct	ImutContainerInfo< T * >
class	ImmutableSet
struct	IdentityFunctor
class	IndexedMap
class	RefCountedBase
class	RefCountedBaseVPTR
class	IntrusiveRefCntPtr
struct	simplify_type< IntrusiveRefCntPtr< T > >
struct	simplify_type< const IntrusiveRefCntPtr< T > >
class	OwningPtr
class	OwningArrayPtr
class	PointerIntPair
struct	DenseMapInfo< PointerIntPair< PointerTy, IntBits, IntType > >
class	po_iterator_storage
class	po_iterator_storage< SetType, true >
class	po_iterator
struct	po_ext_iterator
struct	ipo_iterator
struct	ipo_ext_iterator
class	ReversePostOrderTraversal
class	PriorityQueue
class	scc_iterator
class	ScopedHashTableVal
class	ScopedHashTableScope
class	ScopedHashTableIterator
class	ScopedHashTable
class	SetVector
	A vector that has set insertion semantics. More...
class	SmallSetVector
class	SmallPtrSetImpl
class	SmallPtrSetIteratorImpl
class	SmallPtrSetIterator
	SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet. More...
struct	NextPowerOfTwoH
struct	NextPowerOfTwoH< N, false >
struct	NextPowerOfTwo
class	SmallPtrSet
class	SmallSet
class	SmallSet< PointeeType *, N >
class	SmallString
class	SmallVectorImpl
class	SmallVector
struct	SparseBitVectorElement
class	SparseBitVector
class	Statistic
struct	greater_ptr
class	mapped_iterator
class	StringMapEntryInitializer
class	StringMapEntryBase
	StringMapEntryBase - Shared base class of StringMapEntry instances. More...
class	StringMapImpl
class	StringMapEntry
class	StringMap
class	StringMapConstIterator
class	StringMapIterator
class	StringSet
class	Tree
class	Trie
struct	GraphTraits< Trie< Payload > >
struct	DOTGraphTraits< Trie< Payload > >
class	UniqueVector
class	AliasAnalysis
class	AliasSet
class	AliasSetTracker
class	CallGraph
class	CallGraphNode
struct	GraphTraits< CallGraphNode * >
struct	GraphTraits< const CallGraphNode * >
struct	GraphTraits< CallGraph * >
struct	GraphTraits< const CallGraph * >
class	constant_iterator
class	DIDescriptor
class	DIAnchor
	DIAnchor - A wrapper for various anchor descriptors. More...
class	DISubrange
	DISubrange - This is used to represent ranges, for array bounds. More...
class	DIArray
	DIArray - This descriptor holds an array of descriptors. More...
class	DICompileUnit
	DICompileUnit - A wrapper for a compile unit. More...
class	DIEnumerator
class	DIType
class	DIBasicType
	DIBasicType - A basic type, like 'int' or 'float'. More...
class	DIDerivedType
class	DICompositeType
class	DIGlobal
	DIGlobal - This is a common class for global variables and subprograms. More...
class	DISubprogram
	DISubprogram - This is a wrapper for a subprogram (e.g. a function). More...
class	DIGlobalVariable
	DIGlobalVariable - This is a wrapper for a global variable. More...
class	DIVariable
class	DIBlock
	DIBlock - This is a wrapper for a block (e.g. a function, scope, etc). More...
class	DIFactory
class	DominatorBase
class	DomTreeNodeBase
class	DominatorTreeBase
class	DominatorTree
struct	GraphTraits< DomTreeNode * >
struct	GraphTraits< DominatorTree * >
class	DominanceFrontierBase
class	DominanceFrontier
class	FindUsedTypes
class	Interval
struct	GraphTraits< Interval * >
struct	GraphTraits< Inverse< Interval * > >
class	IntervalIterator
class	IntervalPartition
struct	LibCallAliasAnalysis
	LibCallAliasAnalysis - Alias analysis driven from LibCallInfo. More...
struct	LibCallLocationInfo
struct	LibCallFunctionInfo
class	LibCallInfo
class	LoopBase
class	LoopInfoBase
class	LoopInfo
struct	GraphTraits< const Loop * >
struct	GraphTraits< Loop * >
class	LoopPass
class	LPPassManager
class	LoopVR
class	MemDepResult
class	MemoryDependenceAnalysis
struct	PostDominatorTree
struct	PostDominanceFrontier
class	ProfileInfo
class	ProfileInfoLoader
class	SCEV
struct	SCEVCouldNotCompute
class	SCEVHandle
struct	simplify_type< const SCEVHandle >
struct	simplify_type< SCEVHandle >
class	ScalarEvolution
struct	SCEVExpander
class	SCEVConstant
class	SCEVTruncateExpr
class	SCEVZeroExtendExpr
class	SCEVSignExtendExpr
class	SCEVCommutativeExpr
class	SCEVAddExpr
class	SCEVMulExpr
class	SCEVUDivExpr
class	SCEVAddRecExpr
class	SCEVSMaxExpr
class	SCEVUMaxExpr
class	SCEVUnknown
struct	SCEVVisitor
class	AbstractLatticeFunction
class	SparseSolver
class	Trace
class	Argument
	LLVM Argument representation. More...
class	AssemblyAnnotationWriter
class	ParseError
	An LLVM Assembly Parsing Error Object. More...
struct	AttributeWithIndex
class	AttrListPtr
struct	ilist_traits< Instruction >
class	BasicBlock
	LLVM Basic Block Representation. More...
class	ArchiveMember
	This class represents a single archive member. More...
class	Archive
class	BitCodeAbbrevOp
class	BitCodeAbbrev
class	BitstreamReader
class	BitstreamWriter
class	Deserializer
struct	SerializeTrait
class	Serializer
struct	CallGraphSCCPass
class	AsmPrinter
class	CCValAssign
	CCValAssign - Represent assignment of one arg/retval to a location. More...
class	CCState
struct	DebugLocTuple
class	DebugLoc
struct	DenseMapInfo< DebugLocTuple >
struct	DebugLocTracker
class	DwarfWriter
class	ELFRelocation
class	FastISel
struct	GCPoint
struct	GCRoot
class	GCFunctionInfo
class	GCModuleInfo
class	GCMetadataPrinter
class	GCStrategy
class	IntrinsicLowering
struct	latency_sort
	Sorting functions for the Available queue. More...
class	LatencyPriorityQueue
struct	VNInfo
struct	LiveRange
struct	LiveInterval
struct	Idx2MBBCompare
class	LiveIntervals
class	LiveStacks
class	LiveVariables
struct	ilist_traits< MachineInstr >
class	MachineBasicBlock
struct	GraphTraits< MachineBasicBlock * >
struct	GraphTraits< const MachineBasicBlock * >
struct	GraphTraits< Inverse< MachineBasicBlock * > >
struct	GraphTraits< Inverse< const MachineBasicBlock * > >
class	MachineCodeEmitter
class	MachineConstantPoolValue
class	MachineConstantPoolEntry
	An entry in a MachineConstantPool. More...
class	MachineConstantPool
	The machine constant pool. More...
class	MachineDominatorTree
struct	GraphTraits< MachineDomTreeNode * >
struct	GraphTraits< MachineDominatorTree * >
class	CalleeSavedInfo
class	MachineFrameInfo
	Abstract Stack Frame Information. More...
struct	ilist_traits< MachineBasicBlock >
struct	MachineFunctionInfo
class	MachineFunction
struct	GraphTraits< MachineFunction * >
struct	GraphTraits< const MachineFunction * >
struct	GraphTraits< Inverse< MachineFunction * > >
struct	GraphTraits< Inverse< const MachineFunction * > >
struct	MachineFunctionPass
class	MachineInstr
class	MachineInstrBuilder
struct	MachineJumpTableEntry
class	MachineJumpTableInfo
class	MachineLocation
class	MachineMove
class	MachineLoopInfo
struct	GraphTraits< const MachineLoop * >
struct	GraphTraits< MachineLoop * >
class	MachineMemOperand
class	SourceLineInfo
struct	LandingPadInfo
class	MachineModuleInfo
class	MachineOperand
class	MachinePassRegistryListener
class	MachinePassRegistryNode
class	MachinePassRegistry
class	RegisterPassParser
class	MachineRegisterInfo
class	MachineRelocation
class	MachORelocation
class	PseudoSourceValue
class	RegisterRegAlloc
class	RegisterCoalescer
class	RegallocQuery
class	RegScavenger
class	SDep
struct	SUnit
	SUnit - Scheduling unit. This is a node in the scheduling DAG. More...
class	SchedulingPriorityQueue
class	ScheduleDAG
class	SUnitIterator
struct	GraphTraits< SUnit * >
struct	GraphTraits< ScheduleDAG * >
class	ScheduleDAGTopologicalSort
class	ScheduleDAGInstrs
class	ScheduleDAGSDNodes
class	ScheduleHazardRecognizer
class	RegisterScheduler
struct	ilist_traits< SDNode >
class	SelectionDAG
struct	GraphTraits< SelectionDAG * >
class	SelectionDAGISel
struct	SDVTList
class	SDValue
struct	DenseMapInfo< SDValue >
struct	simplify_type< SDValue >
struct	simplify_type< const SDValue >
class	SDUse
struct	simplify_type< SDUse >
struct	simplify_type< const SDUse >
class	SDNode
class	UnarySDNode
class	BinarySDNode
class	TernarySDNode
class	HandleSDNode
class	MemSDNode
	Abstact virtual class for operations for memory operations. More...
class	AtomicSDNode
class	MemIntrinsicSDNode
class	ConstantSDNode
class	ConstantFPSDNode
class	GlobalAddressSDNode
class	FrameIndexSDNode
class	JumpTableSDNode
class	ConstantPoolSDNode
class	BasicBlockSDNode
class	SrcValueSDNode
class	MemOperandSDNode
class	RegisterSDNode
class	DbgStopPointSDNode
class	LabelSDNode
class	ExternalSymbolSDNode
class	CondCodeSDNode
class	CvtRndSatSDNode
class	ARG_FLAGSSDNode
	ARG_FLAGSSDNode - Leaf node holding parameter flags. More...
class	CallSDNode
	CallSDNode - Node for calls -- ISD::CALL. More...
class	VTSDNode
class	LSBaseSDNode
class	LoadSDNode
class	StoreSDNode
class	SDNodeIterator
struct	GraphTraits< SDNode * >
struct	MVT
struct	GraphTraits< llvmc::CompilationGraph * >
class	Constant
	LLVM Constant Representation. More...
class	ConstantInt
	Class for constant integers. More...
class	ConstantFP
class	ConstantAggregateZero
class	ConstantArray
struct	OperandTraits< ConstantArray >
class	ConstantStruct
struct	OperandTraits< ConstantStruct >
class	ConstantVector
struct	OperandTraits< ConstantVector >
class	ConstantPointerNull
class	ConstantExpr
struct	OperandTraits< ConstantExpr >
class	UndefValue
class	Debugger
class	NonErrorException
class	InferiorProcessDead
class	InferiorProcess
struct	SourceLanguageCache
class	SourceFileInfo
class	SourceFunctionInfo
class	ProgramInfo
class	StackFrame
class	RuntimeInfo
class	SourceFile
struct	SourceLanguage
class	DerivedType
class	IntegerType
	Integer representation type. More...
class	FunctionType
class	CompositeType
class	StructType
class	SequentialType
class	ArrayType
class	VectorType
class	PointerType
class	OpaqueType
class	ExecutionEngineState
class	ExecutionEngine
struct	GenericValue
class	JITMemoryManager
struct	ilist_traits< BasicBlock >
struct	ilist_traits< Argument >
class	Function
class	GlobalAlias
struct	OperandTraits< GlobalAlias >
class	GlobalValue
class	GlobalVariable
struct	OperandTraits< GlobalVariable >
class	InlineAsm
class	TerminatorInst
class	UnaryInstruction
struct	OperandTraits< UnaryInstruction >
class	BinaryOperator
struct	OperandTraits< BinaryOperator >
class	CastInst
	Base class of casting instructions. More...
class	CmpInst
	Abstract base class of comparison instructions. More...
struct	OperandTraits< CmpInst >
class	Instruction
class	AllocationInst
class	MallocInst
class	AllocaInst
class	FreeInst
class	LoadInst
class	StoreInst
struct	OperandTraits< StoreInst >
class	GetElementPtrInst
struct	OperandTraits< GetElementPtrInst >
class	ICmpInst
	Represent an integer comparison operator. More...
class	FCmpInst
	Represents a floating point comparison operator. More...
class	VICmpInst
	Represents a vector integer comparison operator. More...
class	VFCmpInst
	Represents a vector floating point comparison operator. More...
class	CallInst
struct	OperandTraits< CallInst >
class	SelectInst
struct	OperandTraits< SelectInst >
class	VAArgInst
class	ExtractElementInst
struct	OperandTraits< ExtractElementInst >
class	InsertElementInst
struct	OperandTraits< InsertElementInst >
class	ShuffleVectorInst
struct	OperandTraits< ShuffleVectorInst >
class	ExtractValueInst
class	InsertValueInst
struct	OperandTraits< InsertValueInst >
class	PHINode
struct	OperandTraits< PHINode >
class	ReturnInst
struct	OperandTraits< ReturnInst >
class	BranchInst
struct	OperandTraits< BranchInst >
class	SwitchInst
struct	OperandTraits< SwitchInst >
class	InvokeInst
struct	OperandTraits< InvokeInst >
class	UnwindInst
class	UnreachableInst
class	TruncInst
	This class represents a truncation of integer types. More...
class	ZExtInst
	This class represents zero extension of integer types. More...
class	SExtInst
	This class represents a sign extension of integer types. More...
class	FPTruncInst
	This class represents a truncation of floating point types. More...
class	FPExtInst
	This class represents an extension of floating point types. More...
class	UIToFPInst
	This class represents a cast unsigned integer to floating point. More...
class	SIToFPInst
	This class represents a cast from signed integer to floating point. More...
class	FPToUIInst
	This class represents a cast from floating point to unsigned integer. More...
class	FPToSIInst
	This class represents a cast from floating point to signed integer. More...
class	IntToPtrInst
	This class represents a cast from an integer to a pointer. More...
class	PtrToIntInst
	This class represents a cast from a pointer to an integer. More...
class	BitCastInst
	This class represents a no-op cast from one type to another. More...
class	IntrinsicInst
struct	DbgInfoIntrinsic
struct	DbgStopPointInst
struct	DbgFuncStartInst
struct	DbgRegionStartInst
struct	DbgRegionEndInst
struct	DbgDeclareInst
struct	MemIntrinsic
struct	MemCpyInst
struct	MemMoveInst
struct	MemSetInst
struct	EHSelectorInst
class	Linker
	The LLVM Linker. More...
struct	ilist_traits< Function >
struct	ilist_traits< GlobalVariable >
struct	ilist_traits< GlobalAlias >
class	Module
	The main container class for the LLVM Intermediate Representation. More...
class	ModuleProvider
struct	ExistingModuleProvider
struct	FixedNumOperandTraits
struct	OptionalOperandTraits
struct	VariadicOperandTraits
struct	HungoffOperandTraits
class	Pass
class	ModulePass
class	ImmutablePass
class	FunctionPass
class	BasicBlockPass
class	AnalysisUsage
class	AnalysisResolver
class	PassManagerBase
class	PassManager
	PassManager manages ModulePassManagers. More...
class	FunctionPassManager
	FunctionPassManager manages FunctionPasses and BasicBlockPassManagers. More...
class	PMStack
class	PMTopLevelManager
class	PMDataManager
class	FPPassManager
class	PassInfo
struct	RegisterPass
class	RegisterAGBase
struct	RegisterAnalysisGroup
struct	PassRegistrationListener
struct	AlignmentCalcImpl
struct	AlignOf
class	MallocAllocator
class	BumpPtrAllocator
class	AnnotationID
class	Annotation
class	Annotable
struct	AnnotationManager
class	CallSite
struct	simplify_type
struct	simplify_type< const From >
struct	isa_impl_wrap
struct	isa_impl_wrap< To, const FromTy, const FromTy >
struct	isa_impl_cl
struct	isa_impl_cl< const FromCl >
struct	isa_impl_cl< FromCl * >
struct	isa_impl_cl< FromCl & >
struct	cast_retty_impl
struct	cast_retty_impl< To, const From >
struct	cast_retty_impl< To, From * >
struct	cast_retty_impl< To, const From * >
struct	cast_retty_impl< To, const From *const >
struct	cast_retty_wrap
struct	cast_retty_wrap< To, FromTy, FromTy >
struct	cast_retty
struct	cast_convert_val
struct	cast_convert_val< To, FromTy, FromTy >
class	PredIterator
class	SuccIterator
struct	GraphTraits< BasicBlock * >
struct	GraphTraits< const BasicBlock * >
struct	GraphTraits< Inverse< BasicBlock * > >
struct	GraphTraits< Inverse< const BasicBlock * > >
struct	GraphTraits< Function * >
struct	GraphTraits< const Function * >
struct	GraphTraits< Inverse< Function * > >
struct	GraphTraits< Inverse< const Function * > >
class	ConstantFolder
	ConstantFolder - Create constants with minimum, target independent, folding. More...
class	ConstantRange
struct	GraphTraits< const User * >
struct	GraphTraits< User * >
struct	GraphTraits< Inverse< const User * > >
struct	GraphTraits< Inverse< User * > >
struct	DefaultDOTGraphTraits
struct	DOTGraphTraits
class	FileRemover
class	format_object_base
class	format_object1
class	format_object2
class	format_object3
class	generic_gep_type_iterator
class	GraphWriter
class	InstIterator
class	IRBuilder
struct	LeakDetector
class	ManagedStaticBase
	ManagedStaticBase - Common base class for ManagedStatic instances. More...
class	ManagedStatic
class	ManagedCleanup
struct	llvm_shutdown_obj
class	Mangler
class	MemoryBuffer
class	MutexGuard
	Guard a section of code with a Mutex. More...
class	NoFolder
	NoFolder - Create "constants" (actually, values) with no folding. More...
class	OutputBuffer
class	PassNameParser
class	FilteredPassNameParser
class	PassArgFilter
struct	PluginLoader
class	PredIteratorCache
class	raw_ostream
class	raw_fd_ostream
class	raw_stdout_ostream
class	raw_stderr_ostream
class	raw_os_ostream
class	raw_string_ostream
class	raw_svector_ostream
struct	RecyclerStruct
struct	ilist_traits< RecyclerStruct >
class	Recycler
class	RecyclingAllocator
class	SimpleRegistryEntry
class	RegistryTraits
class	Registry
class	RegistryParser
class	SlowOperationInformer
class	StableBasicBlockNumbering
class	StringPool
class	PooledStringPtr
class	TargetFolder
	TargetFolder - Create constants with target dependent folding. More...
class	Timer
class	TimeRegion
struct	NamedRegionTimer
class	TimerGroup
struct	is_class
class	SymbolTableListTraits
struct	IncludeFile
	Class to ensure linking of corresponding object file. More...
struct	DarwinTargetAsmInfo
struct	ELFTargetAsmInfo
struct	SubtargetFeatureKV
struct	SubtargetInfoKV
class	SubtargetFeatures
class	Section
class	TargetAsmInfo
struct	TargetAlignElem
class	TargetData
class	StructLayout
class	TargetELFWriterInfo
class	TargetFrameInfo
class	TargetOperandInfo
class	TargetInstrDesc
class	TargetInstrInfo
class	TargetInstrInfoImpl
struct	InstrStage
struct	InstrItinerary
struct	InstrItineraryData
class	TargetJITInfo
class	TargetLowering
class	TargetMachine
class	LLVMTargetMachine
struct	TargetMachineRegistryEntry
class	RegistryTraits< TargetMachine >
struct	TargetMachineRegistry
struct	RegisterTarget
class	TargetMachOWriterInfo
struct	TargetRegisterDesc
class	TargetRegisterClass
class	TargetRegisterInfo
struct	VirtReg2IndexFunctor
class	TargetSubtarget
struct	Inliner
struct	RSProfilers
class	BasicInliner
struct	ClonedCodeInfo
class	InlineCost
class	InlineCostAnalyzer
	InlineCostAnalyzer - Cost analyzer used by inliner. More...
struct	UnifyFunctionExitNodes
class	Type
	Root of type hierarchy. More...
struct	GraphTraits< Type * >
struct	GraphTraits< const Type * >
class	TypeSymbolTable
class	Use
struct	simplify_type< Use >
struct	simplify_type< const Use >
class	value_use_iterator
struct	simplify_type< value_use_iterator< User > >
struct	simplify_type< const value_use_iterator< User > >
struct	simplify_type< value_use_iterator< const User > >
struct	simplify_type< const value_use_iterator< const User > >
struct	OperandTraits< User >
	OperandTraits<User> - specialization to User. More...
class	User
struct	simplify_type< User::op_iterator >
struct	simplify_type< const User::op_iterator >
struct	simplify_type< User::const_op_iterator >
struct	simplify_type< const User::const_op_iterator >
class	Value
	LLVM Value Representation. More...
class	ValueSymbolTable
struct	DOTGraphTraits< const Function * >
class	ArchiveMemberHeader
	Archive File Member Header. More...
class	LLLexer
struct	ValID
class	LLParser
struct	OperandTraits< ConstantPlaceHolder >
class	BitcodeReaderValueList
struct	OperandTraits< BitcodeReaderValueList >
class	BitcodeReader
class	ValueEnumerator
class	ELFCodeEmitter
class	ELFWriter
struct	DOTGraphTraits< const MachineFunction * >
struct	DebugLabelFolder
class	MachOCodeEmitter
struct	MachOSym
class	MachOWriter
struct	adjnode
struct	bucketnode
struct	pbqp
class	PBQPVector
	PBQP Vector class. More...
class	PBQPMatrix
	PBQP Matrix class. More...
class	PhysRegTracker
struct	DOTGraphTraits< ScheduleDAG * >
class	DAGTypeLegalizer
struct	RegsForValue
struct	SDISelAsmOperandInfo
class	FunctionLoweringInfo
class	SelectionDAGLowering
struct	DOTGraphTraits< SelectionDAG * >
struct	CopyRec
struct	CopyRecSort
class	JoinPriorityQueue
class	SimpleRegisterCoalescing
class	VirtRegMap
struct	Spiller
class	AllocaHolder
class	AllocaHolderHandle
struct	ExecutionContext
class	Interpreter
class	JITState
class	JIT
class	JITDwarfEmitter
struct	fltSemantics
class	AlphaInstrInfo
class	AlphaTargetLowering
class	AlphaJITInfo
struct	AlphaRegisterInfo
class	AlphaSubtarget
struct	AlphaTargetAsmInfo
class	AlphaTargetMachine
class	ARMConstantPoolValue
class	ARMFrameInfo
class	ARMInstrInfo
class	ARMTargetLowering
class	ARMJITInfo
class	ARMFunctionInfo
struct	ARMRegisterInfo
class	ARMSubtarget
struct	ARMTargetAsmInfo
struct	ARMDarwinTargetAsmInfo
struct	ARMELFTargetAsmInfo
class	ARMTargetMachine
class	ThumbTargetMachine
struct	CTargetMachine
class	SPUFrameInfo
class	SPUHazardRecognizer
	SPUHazardRecognizer. More...
class	SPUInstrInfo
	Cell SPU instruction information class. More...
class	SPUTargetLowering
class	SPUFunctionInfo
class	SPURegisterInfo
class	SPUSubtarget
struct	SPUTargetAsmInfo
struct	SPULinuxTargetAsmInfo
class	SPUTargetMachine
struct	CPPTargetMachine
class	IA64InstrInfo
class	IA64TargetLowering
class	IA64FunctionInfo
struct	IA64RegisterInfo
class	IA64Subtarget
struct	IA64TargetAsmInfo
class	IA64TargetMachine
class	MipsInstrInfo
class	MipsTargetLowering
class	MipsFunctionInfo
struct	MipsRegisterInfo
class	MipsSubtarget
struct	MipsTargetAsmInfo
class	MipsTargetMachine
class	MipselTargetMachine
struct	PIC16AsmPrinter
class	PIC16InstrInfo
class	PIC16TargetLowering
class	PIC16RegisterInfo
class	PIC16Subtarget
struct	PIC16TargetAsmInfo
class	PIC16TargetMachine
class	CooperTargetMachine
	CooperTargetMachine. More...
class	PPCFrameInfo
class	PPCHazardRecognizer970
class	PPCInstrInfo
class	PPCTargetLowering
class	PPCJITInfo
class	PPCFunctionInfo
class	PPCMachOWriterInfo
class	PPCRegisterInfo
class	PPCSubtarget
struct	PPCTargetAsmInfo
struct	PPCDarwinTargetAsmInfo
struct	PPCLinuxTargetAsmInfo
class	PPCTargetMachine
class	PPC32TargetMachine
class	PPC64TargetMachine
class	SparcInstrInfo
class	SparcTargetLowering
struct	SparcRegisterInfo
class	SparcSubtarget
struct	SparcELFTargetAsmInfo
class	SparcTargetMachine
struct	X86ATTAsmPrinter
struct	X86IntelAsmPrinter
class	X86ELFWriterInfo
struct	X86AddressMode
class	X86InstrInfo
class	X86TargetLowering
class	X86JITInfo
class	X86MachineFunctionInfo
class	X86RegisterInfo
class	X86Subtarget
struct	X86TargetAsmInfo
struct	X86DarwinTargetAsmInfo
struct	X86ELFTargetAsmInfo
struct	X86COFFTargetAsmInfo
struct	X86WinTargetAsmInfo
class	X86TargetMachine
class	X86_32TargetMachine
class	X86_64TargetMachine
class	XCoreFrameInfo
class	XCoreInstrInfo
class	XCoreTargetLowering
class	XCoreFunctionInfo
struct	XCoreRegisterInfo
class	XCoreSubtarget
class	XCoreTargetAsmInfo
class	XCoreTargetMachine
struct	RSProfilers_std
struct	DenseMapInfo< Expression >
struct	BasicInlinerImpl
struct	DenseMapInfo< std::pair< BasicBlock *, unsigned > >
class	AttributeListImpl
struct	OperandTraits< UnaryConstantExpr >
struct	OperandTraits< BinaryConstantExpr >
struct	OperandTraits< SelectConstantExpr >
struct	OperandTraits< ExtractElementConstantExpr >
struct	OperandTraits< InsertElementConstantExpr >
struct	OperandTraits< ShuffleVectorConstantExpr >
struct	OperandTraits< ExtractValueConstantExpr >
struct	OperandTraits< InsertValueConstantExpr >
struct	OperandTraits< GetElementPtrConstantExpr >
struct	OperandTraits< CompareConstantExpr >
struct	ConstantTraits< std::vector< T, Alloc > >
struct	ConstantCreator
struct	ConvertConstantType
class	ValueMap
struct	ConstantCreator< ConstantAggregateZero, Type, ValType >
struct	ConvertConstantType< ConstantAggregateZero, Type >
struct	ConvertConstantType< ConstantArray, ArrayType >
struct	ConvertConstantType< ConstantStruct, StructType >
struct	ConvertConstantType< ConstantVector, VectorType >
struct	ConstantCreator< ConstantPointerNull, PointerType, ValType >
struct	ConvertConstantType< ConstantPointerNull, PointerType >
struct	ConstantCreator< UndefValue, Type, ValType >
struct	ConvertConstantType< UndefValue, Type >
struct	ConstantCreator< ConstantExpr, Type, ExprMapKeyType >
struct	ConvertConstantType< ConstantExpr, Type >
class	FunctionPassManagerImpl
	FunctionPassManagerImpl manages FPPassManagers. More...
class	MPPassManager
class	PassManagerImpl
	PassManagerImpl manages MPPassManagers. More...
struct	GraphTraits< TypePromotionGraph >
class	TypeMapBase
class	TypeMap
class	IntegerValType
class	FunctionValType
class	ArrayValType
class	VectorValType
class	StructValType
class	PointerValType
struct	AugmentedUse
Namespaces
namespace	Alpha
namespace	AlphaISD
namespace	APIntOps
namespace	ARM
namespace	ARM_AM
	ARM_AM - ARM Addressing Mode Stuff.
namespace	ARMCC
namespace	ARMCP
namespace	ARMII
namespace	ARMISD
namespace	Attribute
namespace	bitc
namespace	CallingConv
namespace	cl
namespace	CodeModel
namespace	dont_use
namespace	DOT
namespace	dwarf
namespace	DwarfEncoding
namespace	DWARFFlavour
namespace	ELF
namespace	FileModel
namespace	GC
namespace	IA64ISD
namespace	Intrinsic
namespace	ISD
namespace	lltok
namespace	Mips
namespace	MipsISD
namespace	N86
namespace	PatternMatch
namespace	PIC16CC
namespace	PIC16ISD
namespace	PICStyles
namespace	PPC
	Define some predicates that are used for node matching.
namespace	PPCII
namespace	PPCISD
namespace	Reloc
namespace	RTLIB
namespace	SectionFlags
namespace	SectionKind
namespace	SPCC
namespace	SPII
namespace	SPISD
namespace	SPU
	Utility functions specific to CellSPU:.
namespace	SPUISD
namespace	sys
namespace	TID
namespace	TOI
namespace	X86
	Define some predicates that are used for node matching.
namespace	X86II
namespace	X86ISD
namespace	XCore
namespace	XCoreISD
Typedefs
typedef signed short	exponent_t
typedef uint64_t	integerPart
typedef FoldingSetImpl::Node	FoldingSetNode
typedef DomTreeNodeBase < BasicBlock >	DomTreeNode
typedef IntervalIterator < BasicBlock, Function >	function_interval_iterator
typedef IntervalIterator < Interval, IntervalPartition >	interval_part_interval_iterator
typedef LoopBase< BasicBlock >	Loop
typedef unsigned	Attributes
	Attributes - A bitset of attributes.
typedef unsigned	SerializedPtrID
typedef bool	CCAssignFn (unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)
typedef Registry < GCMetadataPrinter >	GCMetadataPrinterRegistry
typedef Registry< GCStrategy >	GCRegistry
typedef std::pair< unsigned, MachineBasicBlock * >	IdxMBBPair
typedef DomTreeNodeBase < MachineBasicBlock >	MachineDomTreeNode
typedef LoopBase < MachineBasicBlock >	MachineLoop
typedef void *(*	MachinePassCtor )()
typedef LoadSDNode	LargestSDNode
typedef ARG_FLAGSSDNode	MostAlignedSDNode
typedef void *	PointerTy
typedef const PassInfo *	AnalysisID
typedef PredIterator < BasicBlock, Value::use_iterator >	pred_iterator
typedef PredIterator< const BasicBlock, Value::use_const_iterator >	pred_const_iterator
typedef SuccIterator < TerminatorInst *, BasicBlock >	succ_iterator
typedef SuccIterator< const TerminatorInst *, const BasicBlock >	succ_const_iterator
typedef generic_gep_type_iterator	gep_type_iterator
typedef InstIterator< iplist < BasicBlock > , Function::iterator, BasicBlock::iterator, Instruction >	inst_iterator
typedef InstIterator< const iplist< BasicBlock > , Function::const_iterator, BasicBlock::const_iterator, const Instruction >	const_inst_iterator
typedef DenseMap< const Value *, Value * >	ValueMapTy
typedef StringMapEntry< Value * >	ValueName
typedef struct llvm::adjnode	adjnode
typedef struct llvm::bucketnode	bucketnode
typedef double	PBQPNum
	Floating point type to use in PBQP solver.
typedef struct pbqp	pbqp
typedef std::vector< GenericValue >	ValuePlaneTy
typedef ARMTargetAsmInfo < TargetAsmInfo >	ARMGenericTargetAsmInfo
typedef PPCTargetAsmInfo < TargetAsmInfo >	PPCGenericTargetAsmInfo
typedef X86TargetAsmInfo < TargetAsmInfo >	X86GenericTargetAsmInfo
Enumerations
enum	lostFraction { lfExactlyZero, lfLessThanHalf, lfExactlyHalf, lfMoreThanHalf }
enum	SCEVTypes {   scConstant, scTruncate, scZeroExtend, scSignExtend,   scAddExpr, scMulExpr, scUDivExpr, scAddRecExpr,   scUMaxExpr, scSMaxExpr, scUnknown, scCouldNotCompute }
enum	VerifierFailureAction { AbortProcessAction, PrintMessageAction, ReturnStatusAction }
	An enumeration to specify the action to be taken if errors found. More...
enum	CombineLevel { Unrestricted, NoIllegalTypes, NoIllegalOperations }
enum	PassManagerType {   PMT_Unknown = 0, PMT_ModulePassManager = 1, PMT_CallGraphPassManager, PMT_FunctionPassManager,   PMT_LoopPassManager, PMT_BasicBlockPassManager, PMT_Last }
enum	TopLevelManagerType { TLM_Function, TLM_Pass }
enum	PassDebuggingString {   EXECUTION_MSG, MODIFICATION_MSG, FREEING_MSG, ON_BASICBLOCK_MSG,   ON_FUNCTION_MSG, ON_MODULE_MSG, ON_LOOP_MSG, ON_CG_MSG }
enum	{   LLVMDebugVersion = (7 << 16), LLVMDebugVersion6 = (6 << 16), LLVMDebugVersion5 = (5 << 16), LLVMDebugVersion4 = (4 << 16),   LLVMDebugVersionMask = 0xffff0000 }
enum	AlignTypeEnum {   INTEGER_ALIGN = 'i', VECTOR_ALIGN = 'v', FLOAT_ALIGN = 'f', AGGREGATE_ALIGN = 'a',   STACK_ALIGN = 's' }
	Enum used to categorize the alignment types stored by TargetAlignElem. More...
enum	Tag { noTag, tagOne, tagTwo, tagThree }
	Tag - generic tag type for (at least 32 bit) pointers. More...
enum	NameDecorationStyle { None, StdCall, FastCall }
enum	PassDebugLevel {   None, Arguments, Structure, Executions,   Details }
Functions
bool	operator== (uint64_t V1, const APInt &V2)
bool	operator!= (uint64_t V1, const APInt &V2)
raw_ostream &	operator<< (raw_ostream &OS, const APInt &I)
raw_ostream &	operator<< (raw_ostream &OS, const APSInt &I)
BitVector	operator & (const BitVector &LHS, const BitVector &RHS)
BitVector	operator| (const BitVector &LHS, const BitVector &RHS)
BitVector	operator^ (const BitVector &LHS, const BitVector &RHS)
template<class T>
df_iterator< T >	df_begin (const T &G)
template<class T>
df_iterator< T >	df_end (const T &G)
template<class T, class SetTy>
df_ext_iterator< T, SetTy >	df_ext_begin (const T &G, SetTy &S)
template<class T, class SetTy>
df_ext_iterator< T, SetTy >	df_ext_end (const T &G, SetTy &S)
template<class T>
idf_iterator< T >	idf_begin (const T &G)
template<class T>
idf_iterator< T >	idf_end (const T &G)
template<class T, class SetTy>
idf_ext_iterator< T, SetTy >	idf_ext_begin (const T &G, SetTy &S)
template<class T, class SetTy>
idf_ext_iterator< T, SetTy >	idf_ext_end (const T &G, SetTy &S)
template<typename T>
void	operator- (int, ilist_iterator< T >)
template<typename T>
void	operator- (ilist_iterator< T >, int)
template<typename T>
void	operator+ (int, ilist_iterator< T >)
template<typename T>
void	operator+ (ilist_iterator< T >, int)
template<typename T>
bool	operator!= (const T *LHS, const ilist_iterator< const T > &RHS)
template<typename T>
bool	operator== (const T *LHS, const ilist_iterator< const T > &RHS)
template<typename T>
bool	operator!= (T *LHS, const ilist_iterator< T > &RHS)
template<typename T>
bool	operator== (T *LHS, const ilist_iterator< T > &RHS)
template<class T, class U>
bool	operator== (const IntrusiveRefCntPtr< T > &A, const IntrusiveRefCntPtr< U > &B)
template<class T, class U>
bool	operator!= (const IntrusiveRefCntPtr< T > &A, const IntrusiveRefCntPtr< U > &B)
template<class T, class U>
bool	operator== (const IntrusiveRefCntPtr< T > &A, U *B)
template<class T, class U>
bool	operator!= (const IntrusiveRefCntPtr< T > &A, U *B)
template<class T, class U>
bool	operator== (T *A, const IntrusiveRefCntPtr< U > &B)
template<class T, class U>
bool	operator!= (T *A, const IntrusiveRefCntPtr< U > &B)
template<class T>
void	swap (OwningPtr< T > &a, OwningPtr< T > &b)
template<class T>
void	swap (OwningArrayPtr< T > &a, OwningArrayPtr< T > &b)
template<class T>
po_iterator< T >	po_begin (T G)
template<class T>
po_iterator< T >	po_end (T G)
template<class T, class SetType>
po_ext_iterator< T, SetType >	po_ext_begin (T G, SetType &S)
template<class T, class SetType>
po_ext_iterator< T, SetType >	po_ext_end (T G, SetType &S)
template<class T>
ipo_iterator< T >	ipo_begin (T G, bool Reverse=false)
template<class T>
ipo_iterator< T >	ipo_end (T G)
template<class T, class SetType>
ipo_ext_iterator< T, SetType >	ipo_ext_begin (T G, SetType &S)
template<class T, class SetType>
ipo_ext_iterator< T, SetType >	ipo_ext_end (T G, SetType &S)
template<class T>
scc_iterator< T >	scc_begin (T G)
template<class T>
scc_iterator< T >	scc_end (T G)
template<class S1Ty, class S2Ty>
bool	set_union (S1Ty &S1, const S2Ty &S2)
template<class S1Ty, class S2Ty>
void	set_intersect (S1Ty &S1, const S2Ty &S2)
template<class S1Ty, class S2Ty>
S1Ty	set_difference (const S1Ty &S1, const S2Ty &S2)
template<class S1Ty, class S2Ty>
void	set_subtract (S1Ty &S1, const S2Ty &S2)
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>
void	dump (const SparseBitVector< ElementSize > &LHS, llvm::OStream &out)
template<class T>
static void	deleter (T *Ptr)
template<class _Iterator, class Func>
mapped_iterator< _Iterator, Func >	operator+ (typename mapped_iterator< _Iterator, Func >::difference_type N, const mapped_iterator< _Iterator, Func > &X)
template<class ItTy, class FuncTy>
mapped_iterator< ItTy, FuncTy >	map_iterator (const ItTy &I, FuncTy F)
template<typename ItTy, typename Dist>
ItTy	next (ItTy it, Dist n)
template<typename ItTy>
ItTy	next (ItTy it)
template<typename ItTy, typename Dist>
ItTy	prior (ItTy it, Dist n)
template<typename ItTy>
ItTy	prior (ItTy it)
template<typename T1, typename T2>
tier< T1, T2 >	tie (T1 &f, T2 &s)
template<class T, std::size_t N>
T *	array_endof (T(&x)[N])
template<class T, std::size_t N>
size_t	array_lengthof (T(&x)[N])
	Find the length of an array.
template<typename T>
static int	array_pod_sort_comparator (const void *P1, const void *P2)
template<typename T>
static int(*)(const void *, const void *)	get_array_pad_sort_comparator (const T &X)
template<class IteratorTy>
static void	array_pod_sort (IteratorTy Start, IteratorTy End)
static char	hexdigit (unsigned X)
template<typename IntTy>
static char *	utohex_buffer (IntTy X, char *BufferEnd)
static std::string	utohexstr (uint64_t X)
static std::string	utostr_32 (uint32_t X, bool isNeg=false)
static std::string	utostr (uint64_t X, bool isNeg=false)
static std::string	itostr (int64_t X)
static std::string	itohexstr (int64_t X)
static std::string	ftostr (double V)
static std::string	ftostr (const APFloat &V)
static std::string	LowercaseString (const std::string &S)
static std::string	UppercaseString (const std::string &S)
static bool	StringsEqualNoCase (const std::string &LHS, const std::string &RHS)
static bool	StringsEqualNoCase (const std::string &LHS, const char *RHS)
static const char *	CStrInCStrNoCase (const char *s1, const char *s2)
std::string	getToken (std::string &Source, const char *Delimiters=" \t\n\v\f\r")
void	SplitString (const std::string &Source, std::vector< std::string > &OutFragments, const char *Delimiters=" \t\n\v\f\r")
void	UnescapeString (std::string &Str)
void	EscapeString (std::string &Str)
template<typename T>
std::vector< T >	make_vector (T A,...)
bool	isNoAliasCall (const Value *V)
bool	isIdentifiedObject (const Value *V)
std::ostream &	operator<< (std::ostream &OS, const AliasSet &AS)
std::ostream &	operator<< (std::ostream &OS, const AliasSetTracker &AST)
bool	PointerMayBeCaptured (const Value *V, bool ReturnCaptures)
FunctionPass *	createCFGPrinterPass ()
FunctionPass *	createCFGOnlyPrinterPass ()
Constant *	ConstantFoldInstruction (Instruction *I, const TargetData *TD=0)
Constant *	ConstantFoldConstantExpression (ConstantExpr *CE, const TargetData *TD)
Constant *	ConstantFoldInstOperands (unsigned Opcode, const Type *DestTy, Constant *const *Ops, unsigned NumOps, const TargetData *TD=0)
Constant *	ConstantFoldCompareInstOperands (unsigned Predicate, Constant *const *Ops, unsigned NumOps, const TargetData *TD=0)
Constant *	ConstantFoldLoadThroughGEPConstantExpr (Constant *C, ConstantExpr *CE)
bool	canConstantFoldCallTo (const Function *F)
Constant *	ConstantFoldCall (Function *F, Constant *const *Operands, unsigned NumOperands)
constant_iterator	constant_begin (const Function *F)
constant_iterator	constant_end (const Function *F)
const DbgStopPointInst *	findStopPoint (const Instruction *Inst)
const DbgStopPointInst *	findBBStopPoint (const BasicBlock *BB)
const DbgDeclareInst *	findDbgDeclare (const Value *V, bool stripCasts=true)
template<class GraphT>
unsigned	DFSPass (DominatorTreeBase< typename GraphT::NodeType > &DT, typename GraphT::NodeType *V, unsigned N)
template<class GraphT>
void	Compress (DominatorTreeBase< typename GraphT::NodeType > &DT, typename GraphT::NodeType *VIn)
template<class GraphT>
GraphT::NodeType *	Eval (DominatorTreeBase< typename GraphT::NodeType > &DT, typename GraphT::NodeType *V)
template<class GraphT>
void	Link (DominatorTreeBase< typename GraphT::NodeType > &DT, unsigned DFSNumV, typename GraphT::NodeType *W, typename DominatorTreeBase< typename GraphT::NodeType >::InfoRec &WInfo)
template<class FuncT, class NodeT>
void	Calculate (DominatorTreeBase< typename GraphTraits< NodeT >::NodeType > &DT, FuncT &F)
	EXTERN_TEMPLATE_INSTANTIATION (class DomTreeNodeBase< BasicBlock >)
	EXTERN_TEMPLATE_INSTANTIATION (class DomTreeNodeBase< MachineBasicBlock >)
template<class NodeT>
static std::ostream &	operator<< (std::ostream &o, const DomTreeNodeBase< NodeT > *Node)
template<class NodeT>
static void	PrintDomTree (const DomTreeNodeBase< NodeT > *N, std::ostream &o, unsigned Lev)
template<class FuncT, class N>
void	Calculate (DominatorTreeBase< typename GraphTraits< N >::NodeType > &DT, FuncT &F)
	EXTERN_TEMPLATE_INSTANTIATION (class DominatorTreeBase< BasicBlock >)
Interval::succ_iterator	succ_begin (Interval *I)
Interval::succ_iterator	succ_end (Interval *I)
Interval::pred_iterator	pred_begin (Interval *I)
Interval::pred_iterator	pred_end (Interval *I)
BasicBlock *	getNodeHeader (BasicBlock *BB)
BasicBlock *	getNodeHeader (Interval *I)
BasicBlock *	getSourceGraphNode (Function *, BasicBlock *BB)
Interval *	getSourceGraphNode (IntervalPartition *IP, BasicBlock *BB)
void	addNodeToInterval (Interval *Int, BasicBlock *BB)
void	addNodeToInterval (Interval *Int, Interval *I)
function_interval_iterator	intervals_begin (Function *F, bool DeleteInts=true)
function_interval_iterator	intervals_end (Function *)
interval_part_interval_iterator	intervals_begin (IntervalPartition &IP, bool DeleteIntervals=true)
interval_part_interval_iterator	intervals_end (IntervalPartition &IP)
template<typename T>
static void	RemoveFromVector (std::vector< T * > &V, T *N)
Pass *	createGlobalsModRefPass ()
Pass *	createAliasDebugger ()
ModulePass *	createAliasAnalysisCounterPass ()
FunctionPass *	createAAEvalPass ()
ImmutablePass *	createNoAAPass ()
ImmutablePass *	createBasicAliasAnalysisPass ()
FunctionPass *	createLibCallAliasAnalysisPass (LibCallInfo *LCI)
ModulePass *	createAndersensPass ()
ModulePass *	createProfileLoaderPass ()
ImmutablePass *	createNoProfileInfoPass ()
ModulePass *	createDSAAPass ()
ModulePass *	createDSOptPass ()
ModulePass *	createSteensgaardPass ()
FunctionPass *	createInstCountPass ()
FunctionPass *	createDbgInfoPrinterPass ()
FunctionPass *	createPostDomTree ()
FunctionPass *	createPostDomFrontier ()
Pass *	createProfileLoaderPass (const std::string &Filename)
std::ostream &	operator<< (std::ostream &OS, const SCEV &S)
void	ComputeMaskedBits (Value *V, const APInt &Mask, APInt &KnownZero, APInt &KnownOne, TargetData *TD=0, unsigned Depth=0)
bool	MaskedValueIsZero (Value *V, const APInt &Mask, TargetData *TD=0, unsigned Depth=0)
unsigned	ComputeNumSignBits (Value *Op, TargetData *TD=0, unsigned Depth=0)
bool	CannotBeNegativeZero (const Value *V, unsigned Depth=0)
Value *	FindInsertedValue (Value *V, const unsigned *idx_begin, const unsigned *idx_end, Instruction *InsertBefore=0)
Value *	FindInsertedValue (Value *V, const unsigned Idx, Instruction *InsertBefore=0)
bool	GetConstantStringInfo (Value *V, std::string &Str, uint64_t Offset=0, bool StopAtNul=true)
FunctionPass *	createVerifierPass (VerifierFailureAction action=AbortProcessAction)
	Create a verifier pass.
bool	verifyModule (const Module &M, VerifierFailureAction action=AbortProcessAction, std::string *ErrorInfo=0)
	Check a module for errors.
bool	verifyFunction (const Function &F, VerifierFailureAction action=AbortProcessAction)
Module *	ParseAssemblyFile (const std::string &Filename, ParseError &Error)
	Parse LLVM Assembly from a file.
Module *	ParseAssemblyString (const char *AsmString, Module *M, ParseError &Error)
	Parse LLVM Assembly from a string.
ModulePass *	createPrintModulePass (raw_ostream *OS, bool DeleteStream=false)
FunctionPass *	createPrintFunctionPass (const std::string &Banner, raw_ostream *OS, bool DeleteStream=false)
void	WriteTypeSymbolic (std::ostream &, const Type *, const Module *M)
void	WriteTypeSymbolic (raw_ostream &, const Type *, const Module *M)
void	WriteAsOperand (std::ostream &, const Value *, bool PrintTy=true, const Module *Context=0)
void	WriteAsOperand (raw_ostream &, const Value *, bool PrintTy=true, const Module *Context=0)
bool	UpgradeIntrinsicFunction (Function *F, Function *&NewFn)
void	UpgradeIntrinsicCall (CallInst *CI, Function *NewFn)
void	UpgradeCallsToIntrinsic (Function *F)
ModuleProvider *	getBitcodeModuleProvider (MemoryBuffer *Buffer, std::string *ErrMsg=0)
Module *	ParseBitcodeFile (MemoryBuffer *Buffer, std::string *ErrMsg=0)
void	WriteBitcodeToFile (const Module *M, std::ostream &Out)
void	WriteBitcodeToFile (const Module *M, raw_ostream &Out)
void	WriteBitcodeToStream (const Module *M, BitstreamWriter &Stream)
ModulePass *	CreateBitcodeWriterPass (std::ostream &Str)
ModulePass *	createBitcodeWriterPass (raw_ostream &Str)
MachineBasicBlock *	SplitCriticalMachineEdge (MachineBasicBlock *src, MachineBasicBlock *dst)
MachineCodeEmitter *	AddELFWriter (PassManagerBase &FPM, raw_ostream &O, TargetMachine &TM)
MachineCodeEmitter *	AddMachOWriter (PassManagerBase &FPM, raw_ostream &O, TargetMachine &TM)
void	linkOcamlGC ()
	Creates an ocaml-compatible garbage collector.
void	linkOcamlGCPrinter ()
	Creates an ocaml-compatible metadata printer.
void	linkShadowStackGC ()
std::ostream &	operator<< (std::ostream &os, const LiveRange &LR)
bool	operator< (unsigned V, const LiveRange &LR)
bool	operator< (const LiveRange &LR, unsigned V)
std::ostream &	operator<< (std::ostream &OS, const LiveInterval &LI)
bool	operator< (unsigned V, const IdxMBBPair &IM)
bool	operator< (const IdxMBBPair &IM, unsigned V)
std::ostream &	operator<< (std::ostream &OS, const MachineBasicBlock &MBB)
raw_ostream &	operator<< (raw_ostream &OS, const MachineConstantPoolValue &V)
void	WriteAsOperand (std::ostream &, const MachineBasicBlock *, bool t)
	EXTERN_TEMPLATE_INSTANTIATION (class DominatorTreeBase< MachineBasicBlock >)
std::ostream &	operator<< (std::ostream &OS, const MachineInstr &MI)
raw_ostream &	operator<< (raw_ostream &OS, const MachineInstr &MI)
MachineInstrBuilder	BuildMI (MachineFunction &MF, const TargetInstrDesc &TID)
MachineInstrBuilder	BuildMI (MachineFunction &MF, DebugLoc DL, const TargetInstrDesc &TID)
MachineInstrBuilder	BuildMI (MachineFunction &MF, const TargetInstrDesc &TID, unsigned DestReg)
MachineInstrBuilder	BuildMI (MachineFunction &MF, DebugLoc DL, const TargetInstrDesc &TID, unsigned DestReg)
MachineInstrBuilder	BuildMI (MachineBasicBlock &BB, MachineBasicBlock::iterator I, const TargetInstrDesc &TID, unsigned DestReg)
MachineInstrBuilder	BuildMI (MachineBasicBlock &BB, MachineBasicBlock::iterator I, DebugLoc DL, const TargetInstrDesc &TID, unsigned DestReg)
MachineInstrBuilder	BuildMI (MachineBasicBlock &BB, MachineBasicBlock::iterator I, const TargetInstrDesc &TID)
MachineInstrBuilder	BuildMI (MachineBasicBlock &BB, MachineBasicBlock::iterator I, DebugLoc DL, const TargetInstrDesc &TID)
MachineInstrBuilder	BuildMI (MachineBasicBlock *BB, const TargetInstrDesc &TID)
MachineInstrBuilder	BuildMI (MachineBasicBlock *BB, DebugLoc DL, const TargetInstrDesc &TID)
MachineInstrBuilder	BuildMI (MachineBasicBlock *BB, const TargetInstrDesc &TID, unsigned DestReg)
MachineInstrBuilder	BuildMI (MachineBasicBlock *BB, DebugLoc DL, const TargetInstrDesc &TID, unsigned DestReg)
std::ostream &	operator<< (std::ostream &OS, const MachineOperand &MO)
raw_ostream &	operator<< (raw_ostream &OS, const MachineOperand &MO)
FunctionPass *	createUnreachableBlockEliminationPass ()
FunctionPass *	createMachineFunctionPrinterPass (std::ostream *OS, const std::string &Banner="")
FunctionPass *	createDeadMachineInstructionElimPass ()
FunctionPass *	createRegisterAllocator ()
FunctionPass *	createSimpleRegisterAllocator ()
FunctionPass *	createLocalRegisterAllocator ()
FunctionPass *	createBigBlockRegisterAllocator ()
FunctionPass *	createLinearScanRegisterAllocator ()
FunctionPass *	createPBQPRegisterAllocator ()
RegisterCoalescer *	createSimpleRegisterCoalescer ()
FunctionPass *	createPrologEpilogCodeInserter ()
FunctionPass *	createLowerSubregsPass ()
FunctionPass *	createPostRAScheduler ()
	createPostRAScheduler - under development.
FunctionPass *	createBranchFoldingPass (bool DefaultEnableTailMerge)
FunctionPass *	createIfConverterPass ()
	IfConverter Pass - This pass performs machine code if conversion.
FunctionPass *	createLoopAlignerPass ()
FunctionPass *	createDebugLabelFoldingPass ()
FunctionPass *	createMachineCodeDeleter ()
FunctionPass *	getRegisterAllocator (TargetMachine &T)
FunctionPass *	createGCLoweringPass ()
FunctionPass *	createGCMachineCodeAnalysisPass ()
FunctionPass *	createGCInfoDeleter ()
FunctionPass *	createGCInfoPrinter (std::ostream &OS)
FunctionPass *	createMachineLICMPass ()
FunctionPass *	createMachineSinkingPass ()
FunctionPass *	createStackSlotColoringPass ()
	createStackSlotColoringPass - This pass performs stack slot coloring.
FunctionPass *	createStackProtectorPass (const TargetLowering *tli)
	createStackProtectorPass - This pass adds stack protectors to functions.
ScheduleDAG *	createBURRListDAGScheduler (SelectionDAGISel *IS, bool Fast)
ScheduleDAG *	createTDRRListDAGScheduler (SelectionDAGISel *IS, bool Fast)
ScheduleDAG *	createTDListDAGScheduler (SelectionDAGISel *IS, bool Fast)
ScheduleDAG *	createFastDAGScheduler (SelectionDAGISel *IS, bool Fast)
ScheduleDAG *	createDefaultScheduler (SelectionDAGISel *IS, bool Fast)
GenericValue	PTOGV (void *P)
void *	GVTOP (const GenericValue &GV)
void	LinkInInterpreter ()
void	LinkInJIT ()
static const Type *	checkType (const Type *Ty)
std::ostream &	operator<< (std::ostream &O, const Module &M)
	An iostream inserter for modules.
raw_ostream &	operator<< (raw_ostream &O, const Module &M)
std::ostream &	operator<< (std::ostream &OS, const Pass &P)
template<typename PassName>
Pass *	callDefaultCtor ()
template<typename T>
static unsigned	alignof ()
template<typename To, typename From>
bool	isa_impl (const From &Val)
template<class X, class Y>
bool	isa (const Y &Val)
template<class X, class Y>
cast_retty< X, Y >::ret_type	cast (const Y &Val)
template<class X, class Y>
cast_retty< X, Y * >::ret_type	cast_or_null (Y *Val)
template<class X, class Y>
cast_retty< X, Y >::ret_type	dyn_cast (const Y &Val)
template<class X, class Y>
cast_retty< X, Y >::ret_type	dyn_cast_or_null (const Y &Val)
pred_iterator	pred_begin (BasicBlock *BB)
pred_const_iterator	pred_begin (const BasicBlock *BB)
pred_iterator	pred_end (BasicBlock *BB)
pred_const_iterator	pred_end (const BasicBlock *BB)
succ_iterator	succ_begin (BasicBlock *BB)
succ_const_iterator	succ_begin (const BasicBlock *BB)
succ_iterator	succ_end (BasicBlock *BB)
succ_const_iterator	succ_end (const BasicBlock *BB)
raw_ostream &	operator<< (raw_ostream &OS, const ConstantRange &CR)
bool	isCurrentDebugType (const char *Type)
OStream &	getErrorOutputStream (const char *DebugType)
bool	LinkDynamicObject (const char *filename, std::string *ErrorMessage)
void *	GetAddressOfSymbol (const char *symbolName)
void *	GetAddressOfSymbol (const std::string &symbolName)
int	DiffFilesWithTolerance (const sys::PathWithStatus &FileA, const sys::PathWithStatus &FileB, double AbsTol, double RelTol, std::string *Error=0)
template<typename T>
format_object1< T >	format (const char *Fmt, const T &Val)
template<typename T1, typename T2>
format_object2< T1, T2 >	format (const char *Fmt, const T1 &Val1, const T2 &Val2)
template<typename T1, typename T2, typename T3>
format_object3< T1, T2, T3 >	format (const char *Fmt, const T1 &Val1, const T2 &Val2, const T3 &Val3)
gep_type_iterator	gep_type_begin (const User *GEP)
gep_type_iterator	gep_type_end (const User *GEP)
gep_type_iterator	gep_type_begin (const User &GEP)
gep_type_iterator	gep_type_end (const User &GEP)
template<typename ItTy>
generic_gep_type_iterator< ItTy >	gep_type_begin (const Type *Op0, ItTy I, ItTy E)
template<typename ItTy>
generic_gep_type_iterator< ItTy >	gep_type_end (const Type *Op0, ItTy I, ItTy E)
void	DisplayGraph (const sys::Path &Filename)
template<typename GraphType>
std::ostream &	WriteGraph (std::ostream &O, const GraphType &G, const std::string &Name="", const std::string &Title="")
template<typename GraphType>
sys::Path	WriteGraph (const GraphType &G, const std::string &Name, const std::string &Title="")
template<typename GraphType>
void	ViewGraph (const GraphType &G, const std::string &Name, const std::string &Title="")
inst_iterator	inst_begin (Function *F)
inst_iterator	inst_end (Function *F)
const_inst_iterator	inst_begin (const Function *F)
const_inst_iterator	inst_end (const Function *F)
inst_iterator	inst_begin (Function &F)
inst_iterator	inst_end (Function &F)
const_inst_iterator	inst_begin (const Function &F)
const_inst_iterator	inst_end (const Function &F)
	HANDLE_BINARY_INST (16, Shl, BinaryOperator) HANDLE_BINARY_INST(17
BinaryOperator	HANDLE_BINARY_INST (18, AShr, BinaryOperator) HANDLE_MEMORY_INST(22
BinaryOperator MallocInst	HANDLE_MEMORY_INST (24, Alloca, AllocaInst) HANDLE_MEMORY_INST(25
BinaryOperator MallocInst LoadInst	HANDLE_CAST_INST (28, Trunc, TruncInst) HANDLE_CAST_INST(29
BinaryOperator MallocInst LoadInst ZExtInst	HANDLE_CAST_INST (30, SExt, SExtInst) HANDLE_CAST_INST(31
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst	HANDLE_CAST_INST (32, FPToSI, FPToSIInst) HANDLE_CAST_INST(33
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst	HANDLE_CAST_INST (34, SIToFP, SIToFPInst) HANDLE_CAST_INST(35
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst	HANDLE_CAST_INST (36, FPExt, FPExtInst) HANDLE_CAST_INST(37
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst	HANDLE_CAST_INST (38, IntToPtr, IntToPtrInst) HANDLE_CAST_INST(39
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst	HANDLE_OTHER_INST (40, ICmp, ICmpInst) HANDLE_OTHER_INST(41
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst	HANDLE_OTHER_INST (42, PHI, PHINode) HANDLE_OTHER_INST(43
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst	HANDLE_OTHER_INST (44, Select, SelectInst) HANDLE_OTHER_INST(45
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction	HANDLE_OTHER_INST (46, UserOp2, Instruction) HANDLE_OTHER_INST(47
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst	HANDLE_OTHER_INST (48, ExtractElement, ExtractElementInst) HANDLE_OTHER_INST(49
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst	HANDLE_OTHER_INST (50, ShuffleVector, ShuffleVectorInst) HANDLE_OTHER_INST(51
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst ExtractValueInst	HANDLE_OTHER_INST (52, InsertValue, InsertValueInst) HANDLE_OTHER_INST(53
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst ExtractValueInst VICmpInst	HANDLE_OTHER_INST (54, VFCmp, VFCmpInst) template< typename SubClass
	Base class for instruction visitors.
template<class C>
void	object_deleter (void *Ptr)
void	llvm_shutdown ()
	llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
uint32_t	Hi_32 (uint64_t Value)
	Hi_32 - This function returns the high 32 bits of a 64 bit value.
uint32_t	Lo_32 (uint64_t Value)
	Lo_32 - This function returns the low 32 bits of a 64 bit value.
bool	isInt8 (int64_t Value)
	is?Type - these functions produce optimal testing for integer data types.
bool	isUInt8 (int64_t Value)
bool	isInt16 (int64_t Value)
bool	isUInt16 (int64_t Value)
bool	isInt32 (int64_t Value)
bool	isUInt32 (int64_t Value)
bool	isMask_32 (uint32_t Value)
bool	isMask_64 (uint64_t Value)
bool	isShiftedMask_32 (uint32_t Value)
bool	isShiftedMask_64 (uint64_t Value)
bool	isPowerOf2_32 (uint32_t Value)
bool	isPowerOf2_64 (uint64_t Value)
uint16_t	ByteSwap_16 (uint16_t Value)
uint32_t	ByteSwap_32 (uint32_t Value)
uint64_t	ByteSwap_64 (uint64_t Value)
unsigned	CountLeadingZeros_32 (uint32_t Value)
unsigned	CountLeadingOnes_32 (uint32_t Value)
unsigned	CountLeadingZeros_64 (uint64_t Value)
unsigned	CountLeadingOnes_64 (uint64_t Value)
unsigned	CountTrailingZeros_32 (uint32_t Value)
unsigned	CountTrailingOnes_32 (uint32_t Value)
unsigned	CountTrailingZeros_64 (uint64_t Value)
unsigned	CountTrailingOnes_64 (uint64_t Value)
unsigned	CountPopulation_32 (uint32_t Value)
unsigned	CountPopulation_64 (uint64_t Value)
unsigned	Log2_32 (uint32_t Value)
unsigned	Log2_64 (uint64_t Value)
unsigned	Log2_32_Ceil (uint32_t Value)
unsigned	Log2_64_Ceil (uint64_t Value)
uint64_t	GreatestCommonDivisor64 (uint64_t A, uint64_t B)
double	BitsToDouble (uint64_t Bits)
float	BitsToFloat (uint32_t Bits)
uint64_t	DoubleToBits (double Double)
uint32_t	FloatToBits (float Float)
int	IsNAN (float f)
	Platform-independent wrappers for the C99 isnan() function.
int	IsNAN (double d)
int	IsInf (float f)
	Platform-independent wrappers for the C99 isinf() function.
int	IsInf (double d)
static uint64_t	MinAlign (uint64_t A, uint64_t B)
static uint64_t	NextPowerOf2 (uint64_t A)
static cl::opt< PluginLoader, false, cl::parser< std::string > >	LoadOpt ("load", cl::ZeroOrMore, cl::value_desc("pluginfilename"), cl::desc("Load the specified plugin"))
raw_ostream &	outs ()
raw_ostream &	errs ()
void	PrintRecyclerStats (size_t Size, size_t Align, size_t FreeListSize)
bool	CheckBitcodeOutputToConsole (std::ostream *stream_to_check, bool print_warning=true)
	Check for output written to a console.
sys::Path	FindExecutable (const std::string &ExeName, const std::string &ProgramPath)
	Find a named executable.
std::ostream &	operator<< (std::ostream &strm, const sys::Path &aPath)
std::ostream &	operator<< (std::ostream &strm, const sys::PathWithStatus &aPath)
bool	FiniteOnlyFPMath ()
bool	HonorSignDependentRoundingFPMath ()
ModulePass *	createFunctionProfilerPass ()
ModulePass *	createBlockProfilerPass ()
ModulePass *	createEdgeProfilerPass ()
ModulePass *	createNullProfilerRSPass ()
FunctionPass *	createRSProfilingPass ()
ModulePass *	createStripSymbolsPass (bool OnlyDebugInfo=false)
ModulePass *	createStripNonDebugSymbolsPass ()
ModulePass *	createLowerSetJmpPass ()
ModulePass *	createConstantMergePass ()
ModulePass *	createGlobalOptimizerPass ()
ModulePass *	createRaiseAllocationsPass ()
ModulePass *	createDeadTypeEliminationPass ()
ModulePass *	createGlobalDCEPass ()
ModulePass *	createGVExtractionPass (std::vector< GlobalValue * > &GVs, bool deleteFn=false, bool relinkCallees=false)
Pass *	createFunctionInliningPass ()
Pass *	createFunctionInliningPass (int Threshold)
Pass *	createAlwaysInlinerPass ()
Pass *	createPruneEHPass ()
ModulePass *	createInternalizePass (bool AllButMain)
ModulePass *	createInternalizePass (const std::vector< const char * > &exportList)
ModulePass *	createDeadArgEliminationPass ()
ModulePass *	createDeadArgHackingPass ()
Pass *	createArgumentPromotionPass (unsigned maxElements=3)
Pass *	createStructRetPromotionPass ()
ModulePass *	createIPConstantPropagationPass ()
ModulePass *	createIPSCCPPass ()
FunctionPass *	createLoopExtractorPass ()
FunctionPass *	createSingleLoopExtractorPass ()
ModulePass *	createBlockExtractorPass (const std::vector< BasicBlock * > &BTNE)
ModulePass *	createIndMemRemPass ()
ModulePass *	createStripDeadPrototypesPass ()
ModulePass *	createPartialSpecializationPass ()
Pass *	createFunctionAttrsPass ()
ModulePass *	createMergeFunctionsPass ()
FunctionPass *	createConstantPropagationPass ()
FunctionPass *	createSCCPPass ()
Pass *	createDeadInstEliminationPass ()
FunctionPass *	createDeadCodeEliminationPass ()
FunctionPass *	createDeadStoreEliminationPass ()
FunctionPass *	createAggressiveDCEPass ()
FunctionPass *	createScalarReplAggregatesPass (signed Threshold=-1)
Pass *	createIndVarSimplifyPass ()
FunctionPass *	createInstructionCombiningPass ()
Pass *	createLICMPass ()
Pass *	createLoopStrengthReducePass (const TargetLowering *TLI=0)
Pass *	createLoopUnswitchPass (bool OptimizeForSize=false)
Pass *	createLoopUnrollPass ()
Pass *	createLoopRotatePass ()
Pass *	createLoopIndexSplitPass ()
FunctionPass *	createPromoteMemoryToRegisterPass ()
FunctionPass *	createDemoteRegisterToMemoryPass ()
FunctionPass *	createReassociatePass ()
FunctionPass *	createCondPropagationPass ()
FunctionPass *	createTailDuplicationPass ()
FunctionPass *	createJumpThreadingPass ()
FunctionPass *	createCFGSimplificationPass ()
FunctionPass *	createBreakCriticalEdgesPass ()
FunctionPass *	createLoopSimplifyPass ()
Pass *	createLowerAllocationsPass (bool LowerMallocArgToInteger=false)
FunctionPass *	createTailCallEliminationPass ()
FunctionPass *	createLowerSwitchPass ()
FunctionPass *	createLowerInvokePass (const TargetLowering *TLI=0)
FunctionPass *	createBlockPlacementPass ()
Pass *	createLCSSAPass ()
FunctionPass *	createPredicateSimplifierPass ()
FunctionPass *	createGVNPREPass ()
FunctionPass *	createGVNPass ()
FunctionPass *	createMemCpyOptPass ()
Pass *	createLoopDeletionPass ()
FunctionPass *	createSimplifyLibCallsPass ()
FunctionPass *	createSimplifyHalfPowrLibCallsPass ()
FunctionPass *	createCodeGenPreparePass (const TargetLowering *TLI=0)
FunctionPass *	createInstructionNamerPass ()
void	DeleteDeadBlock (BasicBlock *BB)
void	FoldSingleEntryPHINodes (BasicBlock *BB)
bool	MergeBlockIntoPredecessor (BasicBlock *BB, Pass *P=0)
void	ReplaceInstWithValue (BasicBlock::InstListType &BIL, BasicBlock::iterator &BI, Value *V)
void	ReplaceInstWithInst (BasicBlock::InstListType &BIL, BasicBlock::iterator &BI, Instruction *I)
void	ReplaceInstWithInst (Instruction *From, Instruction *To)
Value *	FindAvailableLoadedValue (Value *Ptr, BasicBlock *ScanBB, BasicBlock::iterator &ScanFrom, unsigned MaxInstsToScan=6, AliasAnalysis *AA=0)
void	RemoveSuccessor (TerminatorInst *TI, unsigned SuccNum)
bool	isCriticalEdge (const TerminatorInst *TI, unsigned SuccNum, bool AllowIdenticalEdges=false)
bool	SplitCriticalEdge (TerminatorInst *TI, unsigned SuccNum, Pass *P=0, bool MergeIdenticalEdges=false)
bool	SplitCriticalEdge (BasicBlock *BB, succ_iterator SI, Pass *P=0)
bool	SplitCriticalEdge (BasicBlock *Succ, pred_iterator PI, Pass *P=0)
bool	SplitCriticalEdge (BasicBlock *Src, BasicBlock *Dst, Pass *P=0, bool MergeIdenticalEdges=false)
BasicBlock *	SplitEdge (BasicBlock *From, BasicBlock *To, Pass *P)
BasicBlock *	SplitBlock (BasicBlock *Old, Instruction *SplitPt, Pass *P)
BasicBlock *	SplitBlockPredecessors (BasicBlock *BB, BasicBlock *const *Preds, unsigned NumPreds, const char *Suffix, Pass *P=0)
Module *	CloneModule (const Module *M)
Module *	CloneModule (const Module *M, DenseMap< const Value *, Value * > &ValueMap)
BasicBlock *	CloneBasicBlock (const BasicBlock *BB, DenseMap< const Value *, Value * > &ValueMap, const char *NameSuffix="", Function *F=0, ClonedCodeInfo *CodeInfo=0)
Loop *	CloneLoop (Loop *L, LPPassManager *LPM, LoopInfo *LI, DenseMap< const Value *, Value * > &ValueMap, Pass *P)
Function *	CloneFunction (const Function *F, DenseMap< const Value *, Value * > &ValueMap, ClonedCodeInfo *CodeInfo=0)
Function *	CloneFunction (const Function *F, ClonedCodeInfo *CodeInfo=0)
void	CloneFunctionInto (Function *NewFunc, const Function *OldFunc, DenseMap< const Value *, Value * > &ValueMap, std::vector< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=0)
void	CloneAndPruneFunctionInto (Function *NewFunc, const Function *OldFunc, DenseMap< const Value *, Value * > &ValueMap, std::vector< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=0, const TargetData *TD=0)
void	CloneTraceInto (Function *NewFunc, Trace &T, DenseMap< const Value *, Value * > &ValueMap, const char *NameSuffix)
std::vector< BasicBlock * >	CloneTrace (const std::vector< BasicBlock * > &origTrace)
bool	InlineFunction (CallInst *C, CallGraph *CG=0, const TargetData *TD=0)
bool	InlineFunction (InvokeInst *II, CallGraph *CG=0, const TargetData *TD=0)
bool	InlineFunction (CallSite CS, CallGraph *CG=0, const TargetData *TD=0)
Function *	ExtractCodeRegion (DominatorTree &DT, const std::vector< BasicBlock * > &code, bool AggregateArgs=false)
Function *	ExtractLoop (DominatorTree &DT, Loop *L, bool AggregateArgs=false)
Function *	ExtractBasicBlock (BasicBlock *BB, bool AggregateArgs=false)
bool	ConstantFoldTerminator (BasicBlock *BB)
bool	isInstructionTriviallyDead (Instruction *I)
void	RecursivelyDeleteTriviallyDeadInstructions (Value *V, SmallVectorImpl< Instruction * > *DeadInst=0)
void	MergeBasicBlockIntoOnlyPred (BasicBlock *BB)
bool	SimplifyCFG (BasicBlock *BB)
AllocaInst *	DemoteRegToStack (Instruction &X, bool VolatileLoads=false, Instruction *AllocaPoint=0)
AllocaInst *	DemotePHIToStack (PHINode *P, Instruction *AllocaPoint=0)
bool	isAllocaPromotable (const AllocaInst *AI)
void	PromoteMemToReg (const std::vector< AllocaInst * > &Allocas, DominatorTree &DT, DominanceFrontier &DF, AliasSetTracker *AST=0)
Pass *	createUnifyFunctionExitNodesPass ()
bool	UnrollLoop (Loop *L, unsigned Count, LoopInfo *LI, LPPassManager *LPM)
Value *	MapValue (const Value *V, ValueMapTy &VM)
void	RemapInstruction (Instruction *I, ValueMapTy &VM)
template<>
bool	isa_impl< PointerType, Type > (const Type &Ty)
std::ostream &	operator<< (std::ostream &OS, const Type &T)
raw_ostream &	operator<< (raw_ostream &OS, const Type &T)
std::ostream &	operator<< (std::ostream &OS, const Value &V)
raw_ostream &	operator<< (raw_ostream &OS, const Value &V)
template<>
bool	isa_impl< Constant, Value > (const Value &Val)
template<>
bool	isa_impl< Argument, Value > (const Value &Val)
template<>
bool	isa_impl< InlineAsm, Value > (const Value &Val)
template<>
bool	isa_impl< Instruction, Value > (const Value &Val)
template<>
bool	isa_impl< BasicBlock, Value > (const Value &Val)
template<>
bool	isa_impl< Function, Value > (const Value &Val)
template<>
bool	isa_impl< GlobalVariable, Value > (const Value &Val)
template<>
bool	isa_impl< GlobalAlias, Value > (const Value &Val)
template<>
bool	isa_impl< GlobalValue, Value > (const Value &Val)
bool	GetBitcodeSymbols (const sys::Path &fName, std::vector< std::string > &symbols, std::string *ErrMsg)
ModuleProvider *	GetBitcodeSymbols (const unsigned char *BufPtr, unsigned Length, const std::string &ModuleID, std::vector< std::string > &symbols, std::string *ErrMsg)
bool	isInf (PBQPNum n)
pbqp *	alloc_pbqp (int num_nodes)
void	free_pbqp (pbqp *this_)
static adjnode *	find_adjnode (pbqp *this_, int u, int v)
static adjnode *	alloc_adjnode (pbqp *this_, int u, PBQPMatrix *costs)
static void	insert_adjnode (pbqp *this_, int u, adjnode *adj_ptr)
static void	remove_adjnode (pbqp *this_, int u, adjnode *adj_ptr)
static int	get_deg (pbqp *this_, int u)
static void	reinsert_node (pbqp *this_, int u)
static void	remove_node (pbqp *this_, int u)
static void	insert_edge (pbqp *this_, int u, int v, PBQPMatrix *costs)
static void	delete_edge (pbqp *this_, int u, int v)
void	add_pbqp_nodecosts (pbqp *this_, int u, PBQPVector *costs)
static PBQPMatrix *	get_costmatrix_ptr (pbqp *this_, int u, int v)
static PBQPMatrix *	pbqp_get_costmatrix (pbqp *this_, int u, int v)
void	add_pbqp_edgecosts (pbqp *this_, int u, int v, PBQPMatrix *costs)
static void	pbqp_remove_bucket (pbqp *this_, bucketnode *bucket)
static int	pop_node (pbqp *this_, int deg)
static void	add_to_bucketlist (pbqp *this_, bucketnode *bucket, int deg)
static void	reorder_node (pbqp *this_, int u)
static void	reorder_adjnodes (pbqp *this_, int u)
static void	create_bucket (pbqp *this_, int u, int deg)
static void	create_bucketlist (pbqp *this_)
static void	disconnect_trivialnode (pbqp *this_, int u)
static void	eliminate_trivial_nodes (pbqp *this_)
static bool	normalize_matrix (PBQPMatrix *m, PBQPVector *u, PBQPVector *v)
static void	simplify_edge (pbqp *this_, int u, int v)
static void	eliminate_independent_edges (pbqp *this_)
static void	apply_RI (pbqp *this_, int x)
static void	apply_RII (pbqp *this_, int x)
static void	apply_RN (pbqp *this_, int x)
static void	compute_tc_info (pbqp *this_, adjnode *p)
static int	is_colorable (pbqp *this_, int x)
int	pop_colorablenode (pbqp *this_)
static void	reduce_pbqp (pbqp *this_)
static void	determine_solution (pbqp *this_, int x)
static void	back_propagate (pbqp *this_)
static void	determine_trivialsolution (pbqp *this_)
static void	check_pbqp (pbqp *this_)
void	solve_pbqp (pbqp *this_)
int	get_pbqp_solution (pbqp *this_, int x)
bool	is_pbqp_optimal (pbqp *this_)
void	AddCatchInfo (CallInst &I, MachineModuleInfo *MMI, MachineBasicBlock *MBB)
llvm::Spiller *	createSpiller ()
std::ostream *	operator<< (std::ostream *OS, const VirtRegMap &VRM)
std::ostream &	operator<< (std::ostream &OS, const VirtRegMap &VRM)
std::ostream *	GetLibSupportInfoOutputFile ()
OStream	cout (std::cout)
OStream	cerr (std::cerr)
IStream	cin (std::cin)
void	FlushStream (std::ostream &S)
	FlushStream - Function called by BaseStream to flush an ostream.
FunctionPass *	createAlphaISelDag (AlphaTargetMachine &TM)
FunctionPass *	createAlphaCodePrinterPass (raw_ostream &OS, TargetMachine &TM)
FunctionPass *	createAlphaPatternInstructionSelector (TargetMachine &TM)
FunctionPass *	createAlphaCodeEmitterPass (AlphaTargetMachine &TM, MachineCodeEmitter &MCE)
FunctionPass *	createAlphaLLRPPass (AlphaTargetMachine &tm)
FunctionPass *	createAlphaBranchSelectionPass ()
static const char *	ARMCondCodeToString (ARMCC::CondCodes CC)
FunctionPass *	createARMISelDag (ARMTargetMachine &TM)
FunctionPass *	createARMCodePrinterPass (raw_ostream &O, ARMTargetMachine &TM)
FunctionPass *	createARMCodeEmitterPass (ARMTargetMachine &TM, MachineCodeEmitter &MCE)
FunctionPass *	createARMLoadStoreOptimizationPass ()
FunctionPass *	createARMConstantIslandPass ()
std::ostream &	operator<< (std::ostream &O, const ARMConstantPoolValue &V)
raw_ostream &	operator<< (raw_ostream &O, const ARMConstantPoolValue &V)
	EXTERN_TEMPLATE_INSTANTIATION (class ARMTargetAsmInfo< TargetAsmInfo >)
FunctionPass *	createSPUAsmPrinterPass (raw_ostream &o, SPUTargetMachine &tm)
FunctionPass *	createSPUISelDag (SPUTargetMachine &TM)
template<typename T>
bool	isS10Constant (T Value)
	Predicate test for a signed 10-bit value.
template<>
bool	isS10Constant< short > (short Value)
template<>
bool	isS10Constant< int > (int Value)
template<>
bool	isS10Constant< uint32_t > (uint32_t Value)
template<>
bool	isS10Constant< int64_t > (int64_t Value)
template<>
bool	isS10Constant< uint64_t > (uint64_t Value)
bool	isU10Constant (short Value)
	Predicate test for an unsigned 10-bit value.
bool	isU10Constant (int Value)
bool	isU10Constant (uint32_t Value)
bool	isU10Constant (int64_t Value)
bool	isU10Constant (uint64_t Value)
const MachineInstrBuilder &	addFrameReference (const MachineInstrBuilder &MIB, int FI, int Offset=0, bool mem=true)
FunctionPass *	createIA64DAGToDAGInstructionSelector (IA64TargetMachine &TM)
FunctionPass *	createIA64BundlingPass (IA64TargetMachine &TM)
FunctionPass *	createIA64CodePrinterPass (raw_ostream &o, IA64TargetMachine &tm)
FunctionPass *	createMipsISelDag (MipsTargetMachine &TM)
FunctionPass *	createMipsDelaySlotFillerPass (MipsTargetMachine &TM)
FunctionPass *	createMipsCodePrinterPass (raw_ostream &OS, MipsTargetMachine &TM)
static const char *	PIC16CondCodeToString (PIC16CC::CondCodes CC)
static bool	isSignedComparison (PIC16CC::CondCodes CC)
FunctionPass *	createPIC16ISelDag (PIC16TargetMachine &TM)
FunctionPass *	createPIC16CodePrinterPass (raw_ostream &OS, PIC16TargetMachine &TM)
FunctionPass *	createPPCAsmPrinterPass (raw_ostream &o, PPCTargetMachine &tm)
FunctionPass *	createPPCBranchSelectionPass ()
FunctionPass *	createPPCISelDag (PPCTargetMachine &TM)
FunctionPass *	createPPCCodeEmitterPass (PPCTargetMachine &TM, MachineCodeEmitter &MCE)
	EXTERN_TEMPLATE_INSTANTIATION (class PPCTargetAsmInfo< TargetAsmInfo >)
FunctionPass *	createSparcCodePrinterPass (raw_ostream &o, TargetMachine &tm)
FunctionPass *	createSparcDelaySlotFillerPass (TargetMachine &tm)
FunctionPass *	createSparcFPMoverPass (TargetMachine &tm)
FunctionPass *	createSparcISelDag (SparcTargetMachine &TM)
static const char *	SPARCCondCodeToString (SPCC::CondCodes CC)
FunctionPass *	createX86CodePrinterPass (raw_ostream &o, X86TargetMachine &tm)
FunctionPass *	createX86ISelDag (X86TargetMachine &TM, bool Fast)
FunctionPass *	createX86FloatingPointStackifierPass ()
FunctionPass *	createX87FPRegKillInserterPass ()
FunctionPass *	createX86CodeEmitterPass (X86TargetMachine &TM, MachineCodeEmitter &MCE)
FunctionPass *	createEmitX86CodeToMemory ()
FunctionPass *	createX86MaxStackAlignmentCalculatorPass ()
const MachineInstrBuilder &	addDirectMem (const MachineInstrBuilder &MIB, unsigned Reg)
const MachineInstrBuilder &	addRegOffset (const MachineInstrBuilder &MIB, unsigned Reg, bool isKill, int Offset)
const MachineInstrBuilder &	addRegReg (const MachineInstrBuilder &MIB, unsigned Reg1, bool isKill1, unsigned Reg2, bool isKill2)
const MachineInstrBuilder &	addFullAddress (const MachineInstrBuilder &MIB, const X86AddressMode &AM)
const MachineInstrBuilder &	addFrameReference (const MachineInstrBuilder &MIB, int FI, int Offset=0)
const MachineInstrBuilder &	addConstantPoolReference (const MachineInstrBuilder &MIB, unsigned CPI, unsigned GlobalBaseReg=0)
static bool	isScale (const MachineOperand &MO)
static bool	isMem (const MachineInstr *MI, unsigned Op)
unsigned	getX86SubSuperRegister (unsigned Reg, MVT VT, bool High)
	EXTERN_TEMPLATE_INSTANTIATION (class X86TargetAsmInfo< TargetAsmInfo >)
FunctionPass *	createXCoreISelDag (XCoreTargetMachine &TM)
FunctionPass *	createXCoreCodePrinterPass (raw_ostream &OS, XCoreTargetMachine &TM)
void	InsertProfilingInitCall (Function *MainFn, const char *FnName, GlobalValue *Array)
void	IncrementCounterInBlock (BasicBlock *BB, unsigned CounterNum, GlobalValue *CounterArray)
FunctionPass *	createScalarReplAggregatesPass (signed int Threshold)
Constant *	ConstantFoldCastInstruction (unsigned opc, const Constant *V, const Type *DestTy)
Constant *	ConstantFoldSelectInstruction (const Constant *Cond, const Constant *V1, const Constant *V2)
Constant *	ConstantFoldExtractElementInstruction (const Constant *Val, const Constant *Idx)
Constant *	ConstantFoldInsertElementInstruction (const Constant *Val, const Constant *Elt, const Constant *Idx)
Constant *	ConstantFoldShuffleVectorInstruction (const Constant *V1, const Constant *V2, const Constant *Mask)
Constant *	ConstantFoldExtractValueInstruction (const Constant *Agg, const unsigned *Idxs, unsigned NumIdx)
Constant *	ConstantFoldInsertValueInstruction (const Constant *Agg, const Constant *Val, const unsigned *Idxs, unsigned NumIdx)
Constant *	ConstantFoldBinaryInstruction (unsigned Opcode, const Constant *C1, const Constant *C2)
Constant *	ConstantFoldCompareInstruction (unsigned short pred, const Constant *C1, const Constant *C2)
Constant *	ConstantFoldGetElementPtr (const Constant *C, Constant *const *Idxs, unsigned NumIdx)
void	CleanupTrueFalse (void *)
static std::ostream &	operator<< (std::ostream &o, const std::set< BasicBlock * > &BBs)
std::ostream &	operator<< (std::ostream &OS, const Type *T)
Variables
const unsigned int	host_char_bit = 8
const unsigned int	integerPartWidth
const PassInfo *const	MachineLoopInfoID = &X
const PassInfo *const	MachineDominatorsID = &E
const PassInfo *const	PHIEliminationID = &X
const PassInfo *const	StrongPHIEliminationID = &X
const PassInfo *const	PreAllocSplittingID = &X
const PassInfo *const	SimpleRegisterCoalescingID = &X
const PassInfo *const	TwoAddressInstructionPassID = &X
const PassInfo *const	UnreachableMachineBlockElimID = &Y
bool	TimePassesIsEnabled = false
	This is the storage for the -time-passes option.
bool	DebugFlag
	LShr
BinaryOperator	Malloc
BinaryOperator MallocInst	Load
BinaryOperator MallocInst LoadInst	ZExt
BinaryOperator MallocInst LoadInst ZExtInst	FPToUI
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst	UIToFP
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst	FPTrunc
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst	PtrToInt
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst	BitCast
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst	FCmp
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst	Call
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst	UserOp1
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction	VAArg
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst	InsertElement
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst	ExtractValue
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst ExtractValueInst	VICmp
BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst ExtractValueInst VICmpInst	RetTy
bool	PrintMachineCode
bool	NoFramePointerElim
bool	NoExcessFPPrecision
bool	UnsafeFPMath
bool	FiniteOnlyFPMathOption
bool	HonorSignDependentRoundingFPMathOption
bool	UseSoftFloat
bool	NoZerosInBSS
bool	ExceptionHandling
bool	UnwindTablesMandatory
bool	PerformTailCallOpt
unsigned	StackAlignment
	StackAlignment - Override default stack alignment for target.
bool	RealignStack
bool	VerboseAsm
bool	DisableJumpTables
bool	EnableFastISel
bool	StrongPHIElim
bool	DisableRedZone
const PassInfo *const	PromoteMemoryToRegisterID = &X
const PassInfo *const	DemoteRegisterToMemoryID = &X
const PassInfo *const	BreakCriticalEdgesID = &X
const PassInfo *const	LoopSimplifyID = &X
const PassInfo *const	LowerAllocationsID = &X
const PassInfo *const	LowerSwitchID = &X
const PassInfo *const	LowerInvokePassID = &X
const PassInfo *const	LCSSAID = &X
const PassInfo *const	InstructionNamerID = &X
const unsigned int	maxExponent = 16383
const unsigned int	maxPrecision = 113
const unsigned int	maxPowerOfFiveExponent = maxExponent + maxPrecision - 1
const unsigned int	maxPowerOfFiveParts
static const bool	pthread_enabled = true
const char *const	arm_asm_table []
Reloc::Model	RelocationModel
CodeModel::Model	CMModel
const char *const	x86_asm_table []
bool	VerifyDomInfo = false
static cl::opt< bool, true >	VerifyDomInfoX ("verify-dom-info", cl::location(VerifyDomInfo), cl::desc("Verify dominator info (time consuming)"))
static cl::opt< enum PassDebugLevel >	PassDebugging ("debug-pass", cl::Hidden, cl::desc("Print PassManager debugging information"), cl::values(clEnumVal(None,"disable debug output"), clEnumVal(Arguments,"print pass arguments to pass to 'opt'"), clEnumVal(Structure,"print pass structure before run()"), clEnumVal(Executions,"print pass name before it is executed"), clEnumVal(Details,"print pass details when it is executed"), clEnumValEnd))

---

Detailed Description

DebugLabelFolding pass - This pass prunes out redundant labels. This allows a info consumer to determine if the range of two labels is empty, by seeing if the labels map to the same reduced label.

---

Typedef Documentation

typedef struct llvm::adjnode llvm::adjnode

typedef const PassInfo* llvm::AnalysisID

Definition at line 49 of file Pass.h.

typedef ARMTargetAsmInfo<TargetAsmInfo> llvm::ARMGenericTargetAsmInfo

Definition at line 50 of file ARMTargetAsmInfo.h.

typedef unsigned llvm::Attributes

Attributes - A bitset of attributes.

Definition at line 23 of file Attributes.h.

typedef struct llvm::bucketnode llvm::bucketnode

typedef bool llvm::CCAssignFn(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)

CCAssignFn - This function assigns a location for Val, updating State to reflect the change.

Definition at line 99 of file CallingConvLower.h.

typedef InstIterator<const iplist<BasicBlock>, Function::const_iterator, BasicBlock::const_iterator, const Instruction> llvm::const_inst_iterator

Definition at line 126 of file InstIterator.h.

typedef DomTreeNodeBase<BasicBlock> llvm::DomTreeNode

Definition at line 185 of file Dominators.h.

typedef signed short llvm::exponent_t

Definition at line 109 of file APFloat.h.

typedef FoldingSetImpl::Node llvm::FoldingSetNode

Definition at line 248 of file FoldingSet.h.

typedef IntervalIterator<BasicBlock, Function> llvm::function_interval_iterator

Definition at line 235 of file IntervalIterator.h.

typedef Registry<GCMetadataPrinter> llvm::GCMetadataPrinterRegistry

GCMetadataPrinterRegistry - The GC assembly printer registry uses all the defaults from Registry.

Definition at line 30 of file GCMetadataPrinter.h.

typedef Registry<GCStrategy> llvm::GCRegistry

The GC strategy registry uses all the defaults from Registry.

Definition at line 45 of file GCStrategy.h.

typedef generic_gep_type_iterator< User::const_op_iterator > llvm::gep_type_iterator

Definition at line 82 of file GetElementPtrTypeIterator.h.

typedef std::pair<unsigned, MachineBasicBlock*> llvm::IdxMBBPair

Definition at line 41 of file LiveIntervalAnalysis.h.

typedef InstIterator<iplist<BasicBlock>, Function::iterator, BasicBlock::iterator, Instruction> llvm::inst_iterator

Definition at line 122 of file InstIterator.h.

typedef uint64_t llvm::integerPart

Definition at line 31 of file APInt.h.

typedef IntervalIterator<Interval, IntervalPartition> llvm::interval_part_interval_iterator

Definition at line 236 of file IntervalIterator.h.

typedef LoadSDNode llvm::LargestSDNode

LargestSDNode - The largest SDNode class.

Definition at line 2529 of file SelectionDAGNodes.h.

typedef LoopBase< BasicBlock > llvm::Loop

Definition at line 58 of file LoopInfo.h.

typedef DomTreeNodeBase<MachineBasicBlock> llvm::MachineDomTreeNode

Definition at line 34 of file MachineDominators.h.

typedef LoopBase<MachineBasicBlock> llvm::MachineLoop

Definition at line 70 of file MachineLoopInfo.h.

typedef void*(* llvm::MachinePassCtor)()

Definition at line 26 of file MachinePassRegistry.h.

typedef ARG_FLAGSSDNode llvm::MostAlignedSDNode

MostAlignedSDNode - The SDNode class with the greatest alignment requirement.

Definition at line 2534 of file SelectionDAGNodes.h.

typedef struct pbqp llvm::pbqp

Definition at line 252 of file PBQP.h.

typedef double llvm::PBQPNum

Floating point type to use in PBQP solver.

Definition at line 30 of file PBQP.h.

typedef void* llvm::PointerTy

Definition at line 23 of file GenericValue.h.

typedef PPCTargetAsmInfo<TargetAsmInfo> llvm::PPCGenericTargetAsmInfo

Definition at line 43 of file PPCTargetAsmInfo.h.

typedef PredIterator<const BasicBlock, Value::use_const_iterator> llvm::pred_const_iterator

Definition at line 70 of file CFG.h.

typedef PredIterator<BasicBlock, Value::use_iterator> llvm::pred_iterator

Definition at line 68 of file CFG.h.

typedef unsigned llvm::SerializedPtrID

Definition at line 21 of file SerializationFwd.h.

typedef SuccIterator<const TerminatorInst*, const BasicBlock> llvm::succ_const_iterator

Definition at line 134 of file CFG.h.

typedef SuccIterator<TerminatorInst*, BasicBlock> llvm::succ_iterator

Definition at line 132 of file CFG.h.

typedef DenseMap<const Value *, Value *> llvm::ValueMapTy

Definition at line 22 of file ValueMapper.h.

typedef StringMapEntry<Value*> llvm::ValueName

Definition at line 36 of file Value.h.

typedef std::vector<GenericValue> llvm::ValuePlaneTy

Definition at line 64 of file lib/ExecutionEngine/Interpreter/Interpreter.h.

typedef X86TargetAsmInfo<TargetAsmInfo> llvm::X86GenericTargetAsmInfo

Definition at line 43 of file X86TargetAsmInfo.h.

---

Enumeration Type Documentation

anonymous enum

Enumerator:

LLVMDebugVersion
LLVMDebugVersion6
LLVMDebugVersion5
LLVMDebugVersion4
LLVMDebugVersionMask

Definition at line 24 of file Dwarf.h.

enum llvm::AlignTypeEnum

Enum used to categorize the alignment types stored by TargetAlignElem.

Enumerator:

INTEGER_ALIGN	Integer type alignment.
VECTOR_ALIGN	Vector type alignment.
FLOAT_ALIGN	Floating point type alignment.
AGGREGATE_ALIGN	Aggregate alignment.
STACK_ALIGN	Stack objects alignment.

Definition at line 37 of file TargetData.h.

enum llvm::CombineLevel

Enumerator:

Unrestricted
NoIllegalTypes
NoIllegalOperations

Definition at line 58 of file SelectionDAG.h.

enum llvm::lostFraction

Enumerator:

lfExactlyZero
lfLessThanHalf
lfExactlyHalf
lfMoreThanHalf

Definition at line 116 of file APFloat.h.

enum llvm::NameDecorationStyle

Enumerator:

None
StdCall
FastCall

Definition at line 21 of file X86MachineFunctionInfo.h.

enum llvm::PassDebuggingString

Enumerator:

EXECUTION_MSG
MODIFICATION_MSG
FREEING_MSG
ON_BASICBLOCK_MSG
ON_FUNCTION_MSG
ON_MODULE_MSG
ON_LOOP_MSG
ON_CG_MSG

Definition at line 101 of file PassManagers.h.

enum llvm::PassDebugLevel

Enumerator:

None
Arguments
Structure
Executions
Details

Definition at line 42 of file PassManager.cpp.

enum llvm::PassManagerType

Different types of internal pass managers. External pass managers (PassManager and FunctionPassManager) are not represented here. Ordering of pass manager types is important here.

Enumerator:

PMT_Unknown
PMT_ModulePassManager
PMT_CallGraphPassManager	MPPassManager.
PMT_FunctionPassManager	CGPassManager.
PMT_LoopPassManager	FPPassManager.
PMT_BasicBlockPassManager	LPPassManager.
PMT_Last	BBPassManager.

Definition at line 57 of file Pass.h.

enum llvm::SCEVTypes

Enumerator:

scConstant
scTruncate
scZeroExtend
scSignExtend
scAddExpr
scMulExpr
scUDivExpr
scAddRecExpr
scUMaxExpr
scSMaxExpr
scUnknown
scCouldNotCompute

Definition at line 24 of file ScalarEvolutionExpressions.h.

enum llvm::Tag

Tag - generic tag type for (at least 32 bit) pointers.

Enumerator:

noTag
tagOne
tagTwo
tagThree

Definition at line 30 of file Use.h.

enum llvm::TopLevelManagerType

FunctionPassManager and PassManager, two top level managers, serve as the public interface of pass manager infrastructure.

Enumerator:

TLM_Function
TLM_Pass

Definition at line 95 of file PassManagers.h.

enum llvm::VerifierFailureAction

An enumeration to specify the action to be taken if errors found.

This enumeration is used in the functions below to indicate what should happen if the verifier finds errors. Each of the functions that uses this enumeration as an argument provides a default value for it. The actions are listed below.

Enumerator:

AbortProcessAction	verifyModule will print to stderr and abort()
PrintMessageAction	verifyModule will print to stderr and return true
ReturnStatusAction	verifyModule will just return true

Definition at line 38 of file Verifier.h.

---

Function Documentation

void llvm::add_pbqp_edgecosts	(	pbqp *	this_,
		int	u,
		int	v,
		PBQPMatrix *	costs
	)

Definition at line 455 of file PBQP.cpp.

References add_pbqp_nodecosts(), llvm::PBQPMatrix::diagonalize(), get_costmatrix_ptr(), insert_edge(), and llvm::PBQPMatrix::transpose().

Referenced by apply_RII().

void llvm::add_pbqp_nodecosts	(	pbqp *	this_,
		int	u,
		PBQPVector *	costs
	)

Definition at line 401 of file PBQP.cpp.

References llvm::pbqp::node_costs.

Referenced by add_pbqp_edgecosts().

static void llvm::add_to_bucketlist	(	pbqp *	this_,
		bucketnode *	bucket,
		int	deg
	)			[static]

Definition at line 541 of file PBQP.cpp.

References llvm::pbqp::bucket_list, llvm::pbqp::node_deg, and llvm::bucketnode::u.

Referenced by create_bucket(), and reorder_node().

void llvm::AddCatchInfo	(	CallInst &	I,
		MachineModuleInfo *	MMI,
		MachineBasicBlock *	MBB
	)

AddCatchInfo - Extract the personality and type infos from an eh.selector call, and add them to the specified machine basic block.

Definition at line 2992 of file SelectionDAGBuild.cpp.

References llvm::MachineModuleInfo::addCatchTypeInfo(), llvm::MachineModuleInfo::addCleanup(), llvm::MachineModuleInfo::addFilterTypeInfo(), llvm::MachineModuleInfo::addPersonality(), BitCast, ExtractTypeInfo(), llvm::User::getNumOperands(), llvm::ConstantExpr::getOpcode(), llvm::Constant::getOperand(), and llvm::User::getOperand().

Referenced by copyCatchInfo().

const MachineInstrBuilder& llvm::addConstantPoolReference	(	const MachineInstrBuilder &	MIB,
		unsigned	CPI,
		unsigned	GlobalBaseReg = 0
	)			[inline]

addConstantPoolReference - This function is used to add a reference to the base of a constant value spilled to the per-function constant pool. The reference uses the abstract ConstantPoolIndex which is retained until either machine code emission or assembly output. In PIC mode on x86-32, the GlobalBaseReg parameter can be used to make this a GlobalBaseReg-relative reference.

Definition at line 140 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addConstantPoolIndex(), llvm::MachineInstrBuilder::addImm(), llvm::MachineInstrBuilder::addReg(), and GlobalBaseReg.

const MachineInstrBuilder& llvm::addDirectMem	(	const MachineInstrBuilder &	MIB,
		unsigned	Reg
	)			[inline]

addDirectMem - This function is used to add a direct memory reference to the current instruction -- that is, a dereference of an address in a register, with no scale, index or displacement. An example is: DWORD PTR [EAX].

Definition at line 62 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addImm(), and llvm::MachineInstrBuilder::addReg().

MachineCodeEmitter * llvm::AddELFWriter	(	PassManagerBase &	PM,
		raw_ostream &	O,
		TargetMachine &	TM
	)

AddELFWriter - Concrete function to add the ELF writer to the function pass manager.

Definition at line 55 of file ELFWriter.cpp.

References llvm::PassManagerBase::add(), and llvm::ELFWriter::getMachineCodeEmitter().

const MachineInstrBuilder& llvm::addFrameReference	(	const MachineInstrBuilder &	MIB,
		int	FI,
		int	Offset = 0
	)			[inline]

addFrameReference - This function is used to add a reference to the base of an abstract object on the stack frame of the current function. This reference has base register as the FrameIndex offset until it is resolved. This allows a constant offset to be specified as well...

Definition at line 113 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addFrameIndex(), llvm::MachineInstrBuilder::addImm(), llvm::MachineInstrBuilder::addMemOperand(), llvm::MachineInstrBuilder::addReg(), llvm::MachineInstr::getDesc(), llvm::PseudoSourceValue::getFixedStack(), llvm::MachineFunction::getFrameInfo(), llvm::MachineFrameInfo::getObjectAlignment(), llvm::MachineFrameInfo::getObjectOffset(), llvm::MachineFrameInfo::getObjectSize(), llvm::MachineBasicBlock::getParent(), llvm::MachineInstr::getParent(), llvm::TargetInstrDesc::mayLoad(), llvm::TargetInstrDesc::mayStore(), MF, MFI, MI, llvm::MachineMemOperand::MOLoad, llvm::MachineMemOperand::MOStore, and Offset.

const MachineInstrBuilder & llvm::addFrameReference	(	const MachineInstrBuilder &	MIB,
		int	FI,
		int	Offset = 0,
		bool	mem = true
	)			[inline]

addFrameReference - This function is used to add a reference to the base of an abstract object on the stack frame of the current function. This reference has base register as the FrameIndex offset until it is resolved. This allows a constant offset to be specified as well...

Definition at line 33 of file SPUInstrBuilder.h.

References llvm::MachineInstrBuilder::addFrameIndex(), llvm::MachineInstrBuilder::addImm(), and Offset.

Referenced by llvm::X86TargetLowering::EmitInstrWithCustomInserter(), llvm::SPUInstrInfo::foldMemoryOperandImpl(), llvm::PPCInstrInfo::foldMemoryOperandImpl(), llvm::X86InstrInfo::loadRegFromStackSlot(), llvm::SPUInstrInfo::loadRegFromStackSlot(), llvm::PPCRegisterInfo::lowerCRSpilling(), llvm::X86InstrInfo::storeRegToStackSlot(), and llvm::SPUInstrInfo::storeRegToStackSlot().

const MachineInstrBuilder& llvm::addFullAddress	(	const MachineInstrBuilder &	MIB,
		const X86AddressMode &	AM
	)			[inline]

Definition at line 90 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addFrameIndex(), llvm::MachineInstrBuilder::addGlobalAddress(), llvm::MachineInstrBuilder::addImm(), llvm::MachineInstrBuilder::addReg(), llvm::X86AddressMode::Base, llvm::X86AddressMode::BaseType, llvm::X86AddressMode::Disp, llvm::X86AddressMode::FrameIndex, llvm::X86AddressMode::FrameIndexBase, llvm::X86AddressMode::GV, llvm::X86AddressMode::IndexReg, llvm::X86AddressMode::Reg, llvm::X86AddressMode::RegBase, and llvm::X86AddressMode::Scale.

Referenced by llvm::X86InstrInfo::convertToThreeAddress(), and llvm::X86TargetLowering::EmitInstrWithCustomInserter().

MachineCodeEmitter * llvm::AddMachOWriter	(	PassManagerBase &	PM,
		raw_ostream &	O,
		TargetMachine &	TM
	)

AddMachOWriter - Concrete function to add the Mach-O writer to the function pass manager.

Definition at line 47 of file MachOWriter.cpp.

References llvm::PassManagerBase::add(), and llvm::MachOWriter::getMachineCodeEmitter().

void llvm::addNodeToInterval	(	Interval *	Int,
		Interval *	I
	)			[inline]

Definition at line 79 of file IntervalIterator.h.

References llvm::Interval::Nodes.

void llvm::addNodeToInterval	(	Interval *	Int,
		BasicBlock *	BB
	)			[inline]

Definition at line 68 of file IntervalIterator.h.

References llvm::Interval::Nodes.

const MachineInstrBuilder& llvm::addRegOffset	(	const MachineInstrBuilder &	MIB,
		unsigned	Reg,
		bool	isKill,
		int	Offset
	)			[inline]

addRegOffset - This function is used to add a memory reference of the form [Reg + Offset], i.e., one with no scale or index, but with a displacement. An example is: DWORD PTR [EAX + 4].

Definition at line 74 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addImm(), and llvm::MachineInstrBuilder::addReg().

Referenced by llvm::X86InstrInfo::convertToThreeAddress(), llvm::X86RegisterInfo::emitEpilogue(), and llvm::X86RegisterInfo::emitPrologue().

const MachineInstrBuilder& llvm::addRegReg	(	const MachineInstrBuilder &	MIB,
		unsigned	Reg1,
		bool	isKill1,
		unsigned	Reg2,
		bool	isKill2
	)			[inline]

addRegReg - This function is used to add a memory reference of the form: [Reg + Reg].

Definition at line 83 of file X86InstrBuilder.h.

References llvm::MachineInstrBuilder::addImm(), and llvm::MachineInstrBuilder::addReg().

Referenced by llvm::X86InstrInfo::convertToThreeAddress().

template<typename T>

static unsigned llvm::alignof

(

)

[inline, static]

alignof - A templated function that returns the mininum alignment of of a type. This provides no extra functionality beyond the AlignOf class besides some cosmetic cleanliness. Example usage: alignof<int>() returns the alignment of an int.

Definition at line 57 of file AlignOf.h.

static adjnode* llvm::alloc_adjnode	(	pbqp *	this_,
		int	u,
		PBQPMatrix *	costs
	)			[static]

Definition at line 212 of file PBQP.cpp.

References llvm::adjnode::adj, llvm::adjnode::costs, llvm::adjnode::tc_impact, llvm::adjnode::tc_safe_regs, and llvm::adjnode::tc_valid.

Referenced by insert_edge(), and reinsert_node().

pbqp * llvm::alloc_pbqp

(

int

num_nodes

)

Definition at line 84 of file PBQP.cpp.

References llvm::pbqp::adj_list, llvm::pbqp::bucket_list, llvm::pbqp::bucket_ptr, llvm::pbqp::changed, llvm::pbqp::max_deg, llvm::pbqp::min, llvm::pbqp::node_costs, llvm::pbqp::node_deg, llvm::pbqp::num_nodes, llvm::pbqp::num_r0, llvm::pbqp::num_ri, llvm::pbqp::num_rii, llvm::pbqp::num_rn, llvm::pbqp::num_rn_special, llvm::pbqp::optimal, llvm::pbqp::solution, llvm::pbqp::solved, llvm::pbqp::stack, and llvm::pbqp::stack_ptr.

static void llvm::apply_RI	(	pbqp *	this_,
		int	x
	)			[static]

Definition at line 832 of file PBQP.cpp.

References c, llvm::pbqp::num_ri, pbqp_get_costmatrix(), remove_node(), reorder_adjnodes(), and llvm::pbqp::stack.

Referenced by reduce_pbqp().

static void llvm::apply_RII	(	pbqp *	this_,
		int	x
	)			[static]

Definition at line 899 of file PBQP.cpp.

References add_pbqp_edgecosts(), c, find_adjnode(), llvm::pbqp::num_rii, pbqp_get_costmatrix(), remove_node(), reorder_adjnodes(), llvm::adjnode::reverse, simplify_edge(), llvm::pbqp::stack, and llvm::adjnode::tc_valid.

Referenced by reduce_pbqp().

static void llvm::apply_RN	(	pbqp *	this_,
		int	x
	)			[static]

Definition at line 984 of file PBQP.cpp.

References llvm::pbqp::num_rn, remove_node(), reorder_adjnodes(), and llvm::pbqp::stack.

Referenced by reduce_pbqp().

static const char* llvm::ARMCondCodeToString

(

ARMCC::CondCodes

CC

)

[inline, static]

Definition at line 70 of file ARM.h.

References llvm::ARMCC::AL, llvm::ARMCC::EQ, llvm::ARMCC::GE, llvm::ARMCC::GT, llvm::ARMCC::HI, llvm::ARMCC::HS, llvm::ARMCC::LE, llvm::ARMCC::LO, llvm::ARMCC::LS, llvm::ARMCC::LT, llvm::ARMCC::MI, llvm::ARMCC::NE, llvm::ARMCC::PL, llvm::ARMCC::VC, and llvm::ARMCC::VS.

template<class T, std::size_t N>

T* llvm::array_endof

(

T(&)

x[N]

)

[inline]

Find where an array ends (for ending iterators) This returns a pointer to the byte immediately after the end of an array.

Definition at line 214 of file STLExtras.h.

Referenced by LowerPartSelect(), LowerPartSet(), and llvm::Mangler::Mangler().

template<class T, std::size_t N>

size_t llvm::array_lengthof

(

T(&)

x[N]

)

[inline]

Find the length of an array.

Definition at line 220 of file STLExtras.h.

Referenced by llvm::TargetLowering::addRegisterClass(), getConcreteOpcode(), llvm::TargetLowering::getCondCodeAction(), llvm::TargetLowering::getConvertAction(), llvm::TargetLowering::getIndexedLoadAction(), llvm::TargetLowering::getIndexedStoreAction(), llvm::TargetLowering::getLoadExtAction(), llvm::XCoreRegisterInfo::getNumArgRegs(), llvm::TargetLowering::getNumRegisters(), llvm::TargetLowering::getOperationAction(), llvm::TargetLowering::getRegClassFor(), llvm::TargetLowering::getRegisterType(), llvm::TargetLowering::getTruncStoreAction(), llvm::TargetLowering::ValueTypeActionImpl::getTypeAction(), llvm::TargetLowering::getTypeToTransformTo(), llvm::TargetLowering::hasTargetDAGCombine(), llvm::TargetLowering::isTypeLegal(), llvm::TargetLowering::setCondCodeAction(), llvm::TargetLowering::setConvertAction(), llvm::TargetLowering::setIndexedLoadAction(), llvm::TargetLowering::setIndexedStoreAction(), llvm::TargetLowering::setLoadExtAction(), llvm::TargetLowering::setOperationAction(), llvm::TargetLowering::setTargetDAGCombine(), llvm::TargetLowering::setTruncStoreAction(), llvm::TargetLowering::ValueTypeActionImpl::setTypeAction(), llvm::TargetLowering::TargetLowering(), and llvm::X86InstrInfo::X86InstrInfo().

template<class IteratorTy>

static void llvm::array_pod_sort	(	IteratorTy	Start,
		IteratorTy	End
	)			[inline, static]

array_pod_sort - This sorts an array with the specified start and end extent. This is just like std::sort, except that it calls qsort instead of using an inlined template. qsort is slightly slower than std::sort, but most sorts are not performance critical in LLVM and std::sort has to be template instantiated for each type, leading to significant measured code bloat. This function should generally be used instead of std::sort where possible.

This function assumes that you have simple POD-like types that can be compared with operator< and can be moved with memcpy. If this isn't true, you should use std::sort.

NOTE: If qsort_r were portable, we could allow a custom comparator and default to std::less.

Definition at line 259 of file STLExtras.h.

References get_array_pad_sort_comparator().

template<typename T>

static int llvm::array_pod_sort_comparator	(	const void *	P1,
		const void *	P2
	)			[inline, static]

array_pod_sort_comparator - This is helper function for array_pod_sort, which just uses operator< on T.

Definition at line 227 of file STLExtras.h.

static void llvm::back_propagate

(

pbqp *

this_

)

[static]

Definition at line 1271 of file PBQP.cpp.

References determine_solution(), llvm::pbqp::num_nodes, reinsert_node(), llvm::pbqp::stack, and llvm::pbqp::stack_ptr.

Referenced by solve_pbqp().

double llvm::BitsToDouble

(

uint64_t

Bits

)

[inline]

BitsToDouble - This function takes a 64-bit integer and returns the bit equivalent double.

Definition at line 343 of file MathExtras.h.

References L, and T.

Referenced by ExpandFCOPYSIGNToBitwiseOps().

float llvm::BitsToFloat

(

uint32_t

Bits

)

[inline]

BitsToFloat - This function takes a 32-bit integer and returns the bit equivalent float.

Definition at line 354 of file MathExtras.h.

References F, and T.

Referenced by ExpandFCOPYSIGNToBitwiseOps().

MachineInstrBuilder llvm::BuildMI	(	MachineBasicBlock *	BB,
		DebugLoc	DL,
		const TargetInstrDesc &	TID,
		unsigned	DestReg
	)			[inline]

Definition at line 197 of file MachineInstrBuilder.h.

References llvm::MachineBasicBlock::end().

Referenced by BuildMI(), and mergeBaseUpdateLoadStore().

MachineInstrBuilder llvm::BuildMI	(	MachineBasicBlock *	BB,
		const TargetInstrDesc &	TID,
		unsigned	DestReg
	)			[inline]

BuildMI - This version of the builder inserts the newly-built instruction at the end of the given MachineBasicBlock, and sets up the first operand as a destination virtual register.

Definition at line 192 of file MachineInstrBuilder.h.

References BuildMI(), and llvm::MachineBasicBlock::end().

MachineInstrBuilder llvm::BuildMI	(	MachineBasicBlock *	BB,
		DebugLoc	DL,
		const TargetInstrDesc &	TID
	)			[inline]

Definition at line 182 of file MachineInstrBuilder.h.

References BuildMI(), and llvm::MachineBasicBlock::end().

MachineInstrBuilder llvm::BuildMI	(	MachineBasicBlock *	BB,
		const TargetInstrDesc &	TID
	)			[inline]

BuildMI - This version of the builder inserts the newly-built instruction at the end of the given MachineBasicBlock, and does NOT take a destination register.

Definition at line 178 of file MachineInstrBuilder.h.

References BuildMI(), and llvm::MachineBasicBlock::end().

MachineInstrBuilder llvm::BuildMI	(	MachineBasicBlock &	BB,
		MachineBasicBlock::iterator	I,
		DebugLoc	DL,
		const TargetInstrDesc &	TID
	)			[inline]

Definition at line 165 of file MachineInstrBuilder.h.

References llvm::MachineFunction::CreateMachineInstr(), llvm::MachineBasicBlock::getParent(), llvm::MachineBasicBlock::insert(), and MI.

MachineInstrBuilder llvm::BuildMI	(	MachineBasicBlock &	BB,
		MachineBasicBlock::iterator	I,
		const TargetInstrDesc &	TID
	)			[inline]

BuildMI - This version of the builder inserts the newly-built instruction before the given position in the given MachineBasicBlock, and does NOT take a destination register.

Definition at line 157 of file MachineInstrBuilder.h.

References llvm::MachineFunction::CreateMachineInstr(), llvm::MachineBasicBlock::getParent(), llvm::MachineBasicBlock::insert(), and MI.

MachineInstrBuilder llvm::BuildMI	(	MachineBasicBlock &	BB,
		MachineBasicBlock::iterator	I,
		DebugLoc	DL,
		const TargetInstrDesc &	TID,
		unsigned	DestReg
	)			[inline]

Definition at line 143 of file MachineInstrBuilder.h.

References llvm::MachineFunction::CreateMachineInstr(), llvm::MachineBasicBlock::getParent(), llvm::MachineBasicBlock::insert(), and MI.

MachineInstrBuilder llvm::BuildMI	(	MachineBasicBlock &	BB,
		MachineBasicBlock::iterator	I,
		const TargetInstrDesc &	TID,
		unsigned	DestReg
	)			[inline]

BuildMI - This version of the builder inserts the newly-built instruction before the given position in the given MachineBasicBlock, and sets up the first operand as a destination virtual register.

Definition at line 134 of file MachineInstrBuilder.h.

References llvm::MachineFunction::CreateMachineInstr(), llvm::MachineBasicBlock::getParent(), llvm::MachineBasicBlock::insert(), and MI.

MachineInstrBuilder llvm::BuildMI	(	MachineFunction &	MF,
		DebugLoc	DL,
		const TargetInstrDesc &	TID,
		unsigned	DestReg
	)			[inline]

Definition at line 122 of file MachineInstrBuilder.h.

References llvm::MachineFunction::CreateMachineInstr().

MachineInstrBuilder llvm::BuildMI	(	MachineFunction &	MF,
		const TargetInstrDesc &	TID,
		unsigned	DestReg
	)			[inline]

BuildMI - This version of the builder sets up the first operand as a destination virtual register.

Definition at line 115 of file MachineInstrBuilder.h.

References llvm::MachineFunction::CreateMachineInstr().

MachineInstrBuilder llvm::BuildMI	(	MachineFunction &	MF,
		DebugLoc	DL,
		const TargetInstrDesc &	TID
	)			[inline]

Definition at line 106 of file MachineInstrBuilder.h.

References llvm::MachineFunction::CreateMachineInstr().

MachineInstrBuilder llvm::BuildMI	(	MachineFunction &	MF,
		const TargetInstrDesc &	TID
	)			[inline]

BuildMI - Builder interface. Specify how to create the initial instruction itself.

Definition at line 101 of file MachineInstrBuilder.h.

References llvm::MachineFunction::CreateMachineInstr().

Referenced by llvm::TargetInstrInfoImpl::commuteInstruction(), llvm::PPCInstrInfo::commuteInstruction(), llvm::X86InstrInfo::convertToThreeAddress(), llvm::ARMInstrInfo::convertToThreeAddress(), llvm::XCoreInstrInfo::copyRegToReg(), llvm::X86InstrInfo::copyRegToReg(), llvm::SPUInstrInfo::copyRegToReg(), llvm::SparcInstrInfo::copyRegToReg(), llvm::PPCInstrInfo::copyRegToReg(), llvm::PIC16InstrInfo::copyRegToReg(), llvm::MipsInstrInfo::copyRegToReg(), llvm::IA64InstrInfo::copyRegToReg(), llvm::ARMInstrInfo::copyRegToReg(), llvm::AlphaInstrInfo::copyRegToReg(), llvm::XCoreRegisterInfo::eliminateCallFramePseudoInstr(), llvm::X86RegisterInfo::eliminateCallFramePseudoInstr(), llvm::SparcRegisterInfo::eliminateCallFramePseudoInstr(), llvm::PPCRegisterInfo::eliminateCallFramePseudoInstr(), llvm::IA64RegisterInfo::eliminateCallFramePseudoInstr(), llvm::AlphaRegisterInfo::eliminateCallFramePseudoInstr(), llvm::XCoreRegisterInfo::eliminateFrameIndex(), llvm::SparcRegisterInfo::eliminateFrameIndex(), llvm::PPCRegisterInfo::eliminateFrameIndex(), llvm::IA64RegisterInfo::eliminateFrameIndex(), llvm::ARMRegisterInfo::eliminateFrameIndex(), llvm::AlphaRegisterInfo::eliminateFrameIndex(), emitARMRegPlusImmediate(), llvm::PPCTargetLowering::EmitAtomicBinary(), llvm::XCoreRegisterInfo::emitEpilogue(), llvm::X86RegisterInfo::emitEpilogue(), llvm::SPURegisterInfo::emitEpilogue(), llvm::SparcRegisterInfo::emitEpilogue(), llvm::PPCRegisterInfo::emitEpilogue(), llvm::MipsRegisterInfo::emitEpilogue(), llvm::IA64RegisterInfo::emitEpilogue(), llvm::ARMRegisterInfo::emitEpilogue(), llvm::AlphaRegisterInfo::emitEpilogue(), llvm::XCoreTargetLowering::EmitInstrWithCustomInserter(), llvm::X86TargetLowering::EmitInstrWithCustomInserter(), llvm::SparcTargetLowering::EmitInstrWithCustomInserter(), llvm::PPCTargetLowering::EmitInstrWithCustomInserter(), llvm::PIC16TargetLowering::EmitInstrWithCustomInserter(), llvm::ARMTargetLowering::EmitInstrWithCustomInserter(), llvm::AlphaTargetLowering::EmitInstrWithCustomInserter(), llvm::ARMRegisterInfo::emitLoadConstPool(), llvm::ScheduleDAGSDNodes::EmitNode(), llvm::PPCTargetLowering::EmitPartwordAtomicBinary(), llvm::XCoreRegisterInfo::emitPrologue(), llvm::X86RegisterInfo::emitPrologue(), llvm::SPURegisterInfo::emitPrologue(), llvm::SparcRegisterInfo::emitPrologue(), llvm::PPCRegisterInfo::emitPrologue(), llvm::MipsRegisterInfo::emitPrologue(), llvm::IA64RegisterInfo::emitPrologue(), llvm::ARMRegisterInfo::emitPrologue(), llvm::AlphaRegisterInfo::emitPrologue(), emitSPUpdate(), emitThumbConstant(), emitThumbRegPlusImmediate(), emitThumbRegPlusImmInReg(), llvm::FastISel::FastEmitInst_(), llvm::FastISel::FastEmitInst_extractsubreg(), llvm::FastISel::FastEmitInst_i(), llvm::FastISel::FastEmitInst_r(), llvm::FastISel::FastEmitInst_rf(), llvm::FastISel::FastEmitInst_ri(), llvm::FastISel::FastEmitInst_rr(), llvm::FastISel::FastEmitInst_rri(), llvm::SPUInstrInfo::foldMemoryOperandImpl(), llvm::SparcInstrInfo::foldMemoryOperandImpl(), llvm::PPCInstrInfo::foldMemoryOperandImpl(), llvm::MipsInstrInfo::foldMemoryOperandImpl(), llvm::ARMInstrInfo::foldMemoryOperandImpl(), llvm::AlphaInstrInfo::foldMemoryOperandImpl(), llvm::X86InstrInfo::getGlobalBaseReg(), llvm::FastISel::getRegForValue(), HandleVRSaveUpdate(), llvm::XCoreInstrInfo::InsertBranch(), llvm::X86InstrInfo::InsertBranch(), llvm::SPUInstrInfo::InsertBranch(), llvm::SparcInstrInfo::InsertBranch(), llvm::PPCInstrInfo::InsertBranch(), llvm::MipsInstrInfo::InsertBranch(), llvm::IA64InstrInfo::InsertBranch(), llvm::ARMInstrInfo::InsertBranch(), llvm::AlphaInstrInfo::InsertBranch(), llvm::PPCInstrInfo::insertNoop(), llvm::MipsInstrInfo::insertNoop(), llvm::AlphaInstrInfo::insertNoop(), llvm::X86InstrInfo::loadRegFromAddr(), llvm::SPUInstrInfo::loadRegFromAddr(), llvm::SparcInstrInfo::loadRegFromAddr(), llvm::PPCInstrInfo::loadRegFromAddr(), llvm::MipsInstrInfo::loadRegFromAddr(), llvm::IA64InstrInfo::loadRegFromAddr(), llvm::ARMInstrInfo::loadRegFromAddr(), llvm::AlphaInstrInfo::loadRegFromAddr(), llvm::XCoreInstrInfo::loadRegFromStackSlot(), llvm::X86InstrInfo::loadRegFromStackSlot(), llvm::SPUInstrInfo::loadRegFromStackSlot(), llvm::SparcInstrInfo::loadRegFromStackSlot(), llvm::PIC16InstrInfo::loadRegFromStackSlot(), llvm::MipsInstrInfo::loadRegFromStackSlot(), llvm::IA64InstrInfo::loadRegFromStackSlot(), llvm::ARMInstrInfo::loadRegFromStackSlot(), llvm::AlphaInstrInfo::loadRegFromStackSlot(), llvm::IA64TargetLowering::LowerArguments(), llvm::PPCRegisterInfo::lowerCRSpilling(), llvm::PPCRegisterInfo::lowerDynamicAlloc(), MakeM0Inst(), mergeOps(), llvm::X86InstrInfo::reMaterialize(), llvm::X86InstrInfo::restoreCalleeSavedRegisters(), llvm::FunctionLoweringInfo::set(), llvm::XCoreInstrInfo::spillCalleeSavedRegisters(), llvm::X86InstrInfo::spillCalleeSavedRegisters(), llvm::ARMInstrInfo::spillCalleeSavedRegisters(), llvm::X86InstrInfo::storeRegToAddr(), llvm::SPUInstrInfo::storeRegToAddr(), llvm::SparcInstrInfo::storeRegToAddr(), llvm::PPCInstrInfo::storeRegToAddr(), llvm::MipsInstrInfo::storeRegToAddr(), llvm::IA64InstrInfo::storeRegToAddr(), llvm::ARMInstrInfo::storeRegToAddr(), llvm::AlphaInstrInfo::storeRegToAddr(), llvm::XCoreInstrInfo::storeRegToStackSlot(), llvm::X86InstrInfo::storeRegToStackSlot(), llvm::SPUInstrInfo::storeRegToStackSlot(), llvm::SparcInstrInfo::storeRegToStackSlot(), llvm::PIC16InstrInfo::storeRegToStackSlot(), llvm::MipsInstrInfo::storeRegToStackSlot(), llvm::IA64InstrInfo::storeRegToStackSlot(), llvm::ARMInstrInfo::storeRegToStackSlot(), and llvm::AlphaInstrInfo::storeRegToStackSlot().

uint16_t llvm::ByteSwap_16

(

uint16_t

Value

)

[inline]

ByteSwap_16 - This function returns a byte-swapped representation of the 16-bit argument, Value.

Definition at line 96 of file MathExtras.h.

References llvm::SPISD::Hi, and llvm::SPISD::Lo.

Referenced by llvm::APInt::byteSwap(), and llvm::MachOWriter::InitMem().

uint32_t llvm::ByteSwap_32

(

uint32_t

Value

)

[inline]

ByteSwap_32 - This function returns a byte-swapped representation of the 32-bit argument, Value.

Definition at line 110 of file MathExtras.h.

Referenced by llvm::APInt::byteSwap(), ByteSwap_64(), and llvm::MachOWriter::InitMem().

uint64_t llvm::ByteSwap_64

(

uint64_t

Value

)

[inline]

ByteSwap_64 - This function returns a byte-swapped representation of the 64-bit argument, Value.

Definition at line 126 of file MathExtras.h.

References ByteSwap_32(), llvm::SPISD::Hi, and llvm::SPISD::Lo.

Referenced by llvm::APInt::byteSwap(), and llvm::MachOWriter::InitMem().

template<class FuncT, class N>

void llvm::Calculate	(	DominatorTreeBase< typename GraphTraits< N >::NodeType > &	DT,
		FuncT &	F
	)			[inline]

DominatorTree - Calculate the immediate dominator tree for a function.

template<class FuncT, class NodeT>

void llvm::Calculate	(	DominatorTreeBase< typename GraphTraits< NodeT >::NodeType > &	DT,
		FuncT &	F
	)			[inline]

Definition at line 231 of file DominatorInternals.h.

References llvm::DomTreeNodeBase< NodeT >::addChild(), llvm::CallingConv::C, DT, E, Root, swap(), U, and V.

template<typename PassName>

Pass* llvm::callDefaultCtor

(

)

[inline]

Definition at line 148 of file PassSupport.h.

bool llvm::canConstantFoldCallTo

(

const Function *

F

)

canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function.

Definition at line 562 of file ConstantFolding.cpp.

References llvm::Intrinsic::bswap, llvm::Intrinsic::ctlz, llvm::Intrinsic::ctpop, llvm::Intrinsic::cttz, llvm::Function::getIntrinsicID(), llvm::StringMapEntry< ValueTy >::getKeyData(), llvm::StringMapEntryBase::getKeyLength(), llvm::Value::getValueName(), llvm::Intrinsic::powi, and llvm::Intrinsic::sqrt.

Referenced by CanConstantFold(), and ConstantFoldInstOperands().

bool llvm::CannotBeNegativeZero	(	const Value *	V,
		unsigned	Depth = 0
	)

CannotBeNegativeZero - Return true if we can prove that the specified FP value is never equal to -0.0.

CannotBeNegativeZero - Return true if we can prove that the specified FP value is never equal to -0.0.

NOTE: this function will need to be revisited when we support non-default rounding modes!

Definition at line 717 of file ValueTracking.cpp.

References Add(), dyn_cast(), F, llvm::Instruction::getOpcode(), llvm::User::getOperand(), II, and llvm::Intrinsic::sqrt.

template<class X, class Y>

cast_retty<X, Y>::ret_type llvm::cast

(

const Y &

Val

)

[inline]

Definition at line 198 of file Casting.h.

References X, and Y.

template<class X, class Y>

cast_retty<X, Y*>::ret_type llvm::cast_or_null

(

Y *

Val

)

[inline]

Definition at line 208 of file Casting.h.

OStream llvm::cerr

(

std::cerr

)

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses(), llvm::PMDataManager::addLowerLevelRequiredPass(), llvm::JIT::addModuleProvider(), llvm::LLVMTargetMachine::addPassesToEmitFile(), llvm::LLVMTargetMachine::addPassesToEmitMachineCode(), AlphaCompilationCallback(), llvm::SPUInstrInfo::AnalyzeBranch(), llvm::CCState::AnalyzeCallOperands(), llvm::CCState::AnalyzeCallResult(), llvm::CCState::AnalyzeFormalArguments(), llvm::CCState::AnalyzeReturn(), ARMCompilationCallbackC(), llvm::Interpreter::callExternalFunction(), CheckBitcodeOutputToConsole(), llvm::SelectionDAG::clearGraphAttrs(), llvm::JIT::createJIT(), DisplayGraph(), llvm::VirtRegMap::dump(), llvm::TypeSymbolTable::dump(), llvm::Trace::dump(), llvm::SubtargetFeatures::dump(), llvm::SUnit::dump(), llvm::SCEV::dump(), llvm::Pass::dump(), llvm::MachineInstr::dump(), llvm::MachineJumpTableInfo::dump(), llvm::MachineFrameInfo::dump(), llvm::MachineFunction::dump(), llvm::MachineBasicBlock::dump(), llvm::LoopBase< BlockT >::dump(), llvm::LiveVariables::VarInfo::dump(), llvm::LiveInterval::dump(), llvm::LiveRange::dump(), llvm::DominatorTreeBase< llvm::MachineBasicBlock >::dump(), llvm::DominanceFrontierBase::dump(), llvm::DIVariable::dump(), llvm::DIGlobalVariable::dump(), llvm::DIGlobal::dump(), llvm::DICompositeType::dump(), llvm::DIDerivedType::dump(), llvm::DIBasicType::dump(), llvm::DIType::dump(), llvm::DICompileUnit::dump(), llvm::CallGraphNode::dump(), llvm::CallGraph::dump(), llvm::AttrListPtr::dump(), llvm::ARMConstantPoolValue::dump(), llvm::AliasSetTracker::dump(), llvm::AliasSet::dump(), llvm::SUnit::dumpAll(), llvm::PMTopLevelManager::dumpArguments(), llvm::PMDataManager::dumpLastUses(), llvm::ScheduleDAGSDNodes::dumpNode(), llvm::PMDataManager::dumpPassArguments(), llvm::PMDataManager::dumpPassInfo(), llvm::FPPassManager::dumpPassStructure(), llvm::MPPassManager::dumpPassStructure(), llvm::Pass::dumpPassStructure(), llvm::LPPassManager::dumpPassStructure(), llvm::ScheduleDAG::dumpSchedule(), DumpTypes(), llvm::XCoreRegisterInfo::eliminateCallFramePseudoInstr(), llvm::XCoreRegisterInfo::eliminateFrameIndex(), llvm::SPURegisterInfo::eliminateFrameIndex(), llvm::XCoreRegisterInfo::emitEpilogue(), llvm::SPURegisterInfo::emitEpilogue(), llvm::AlphaRegisterInfo::emitEpilogue(), llvm::ExecutionEngine::emitGlobals(), llvm::TargetLowering::EmitInstrWithCustomInserter(), llvm::XCoreRegisterInfo::emitPrologue(), llvm::SPURegisterInfo::emitPrologue(), llvm::AlphaRegisterInfo::emitPrologue(), llvm::cl::Option::error(), executeAddInst(), executeCmpInst(), executeFCMP_OEQ(), executeFCMP_OGE(), executeFCMP_OGT(), executeFCMP_OLE(), executeFCMP_OLT(), executeFCMP_ONE(), executeFDivInst(), executeFRemInst(), executeICMP_EQ(), executeICMP_NE(), executeICMP_SGE(), executeICMP_SGT(), executeICMP_SLE(), executeICMP_SLT(), executeICMP_UGE(), executeICMP_UGT(), executeICMP_ULE(), executeICMP_ULT(), executeMulInst(), executeSubInst(), llvm::ProfileInfoLoader::getBBTrace(), llvm::SubtargetFeatures::getBits(), llvm::ProfileInfoLoader::getBlockCounts(), llvm::ExecutionEngine::getConstantValue(), llvm::ProfileInfoLoader::getEdgeCounts(), getErrorOutputStream(), llvm::ProfileInfoLoader::getFunctionCounts(), llvm::SelectionDAG::getGraphAttrs(), llvm::SubtargetFeatures::getInfo(), llvm::ARMTargetAsmInfo< BaseTAI >::getInlineAsmLength(), GetInstSizeWithDesc(), GetLibSupportInfoOutputFile(), GetOptionInfo(), llvm::JIT::getOrEmitGlobalVariable(), llvm::JIT::getPointerToFunction(), llvm::JIT::getPointerToNamedFunction(), llvm::SPURegisterInfo::getRegisterNumbering(), llvm::PPCRegisterInfo::getRegisterNumbering(), getValueTypeMapEntry(), Help(), llvm::ExecutionEngine::InitializeMemory(), llvm::MachOWriter::InitMem(), llvm::TypeSymbolTable::insert(), llvm::SPUInstrInfo::InsertBranch(), KnuthDiv(), llvm::Linker::LinkModules(), lle_X_sprintf(), llvm::SPUInstrInfo::loadRegFromAddr(), llvm::ExecutionEngine::LoadValueFromMemory(), LowerBUILD_VECTOR(), LowerEXTRACT_VECTOR_ELT(), LowerFORMAL_ARGUMENTS(), LowerGlobalAddress(), llvm::IntrinsicLowering::LowerIntrinsicCall(), LowerLOAD(), llvm::SPUTargetLowering::LowerOperation(), LowerSETCC(), LowerSTORE(), llvm::PluginLoader::operator=(), llvm::cl::ParseCommandLineOptions(), llvm::PassNameParser::passRegistered(), llvm::GCStrategy::performCustomLowering(), llvm::SPUTargetLowering::PerformDAGCombine(), llvm::AsmPrinter::printInlineAsm(), PrintMap(), PrintModRefResults(), PrintOps(), PrintPercent(), PrintRecyclerStats(), PrintResults(), llvm::AsmPrinter::PrintSpecial(), llvm::BumpPtrAllocator::PrintStats(), llvm::ProfileInfoLoader::ProfileInfoLoader(), ProvideOption(), ReadProfilingBlock(), llvm::Deserializer::ReadUIntPtr(), llvm::Deserializer::RegisterPtr(), RemapOperand(), llvm::TypeSymbolTable::remove(), llvm::SPUInstrInfo::RemoveBranch(), llvm::PMDataManager::removeDeadPasses(), llvm::PMDataManager::removeNotPreservedAnalysis(), llvm::SPUTargetLowering::ReplaceNodeResults(), llvm::FunctionPassManager::run(), llvm::DAGTypeLegalizer::run(), llvm::ExecutionEngine::runFunctionAsMain(), llvm::SelectionDAGISel::SelectInlineAsmMemoryOperands(), llvm::SelectionDAG::setGraphAttrs(), llvm::SelectionDAG::setGraphColor(), llvm::SelectionDAG::setSubgraphColor(), llvm::LiveIntervals::spillPhysRegAroundRegDefsUses(), llvm::ELFCodeEmitter::startFunction(), llvm::SPUInstrInfo::storeRegToAddr(), llvm::ExecutionEngine::StoreValueToMemory(), llvm::PMDataManager::verifyDomInfo(), llvm::ScheduleDAG::VerifySchedule(), llvm::MachineFunction::viewCFG(), llvm::SelectionDAG::viewGraph(), llvm::ScheduleDAG::viewGraph(), llvm::Interpreter::visitBinaryOperator(), llvm::Interpreter::visitFCmpInst(), llvm::Interpreter::visitICmpInst(), llvm::Interpreter::visitInstruction(), llvm::Interpreter::visitLoadInst(), llvm::Interpreter::visitStoreInst(), llvm::Interpreter::visitUnreachableInst(), llvm::Interpreter::visitVAArgInst(), WriteGraph(), llvm::Value::~Value(), and llvm::ValueSymbolTable::~ValueSymbolTable().

static void llvm::check_pbqp

(

pbqp *

this_

)

[static]

Definition at line 1316 of file PBQP.cpp.

References llvm::PBQPMatrix::getCols(), llvm::PBQPVector::getLength(), llvm::PBQPMatrix::getRows(), llvm::pbqp::node_costs, and llvm::pbqp::num_nodes.

Referenced by solve_pbqp().

bool llvm::CheckBitcodeOutputToConsole	(	std::ostream *	stream_to_check,
		bool	print_warning = true
	)

Check for output written to a console.

Determine if the ostream provided is connected to the std::cout and displayed or not (to a console window). If so, generate a warning message advising against display of bitcode and return true. Otherwise just return false

Parameters:

stream_to_check	The stream to be checked
print_warning	Control whether warnings are printed

Definition at line 22 of file SystemUtils.cpp.

References cerr(), cout(), and llvm::sys::Process::StandardOutIsDisplayed().

static const Type* llvm::checkType

(

const Type *

Ty

)

[inline, static]

Definition at line 375 of file Instructions.h.

IStream llvm::cin

(

std::cin

)

void llvm::CleanupTrueFalse

(

void *

)

Definition at line 201 of file Constants.cpp.

References llvm::ConstantInt::ResetTrueFalse().

void llvm::CloneAndPruneFunctionInto	(	Function *	NewFunc,
		const Function *	OldFunc,
		DenseMap< const Value *, Value * > &	ValueMap,
		std::vector< ReturnInst * > &	Returns,
		const char *	NameSuffix = "",
		ClonedCodeInfo *	CodeInfo = 0,
		const TargetData *	TD = 0
	)

CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto, except that it does some simple constant prop and DCE on the fly. The effect of this is to copy significantly less code in cases where (for example) a function call with constant arguments is inlined, and those constant arguments cause a significant amount of code in the callee to be dead. Since this doesn't produce an exactly copy of the input, it can't be used for things like CloneFunction or CloneModule.

CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto, except that it does some simple constant prop and DCE on the fly. The effect of this is to copy significantly less code in cases where (for example) a function call with constant arguments is inlined, and those constant arguments cause a significant amount of code in the callee to be dead. Since this doesn't produce an exact copy of the input, it can't be used for things like CloneFunction or CloneModule.

Definition at line 342 of file CloneFunction.cpp.

References llvm::Function::arg_begin(), llvm::Function::arg_end(), llvm::BasicBlock::back(), llvm::BasicBlock::begin(), llvm::Function::begin(), llvm::DenseMap< KeyT, ValueT, KeyInfoT, ValueInfoT >::count(), dyn_cast(), E, llvm::BasicBlock::end(), llvm::Function::end(), llvm::BasicBlock::eraseFromParent(), llvm::Instruction::eraseFromParent(), llvm::UndefValue::get(), llvm::Function::getBasicBlockList(), llvm::Function::getEntryBlock(), llvm::PHINode::getIncomingBlock(), llvm::PHINode::getIncomingValue(), llvm::BasicBlock::getInstList(), llvm::PHINode::getNumIncomingValues(), llvm::Instruction::getParent(), llvm::BasicBlock::getSinglePredecessor(), llvm::BranchInst::getSuccessor(), llvm::Value::getType(), II, llvm::BranchInst::isConditional(), MapValue(), PI, Pred, pred, pred_begin(), pred_end(), RemapInstruction(), llvm::PHINode::removeIncomingValue(), llvm::Value::replaceAllUsesWith(), llvm::PHINode::setIncomingBlock(), and llvm::PHINode::setIncomingValue().

Referenced by InlineFunction().

BasicBlock * llvm::CloneBasicBlock	(	const BasicBlock *	BB,
		DenseMap< const Value *, Value * > &	ValueMap,
		const char *	NameSuffix = "",
		Function *	F = 0,
		ClonedCodeInfo *	CodeInfo = 0
	)

CloneBasicBlock - Return a copy of the specified basic block, but without embedding the block into a particular function. The block returned is an exact copy of the specified basic block, without any remapping having been performed. Because of this, this is only suitable for applications where the basic block will be inserted into the same function that it was cloned from (loop unrolling would use this, for example).

Also, note that this function makes a direct copy of the basic block, and can thus produce illegal LLVM code. In particular, it will copy any PHI nodes from the original block, even though there are no predecessors for the newly cloned block (thus, phi nodes will have to be updated). Also, this block will branch to the old successors of the original block: these successors will have to have any PHI nodes updated to account for the new incoming edges.

The correlation between instructions in the source and result basic blocks is recorded in the ValueMap map.

If you have a particular suffix you'd like to use to add to any cloned names, specify it as the optional third parameter.

If you would like the basic block to be auto-inserted into the end of a function, you can specify it as the optional fourth parameter.

If you would like to collect additional information about the cloned function, you can specify a ClonedCodeInfo object with the optional fifth parameter.

Definition at line 31 of file CloneFunction.cpp.

References AI, llvm::BasicBlock::begin(), llvm::ClonedCodeInfo::ContainsCalls, llvm::ClonedCodeInfo::ContainsDynamicAllocas, llvm::ClonedCodeInfo::ContainsUnwinds, llvm::BasicBlock::Create(), llvm::BasicBlock::end(), llvm::AllocationInst::getArraySize(), llvm::Function::getEntryBlock(), llvm::BasicBlock::getInstList(), llvm::Value::getName(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getTerminator(), llvm::Value::hasName(), II, and llvm::Value::setName().

Referenced by CloneFunctionInto(), CloneLoop(), CloneTrace(), CloneTraceInto(), and UnrollLoop().

Function* llvm::CloneFunction	(	const Function *	F,
		ClonedCodeInfo *	CodeInfo = 0
	)			[inline]

CloneFunction - Version of the function that doesn't need the ValueMap.

Definition at line 127 of file Cloning.h.

References CloneFunction(), and CodeInfo.

Referenced by SpecializeFunction().

Function * llvm::CloneFunction	(	const Function *	F,
		DenseMap< const Value *, Value * > &	ValueMap,
		ClonedCodeInfo *	CodeInfo = 0
	)

CloneFunction - Return a copy of the specified function, but without embedding the function into another module. Also, any references specified in the ValueMap are changed to refer to their mapped value instead of the original one. If any of the arguments to the function are in the ValueMap, the arguments are deleted from the resultant function. The ValueMap is updated to include mappings from all of the instructions and basicblocks in the function from their old to new values. The final argument captures information about the cloned code if non-null.

CloneFunction - Return a copy of the specified function, but without embedding the function into another module. Also, any references specified in the ValueMap are changed to refer to their mapped value instead of the original one. If any of the arguments to the function are in the ValueMap, the arguments are deleted from the resultant function. The ValueMap is updated to include mappings from all of the instructions and basicblocks in the function from their old to new values.

Definition at line 137 of file CloneFunction.cpp.

References llvm::Function::arg_begin(), llvm::Function::arg_end(), CloneFunctionInto(), llvm::DenseMap< KeyT, ValueT, KeyInfoT, ValueInfoT >::count(), llvm::Function::Create(), E, llvm::FunctionType::get(), llvm::Function::getFunctionType(), llvm::GlobalValue::getLinkage(), llvm::Value::getName(), llvm::FunctionType::getReturnType(), llvm::FunctionType::isVarArg(), and Returns.

Referenced by CloneFunction().

void llvm::CloneFunctionInto	(	Function *	NewFunc,
		const Function *	OldFunc,
		DenseMap< const Value *, Value * > &	ValueMap,
		std::vector< ReturnInst * > &	Returns,
		const char *	NameSuffix = "",
		ClonedCodeInfo *	CodeInfo = 0
	)

Clone OldFunc into NewFunc, transforming the old arguments into references to ArgMap values. Note that if NewFunc already has basic blocks, the ones cloned into it will be added to the end of the function. This function fills in a list of return instructions, and can optionally append the specified suffix to all values cloned.

Definition at line 71 of file CloneFunction.cpp.

References llvm::AttrListPtr::addAttr(), llvm::Function::arg_begin(), llvm::Function::arg_end(), llvm::Function::arg_size(), BB, llvm::MachineBasicBlock::begin(), llvm::Function::begin(), CloneBasicBlock(), llvm::Function::copyAttributesFrom(), llvm::DenseMap< KeyT, ValueT, KeyInfoT, ValueInfoT >::count(), E, llvm::MachineBasicBlock::end(), llvm::Function::end(), llvm::Function::getAttributes(), llvm::AttrListPtr::getFnAttributes(), llvm::AttrListPtr::getParamAttributes(), llvm::AttrListPtr::getRetAttributes(), llvm::BasicBlock::getTerminator(), II, RemapInstruction(), and llvm::Function::setAttributes().

Referenced by CloneFunction(), and CloneModule().

Loop * llvm::CloneLoop	(	Loop *	OrigL,
		LPPassManager *	LPM,
		LoopInfo *	LI,
		DenseMap< const Value *, Value * > &	ValueMap,
		Pass *	P
	)

CloneLoop - Clone Loop. Clone dominator info for loop insiders. Populate ValueMap using old blocks to new blocks mapping.

CloneLoop - Clone Loop. Clone dominator info. Populate ValueMap using old blocks to new blocks mapping.

Definition at line 76 of file CloneLoop.cpp.

References llvm::LoopBase< BlockT >::addBasicBlockToLoop(), llvm::SmallVectorImpl< T >::back(), BB, llvm::BasicBlock::begin(), llvm::SmallVectorImpl< T >::begin(), llvm::LoopBase< BlockT >::begin(), llvm::LoopBase< BlockT >::block_begin(), llvm::LoopBase< BlockT >::block_end(), CloneBasicBlock(), llvm::LPPassManager::cloneBasicBlockSimpleAnalysis(), CloneDominatorInfo(), DF, DT, E, llvm::SmallVectorImpl< T >::empty(), llvm::DenseMap< KeyT, ValueT, KeyInfoT, ValueInfoT >::end(), llvm::BasicBlock::end(), llvm::SmallVectorImpl< T >::end(), llvm::LoopBase< BlockT >::end(), F, llvm::DenseMap< KeyT, ValueT, KeyInfoT, ValueInfoT >::find(), llvm::Pass::getAnalysisIfAvailable(), llvm::LoopInfo::getBase(), llvm::Function::getBasicBlockList(), llvm::LoopBase< BlockT >::getHeader(), llvm::LoopBase< BlockT >::getLoopLatch(), llvm::User::getNumOperands(), llvm::User::getOperand(), llvm::BasicBlock::getParent(), llvm::LoopBase< BlockT >::getParentLoop(), index, llvm::LPPassManager::insertLoop(), L, NewBlocks, Op, llvm::SmallVectorImpl< T >::pop_back(), llvm::SmallVectorImpl< T >::push_back(), and llvm::User::setOperand().

Module * llvm::CloneModule	(	const Module *	M,
		DenseMap< const Value *, Value * > &	ValueMap
	)

Definition at line 35 of file CloneModule.cpp.

References llvm::Module::addLibrary(), llvm::Module::addTypeName(), llvm::Module::alias_begin(), llvm::Module::alias_end(), llvm::Function::arg_begin(), llvm::Module::begin(), llvm::TypeSymbolTable::begin(), llvm::CallingConv::C, CloneFunctionInto(), llvm::Function::copyAttributesFrom(), llvm::Function::Create(), E, llvm::Module::end(), llvm::TypeSymbolTable::end(), llvm::GlobalValue::ExternalLinkage, F, llvm::Module::getDataLayout(), llvm::Module::getModuleIdentifier(), llvm::Module::getModuleInlineAsm(), llvm::Module::getTargetTriple(), llvm::Module::getTypeSymbolTable(), llvm::Module::global_begin(), llvm::Module::global_end(), GV, llvm::Module::lib_begin(), llvm::Module::lib_end(), MapValue(), Returns, llvm::GlobalAlias::setAliasee(), llvm::GlobalValue::setAlignment(), llvm::GlobalVariable::setConstant(), llvm::Module::setDataLayout(), llvm::GlobalVariable::setInitializer(), llvm::GlobalValue::setLinkage(), llvm::Module::setModuleInlineAsm(), llvm::Module::setTargetTriple(), and llvm::GlobalVariable::setThreadLocal().

Module * llvm::CloneModule

(

const Module *

M

)

CloneModule - Return an exact copy of the specified module

CloneModule - Return an exact copy of the specified module. This is not as easy as it might seem because we have to worry about making copies of global variables and functions, and making their (initializers and references, respectively) refer to the right globals.

Definition at line 28 of file CloneModule.cpp.

std::vector< BasicBlock * > llvm::CloneTrace

(

const std::vector< BasicBlock * > &

origTrace

)

CloneTrace - Returns a copy of the specified trace. It takes a vector of basic blocks clones the basic blocks, removes internal phi nodes, adds it to the same function as the original (although there is no jump to it) and returns the new vector of basic blocks.

Definition at line 27 of file CloneTrace.cpp.

References BB, llvm::MachineBasicBlock::begin(), llvm::BasicBlock::begin(), CloneBasicBlock(), E, End, llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), Op, T, and V.

void llvm::CloneTraceInto	(	Function *	NewFunc,
		Trace &	T,
		DenseMap< const Value *, Value * > &	ValueMap,
		const char *	NameSuffix
	)

CloneTraceInto - Clone T into NewFunc. Original<->clone mapping is saved in ValueMap.

Definition at line 93 of file CloneTrace.cpp.

References BB, llvm::MachineBasicBlock::begin(), llvm::Trace::begin(), CloneBasicBlock(), llvm::MachineBasicBlock::end(), llvm::Function::end(), llvm::Trace::end(), llvm::Trace::getEntryBasicBlock(), II, and RemapInstruction().

template<class GraphT>

void llvm::Compress	(	DominatorTreeBase< typename GraphT::NodeType > &	DT,
		typename GraphT::NodeType *	VIn
	)			[inline]

Definition at line 117 of file DominatorInternals.h.

References llvm::DominatorTreeBase< NodeT >::Info, llvm::SmallPtrSet< PtrType, SmallSize >::insert(), V, llvm::DominatorTreeBase< NodeT >::Vertex, and Visited.

static void llvm::compute_tc_info	(	pbqp *	this_,
		adjnode *	p
	)			[static]

Definition at line 1014 of file PBQP.cpp.

References llvm::adjnode::adj, llvm::PBQPVector::getLength(), isInf(), pbqp_get_costmatrix(), llvm::adjnode::reverse, llvm::adjnode::tc_impact, llvm::adjnode::tc_safe_regs, and llvm::adjnode::tc_valid.

Referenced by is_colorable().

void llvm::ComputeMaskedBits	(	Value *	V,
		const APInt &	Mask,
		APInt &	KnownZero,
		APInt &	KnownOne,
		TargetData *	TD = 0,
		unsigned	Depth = 0
	)

ComputeMaskedBits - Determine which of the bits specified in Mask are known to be either zero or one and return them in the KnownZero/KnownOne bit sets. This code only analyzes bits in Mask, in order to short-circuit processing.

ComputeMaskedBits - Determine which of the bits specified in Mask are known to be either zero or one and return them in the KnownZero/KnownOne bit sets. This code only analyzes bits in Mask, in order to short-circuit processing. NOTE: we cannot consider 'undef' to be "IsZero" here. The problem is that we cannot optimize based on the assumption that it is zero without changing it to be an explicit zero. If we don't change it to zero, other code could optimized based on the contradictory assumption that it is non-zero. Because instcombine aggressively folds operations with undef args anyway, this won't lose us code quality.

Definition at line 48 of file ValueTracking.cpp.

References Add(), AI, Align, And(), BitCast, Call, llvm::APInt::clear(), llvm::APInt::countTrailingOnes(), CountTrailingZeros_32(), CountTrailingZeros_64(), llvm::Intrinsic::ctlz, llvm::Intrinsic::ctpop, llvm::Intrinsic::cttz, llvm::Type::DoubleTy, dyn_cast(), FPToUI, FPTrunc, gep_type_begin(), llvm::AllocationInst::getAlignment(), llvm::GlobalValue::getAlignment(), llvm::APInt::getAllOnesValue(), llvm::IntegerType::getBitWidth(), llvm::APInt::getBitWidth(), llvm::StructLayout::getElementOffset(), llvm::SequentialType::getElementType(), llvm::APInt::getHighBitsSet(), llvm::PHINode::getIncomingValue(), llvm::generic_gep_type_iterator< ItTy >::getIndexedType(), llvm::APInt::getLowBitsSet(), llvm::PHINode::getNumIncomingValues(), llvm::User::getNumOperands(), getOpcode(), llvm::User::getOperand(), llvm::TargetData::getPrefTypeAlignment(), llvm::Type::getPrimitiveSizeInBits(), llvm::APInt::getSignBit(), llvm::AllocationInst::getType(), llvm::GlobalValue::getType(), llvm::Value::getType(), llvm::TargetData::getTypeSizeInBits(), GV, Idx, II, Index, llvm::Type::Int64Ty, llvm::Type::isInteger(), llvm::APInt::isPowerOf2(), llvm::Type::isSized(), llvm::APInt::isStrictlyPositive(), L, Log2_32(), llvm::APIntOps::lshr(), LShr, llvm::APInt::lshr(), Malloc, Offset, llvm::APIntOps::Or(), PHI, PtrToInt, R, llvm::Attribute::SExt, llvm::APInt::shl(), llvm::APInt::trunc(), UIToFP, llvm::APIntOps::Xor(), ZExt, and llvm::APInt::zextOrTrunc().

Referenced by ComputeNumSignBits(), and MaskedValueIsZero().

unsigned llvm::ComputeNumSignBits	(	Value *	V,
		TargetData *	TD = 0,
		unsigned	Depth = 0
	)

ComputeNumSignBits - Return the number of times the sign bit of the register is replicated into the other bits. We know that at least 1 bit is always equal to the sign bit (itself), but other cases can give us information. For example, immediately after an "ashr X, 2", we know that the top 3 bits are all equal to each other, so we return 3.

'Op' must have a scalar integer type.

ComputeNumSignBits - Return the number of times the sign bit of the register is replicated into the other bits. We know that at least 1 bit is always equal to the sign bit (itself), but other cases can give us information. For example, immediately after an "ashr X, 2", we know that the top 3 bits are all equal to each other, so we return 3.

'Op' must have a scalar integer type.

Definition at line 565 of file ValueTracking.cpp.

References Add(), And(), llvm::CallingConv::C, ComputeMaskedBits(), llvm::APInt::countLeadingZeros(), dyn_cast(), llvm::APInt::getAllOnesValue(), llvm::APInt::getBitWidth(), llvm::IntegerType::getBitWidth(), getOpcode(), llvm::User::getOperand(), llvm::Value::getType(), llvm::APInt::isNegative(), llvm::APIntOps::Or(), llvm::Attribute::SExt, Ty, and llvm::APIntOps::Xor().

constant_iterator llvm::constant_begin

(

const Function *

F

)

[inline]

Definition at line 83 of file ConstantsScanner.h.

constant_iterator llvm::constant_end

(

const Function *

F

)

[inline]

Definition at line 87 of file ConstantsScanner.h.

Constant * llvm::ConstantFoldBinaryInstruction	(	unsigned	Opcode,
		const Constant *	C1,
		const Constant *	C2
	)

Definition at line 587 of file ConstantFold.cpp.

References llvm::APFloat::add(), Add(), And(), llvm::APInt::ashr(), llvm::APFloat::divide(), dyn_cast(), EvalVectorOp(), llvm::ConstantFP::get(), llvm::ConstantInt::get(), llvm::UndefValue::get(), llvm::ConstantExpr::getAdd(), llvm::GlobalValue::getAlignment(), llvm::ConstantInt::getAllOnesValue(), llvm::ConstantVector::getAllOnesValue(), llvm::ConstantExpr::getAnd(), llvm::APInt::getBitWidth(), llvm::IntegerType::getBitWidth(), llvm::ConstantExpr::getFDiv(), llvm::ConstantExpr::getFRem(), llvm::APInt::getLowBitsSet(), llvm::ConstantExpr::getLShr(), llvm::ConstantExpr::getMul(), llvm::Constant::getNullValue(), llvm::ConstantExpr::getOr(), llvm::ConstantExpr::getSDiv(), llvm::ConstantExpr::getSRem(), llvm::ConstantExpr::getSub(), llvm::ConstantInt::getType(), llvm::Value::getType(), llvm::ConstantExpr::getUDiv(), llvm::ConstantExpr::getURem(), llvm::ConstantExpr::getXor(), GV, llvm::APInt::isMinSignedValue(), Log2_32(), llvm::APInt::lshr(), LShr, llvm::APFloat::mod(), llvm::APFloat::multiply(), llvm::APIntOps::Or(), llvm::Type::PPC_FP128Ty, PtrToInt, llvm::APFloat::rmNearestTiesToEven, llvm::APInt::sdiv(), llvm::APInt::shl(), llvm::APInt::srem(), llvm::APFloat::subtract(), llvm::APInt::udiv(), llvm::APInt::urem(), llvm::APIntOps::Xor(), and ZExt.

Referenced by llvm::ConstantExpr::getTy().

Constant * llvm::ConstantFoldCall	(	Function *	F,
		Constant *const *	Operands,
		unsigned	NumOperands
	)

ConstantFoldCall - Attempt to constant fold a call to the specified function with the specified arguments, returning null if unsuccessful.

Currently APFloat versions of these functions do not exist, so we use the host native double versions. Float versions are not called directly but for all these it is true (float)(f((double)arg)) == f(arg). Long double not supported yet.

Definition at line 676 of file ConstantFolding.cpp.

References llvm::lltok::APFloat, ConstantFoldBinaryFP(), ConstantFoldFP(), llvm::Intrinsic::cos, llvm::Type::DoubleTy, llvm::Intrinsic::exp, llvm::Type::FloatTy, llvm::ConstantFP::get(), llvm::ConstantInt::get(), llvm::StringMapEntry< ValueTy >::getKeyData(), llvm::StringMapEntryBase::getKeyLength(), llvm::Constant::getNullValue(), llvm::Function::getReturnType(), llvm::Value::getValueName(), llvm::Intrinsic::log, llvm::Intrinsic::log10, Op, llvm::Intrinsic::pow, llvm::Intrinsic::sin, llvm::Intrinsic::sqrt, Ty, and V.

Referenced by ConstantFoldInstOperands(), and EvaluateFunction().

Constant * llvm::ConstantFoldCastInstruction	(	unsigned	opc,
		const Constant *	V,
		const Type *	DestTy
	)

Parameters:

opcode	The opcode of the cast
V	The source constant
DestTy	The destination type

Definition at line 180 of file ConstantFold.cpp.

References llvm::lltok::APFloat, BitCast, llvm::APFloat::Bogus, llvm::APFloat::convert(), llvm::APFloat::convertFromAPInt(), llvm::APFloat::convertToInteger(), llvm::Type::DoubleTy, llvm::Type::FloatTy, FoldBitCast(), foldConstantCastPair(), llvm::Type::FP128Ty, FPToUI, FPTrunc, llvm::ConstantPointerNull::get(), llvm::ConstantVector::get(), llvm::ConstantInt::get(), llvm::ConstantFP::get(), llvm::UndefValue::get(), llvm::ConstantExpr::getCast(), llvm::SequentialType::getElementType(), llvm::Constant::getNullValue(), llvm::ConstantExpr::getPointerCast(), llvm::Type::getPrimitiveSizeInBits(), llvm::Value::getType(), llvm::APFloat::IEEEdouble, llvm::APFloat::IEEEquad, llvm::APFloat::IEEEsingle, llvm::Constant::isNullValue(), llvm::Type::PPC_FP128Ty, PtrToInt, llvm::APFloat::rmNearestTiesToEven, llvm::APFloat::rmTowardZero, llvm::Attribute::SExt, UIToFP, Val, llvm::Type::X86_FP80Ty, llvm::APFloat::x87DoubleExtended, and ZExt.

Referenced by getFoldedCast().

Constant * llvm::ConstantFoldCompareInstOperands	(	unsigned	Predicate,
		Constant *const *	Ops,
		unsigned	NumOps,
		const TargetData *	TD = 0
	)

ConstantFoldCompareInstOperands - Attempt to constant fold a compare instruction (icmp/fcmp) with the specified operands. If it fails, it returns a constant expression of the specified operands.

Definition at line 430 of file ConstantFolding.cpp.

References llvm::CallingConv::C, llvm::ConstantExpr::getCompare(), llvm::ConstantExpr::getIntegerCast(), llvm::TargetData::getIntPtrType(), llvm::Constant::getNullValue(), llvm::Constant::getOperand(), llvm::Value::getType(), and PtrToInt.

Referenced by ConstantFoldConstantExpression(), ConstantFoldInstruction(), and EvaluateExpression().

Constant * llvm::ConstantFoldCompareInstruction	(	unsigned short	pred,
		const Constant *	C1,
		const Constant *	C2
	)

Definition at line 1236 of file ConstantFold.cpp.

References llvm::CmpInst::BAD_FCMP_PREDICATE, llvm::CmpInst::BAD_ICMP_PREDICATE, llvm::CallingConv::C, llvm::APFloat::cmpEqual, llvm::APFloat::cmpGreaterThan, llvm::APFloat::cmpLessThan, llvm::APFloat::cmpUnordered, llvm::APFloat::compare(), evaluateFCmpRelation(), evaluateICmpRelation(), llvm::CmpInst::FCMP_FALSE, llvm::CmpInst::FCMP_OEQ, llvm::CmpInst::FCMP_OGE, llvm::CmpInst::FCMP_OGT, llvm::CmpInst::FCMP_OLE, llvm::CmpInst::FCMP_OLT, llvm::CmpInst::FCMP_ONE, llvm::CmpInst::FCMP_ORD, llvm::CmpInst::FCMP_TRUE, llvm::CmpInst::FCMP_UEQ, llvm::CmpInst::FCMP_UGE, llvm::CmpInst::FCMP_UGT, llvm::CmpInst::FCMP_ULE, llvm::CmpInst::FCMP_ULT, llvm::CmpInst::FCMP_UNE, llvm::CmpInst::FCMP_UNO, llvm::ConstantVector::get(), llvm::IntegerType::get(), llvm::ConstantInt::get(), llvm::UndefValue::get(), llvm::Constant::getAllOnesValue(), llvm::ConstantInt::getFalse(), llvm::ConstantExpr::getFCmp(), llvm::ConstantExpr::getICmp(), llvm::VectorType::getInteger(), llvm::Constant::getNullValue(), llvm::Type::getPrimitiveSizeInBits(), llvm::CmpInst::getSwappedPredicate(), llvm::ConstantInt::getTrue(), llvm::Value::getType(), llvm::Constant::getVectorElements(), GV, llvm::GlobalValue::hasExternalWeakLinkage(), llvm::CmpInst::ICMP_EQ, llvm::CmpInst::ICMP_NE, llvm::CmpInst::ICMP_SGE, llvm::CmpInst::ICMP_SGT, llvm::CmpInst::ICMP_SLE, llvm::CmpInst::ICMP_SLT, llvm::CmpInst::ICMP_UGE, llvm::CmpInst::ICMP_UGT, llvm::CmpInst::ICMP_ULE, llvm::CmpInst::ICMP_ULT, llvm::Type::Int1Ty, llvm::Type::isFloatingPoint(), llvm::Constant::isNullValue(), llvm::CmpInst::isSigned(), llvm::Type::PPC_FP128Ty, llvm::SmallVectorImpl< T >::push_back(), R, llvm::APInt::sge(), llvm::APInt::sgt(), llvm::SmallVectorImpl< T >::size(), llvm::APInt::sle(), llvm::APInt::slt(), llvm::APInt::uge(), llvm::APInt::ugt(), llvm::APInt::ule(), llvm::APInt::ult(), and VT.

Referenced by llvm::ConstantExpr::getFCmp(), llvm::ConstantExpr::getICmp(), llvm::ConstantExpr::getVFCmp(), and llvm::ConstantExpr::getVICmp().

Constant * llvm::ConstantFoldConstantExpression	(	ConstantExpr *	CE,
		const TargetData *	TD
	)

ConstantFoldConstantExpression - Attempt to fold the constant expression using the specified TargetData. If successful, the constant result is result is returned, if not, null is returned.

Definition at line 317 of file ConstantFolding.cpp.

References ConstantFoldCompareInstOperands(), ConstantFoldInstOperands(), llvm::ConstantExpr::getOpcode(), llvm::ConstantExpr::getPredicate(), llvm::Value::getType(), llvm::ConstantExpr::isCompare(), llvm::User::op_begin(), llvm::User::op_end(), llvm::SmallVectorImpl< T >::push_back(), and llvm::SmallVectorImpl< T >::size().

Constant * llvm::ConstantFoldExtractElementInstruction	(	const Constant *	Val,
		const Constant *	Idx
	)

Definition at line 332 of file ConstantFold.cpp.

References llvm::UndefValue::get(), llvm::Constant::getNullValue(), llvm::Constant::getOperand(), llvm::Value::getType(), and llvm::Constant::isNullValue().

Referenced by llvm::ConstantExpr::getExtractElementTy().

Constant * llvm::ConstantFoldExtractValueInstruction	(	const Constant *	Agg,
		const unsigned *	Idxs,
		unsigned	NumIdx
	)

Definition at line 459 of file ConstantFold.cpp.

References llvm::UndefValue::get(), llvm::Constant::getNullValue(), llvm::Constant::getOperand(), and llvm::Value::getType().

Referenced by llvm::ConstantExpr::getExtractValueTy().

Constant * llvm::ConstantFoldGetElementPtr	(	const Constant *	C,
		Constant *const *	Idxs,
		unsigned	NumIdx
	)

Definition at line 1566 of file ConstantFold.cpp.

References Add(), Base, C2, E, llvm::SmallVectorImpl< T >::end(), gep_type_begin(), gep_type_end(), llvm::ConstantExpr::get(), llvm::ConstantPointerNull::get(), llvm::PointerType::get(), llvm::UndefValue::get(), llvm::ConstantExpr::getAdd(), llvm::PointerType::getAddressSpace(), llvm::ConstantExpr::getGetElementPtr(), llvm::ConstantExpr::getIntToPtr(), llvm::Type::getPrimitiveSizeInBits(), llvm::ConstantExpr::getSExt(), llvm::ConstantExpr::getSExtOrBitCast(), llvm::Value::getType(), llvm::ConstantExpr::getZExt(), llvm::SmallVectorImpl< T >::insert(), llvm::Type::Int64Ty, llvm::Type::Int8Ty, llvm::Constant::isNullValue(), Offset, llvm::SmallVectorImpl< T >::push_back(), llvm::SmallVectorImpl< T >::reserve(), llvm::SmallVectorImpl< T >::size(), and Ty.

Referenced by llvm::ConstantExpr::getGetElementPtrTy().

Constant * llvm::ConstantFoldInsertElementInstruction	(	const Constant *	Val,
		const Constant *	Elt,
		const Constant *	Idx
	)

Definition at line 351 of file ConstantFold.cpp.

References dyn_cast(), llvm::ConstantVector::get(), llvm::UndefValue::get(), llvm::Constant::getNullValue(), llvm::Value::getType(), llvm::ConstantInt::getValue(), llvm::Constant::isNullValue(), and Op.

Referenced by llvm::ConstantExpr::getInsertElementTy().

Constant * llvm::ConstantFoldInsertValueInstruction	(	const Constant *	Agg,
		const Constant *	Val,
		const unsigned *	Idxs,
		unsigned	NumIdx
	)

Definition at line 482 of file ConstantFold.cpp.

References llvm::CallingConv::C, llvm::ConstantArray::get(), llvm::ConstantStruct::get(), llvm::UndefValue::get(), llvm::Constant::getNullValue(), llvm::User::getNumOperands(), llvm::Constant::getOperand(), llvm::Value::getType(), llvm::CompositeType::getTypeAtIndex(), llvm::Constant::isNullValue(), and Op.

Referenced by llvm::ConstantExpr::getInsertValueTy().

Constant * llvm::ConstantFoldInstOperands	(	unsigned	Opcode,
		const Type *	DestTy,
		Constant *const *	Ops,
		unsigned	NumOps,
		const TargetData *	TD = 0
	)

ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified operands. If successful, the constant result is returned, if not, null is returned. Note that this function can fail when attempting to fold instructions like loads and stores, which have no constant expression form.

ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified opcode and operands. If successful, the constant result is returned, if not, null is returned. Note that this function can fail when attempting to fold instructions like loads and stores, which have no constant expression form.

Definition at line 339 of file ConstantFolding.cpp.

References BitCast, llvm::CallingConv::C, Call, canConstantFoldCallTo(), ConstantFoldCall(), F, FCmp, FoldBitCast(), FPToUI, FPTrunc, llvm::ConstantInt::get(), llvm::ConstantExpr::get(), llvm::ConstantExpr::getAnd(), llvm::ConstantExpr::getBitCast(), llvm::ConstantExpr::getCast(), llvm::ConstantExpr::getExtractElement(), llvm::ConstantExpr::getGetElementPtr(), llvm::ConstantExpr::getInsertElement(), llvm::ConstantExpr::getIntegerCast(), llvm::APInt::getLowBitsSet(), llvm::User::getOperand(), llvm::TargetData::getPointerSizeInBits(), llvm::Type::getPrimitiveSizeInBits(), llvm::ConstantExpr::getSelect(), llvm::ConstantExpr::getShuffleVector(), llvm::Value::getType(), InsertElement, llvm::Instruction::isBinaryOp(), PtrToInt, llvm::Attribute::SExt, SymbolicallyEvaluateBinop(), SymbolicallyEvaluateGEP(), UIToFP, VICmp, and ZExt.

Referenced by ConstantFoldConstantExpression(), ConstantFoldInstruction(), and EvaluateExpression().

Constant * llvm::ConstantFoldInstruction	(	Instruction *	I,
		const TargetData *	TD = 0
	)

ConstantFoldInstruction - Attempt to constant fold the specified instruction. If successful, the constant result is returned, if not, null is returned. Note that this function can only fail when attempting to fold instructions like loads and stores, which have no constant expression form.

Definition at line 280 of file ConstantFolding.cpp.

References ConstantFoldCompareInstOperands(), ConstantFoldInstOperands(), dyn_cast(), llvm::UndefValue::get(), llvm::Instruction::getOpcode(), llvm::Value::getType(), Op, llvm::User::op_begin(), llvm::User::op_end(), llvm::SmallVectorImpl< T >::push_back(), and llvm::SmallVectorImpl< T >::size().

Referenced by AddReachableCodeToWorklist(), CleanupConstantGlobalUsers(), ConstantPropUsersOf(), FoldCondBranchOnPHI(), and UnrollLoop().

Constant * llvm::ConstantFoldLoadThroughGEPConstantExpr	(	Constant *	C,
		ConstantExpr *	CE
	)

ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a getelementptr constantexpr, return the constant value being addressed by the constant expression, or null if something is funny and we can't decide.

Definition at line 499 of file ConstantFolding.cpp.

References CA, CP, E, gep_type_begin(), gep_type_end(), llvm::UndefValue::get(), llvm::Constant::getNullValue(), llvm::generic_gep_type_iterator< ItTy >::getOperand(), llvm::Constant::getOperand(), llvm::Value::getType(), and llvm::ConstantInt::getZExtValue().

Referenced by CleanupConstantGlobalUsers(), ComputeLoadResult(), and isSimpleEnoughPointerToCommit().

Constant * llvm::ConstantFoldSelectInstruction	(	const Constant *	Cond,
		const Constant *	V1,
		const Constant *	V2
	)

Definition at line 319 of file ConstantFold.cpp.

Referenced by llvm::ConstantExpr::getSelectTy().

Constant * llvm::ConstantFoldShuffleVectorInstruction	(	const Constant *	V1,
		const Constant *	V2,
		const Constant *	Mask
	)

Definition at line 422 of file ConstantFold.cpp.

References llvm::ConstantVector::get(), llvm::UndefValue::get(), llvm::Value::getType(), GetVectorElement(), llvm::SmallVectorImpl< T >::push_back(), and llvm::SmallVectorImpl< T >::size().

Referenced by llvm::ConstantExpr::getShuffleVectorTy().

bool llvm::ConstantFoldTerminator

(

BasicBlock *

BB

)

ConstantFoldTerminator - If a terminator instruction is predicated on a constant value, convert it into an unconditional branch to the constant destination. This is a nontrivial operation because the successors of this basic block must have their PHI nodes updated.

Definition at line 35 of file Local.cpp.

References llvm::BranchInst::Create(), dyn_cast(), llvm::Instruction::eraseFromParent(), llvm::BasicBlock::getInstList(), llvm::BasicBlock::getParent(), llvm::TerminatorInst::getSuccessor(), llvm::BasicBlock::getTerminator(), llvm::CmpInst::ICMP_EQ, llvm::BasicBlock::removePredecessor(), and T.

Referenced by MarkAliveBlocks(), and SimplifyCFG().

unsigned llvm::CountLeadingOnes_32

(

uint32_t

Value

)

[inline]

CountLeadingOnes_32 - this function performs the operation of counting the number of ones from the most significant bit to the first zero bit. Ex. CountLeadingOnes_32(0xFF0FFF00) == 8. Returns 32 if the word is all ones.

Definition at line 170 of file MathExtras.h.

References CountLeadingZeros_32().

unsigned llvm::CountLeadingOnes_64

(

uint64_t

Value

)

[inline]

CountLeadingOnes_64 - This function performs the operation of counting the number of ones from the most significant bit to the first zero bit (64 bit edition.) Returns 64 if the word is all ones.

Definition at line 222 of file MathExtras.h.

References CountLeadingZeros_64().

unsigned llvm::CountLeadingZeros_32

(

uint32_t

Value

)

[inline]

CountLeadingZeros_32 - this function performs the platform optimal form of counting the number of zeros from the most significant bit to the first one bit. Ex. CountLeadingZeros_32(0x00F000FF) == 8. Returns 32 if the word is zero.

Definition at line 142 of file MathExtras.h.

Referenced by CountLeadingOnes_32(), CountLeadingZeros_64(), KnuthDiv(), Log2_32(), and Log2_32_Ceil().

unsigned llvm::CountLeadingZeros_64

(

uint64_t

Value

)

[inline]

CountLeadingZeros_64 - This function performs the platform optimal form of counting the number of zeros from the most significant bit to the first one bit (64 bit edition.) Returns 64 if the word is zero.

Definition at line 178 of file MathExtras.h.

References CountLeadingZeros_32(), llvm::SPISD::Hi, Hi_32(), llvm::SPISD::Lo, and Lo_32().

Referenced by CountLeadingOnes_64(), llvm::APInt::countLeadingZeros(), Log2_64(), and Log2_64_Ceil().

unsigned llvm::CountPopulation_32

(

uint32_t

Value

)

[inline]

CountPopulation_32 - this function counts the number of set bits in a value. Ex. CountPopulation(0xF000F000) = 8 Returns 0 if the word is zero.

Definition at line 281 of file MathExtras.h.

Referenced by llvm::SparseBitVectorElement< ElementSize >::count(), and llvm::BitVector::count().

unsigned llvm::CountPopulation_64

(

uint64_t

Value

)

[inline]

CountPopulation_64 - this function counts the number of set bits in a value, (64 bit edition.)

Definition at line 293 of file MathExtras.h.

Referenced by llvm::SparseBitVectorElement< ElementSize >::count(), llvm::BitVector::count(), and llvm::APInt::countPopulation().

unsigned llvm::CountTrailingOnes_32

(

uint32_t

Value

)

[inline]

CountTrailingOnes_32 - this function performs the operation of counting the number of ones from the least significant bit to the first zero bit. Ex. CountTrailingOnes_32(0x00FF00FF) == 8. Returns 32 if the word is all ones.

Definition at line 247 of file MathExtras.h.

References CountTrailingZeros_32().

unsigned llvm::CountTrailingOnes_64

(

uint64_t

Value

)

[inline]

CountTrailingOnes_64 - This function performs the operation of counting the number of ones from the least significant bit to the first zero bit (64 bit edition.) Returns 64 if the word is all ones.

Definition at line 274 of file MathExtras.h.

References CountTrailingZeros_64().

Referenced by llvm::APInt::countTrailingOnes().

unsigned llvm::CountTrailingZeros_32

(

uint32_t

Value

)

[inline]

CountTrailingZeros_32 - this function performs the platform optimal form of counting the number of zeros from the least significant bit to the first one bit. Ex. CountTrailingZeros_32(0xFF00FF00) == 8. Returns 32 if the word is zero.

Definition at line 230 of file MathExtras.h.

Referenced by CollectBSwapParts(), ComputeMaskedBits(), CountTrailingOnes_32(), llvm::SparseBitVectorElement< ElementSize >::find_first(), llvm::BitVector::find_first(), llvm::SparseBitVectorElement< ElementSize >::find_next(), llvm::BitVector::find_next(), llvm::ARM_AM::getSOImmValRotate(), and llvm::ARM_AM::getThumbImmValShift().

unsigned llvm::CountTrailingZeros_64

(

uint64_t

Value

)

[inline]

CountTrailingZeros_64 - This function performs the platform optimal form of counting the number of zeros from the least significant bit to the first one bit (64 bit edition.) Returns 64 if the word is zero.

Definition at line 255 of file MathExtras.h.

Referenced by ComputeMaskedBits(), CountTrailingOnes_64(), llvm::APInt::countTrailingZeros(), llvm::SparseBitVectorElement< ElementSize >::find_first(), llvm::BitVector::find_first(), llvm::SparseBitVectorElement< ElementSize >::find_next(), and llvm::BitVector::find_next().

OStream llvm::cout

(

std::cout

)

Referenced by CheckBitcodeOutputToConsole(), GetLibSupportInfoOutputFile(), llvm::SourceFunctionInfo::getSourceLocation(), lle_X_printf(), lle_X_putchar(), llvm::cl::generic_parser_base::printOptionInfo(), llvm::cl::basic_parser_impl::printOptionInfo(), llvm::SlowOperationInformer::progress(), WriteBitcodeToFile(), and llvm::SlowOperationInformer::~SlowOperationInformer().

static void llvm::create_bucket	(	pbqp *	this_,
		int	u,
		int	deg
	)			[static]

Definition at line 610 of file PBQP.cpp.

References add_to_bucketlist(), llvm::pbqp::bucket_list, and llvm::pbqp::bucket_ptr.

Referenced by create_bucketlist().

static void llvm::create_bucketlist

(

pbqp *

this_

)

[static]

Definition at line 629 of file PBQP.cpp.

References llvm::pbqp::bucket_list, create_bucket(), get_deg(), llvm::pbqp::max_deg, llvm::Intrinsic::memset, llvm::pbqp::node_deg, and llvm::pbqp::num_nodes.

Referenced by solve_pbqp().

FunctionPass * llvm::createAAEvalPass

(

)

Definition at line 82 of file AliasAnalysisEvaluator.cpp.

FunctionPass * llvm::createAggressiveDCEPass

(

)

Definition at line 94 of file ADCE.cpp.

ModulePass * llvm::createAliasAnalysisCounterPass

(

)

Definition at line 123 of file AliasAnalysisCounter.cpp.

Pass * llvm::createAliasDebugger

(

)

Definition at line 131 of file AliasDebugger.cpp.

FunctionPass * llvm::createAlphaBranchSelectionPass

(

)

createAlphaBranchSelectionPass - returns an instance of the Branch Selection Pass

Definition at line 40 of file AlphaBranchSelector.cpp.

Referenced by llvm::AlphaTargetMachine::addPreEmitPass().

FunctionPass * llvm::createAlphaCodeEmitterPass	(	AlphaTargetMachine &	TM,
		MachineCodeEmitter &	MCE
	)

createAlphaCodeEmitterPass - Return a pass that emits the collected Alpha code to the specified MCE object.

Definition at line 70 of file AlphaCodeEmitter.cpp.

Referenced by llvm::AlphaTargetMachine::addCodeEmitter().

FunctionPass * llvm::createAlphaCodePrinterPass	(	raw_ostream &	o,
		TargetMachine &	tm
	)

createAlphaCodePrinterPass - Returns a pass that prints the Alpha assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 69 of file AlphaAsmPrinter.cpp.

References llvm::TargetMachine::getTargetAsmInfo().

Referenced by llvm::AlphaTargetMachine::addAssemblyEmitter(), and llvm::AlphaTargetMachine::addCodeEmitter().

FunctionPass * llvm::createAlphaISelDag

(

AlphaTargetMachine &

TM

)

createAlphaISelDag - This pass converts a legalized DAG into a Alpha-specific DAG, ready for instruction scheduling.

Definition at line 539 of file AlphaISelDAGToDAG.cpp.

Referenced by llvm::AlphaTargetMachine::addInstSelector().

FunctionPass * llvm::createAlphaLLRPPass

(

AlphaTargetMachine &

tm

)

Definition at line 155 of file AlphaLLRP.cpp.

Referenced by llvm::AlphaTargetMachine::addAssemblyEmitter().

FunctionPass* llvm::createAlphaPatternInstructionSelector

(

TargetMachine &

TM

)

Pass * llvm::createAlwaysInlinerPass

(

)

createAlwaysInlinerPass - Return a new pass object that inlines only functions that are marked as "always_inline".

Definition at line 62 of file InlineAlways.cpp.

ModulePass * llvm::createAndersensPass

(

)

Definition at line 621 of file Andersens.cpp.

Pass * llvm::createArgumentPromotionPass

(

unsigned

maxElements = 3

)

createArgumentPromotionPass - This pass promotes "by reference" arguments to be passed by value if the number of elements passed is smaller or equal to maxElements (maxElements == 0 means always promote).

Definition at line 90 of file ArgumentPromotion.cpp.

FunctionPass * llvm::createARMCodeEmitterPass	(	ARMTargetMachine &	TM,
		MachineCodeEmitter &	MCE
	)

createARMCodeEmitterPass - Return a pass that emits the collected ARM code to the specified MCE object.

Definition at line 169 of file ARMCodeEmitter.cpp.

Referenced by llvm::ARMTargetMachine::addCodeEmitter(), and llvm::ARMTargetMachine::addSimpleCodeEmitter().

FunctionPass * llvm::createARMCodePrinterPass	(	raw_ostream &	o,
		ARMTargetMachine &	tm
	)

createARMCodePrinterPass - Returns a pass that prints the ARM assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 1039 of file ARMAsmPrinter.cpp.

References llvm::TargetMachine::getTargetAsmInfo().

FunctionPass * llvm::createARMConstantIslandPass

(

)

createARMConstantIslandPass - returns an instance of the constpool island pass.

Definition at line 206 of file ARMConstantIslandPass.cpp.

Referenced by llvm::ARMTargetMachine::addPreEmitPass().

FunctionPass * llvm::createARMISelDag

(

ARMTargetMachine &

TM

)

createARMISelDag - This pass converts a legalized DAG into a ARM-specific DAG, ready for instruction scheduling.

Definition at line 871 of file ARMISelDAGToDAG.cpp.

Referenced by llvm::ARMTargetMachine::addInstSelector().

FunctionPass * llvm::createARMLoadStoreOptimizationPass

(

)

createARMLoadStoreOptimizationPass - returns an instance of the load / store optimization pass.

Definition at line 82 of file ARMLoadStoreOptimizer.cpp.

Referenced by llvm::ARMTargetMachine::addPreEmitPass().

ImmutablePass * llvm::createBasicAliasAnalysisPass

(

)

Definition at line 238 of file BasicAliasAnalysis.cpp.

FunctionPass * llvm::createBigBlockRegisterAllocator

(

)

BigBlockRegisterAllocation Pass - The BigBlock register allocator munches single basic blocks at a time, like the local register allocator. While the BigBlock allocator is a little slower, and uses somewhat more memory than the local register allocator, it tends to yield the best allocations (of any of the allocators) for blocks that have hundreds or thousands of instructions in sequence.

Definition at line 889 of file RegAllocBigBlock.cpp.

ModulePass * llvm::createBitcodeWriterPass

(

raw_ostream &

Str

)

createBitcodeWriterPass - Create and return a pass that writes the module to the specified ostream.

createBitcodeWriterPass - Create and return a pass that writes the module to the specified ostream.

Definition at line 54 of file BitcodeWriterPass.cpp.

ModulePass * llvm::CreateBitcodeWriterPass

(

std::ostream &

Str

)

CreateBitcodeWriterPass - Create and return a pass that writes the module to the specified ostream.

CreateBitcodeWriterPass - Create and return a pass that writes the module to the specified ostream.

Definition at line 47 of file BitcodeWriterPass.cpp.

ModulePass * llvm::createBlockExtractorPass

(

const std::vector< BasicBlock * > &

BTNE

)

createBlockExtractorPass - This pass extracts all blocks (except those specified in the argument list) from the functions in the module.

Definition at line 187 of file LoopExtractor.cpp.

FunctionPass * llvm::createBlockPlacementPass

(

)

Definition at line 81 of file BasicBlockPlacement.cpp.

ModulePass * llvm::createBlockProfilerPass

(

)

Definition at line 96 of file BlockProfiling.cpp.

FunctionPass * llvm::createBranchFoldingPass

(

bool

DefaultEnableTailMerge

)

BranchFolding Pass - This pass performs machine code CFG based optimizations to delete branches to branches, eliminate branches to successor blocks (creating fall throughs), and eliminating branches over branches.

Definition at line 103 of file BranchFolding.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createBreakCriticalEdgesPass

(

)

Definition at line 59 of file BreakCriticalEdges.cpp.

llvm::ScheduleDAG * llvm::createBURRListDAGScheduler	(	SelectionDAGISel *	IS,
		bool	Fast
	)

createBURRListDAGScheduler - This creates a bottom up register usage reduction list scheduler.

Definition at line 1341 of file ScheduleDAGRRList.cpp.

References llvm::TargetMachine::getInstrInfo(), llvm::TargetMachine::getRegisterInfo(), llvm::SelectionDAGISel::MF, TII, llvm::SelectionDAGISel::TM, TM, and TRI.

Referenced by createDefaultScheduler().

FunctionPass * llvm::createCFGOnlyPrinterPass

(

)

Definition at line 218 of file CFGPrinter.cpp.

FunctionPass * llvm::createCFGPrinterPass

(

)

Definition at line 214 of file CFGPrinter.cpp.

FunctionPass * llvm::createCFGSimplificationPass

(

)

Definition at line 54 of file SimplifyCFGPass.cpp.

Referenced by llvm::CTargetMachine::addPassesToEmitWholeFile(), and LLVMAddCFGSimplificationPass().

FunctionPass * llvm::createCodeGenPreparePass

(

const TargetLowering *

TLI = 0

)

Definition at line 77 of file CodeGenPrepare.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createCondPropagationPass

(

)

Definition at line 57 of file CondPropagate.cpp.

ModulePass * llvm::createConstantMergePass

(

)

createConstantMergePass - This function returns a new pass that merges duplicate global constants together into a single constant that is shared. This is useful because some passes (ie TraceValues) insert a lot of string constants into the program, regardless of whether or not they duplicate an existing string.

Definition at line 47 of file ConstantMerge.cpp.

FunctionPass * llvm::createConstantPropagationPass

(

)

Definition at line 52 of file ConstantProp.cpp.

Referenced by LLVMAddConstantPropagationPass().

FunctionPass * llvm::createDbgInfoPrinterPass

(

)

Definition at line 56 of file DbgInfoPrinter.cpp.

ModulePass * llvm::createDeadArgEliminationPass

(

)

createDeadArgEliminationPass - This pass removes arguments from functions which are not used by the body of the function.

Definition at line 168 of file DeadArgumentElimination.cpp.

ModulePass * llvm::createDeadArgHackingPass

(

)

DeadArgHacking pass - Same as DAE, but delete arguments of external functions as well. This is definitely not safe, and should only be used by bugpoint.

Definition at line 169 of file DeadArgumentElimination.cpp.

FunctionPass * llvm::createDeadCodeEliminationPass

(

)

Definition at line 130 of file DCE.cpp.

Pass * llvm::createDeadInstEliminationPass

(

)

Definition at line 63 of file DCE.cpp.

FunctionPass * llvm::createDeadMachineInstructionElimPass

(

)

DeadMachineInstructionElim pass - This pass removes dead machine instructions.

Definition at line 48 of file DeadMachineInstructionElim.cpp.

Referenced by llvm::X86TargetMachine::addInstSelector().

FunctionPass * llvm::createDeadStoreEliminationPass

(

)

Definition at line 78 of file DeadStoreElimination.cpp.

ModulePass * llvm::createDeadTypeEliminationPass

(

)

createDeadTypeEliminationPass - Return a new pass that eliminates symbol table entries for types that are never used.

Definition at line 51 of file DeadTypeElimination.cpp.

FunctionPass * llvm::createDebugLabelFoldingPass

(

)

DebugLabelFoldingPass - This pass prunes out redundant debug labels. This allows a debug emitter to determine if the range of two labels is empty, by seeing if the labels map to the same reduced label.

Definition at line 366 of file MachineModuleInfo.cpp.

References llvm::DebugLabelFolder::DebugLabelFolder().

Referenced by llvm::LLVMTargetMachine::addPassesToEmitFile().

ScheduleDAG * llvm::createDefaultScheduler	(	SelectionDAGISel *	IS,
		bool	Fast
	)

createDefaultScheduler - This creates an instruction scheduler appropriate for the target.

createDefaultScheduler - This creates an instruction scheduler appropriate for the target.

Definition at line 140 of file SelectionDAGISel.cpp.

References createBURRListDAGScheduler(), createFastDAGScheduler(), createTDListDAGScheduler(), llvm::TargetLowering::getSchedulingPreference(), llvm::SelectionDAGISel::getTargetLowering(), llvm::TargetLowering::SchedulingForLatency, llvm::TargetLowering::SchedulingForRegPressure, and TLI.

FunctionPass * llvm::createDemoteRegisterToMemoryPass

(

)

Definition at line 123 of file Reg2Mem.cpp.

Referenced by LLVMAddDemoteMemoryToRegisterPass().

ModulePass* llvm::createDSAAPass

(

)

ModulePass* llvm::createDSOptPass

(

)

ModulePass * llvm::createEdgeProfilerPass

(

)

Definition at line 45 of file EdgeProfiling.cpp.

FunctionPass* llvm::createEmitX86CodeToMemory

(

)

createX86EmitCodeToMemory - Returns a pass that converts a register allocated function into raw machine code in a dynamically allocated chunk of memory.

llvm::ScheduleDAG * llvm::createFastDAGScheduler	(	SelectionDAGISel *	IS,
		bool	Fast
	)

createFastDAGScheduler - This creates a "fast" scheduler.

Definition at line 621 of file ScheduleDAGFast.cpp.

References llvm::SelectionDAGISel::MF.

Referenced by createDefaultScheduler().

Pass * llvm::createFunctionAttrsPass

(

)

createFunctionAttrsPass - This pass discovers functions that do not access memory, or only read memory, and gives them the readnone/readonly attribute. It also discovers function arguments that are not captured by the function and marks them with the nocapture attribute.

Definition at line 65 of file FunctionAttrs.cpp.

Pass * llvm::createFunctionInliningPass

(

int

Threshold

)

Definition at line 59 of file InlineSimple.cpp.

Pass * llvm::createFunctionInliningPass

(

)

createFunctionInliningPass - Return a new pass object that uses a heuristic to inline direct function calls to small functions.

Definition at line 57 of file InlineSimple.cpp.

ModulePass * llvm::createFunctionProfilerPass

(

)

Definition at line 48 of file BlockProfiling.cpp.

FunctionPass * llvm::createGCInfoDeleter

(

)

Deleter Pass - Releases GC metadata.

Definition at line 188 of file GCMetadata.cpp.

Referenced by llvm::LLVMTargetMachine::addPassesToEmitFileFinish(), llvm::LLVMTargetMachine::addPassesToEmitMachineCode(), and llvm::CTargetMachine::addPassesToEmitWholeFile().

FunctionPass * llvm::createGCInfoPrinter

(

std::ostream &

OS

)

Creates a pass to print GC metadata.

Definition at line 127 of file GCMetadata.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createGCLoweringPass

(

)

IntrinsicLowering Pass - Performs target-independent LLVM IR transformations for highly portable strategies.

Definition at line 123 of file GCStrategy.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses(), and llvm::CTargetMachine::addPassesToEmitWholeFile().

FunctionPass * llvm::createGCMachineCodeAnalysisPass

(

)

MachineCodeAnalysis Pass - Target-independent pass to mark safe points in machine code. Must be added very late during code generation, just prior to output, and importantly after all CFG transformations (such as branch folding).

Definition at line 309 of file GCStrategy.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

ModulePass * llvm::createGlobalDCEPass

(

)

createGlobalDCEPass - This transform is designed to eliminate unreachable internal globals (functions or global variables)

Definition at line 58 of file GlobalDCE.cpp.

ModulePass * llvm::createGlobalOptimizerPass

(

)

createGlobalOptimizerPass - This function returns a new pass that optimizes non-address taken internal globals.

Definition at line 77 of file GlobalOpt.cpp.

Pass * llvm::createGlobalsModRefPass

(

)

Definition at line 158 of file GlobalsModRef.cpp.

ModulePass * llvm::createGVExtractionPass	(	std::vector< GlobalValue * > &	GVs,
		bool	deleteFn = false,
		bool	relinkCallees = false
	)

createGVExtractionPass - If deleteFn is true, this pass deletes as the specified global values. Otherwise, it deletes as much of the module as possible, except for the global values specified.

Definition at line 170 of file ExtractGV.cpp.

FunctionPass * llvm::createGVNPass

(

)

Definition at line 738 of file GVN.cpp.

Referenced by LLVMAddGVNPass().

FunctionPass * llvm::createGVNPREPass

(

)

Definition at line 741 of file GVNPRE.cpp.

FunctionPass * llvm::createIA64BundlingPass

(

IA64TargetMachine &

tm

)

createIA64BundlingPass - This pass adds stop bits and bundles instructions.

createIA64BundlingPass - Returns a pass that adds STOP (;;) instructions and arranges the result into bundles.

Definition at line 72 of file IA64Bundling.cpp.

Referenced by llvm::IA64TargetMachine::addPreEmitPass().

FunctionPass * llvm::createIA64CodePrinterPass	(	raw_ostream &	o,
		IA64TargetMachine &	tm
	)

createIA64CodePrinterPass - Returns a pass that prints the IA64 assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

createIA64CodePrinterPass - Returns a pass that prints the IA64 assembly code for a MachineFunction to the given output stream, using the given target machine description.

Definition at line 366 of file IA64AsmPrinter.cpp.

References llvm::TargetMachine::getTargetAsmInfo().

Referenced by llvm::IA64TargetMachine::addAssemblyEmitter().

FunctionPass * llvm::createIA64DAGToDAGInstructionSelector

(

IA64TargetMachine &

TM

)

createIA64DAGToDAGInstructionSelector - This pass converts an LLVM function into IA64 machine code in a sane, DAG->DAG transform.

createIA64DAGToDAGInstructionSelector - This pass converts a legalized DAG into an IA64-specific DAG, ready for instruction scheduling.

Definition at line 565 of file IA64ISelDAGToDAG.cpp.

Referenced by llvm::IA64TargetMachine::addInstSelector().

FunctionPass * llvm::createIfConverterPass

(

)

IfConverter Pass - This pass performs machine code if conversion.

Definition at line 221 of file IfConversion.cpp.

Referenced by llvm::ARMTargetMachine::addPreEmitPass().

ModulePass * llvm::createIndMemRemPass

(

)

createIndMemRemPass - This pass removes potential indirect calls of malloc and free

Definition at line 87 of file IndMemRemoval.cpp.

Pass * llvm::createIndVarSimplifyPass

(

)

Definition at line 108 of file IndVarSimplify.cpp.

FunctionPass * llvm::createInstCountPass

(

)

Definition at line 71 of file InstCount.cpp.

FunctionPass * llvm::createInstructionCombiningPass

(

)

Definition at line 12596 of file InstructionCombining.cpp.

Referenced by LLVMAddInstructionCombiningPass().

FunctionPass * llvm::createInstructionNamerPass

(

)

Definition at line 61 of file InstructionNamer.cpp.

ModulePass * llvm::createInternalizePass

(

const std::vector< const char * > &

exportList

)

createInternalizePass - This pass loops over all of the functions in the input module, internalizing all globals (functions and variables) not in the given exportList.

Note that commandline options that are used with the above function are not used now! Also, when exportList is empty, nothing is internalized.

Definition at line 182 of file Internalize.cpp.

ModulePass * llvm::createInternalizePass

(

bool

AllButMain

)

createInternalizePass - This pass loops over all of the functions in the input module, internalizing all globals (functions and variables) not part of the api. If a list of symbols is specified with the -internalize-public-api-* command line options, those symbols are not internalized and all others are. Otherwise if AllButMain is set and the main function is found, all other globals are marked as internal. If no api is supplied and AllButMain is not set, or no main function is found, nothing is internalized.

Definition at line 178 of file Internalize.cpp.

ModulePass * llvm::createIPConstantPropagationPass

(

)

createIPConstantPropagationPass - This pass propagates constants from call sites into the bodies of functions.

Definition at line 52 of file IPConstantPropagation.cpp.

ModulePass * llvm::createIPSCCPPass

(

)

createIPSCCPPass - This pass propagates constants from call sites into the bodies of functions, and keeps track of whether basic blocks are executable in the process.

Definition at line 1624 of file SCCP.cpp.

FunctionPass * llvm::createJumpThreadingPass

(

)

Definition at line 86 of file JumpThreading.cpp.

Pass * llvm::createLCSSAPass

(

)

Definition at line 102 of file LCSSA.cpp.

FunctionPass * llvm::createLibCallAliasAnalysisPass

(

LibCallInfo *

LCI

)

createLibCallAliasAnalysisPass - Create an alias analysis pass that knows about the semantics of a set of libcalls specified by LCI. The newly constructed pass takes ownership of the pointer that is provided.

Definition at line 30 of file LibCallAliasAnalysis.cpp.

Pass * llvm::createLICMPass

(

)

Definition at line 233 of file LICM.cpp.

FunctionPass * llvm::createLinearScanRegisterAllocator

(

)

LinearScanRegisterAllocation Pass - This pass implements the linear scan register allocation algorithm, a global register allocator.

Definition at line 1100 of file RegAllocLinearScan.cpp.

FunctionPass * llvm::createLocalRegisterAllocator

(

)

LocalRegisterAllocation Pass - This pass register allocates the input code a basic block at a time, yielding code better than the simple register allocator, but not as good as a global allocator.

Definition at line 1064 of file RegAllocLocal.cpp.

FunctionPass * llvm::createLoopAlignerPass

(

)

LoopAligner Pass - This pass aligns loop headers to target specific alignment boundary.

Definition at line 45 of file LoopAligner.cpp.

Referenced by llvm::LLVMTargetMachine::addPassesToEmitFile().

Pass * llvm::createLoopDeletionPass

(

)

Definition at line 63 of file LoopDeletion.cpp.

FunctionPass * llvm::createLoopExtractorPass

(

)

createLoopExtractorPass - This pass extracts all natural loops from the program into a function if it can.

Definition at line 76 of file LoopExtractor.cpp.

Pass * llvm::createLoopIndexSplitPass

(

)

Definition at line 194 of file LoopIndexSplit.cpp.

Pass * llvm::createLoopRotatePass

(

)

Definition at line 108 of file LoopRotation.cpp.

FunctionPass * llvm::createLoopSimplifyPass

(

)

Definition at line 107 of file LoopSimplify.cpp.

Pass * llvm::createLoopStrengthReducePass

(

const TargetLowering *

TLI = 0

)

Definition at line 222 of file LoopStrengthReduce.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

Pass * llvm::createLoopUnrollPass

(

)

Definition at line 76 of file LoopUnroll.cpp.

Pass * llvm::createLoopUnswitchPass

(

bool

OptimizeForSize = false

)

Definition at line 158 of file LoopUnswitch.cpp.

Pass * llvm::createLowerAllocationsPass

(

bool

LowerMallocArgToInteger = false

)

Definition at line 78 of file LowerAllocations.cpp.

Referenced by llvm::CTargetMachine::addPassesToEmitWholeFile().

FunctionPass * llvm::createLowerInvokePass

(

const TargetLowering *

TLI = 0

)

Definition at line 110 of file LowerInvoke.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses(), and llvm::CTargetMachine::addPassesToEmitWholeFile().

ModulePass * llvm::createLowerSetJmpPass

(

)

createLowerSetJmpPass - This function lowers the setjmp/longjmp intrinsics to invoke/unwind instructions. This should really be part of the C/C++ front-end, but it's so much easier to write transformations in LLVM proper.

Definition at line 533 of file LowerSetJmp.cpp.

FunctionPass * llvm::createLowerSubregsPass

(

)

LowerSubregs Pass - This pass lowers subregs to register-register copies which yields suboptimal, but correct code if the register allocator cannot coalesce all subreg operations during allocation.

Definition at line 62 of file LowerSubregs.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createLowerSwitchPass

(

)

Definition at line 90 of file LowerSwitch.cpp.

FunctionPass * llvm::createMachineCodeDeleter

(

)

MachineCodeDeletion Pass - This pass deletes all of the machine code for the current function, which should happen after the function has been emitted to a .s file or to memory.

MachineCodeDeletion Pass - This pass deletes all of the machine code for the current function, which should happen after the function has been emitted to a .s file or to memory.

Definition at line 96 of file MachineFunction.cpp.

Referenced by llvm::LLVMTargetMachine::addPassesToEmitFileFinish(), and llvm::LLVMTargetMachine::addPassesToEmitMachineCode().

FunctionPass * llvm::createMachineFunctionPrinterPass	(	std::ostream *	OS,
		const std::string &	Banner = ""
	)

MachineFunctionPrinter pass - This pass prints out the machine function to standard error, as a debugging tool.

Returns a newly-created MachineFunction Printer pass. The default output stream is std::cerr; the default banner is empty.

Definition at line 72 of file MachineFunction.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses(), llvm::LLVMTargetMachine::addPassesToEmitFile(), and llvm::LLVMTargetMachine::addPassesToEmitMachineCode().

FunctionPass * llvm::createMachineLICMPass

(

)

createMachineLICMPass - This pass performs LICM on machine instructions.

Definition at line 98 of file MachineLICM.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createMachineSinkingPass

(

)

createMachineSinkingPass - This pass performs sinking on machine instructions.

Definition at line 58 of file MachineSink.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createMemCpyOptPass

(

)

Definition at line 328 of file MemCpyOptimizer.cpp.

ModulePass * llvm::createMergeFunctionsPass

(

)

createMergeFunctionsPass - This pass discovers identical functions and collapses them.

Definition at line 80 of file MergeFunctions.cpp.

FunctionPass * llvm::createMipsCodePrinterPass	(	raw_ostream &	o,
		MipsTargetMachine &	tm
	)

createMipsCodePrinterPass - Returns a pass that prints the MIPS assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 92 of file MipsAsmPrinter.cpp.

References llvm::TargetMachine::getTargetAsmInfo().

Referenced by llvm::MipsTargetMachine::addAssemblyEmitter().

FunctionPass * llvm::createMipsDelaySlotFillerPass

(

MipsTargetMachine &

tm

)

createMipsDelaySlotFillerPass - Returns a pass that fills in delay slots in Mips MachineFunctions

Definition at line 74 of file MipsDelaySlotFiller.cpp.

Referenced by llvm::MipsTargetMachine::addPreEmitPass().

FunctionPass * llvm::createMipsISelDag

(

MipsTargetMachine &

TM

)

createMipsISelDag - This pass converts a legalized DAG into a MIPS-specific DAG, ready for instruction scheduling.

Definition at line 387 of file MipsISelDAGToDAG.cpp.

Referenced by llvm::MipsTargetMachine::addInstSelector().

ImmutablePass * llvm::createNoAAPass

(

)

Definition at line 191 of file BasicAliasAnalysis.cpp.

ImmutablePass * llvm::createNoProfileInfoPass

(

)

Definition at line 100 of file ProfileInfo.cpp.

ModulePass * llvm::createNullProfilerRSPass

(

)

Definition at line 647 of file RSProfiling.cpp.

ModulePass * llvm::createPartialSpecializationPass

(

)

createPartialSpecializationPass - This pass specializes functions for constant arguments.

Definition at line 188 of file PartialSpecialization.cpp.

FunctionPass * llvm::createPBQPRegisterAllocator

(

)

PBQPRegisterAllocation Pass - This pass implements the Partitioned Boolean Quadratic Prograaming (PBQP) based register allocator.

Definition at line 861 of file RegAllocPBQP.cpp.

FunctionPass * llvm::createPIC16CodePrinterPass	(	raw_ostream &	o,
		PIC16TargetMachine &	tm
	)

createPIC16CodePrinterPass - Returns a pass that prints the PIC16 assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 134 of file PIC16AsmPrinter.cpp.

References llvm::TargetMachine::getTargetAsmInfo().

Referenced by llvm::PIC16TargetMachine::addAssemblyEmitter().

FunctionPass * llvm::createPIC16ISelDag

(

PIC16TargetMachine &

TM

)

createPIC16ISelDag - This pass converts a legalized DAG into a PIC16-specific DAG, ready for instruction scheduling.

Definition at line 23 of file PIC16ISelDAGToDAG.cpp.

Referenced by llvm::PIC16TargetMachine::addInstSelector().

FunctionPass * llvm::createPostDomFrontier

(

)

Definition at line 92 of file PostDominators.cpp.

FunctionPass * llvm::createPostDomTree

(

)

Definition at line 45 of file PostDominators.cpp.

FunctionPass * llvm::createPostRAScheduler

(

)

createPostRAScheduler - under development.

Definition at line 808 of file PostRASchedulerList.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createPPCAsmPrinterPass	(	raw_ostream &	o,
		PPCTargetMachine &	tm
	)

createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code for a MachineFunction to the given output stream, in a format that the Darwin assembler can deal with.

Definition at line 1147 of file PPCAsmPrinter.cpp.

References llvm::TargetMachine::getSubtarget(), llvm::TargetMachine::getTargetAsmInfo(), llvm::PPCSubtarget::isDarwin(), and Subtarget.

FunctionPass * llvm::createPPCBranchSelectionPass

(

)

createPPCBranchSelectionPass - returns an instance of the Branch Selection Pass

Definition at line 52 of file PPCBranchSelector.cpp.

Referenced by llvm::PPCTargetMachine::addPreEmitPass().

FunctionPass * llvm::createPPCCodeEmitterPass	(	PPCTargetMachine &	TM,
		MachineCodeEmitter &	MCE
	)

createPPCCodeEmitterPass - Return a pass that emits the collected PPC code to the specified MCE object.

Definition at line 78 of file PPCCodeEmitter.cpp.

Referenced by llvm::PPCTargetMachine::addCodeEmitter(), and llvm::PPCTargetMachine::addSimpleCodeEmitter().

FunctionPass * llvm::createPPCISelDag

(

PPCTargetMachine &

TM

)

createPPCISelDag - This pass converts a legalized DAG into a PowerPC-specific DAG, ready for instruction scheduling.

Definition at line 1144 of file PPCISelDAGToDAG.cpp.

Referenced by llvm::PPCTargetMachine::addInstSelector().

FunctionPass * llvm::createPredicateSimplifierPass

(

)

Definition at line 2723 of file PredicateSimplifier.cpp.

FunctionPass * llvm::createPrintFunctionPass	(	const std::string &	Banner,
		llvm::raw_ostream *	OS,
		bool	DeleteStream = false
	)

createPrintFunctionPass - Create and return a pass that prints functions to the specified raw_ostream as they are processed.

createPrintFunctionPass - Create and return a pass that prints functions to the specified raw_ostream as they are processed.

Definition at line 96 of file PrintModulePass.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

ModulePass * llvm::createPrintModulePass	(	llvm::raw_ostream *	OS,
		bool	DeleteStream = false
	)

createPrintModulePass - Create and return a pass that writes the module to the specified raw_ostream.

createPrintModulePass - Create and return a pass that writes the module to the specified raw_ostream.

Definition at line 89 of file PrintModulePass.cpp.

Pass * llvm::createProfileLoaderPass

(

const std::string &

Filename

)

createProfileLoaderPass - This function returns a Pass that loads the profiling information for the module from the specified filename, making it available to the optimizers.

createProfileLoaderPass - This function returns a Pass that loads the profiling information for the module from the specified filename, making it available to the optimizers.

Definition at line 65 of file ProfileInfoLoaderPass.cpp.

ModulePass * llvm::createProfileLoaderPass

(

)

Definition at line 60 of file ProfileInfoLoaderPass.cpp.

FunctionPass * llvm::createPrologEpilogCodeInserter

(

)

PrologEpilogCodeInserter Pass - This pass inserts prolog and epilog code, and eliminates abstract frame references.

createPrologEpilogCodeInserter - This function returns a pass that inserts prolog and epilog code, and eliminates abstract frame references.

Definition at line 118 of file PrologEpilogInserter.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createPromoteMemoryToRegisterPass

(

)

Definition at line 90 of file Mem2Reg.cpp.

Referenced by LLVMAddPromoteMemoryToRegisterPass().

Pass * llvm::createPruneEHPass

(

)

createPruneEHPass - Return a new pass object which transforms invoke instructions into calls, if the callee can _not_ unwind the stack.

Definition at line 53 of file PruneEH.cpp.

ModulePass * llvm::createRaiseAllocationsPass

(

)

createRaiseAllocationsPass - Return a new pass that transforms malloc and free function calls into malloc and free instructions.

Definition at line 58 of file RaiseAllocations.cpp.

FunctionPass * llvm::createReassociatePass

(

)

Definition at line 104 of file Reassociate.cpp.

Referenced by LLVMAddReassociatePass().

FunctionPass * llvm::createRegisterAllocator

(

)

Creates a register allocator as the user specified on the command line.

createRegisterAllocator - choose the appropriate register allocator.

Definition at line 45 of file Passes.cpp.

References llvm::RegisterRegAlloc::getDefault(), RegAlloc, and llvm::RegisterRegAlloc::setDefault().

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createRSProfilingPass

(

)

Definition at line 651 of file RSProfiling.cpp.

FunctionPass* llvm::createScalarReplAggregatesPass

(

signed int

Threshold

)

Definition at line 143 of file ScalarReplAggregates.cpp.

FunctionPass* llvm::createScalarReplAggregatesPass

(

signed

Threshold = -1

)

FunctionPass * llvm::createSCCPPass

(

)

Definition at line 1518 of file SCCP.cpp.

FunctionPass * llvm::createSimpleRegisterAllocator

(

)

SimpleRegisterAllocation Pass - This pass converts the input machine code from SSA form to use explicit registers by spilling every register. Wow, great policy huh?

Definition at line 255 of file RegAllocSimple.cpp.

RegisterCoalescer * llvm::createSimpleRegisterCoalescer

(

)

SimpleRegisterCoalescing Pass - Coalesce all copies possible. Can run independently of the register allocator.

Definition at line 2608 of file SimpleRegisterCoalescing.cpp.

FunctionPass * llvm::createSimplifyHalfPowrLibCallsPass

(

)

createSimplifyHalfPowrLibCallsPass - This is an experimental pass that optimizes specific half_pow functions.

Definition at line 56 of file SimplifyHalfPowrLibCalls.cpp.

FunctionPass * llvm::createSimplifyLibCallsPass

(

)

createSimplifyLibCallsPass - This pass optimizes specific calls to specific well-known (library) functions.

Definition at line 1369 of file SimplifyLibCalls.cpp.

FunctionPass * llvm::createSingleLoopExtractorPass

(

)

createSingleLoopExtractorPass - This pass extracts one natural loop from the program into a function if it can. This is used by bugpoint.

Definition at line 146 of file LoopExtractor.cpp.

FunctionPass * llvm::createSparcCodePrinterPass	(	raw_ostream &	o,
		TargetMachine &	tm
	)

createSparcCodePrinterPass - Returns a pass that prints the SPARC assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 82 of file SparcAsmPrinter.cpp.

References llvm::TargetMachine::getTargetAsmInfo().

Referenced by llvm::SparcTargetMachine::addAssemblyEmitter().

FunctionPass * llvm::createSparcDelaySlotFillerPass

(

TargetMachine &

tm

)

createSparcDelaySlotFillerPass - Returns a pass that fills in delay slots in Sparc MachineFunctions

Definition at line 57 of file DelaySlotFiller.cpp.

Referenced by llvm::SparcTargetMachine::addPreEmitPass().

FunctionPass * llvm::createSparcFPMoverPass

(

TargetMachine &

tm

)

createSparcFPMoverPass - Returns a pass that turns FpMOVD instructions into FMOVS instructions

Definition at line 52 of file FPMover.cpp.

Referenced by llvm::SparcTargetMachine::addPreEmitPass().

FunctionPass * llvm::createSparcISelDag

(

SparcTargetMachine &

TM

)

createSparcISelDag - This pass converts a legalized DAG into a SPARC-specific DAG, ready for instruction scheduling.

Definition at line 212 of file SparcISelDAGToDAG.cpp.

Referenced by llvm::SparcTargetMachine::addInstSelector().

Spiller * llvm::createSpiller

(

)

createSpiller - Create an return a spiller object, as specified on the command line.

Definition at line 1868 of file VirtRegMap.cpp.

References local, simple, and SpillerOpt.

FunctionPass * llvm::createSPUAsmPrinterPass	(	raw_ostream &	o,
		SPUTargetMachine &	tm
	)

createSPUCodePrinterPass - Returns a pass that prints the Cell SPU assembly code for a MachineFunction to the given output stream, in a format that the Linux SPU assembler can deal with.

Definition at line 615 of file SPUAsmPrinter.cpp.

References llvm::TargetMachine::getTargetAsmInfo().

Referenced by llvm::SPUTargetMachine::addAssemblyEmitter().

FunctionPass * llvm::createSPUISelDag

(

SPUTargetMachine &

TM

)

createSPUISelDag - This pass converts a legalized DAG into a SPU-specific DAG, ready for instruction scheduling.

Definition at line 1147 of file SPUISelDAGToDAG.cpp.

Referenced by llvm::SPUTargetMachine::addInstSelector().

FunctionPass * llvm::createStackProtectorPass

(

const TargetLowering *

tli

)

createStackProtectorPass - This pass adds stack protectors to functions.

Definition at line 77 of file StackProtector.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createStackSlotColoringPass

(

)

createStackSlotColoringPass - This pass performs stack slot coloring.

Definition at line 93 of file StackSlotColoring.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

ModulePass* llvm::createSteensgaardPass

(

)

ModulePass * llvm::createStripDeadPrototypesPass

(

)

createStripDeadPrototypesPass - This pass removes any function declarations (prototypes) that are not used.

Definition at line 70 of file StripDeadPrototypes.cpp.

ModulePass * llvm::createStripNonDebugSymbolsPass

(

)

Definition at line 76 of file StripSymbols.cpp.

ModulePass * llvm::createStripSymbolsPass

(

bool

OnlyDebugInfo = false

)

Definition at line 68 of file StripSymbols.cpp.

Pass * llvm::createStructRetPromotionPass

(

)

Definition at line 67 of file StructRetPromotion.cpp.

FunctionPass * llvm::createTailCallEliminationPass

(

)

Definition at line 89 of file TailRecursionElimination.cpp.

FunctionPass * llvm::createTailDuplicationPass

(

)

Definition at line 65 of file TailDuplication.cpp.

ScheduleDAG * llvm::createTDListDAGScheduler	(	SelectionDAGISel *	IS,
		bool	Fast
	)

createTDListDAGScheduler - This creates a top-down list scheduler with a hazard recognizer.

createTDListDAGScheduler - This creates a top-down list scheduler with a new hazard recognizer. This scheduler takes ownership of the hazard recognizer and deletes it when done.

Definition at line 255 of file ScheduleDAGList.cpp.

References llvm::SelectionDAGISel::CreateTargetHazardRecognizer(), and llvm::SelectionDAGISel::MF.

Referenced by createDefaultScheduler().

llvm::ScheduleDAG * llvm::createTDRRListDAGScheduler	(	SelectionDAGISel *	IS,
		bool	Fast
	)

createTDRRListDAGScheduler - This creates a top down register usage reduction list scheduler.

Definition at line 1355 of file ScheduleDAGRRList.cpp.

References llvm::TargetMachine::getInstrInfo(), llvm::TargetMachine::getRegisterInfo(), llvm::SelectionDAGISel::MF, TII, llvm::SelectionDAGISel::TM, TM, and TRI.

Pass * llvm::createUnifyFunctionExitNodesPass

(

)

Definition at line 30 of file UnifyFunctionExitNodes.cpp.

FunctionPass * llvm::createUnreachableBlockEliminationPass

(

)

createUnreachableBlockEliminationPass - The LLVM code generator does not work well with unreachable basic blocks (what live ranges make sense for a block that cannot be reached?). As such, a code generator should either not instruction select unreachable blocks, or it can run this pass as it's last LLVM modifying pass to clean up blocks that are not reachable from the entry block.

Definition at line 51 of file UnreachableBlockElim.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses().

FunctionPass * llvm::createVerifierPass

(

VerifierFailureAction

action = AbortProcessAction

)

Create a verifier pass.

Check a module or function for validity. When the pass is used, the action indicated by the action argument will be used if errors are found.

Parameters:

action

Action to take

Definition at line 1633 of file Verifier.cpp.

FunctionPass * llvm::createX86CodeEmitterPass	(	X86TargetMachine &	TM,
		MachineCodeEmitter &	MCE
	)

createX86CodeEmitterPass - Return a pass that emits the collected X86 code to the specified MCE object.

Definition at line 104 of file X86CodeEmitter.cpp.

Referenced by llvm::X86TargetMachine::addCodeEmitter(), and llvm::X86TargetMachine::addSimpleCodeEmitter().

FunctionPass * llvm::createX86CodePrinterPass	(	raw_ostream &	o,
		X86TargetMachine &	tm
	)

createX86CodePrinterPass - Returns a pass that prints the X86 assembly code for a MachineFunction to the given output stream, using the given target machine description.

createX86CodePrinterPass - Returns a pass that prints the X86 assembly code for a MachineFunction to the given output stream, using the given target machine description.

Definition at line 26 of file X86AsmPrinter.cpp.

References llvm::TargetMachine::getSubtarget(), llvm::TargetMachine::getTargetAsmInfo(), llvm::X86Subtarget::isFlavorIntel(), and Subtarget.

FunctionPass * llvm::createX86FloatingPointStackifierPass

(

)

createX86FloatingPointStackifierPass - This function returns a pass which converts floating point register references and pseudo instructions into floating point stack references and physical instructions.

Definition at line 166 of file X86FloatingPoint.cpp.

Referenced by llvm::X86TargetMachine::addPostRegAlloc().

FunctionPass * llvm::createX86ISelDag	(	X86TargetMachine &	TM,
		bool	Fast
	)

createX86ISelDag - This pass converts a legalized DAG into a X86-specific DAG, ready for instruction scheduling.

Definition at line 1611 of file X86ISelDAGToDAG.cpp.

Referenced by llvm::X86TargetMachine::addInstSelector().

FunctionPass * llvm::createX86MaxStackAlignmentCalculatorPass

(

)

createX86MaxStackAlignmentCalculatorPass - This function returns a pass which calculates maximal stack alignment required for function

Definition at line 1246 of file X86RegisterInfo.cpp.

Referenced by llvm::X86TargetMachine::addPreRegAlloc().

FunctionPass * llvm::createX87FPRegKillInserterPass

(

)

createX87FPRegKillInserterPass - This function returns a pass which inserts FP_REG_KILL instructions where needed.

Definition at line 50 of file X86FloatingPointRegKill.cpp.

Referenced by llvm::X86TargetMachine::addInstSelector().

FunctionPass * llvm::createXCoreCodePrinterPass	(	raw_ostream &	o,
		XCoreTargetMachine &	tm
	)

createXCoreCodePrinterPass - Returns a pass that prints the XCore assembly code for a MachineFunction to the given output stream, using the given target machine description. This should work regardless of whether the function is in SSA form.

Definition at line 106 of file XCoreAsmPrinter.cpp.

References llvm::TargetMachine::getTargetAsmInfo().

Referenced by llvm::XCoreTargetMachine::addAssemblyEmitter().

FunctionPass * llvm::createXCoreISelDag

(

XCoreTargetMachine &

TM

)

createXCoreISelDag - This pass converts a legalized DAG into a XCore-specific DAG, ready for instruction scheduling.

Definition at line 79 of file XCoreISelDAGToDAG.cpp.

Referenced by llvm::XCoreTargetMachine::addInstSelector().

static const char* llvm::CStrInCStrNoCase	(	const char *	s1,
		const char *	s2
	)			[inline, static]

CStrInCStrNoCase - Portable version of strcasestr. Locates the first occurance of c-string 's2' in string 's1', ignoring case. Returns NULL if 's2' cannot be found.

Definition at line 166 of file StringExtras.h.

static void llvm::delete_edge	(	pbqp *	this_,
		int	u,
		int	v
	)			[static]

Definition at line 370 of file PBQP.cpp.

References find_adjnode(), remove_adjnode(), and llvm::adjnode::reverse.

Referenced by disconnect_trivialnode(), and simplify_edge().

void llvm::DeleteDeadBlock

(

BasicBlock *

BB

)

DeleteDeadBlock - Delete the specified block, which must have no predecessors.

Definition at line 29 of file BasicBlockUtils.cpp.

References llvm::BasicBlock::back(), llvm::BasicBlock::empty(), llvm::BasicBlock::eraseFromParent(), llvm::UndefValue::get(), llvm::BasicBlock::getInstList(), llvm::TerminatorInst::getNumSuccessors(), llvm::BasicBlock::getSinglePredecessor(), llvm::TerminatorInst::getSuccessor(), llvm::BasicBlock::getTerminator(), llvm::Value::getType(), pred_begin(), pred_end(), llvm::BasicBlock::removePredecessor(), llvm::Value::replaceAllUsesWith(), and llvm::Value::use_empty().

Referenced by SimplifyCFG().

template<class T>

static void llvm::deleter

(

T *

Ptr

)

[inline, static]

Definition at line 44 of file STLExtras.h.

AllocaInst * llvm::DemotePHIToStack	(	PHINode *	P,
		Instruction *	AllocaPoint = 0
	)

DemotePHIToStack - This function takes a virtual register computed by a phi node and replaces it with a slot in the stack frame, allocated via alloca. The phi node is deleted and it returns the pointer to the alloca inserted.

DemotePHIToStack - This function takes a virtual register computed by a phi node and replaces it with a slot in the stack frame, allocated via alloca. The phi node is deleted and it returns the pointer to the alloca inserted.

Definition at line 110 of file DemoteRegToStack.cpp.

References llvm::BasicBlock::begin(), llvm::Instruction::eraseFromParent(), F, llvm::Function::getEntryBlock(), llvm::PHINode::getIncomingBlock(), llvm::PHINode::getIncomingValue(), llvm::Value::getName(), llvm::PHINode::getNumIncomingValues(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::BasicBlock::getTerminator(), llvm::Value::getType(), II, llvm::Value::replaceAllUsesWith(), llvm::Value::use_empty(), and V.

AllocaInst * llvm::DemoteRegToStack	(	Instruction &	I,
		bool	VolatileLoads = false,
		Instruction *	AllocaPoint = 0
	)

DemoteRegToStack - This function takes a virtual register computed by an Instruction and replaces it with a slot in the stack frame, allocated via alloca. This allows the CFG to be changed around without fear of invalidating the SSA information for the value. It returns the pointer to the alloca inserted to create a stack slot for X.

DemoteRegToStack - This function takes a virtual register computed by an Instruction and replaces it with a slot in the stack frame, allocated via alloca. This allows the CFG to be changed around without fear of invalidating the SSA information for the value. It returns the pointer to the alloca inserted to create a stack slot for I.

Definition at line 32 of file DemoteRegToStack.cpp.

References llvm::BasicBlock::begin(), llvm::Instruction::eraseFromParent(), F, llvm::Function::getEntryBlock(), llvm::Value::getName(), llvm::InvokeInst::getNormalDest(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::BasicBlock::getSinglePredecessor(), llvm::Value::getType(), II, llvm::User::replaceUsesOfWith(), llvm::Instruction::use_back(), llvm::Value::use_empty(), and V.

static void llvm::determine_solution	(	pbqp *	this_,
		int	x
	)			[static]

Definition at line 1245 of file PBQP.cpp.

References llvm::pbqp::adj_list, llvm::PBQPVector::getLength(), llvm::PBQPMatrix::getRowAsVector(), llvm::PBQPVector::minIndex(), llvm::pbqp::node_costs, and pbqp_get_costmatrix().

Referenced by back_propagate().

static void llvm::determine_trivialsolution

(

pbqp *

this_

)

[static]

Definition at line 1289 of file PBQP.cpp.

References llvm::pbqp::bucket_list, llvm::pbqp::min, llvm::PBQPVector::minIndex(), llvm::pbqp::node_costs, llvm::pbqp::num_r0, pop_node(), and llvm::pbqp::solution.

Referenced by solve_pbqp().

template<class T>

df_iterator<T> llvm::df_begin

(

const T &

G

)

[inline]

Definition at line 165 of file DepthFirstIterator.h.

Referenced by llvm::LoopInfoBase< llvm::MachineBasicBlock >::Calculate().

template<class T>

df_iterator<T> llvm::df_end

(

const T &

G

)

[inline]

Definition at line 170 of file DepthFirstIterator.h.

Referenced by llvm::LoopInfoBase< llvm::MachineBasicBlock >::Calculate().

template<class T, class SetTy>

df_ext_iterator<T, SetTy> llvm::df_ext_begin	(	const T &	G,
		SetTy &	S
	)			[inline]

Definition at line 182 of file DepthFirstIterator.h.

Referenced by llvm::LiveVariables::runOnMachineFunction().

template<class T, class SetTy>

df_ext_iterator<T, SetTy> llvm::df_ext_end	(	const T &	G,
		SetTy &	S
	)			[inline]

Definition at line 187 of file DepthFirstIterator.h.

Referenced by llvm::LiveVariables::runOnMachineFunction().

template<class GraphT>

unsigned llvm::DFSPass	(	DominatorTreeBase< typename GraphT::NodeType > &	DT,
		typename GraphT::NodeType *	V,
		unsigned	N
	)			[inline]

Definition at line 38 of file DominatorInternals.h.

References llvm::MachineBasicBlock::back(), BB, E, llvm::DominatorTreeBase< NodeT >::Info, llvm::DominatorBase< NodeT >::Roots, succ_begin(), succ_end(), llvm::DominatorTreeBase< NodeT >::Vertex, and Worklist.

int llvm::DiffFilesWithTolerance	(	const sys::PathWithStatus &	FileA,
		const sys::PathWithStatus &	FileB,
		double	AbsTol,
		double	RelTol,
		std::string *	Error = 0
	)

DiffFilesWithTolerance - Compare the two files specified, returning 0 if the files match, 1 if they are different, and 2 if there is a file error. This function allows you to specify an absolete and relative FP error that is allowed to exist. If you specify a string to fill in for the error option, it will set the string to an error message if an error occurs, or if the files are different.

DiffFilesWithTolerance - Compare the two files specified, returning 0 if the files match, 1 if they are different, and 2 if there is a file error. This function differs from DiffFiles in that you can specify an absolete and relative FP error that is allowed to exist. If you specify a string to fill in for the error option, it will set the string to an error message if an error occurs, allowing the caller to distinguish between a failed diff and a file system error.

Definition at line 165 of file FileUtilities.cpp.

References BackupNumber(), llvm::sys::Path::c_str(), CompareNumbers(), llvm::MemoryBuffer::getFile(), llvm::sys::PathWithStatus::getFileStatus(), llvm::sys::FileStatus::getSize(), and isNumberChar().

static void llvm::disconnect_trivialnode	(	pbqp *	this_,
		int	u
	)			[static]

Definition at line 665 of file PBQP.cpp.

References llvm::pbqp::adj_list, delete_edge(), llvm::PBQPVector::getLength(), llvm::PBQPMatrix::getRowAsVector(), next(), llvm::pbqp::node_costs, and pbqp_get_costmatrix().

Referenced by eliminate_trivial_nodes().

void llvm::DisplayGraph

(

const sys::Path &

Filename

)

Definition at line 21 of file GraphWriter.cpp.

References llvm::sys::Path::appendSuffix(), llvm::sys::Path::c_str(), cerr(), llvm::sys::Path::eraseFromDisk(), llvm::sys::Program::ExecuteAndWait(), LLVM_PATH_DOT, and LLVM_PATH_DOTTY.

Referenced by ViewGraph().

uint64_t llvm::DoubleToBits

(

double

Double

)

[inline]

DoubleToBits - This function takes a double and returns the bit equivalent 64-bit integer. Note that copying doubles around changes the bits of NaNs on some hosts, notably x86, so this routine cannot be used if these bits are needed.

Definition at line 367 of file MathExtras.h.

References L, and T.

Referenced by GetConstantBuildVectorBits(), and LowerConstantFP().

template<unsigned ElementSize>

void llvm::dump	(	const SparseBitVector< ElementSize > &	LHS,
		llvm::OStream &	out
	)			[inline]

Definition at line 845 of file SparseBitVector.h.

References llvm::SparseBitVector< ElementSize >::begin(), and llvm::SparseBitVector< ElementSize >::end().

Referenced by llvm::DerivedType::dump(), llvm::DISubprogram::dump(), and dumpToDOUT().

template<class X, class Y>

cast_retty<X, Y>::ret_type llvm::dyn_cast

(

const Y &

Val

)

[inline]

Definition at line 224 of file Casting.h.

Referenced by AddPredecessorToBlock(), AddReachableCodeToWorklist(), llvm::MachineModuleInfo::AnalyzeModule(), llvm::SelectInst::areInvalidOperands(), AssociativeOpt(), BuildSubAggregate(), CannotBeNegativeZero(), CanPropagatePredecessorsForPHIs(), llvm::Constant::canTrap(), CheapToScalarize(), CloneAndPruneFunctionInto(), combineShlAddConstant(), ComputeMaskedBits(), ComputeNumSignBits(), ConstantFoldBinaryInstruction(), ConstantFoldInsertElementInstruction(), ConstantFoldInstruction(), ConstantFoldTerminator(), llvm::X86IntelAsmPrinter::decorateName(), llvm::X86ATTAsmPrinter::decorateName(), DominatesMergePoint(), llvm::Value::DoPHITranslation(), EnforceKnownAlignment(), EraseTerminatorInstAndDCECond(), evaluateFCmpRelation(), EvaluateFunction(), EvaluateGEPOffsetExpression(), evaluateICmpRelation(), llvm::PIC16TargetLowering::ExpandExternalSymbol(), llvm::PIC16TargetLowering::ExpandFrameIndex(), llvm::PIC16TargetLowering::ExpandGlobalAddress(), llvm::PIC16TargetLowering::ExpandLoad(), ExtractTypeInfo(), FindAllMemoryUses(), llvm::SelectionDAGLowering::FindMergedConditions(), FindStaticTors(), FoldBitCast(), FoldBranchToCommonDest(), FoldCondBranchOnPHI(), getAggregateConstantElement(), llvm::GlobalAlias::getAliasedGlobal(), getBitCastOperand(), llvm::InvokeInst::getCalledFunction(), llvm::CallInst::getCalledFunction(), llvm::CallSite::getCalledFunction(), getConstantEvolvingPHI(), GetConstantStringInfo(), llvm::SelectionDAG::getGlobalAddress(), llvm::Module::getGlobalVariable(), llvm::DIDescriptor::getGlobalVariableField(), llvm::GetElementPtrInst::getIndexedType(), getIndexedTypeInternal(), llvm::SelectionDAG::getMemcpy(), llvm::SelectionDAG::getMemmove(), llvm::MemSDNode::getMemOperand(), llvm::SelectionDAG::getMemset(), llvm::SelectionDAG::getNode(), llvm::SCEVAddRecExpr::getNumIterationsInRange(), GetOffsetFromIndex(), getSCEVStartAndStride(), llvm::LoopBase< BlockT >::getSmallConstantTripMultiple(), GetStringLengthH(), llvm::BasicBlock::getTerminator(), getVZextMovL(), HoistThenElseCodeToIf(), InstCombineStoreToCast(), llvm::ConstantVector::isAllOnesValue(), isBLACompatibleAddress(), isCalleeLoad(), IsConstantOffsetFromGlobal(), isConstantString(), IsFixedFrameObjectWithPosOffset(), llvm::TargetLowering::isGAPlusOffset(), isI16IntS10Immediate(), isLSAAddress(), isMemSrcFromString(), isNonConstantNegative(), llvm::ISD::isNormalLoad(), llvm::ISD::isNormalStore(), IsPointerOffset(), IsPossiblyOverwrittenArgumentOfTailCall(), isRMWLoad(), isSafeSROAElementUse(), llvm::Value::isUsedInBasicBlock(), llvm::Instruction::isUsedOutsideOfBlock(), IsUserOfGlobalSafeForSRA(), llvm::ShuffleVectorInst::isValidOperands(), llvm::FunctionType::isValidReturnType(), llvm::SelectionDAG::isVerifiedDebugInfoDesc(), isXor1OfSetCC(), IVUseShouldUsePostIncValue(), LinkFunctionBodies(), llvm::X86TargetLowering::LowerAsmOperandForConstraint(), llvm::TargetLowering::LowerAsmOperandForConstraint(), llvm::PPCTargetLowering::LowerAsmOperandForConstraint(), llvm::PIC16TargetLowering::LowerCALL(), llvm::PIC16TargetLowering::LowerCallArguments(), llvm::PIC16TargetLowering::LowerCallReturn(), LowerLOAD(), LowerSETCC(), LowerSTORE(), OnlyCalledDirectly(), llvm::SPUTargetLowering::PerformDAGCombine(), llvm::X86ATTAsmPrinter::printOperand(), RecursivelyDeleteTriviallyDeadInstructions(), removeDeadUsersOfConstant(), llvm::BasicBlock::removePredecessor(), llvm::ExecutionEngine::runStaticConstructorsDestructors(), llvm::TargetAsmInfo::SectionKindForGlobal(), llvm::MipsTargetAsmInfo::SelectSectionForGlobal(), llvm::FunctionLoweringInfo::set(), ShrinkDemandedConstant(), SimplifyCondBranchToCondBranch(), SolveQuadraticEquation(), SpeculativelyExecuteBB(), llvm::BasicBlock::splitBasicBlock(), SplitBlockPredecessors(), SplitEdgeNicely(), llvm::DbgInfoIntrinsic::StripCast(), StripDebugInfo(), UnrollLoop(), ValueIsOnlyUsedLocallyOrStoredToOneGlobal(), llvm::InlineAsm::Verify(), and WriteAsOperandInternal().

template<class X, class Y>

cast_retty<X, Y>::ret_type llvm::dyn_cast_or_null

(

const Y &

Val

)

[inline]

Definition at line 232 of file Casting.h.

static void llvm::eliminate_independent_edges

(

pbqp *

this_

)

[static]

Definition at line 801 of file PBQP.cpp.

References llvm::pbqp::changed, next(), llvm::pbqp::num_nodes, and simplify_edge().

Referenced by solve_pbqp().

static void llvm::eliminate_trivial_nodes

(

pbqp *

this_

)

[static]

Definition at line 698 of file PBQP.cpp.

References disconnect_trivialnode(), llvm::PBQPVector::getLength(), and llvm::pbqp::node_costs.

Referenced by solve_pbqp().

raw_ostream & llvm::errs

(

)

errs() - This returns a reference to a raw_ostream for standard error. Use it like: errs() << "foo" << "bar";

Definition at line 284 of file raw_ostream.cpp.

Referenced by llvm::X86TargetMachine::addCodeEmitter(), llvm::PPCTargetMachine::addCodeEmitter(), llvm::ARMTargetMachine::addCodeEmitter(), llvm::AlphaTargetMachine::addCodeEmitter(), llvm::LLVMTargetMachine::addCommonCodeGenPasses(), llvm::X86TargetMachine::addSimpleCodeEmitter(), llvm::PPCTargetMachine::addSimpleCodeEmitter(), llvm::ARMTargetMachine::addSimpleCodeEmitter(), llvm::SDNode::dump(), llvm::PseudoSourceValue::dump(), llvm::MachineConstantPool::dump(), llvm::ConstantRange::dump(), llvm::Module::dump(), llvm::Type::dump(), llvm::Value::dump(), and llvm::ParseError::PrintError().

void llvm::EscapeString

(

std::string &

Str

)

EscapeString - Modify the argument string, turning '\' and anything that doesn't satisfy std::isprint into an escape sequence.

Definition at line 91 of file StringExtras.cpp.

template<class GraphT>

GraphT::NodeType* llvm::Eval	(	DominatorTreeBase< typename GraphT::NodeType > &	DT,
		typename GraphT::NodeType *	V
	)			[inline]

Definition at line 155 of file DominatorInternals.h.

References llvm::DominatorTreeBase< NodeT >::Info.

llvm::EXTERN_TEMPLATE_INSTANTIATION

(

class X86TargetAsmInfo< TargetAsmInfo >

)

llvm::EXTERN_TEMPLATE_INSTANTIATION

(

class PPCTargetAsmInfo< TargetAsmInfo >

)

llvm::EXTERN_TEMPLATE_INSTANTIATION

(

class ARMTargetAsmInfo< TargetAsmInfo >

)

llvm::EXTERN_TEMPLATE_INSTANTIATION

(

class DominatorTreeBase< MachineBasicBlock >

)

llvm::EXTERN_TEMPLATE_INSTANTIATION

(

class DominatorTreeBase< BasicBlock >

)

llvm::EXTERN_TEMPLATE_INSTANTIATION

(

class DomTreeNodeBase< MachineBasicBlock >

)

llvm::EXTERN_TEMPLATE_INSTANTIATION

(

class DomTreeNodeBase< BasicBlock >

)

Function * llvm::ExtractBasicBlock	(	BasicBlock *	BB,
		bool	AggregateArgs = false
	)

ExtractBasicBlock - rip out a basic block into a new function

ExtractBasicBlock - slurp a basic block into a brand new function

Definition at line 742 of file CodeExtractor.cpp.

References Blocks.

Function * llvm::ExtractCodeRegion	(	DominatorTree &	DT,
		const std::vector< BasicBlock * > &	code,
		bool	AggregateArgs = false
	)

ExtractCodeRegion - rip out a sequence of basic blocks into a new function

ExtractCodeRegion - slurp a sequence of basic blocks into a brand new function

Definition at line 728 of file CodeExtractor.cpp.

Function * llvm::ExtractLoop	(	DominatorTree &	DT,
		Loop *	L,
		bool	AggregateArgs = false
	)

ExtractLoop - rip out a natural loop into a new function

ExtractBasicBlock - slurp a natural loop into a brand new function

Definition at line 736 of file CodeExtractor.cpp.

References llvm::LoopBase< BlockT >::getBlocks().

static adjnode* llvm::find_adjnode	(	pbqp *	this_,
		int	u,
		int	v
	)			[static]

Definition at line 193 of file PBQP.cpp.

References llvm::adjnode::adj, and llvm::pbqp::adj_list.

Referenced by apply_RII(), delete_edge(), get_costmatrix_ptr(), and pbqp_get_costmatrix().

Value * llvm::FindAvailableLoadedValue	(	Value *	Ptr,
		BasicBlock *	ScanBB,
		BasicBlock::iterator &	ScanFrom,
		unsigned	MaxInstsToScan = 6,
		AliasAnalysis *	AA = 0
	)

FindAvailableLoadedValue - Scan the ScanBB block backwards (starting at the instruction before ScanFrom) checking to see if we have the value at the memory address *Ptr locally available within a small number of instructions. If the value is available, return it.

If not, return the iterator for the last validated instruction that the value would be live through. If we scanned the entire block and didn't find something that invalidates *Ptr or provides it, ScanFrom would be left at begin() and this returns null. ScanFrom could also be left

MaxInstsToScan specifies the maximum instructions to scan in the block. If it is set to 0, it will scan the whole block. You can also optionally specify an alias analysis implementation, which makes this more precise.

Definition at line 460 of file BasicBlockUtils.cpp.

References AccessTy, AreEquivalentAddressValues(), llvm::BasicBlock::begin(), llvm::AliasAnalysis::getModRefInfo(), llvm::AliasAnalysis::getTargetData(), llvm::Value::getType(), llvm::TargetData::getTypeStoreSizeInBits(), Inst, LI, llvm::Instruction::mayWriteToMemory(), and llvm::AliasAnalysis::Mod.

const DbgStopPointInst * llvm::findBBStopPoint

(

const BasicBlock *

BB

)

Finds the stoppoint corresponding to first real (non-debug intrinsic) instruction in this Basic Block, and returns the stoppoint for it.

Definition at line 811 of file DebugInfo.cpp.

References llvm::BasicBlock::begin(), E, llvm::BasicBlock::end(), findStopPoint(), llvm::BasicBlock::getTerminator(), and llvm::BasicBlock::getUniquePredecessor().

const DbgDeclareInst * llvm::findDbgDeclare	(	const Value *	V,
		bool	stripCasts = true
	)

Finds the dbg.declare intrinsic corresponding to this value if any. It looks through pointer casts too.

Definition at line 827 of file DebugInfo.cpp.

References E, llvm::Value::stripPointerCasts(), llvm::Value::use_begin(), and llvm::Value::use_end().

sys::Path llvm::FindExecutable	(	const std::string &	ExeName,
		const std::string &	ProgramPath
	)

Find a named executable.

FindExecutable - Find a named executable, giving the argv[0] of program being executed. This allows us to find another LLVM tool if it is built into the same directory, but that directory is neither the current directory, nor in the PATH. If the executable cannot be found, return an empty string.

FindExecutable - Find a named executable, giving the argv[0] of program being executed. This allows us to find another LLVM tool if it is built into the same directory, but that directory is neither the current directory, nor in the PATH. If the executable cannot be found, return an empty string.

Definition at line 44 of file SystemUtils.cpp.

References llvm::sys::Path::appendComponent(), llvm::sys::Path::canExecute(), llvm::sys::Path::eraseComponent(), llvm::sys::Program::FindProgramByName(), and llvm::sys::Path::isEmpty().

Value* llvm::FindInsertedValue	(	Value *	V,
		const unsigned	Idx,
		Instruction *	InsertBefore = 0
	)			[inline]

This is a convenience wrapper for finding values indexed by a single index only.

Definition at line 71 of file ValueTracking.h.

References FindInsertedValue().

Value * llvm::FindInsertedValue	(	Value *	V,
		const unsigned *	idx_begin,
		const unsigned *	idx_end,
		Instruction *	InsertBefore = 0
	)

FindScalarValue - Given an aggregrate and an sequence of indices, see if the scalar value indexed is already around as a register, for example if it were inserted directly into the aggregrate.

If InsertBefore is not null, this function will duplicate (modified) insertvalues when a part of a nested struct is extracted.

FindInsertedValue - Given an aggregrate and an sequence of indices, see if the scalar value indexed is already around as a register, for example if it were inserted directly into the aggregrate.

If InsertBefore is not null, this function will duplicate (modified) insertvalues when a part of a nested struct is extracted.

Definition at line 844 of file ValueTracking.cpp.

References llvm::SmallVectorImpl< T >::begin(), BuildSubAggregate(), llvm::CallingConv::C, llvm::SmallVectorImpl< T >::end(), llvm::UndefValue::get(), llvm::Constant::getNullValue(), llvm::Value::getType(), llvm::SmallVectorImpl< T >::push_back(), llvm::SmallVectorImpl< T >::reserve(), and llvm::SmallVectorImpl< T >::size().

Referenced by BuildSubAggregate(), and FindInsertedValue().

const DbgStopPointInst * llvm::findStopPoint

(

const Instruction *

Inst

)

Finds the stoppoint coressponding to this instruction, that is the stoppoint that dominates this instruction

Definition at line 782 of file DebugInfo.cpp.

References BB, llvm::BasicBlock::begin(), llvm::Instruction::getParent(), and llvm::BasicBlock::getTerminator().

Referenced by findBBStopPoint().

bool llvm::FiniteOnlyFPMath

(

)

FiniteOnlyFPMath - This returns true when the -enable-finite-only-fp-math option is specified on the command line. If this returns false (default), the code generator is not allowed to assume that FP arithmetic arguments and results are never NaNs or +-Infs.

Definition at line 209 of file TargetMachine.cpp.

References FiniteOnlyFPMathOption, and UnsafeFPMath.

Referenced by getFCmpCondCode().

uint32_t llvm::FloatToBits

(

float

Float

)

[inline]

FloatToBits - This function takes a float and returns the bit equivalent 32-bit integer. Note that copying floats around changes the bits of NaNs on some hosts, notably x86, so this routine cannot be used if these bits are needed.

Definition at line 380 of file MathExtras.h.

References F, and T.

Referenced by llvm::PPC::get_VSPLTI_elt(), GetConstantBuildVectorBits(), and isFPS16Immediate().

void llvm::FlushStream

(

std::ostream &

S

)

FlushStream - Function called by BaseStream to flush an ostream.

Definition at line 26 of file Streams.cpp.

void llvm::FoldSingleEntryPHINodes

(

BasicBlock *

BB

)

FoldSingleEntryPHINodes - We know that BB has one predecessor. If there are any single-entry PHI nodes in it, fold them away. This handles the case when all entries to the PHI nodes in a block are guaranteed equal, such as when the block has exactly one predecessor.

Definition at line 61 of file BasicBlockUtils.cpp.

References llvm::BasicBlock::begin(), and llvm::UndefValue::get().

Referenced by FoldBlockIntoPredecessor(), and FoldCondBranchOnPHI().

template<typename T1, typename T2, typename T3>

format_object3<T1, T2, T3> llvm::format	(	const char *	Fmt,
		const T1 &	Val1,
		const T2 &	Val2,
		const T3 &	Val3
	)			[inline]

format - This is a helper function that is used to produce formatted output. This is typically used like: OS << format("%0.4f", myfloat) << '
';

Definition at line 148 of file Format.h.

template<typename T1, typename T2>

format_object2<T1, T2> llvm::format	(	const char *	Fmt,
		const T1 &	Val1,
		const T2 &	Val2
	)			[inline]

format - This is a helper function that is used to produce formatted output. This is typically used like: OS << format("%0.4f", myfloat) << '
';

Definition at line 140 of file Format.h.

template<typename T>

format_object1<T> llvm::format	(	const char *	Fmt,
		const T &	Val
	)			[inline]

format - This is a helper function that is used to produce formatted output. This is typically used like: OS << format("%0.4f", myfloat) << '
';

Definition at line 133 of file Format.h.

Referenced by llvm::raw_ostream::operator<<().

void llvm::free_pbqp

(

pbqp *

this_

)

Definition at line 132 of file PBQP.cpp.

References llvm::pbqp::adj_list, llvm::pbqp::bucket_list, llvm::pbqp::bucket_ptr, llvm::adjnode::costs, llvm::pbqp::max_deg, llvm::pbqp::node_costs, llvm::pbqp::node_deg, llvm::pbqp::num_nodes, llvm::pbqp::solution, llvm::pbqp::stack, and llvm::bucketnode::u.

static std::string llvm::ftostr

(

const APFloat &

V

)

[inline, static]

Definition at line 118 of file StringExtras.h.

References llvm::APFloat::convertToDouble(), llvm::APFloat::convertToFloat(), ftostr(), llvm::APFloat::getSemantics(), llvm::APFloat::IEEEdouble, and llvm::APFloat::IEEEsingle.

Referenced by CompareNumbers(), and isFPCSafeToPrint().

static std::string llvm::ftostr

(

double

V

)

[inline, static]

Definition at line 110 of file StringExtras.h.

Referenced by ftostr(), llvm::raw_ostream::operator<<(), and WriteConstantInt().

template<typename ItTy>

generic_gep_type_iterator<ItTy> llvm::gep_type_begin	(	const Type *	Op0,
		ItTy	I,
		ItTy	E
	)			[inline]

Definition at line 101 of file GetElementPtrTypeIterator.h.

Referenced by EmitGEPOffset(), EvaluateGEPOffsetExpression(), GetOffsetFromIndex(), and IsConstantOffsetFromGlobal().

gep_type_iterator llvm::gep_type_begin

(

const User &

GEP

)

[inline]

Definition at line 91 of file GetElementPtrTypeIterator.h.

References llvm::generic_gep_type_iterator< ItTy >::begin(), llvm::User::getOperand(), llvm::Value::getType(), and llvm::User::op_begin().

gep_type_iterator llvm::gep_type_begin

(

const User *

GEP

)

[inline]

Definition at line 84 of file GetElementPtrTypeIterator.h.

References llvm::generic_gep_type_iterator< ItTy >::begin(), llvm::User::getOperand(), llvm::Value::getType(), and llvm::User::op_begin().

Referenced by ComputeMaskedBits(), ConstantFoldGetElementPtr(), ConstantFoldLoadThroughGEPConstantExpr(), evaluateICmpRelation(), llvm::TargetData::getIndexedOffset(), IsUserOfGlobalSafeForSRA(), and llvm::Interpreter::visitGetElementPtrInst().

template<typename ItTy>

generic_gep_type_iterator<ItTy> llvm::gep_type_end	(	const Type *	Op0,
		ItTy	I,
		ItTy	E
	)			[inline]

Definition at line 107 of file GetElementPtrTypeIterator.h.

gep_type_iterator llvm::gep_type_end

(

const User &

GEP

)

[inline]

Definition at line 95 of file GetElementPtrTypeIterator.h.

References llvm::generic_gep_type_iterator< ItTy >::end(), and llvm::User::op_end().

gep_type_iterator llvm::gep_type_end

(

const User *

GEP

)

[inline]

Definition at line 88 of file GetElementPtrTypeIterator.h.

References llvm::generic_gep_type_iterator< ItTy >::end(), and llvm::User::op_end().

Referenced by ConstantFoldGetElementPtr(), ConstantFoldLoadThroughGEPConstantExpr(), IsUserOfGlobalSafeForSRA(), and llvm::Interpreter::visitGetElementPtrInst().

template<typename T>

static int(*)(const void*, const void*) llvm::get_array_pad_sort_comparator

(

const T &

X

)

[inline, static]

get_array_pad_sort_comparator - This is an internal helper function used to get type deduction of T right.

Definition at line 238 of file STLExtras.h.

Referenced by array_pod_sort().

static PBQPMatrix* llvm::get_costmatrix_ptr	(	pbqp *	this_,
		int	u,
		int	v
	)			[static]

Definition at line 416 of file PBQP.cpp.

References find_adjnode().

Referenced by add_pbqp_edgecosts(), and simplify_edge().

static int llvm::get_deg	(	pbqp *	this_,
		int	u
	)			[static]

Definition at line 294 of file PBQP.cpp.

References llvm::pbqp::adj_list.

Referenced by create_bucketlist(), and reorder_node().

int llvm::get_pbqp_solution	(	pbqp *	this_,
		int	x
	)

Definition at line 1377 of file PBQP.cpp.

References llvm::pbqp::solution.

void* llvm::GetAddressOfSymbol

(

const std::string &

symbolName

)

void* llvm::GetAddressOfSymbol

(

const char *

symbolName

)

GetAddressOfSymbol - Returns the address of the named symbol in the currently running process, as reported by the dynamic linker, or NULL if the symbol does not exist or some other error has occurred.

ModuleProvider * llvm::getBitcodeModuleProvider	(	MemoryBuffer *	Buffer,
		std::string *	ErrMsg = 0
	)

getBitcodeModuleProvider - Read the header of the specified bitcode buffer and prepare for lazy deserialization of function bodies. If successful, this takes ownership of 'buffer' and returns a non-null pointer. On error, this returns null, *does not* take ownership of Buffer, and fills in *ErrMsg with an error description if ErrMsg is non-null.

getBitcodeModuleProvider - lazy function-at-a-time loading from a file.

Definition at line 2077 of file BitcodeReader.cpp.

References llvm::BitcodeReader::getErrorString(), llvm::BitcodeReader::ParseBitcode(), R, and llvm::BitcodeReader::releaseMemoryBuffer().

Referenced by llvm::Archive::findModuleDefiningSymbol(), GetBitcodeSymbols(), LLVMGetBitcodeModuleProvider(), and ParseBitcodeFile().

ModuleProvider * llvm::GetBitcodeSymbols	(	const unsigned char *	BufPtr,
		unsigned	Length,
		const std::string &	ModuleID,
		std::vector< std::string > &	symbols,
		std::string *	ErrMsg
	)

Definition at line 240 of file Archive.cpp.

References getBitcodeModuleProvider(), llvm::MemoryBuffer::getBufferStart(), llvm::MemoryBuffer::getNewMemBuffer(), getSymbols(), M, and llvm::Intrinsic::memcpy.

bool llvm::GetBitcodeSymbols	(	const sys::Path &	fName,
		std::vector< std::string > &	symbols,
		std::string *	ErrMsg
	)

Definition at line 210 of file Archive.cpp.

References llvm::sys::Path::c_str(), getBitcodeModuleProvider(), llvm::MemoryBuffer::getFileOrSTDIN(), getSymbols(), M, llvm::ModuleProvider::materializeModule(), and llvm::sys::Path::toString().

Referenced by llvm::Archive::findModulesDefiningSymbols(), and llvm::Archive::writeMember().

bool llvm::GetConstantStringInfo	(	Value *	V,
		std::string &	Str,
		uint64_t	Offset = 0,
		bool	StopAtNul = true
	)

GetConstantStringInfo - This function computes the length of a null-terminated C string pointed to by V. If successful, it returns true and returns the string in Str. If unsuccessful, it returns false. If StopAtNul is set to true (the default), the returned string is truncated by a nul character in the global. If StopAtNul is false, the nul character is included in the result string.

GetConstantStringInfo - This function computes the length of a null-terminated C string pointed to by V. If successful, it returns true and returns the string in Str. If unsuccessful, it returns false.

Definition at line 939 of file ValueTracking.cpp.

References BitCast, dyn_cast(), llvm::SequentialType::getElementType(), llvm::GlobalVariable::getInitializer(), llvm::ArrayType::getNumElements(), llvm::Constant::getOperand(), llvm::ConstantArray::getType(), llvm::ConstantInt::getZExtValue(), GV, llvm::GlobalVariable::hasInitializer(), llvm::Type::Int8Ty, llvm::GlobalVariable::isConstant(), and llvm::ConstantInt::isZero().

Referenced by llvm::DIDescriptor::getStringField(), InstCombineLoadCast(), isMemSrcFromString(), llvm::SourceFileInfo::SourceFileInfo(), and llvm::SourceFunctionInfo::SourceFunctionInfo().

OStream & llvm::getErrorOutputStream

(

const char *

DebugType

)

getErrorOutputStream - Returns the error output stream (std::cerr). This places the std::c* I/O streams into one .cpp file and relieves the whole program from having to have hundreds of static c'tor/d'tors for them.

Definition at line 71 of file Debug.cpp.

References cerr(), DebugFlag, and isCurrentDebugType().

std::ostream * llvm::GetLibSupportInfoOutputFile

(

)

Definition at line 295 of file Timer.cpp.

References cerr(), cout(), and getLibSupportInfoOutputFilename().

BasicBlock* llvm::getNodeHeader

(

Interval *

I

)

[inline]

Definition at line 50 of file IntervalIterator.h.

References llvm::Interval::getHeaderNode().

BasicBlock* llvm::getNodeHeader

(

BasicBlock *

BB

)

[inline]

Definition at line 49 of file IntervalIterator.h.

FunctionPass* llvm::getRegisterAllocator

(

TargetMachine &

T

)

getRegisterAllocator - This creates an instance of the register allocator for the Sparc.

Interval* llvm::getSourceGraphNode	(	IntervalPartition *	IP,
		BasicBlock *	BB
	)			[inline]

Definition at line 59 of file IntervalIterator.h.

References llvm::IntervalPartition::getBlockInterval().

BasicBlock* llvm::getSourceGraphNode	(	Function *	,
		BasicBlock *	BB
	)			[inline]

Definition at line 56 of file IntervalIterator.h.

Referenced by llvm::IntervalIterator< NodeTy, OrigContainer_t, GT, IGT >::operator++().

std::string llvm::getToken	(	std::string &	Source,
		const char *	Delimiters = " \t\n\v\f\r"
	)

getToken - This function extracts one token from source, ignoring any leading characters that appear in the Delimiters string, and ending the token at any of the characters that appear in the Delimiters string. If there are no tokens in the source string, an empty string is returned. The Source source string is updated in place to remove the returned string and any delimiter prefix from it.

Definition at line 24 of file StringExtras.cpp.

References End, and Start.

Referenced by llvm::Module::getEndianness(), llvm::Module::getPointerSize(), llvm::TargetData::init(), llvm::Debugger::loadProgram(), and SplitString().

unsigned llvm::getX86SubSuperRegister	(	unsigned	Reg,
		MVT	VT,
		bool	High
	)

Definition at line 1044 of file X86RegisterInfo.cpp.

References llvm::ARMCC::AL, llvm::XCoreISD::BL, llvm::N86::EAX, llvm::N86::EBP, llvm::N86::EBX, llvm::N86::ECX, llvm::N86::EDI, llvm::N86::EDX, llvm::N86::ESI, llvm::N86::ESP, llvm::MVT::getSimpleVT(), llvm::MVT::i16, llvm::MVT::i32, llvm::MVT::i64, and llvm::MVT::i8.

Referenced by llvm::X86IntelAsmPrinter::printAsmMRegister(), llvm::X86ATTAsmPrinter::printAsmMRegister(), llvm::X86IntelAsmPrinter::printOp(), and llvm::X86ATTAsmPrinter::printOperand().

uint64_t llvm::GreatestCommonDivisor64	(	uint64_t	A,
		uint64_t	B
	)			[inline]

GreatestCommonDivisor64 - Return the greatest common divisor of the two values using Euclid's algorithm.

Definition at line 332 of file MathExtras.h.

References T.

Referenced by UnrollLoop().

void* llvm::GVTOP

(

const GenericValue &

GV

)

[inline]

Definition at line 41 of file GenericValue.h.

References llvm::GenericValue::PointerVal.

Referenced by lle_X___cxa_guard_acquire(), lle_X___cxa_guard_release(), lle_X___strdup(), lle_X_atexit(), lle_X_atoi(), lle_X_fclose(), lle_X_feof(), lle_X_ferror(), lle_X_fflush(), lle_X_fgets(), lle_X_fopen(), lle_X_fprintf(), lle_X_fputc(), lle_X_fread(), lle_X_free(), lle_X_freopen(), lle_X_fwrite(), lle_X_getc(), lle_X_memcpy(), lle_X_memmove(), lle_X_memset(), lle_X_puts(), lle_X_realloc(), lle_X_scanf(), lle_X_sprintf(), lle_X_sscanf(), lle_X_strcat(), lle_X_strcmp(), lle_X_strcpy(), lle_X_strdup(), lle_X_strlen(), lle_X_ungetc(), llvm::JIT::runFunction(), llvm::ExecutionEngine::runFunctionAsMain(), llvm::Interpreter::visitCallSite(), llvm::Interpreter::visitFreeInst(), llvm::Interpreter::visitLoadInst(), and llvm::Interpreter::visitStoreInst().

BinaryOperator llvm::HANDLE_BINARY_INST	(	18	,
		AShr	,
		BinaryOperator
	)

Type Constraints

llvm::HANDLE_BINARY_INST	(	16	,
		Shl	,
		BinaryOperator
	)

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst llvm::HANDLE_CAST_INST	(	38	,
		IntToPtr	,
		IntToPtrInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst llvm::HANDLE_CAST_INST	(	36	,
		FPExt	,
		FPExtInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst llvm::HANDLE_CAST_INST	(	34	,
		SIToFP	,
		SIToFPInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst llvm::HANDLE_CAST_INST	(	32	,
		FPToSI	,
		FPToSIInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst llvm::HANDLE_CAST_INST	(	30	,
		SExt	,
		SExtInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst llvm::HANDLE_CAST_INST	(	28	,
		Trunc	,
		TruncInst
	)

Type Constraints

BinaryOperator MallocInst llvm::HANDLE_MEMORY_INST	(	24	,
		Alloca	,
		AllocaInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst ExtractValueInst VICmpInst llvm::HANDLE_OTHER_INST	(	54	,
		VFCmp	,
		VFCmpInst
	)

Base class for instruction visitors.

Instruction visitors are used when you want to perform different action for different kinds of instruction without without having to use lots of casts and a big switch statement (in your code that is).

To define your own visitor, inherit from this class, specifying your new type for the 'SubClass' template parameter, and "override" visitXXX functions in your class. I say "overriding" because this class is defined in terms of statically resolved overloading, not virtual functions.

For example, here is a visitor that counts the number of malloc instructions processed:

/ Declare the class. Note that we derive from InstVisitor instantiated / with _our new subclasses_ type. / struct CountMallocVisitor : public InstVisitor<CountMallocVisitor> { unsigned Count; CountMallocVisitor() : Count(0) {}

void visitMallocInst(MallocInst &MI) { ++Count; } };

And this class would be used like this: CountMallocVistor CMV; CMV.visit(function); NumMallocs = CMV.Count;

The defined has 'visit' methods for Instruction, and also for BasicBlock, Function, and Module, which recursively process all conained instructions.

Note that if you don't implement visitXXX for some instruction type, the visitXXX method for instruction superclass will be invoked. So if instructions are added in the future, they will be automatically supported, if you handle on of their superclasses.

The optional second template argument specifies the type that instruction visitation functions should return. If you specify this, you *MUST* provide an implementation of visitInstruction though!.

Note that this class is specifically designed as a template to avoid virtual function call overhead. Defining and using an InstVisitor is just as efficient as having your own switch statement over the instruction opcode.

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst ExtractValueInst llvm::HANDLE_OTHER_INST	(	52	,
		InsertValue	,
		InsertValueInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst llvm::HANDLE_OTHER_INST	(	50	,
		ShuffleVector	,
		ShuffleVectorInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst llvm::HANDLE_OTHER_INST	(	48	,
		ExtractElement	,
		ExtractElementInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction llvm::HANDLE_OTHER_INST	(	46	,
		UserOp2	,
		Instruction
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst llvm::HANDLE_OTHER_INST	(	44	,
		Select	,
		SelectInst
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst llvm::HANDLE_OTHER_INST	(	42	,
		PHI	,
		PHINode
	)

Type Constraints

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst llvm::HANDLE_OTHER_INST	(	40	,
		ICmp	,
		ICmpInst
	)

Type Constraints

static char llvm::hexdigit

(

unsigned

X

)

[inline, static]

hexdigit - Return the (uppercase) hexadecimal character for the given number

• X (which should be less than 16).

Definition at line 28 of file StringExtras.h.

Referenced by PrintEscapedString(), and utohex_buffer().

uint32_t llvm::Hi_32

(

uint64_t

Value

)

[inline]

Hi_32 - This function returns the high 32 bits of a 64 bit value.

Definition at line 26 of file MathExtras.h.

Referenced by CountLeadingZeros_64().

bool llvm::HonorSignDependentRoundingFPMath

(

)

HonorSignDependentRoundingFPMath - Return true if the codegen must assume that the rounding mode of the FPU can change from its default.

Definition at line 213 of file TargetMachine.cpp.

References HonorSignDependentRoundingFPMathOption, and UnsafeFPMath.

Referenced by GetNegatedExpression(), and isNegatibleForFree().

template<class T>

idf_iterator<T> llvm::idf_begin

(

const T &

G

)

[inline]

Definition at line 202 of file DepthFirstIterator.h.

template<class T>

idf_iterator<T> llvm::idf_end

(

const T &

G

)

[inline]

Definition at line 208 of file DepthFirstIterator.h.

template<class T, class SetTy>

idf_ext_iterator<T, SetTy> llvm::idf_ext_begin	(	const T &	G,
		SetTy &	S
	)			[inline]

Definition at line 223 of file DepthFirstIterator.h.

template<class T, class SetTy>

idf_ext_iterator<T, SetTy> llvm::idf_ext_end	(	const T &	G,
		SetTy &	S
	)			[inline]

Definition at line 229 of file DepthFirstIterator.h.

void llvm::IncrementCounterInBlock	(	BasicBlock *	BB,
		unsigned	CounterNum,
		GlobalValue *	CounterArray
	)

Definition at line 100 of file ProfilingUtils.cpp.

References Add(), llvm::BinaryOperator::Create(), llvm::ConstantInt::get(), llvm::BasicBlock::getFirstNonPHI(), llvm::ConstantExpr::getGetElementPtr(), llvm::Constant::getNullValue(), Indices, InsertPos, and llvm::Type::Int32Ty.

bool llvm::InlineFunction	(	CallSite	CS,
		CallGraph *	CG = 0,
		const TargetData *	TD = 0
	)

Definition at line 195 of file InlineFunction.cpp.

References llvm::CallGraphNode::addCalledFunction(), llvm::PHINode::addIncoming(), AI, Align, llvm::CallSite::arg_begin(), llvm::CallSite::arg_size(), llvm::Function::back(), BB, llvm::BasicBlock::begin(), llvm::MachineBasicBlock::begin(), llvm::Function::begin(), llvm::Attribute::ByVal, Caller, CloneAndPruneFunctionInto(), llvm::ClonedCodeInfo::ContainsCalls, llvm::ClonedCodeInfo::ContainsDynamicAllocas, llvm::ClonedCodeInfo::ContainsUnwinds, llvm::PHINode::Create(), llvm::BranchInst::Create(), llvm::CallInst::Create(), llvm::CallSite::doesNotThrow(), E, llvm::MachineBasicBlock::end(), llvm::Function::end(), llvm::MachineBasicBlock::erase(), llvm::BasicBlock::eraseFromParent(), llvm::Instruction::eraseFromParent(), llvm::UndefValue::get(), llvm::ConstantInt::get(), llvm::AllocationInst::getArraySize(), llvm::Function::getBasicBlockList(), llvm::CallSite::getCalledFunction(), llvm::Intrinsic::getDeclaration(), llvm::Function::getEntryBlock(), llvm::Function::getGC(), llvm::BasicBlock::getInstList(), llvm::CallSite::getInstruction(), llvm::Value::getName(), llvm::Instruction::getOpcode(), llvm::CallGraph::getOrInsertFunction(), llvm::GlobalValue::getParent(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::TargetData::getPrefTypeAlignment(), llvm::ReturnInst::getReturnValue(), llvm::ConstantExpr::getSizeOf(), llvm::BasicBlock::getTerminator(), llvm::Value::getType(), llvm::TargetData::getTypeStoreSize(), llvm::PointerType::getUnqual(), HandleInlinedInvoke(), llvm::Function::hasGC(), II, llvm::Type::Int32Ty, llvm::Type::Int64Ty, llvm::Type::Int8Ty, M, llvm::Intrinsic::memcpy, PHI, R, llvm::Value::replaceAllUsesWith(), Returns, llvm::Function::setGC(), llvm::User::setOperand(), llvm::BasicBlock::splitBasicBlock(), llvm::Intrinsic::stackrestore, llvm::Intrinsic::stacksave, UpdateCallGraphAfterInlining(), and llvm::Value::use_empty().

bool llvm::InlineFunction	(	InvokeInst *	II,
		CallGraph *	CG = 0,
		const TargetData *	TD = 0
	)

Definition at line 32 of file InlineFunction.cpp.

References InlineFunction().

bool llvm::InlineFunction	(	CallInst *	C,
		CallGraph *	CG = 0,
		const TargetData *	TD = 0
	)

InlineFunction - This function inlines the called function into the basic block of the caller. This returns false if it is not possible to inline this call. The program is still in a well defined state if this occurs though.

Note that this only does one level of inlining. For example, if the instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now exists in the instruction stream. Similiarly this will inline a recursive function by one level.

If a non-null callgraph pointer is provided, these functions update the CallGraph to represent the program after inlining.

Definition at line 29 of file InlineFunction.cpp.

Referenced by InlineCallIfPossible(), InlineFunction(), and llvm::BasicInlinerImpl::inlineFunctions().

static void llvm::insert_adjnode	(	pbqp *	this_,
		int	u,
		adjnode *	adj_ptr
	)			[static]

Definition at line 235 of file PBQP.cpp.

References llvm::pbqp::adj_list, and llvm::adjnode::prev.

Referenced by insert_edge(), and reinsert_node().

static void llvm::insert_edge	(	pbqp *	this_,
		int	u,
		int	v,
		PBQPMatrix *	costs
	)			[static]

Definition at line 349 of file PBQP.cpp.

References alloc_adjnode(), and insert_adjnode().

Referenced by add_pbqp_edgecosts().

void llvm::InsertProfilingInitCall	(	Function *	MainFn,
		const char *	FnName,
		GlobalValue *	Array
	)

Definition at line 23 of file ProfilingUtils.cpp.

References AI, llvm::Function::arg_begin(), llvm::Function::arg_size(), llvm::BasicBlock::begin(), llvm::Function::begin(), llvm::CastInst::Create(), llvm::CallInst::Create(), Entry, llvm::ConstantInt::get(), llvm::ConstantPointerNull::get(), llvm::CastInst::getCastOpcode(), llvm::SequentialType::getElementType(), llvm::ConstantExpr::getGetElementPtr(), llvm::Constant::getNullValue(), llvm::Module::getOrInsertFunction(), llvm::GlobalValue::getParent(), llvm::Value::getType(), llvm::GlobalValue::getType(), llvm::PointerType::getUnqual(), InsertPos, llvm::Type::Int32Ty, llvm::Type::Int8Ty, M, opcode, and llvm::User::setOperand().

const_inst_iterator llvm::inst_begin

(

const Function &

F

)

[inline]

Definition at line 138 of file InstIterator.h.

inst_iterator llvm::inst_begin

(

Function &

F

)

[inline]

Definition at line 136 of file InstIterator.h.

const_inst_iterator llvm::inst_begin

(

const Function *

F

)

[inline]

Definition at line 130 of file InstIterator.h.

inst_iterator llvm::inst_begin

(

Function *

F

)

[inline]

Definition at line 128 of file InstIterator.h.

Referenced by llvm::ScalarEvolution::print(), and llvm::FindUsedTypes::runOnModule().

const_inst_iterator llvm::inst_end

(

const Function &

F

)

[inline]

Definition at line 141 of file InstIterator.h.

inst_iterator llvm::inst_end

(

Function &

F

)

[inline]

Definition at line 137 of file InstIterator.h.

const_inst_iterator llvm::inst_end

(

const Function *

F

)

[inline]

Definition at line 133 of file InstIterator.h.

inst_iterator llvm::inst_end

(

Function *

F

)

[inline]

Definition at line 129 of file InstIterator.h.

Referenced by llvm::constant_iterator::constant_iterator(), llvm::ScalarEvolution::print(), and llvm::FindUsedTypes::runOnModule().

interval_part_interval_iterator llvm::intervals_begin	(	IntervalPartition &	IP,
		bool	DeleteIntervals = true
	)			[inline]

Definition at line 248 of file IntervalIterator.h.

function_interval_iterator llvm::intervals_begin	(	Function *	F,
		bool	DeleteInts = true
	)			[inline]

Definition at line 239 of file IntervalIterator.h.

Referenced by llvm::IntervalPartition::IntervalPartition(), and llvm::IntervalPartition::runOnFunction().

interval_part_interval_iterator llvm::intervals_end

(

IntervalPartition &

IP

)

[inline]

Definition at line 252 of file IntervalIterator.h.

function_interval_iterator llvm::intervals_end

(

Function *

)

[inline]

Definition at line 243 of file IntervalIterator.h.

Referenced by llvm::IntervalPartition::IntervalPartition(), and llvm::IntervalPartition::runOnFunction().

template<class T>

ipo_iterator<T> llvm::ipo_begin	(	T	G,
		bool	Reverse = false
	)			[inline]

Definition at line 158 of file PostOrderIterator.h.

template<class T>

ipo_iterator<T> llvm::ipo_end

(

T

G

)

[inline]

Definition at line 163 of file PostOrderIterator.h.

template<class T, class SetType>

ipo_ext_iterator<T, SetType> llvm::ipo_ext_begin	(	T	G,
		SetType &	S
	)			[inline]

Definition at line 177 of file PostOrderIterator.h.

template<class T, class SetType>

ipo_ext_iterator<T, SetType> llvm::ipo_ext_end	(	T	G,
		SetType &	S
	)			[inline]

Definition at line 182 of file PostOrderIterator.h.

static int llvm::is_colorable	(	pbqp *	this_,
		int	x
	)			[static]

Definition at line 1097 of file PBQP.cpp.

References llvm::pbqp::adj_list, compute_tc_info(), llvm::PBQPVector::getLength(), isInf(), llvm::adjnode::tc_impact, and llvm::adjnode::tc_safe_regs.

Referenced by pop_colorablenode().

bool llvm::is_pbqp_optimal

(

pbqp *

this_

)

Definition at line 1387 of file PBQP.cpp.

References llvm::pbqp::optimal.

template<class X, class Y>

bool llvm::isa

(

const Y &

Val

)

[inline]

Definition at line 115 of file Casting.h.

template<typename To, typename From>

bool llvm::isa_impl

(

const From &

Val

)

[inline]

Definition at line 53 of file Casting.h.

template<>

bool llvm::isa_impl< Argument, Value >

(

const Value &

Val

)

[inline]

template<>

bool llvm::isa_impl< BasicBlock, Value >

(

const Value &

Val

)

[inline]

template<>

bool llvm::isa_impl< Constant, Value >

(

const Value &

Val

)

[inline]

template<>

bool llvm::isa_impl< Function, Value >

(

const Value &

Val

)

[inline]

template<>

bool llvm::isa_impl< GlobalAlias, Value >

(

const Value &

Val

)

[inline]

template<>

bool llvm::isa_impl< GlobalValue, Value >

(

const Value &

Val

)

[inline]

template<>

bool llvm::isa_impl< GlobalVariable, Value >

(

const Value &

Val

)

[inline]

template<>

bool llvm::isa_impl< InlineAsm, Value >

(

const Value &

Val

)

[inline]

template<>

bool llvm::isa_impl< Instruction, Value >

(

const Value &

Val

)

[inline]

template<>

bool llvm::isa_impl< PointerType, Type >

(

const Type &

Ty

)

[inline]

bool llvm::isAllocaPromotable

(

const AllocaInst *

AI

)

isAllocaPromotable - Return true if this alloca is legal for promotion. This is true if there are only loads and stores to the alloca...

isAllocaPromotable - Return true if this alloca is legal for promotion. This is true if there are only loads and stores to the alloca.

Definition at line 68 of file PromoteMemoryToRegister.cpp.

References LI, llvm::Value::use_begin(), and llvm::Value::use_end().

bool llvm::isCriticalEdge	(	const TerminatorInst *	TI,
		unsigned	SuccNum,
		bool	AllowIdenticalEdges = false
	)

isCriticalEdge - Return true if the specified edge is a critical edge. Critical edges are edges from a block with multiple successors to a block with multiple predecessors.

Definition at line 89 of file BreakCriticalEdges.cpp.

References Dest, E, llvm::TerminatorInst::getNumSuccessors(), llvm::TerminatorInst::getSuccessor(), pred_begin(), and pred_end().

Referenced by SplitCriticalEdge().

bool llvm::isCurrentDebugType

(

const char *

Type

)

Definition at line 59 of file Debug.cpp.

Referenced by getErrorOutputStream(), LowerSTORE(), and llvm::SPUTargetLowering::PerformDAGCombine().

bool llvm::isIdentifiedObject

(

const Value *

V

)

isIdentifiedObject - Return true if this pointer refers to a distinct and identifiable object. This returns true for: Global Variables and Functions Allocas and Mallocs ByVal and NoAlias Arguments NoAlias returns

Definition at line 226 of file AliasAnalysis.cpp.

References A, and isNoAliasCall().

Referenced by getUnderlyingObjectForInstr().

bool llvm::isInf

(

PBQPNum

n

)

Definition at line 77 of file PBQP.cpp.

Referenced by compute_tc_info(), is_colorable(), and normalize_matrix().

int llvm::IsInf

(

double

d

)

Definition at line 47 of file IsInf.cpp.

int llvm::IsInf

(

float

f

)

Platform-independent wrappers for the C99 isinf() function.

Definition at line 46 of file IsInf.cpp.

bool llvm::isInstructionTriviallyDead

(

Instruction *

I

)

isInstructionTriviallyDead - Return true if the result produced by the instruction is not used, and the instruction has no side effects.

Definition at line 159 of file Local.cpp.

References II, llvm::Instruction::mayWriteToMemory(), llvm::Intrinsic::stacksave, and llvm::Value::use_empty().

Referenced by AddReachableCodeToWorklist(), RecursivelyDeleteTriviallyDeadInstructions(), and UnrollLoop().

bool llvm::isInt16

(

int64_t

Value

)

[inline]

Definition at line 42 of file MathExtras.h.

Referenced by llvm::PPCRegisterInfo::eliminateCallFramePseudoInstr(), llvm::PPCRegisterInfo::eliminateFrameIndex(), llvm::PPCRegisterInfo::emitEpilogue(), llvm::PPCRegisterInfo::emitPrologue(), and llvm::PPCRegisterInfo::lowerDynamicAlloc().

bool llvm::isInt32

(

int64_t

Value

)

[inline]

Definition at line 48 of file MathExtras.h.

bool llvm::isInt8

(

int64_t

Value

)

[inline]

is?Type - these functions produce optimal testing for integer data types.

Definition at line 36 of file MathExtras.h.

bool llvm::isMask_32

(

uint32_t

Value

)

[inline]

isMask_32 - This function returns true if the argument is a sequence of ones starting at the least significant bit with the remainder zero (32 bit version). Ex. isMask_32(0x0000FFFFU) == true.

Definition at line 58 of file MathExtras.h.

Referenced by isShiftedMask_32().

bool llvm::isMask_64

(

uint64_t

Value

)

[inline]

isMask_64 - This function returns true if the argument is a sequence of ones starting at the least significant bit with the remainder zero (64 bit version).

Definition at line 65 of file MathExtras.h.

Referenced by isShiftedMask_64().

static bool llvm::isMem	(	const MachineInstr *	MI,
		unsigned	Op
	)			[inline, static]

Definition at line 252 of file X86InstrInfo.h.

References llvm::MachineInstr::getNumOperands(), llvm::MachineInstr::getOperand(), llvm::MachineOperand::isCPI(), llvm::MachineOperand::isFI(), llvm::MachineOperand::isGlobal(), llvm::MachineOperand::isImm(), llvm::MachineOperand::isJTI(), llvm::MachineOperand::isReg(), and isScale().

Referenced by llvm::X86IntelAsmPrinter::printMemReference(), and llvm::X86ATTAsmPrinter::printMemReference().

int llvm::IsNAN

(

double

d

)

Definition at line 32 of file IsNAN.cpp.

int llvm::IsNAN

(

float

f

)

Platform-independent wrappers for the C99 isnan() function.

Definition at line 31 of file IsNAN.cpp.

bool llvm::isNoAliasCall

(

const Value *

V

)

isNoAliasCall - Return true if this pointer is returned by a noalias function.

Definition at line 212 of file AliasAnalysis.cpp.

References llvm::Attribute::NoAlias.

Referenced by isIdentifiedObject(), and isNonEscapingLocalObject().

bool llvm::isPowerOf2_32

(

uint32_t

Value

)

[inline]

isPowerOf2_32 - This function returns true if the argument is a power of two > 0. Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.)

Definition at line 84 of file MathExtras.h.

Referenced by CollectBSwapParts(), llvm::Attribute::constructAlignmentFromInt(), llvm::SPURegisterInfo::determineFrameLayout(), llvm::PPCRegisterInfo::emitPrologue(), llvm::TargetLowering::getVectorTypeBreakdown(), isBytewiseValue(), llvm::ARMTargetLowering::isLegalAddressingMode(), llvm::IntegerType::isPowerOf2ByteWidth(), llvm::PPCTargetLowering::LowerAsmOperandForConstraint(), llvm::MachineMemOperand::MachineMemOperand(), llvm::MemSDNode::MemSDNode(), and llvm::X86TargetLowering::X86TargetLowering().

bool llvm::isPowerOf2_64

(

uint64_t

Value

)

[inline]

isPowerOf2_64 - This function returns true if the argument is a power of two > 0 (64 bit edition.)

Definition at line 90 of file MathExtras.h.

References L.

Referenced by llvm::TargetLowering::SimplifySetCC().

template<typename T>

bool llvm::isS10Constant

(

T

Value

)

[inline]

Predicate test for a signed 10-bit value.

Parameters:

Value

The input value to be tested

This predicate tests for a signed 10-bit value, returning the 10-bit value as a short if true.

Referenced by llvm::SPURegisterInfo::emitEpilogue(), llvm::SPURegisterInfo::emitPrologue(), llvm::SPU::get_vec_i10imm(), isI16IntS10Immediate(), isI32IntS10Immediate(), and isI64IntS10Immediate().

template<>

bool llvm::isS10Constant< int >

(

int

Value

)

[inline]

template<>

bool llvm::isS10Constant< int64_t >

(

int64_t

Value

)

[inline]

template<>

bool llvm::isS10Constant< short >

(

short

Value

)

[inline]

template<>

bool llvm::isS10Constant< uint32_t >

(

uint32_t

Value

)

[inline]

template<>

bool llvm::isS10Constant< uint64_t >

(

uint64_t

Value

)

[inline]

static bool llvm::isScale

(

const MachineOperand &

MO

)

[inline, static]

Definition at line 246 of file X86InstrInfo.h.

References llvm::MachineOperand::getImm(), and llvm::MachineOperand::isImm().

Referenced by isMem().

bool llvm::isShiftedMask_32

(

uint32_t

Value

)

[inline]

isShiftedMask_32 - This function returns true if the argument contains a sequence of ones with the remainder zero (32 bit version.) Ex. isShiftedMask_32(0x0000FF00U) == true.

Definition at line 72 of file MathExtras.h.

References isMask_32().

bool llvm::isShiftedMask_64

(

uint64_t

Value

)

[inline]

isShiftedMask_64 - This function returns true if the argument contains a sequence of ones with the remainder zero (64 bit version.)

Definition at line 78 of file MathExtras.h.

References isMask_64().

static bool llvm::isSignedComparison

(

PIC16CC::CondCodes

CC

)

[inline, static]

Definition at line 56 of file PIC16.h.

References llvm::PIC16CC::EQ, llvm::PIC16CC::GE, llvm::PIC16CC::GT, llvm::PIC16CC::LE, llvm::PIC16CC::LT, llvm::PIC16CC::NE, llvm::PIC16CC::UGE, llvm::PIC16CC::UGT, llvm::PIC16CC::ULE, and llvm::PIC16CC::ULT.

Referenced by llvm::PIC16TargetLowering::getPIC16Cmp().

bool llvm::isU10Constant

(

uint64_t

Value

)

[inline]

Definition at line 89 of file SPU.h.

Referenced by isI16IntU10Immediate(), and isI32IntU10Immediate().

bool llvm::isU10Constant

(

int64_t

Value

)

[inline]

Definition at line 85 of file SPU.h.

bool llvm::isU10Constant

(

uint32_t

Value

)

[inline]

Definition at line 81 of file SPU.h.

bool llvm::isU10Constant

(

int

Value

)

[inline]

Definition at line 77 of file SPU.h.

bool llvm::isU10Constant

(

short

Value

)

[inline]

Predicate test for an unsigned 10-bit value.

Parameters:

Value

The input value to be tested

This predicate tests for an unsigned 10-bit value, returning the 10-bit value as a short if true.

Definition at line 73 of file SPU.h.

bool llvm::isUInt16

(

int64_t

Value

)

[inline]

Definition at line 45 of file MathExtras.h.

bool llvm::isUInt32

(

int64_t

Value

)

[inline]

Definition at line 51 of file MathExtras.h.

bool llvm::isUInt8

(

int64_t

Value

)

[inline]

Definition at line 39 of file MathExtras.h.

static std::string llvm::itohexstr

(

int64_t

X

)

[inline, static]

Definition at line 106 of file StringExtras.h.

References utohexstr().

static std::string llvm::itostr

(

int64_t

X

)

[inline, static]

Definition at line 99 of file StringExtras.h.

References utostr().

Referenced by llvm::Debugger::contProgram(), llvm::Debugger::finishProgram(), llvm::TargetData::getStringRepresentation(), llvm::Debugger::nextProgram(), and llvm::Debugger::stepProgram().

template<class GraphT>

void llvm::Link	(	DominatorTreeBase< typename GraphT::NodeType > &	DT,
		unsigned	DFSNumV,
		typename GraphT::NodeType *	W,
		typename DominatorTreeBase< typename GraphT::NodeType >::InfoRec &	WInfo
	)			[inline]

Definition at line 181 of file DominatorInternals.h.

References llvm::DominatorTreeBase< NodeT >::InfoRec::Child, llvm::DominatorTreeBase< NodeT >::Info, llvm::DominatorTreeBase< NodeT >::InfoRec::Size, std::swap(), and V.

bool llvm::LinkDynamicObject	(	const char *	filename,
		std::string *	ErrorMessage
	)

LinkDynamicObject - Load the named file as a dynamic library and link it with the currently running process. Returns false on success, true if there is an error (and sets ErrorMessage if it is not NULL). Analogous to dlopen().

void llvm::LinkInInterpreter

(

)

Definition at line 33 of file Interpreter.cpp.

void llvm::LinkInJIT

(

)

Definition at line 63 of file JIT.cpp.

void llvm::linkOcamlGC

(

)

Creates an ocaml-compatible garbage collector.

FIXME: Collector instances are not useful on their own. These no longer serve any purpose except to link in the plugins.

Definition at line 33 of file OcamlGC.cpp.

void llvm::linkOcamlGCPrinter

(

)

Creates an ocaml-compatible metadata printer.

Definition at line 42 of file OcamlGCPrinter.cpp.

void llvm::linkShadowStackGC

(

)

Creates a shadow stack garbage collector. This collector requires no code generator support.

Definition at line 180 of file ShadowStackGC.cpp.

void llvm::llvm_shutdown

(

)

llvm_shutdown - Deallocate and destroy all ManagedStatic variables.

Definition at line 49 of file ManagedStatic.cpp.

References llvm::ManagedStaticBase::destroy().

Referenced by llvm::llvm_shutdown_obj::~llvm_shutdown_obj().

uint32_t llvm::Lo_32

(

uint64_t

Value

)

[inline]

Lo_32 - This function returns the low 32 bits of a 64 bit value.

Definition at line 31 of file MathExtras.h.

Referenced by CountLeadingZeros_64().

static cl::opt<PluginLoader, false, cl::parser<std::string> > llvm::LoadOpt	(	"load"	,
		cl::ZeroOrMore	,
		cl::	value_desc"pluginfilename",
		cl::	desc"Load the specified plugin"
	)			[static]

unsigned llvm::Log2_32

(

uint32_t

Value

)

[inline]

Log2_32 - This function returns the floor log base 2 of the specified value, -1 if the value is zero. (32 bit edition.) Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1, Log2_32(6) == 2

Definition at line 307 of file MathExtras.h.

References CountLeadingZeros_32().

Referenced by ComputeMaskedBits(), llvm::SelectionDAG::ComputeMaskedBits(), ConstantFoldBinaryInstruction(), llvm::Attribute::constructAlignmentFromInt(), llvm::AsmPrinter::EmitAlignment(), llvm::AsmPrinter::EmitJumpTableInfo(), llvm::PPCRegisterInfo::emitPrologue(), llvm::AsmPrinter::EmitSpecialLLVMGlobal(), encodeMemSDNodeFlags(), FindAssocWidenVecType(), FindWidenVecType(), getCopyFromParts(), getCopyToParts(), llvm::TargetData::getPreferredAlignmentLog(), llvm::TargetData::getPreferredTypeAlignmentShift(), PerformBTCombine(), llvm::AsmPrinter::printBasicBlockLabel(), llvm::StoreInst::setAlignment(), llvm::LoadInst::setAlignment(), llvm::AllocationInst::setAlignment(), llvm::ISD::ArgFlagsTy::setByValAlign(), llvm::ISD::ArgFlagsTy::setOrigAlign(), llvm::TargetLowering::SimplifySetCC(), llvm::MachOCodeEmitter::startFunction(), WriteInstruction(), and WriteModuleInfo().

unsigned llvm::Log2_32_Ceil

(

uint32_t

Value

)

[inline]

Log2_32_Ceil - This function returns the ceil log base 2 of the specified value, 32 if the value is zero. (32 bit edition). Ex. Log2_32_Ceil(32) == 5, Log2_32_Ceil(1) == 0, Log2_32_Ceil(6) == 3

Definition at line 320 of file MathExtras.h.

References CountLeadingZeros_32().

Referenced by BinomialCoefficient(), llvm::MVT::getPow2VectorType(), llvm::MVT::getRoundIntegerType(), WriteBlockInfo(), WriteConstants(), WriteModuleInfo(), WriteTypeSymbolTable(), and WriteTypeTable().

unsigned llvm::Log2_64

(

uint64_t

Value

)

[inline]

Log2_64 - This function returns the floor log base 2 of the specified value, -1 if the value is zero. (64 bit edition.)

Definition at line 313 of file MathExtras.h.

References CountLeadingZeros_64().

Referenced by llvm::TargetLowering::SimplifySetCC().

unsigned llvm::Log2_64_Ceil

(

uint64_t

Value

)

[inline]

Log2_64 - This function returns the ceil log base 2 of the specified value, 64 if the value is zero. (64 bit edition.)

Definition at line 326 of file MathExtras.h.

References CountLeadingZeros_64().

static std::string llvm::LowercaseString

(

const std::string &

S

)

[inline, static]

Definition at line 126 of file StringExtras.h.

Referenced by llvm::SubtargetFeatures::AddFeature(), llvm::SubtargetFeatures::setCPU(), and llvm::SubtargetFeatures::setString().

template<typename T>

std::vector<T> llvm::make_vector	(	T	A,
			...
	)			[inline]

make_vector - Helper function which is useful for building temporary vectors to pass into type construction of CallInst ctors. This turns a null terminated list of pointers (or other value types) into a real live vector.

Definition at line 28 of file VectorExtras.h.

References T, and Val.

template<class ItTy, class FuncTy>

mapped_iterator<ItTy, FuncTy> llvm::map_iterator	(	const ItTy &	I,
		FuncTy	F
	)			[inline]

Definition at line 122 of file STLExtras.h.

Referenced by llvm::GraphTraits< CallGraphNode * >::child_begin(), llvm::GraphTraits< CallGraphNode * >::child_end(), llvm::GraphTraits< CallGraph * >::nodes_begin(), and llvm::GraphTraits< CallGraph * >::nodes_end().

Value * llvm::MapValue	(	const Value *	V,
		ValueMapTy &	VM
	)

Definition at line 21 of file ValueMapper.cpp.

References llvm::CallingConv::C, CA, CP, llvm::ConstantVector::get(), llvm::ConstantStruct::get(), llvm::ConstantArray::get(), llvm::User::getNumOperands(), llvm::User::op_begin(), llvm::User::op_end(), and Values.

Referenced by CloneAndPruneFunctionInto(), CloneModule(), and RemapInstruction().

bool llvm::MaskedValueIsZero	(	Value *	V,
		const APInt &	Mask,
		TargetData *	TD = 0,
		unsigned	Depth = 0
	)

MaskedValueIsZero - Return true if 'V & Mask' is known to be zero. We use this predicate to simplify operations downstream. Mask is known to be zero for bits that V cannot have.

MaskedValueIsZero - Return true if 'V & Mask' is known to be zero. We use this predicate to simplify operations downstream. Mask is known to be zero for bits that V cannot have.

Definition at line 547 of file ValueTracking.cpp.

References ComputeMaskedBits(), and llvm::APInt::getBitWidth().

void llvm::MergeBasicBlockIntoOnlyPred

(

BasicBlock *

DestBB

)

MergeBasicBlockIntoOnlyPred - BB is a block with one predecessor and its predecessor is known to have one successor (BB!). Eliminate the edge between them, moving the instructions in the predecessor into BB. This deletes the predecessor block.

MergeBasicBlockIntoOnlyPred - DestBB is a block with one predecessor and its predecessor is known to have one successor (DestBB!). Eliminate the edge between them, moving the instructions in the predecessor into DestBB and deleting the predecessor block.

Definition at line 228 of file Local.cpp.

References llvm::BasicBlock::begin(), llvm::BasicBlock::eraseFromParent(), llvm::Instruction::eraseFromParent(), llvm::UndefValue::get(), llvm::BasicBlock::getInstList(), llvm::BasicBlock::getSinglePredecessor(), llvm::BasicBlock::getTerminator(), and llvm::Value::replaceAllUsesWith().

bool llvm::MergeBlockIntoPredecessor	(	BasicBlock *	BB,
		Pass *	P = 0
	)

MergeBlockIntoPredecessor - Attempts to merge a block into its predecessor, if possible. The return value indicates success or failure.

Definition at line 77 of file BasicBlockUtils.cpp.

References llvm::DomTreeNodeBase< NodeT >::begin(), llvm::BasicBlock::begin(), llvm::MachineDominatorTree::changeImmediateDominator(), Children, DE, DT, llvm::DomTreeNodeBase< NodeT >::end(), llvm::BasicBlock::end(), llvm::BasicBlock::eraseFromParent(), llvm::MachineDominatorTree::eraseNode(), llvm::BasicBlock::front(), llvm::Pass::getAnalysisIfAvailable(), llvm::BasicBlock::getInstList(), llvm::MachineDominatorTree::getNode(), llvm::BasicBlock::getTerminator(), llvm::Value::hasName(), PI, pred_begin(), pred_end(), llvm::Value::replaceAllUsesWith(), SE, succ_begin(), succ_end(), and llvm::Value::takeName().

Referenced by SimplifyCFG().

static uint64_t llvm::MinAlign	(	uint64_t	A,
		uint64_t	B
	)			[inline, static]

MinAlign - A and B are either alignments or offsets. Return the minimum alignment that may be assumed after adding the two together.

Definition at line 399 of file MathExtras.h.

Referenced by ExpandUnalignedLoad(), ExpandUnalignedStore(), InferAlignment(), PerformSTORECombine(), llvm::TargetLowering::SimplifySetCC(), and SRAGlobal().

template<typename ItTy>

ItTy llvm::next

(

ItTy

it

)

[inline]

Definition at line 143 of file STLExtras.h.

Referenced by calcTypeName(), FixTail(), mergeBaseUpdateLoadStore(), mergeBaseUpdateLSMultiple(), and SelectRoot().

template<typename ItTy, typename Dist>

ItTy llvm::next	(	ItTy	it,
		Dist	n
	)			[inline]

Definition at line 136 of file STLExtras.h.

Referenced by llvm::X86InstrInfo::AnalyzeBranch(), BBHasFallthrough(), llvm::MachineBasicBlock::CorrectExtraCFGEdges(), disconnect_trivialnode(), eliminate_independent_edges(), llvm::ARMRegisterInfo::eliminateFrameIndex(), llvm::AsmPrinter::EmitConstantPool(), llvm::X86RegisterInfo::emitPrologue(), llvm::iplist< llvm::Instruction >::erase(), llvm::iplist< llvm::Instruction >::erase_if(), llvm::FastISel::FastEmitBranch(), llvm::RegScavenger::forward(), llvm::MachineInstr::hasOneMemOperand(), llvm::SDNode::hasOneUse(), llvm::MachineBasicBlock::isLayoutSuccessor(), llvm::iplist< llvm::Instruction >::merge(), mergeSPUpdates(), mergeSPUpdatesDown(), llvm::LiveInterval::removeRange(), and llvm::BasicBlock::splitBasicBlock().

static uint64_t llvm::NextPowerOf2

(

uint64_t

A

)

[inline, static]

NextPowerOf2 - Returns the next power of two (in 64-bits) that is strictly greater than A. Returns zero on overflow.

Definition at line 406 of file MathExtras.h.

static bool llvm::normalize_matrix	(	PBQPMatrix *	m,
		PBQPVector *	u,
		PBQPVector *	v
	)			[static]

Definition at line 724 of file PBQP.cpp.

References c, llvm::PBQPMatrix::getColMin(), llvm::PBQPMatrix::getCols(), llvm::PBQPVector::getLength(), llvm::PBQPMatrix::getRowMin(), llvm::PBQPMatrix::getRows(), isInf(), llvm::PBQPMatrix::isZero(), llvm::PBQPMatrix::setCol(), llvm::PBQPMatrix::setRow(), llvm::PBQPMatrix::subFromCol(), and llvm::PBQPMatrix::subFromRow().

Referenced by simplify_edge().

template<class C>

void llvm::object_deleter

(

void *

Ptr

)

[inline]

object_deleter - Helper method for ManagedStatic.

Definition at line 22 of file ManagedStatic.h.

References llvm::CallingConv::C.

BitVector llvm::operator &	(	const BitVector &	LHS,
		const BitVector &	RHS
	)			[inline]

Definition at line 389 of file BitVector.h.

template<unsigned ElementSize>

bool llvm::operator &=	(	SparseBitVector< ElementSize > &	LHS,
		const SparseBitVector< ElementSize > *	RHS
	)			[inline]

Definition at line 837 of file SparseBitVector.h.

template<unsigned ElementSize>

bool llvm::operator &=	(	SparseBitVector< ElementSize > *	LHS,
		const SparseBitVector< ElementSize > &	RHS
	)			[inline]

Definition at line 831 of file SparseBitVector.h.

template<class T, class U>

bool llvm::operator!=	(	T *	A,
		const IntrusiveRefCntPtr< U > &	B
	)			[inline]

Definition at line 204 of file IntrusiveRefCntPtr.h.

References llvm::IntrusiveRefCntPtr< T >::getPtr().

template<class T, class U>

bool llvm::operator!=	(	const IntrusiveRefCntPtr< T > &	A,
		U *	B
	)			[inline]

Definition at line 190 of file IntrusiveRefCntPtr.h.

References llvm::IntrusiveRefCntPtr< T >::getPtr().

template<class T, class U>

bool llvm::operator!=	(	const IntrusiveRefCntPtr< T > &	A,
		const IntrusiveRefCntPtr< U > &	B
	)			[inline]

Definition at line 176 of file IntrusiveRefCntPtr.h.

References llvm::IntrusiveRefCntPtr< T >::getPtr().

template<typename T>

bool llvm::operator!=	(	T *	LHS,
		const ilist_iterator< T > &	RHS
	)			[inline]

Definition at line 219 of file ilist.h.

References llvm::ilist_iterator< NodeTy >::getNodePtrUnchecked().

template<typename T>

bool llvm::operator!=	(	const T *	LHS,
		const ilist_iterator< const T > &	RHS
	)			[inline]

Definition at line 211 of file ilist.h.

References llvm::ilist_iterator< NodeTy >::getNodePtrUnchecked().

bool llvm::operator!=	(	uint64_t	V1,
		const APInt &	V2
	)			[inline]

Definition at line 1384 of file APInt.h.

template<class _Iterator, class Func>

mapped_iterator<_Iterator, Func> llvm::operator+	(	typename mapped_iterator< _Iterator, Func >::difference_type	N,
		const mapped_iterator< _Iterator, Func > &	X
	)			[inline]

Definition at line 112 of file STLExtras.h.

References llvm::mapped_iterator< RootIt, UnaryFunc >::getCurrent(), and llvm::mapped_iterator< RootIt, UnaryFunc >::getFunc().

template<typename T>

void llvm::operator+	(	ilist_iterator< T >	,
		int
	)			[inline]

template<typename T>

void llvm::operator+	(	int	,
		ilist_iterator< T >
	)			[inline]

template<typename T>

void llvm::operator-	(	ilist_iterator< T >	,
		int
	)			[inline]

template<typename T>

void llvm::operator-	(	int	,
		ilist_iterator< T >
	)			[inline]

bool llvm::operator<	(	const IdxMBBPair &	IM,
		unsigned	V
	)			[inline]

Definition at line 48 of file LiveIntervalAnalysis.h.

bool llvm::operator<	(	unsigned	V,
		const IdxMBBPair &	IM
	)			[inline]

Definition at line 44 of file LiveIntervalAnalysis.h.

bool llvm::operator<	(	const LiveRange &	LR,
		unsigned	V
	)			[inline]

Definition at line 96 of file LiveInterval.h.

References llvm::LiveRange::start.

bool llvm::operator<	(	unsigned	V,
		const LiveRange &	LR
	)			[inline]

Definition at line 92 of file LiveInterval.h.

References llvm::LiveRange::start.

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const Type *	T
	)

Definition at line 1524 of file Type.cpp.

References llvm::Type::print().

static std::ostream& llvm::operator<<	(	std::ostream &	o,
		const std::set< BasicBlock * > &	BBs
	)			[static]

Definition at line 31 of file Dominators.cpp.

References E, and WriteAsOperand().

raw_ostream& llvm::operator<<	(	raw_ostream &	O,
		const ARMConstantPoolValue &	V
	)			[inline]

Definition at line 85 of file ARMConstantPoolValue.h.

References llvm::ARMConstantPoolValue::print().

std::ostream& llvm::operator<<	(	std::ostream &	O,
		const ARMConstantPoolValue &	V
	)			[inline]

Definition at line 80 of file ARMConstantPoolValue.h.

References llvm::ARMConstantPoolValue::print().

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const VirtRegMap &	VRM
	)			[inline]

Definition at line 429 of file VirtRegMap.h.

References llvm::VirtRegMap::print().

std::ostream* llvm::operator<<	(	std::ostream *	OS,
		const VirtRegMap &	VRM
	)			[inline]

Definition at line 425 of file VirtRegMap.h.

References llvm::VirtRegMap::print().

raw_ostream& llvm::operator<<	(	raw_ostream &	OS,
		const Value &	V
	)			[inline]

Definition at line 262 of file Value.h.

References llvm::Value::print().

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const Value &	V
	)			[inline]

Definition at line 258 of file Value.h.

References llvm::Value::print().

raw_ostream& llvm::operator<<	(	raw_ostream &	OS,
		const Type &	T
	)

std::ostream & llvm::operator<<	(	std::ostream &	OS,
		const Type &	T
	)

Definition at line 1532 of file Type.cpp.

References llvm::Type::print().

std::ostream& llvm::operator<<	(	std::ostream &	strm,
		const sys::PathWithStatus &	aPath
	)			[inline]

Definition at line 709 of file Path.h.

std::ostream & llvm::operator<<	(	std::ostream &	strm,
		const sys::Path &	aPath
	)

Definition at line 39 of file Path.cpp.

References llvm::sys::Path::toString().

raw_ostream& llvm::operator<<	(	raw_ostream &	OS,
		const ConstantRange &	CR
	)			[inline]

Definition at line 188 of file ConstantRange.h.

References llvm::ConstantRange::print().

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const Pass &	P
	)			[inline]

Definition at line 208 of file Pass.h.

References llvm::Pass::print().

raw_ostream& llvm::operator<<	(	raw_ostream &	O,
		const Module &	M
	)			[inline]

Definition at line 403 of file Module.h.

References llvm::Module::print().

std::ostream& llvm::operator<<	(	std::ostream &	O,
		const Module &	M
	)			[inline]

An iostream inserter for modules.

Definition at line 399 of file Module.h.

References llvm::Module::print().

raw_ostream& llvm::operator<<	(	raw_ostream &	OS,
		const MachineOperand &	MO
	)			[inline]

Definition at line 449 of file MachineOperand.h.

References llvm::MachineOperand::print().

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const MachineOperand &	MO
	)			[inline]

Definition at line 444 of file MachineOperand.h.

References llvm::MachineOperand::print().

raw_ostream& llvm::operator<<	(	raw_ostream &	OS,
		const MachineInstr &	MI
	)			[inline]

Definition at line 362 of file MachineInstr.h.

References llvm::MachineInstr::print().

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const MachineInstr &	MI
	)			[inline]

Definition at line 357 of file MachineInstr.h.

References llvm::MachineInstr::print().

raw_ostream& llvm::operator<<	(	raw_ostream &	OS,
		const MachineConstantPoolValue &	V
	)			[inline]

Definition at line 53 of file MachineConstantPool.h.

References llvm::MachineConstantPoolValue::print().

std::ostream & llvm::operator<<	(	std::ostream &	OS,
		const MachineBasicBlock &	MBB
	)

Definition at line 34 of file MachineBasicBlock.cpp.

References llvm::MachineBasicBlock::print().

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const LiveInterval &	LI
	)			[inline]

Definition at line 428 of file LiveInterval.h.

References llvm::LiveInterval::print().

std::ostream & llvm::operator<<	(	std::ostream &	os,
		const LiveRange &	LR
	)

Definition at line 683 of file LiveInterval.cpp.

References llvm::LiveRange::end, llvm::VNInfo::id, llvm::LiveRange::start, and llvm::LiveRange::valno.

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const SCEV &	S
	)			[inline]

Definition at line 105 of file ScalarEvolution.h.

References llvm::SCEV::print().

template<class NodeT>

static std::ostream& llvm::operator<<	(	std::ostream &	o,
		const DomTreeNodeBase< NodeT > *	Node
	)			[inline, static]

Definition at line 164 of file Dominators.h.

References llvm::DomTreeNodeBase< NodeT >::getBlock(), llvm::DomTreeNodeBase< NodeT >::getDFSNumIn(), llvm::DomTreeNodeBase< NodeT >::getDFSNumOut(), and WriteAsOperand().

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const AliasSetTracker &	AST
	)			[inline]

Definition at line 384 of file AliasSetTracker.h.

References llvm::AliasSetTracker::print().

std::ostream& llvm::operator<<	(	std::ostream &	OS,
		const AliasSet &	AS
	)			[inline]

Definition at line 245 of file AliasSetTracker.h.

References llvm::AliasSet::print().

raw_ostream& llvm::operator<<	(	raw_ostream &	OS,
		const APSInt &	I
	)			[inline]

Definition at line 256 of file APSInt.h.

References llvm::APSInt::isSigned(), and llvm::APInt::print().

raw_ostream& llvm::operator<<	(	raw_ostream &	OS,
		const APInt &	I
	)			[inline]

Definition at line 1388 of file APInt.h.

References llvm::APInt::print().

template<class T, class U>

bool llvm::operator==	(	T *	A,
		const IntrusiveRefCntPtr< U > &	B
	)			[inline]

Definition at line 197 of file IntrusiveRefCntPtr.h.

References llvm::IntrusiveRefCntPtr< T >::getPtr().

template<class T, class U>

bool llvm::operator==	(	const IntrusiveRefCntPtr< T > &	A,
		U *	B
	)			[inline]

Definition at line 183 of file IntrusiveRefCntPtr.h.

References llvm::IntrusiveRefCntPtr< T >::getPtr().

template<class T, class U>

bool llvm::operator==	(	const IntrusiveRefCntPtr< T > &	A,
		const IntrusiveRefCntPtr< U > &	B
	)			[inline]

Definition at line 169 of file IntrusiveRefCntPtr.h.

References llvm::IntrusiveRefCntPtr< T >::getPtr().

template<typename T>

bool llvm::operator==	(	T *	LHS,
		const ilist_iterator< T > &	RHS
	)			[inline]

Definition at line 223 of file ilist.h.

References llvm::ilist_iterator< NodeTy >::getNodePtrUnchecked().

template<typename T>

bool llvm::operator==	(	const T *	LHS,
		const ilist_iterator< const T > &	RHS
	)			[inline]

Definition at line 215 of file ilist.h.

References llvm::ilist_iterator< NodeTy >::getNodePtrUnchecked().

bool llvm::operator==	(	uint64_t	V1,
		const APInt &	V2
	)			[inline]

Definition at line 1380 of file APInt.h.

BitVector llvm::operator^	(	const BitVector &	LHS,
		const BitVector &	RHS
	)			[inline]

Definition at line 401 of file BitVector.h.

BitVector llvm::operator|	(	const BitVector &	LHS,
		const BitVector &	RHS
	)			[inline]

Definition at line 395 of file BitVector.h.

template<unsigned ElementSize>

bool llvm::operator|=	(	SparseBitVector< ElementSize > *	LHS,
		const SparseBitVector< ElementSize > &	RHS
	)			[inline]

Definition at line 825 of file SparseBitVector.h.

template<unsigned ElementSize>

bool llvm::operator|=	(	SparseBitVector< ElementSize > &	LHS,
		const SparseBitVector< ElementSize > *	RHS
	)			[inline]

Definition at line 819 of file SparseBitVector.h.

raw_ostream & llvm::outs

(

)

outs() - This returns a reference to a raw_ostream for standard output. Use it like: outs() << "foo" << "bar";

Definition at line 277 of file raw_ostream.cpp.

Referenced by WriteBitcodeToFile().

Module * llvm::ParseAssemblyFile	(	const std::string &	Filename,
		ParseError &	Error
	)

Parse LLVM Assembly from a file.

This function is the main interface to the LLVM Assembly Parser. It parses an ASCII file that (presumably) contains LLVM Assembly code. It returns a Module (intermediate representation) with the corresponding features. Note that this does not verify that the generated Module is valid, so you should run the verifier after parsing the file to check that it is okay.

Parameters:

Filename	The name of the file to parse
Error	If not null, an object to return errors in.

Definition at line 23 of file Parser.cpp.

References F, llvm::OwningPtr< T >::get(), llvm::MemoryBuffer::getFileOrSTDIN(), M, llvm::ParseError::setError(), llvm::ParseError::setFilename(), and llvm::OwningPtr< T >::take().

Module * llvm::ParseAssemblyString	(	const char *	AsmString,
		Module *	M,
		ParseError &	Error
	)

Parse LLVM Assembly from a string.

The function is a secondary interface to the LLVM Assembly Parser. It parses an ASCII string that (presumably) contains LLVM Assembly code. It returns a Module (intermediate representation) with the corresponding features. Note that this does not verify that the generated Module is valid, so you should run the verifier after parsing the file to check that it is okay.

Parameters:

AsmString	The string containing assembly
M	A module to add the assembly too.
Error	If not null, an object to return errors in.

Definition at line 40 of file Parser.cpp.

References F, llvm::OwningPtr< T >::get(), llvm::MemoryBuffer::getMemBuffer(), llvm::ParseError::setFilename(), and llvm::OwningPtr< T >::take().

Module * llvm::ParseBitcodeFile	(	MemoryBuffer *	Buffer,
		std::string *	ErrMsg = 0
	)

ParseBitcodeFile - Read the specified bitcode file, returning the module. If an error occurs, this returns null and fills in *ErrMsg if it is non-null. This method *never* takes ownership of Buffer.

ParseBitcodeFile - Read the specified bitcode file, returning the module. If an error occurs, return null and fill in *ErrMsg if non-null.

Definition at line 2094 of file BitcodeReader.cpp.

References getBitcodeModuleProvider(), M, llvm::BitcodeReader::materializeModule(), R, llvm::BitcodeReader::releaseMemoryBuffer(), and llvm::BitcodeReader::releaseModule().

Referenced by llvm::Archive::getAllModules(), getMaterializedModuleProvider(), llvm::Archive::isBitcodeArchive(), llvm::Linker::LinkInFile(), and LLVMParseBitcode().

static PBQPMatrix* llvm::pbqp_get_costmatrix	(	pbqp *	this_,
		int	u,
		int	v
	)			[static]

Definition at line 439 of file PBQP.cpp.

References llvm::adjnode::costs, find_adjnode(), and llvm::PBQPMatrix::transpose().

Referenced by apply_RI(), apply_RII(), compute_tc_info(), determine_solution(), and disconnect_trivialnode().

static void llvm::pbqp_remove_bucket	(	pbqp *	this_,
		bucketnode *	bucket
	)			[static]

Definition at line 483 of file PBQP.cpp.

References llvm::pbqp::bucket_list, llvm::pbqp::bucket_ptr, llvm::pbqp::node_deg, llvm::bucketnode::prev, llvm::bucketnode::succ, and llvm::bucketnode::u.

Referenced by pop_colorablenode(), pop_node(), and reorder_node().

static const char* llvm::PIC16CondCodeToString

(

PIC16CC::CondCodes

CC

)

[inline, static]

Definition at line 42 of file PIC16.h.

References llvm::PIC16CC::EQ, llvm::PIC16CC::GE, llvm::PIC16CC::GT, llvm::PIC16CC::LE, llvm::PIC16CC::LT, llvm::PIC16CC::NE, llvm::PIC16CC::UGT, and llvm::PIC16CC::ULT.

template<class T>

po_iterator<T> llvm::po_begin

(

T

G

)

[inline]

Definition at line 127 of file PostOrderIterator.h.

template<class T>

po_iterator<T> llvm::po_end

(

T

G

)

[inline]

Definition at line 129 of file PostOrderIterator.h.

template<class T, class SetType>

po_ext_iterator<T, SetType> llvm::po_ext_begin	(	T	G,
		SetType &	S
	)			[inline]

Definition at line 139 of file PostOrderIterator.h.

template<class T, class SetType>

po_ext_iterator<T, SetType> llvm::po_ext_end	(	T	G,
		SetType &	S
	)			[inline]

Definition at line 144 of file PostOrderIterator.h.

bool llvm::PointerMayBeCaptured	(	const Value *	V,
		bool	ReturnCaptures
	)

PointerMayBeCaptured - Return true if this pointer value may be captured by the enclosing function (which is required to exist). This routine can be expensive, so consider caching the results. The boolean ReturnCaptures specifies whether returning the value (or part of it) from the function counts as capturing it or not.

PointerMayBeCaptured - Return true if this pointer value may be captured by the enclosing function (which is required to exist). This routine can be expensive, so consider caching the results. The boolean ReturnCaptures specifies whether returning the value (or part of it) from the function counts as capturing it or not.

Definition at line 32 of file CaptureTracking.cpp.

References A, llvm::CallSite::arg_begin(), llvm::CallSite::arg_end(), BitCast, Call, E, llvm::SmallVectorImpl< T >::empty(), llvm::CallSite::get(), llvm::Use::get(), llvm::Instruction::getOpcode(), llvm::User::getOperand(), llvm::Value::getType(), llvm::Use::getUser(), llvm::SmallSet< T, N >::insert(), Load, llvm::Attribute::NoCapture, llvm::CallSite::onlyReadsMemory(), llvm::CallSite::paramHasAttr(), PHI, llvm::SmallVectorImpl< T >::pop_back_val(), llvm::SmallVectorImpl< T >::push_back(), llvm::MipsISD::Ret, llvm::SPII::Store, llvm::Value::use_begin(), llvm::Value::use_end(), Visited, llvm::Type::VoidTy, and Worklist.

Referenced by isNonEscapingLocalObject().

int llvm::pop_colorablenode

(

pbqp *

this_

)

Definition at line 1158 of file PBQP.cpp.

References llvm::pbqp::bucket_list, is_colorable(), llvm::pbqp::max_deg, llvm::pbqp::node_costs, llvm::pbqp::num_rn_special, pbqp_remove_bucket(), and llvm::bucketnode::u.

Referenced by reduce_pbqp().

static int llvm::pop_node	(	pbqp *	this_,
		int	deg
	)			[static]

Definition at line 515 of file PBQP.cpp.

References llvm::pbqp::bucket_list, pbqp_remove_bucket(), and llvm::bucketnode::u.

Referenced by determine_trivialsolution(), and reduce_pbqp().

pred_const_iterator llvm::pred_begin

(

const BasicBlock *

BB

)

[inline]

Definition at line 73 of file CFG.h.

Referenced by CanPropagatePredecessorsForPHIs(), FoldBranchToCommonDest(), FoldTwoEntryPHINode(), FoldValueComparisonIntoPredecessors(), GetIfCondition(), isValueEqualityComparison(), SimplifyCondBranchToCondBranch(), and TryToSimplifyUncondBranchFromEmptyBlock().

pred_iterator llvm::pred_begin

(

BasicBlock *

BB

)

[inline]

Definition at line 72 of file CFG.h.

Interval::pred_iterator llvm::pred_begin

(

Interval *

I

)

[inline]

pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the pred_* functions, and *pred_iterator.

Definition at line 118 of file Interval.h.

References llvm::Interval::Predecessors.

Referenced by AddBlockAndPredsToSet(), llvm::GraphTraits< Inverse< Interval * > >::child_begin(), llvm::GraphTraits< Inverse< const BasicBlock * > >::child_begin(), llvm::GraphTraits< Inverse< BasicBlock * > >::child_begin(), CloneAndPruneFunctionInto(), DeleteDeadBlock(), FindObviousSharedDomOf(), llvm::ProfileInfo::getExecutionCount(), llvm::PredIteratorCache::GetPreds(), llvm::BasicBlock::getSinglePredecessor(), llvm::BasicBlock::getUniquePredecessor(), isCriticalEdge(), llvm::Interval::isLoop(), IsValueFullyAvailableInBlock(), MarkBlocksLiveIn(), MergeBlockIntoPredecessor(), llvm::BasicBlock::removePredecessor(), SimplifyCFG(), llvm::DominanceFrontier::splitBlock(), SplitCriticalEdge(), SplitEdgeNicely(), and llvm::SCEVExpander::visitAddRecExpr().

pred_const_iterator llvm::pred_end

(

const BasicBlock *

BB

)

[inline]

Definition at line 77 of file CFG.h.

Referenced by CanPropagatePredecessorsForPHIs(), FoldBranchToCommonDest(), FoldValueComparisonIntoPredecessors(), GetIfCondition(), isValueEqualityComparison(), SimplifyCondBranchToCondBranch(), and TryToSimplifyUncondBranchFromEmptyBlock().

pred_iterator llvm::pred_end

(

BasicBlock *

BB

)

[inline]

Definition at line 76 of file CFG.h.

Interval::pred_iterator llvm::pred_end

(

Interval *

I

)

[inline]

Definition at line 121 of file Interval.h.

References llvm::Interval::Predecessors.

Referenced by AddBlockAndPredsToSet(), llvm::GraphTraits< Inverse< Interval * > >::child_end(), llvm::GraphTraits< Inverse< const BasicBlock * > >::child_end(), llvm::GraphTraits< Inverse< BasicBlock * > >::child_end(), CloneAndPruneFunctionInto(), DeleteDeadBlock(), FindObviousSharedDomOf(), llvm::ProfileInfo::getExecutionCount(), llvm::PredIteratorCache::GetPreds(), llvm::BasicBlock::getSinglePredecessor(), llvm::BasicBlock::getUniquePredecessor(), isCriticalEdge(), llvm::Interval::isLoop(), IsValueFullyAvailableInBlock(), MarkBlocksLiveIn(), MergeBlockIntoPredecessor(), llvm::BasicBlock::removePredecessor(), SimplifyCFG(), llvm::DominanceFrontier::splitBlock(), SplitCriticalEdge(), SplitEdgeNicely(), and llvm::SCEVExpander::visitAddRecExpr().

template<class NodeT>

static void llvm::PrintDomTree	(	const DomTreeNodeBase< NodeT > *	N,
		std::ostream &	o,
		unsigned	Lev
	)			[inline, static]

Definition at line 177 of file Dominators.h.

References E.

void llvm::PrintRecyclerStats	(	size_t	Size,
		size_t	Align,
		size_t	FreeListSize
	)

PrintRecyclingAllocatorStats - Helper for RecyclingAllocator for printing statistics.

Definition at line 135 of file Allocator.cpp.

References cerr().

Referenced by llvm::Recycler< llvm::MachineInstr >::PrintStats().

template<typename ItTy>

ItTy llvm::prior

(

ItTy

it

)

[inline]

Definition at line 156 of file STLExtras.h.

Referenced by mergeBaseUpdateLoadStore(), mergeBaseUpdateLSMultiple(), and ReMaterialize().

template<typename ItTy, typename Dist>

ItTy llvm::prior	(	ItTy	it,
		Dist	n
	)			[inline]

Definition at line 149 of file STLExtras.h.

Referenced by llvm::RegScavenger::backward(), llvm::ScheduleDAGInstrs::BuildSchedGraph(), llvm::XCoreRegisterInfo::emitEpilogue(), llvm::X86RegisterInfo::emitEpilogue(), llvm::SPURegisterInfo::emitEpilogue(), llvm::SparcRegisterInfo::emitEpilogue(), llvm::PPCRegisterInfo::emitEpilogue(), llvm::MipsRegisterInfo::emitEpilogue(), llvm::IA64RegisterInfo::emitEpilogue(), llvm::ARMRegisterInfo::emitEpilogue(), llvm::AlphaRegisterInfo::emitEpilogue(), EmitLiveInCopy(), llvm::SPURegisterInfo::emitPrologue(), llvm::MemoryDependenceAnalysis::getNonLocalCallDependency(), mergeSPUpdates(), mergeSPUpdatesUp(), llvm::X86InstrInfo::reMaterialize(), llvm::MachineFunction::RenumberBlocks(), and llvm::RegScavenger::scavengeRegister().

void llvm::PromoteMemToReg	(	const std::vector< AllocaInst * > &	Allocas,
		DominatorTree &	DT,
		DominanceFrontier &	DF,
		AliasSetTracker *	AST = 0
	)

PromoteMemToReg - Promote the specified list of alloca instructions into scalar registers, inserting PHI nodes as appropriate. This function makes use of DominanceFrontier information. This function does not modify the CFG of the function at all. All allocas must be from the same function.

If AST is specified, the specified tracker is updated to reflect changes made to the IR.

Definition at line 999 of file PromoteMemoryToRegister.cpp.

GenericValue llvm::PTOGV

(

void *

P

)

[inline]

Definition at line 40 of file GenericValue.h.

Referenced by CreateArgv(), llvm::ExecutionEngine::getConstantValue(), lle_X___strdup(), lle_X_calloc(), lle_X_fgets(), lle_X_fopen(), lle_X_fprintf(), lle_X_freopen(), lle_X_malloc(), lle_X_memcpy(), lle_X_memmove(), lle_X_memset(), lle_X_printf(), lle_X_realloc(), lle_X_strcat(), lle_X_strcpy(), lle_X_strdup(), llvm::JIT::runFunction(), llvm::ExecutionEngine::runFunctionAsMain(), and llvm::Interpreter::visitAllocationInst().

void llvm::RecursivelyDeleteTriviallyDeadInstructions	(	Value *	V,
		SmallVectorImpl< Instruction * > *	DeadInst = 0
	)

RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a trivially dead instruction, delete it. If that makes any of its operands trivially dead, delete them too, recursively.

If DeadInst is specified, the vector is filled with the instructions that are actually deleted.

Definition at line 181 of file Local.cpp.

References llvm::SmallVectorImpl< T >::back(), DeadInsts, dyn_cast(), llvm::SmallVectorImpl< T >::empty(), llvm::Instruction::eraseFromParent(), llvm::User::getNumOperands(), llvm::User::getOperand(), isInstructionTriviallyDead(), llvm::SmallVectorImpl< T >::pop_back(), llvm::SmallVectorImpl< T >::push_back(), llvm::User::setOperand(), and llvm::Value::use_empty().

Referenced by EraseTerminatorInstAndDCECond().

static void llvm::reduce_pbqp

(

pbqp *

this_

)

[static]

Definition at line 1215 of file PBQP.cpp.

References apply_RI(), apply_RII(), apply_RN(), llvm::pbqp::bucket_list, pop_colorablenode(), and pop_node().

Referenced by solve_pbqp().

static void llvm::reinsert_node	(	pbqp *	this_,
		int	u
	)			[static]

Definition at line 311 of file PBQP.cpp.

References llvm::pbqp::adj_list, alloc_adjnode(), llvm::adjnode::costs, and insert_adjnode().

Referenced by back_propagate().

void llvm::RemapInstruction	(	Instruction *	I,
		ValueMapTy &	ValueMap
	)

RemapInstruction - Convert the instruction operands from referencing the current values into those specified by ValueMap.

Definition at line 114 of file ValueMapper.cpp.

References E, MapValue(), llvm::User::op_begin(), llvm::User::op_end(), and V.

Referenced by CloneAndPruneFunctionInto(), CloneFunctionInto(), CloneTraceInto(), and UnrollLoop().

static void llvm::remove_adjnode	(	pbqp *	this_,
		int	u,
		adjnode *	adj_ptr
	)			[static]

Definition at line 259 of file PBQP.cpp.

References llvm::pbqp::adj_list, and llvm::adjnode::reverse.

Referenced by delete_edge(), and remove_node().

static void llvm::remove_node	(	pbqp *	this_,
		int	u
	)			[static]

Definition at line 329 of file PBQP.cpp.

References llvm::adjnode::adj, llvm::pbqp::adj_list, and remove_adjnode().

Referenced by apply_RI(), apply_RII(), and apply_RN().

template<typename T>

static void llvm::RemoveFromVector	(	std::vector< T * > &	V,
		T *	N
	)			[inline, static]

Definition at line 49 of file LoopInfo.h.

Referenced by llvm::LoopBase< BlockT >::removeBlockFromLoop().

void llvm::RemoveSuccessor	(	TerminatorInst *	TI,
		unsigned	SuccNum
	)

RemoveSuccessor - Change the specified terminator instruction such that its successor SuccNum no longer exists. Because this reduces the outgoing degree of the current basic block, the actual terminator instruction itself may have to be changed. In the case where the last successor of the block is deleted, a return instruction is inserted in its place which can cause a surprising change in program behavior if it is not expected.

Definition at line 212 of file BasicBlockUtils.cpp.

References BB, llvm::ReturnInst::Create(), llvm::Constant::getNullValue(), llvm::TerminatorInst::getNumSuccessors(), llvm::Instruction::getOpcode(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::Function::getReturnType(), llvm::TerminatorInst::getSuccessor(), llvm::BasicBlock::removePredecessor(), ReplaceInstWithInst(), llvm::MipsISD::Ret, and llvm::Type::VoidTy.

static void llvm::reorder_adjnodes	(	pbqp *	this_,
		int	u
	)			[static]

Definition at line 590 of file PBQP.cpp.

References llvm::adjnode::adj, llvm::pbqp::adj_list, and reorder_node().

Referenced by apply_RI(), apply_RII(), and apply_RN().

static void llvm::reorder_node	(	pbqp *	this_,
		int	u
	)			[static]

Definition at line 568 of file PBQP.cpp.

References add_to_bucketlist(), llvm::pbqp::bucket_list, llvm::pbqp::bucket_ptr, get_deg(), llvm::pbqp::node_deg, and pbqp_remove_bucket().

Referenced by reorder_adjnodes().

void llvm::ReplaceInstWithInst	(	Instruction *	From,
		Instruction *	To
	)

ReplaceInstWithInst - Replace the instruction specified by From with the instruction specified by To.

Definition at line 200 of file BasicBlockUtils.cpp.

References llvm::BasicBlock::getInstList(), llvm::Instruction::getParent(), and ReplaceInstWithInst().

void llvm::ReplaceInstWithInst	(	BasicBlock::InstListType &	BIL,
		BasicBlock::iterator &	BI,
		Instruction *	I
	)

ReplaceInstWithInst - Replace the instruction specified by BI with the instruction specified by I. The original instruction is deleted and BI is updated to point to the new instruction.

Referenced by RemoveSuccessor(), and ReplaceInstWithInst().

void llvm::ReplaceInstWithValue	(	BasicBlock::InstListType &	BIL,
		BasicBlock::iterator &	BI,
		Value *	V
	)

ReplaceInstWithValue - Replace all uses of an instruction (specified by BI) with a value, then remove and delete the original instruction.

template<class T>

scc_iterator<T> llvm::scc_begin

(

T

G

)

[inline]

Definition at line 188 of file SCCIterator.h.

Referenced by llvm::Type::PromoteAbstractToConcrete().

template<class T>

scc_iterator<T> llvm::scc_end

(

T

G

)

[inline]

Definition at line 193 of file SCCIterator.h.

Referenced by llvm::Type::PromoteAbstractToConcrete().

template<class S1Ty, class S2Ty>

S1Ty llvm::set_difference	(	const S1Ty &	S1,
		const S2Ty &	S2
	)			[inline]

set_difference(A, B) - Return A - B

Definition at line 51 of file SetOperations.h.

References SE.

template<class S1Ty, class S2Ty>

void llvm::set_intersect	(	S1Ty &	S1,
		const S2Ty &	S2
	)			[inline]

set_intersect(A, B) - Compute A := A ^ B Identical to set_intersection, except that it works on set<>'s and is nicer to use. Functionally, this iterates through S1, removing elements that are not contained in S2.

Definition at line 40 of file SetOperations.h.

References E.

template<class S1Ty, class S2Ty>

void llvm::set_subtract	(	S1Ty &	S1,
		const S2Ty &	S2
	)			[inline]

set_subtract(A, B) - Compute A := A - B

Definition at line 63 of file SetOperations.h.

References SE.

Referenced by llvm::Linker::LinkInArchive().

template<class S1Ty, class S2Ty>

bool llvm::set_union	(	S1Ty &	S1,
		const S2Ty &	S2
	)			[inline]

set_union(A, B) - Compute A := A u B, return whether A changed.

Definition at line 23 of file SetOperations.h.

References Changed, and SE.

static void llvm::simplify_edge	(	pbqp *	this_,
		int	u,
		int	v
	)			[static]

Definition at line 765 of file PBQP.cpp.

References llvm::pbqp::changed, delete_edge(), get_costmatrix_ptr(), llvm::pbqp::node_costs, normalize_matrix(), and swap().

Referenced by apply_RII(), and eliminate_independent_edges().

bool llvm::SimplifyCFG

(

BasicBlock *

BB

)

SimplifyCFG - This function is used to do simplification of a CFG. For example, it adjusts branches to branches to eliminate the extra hop, it eliminates unreachable basic blocks, and does other "peephole" optimization of the CFG. It returns true if a modification was made, possibly deleting the basic block that was pointed to.

WARNING: The entry node of a method may not be simplified.

SimplifyCFG - This function is used to do simplification of a CFG. For example, it adjusts branches to branches to eliminate the extra hop, it eliminates unreachable basic blocks, and does other "peephole" optimization of the CFG. It returns true if a modification was made.

WARNING: The entry node of a function may not be simplified.

Definition at line 1697 of file SimplifyCFG.cpp.

References llvm::SwitchInst::addCase(), llvm::PHINode::addIncoming(), llvm::SmallVectorImpl< T >::back(), BBI, llvm::BasicBlock::begin(), Changed, ConstantFoldTerminator(), llvm::SwitchInst::Create(), llvm::CallInst::Create(), llvm::BranchInst::Create(), DeleteDeadBlock(), DOUT, E, llvm::SmallVectorImpl< T >::empty(), llvm::Instruction::eraseFromParent(), EraseTerminatorInstAndDCECond(), FoldBranchToCommonDest(), FoldCondBranchOnPHI(), FoldTwoEntryPHINode(), FoldValueComparisonIntoPredecessors(), llvm::BasicBlock::front(), GatherValueComparisons(), llvm::Function::getBasicBlockList(), llvm::Function::getEntryBlock(), llvm::BasicBlock::getFirstNonPHI(), llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), llvm::BasicBlock::getParent(), llvm::BasicBlock::getSinglePredecessor(), llvm::BranchInst::getSuccessor(), llvm::BasicBlock::getTerminator(), HoistThenElseCodeToIf(), II, isValueEqualityComparison(), LI, M, MergeBlockIntoPredecessor(), llvm::User::op_begin(), llvm::User::op_end(), PI, llvm::SmallVectorImpl< T >::pop_back(), Pred, pred_begin(), pred_end(), llvm::SmallVectorImpl< T >::push_back(), llvm::BasicBlock::removePredecessor(), SE, SimplifyCondBranchToCondBranch(), SimplifyCondBranchToTwoReturns(), SimplifyEqualityComparisonWithOnlyPredecessor(), llvm::BasicBlock::size(), llvm::SmallVectorImpl< T >::size(), SpeculativelyExecuteBB(), succ_begin(), succ_end(), std::swap(), TryToSimplifyUncondBranchFromEmptyBlock(), and Values.

Referenced by IterativeSimplifyCFG().

void llvm::solve_pbqp

(

pbqp *

this_

)

Definition at line 1343 of file PBQP.cpp.

References back_propagate(), check_pbqp(), create_bucketlist(), determine_trivialsolution(), eliminate_independent_edges(), eliminate_trivial_nodes(), reduce_pbqp(), and llvm::pbqp::solved.

static const char* llvm::SPARCCondCodeToString

(

SPCC::CondCodes

CC

)

[inline, static]

Definition at line 83 of file Sparc.h.

References llvm::SPCC::FCC_E, llvm::SPCC::FCC_G, llvm::SPCC::FCC_GE, llvm::SPCC::FCC_L, llvm::SPCC::FCC_LE, llvm::SPCC::FCC_LG, llvm::SPCC::FCC_NE, llvm::SPCC::FCC_O, llvm::SPCC::FCC_U, llvm::SPCC::FCC_UE, llvm::SPCC::FCC_UG, llvm::SPCC::FCC_UGE, llvm::SPCC::FCC_UL, llvm::SPCC::FCC_ULE, llvm::SPCC::ICC_CC, llvm::SPCC::ICC_CS, llvm::SPCC::ICC_E, llvm::SPCC::ICC_G, llvm::SPCC::ICC_GE, llvm::SPCC::ICC_GU, llvm::SPCC::ICC_L, llvm::SPCC::ICC_LE, llvm::SPCC::ICC_LEU, llvm::SPCC::ICC_NE, llvm::SPCC::ICC_NEG, llvm::SPCC::ICC_POS, llvm::SPCC::ICC_VC, and llvm::SPCC::ICC_VS.

BasicBlock * llvm::SplitBlock	(	BasicBlock *	Old,
		Instruction *	SplitPt,
		Pass *	P
	)

SplitBlock - Split the specified block at the specified instruction - every thing before SplitPt stays in Old and everything starting with SplitPt moves to a new block. The two blocks are joined by an unconditional branch and the loop info is updated.

Definition at line 295 of file BasicBlockUtils.cpp.

References llvm::LoopBase< BlockT >::addBasicBlockToLoop(), llvm::MachineDominatorTree::addNewBlock(), llvm::DomTreeNodeBase< NodeT >::begin(), llvm::MachineDominatorTree::changeImmediateDominator(), Children, DF, DT, E, llvm::DomTreeNodeBase< NodeT >::end(), llvm::Pass::getAnalysisIfAvailable(), llvm::LoopInfo::getBase(), llvm::LoopInfo::getLoopFor(), llvm::Value::getName(), llvm::MachineDominatorTree::getNode(), L, LI, llvm::BasicBlock::splitBasicBlock(), and llvm::DominanceFrontier::splitBlock().

Referenced by SplitEdge().

BasicBlock * llvm::SplitBlockPredecessors	(	BasicBlock *	BB,
		BasicBlock *const *	Preds,
		unsigned	NumPreds,
		const char *	Suffix,
		Pass *	P = 0
	)

SplitBlockPredecessors - This method transforms BB by introducing a new basic block into the function, and moving some of the predecessors of BB to be predecessors of the new block. The new predecessors are indicated by the Preds array, which has NumPreds elements in it. The new block is given a suffix of 'Suffix'. This function returns the new block.

This currently updates the LLVM IR, AliasAnalysis, DominatorTree and DominanceFrontier, but no other analyses.

SplitBlockPredecessors - This method transforms BB by introducing a new basic block into the function, and moving some of the predecessors of BB to be predecessors of the new block. The new predecessors are indicated by the Preds array, which has NumPreds elements in it. The new block is given a suffix of 'Suffix'.

This currently updates the LLVM IR, AliasAnalysis, DominatorTree and DominanceFrontier, but no other analyses.

Definition at line 337 of file BasicBlockUtils.cpp.

References AA, llvm::PHINode::addIncoming(), llvm::BasicBlock::begin(), llvm::AliasAnalysis::copyValue(), llvm::PHINode::Create(), llvm::BranchInst::Create(), llvm::BasicBlock::Create(), llvm::AliasAnalysis::deleteValue(), DF, llvm::DominatorTree::dominates(), DT, dyn_cast(), llvm::Instruction::eraseFromParent(), llvm::UndefValue::get(), llvm::Pass::getAnalysisIfAvailable(), llvm::PHINode::getIncomingValueForBlock(), llvm::Value::getName(), llvm::BasicBlock::getParent(), llvm::Value::getType(), llvm::PHINode::hasConstantValue(), llvm::PHINode::removeIncomingValue(), llvm::Value::replaceAllUsesWith(), llvm::DominanceFrontier::splitBlock(), and llvm::DominatorTree::splitBlock().

Referenced by SplitEdgeNicely().

bool llvm::SplitCriticalEdge	(	BasicBlock *	Src,
		BasicBlock *	Dst,
		Pass *	P = 0,
		bool	MergeIdenticalEdges = false
	)			[inline]

SplitCriticalEdge - If an edge from Src to Dst is critical, split the edge and return true, otherwise return false. This method requires that there be an edge between the two blocks. If P is specified, it updates the analyses described above.

Definition at line 137 of file BasicBlockUtils.h.

References llvm::TerminatorInst::getNumSuccessors(), llvm::TerminatorInst::getSuccessor(), llvm::BasicBlock::getTerminator(), and SplitCriticalEdge().

bool llvm::SplitCriticalEdge	(	BasicBlock *	Succ,
		pred_iterator	PI,
		Pass *	P = 0
	)			[inline]

SplitCriticalEdge - If the edge from *PI to BB is not critical, return false. Otherwise, split all edges between the two blocks and return true. This updates all of the same analyses as the other SplitCriticalEdge function. If P is specified, it updates the analyses described above.

Definition at line 124 of file BasicBlockUtils.h.

References llvm::TerminatorInst::getNumSuccessors(), llvm::TerminatorInst::getSuccessor(), MadeChange, and SplitCriticalEdge().

bool llvm::SplitCriticalEdge	(	BasicBlock *	BB,
		succ_iterator	SI,
		Pass *	P = 0
	)			[inline]

Definition at line 115 of file BasicBlockUtils.h.

References llvm::SuccIterator< Term_, BB_ >::getSuccessorIndex(), llvm::BasicBlock::getTerminator(), and SplitCriticalEdge().

bool llvm::SplitCriticalEdge	(	TerminatorInst *	TI,
		unsigned	SuccNum,
		Pass *	P = 0,
		bool	MergeIdenticalEdges = false
	)

SplitCriticalEdge - If this edge is a critical edge, insert a new node to split the critical edge. This will update DominatorTree and DominatorFrontier information if it is available, thus calling this pass will not invalidate either of them. This returns true if the edge was split, false otherwise.

If MergeIdenticalEdges is true (not the default), *all* edges from TI to the specified successor will be merged into the same critical edge block. This is most commonly interesting with switch instructions, which may have many edges to any one destination. This ensures that all edges to that dest go to one block instead of each going to a different block, but isn't the standard definition of a "critical edge".

SplitCriticalEdge - If this edge is a critical edge, insert a new node to split the critical edge. This will update DominatorTree and DominatorFrontier information if it is available, thus calling this pass will not invalidate any of them. This returns true if the edge was split, false otherwise. This ensures that all edges to that dest go to one block instead of each going to a different block.

Definition at line 124 of file BreakCriticalEdges.cpp.

References llvm::DominanceFrontierBase::addBasicBlock(), llvm::MachineDominatorTree::addNewBlock(), llvm::SmallVectorImpl< T >::back(), llvm::BasicBlock::begin(), llvm::MachineDominatorTree::changeImmediateDominator(), llvm::SmallVectorImpl< T >::clear(), llvm::BranchInst::Create(), llvm::BasicBlock::Create(), DF, llvm::MachineDominatorTree::dominates(), DT, E, llvm::SmallVectorImpl< T >::empty(), llvm::DominanceFrontierBase::end(), llvm::DominanceFrontierBase::find(), llvm::Pass::getAnalysisIfAvailable(), llvm::LoopInfo::getBase(), llvm::PHINode::getBasicBlockIndex(), llvm::Function::getBasicBlockList(), llvm::LoopInfo::getLoopFor(), llvm::Value::getName(), llvm::MachineDominatorTree::getNode(), llvm::TerminatorInst::getNumSuccessors(), llvm::BasicBlock::getParent(), llvm::Instruction::getParent(), llvm::TerminatorInst::getSuccessor(), isCriticalEdge(), LI, llvm::SmallVectorImpl< T >::pop_back(), pred_begin(), pred_end(), llvm::SmallVectorImpl< T >::push_back(), llvm::DominanceFrontierBase::removeFromFrontier(), llvm::BasicBlock::removePredecessor(), llvm::PHINode::setIncomingBlock(), and llvm::TerminatorInst::setSuccessor().

Referenced by IVUseShouldUsePostIncValue(), SplitCriticalEdge(), SplitEdge(), and SplitEdgeNicely().

MachineBasicBlock* llvm::SplitCriticalMachineEdge	(	MachineBasicBlock *	src,
		MachineBasicBlock *	dst
	)

Change all the phi functions in dst, so that the incoming block be crit_mbb, instead of src

the first instructions are always phi functions.

Definition at line 23 of file BreakCriticalMachineEdge.h.

References llvm::MachineBasicBlock::addSuccessor(), llvm::MachineBasicBlock::begin(), llvm::MachineFunction::CreateMachineBasicBlock(), llvm::MachineOperand::CreateMBB(), llvm::MachineOperand::CreateReg(), E, llvm::MachineBasicBlock::end(), llvm::MachineBasicBlock::getBasicBlock(), llvm::TargetMachine::getInstrInfo(), llvm::MachineOperand::getMBB(), llvm::MachineBasicBlock::getParent(), llvm::MachineFunction::getTarget(), llvm::TargetInstrInfo::InsertBranch(), llvm::MachineOperand::isMBB(), MF, llvm::TargetInstrInfo::PHI, llvm::MachineFunction::push_back(), reg, llvm::MachineBasicBlock::removeSuccessor(), llvm::MachineOperand::setMBB(), TII, and TM.

BasicBlock * llvm::SplitEdge	(	BasicBlock *	BB,
		BasicBlock *	Succ,
		Pass *	P
	)

SplitEdge - Split the edge connecting specified block. Pass P must not be NULL.

Definition at line 254 of file BasicBlockUtils.cpp.

References llvm::BasicBlock::begin(), llvm::TerminatorInst::getNumSuccessors(), llvm::BasicBlock::getSinglePredecessor(), llvm::TerminatorInst::getSuccessor(), llvm::BasicBlock::getTerminator(), SplitBlock(), and SplitCriticalEdge().

void llvm::SplitString	(	const std::string &	Source,
		std::vector< std::string > &	OutFragments,
		const char *	Delimiters = " \t\n\v\f\r"
	)

SplitString - Split up the specified string according to the specified delimiters, appending the result fragments to the output list.

Definition at line 48 of file StringExtras.cpp.

References getToken().

Referenced by llvm::X86TargetAsmInfo< BaseTAI >::ExpandInlineAsm().

static bool llvm::StringsEqualNoCase	(	const std::string &	LHS,
		const char *	RHS
	)			[inline, static]

StringsEqualNoCase - Return true if the two strings are equal, ignoring case.

Definition at line 154 of file StringExtras.h.

static bool llvm::StringsEqualNoCase	(	const std::string &	LHS,
		const std::string &	RHS
	)			[inline, static]

StringsEqualNoCase - Return true if the two strings are equal, ignoring case.

Definition at line 144 of file StringExtras.h.

Referenced by llvm::X86TargetLowering::getRegForInlineAsmConstraint(), and llvm::TargetLowering::getRegForInlineAsmConstraint().

succ_const_iterator llvm::succ_begin

(

const BasicBlock *

BB

)

[inline]

Definition at line 139 of file CFG.h.

References llvm::BasicBlock::getTerminator().

Referenced by AddPredecessorToBlock(), CanPropagatePredecessorsForPHIs(), HoistThenElseCodeToIf(), isTrivialLoopExitBlockHelper(), SafeToMergeTerminators(), and SimplifyEqualityComparisonWithOnlyPredecessor().

succ_iterator llvm::succ_begin

(

BasicBlock *

BB

)

[inline]

Definition at line 136 of file CFG.h.

References llvm::BasicBlock::getTerminator().

Interval::succ_iterator llvm::succ_begin

(

Interval *

I

)

[inline]

succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the succ_* functions, and *succ_iterator.

Definition at line 108 of file Interval.h.

References llvm::Interval::Successors.

Referenced by llvm::DominanceFrontier::calculate(), ChangeToUnreachable(), llvm::GraphTraits< Interval * >::child_begin(), llvm::GraphTraits< const BasicBlock * >::child_begin(), llvm::GraphTraits< BasicBlock * >::child_begin(), DFSPass(), llvm::DOTGraphTraits< const Function * >::getEdgeSourceLabel(), IsValueFullyAvailableInBlock(), MarkAliveBlocks(), MergeBlockIntoPredecessor(), RemoveUnreachableBlocksFromFn(), SimplifyCFG(), and llvm::BasicBlock::splitBasicBlock().

succ_const_iterator llvm::succ_end

(

const BasicBlock *

BB

)

[inline]

Definition at line 145 of file CFG.h.

References llvm::BasicBlock::getTerminator().

Referenced by AddPredecessorToBlock(), HoistThenElseCodeToIf(), isTrivialLoopExitBlockHelper(), SafeToMergeTerminators(), and SimplifyEqualityComparisonWithOnlyPredecessor().

succ_iterator llvm::succ_end

(

BasicBlock *

BB

)

[inline]

Definition at line 142 of file CFG.h.

References llvm::BasicBlock::getTerminator().

Interval::succ_iterator llvm::succ_end

(

Interval *

I

)

[inline]

Definition at line 111 of file Interval.h.

References llvm::Interval::Successors.

Referenced by llvm::DominanceFrontier::calculate(), ChangeToUnreachable(), llvm::GraphTraits< Interval * >::child_end(), llvm::GraphTraits< const BasicBlock * >::child_end(), llvm::GraphTraits< BasicBlock * >::child_end(), DFSPass(), IsValueFullyAvailableInBlock(), MarkAliveBlocks(), MergeBlockIntoPredecessor(), llvm::IntervalIterator< NodeTy, OrigContainer_t, GT, IGT >::operator++(), RemoveUnreachableBlocksFromFn(), SimplifyCFG(), and llvm::BasicBlock::splitBasicBlock().

template<class T>

void llvm::swap	(	OwningArrayPtr< T > &	a,
		OwningArrayPtr< T > &	b
	)			[inline]

Definition at line 127 of file OwningPtr.h.

References llvm::OwningArrayPtr< T >::swap().

template<class T>

void llvm::swap	(	OwningPtr< T > &	a,
		OwningPtr< T > &	b
	)			[inline]

Definition at line 74 of file OwningPtr.h.

References llvm::OwningPtr< T >::swap().

Referenced by Calculate(), llvm::BitcodeReader::FreeState(), llvm::BitcodeReader::materializeModule(), simplify_edge(), llvm::FCmpInst::swapOperands(), llvm::ICmpInst::swapOperands(), and llvm::BinaryOperator::swapOperands().

template<typename T1, typename T2>

tier<T1, T2> llvm::tie	(	T1 &	f,
		T2 &	s
	)			[inline]

Definition at line 202 of file STLExtras.h.

Referenced by llvm::ProgramInfo::getSourceFile(), llvm::TypeMap< ValType, TypeClass >::RefineAbstractType(), and RewriteHeapSROALoadUser().

void llvm::UnescapeString

(

std::string &

Str

)

UnescapeString - Modify the argument string, turning two character sequences like '\' 'n' into '
'. This handles: \' \ and (where num is a 1-3 byte octal value).

UnescapeString - Modify the argument string, turning two character sequences

/// like '\\' 'n' into '\n'.  This handles: \e \a \b \f \n \r \t \v \' \ and
/// \num (where num is a 1-3 byte octal value).
/// 

Definition at line 67 of file StringExtras.cpp.

bool llvm::UnrollLoop	(	Loop *	L,
		unsigned	Count,
		LoopInfo *	LI,
		LPPassManager *	LPM
	)

Unroll the given loop by Count. The loop must be in LCSSA form. Returns true if unrolling was succesful, or false if the loop was unmodified. Unrolling can only fail when the loop's latch block is not terminated by a conditional branch instruction. However, if the trip count (and multiple) are not known, loop unrolling will mostly produce more code that is no faster.

The LoopInfo Analysis that is passed will be kept consistent.

If a LoopPassManager is passed in, and the loop is fully removed, it will be removed from the LoopPassManager as well. LPM can also be NULL.

Definition at line 107 of file UnrollLoop.cpp.

References llvm::LoopBase< BlockT >::addBasicBlockToLoop(), llvm::PHINode::addIncoming(), BB, llvm::SmallPtrSet< PtrType, SmallSize >::begin(), llvm::DenseMap< KeyT, ValueT, KeyInfoT, ValueInfoT >::begin(), llvm::MachineBasicBlock::begin(), llvm::CallingConv::C, CloneBasicBlock(), ConstantFoldInstruction(), llvm::LoopBase< BlockT >::contains(), llvm::LPPassManager::deleteLoopFromQueue(), Dest, DOUT, dyn_cast(), E, llvm::SmallPtrSet< PtrType, SmallSize >::end(), llvm::DenseMap< KeyT, ValueT, KeyInfoT, ValueInfoT >::end(), FoldBlockIntoPredecessor(), llvm::LoopInfo::getBase(), llvm::LoopBase< BlockT >::getBlocks(), llvm::LoopBase< BlockT >::getHeader(), llvm::PHINode::getIncomingValueForBlock(), llvm::BasicBlock::getInstList(), llvm::LoopBase< BlockT >::getLoopLatch(), llvm::LoopBase< BlockT >::getLoopPreheader(), llvm::Instruction::getParent(), llvm::LoopBase< BlockT >::getSmallConstantTripCount(), llvm::LoopBase< BlockT >::getSmallConstantTripMultiple(), llvm::TerminatorInst::getSuccessor(), llvm::BranchInst::getSuccessor(), llvm::BasicBlock::getTerminator(), GreatestCommonDivisor64(), Header, llvm::SmallPtrSet< PtrType, SmallSize >::insert(), Inst, isInstructionTriviallyDead(), llvm::LoopBase< BlockT >::isLCSSAForm(), llvm::BranchInst::isUnconditional(), LoopBlocks, NewBlocks, Preheader, RemapInstruction(), llvm::PHINode::removeIncomingValue(), llvm::Value::replaceAllUsesWith(), SE, llvm::BranchInst::setSuccessor(), llvm::TerminatorInst::setSuccessor(), llvm::BranchInst::setUnconditionalDest(), llvm::Value::use_begin(), llvm::Value::use_end(), Users, and VE.

void llvm::UpgradeCallsToIntrinsic

(

Function *

F

)

This is an auto-upgrade hook for any old intrinsic function syntaxes which need to have both the function updated as well as all calls updated to the new function. This should only be run in a post-processing fashion so that it can update all calls to the old function.

Definition at line 413 of file AutoUpgrade.cpp.

References llvm::Function::eraseFromParent(), UpgradeIntrinsicCall(), UpgradeIntrinsicFunction(), llvm::Value::use_begin(), and llvm::Value::use_end().

void llvm::UpgradeIntrinsicCall	(	CallInst *	CI,
		Function *	NewFn
	)

This is the complement to the above, replacing a specific call to an intrinsic function with a call to the specified new function.

Definition at line 228 of file AutoUpgrade.cpp.

References llvm::Function::begin(), llvm::CastInst::Create(), llvm::CallInst::Create(), llvm::InsertElementInst::Create(), llvm::Intrinsic::ctlz, llvm::Intrinsic::ctpop, llvm::Intrinsic::cttz, llvm::Type::DoubleTy, llvm::Instruction::eraseFromParent(), F, llvm::ConstantVector::get(), llvm::ConstantInt::get(), llvm::UndefValue::get(), llvm::Function::getAttributes(), llvm::CallInst::getCalledFunction(), llvm::CallInst::getCallingConv(), llvm::CastInst::getCastOpcode(), llvm::Function::getFunctionType(), llvm::Function::getIntrinsicID(), llvm::Value::getName(), llvm::Value::getNameStart(), llvm::User::getOperand(), llvm::FunctionType::getParamType(), llvm::Function::getReturnType(), llvm::Value::getType(), llvm::PointerType::getUnqual(), Idx, llvm::Type::Int32Ty, llvm::CallInst::isTailCall(), Load, llvm::User::op_begin(), llvm::User::op_end(), llvm::AttrListPtr::paramHasAttr(), llvm::Value::replaceAllUsesWith(), llvm::CallInst::setCallingConv(), llvm::CallInst::setTailCall(), llvm::Attribute::SExt, llvm::Value::use_empty(), llvm::Intrinsic::x86_mmx_psll_d, llvm::Intrinsic::x86_mmx_psll_q, llvm::Intrinsic::x86_mmx_psll_w, llvm::Intrinsic::x86_mmx_psra_d, llvm::Intrinsic::x86_mmx_psra_w, llvm::Intrinsic::x86_mmx_psrl_d, llvm::Intrinsic::x86_mmx_psrl_q, and llvm::Intrinsic::x86_mmx_psrl_w.

Referenced by llvm::BitcodeReader::materializeFunction(), llvm::BitcodeReader::materializeModule(), and UpgradeCallsToIntrinsic().

bool llvm::UpgradeIntrinsicFunction	(	Function *	F,
		Function *&	NewFn
	)

This is a more granular function that simply checks an intrinsic function for upgrading, and returns true if it requires upgrading. It may return null in NewFn if the all calls to the original intrinsic function should be transformed to non-function-call instructions.

Definition at line 213 of file AutoUpgrade.cpp.

References llvm::Intrinsic::getAttributes(), llvm::Function::getIntrinsicID(), llvm::Function::setAttributes(), and UpgradeIntrinsicFunction1().

Referenced by UpgradeCallsToIntrinsic().

static std::string llvm::UppercaseString

(

const std::string &

S

)

[inline, static]

Definition at line 134 of file StringExtras.h.

template<typename IntTy>

static char* llvm::utohex_buffer	(	IntTy	X,
		char *	BufferEnd
	)			[inline, static]

utohex_buffer - Emit the specified number into the buffer specified by BufferEnd, returning a pointer to the start of the string. This can be used like this: (note that the buffer must be large enough to handle any number): char Buffer[40]; printf("0x%s", utohex_buffer(X, Buffer+40));

This should only be used with unsigned types.

Definition at line 41 of file StringExtras.h.

References hexdigit(), and Mod.

Referenced by llvm::AsmPrinter::PrintHex(), llvm::AsmPrinter::PrintSLEB128(), llvm::AsmPrinter::PrintULEB128(), utohexstr(), and WriteConstantInt().

static std::string llvm::utohexstr

(

uint64_t

X

)

[inline, static]

Definition at line 57 of file StringExtras.h.

References utohex_buffer().

Referenced by itohexstr().

static std::string llvm::utostr	(	uint64_t	X,
		bool	isNeg = false
	)			[inline, static]

Definition at line 79 of file StringExtras.h.

References utostr_32().

Referenced by calcTypeName(), llvm::Archive::fillHeader(), llvm::ISD::ArgFlagsTy::getArgFlagsString(), llvm::Attribute::getAsString(), GetHeapSROAValue(), llvm::MVT::getMVTString(), llvm::Intrinsic::getName(), llvm::TargetData::getStringRepresentation(), getTypeDescription(), getTypePrefix(), llvm::TypeSymbolTable::getUniqueName(), llvm::Mangler::getValueName(), IntrinsicParam(), itostr(), llvm::XCoreTargetAsmInfo::MergeableConstSection(), llvm::ELFTargetAsmInfo::MergeableConstSection(), llvm::ELFTargetAsmInfo::MergeableStringSection(), PerformHeapAllocSRoA(), llvm::XCoreTargetAsmInfo::printSectionFlags(), llvm::ELFTargetAsmInfo::printSectionFlags(), and SRAGlobal().

static std::string llvm::utostr_32	(	uint32_t	X,
		bool	isNeg = false
	)			[inline, static]

Definition at line 62 of file StringExtras.h.

Referenced by llvm::X86IntelAsmPrinter::decorateName(), llvm::X86ATTAsmPrinter::decorateName(), getPICLabelString(), and utostr().

bool llvm::verifyFunction	(	const Function &	F,
		VerifierFailureAction	action = AbortProcessAction
	)

Parameters:

F	The function to be verified
action	Action to take

Definition at line 1639 of file Verifier.cpp.

References llvm::GlobalValue::getParent(), and llvm::Function::isDeclaration().

Referenced by LLVMVerifyFunction().

bool llvm::verifyModule	(	const Module &	M,
		VerifierFailureAction	action = AbortProcessAction,
		std::string *	ErrorInfo = 0
	)

Check a module for errors.

If there are no errors, the function returns false. If an error is found, the action taken depends on the action parameter. This should only be used for debugging, because it plays games with PassManagers and stuff.

verifyModule - Check a module for errors, printing messages on stderr. Return true if the module is corrupt.

Parameters:

M	The module to be verified
action	Action to take
ErrorInfo	Information about failures.

Definition at line 1655 of file Verifier.cpp.

References llvm::PassManager::add(), and llvm::PassManager::run().

Referenced by LLVMVerifyModule().

template<typename GraphType>

void llvm::ViewGraph	(	const GraphType &	G,
		const std::string &	Name,
		const std::string &	Title = ""
	)			[inline]

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

Definition at line 309 of file GraphWriter.h.

References DisplayGraph(), Filename, llvm::sys::Path::isEmpty(), and WriteGraph().

Referenced by llvm::MachineFunction::viewCFG(), llvm::Function::viewCFG(), llvm::SelectionDAG::viewGraph(), and llvm::ScheduleDAG::viewGraph().

void llvm::WriteAsOperand	(	std::ostream &	,
		const MachineBasicBlock *	,
		bool	t
	)			[inline]

Definition at line 24 of file MachineDominators.h.

Referenced by PrintOps().

void llvm::WriteAsOperand	(	raw_ostream &	Out,
		const Value *	V,
		bool	PrintTy = true,
		const Module *	Context = 0
	)

Definition at line 907 of file AsmWriter.cpp.

References fillTypeNameTable(), getModuleFromVal(), llvm::Value::getType(), printTypeInt(), TypeNames, and WriteAsOperandInternal().

void llvm::WriteAsOperand	(	std::ostream &	Out,
		const Value *	V,
		bool	PrintType,
		const Module *	Context
	)

WriteAsOperand - Write the name of the specified value out to the specified ostream. This can be useful when you just want to print int reg126, not the whole instruction that generated it.

Definition at line 901 of file AsmWriter.cpp.

References OS.

Referenced by llvm::DOTGraphTraits< const Function * >::getNodeLabel(), operator<<(), llvm::Trace::print(), llvm::SDNode::print(), llvm::SCEVUnknown::print(), llvm::SCEVConstant::print(), llvm::LoopBase< BlockT >::print(), llvm::DominanceFrontierBase::print(), llvm::Value::print(), llvm::AliasSet::print(), PrintModRefResults(), and PrintResults().

void llvm::WriteBitcodeToFile	(	const Module *	M,
		raw_ostream &	Out
	)

WriteBitcodeToFile - Write the specified module to the specified raw output stream.

WriteBitcodeToFile - Write the specified module to the specified output stream.

Definition at line 1358 of file BitcodeWriter.cpp.

References llvm::sys::Program::ChangeStdoutToBinary(), llvm::raw_ostream::flush(), outs(), llvm::raw_ostream::write(), and WriteBitcodeToStream().

Referenced by LLVMWriteBitcodeToFile().

void llvm::WriteBitcodeToFile	(	const Module *	M,
		std::ostream &	Out
	)

WriteBitcodeToFile - Write the specified module to the specified output stream.

WriteBitcodeToFile - Write the specified module to the specified output stream.

Definition at line 1348 of file BitcodeWriter.cpp.

References llvm::sys::Program::ChangeStdoutToBinary(), cout(), and RawOut.

void llvm::WriteBitcodeToStream	(	const Module *	M,
		BitstreamWriter &	Stream
	)

WriteBitcodeToStream - Write the specified module to the specified raw output stream.

WriteBitcodeToStream - Write the specified module to the specified output stream.

Definition at line 1379 of file BitcodeWriter.cpp.

References llvm::BitstreamWriter::Emit(), EmitDarwinBCHeader(), EmitDarwinBCTrailer(), llvm::BitstreamWriter::getBuffer(), llvm::Module::getTargetTriple(), and WriteModule().

Referenced by WriteBitcodeToFile().

template<typename GraphType>

sys::Path llvm::WriteGraph	(	const GraphType &	G,
		const std::string &	Name,
		const std::string &	Title = ""
	)			[inline]

Definition at line 273 of file GraphWriter.h.

References llvm::sys::Path::appendComponent(), cerr(), Filename, llvm::sys::Path::GetTemporaryDirectory(), llvm::sys::Path::isEmpty(), llvm::sys::Path::makeUnique(), and WriteGraph().

template<typename GraphType>

std::ostream& llvm::WriteGraph	(	std::ostream &	O,
		const GraphType &	G,
		const std::string &	Name = "",
		const std::string &	Title = ""
	)			[inline]

Definition at line 252 of file GraphWriter.h.

References llvm::GraphWriter< GraphType >::writeFooter(), llvm::GraphWriter< GraphType >::writeHeader(), and llvm::GraphWriter< GraphType >::writeNodes().

Referenced by ViewGraph(), and WriteGraph().

void llvm::WriteTypeSymbolic	(	raw_ostream &	Out,
		const Type *	Ty,
		const Module *	M
	)

Definition at line 576 of file AsmWriter.cpp.

References fillTypeNameTable(), llvm::Type::getDescription(), printTypeInt(), and TypeNames.

void llvm::WriteTypeSymbolic	(	std::ostream &	Out,
		const Type *	Ty,
		const Module *	M
	)

WriteTypeSymbolic - This attempts to write the specified type as a symbolic type, iff there is an entry in the modules symbol table for the specified type or one of it's component types. This is slower than a simple x << Type

Definition at line 570 of file AsmWriter.cpp.

Referenced by llvm::Type::dump(), and llvm::FindUsedTypes::print().

---

Variable Documentation

const char *const llvm::arm_asm_table

Initial value:

 {
                                      "{r0}", "r0",
                                      "{r1}", "r1",
                                      "{r2}", "r2",
                                      "{r3}", "r3",
                                      "{r4}", "r4",
                                      "{r5}", "r5",
                                      "{r6}", "r6",
                                      "{r7}", "r7",
                                      "{r8}", "r8",
                                      "{r9}", "r9",
                                      "{r10}", "r10",
                                      "{r11}", "r11",
                                      "{r12}", "r12",
                                      "{r13}", "r13",
                                      "{r14}", "r14",
                                      "{lr}", "lr",
                                      "{sp}", "sp",
                                      "{ip}", "ip",
                                      "{fp}", "fp",
                                      "{sl}", "sl",
                                      "{memory}", "memory",
                                      "{cc}", "cc",
                                      0,0}

Definition at line 21 of file ARMTargetAsmInfo.cpp.

Referenced by llvm::ARMTargetAsmInfo< llvm::ELFTargetAsmInfo >::ARMTargetAsmInfo().

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst llvm::BitCast

Definition at line 174 of file InstVisitor.h.

Referenced by llvm::BitCastInst::classof(), llvm::CastInst::Create(), llvm::CastInst::getCastOpcode(), and llvm::Instruction::getOpcodeName().

const PassInfo *const llvm::BreakCriticalEdgesID = &X

Definition at line 58 of file BreakCriticalEdges.cpp.

Referenced by llvm::UnifyFunctionExitNodes::getAnalysisUsage().

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst llvm::Call

Definition at line 182 of file InstVisitor.h.

Referenced by AddNodeIDCustom(), llvm::Instruction::getOpcodeName(), and llvm::Instruction::isTrapping().

CodeModel::Model llvm::CMModel

Definition at line 36 of file TargetMachine.cpp.

Referenced by llvm::TargetMachine::getCodeModel(), and llvm::TargetMachine::setCodeModel().

bool llvm::DebugFlag

Definition at line 30 of file Debug.cpp.

Referenced by getErrorOutputStream(), LowerSTORE(), and llvm::SPUTargetLowering::PerformDAGCombine().

const PassInfo *const llvm::DemoteRegisterToMemoryID = &X

Definition at line 122 of file Reg2Mem.cpp.

bool llvm::DisableJumpTables

DisableJumpTables - This flag indicates jump tables should not be generated.

Definition at line 41 of file TargetMachine.cpp.

Referenced by llvm::PPCTargetMachine::addCodeEmitter(), and areJTsAllowed().

bool llvm::DisableRedZone

DisableRedZone - This flag disables use of the "Red Zone" on targets which would otherwise have one.

Definition at line 43 of file TargetMachine.cpp.

Referenced by llvm::PPCRegisterInfo::determineFrameLayout(), and llvm::X86RegisterInfo::emitPrologue().

bool llvm::EnableFastISel

FastISel - This flag enables fast-path instruction selection which trades away generated code quality in favor of reducing compile time.

Definition at line 29 of file LLVMTargetMachine.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses(), llvm::X86TargetMachine::addInstSelector(), and llvm::SelectionDAGISel::runOnFunction().

bool llvm::ExceptionHandling

ExceptionHandling - This flag indicates that exception information should be emitted.

Definition at line 33 of file TargetMachine.cpp.

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst llvm::ExtractValue

Definition at line 190 of file InstVisitor.h.

Referenced by llvm::Instruction::getOpcodeName().

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst llvm::FCmp

Definition at line 180 of file InstVisitor.h.

Referenced by llvm::Instruction::getOpcodeName().

bool llvm::FiniteOnlyFPMathOption

FiniteOnlyFPMath - This returns true when the -enable-finite-only-fp-math option is specified on the command line. If this returns false (default), the code generator is not allowed to assume that FP arithmetic arguments and results are never NaNs or +-Infs.

Definition at line 29 of file TargetMachine.cpp.

Referenced by FiniteOnlyFPMath().

BinaryOperator MallocInst LoadInst ZExtInst llvm::FPToUI

Definition at line 166 of file InstVisitor.h.

Referenced by llvm::FPToUIInst::classof(), llvm::CastInst::Create(), llvm::CastInst::getCastOpcode(), and llvm::Instruction::getOpcodeName().

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst llvm::FPTrunc

Definition at line 170 of file InstVisitor.h.

Referenced by llvm::FPTruncInst::classof(), llvm::CastInst::Create(), llvm::CastInst::getCastOpcode(), and llvm::Instruction::getOpcodeName().

bool llvm::HonorSignDependentRoundingFPMathOption

HonorSignDependentRoundingFPMath - This returns true when the -enable-sign-dependent-rounding-fp-math is specified. If this returns false (the default), the code generator is allowed to assume that the rounding behavior is the default (round-to-zero for all floating point to integer conversions, and round-to-nearest for all other arithmetic truncations). If this is enabled (set to true), the code generator must assume that the rounding mode may dynamically change.

Definition at line 30 of file TargetMachine.cpp.

Referenced by HonorSignDependentRoundingFPMath().

const unsigned int llvm::host_char_bit = 8

Definition at line 37 of file APInt.h.

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst llvm::InsertElement

Definition at line 188 of file InstVisitor.h.

Referenced by llvm::Instruction::getOpcodeName().

const PassInfo *const llvm::InstructionNamerID = &X

Definition at line 56 of file InstructionNamer.cpp.

const unsigned int llvm::integerPartWidth

Initial value:

 host_char_bit *
    static_cast<unsigned int>(sizeof(integerPart))

Definition at line 38 of file APInt.h.

Referenced by llvm::APFloat::convertFromSignExtendedInteger(), llvm::SelectionDAG::getNode(), highHalf(), lostFractionThroughTruncation(), lowBitMask(), lowHalf(), llvm::APFloat::mod(), partAsHex(), partCountForBits(), partLSB(), partMSB(), llvm::APFloat::remainder(), llvm::APInt::tcDivide(), llvm::APInt::tcExtract(), llvm::APInt::tcExtractBit(), llvm::APInt::tcLSB(), llvm::APInt::tcMSB(), llvm::APInt::tcMultiplyPart(), llvm::APInt::tcSetBit(), llvm::APInt::tcSetLeastSignificantBits(), llvm::APInt::tcShiftLeft(), llvm::APInt::tcShiftRight(), and ulpsFromBoundary().

const PassInfo *const llvm::LCSSAID = &X

Definition at line 103 of file LCSSA.cpp.

BinaryOperator MallocInst llvm::Load

Definition at line 154 of file InstVisitor.h.

Referenced by llvm::PIC16TargetLowering::ExpandLoad(), llvm::Instruction::getOpcodeName(), llvm::Instruction::isTrapping(), llvm::SparcTargetLowering::LowerArguments(), llvm::X86InstrInfo::unfoldMemoryOperand(), and UpgradeIntrinsicCall().

const PassInfo *const llvm::LoopSimplifyID = &X

Definition at line 106 of file LoopSimplify.cpp.

const PassInfo *const llvm::LowerAllocationsID = &X

Definition at line 76 of file LowerAllocations.cpp.

const PassInfo *const llvm::LowerInvokePassID = &X

Definition at line 107 of file LowerInvoke.cpp.

const PassInfo *const llvm::LowerSwitchID = &X

Definition at line 88 of file LowerSwitch.cpp.

Referenced by llvm::UnifyFunctionExitNodes::getAnalysisUsage().

llvm::LShr

Definition at line 142 of file InstVisitor.h.

Referenced by llvm::Instruction::getOpcodeName(), and llvm::Instruction::isLogicalShift().

const PassInfo *const llvm::MachineDominatorsID = &E

MachineDominators pass - This pass is a machine dominators analysis pass.

Definition at line 28 of file MachineDominators.cpp.

Referenced by llvm::SimpleRegisterCoalescing::getAnalysisUsage(), llvm::DebugLabelFolder::getAnalysisUsage(), and llvm::LiveIntervals::getAnalysisUsage().

const PassInfo *const llvm::MachineLoopInfoID = &X

MachineLoopInfo pass - This pass is a loop analysis pass.

Definition at line 29 of file MachineLoopInfo.cpp.

Referenced by llvm::DebugLabelFolder::getAnalysisUsage(), and llvm::LiveIntervals::getAnalysisUsage().

BinaryOperator llvm::Malloc

Definition at line 151 of file InstVisitor.h.

Referenced by llvm::Instruction::getOpcodeName().

const unsigned int llvm::maxExponent = 16383

Definition at line 71 of file APFloat.cpp.

Referenced by powerOf5().

const unsigned int llvm::maxPowerOfFiveExponent = maxExponent + maxPrecision - 1

Definition at line 73 of file APFloat.cpp.

const unsigned int llvm::maxPowerOfFiveParts

Initial value:

 2 + ((maxPowerOfFiveExponent * 815)
                                                / (351 * integerPartWidth))

Definition at line 74 of file APFloat.cpp.

Referenced by powerOf5().

const unsigned int llvm::maxPrecision = 113

Definition at line 72 of file APFloat.cpp.

bool llvm::NoExcessFPPrecision

NoExcessFPPrecision - This flag is enabled when the -disable-excess-fp-precision flag is specified on the command line. When this flag is off (the default), the code generator is allowed to produce results that are "more precise" than IEEE allows. This includes use of FMA-like operations and use of the X86 FP registers without rounding all over the place.

Definition at line 27 of file TargetMachine.cpp.

bool llvm::NoFramePointerElim

NoFramePointerElim - This flag is enabled when the -disable-fp-elim is specified on the command line. If the target supports the frame pointer elimination optimization, this option should disable it.

Definition at line 26 of file TargetMachine.cpp.

Referenced by llvm::XCoreRegisterInfo::hasFP(), llvm::X86RegisterInfo::hasFP(), llvm::MipsRegisterInfo::hasFP(), llvm::IA64RegisterInfo::hasFP(), llvm::ARMRegisterInfo::hasFP(), needsFP(), and llvm::PPCRegisterInfo::processFunctionBeforeCalleeSavedScan().

bool llvm::NoZerosInBSS

NoZerosInBSS - By default some codegens place zero-initialized data to .bss section. This flag disables such behaviour (necessary, e.g. for crt*.o compiling).

Definition at line 32 of file TargetMachine.cpp.

Referenced by isSuitableForBSS().

cl::opt<enum PassDebugLevel> llvm::PassDebugging("debug-pass", cl::Hidden, cl::desc("Print PassManager debugging information"), cl::values(clEnumVal(None,"disable debug output"),clEnumVal(Arguments,"print pass arguments to pass to 'opt'"),clEnumVal(Structure,"print pass structure before run()"),clEnumVal(Executions,"print pass name before it is executed"),clEnumVal(Details,"print pass details when it is executed"),clEnumValEnd)) [static]

Referenced by llvm::PMTopLevelManager::dumpArguments(), llvm::PMTopLevelManager::dumpPasses(), llvm::PMDataManager::dumpPassInfo(), llvm::PMDataManager::dumpPreservedSet(), llvm::PMDataManager::dumpRequiredSet(), llvm::PMDataManager::removeDeadPasses(), and llvm::PMDataManager::removeNotPreservedAnalysis().

bool llvm::PerformTailCallOpt

PerformTailCallOpt - This flag is enabled when -tailcallopt is specified on the commandline. When the flag is on, the target will perform tail call optimization (pop the caller's stack) providing it supports it.

Definition at line 37 of file TargetMachine.cpp.

Referenced by CalculateParameterAndLinkageAreaSize(), llvm::PPCRegisterInfo::eliminateCallFramePseudoInstr(), llvm::PPCRegisterInfo::emitEpilogue(), llvm::PPCTargetLowering::IsEligibleForTailCallOptimization(), llvm::SelectionDAGLowering::LowerCallTo(), needsFP(), and llvm::PPCRegisterInfo::processFunctionBeforeCalleeSavedScan().

const PassInfo *const llvm::PHIEliminationID = &X

PHIElimination pass - This pass eliminates machine instruction PHI nodes by inserting copy instructions. This destroys SSA information, but is the desired input for some register allocators. This pass is "required" by these register allocator like this: AU.addRequiredID(PHIEliminationID);

Definition at line 82 of file PHIElimination.cpp.

Referenced by llvm::SimpleRegisterCoalescing::getAnalysisUsage(), and llvm::LiveIntervals::getAnalysisUsage().

const PassInfo *const llvm::PreAllocSplittingID = &X

Definition at line 193 of file PreAllocSplitting.cpp.

bool llvm::PrintMachineCode

PrintMachineCode - This flag is enabled when the -print-machineinstrs option is specified on the command line, and should enable debugging output from the code generator.

Definition at line 25 of file TargetMachine.cpp.

Referenced by llvm::LLVMTargetMachine::addCommonCodeGenPasses(), llvm::LLVMTargetMachine::addPassesToEmitFile(), and llvm::LLVMTargetMachine::addPassesToEmitMachineCode().

const PassInfo *const llvm::PromoteMemoryToRegisterID = &X

Definition at line 87 of file Mem2Reg.cpp.

Referenced by llvm::UnifyFunctionExitNodes::getAnalysisUsage().

const bool llvm::pthread_enabled = true [static]

Definition at line 55 of file Mutex.cpp.

Referenced by llvm::sys::Mutex::acquire(), llvm::sys::Mutex::Mutex(), llvm::sys::Mutex::release(), llvm::sys::Mutex::tryacquire(), and llvm::sys::Mutex::~Mutex().

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst llvm::PtrToInt

Definition at line 172 of file InstVisitor.h.

Referenced by llvm::PtrToIntInst::classof(), llvm::CastInst::Create(), llvm::CastInst::getCastOpcode(), and llvm::Instruction::getOpcodeName().

bool llvm::RealignStack

RealignStack - This flag indicates, whether stack should be automatically realigned, if needed.

Definition at line 39 of file TargetMachine.cpp.

Referenced by llvm::X86RegisterInfo::needsStackRealignment().

Reloc::Model llvm::RelocationModel

Definition at line 35 of file TargetMachine.cpp.

Referenced by llvm::TargetMachine::getRelocationModel(), and llvm::TargetMachine::setRelocationModel().

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst ExtractValueInst VICmpInst llvm::RetTy

Definition at line 271 of file InstVisitor.h.

Referenced by llvm::FunctionValType::operator<(), and llvm::JIT::runFunction().

const PassInfo *const llvm::SimpleRegisterCoalescingID = &X

SimpleRegisterCoalescing pass. Aggressively coalesces every register copy it can.

Definition at line 69 of file SimpleRegisterCoalescing.cpp.

unsigned llvm::StackAlignment

StackAlignment - Override default stack alignment for target.

Definition at line 38 of file TargetMachine.cpp.

Referenced by llvm::X86Subtarget::X86Subtarget().

bool llvm::StrongPHIElim

StrongPHIElim - This flag enables more aggressive PHI elimination wth earlier copy coalescing.

Definition at line 42 of file TargetMachine.cpp.

Referenced by llvm::SimpleRegisterCoalescing::getAnalysisUsage(), and llvm::LiveIntervals::getAnalysisUsage().

const PassInfo *const llvm::StrongPHIEliminationID = &X

StrongPHIElimination pass - This pass eliminates machine instruction PHI nodes by inserting copy instructions. This destroys SSA information, but is the desired input for some register allocators. This pass is "required" by these register allocator like this: AU.addRequiredID(PHIEliminationID); This pass is still in development

Definition at line 154 of file StrongPHIElimination.cpp.

Referenced by llvm::SimpleRegisterCoalescing::getAnalysisUsage().

bool llvm::TimePassesIsEnabled = false

This is the storage for the -time-passes option.

If the user specifies the -time-passes argument on an LLVM tool command line then the value of this boolean will be true, otherwise false.

Definition at line 1507 of file PassManager.cpp.

const PassInfo *const llvm::TwoAddressInstructionPassID = &X

TwoAddressInstruction pass - This pass reduces two-address instructions to use two operands. This destroys SSA information but it is desired by register allocators.

Definition at line 111 of file TwoAddressInstructionPass.cpp.

Referenced by llvm::SimpleRegisterCoalescing::getAnalysisUsage(), and llvm::LiveIntervals::getAnalysisUsage().

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst llvm::UIToFP

Definition at line 168 of file InstVisitor.h.

Referenced by llvm::UIToFPInst::classof(), llvm::CastInst::Create(), llvm::CastInst::getCastOpcode(), and llvm::Instruction::getOpcodeName().

const PassInfo *const llvm::UnreachableMachineBlockElimID = &Y

UnreachableMachineBlockElimination pass - This pass removes unreachable machine basic blocks.

Definition at line 103 of file UnreachableBlockElim.cpp.

Referenced by llvm::LiveVariables::getAnalysisUsage().

bool llvm::UnsafeFPMath

UnsafeFPMath - This flag is enabled when the -enable-unsafe-fp-math flag is specified on the command line. When this flag is off (the default), the code generator is not allowed to produce results that are "less precise" than IEEE allows. This includes use of X86 instructions like FSIN and FCOS instead of libcalls. UnsafeFPMath implies FiniteOnlyFPMath.

Definition at line 28 of file TargetMachine.cpp.

Referenced by FiniteOnlyFPMath(), GetNegatedExpression(), llvm::SelectionDAG::getNode(), HonorSignDependentRoundingFPMath(), isNegatibleForFree(), PerformSELECTCombine(), and llvm::X86TargetLowering::X86TargetLowering().

bool llvm::UnwindTablesMandatory

UnwindTablesMandatory - This flag indicates that unwind tables should be emitted for all functions.

Definition at line 34 of file TargetMachine.cpp.

Referenced by llvm::X86RegisterInfo::emitPrologue(), llvm::PPCRegisterInfo::emitPrologue(), and llvm::XCoreRegisterInfo::needsFrameMoves().

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst llvm::UserOp1

Definition at line 184 of file InstVisitor.h.

bool llvm::UseSoftFloat

UseSoftFloat - This flag is enabled when the -soft-float flag is specified on the command line. When this flag is on, the code generator will generate libcalls to the software floating point library instead of target FP instructions.

Definition at line 31 of file TargetMachine.cpp.

Referenced by llvm::ARMTargetLowering::ARMTargetLowering().

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction llvm::VAArg

Definition at line 186 of file InstVisitor.h.

Referenced by llvm::VAArgInst::classof(), llvm::Instruction::getOpcodeName(), and llvm::Instruction::isTrapping().

bool llvm::VerboseAsm

VerboseAsm - When this flag is set, the asm printer prints additional comments to asm directives.

Definition at line 40 of file TargetMachine.cpp.

Referenced by llvm::AsmPrinter::EOL().

bool llvm::VerifyDomInfo = false

Definition at line 46 of file PassManager.cpp.

Referenced by llvm::PMDataManager::verifyDomInfo().

cl::opt<bool,true> llvm::VerifyDomInfoX("verify-dom-info", cl::location(VerifyDomInfo), cl::desc("Verify dominator info (time consuming)")) [static]

BinaryOperator MallocInst LoadInst ZExtInst FPToUIInst UIToFPInst FPTruncInst PtrToIntInst BitCastInst FCmpInst CallInst Instruction VAArgInst InsertElementInst ExtractValueInst llvm::VICmp

Definition at line 192 of file InstVisitor.h.

Referenced by llvm::Instruction::getOpcodeName().

const char *const llvm::x86_asm_table

Initial value:

 {
  "{si}", "S",
  "{di}", "D",
  "{ax}", "a",
  "{cx}", "c",
  "{memory}", "memory",
  "{flags}", "",
  "{dirflag}", "",
  "{fpsr}", "",
  "{cc}", "cc",
  0,0}

Definition at line 28 of file X86TargetAsmInfo.cpp.

Referenced by llvm::X86TargetAsmInfo< llvm::TargetAsmInfo >::X86TargetAsmInfo().

BinaryOperator MallocInst LoadInst llvm::ZExt

Definition at line 164 of file InstVisitor.h.

Referenced by llvm::ZExtInst::classof(), llvm::CastInst::Create(), llvm::CastInst::getCastOpcode(), llvm::Instruction::getOpcodeName(), and llvm::ISD::ArgFlagsTy::isZExt().