LLVM  mainline
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
___itt_api_info
___itt_api_info_20101001
___itt_global
___itt_group_list
___itt_thread_info
_iJIT_Method_Id
_iJIT_Method_Load
_iJIT_Method_NIDS
_LineNumberInfo
llvm::A57ChainingConstraintAdd the accumulator chaining constraint to a PBQP graph
llvm::AAMDNodesA collection of metadata nodes that might be associated with a memory access used by the alias-analysis infrastructure
llvm::AArch64_ELFTargetObjectFileThis implementation is used for AArch64 ELF targets (Linux in particular)
llvm::AArch64_MachoTargetObjectFileAArch64_MachoTargetObjectFile - This TLOF implementation is used for Darwin
llvm::AArch64AppleInstPrinter
llvm::AArch64beTargetMachine
llvm::AArch64Disassembler
llvm::AArch64ExternalSymbolizer
llvm::AArch64FrameLowering
llvm::AArch64FunctionInfoAArch64FunctionInfo - This class is derived from MachineFunctionInfo and contains private AArch64-specific information for each MachineFunction
AArch64GenInstrInfo
AArch64GenRegisterInfo
AArch64GenSubtargetInfo
llvm::AArch64InstPrinter
llvm::AArch64InstrInfo
llvm::AArch64leTargetMachine
llvm::AArch64MCAsmInfoDarwin
llvm::AArch64MCAsmInfoELF
llvm::AArch64MCExpr
llvm::AArch64MCInstLowerAArch64MCInstLower - This class is used to lower an MachineInstr into an MCInst
llvm::AArch64NamedImmMapperInstances of this class can perform bidirectional mapping from random identifier strings to operand encodings
llvm::AArch64RegisterInfo
llvm::AArch64SelectionDAGInfo
AArch64SetCCInfoHelper structure to keep track of a SET_CC lowered into AArch64 code
llvm::AArch64Subtarget
llvm::AArch64TargetLowering
llvm::AArch64TargetMachine
llvm::AArch64TargetStreamer
llvm::AArch64TTIImpl
llvm::AbstractLatticeFunctionAbstractLatticeFunction - This class is implemented by the dataflow instance to specify what the lattice values are and how they handle merges etc
llvm::EHStreamer::ActionEntryStructure describing an entry in the actions table
llvm::ActionHandler
llvm::Registry< T, U >::Add< V >A static registration template
llvm::add_const_past_pointer< T, Enable >If T is a pointer to X, return a pointer to const X
llvm::add_const_past_pointer< T, typename std::enable_if< std::is_pointer< T >::value >::type >
llvm::add_lvalue_reference_if_not_pointer< T, Enable >If T is a pointer, just return it. If it is not, return T&
llvm::add_lvalue_reference_if_not_pointer< T, typename std::enable_if< std::is_pointer< T >::value >::type >
llvm::AddOperator
llvm::AddressPool
llvm::TargetLoweringBase::AddrModeThis represents an addressing mode of: BaseGV + BaseOffs + BaseReg + Scale*ScaleReg If BaseGV is null, there is no BaseGV
llvm::AddrSpaceCastInstThis class represents a conversion between pointers from one address space to another
llvm::AddrSpaceCastSDNode
AddSubFlagsOpcodePairMap pseudo instructions that imply an 'S' bit onto real opcodes
llvm::PBQP::Graph< SolverT >::AdjEdgeIdSet
llvm::AggressiveAntiDepBreaker
llvm::AggressiveAntiDepStateContains all the state necessary for anti-dep breaking
llvm::cl::alias
llvm::AliasAnalysis
llvm::cl::aliasopt
llvm::AliasSet
llvm::AliasSetTracker
AlignedCharArrayHelper for building an aligned character array type
AlignedCharArray
llvm::AlignedCharArrayUnion< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >This union template exposes a suitably aligned and sized character array member which can hold elements of any of up to ten types
llvm::detail::AlignerImpl< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >
llvm::AlignmentCalcImpl< T >
llvm::AlignOf< T >AlignOf - A templated class that contains an enum value representing the alignment of the template argument
llvm::AllocaHolder
llvm::AllocaInstAllocaInst - an instruction to allocate memory on the stack
llvm::AllocationOrder
llvm::AllocatorBase< DerivedT >CRTP base class providing obvious overloads for the core Allocate() methods of LLVM-style allocators
AllocFnsTy
llvm::PBQP::RegAlloc::AllowedRegVectorHolds a vector of the allowed physical regs for a vreg
amd_kernel_code_sAMD Kernel Code Object (amd_kernel_code_t)
llvm::AMDGPUAsmPrinter
llvm::AMDGPUFrameLoweringInformation about the stack frame layout on the AMDGPU targets
AMDGPUGenInstrInfo
AMDGPUGenRegisterInfo
AMDGPUGenSubtargetInfo
llvm::AMDGPUInstPrinter
llvm::AMDGPUInstrInfo
llvm::AMDGPUIntrinsicInfo
llvm::AMDGPUMachineFunction
llvm::AMDGPUMCAsmInfo
llvm::AMDGPUMCCodeEmitter
llvm::AMDGPUMCInstLower
llvm::AMDGPURegisterInfo
llvm::AMDGPUSubtarget
llvm::AMDGPUTargetLowering
llvm::AMDGPUTargetMachine
llvm::AMDGPUTTIImpl
llvm::AnalysisCallGraphWrapperPassTraits
llvm::AnalysisManager< IRUnitT >A generic analysis pass manager with lazy running and caching of results
llvm::detail::AnalysisManagerBase< DerivedT, IRUnitT >A CRTP base used to implement analysis managers
llvm::detail::AnalysisPassConcept< IRUnitT >Abstract concept of an analysis pass
llvm::detail::AnalysisPassModel< IRUnitT, PassT, false >Specialization of AnalysisPassModel which does not pass an AnalysisManager to PassT's run method
llvm::detail::AnalysisPassModel< IRUnitT, PassT, true >Specialization of AnalysisPassModel which passes an AnalysisManager to PassT's run method
llvm::AnalysisResolver
llvm::detail::AnalysisResultConcept< IRUnitT >Abstract concept of an analysis result
llvm::detail::AnalysisResultModel< IRUnitT, PassT, ResultT, PreservedAnalysesT, false >Specialization of AnalysisResultModel which provides the default invalidate functionality
llvm::detail::AnalysisResultModel< IRUnitT, PassT, ResultT, PreservedAnalysesT, true >Specialization of AnalysisResultModel which delegates invalidate handling to ResultT
llvm::AnalysisUsage
llvm::AnonStructTypeKeyInfo
llvm::AntiDepBreakerThis class works in conjunction with the post-RA scheduler to rename registers to break register anti-dependencies (WAR hazards)
llvm::MachO::any_relocation_info
llvm::PatternMatch::AnyBinaryOp_match< LHS_t, RHS_t >
llvm::APByteStreamer
llvm::APFloatA self-contained host- and target-independent arbitrary-precision floating-point software implementation
llvm::PatternMatch::api_pred_ty< Predicate >This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to an APInt
llvm::APIntClass for arbitrary precision integers
llvm::PatternMatch::apint_match
llvm::cl::applicator< Mod >
llvm::cl::applicator< char[n]>
llvm::cl::applicator< const char * >
llvm::cl::applicator< const char[n]>
llvm::cl::applicator< FormattingFlags >
llvm::cl::applicator< MiscFlags >
llvm::cl::applicator< NumOccurrencesFlag >
llvm::cl::applicator< OptionHidden >
llvm::cl::applicator< ValueExpected >
llvm::APSInt
ArangeSpan
llvm::object::Archive
llvm::object::ArchiveMemberHeader
llvm::object::ELFFile< ELFT >::ArchivePointerTypeTraits< T >Archive files are 2 byte aligned, so we need this for PointerIntPair to work
llvm::objcarc::ARCMDKindCacheA cache of MDKinds used by various ARC optimizations
llvm::objcarc::ARCRuntimeEntryPointsDeclarations for ObjC runtime functions and constants
llvm::opt::ArgA concrete instance of a particular driver option
llvm::opt::arg_iteratorArg_iterator - Iterates through arguments stored inside an ArgList
llvm::ISD::ArgFlagsTy
llvm::opt::ArgListArgList - Ordered collection of driver arguments
llvm::TargetLowering::ArgListEntry
llvm::FastISel::ArgListEntry
llvm::ArgumentLLVM Argument representation
llvm::PatternMatch::Argument_match< Opnd_t >
ARM_MLxEntryARM_MLxEntry - Record information about MLA / MLS instructions
llvm::ARMAsmPrinter
llvm::ARMBaseInstrInfo
llvm::ARMBaseRegisterInfo
llvm::ARMBaseTargetMachine
llvm::ARMBETargetMachineARMBETargetMachine - ARM big endian target machine
llvm::ARMCOFFMCAsmInfoGNU
llvm::ARMCOFFMCAsmInfoMicrosoft
llvm::ARMConstantPoolConstantARMConstantPoolConstant - ARM-specific constant pool values for Constants, Functions, and BlockAddresses
llvm::ARMConstantPoolMBBARMConstantPoolMBB - ARM-specific constantpool value of a machine basic block
llvm::ARMConstantPoolSymbolARMConstantPoolSymbol - ARM-specific constantpool values for external symbols
llvm::ARMConstantPoolValueARMConstantPoolValue - ARM specific constantpool value
llvm::ARMELFMCAsmInfo
llvm::ARMElfTargetObjectFile
llvm::ARMException
llvm::ARMFrameLowering
llvm::ARMFunctionInfoARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific information for each MachineFunction
ARMGenInstrInfo
ARMGenRegisterInfo
ARMGenSubtargetInfo
llvm::ARMHazardRecognizerARMHazardRecognizer handles special constraints that are not expressed in the scheduling itinerary
llvm::ARMInstPrinter
llvm::ARMInstrInfo
llvm::ARMLETargetMachineARMLETargetMachine - ARM little endian target machine
llvm::ARMMCAsmInfoDarwin
llvm::ARMMCExpr
llvm::ARMRegisterInfo
llvm::ARMSelectionDAGInfo
llvm::ARMSubtarget
llvm::ARMTargetLowering
llvm::ARMTargetMachineARMTargetMachine - ARM target machine
llvm::ARMTargetParser
llvm::ARMTargetStreamer
llvm::ARMTTIImpl
llvm::LiveIntervalUnion::Array
llvm::ArrayRecycler< T, Align >Recycle small arrays allocated from a BumpPtrAllocator
llvm::ArrayRef< T >ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory), i.e
llvm::ArrayTypeArrayType - Class to represent array types
llvm::ASanStackFrameLayout
llvm::ASanStackVariableDescription
llvm::AShrOperator
llvm::AsmCondAsmCond - Class to support conditional assembly
llvm::AsmLexerAsmLexer - Lexer class for assembly files
llvm::TargetLowering::AsmOperandInfoThis contains information for each constraint that we are lowering
llvm::AsmPrinterThis class is intended to be used as a driving class for all asm writers
llvm::AsmPrinterHandlerCollects and handles AsmPrinter objects required to build debug or EH information
llvm::AsmRewrite
llvm::AsmTokenTarget independent representation for an assembler token
llvm::AssemblerConstantPools
llvm::AssemblyAnnotationWriter
llvm::AssertingVH< ValueTy >Value handle that asserts if the Value is deleted
llvm::AssumptionAnalysisA function analysis which provides an AssumptionCache
llvm::AssumptionCacheA cache of .assume calls within a function
llvm::AssumptionCacheTrackerAn immutable pass that tracks lazily created AssumptionCache objects
llvm::AssumptionPrinterPassPrinter pass for the AssumptionAnalysis results
llvm::AArch64AT::ATMapper
llvm::DwarfAccelTable::Atom
llvm::AtomicCmpXchgInstAtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there
llvm::AtomicRMWInstAtomicRMWInst - an instruction that atomically reads a memory location, combines it with another value, and then stores the result back
llvm::AtomicSDNodeThis is an SDNode representing atomic operations
llvm::AttrBuilder
llvm::Attribute
llvm::AttributeImpl
llvm::AttributeSet
llvm::AttributeSetImpl
llvm::AttributeSetNode
llvm::DWARFAbbreviationDeclaration::AttributeSpec
llvm::COFF::Auxiliary
llvm::COFF::AuxiliarybfAndefSymbol
llvm::COFF::AuxiliaryCLRToken
llvm::COFF::AuxiliaryFunctionDefinition
llvm::COFF::AuxiliarySectionDefinition
llvm::COFF::AuxiliaryWeakExternal
llvm::object::BaseRelocRef
llvm::yaml::basic_collection_iterator< BaseT, ValueT >This is an iterator abstraction over YAML collections shared by both sequences and maps
llvm::cl::basic_parser< DataType >
llvm::cl::basic_parser_impl
llvm::BasicBlockLLVM Basic Block Representation
llvm::BasicBlockEdge
llvm::BasicBlockPassBasicBlockPass class - This class is used to implement most local optimizations
llvm::BasicBlockSDNode
llvm::object::BasicSymbolRefThis is a value type class that represents a single symbol in the list of symbols in the object file
llvm::BasicTTIImplConcrete BasicTTIImpl that can be used if no further customization is needed
llvm::BasicTTIImplBase< T >Base class which can be used to help build a TTI implementation
llvm::COFF::BigObjHeader
llvm::object::Binary
binary_function
llvm::BinaryConstantExprBinaryConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement binary constant exprs
llvm::coverage::BinaryCoverageReaderReader for the coverage mapping data that is emitted by the frontend and stored in an object file
llvm::PatternMatch::BinaryOp_match< LHS_t, RHS_t, Opcode >
llvm::BinaryOperator
llvm::yaml::BinaryRefSpecialized YAMLIO scalar type for representing a binary blob
llvm::BinarySDNodeThis class is used for two-operand SDNodes
llvm::BinaryWithFlagsSDNodeThis class is an extension of BinarySDNode used from those opcodes that have associated extra flags
llvm::PatternMatch::bind_const_intval_ty
llvm::PatternMatch::bind_ty< Class >
llvm::PatternMatch::BinOp2_match< LHS_t, RHS_t, Opc1, Opc2 >
llvm::BinOpInitBinOpInit - !op (X, Y) - Combine two inits
llvm::BitCastInstThis class represents a no-op cast from one type to another
llvm::BitCastOperator
llvm::BitCodeAbbrevBitCodeAbbrev - This class represents an abbreviation record
llvm::BitCodeAbbrevOpBitCodeAbbrevOp - This describes one or more operands in an abbreviation
llvm::BitcodeDiagnosticInfo
llvm::BitcodeWriterPassPass for writing a module of IR out to a bitcode file
llvm::BitInitBitInit - true/false - Represent a concrete initializer for a bit
llvm::BitRecTyBitRecTy - 'bit' - Represent a single bit
llvm::cl::bits< DataType, Storage, ParserClass >
llvm::cl::bits_storage< DataType, StorageClass >
llvm::cl::bits_storage< DataType, bool >
bitset
llvm::BitSetBuilder
llvm::BitSetInfo
llvm::BitsInitBitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value
llvm::BitsRecTyBitsRecTy - 'bits<n>' - Represent a fixed number of bits
llvm::BitstreamCursorThis represents a position within a bitcode file
llvm::BitstreamEntryWhen advancing through a bitstream cursor, each advance can discover a few different kinds of entries:
llvm::BitstreamReaderThis class is used to read from an LLVM bitcode stream, maintaining information that is global to decoding the entire file
llvm::BitstreamWriter
llvm::BitVector
llvm::RegionBase< Tr >::block_iterator_wrapper< IsConst >
llvm::BlockAddressBlockAddress - The address of a basic block
llvm::BlockAddressSDNode
llvm::SpillPlacement::BlockConstraintBlockConstraint - Entry and exit constraints for a basic block
llvm::bfi_detail::BlockEdgesAdder< BT >
llvm::BlockFrequency
llvm::BlockFrequencyInfoBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequencies
llvm::BlockFrequencyInfoImpl< BT >Shared implementation for block frequency analysis
llvm::BlockFrequencyInfoImplBaseBase class for BlockFrequencyInfoImpl
llvm::SplitAnalysis::BlockInfoAdditional information about basic blocks where the current variable is live
llvm::BitstreamReader::BlockInfoThis contains information emitted to BLOCKINFO_BLOCK blocks
llvm::bfi_detail::BlockMassMass of a block
llvm::BlockFrequencyInfoImplBase::BlockNodeRepresentative of a block
llvm::yaml::BlockScalarTraits< T >This class should be specialized by type that requires custom conversion to/from a YAML literal block scalar
llvm::yaml::BlockScalarTraits< Module >This struct serializes the LLVM IR module
llvm::BlotMapVector< KeyT, ValueT >An associative container with fast insertion-order (deterministic) iteration over its elements
llvm::objcarc::BottomUpPtrState
llvm::BPFFrameLowering
BPFGenInstrInfo
BPFGenRegisterInfo
BPFGenSubtargetInfo
llvm::BPFInstPrinter
llvm::BPFInstrInfo
llvm::BPFMCAsmInfo
llvm::BPFMCInstLower
llvm::BPFRegisterInfo
llvm::BPFSubtarget
llvm::BPFTargetLowering
llvm::BPFTargetMachine
llvm::PatternMatch::br_match
llvm::SystemZII::Branch
llvm::BranchFolder
llvm::BranchInstBranchInst - Conditional or Unconditional Branch instruction
llvm::IntervalMapImpl::BranchNode< KeyT, ValT, N, Traits >
llvm::BranchProbability
llvm::BranchProbabilityInfoAnalysis pass providing branch probability information
llvm::PatternMatch::brc_match< Cond_t >
llvm::buffer_ostream
llvm::BufferByteStreamer
llvm::build_index_impl< N, I >
llvm::build_index_impl< 0, I...>
llvm::BuildVectorSDNodeA "pseudo-class" with methods for operating on BUILD_VECTORs
llvm::BumpPtrAllocatorImpl< AllocatorT, SlabSize, SizeThreshold >Allocate memory in an ever growing pool, as if by bump-pointer
llvm::MachineBasicBlock::bundle_iterator< Ty, IterTy >Bundle_iterator - MachineBasicBlock iterator that automatically skips over MIs that are inside bundles (i.e
llvm::ByteArrayBuilderThis class is used to build a byte array containing overlapping bit sets
llvm::ByteStreamer
llvm::CallbackVHValue handle with callbacks on RAUW and destruction
llvm::CalleeSavedInfoTracks the information need to locate where a callee saved register is in the current frame
llvm::CallGraphThe basic data container for the call graph of a Module of IR
llvm::CallGraphAnalysisAn analysis pass to compute the CallGraph for a Module
llvm::CallGraphNodeA node in the call graph for a module
llvm::CallGraphSCCCallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on
llvm::CallGraphSCCPass
llvm::CallGraphWrapperPassThe ModulePass which wraps up a CallGraph and the logic to build it
llvm::CallInstCallInst - This class represents a function call, abstracting a target machine's calling convention
llvm::TargetLowering::CallLoweringInfoThis structure contains all information that is necessary for lowering calls
llvm::FastISel::CallLoweringInfo
llvm::CallSite
llvm::CallSiteBase< FunTy, ValTy, UserTy, InstrTy, CallTy, InvokeTy, IterTy >
llvm::EHStreamer::CallSiteEntryStructure describing an entry in the call-site table
llvm::GenericSchedulerBase::CandPolicyPolicy for scheduling the next instruction in the candidate's zone
llvm::ArrayRecycler< T, Align >::CapacityThe size of an allocated array is represented by a Capacity instance
llvm::CaptureTrackerThis callback is used in conjunction with PointerMayBeCaptured
llvm::SwitchInst::CaseIt
llvm::SwitchInst::CaseIteratorT< SwitchInstTy, ConstantIntTy, BasicBlockTy >
llvm::cast_convert_val< To, From, SimpleFrom >
llvm::cast_convert_val< To, FromTy, FromTy >
llvm::cast_retty< To, From >
llvm::cast_retty_impl< To, From >
llvm::cast_retty_impl< To, const From * >
llvm::cast_retty_impl< To, const From *const >
llvm::cast_retty_impl< To, const From >
llvm::cast_retty_impl< To, From * >
llvm::cast_retty_wrap< To, From, SimpleFrom >
llvm::cast_retty_wrap< To, FromTy, FromTy >
llvm::PatternMatch::CastClass_match< Op_t, Opcode >
llvm::CastInstThis is the base class for all instructions that perform data casts
llvm::cl::cat
llvm::CatchHandler
cclass
llvm::CCStateCCState - This class holds information needed while lowering arguments and return values
llvm::CCValAssignCCValAssign - Represent assignment of one arg/retval to a location
llvm::CGSCCAnalysisManagerFunctionProxyA function analysis which acts as a proxy for a CGSCC analysis manager
llvm::CGSCCAnalysisManagerModuleProxyA module analysis which acts as a proxy for a CGSCC analysis manager
llvm::CGSCCToFunctionPassAdaptor< FunctionPassT >Adaptor that maps from a SCC to its functions
false::ChainA Chain is a sequence of instructions that are linked together by an accumulation operand
llvm::object::Archive::Child
llvm::object::Archive::child_iterator
llvm::circular_raw_ostreamCircular_raw_ostream - A raw_ostream which *can* save its data to a circular buffer, or can pass it through directly to an underlying stream if specified with a buffer of zero
llvm::PatternMatch::class_match< Class >
llvm::CleanupHandler
llvm::ClonedCodeInfoClonedCodeInfo - This struct can be used to capture information about code being cloned, while it is being cloned
llvm::CloningDirectorA helper class used with CloneAndPruneIntoFromInst to change the default behavior while instructions are being cloned
llvm::PatternMatch::CmpClass_match< LHS_t, RHS_t, Class, PredicateTy >
llvm::CmpInstThis class is the base class for the comparison instructions
cname
llvm::CoalescerPairA helper class for register coalescers
llvm::CodeExtractorUtility class for extracting code into a new function
llvm::CodeMetricsUtility to calculate the size and a few similar metrics for a set of basic blocks
llvm::object::coff_aux_bf_and_ef_symbol
llvm::object::coff_aux_clr_token
llvm::object::coff_aux_function_definition
llvm::object::coff_aux_section_definition
llvm::object::coff_aux_weak_external
llvm::object::coff_base_reloc_block_entry
llvm::object::coff_base_reloc_block_header
llvm::object::coff_bigobj_file_header
llvm::object::coff_file_header
llvm::object::coff_import_directory_table_entry
llvm::object::coff_import_header
llvm::object::coff_load_configuration32
llvm::object::coff_load_configuration64
llvm::object::coff_relocation
llvm::object::coff_runtime_function_x64
llvm::object::coff_section
llvm::object::coff_symbol< SectionNumberType >
llvm::object::COFFObjectFile
llvm::object::COFFSymbolRef
llvm::Comdat
CommonHandleTraits
llvm::CompareConstantExpr
llvm::EVT::compareRawBitsCompareRawBits - A meaningless but well-behaved order, useful for constructing containers
llvm::orc::JITCompileCallbackManagerBase::CompileCallbackInfoHandle to a newly created compile callback
llvm::orc::CompileOnDemandLayer< BaseLayerT, CompileCallbackMgrT, PartitioningFtor >Compile-on-demand layer
llvm::LineEditor::CompletionA possible completion at a given cursor position
llvm::LineEditor::CompletionActionThe action to perform upon a completion request
llvm::CompositeTypeCompositeType - Common super class of ArrayType, StructType, PointerType and VectorType
llvm::TargetTransformInfo::Concept
llvm::ConcreteOperator< SuperClass, Opc >A helper template for defining operators for individual opcodes
llvm::ConcreteSymbolEnumerator< ChildType >
llvm::CondCodeSDNode
llvm::ConnectedVNInfoEqClassesConnectedVNInfoEqClasses - Helper class that can divide VNInfos in a LiveInterval into equivalence clases of connected components
llvm::IntervalMap< KeyT, ValT, N, Traits >::const_iterator
llvm::sys::path::const_iteratorPath iterator
llvm::ConstantThis is an important base class in LLVM
llvm::ConstantAggregateZeroConstantAggregateZero - All zero aggregate value
llvm::ConstantAggrKeyType< ConstantClass >
llvm::ConstantArrayConstantArray - Constant Array Declarations
llvm::ConstantAsMetadata
llvm::ConstantDataArrayConstantDataArray - An array constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e
llvm::ConstantDataSequentialConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e
llvm::ConstantDataVectorConstantDataVector - A vector constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e
llvm::ConstantExprConstantExpr - a constant value that is initialized with an expression using other constant values
llvm::ConstantExprKeyType
llvm::ConstantFolderConstantFolder - Create constants with minimum, target independent, folding
llvm::ConstantFPConstantFP - Floating Point Values [float, double]
llvm::ConstantFPSDNode
llvm::ConstantInfo< ConstantArray >
llvm::ConstantInfo< ConstantExpr >
llvm::ConstantInfo< ConstantStruct >
llvm::ConstantInfo< ConstantVector >
llvm::ConstantInfo< InlineAsm >
llvm::ConstantIntThis is the shared class of boolean and integer constants
llvm::PatternMatch::constantint_match< Val >
llvm::ConstantPointerNullConstantPointerNull - a constant pointer value that points to null
llvm::ConstantPool
llvm::ConstantPoolEntry
llvm::ConstantPoolSDNode
llvm::ConstantRangeThis class represents a range of values
llvm::ConstantSDNode
llvm::ConstantStruct
llvm::ConstantUniqueMap< ConstantClass >
llvm::ConstantVectorConstantVector - Constant Vector Declarations
llvm::DenseSet< ValueT, ValueInfoT >::ConstIterator
llvm::ConstMIBundleOperandsConstMIBundleOperands - Iterate over all operands in a const bundle of machine instructions
llvm::ConstMIOperandsConstMIOperands - Iterate over operands of a single const instruction
llvm::InlineAsm::ConstraintInfo
llvm::object::content_iterator< content_type >
llvm::ContextAndReplaceableUsesPointer to the context, with optional RAUW support
ContextDecisionSpecifies which opcode->instruction tables to look at given a particular context (set of attributes)
llvm::ContextualFoldingSetTrait< T, Ctx >ContextualFoldingSetTrait - Like FoldingSetTrait, but for ContextualFoldingSets
llvm::ConvergingVLIWSchedulerConvergingVLIWScheduler shrinks the unscheduled zone using heuristics to balance the schedule
llvm::CostTblEntry< TypeTy >Cost Table Entry
llvm::coverage::CountedRegionAssociates a source range with an execution count
llvm::coverage::CounterA Counter is an abstract value that describes how to compute the execution count for a region of code using the collected profile count data
llvm::coverage::CounterExpressionA Counter expression is a value that represents an arithmetic operation with two counters
llvm::coverage::CounterExpressionBuilderA Counter expression builder is used to construct the counter expressions
llvm::coverage::CounterMappingContextA Counter mapping context is used to connect the counters, expressions and the obtained counter values
llvm::coverage::CounterMappingRegionA Counter mapping region associates a source range with a specific counter
llvm::coverage::CoverageDataCoverage information to be processed or displayed
llvm::coverage::CoverageFilenamesSectionWriterWriter of the filenames section for the instrumentation based code coverage
llvm::coverage::CoverageMappingThe mapping of profile information to coverage data
llvm::coverage::CoverageMappingIteratorA file format agnostic iterator over coverage mapping data
llvm::coverage::CoverageMappingReader
llvm::coverage::CoverageMappingRecordCoverage mapping information for a single function
llvm::coverage::CoverageMappingWriterWriter for instrumentation based coverage mapping data
llvm::coverage::CoverageSegmentThe execution count information starting at a point in a file
llvm::CPPTargetMachine
llvm::CrashRecoveryContextCrash recovery helper object
llvm::CrashRecoveryContextCleanup
llvm::CrashRecoveryContextCleanupBase< DERIVED, T >
llvm::CrashRecoveryContextCleanupRegistrar< T, Cleanup >
llvm::CrashRecoveryContextDeleteCleanup< T >
llvm::CrashRecoveryContextDestructorCleanup< T >
llvm::CrashRecoveryContextReleaseRefCleanup< T >
llvm::CriticalAntiDepBreaker
llvm::CriticalEdgeSplittingOptionsOption class for critical edge splitting
CryptContextTraits
cset
llvm::PatternMatch::cst_pred_ty< Predicate >This helper class is used to match scalar and vector constants that satisfy a specified predicate
llvm::orc::CtorDtorIteratorThis iterator provides a convenient way to iterate over the elements of an llvm.global_ctors/llvm.global_dtors instance
llvm::orc::CtorDtorRunner< JITLayerT >Convenience class for recording constructor/destructor names for later execution
llvm::InterferenceCache::CursorCursor - The primary query interface for the block interference cache
llvm::CvtRndSatSDNodeNOTE: avoid using this node as this may disappear in the future and most targets don't support it
llvm::TargetLowering::DAGCombinerInfo
llvm::DAGDeltaAlgorithmDAGDeltaAlgorithm - Implements a "delta debugging" algorithm for minimizing directed acyclic graphs using a predicate function
llvm::DagInitDagInit - (v a, b) - Represent a DAG tree value
llvm::DagRecTyDagRecTy - 'dag' - Represent a dag fragment
llvm::DAGTypeLegalizerDAGTypeLegalizer - This takes an arbitrary SelectionDAG as input and hacks on it until only value types the target machine can handle are left
llvm::SelectionDAG::DAGUpdateListenerClients of various APIs that cause global effects on the DAG can optionally implement this interface
llvm::object::data_directory
llvm::MachO::data_in_code_entry
llvm::OnDiskIterableChainedHashTable< Info >::data_iteratorIterates over all the entries in the table, returning the data
llvm::COFF::DataDirectory
llvm::DataExtractor
llvm::DataLayoutA parsed version of the target data layout string in and methods for querying it
llvm::object::DataRefImpl
llvm::DataRegionData
llvm::DataStreamer
DataType
llvm::AArch64DB::DBarrierMapper
llvm::DbgDeclareInstDbgDeclareInst - This represents the llvm.dbg.declare instruction
llvm::DbgInfoIntrinsicDbgInfoIntrinsic - This is the common base class for debug info intrinsics
llvm::DbgValueHistoryMap
llvm::DbgValueInstDbgValueInst - This represents the llvm.dbg.value instruction
llvm::DbgVariableThis class is used to track local variable information
llvm::AArch64DC::DCMapper
llvm::DebugEpochBase
llvm::DebugInfoFinderUtility to find all debug info in a module
llvm::DebugLocA debug info location
llvm::DebugLocDwarfExpressionDwarfExpression implementation for .debug_loc entries
llvm::DebugLocEntryThis struct describes location entries emitted in the .debug_loc section
llvm::DebugLocStreamByte stream of .debug_loc entries
decimalInfo
llvm::DefaultAnalysisGraphTraits< AnalysisT, GraphT >Default traits class for extracting a graph from an analysis pass
llvm::DefaultContextualFoldingSetTrait< T, Ctx >DefaultContextualFoldingSetTrait - Like DefaultFoldingSetTrait, but for ContextualFoldingSets
llvm::DefaultDOTGraphTraitsDefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits methods
llvm::DefaultFoldingSetTrait< T >DefaultFoldingSetTrait - This class provides default implementations for FoldingSetTrait implementations
llvm::DefaultVLIWScheduler
llvm::DefInitDefInit - AL - Represent a reference to a 'def' in the description
llvm::MachineRegisterInfo::defusechain_instr_iterator< ReturnUses, ReturnDefs, SkipDebug, ByOperand, ByInstr, ByBundle >Defusechain_iterator - This class provides iterator support for machine operands in the function that use or define a specific register
llvm::MachineRegisterInfo::defusechain_iterator< ReturnUses, ReturnDefs, SkipDebug, ByOperand, ByInstr, ByBundle >Defusechain_iterator - This class provides iterator support for machine operands in the function that use or define a specific register
llvm::object::delay_import_directory_table_entry
llvm::object::DelayImportDirectoryEntryRef
llvm::LiveRangeEdit::DelegateCallback methods for LiveRangeEdit owners
llvm::MachineRegisterInfo::Delegate
llvm::DeltaAlgorithmDeltaAlgorithm - Implements the delta debugging algorithm (A
llvm::DenseMap< KeyT, ValueT, KeyInfoT, BucketT >
llvm::DenseMapAPFloatKeyInfo
llvm::DenseMapAPIntKeyInfo
llvm::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT >
llvm::DenseMapInfo< T >
llvm::DenseMapInfo< AAMDNodes >
llvm::DenseMapInfo< AssertingVH< T > >
llvm::DenseMapInfo< AttributeSet >
llvm::DenseMapInfo< CallValue >
llvm::DenseMapInfo< char >
llvm::DenseMapInfo< CIEKey >
llvm::DenseMapInfo< coverage::CounterExpression >Provide DenseMapInfo for CounterExpression
llvm::DenseMapInfo< DivOpInfo >
llvm::DenseMapInfo< Expression >
llvm::DenseMapInfo< ImmutableList< T > >
llvm::DenseMapInfo< int >
llvm::DenseMapInfo< long >
llvm::DenseMapInfo< long long >
llvm::DenseMapInfo< LoweredPHIRecord >
llvm::DenseMapInfo< MemoryLocation >
llvm::DenseMapInfo< PointerIntPair< PointerTy, IntBits, IntType > >
llvm::DenseMapInfo< PointerUnion< T, U > >
llvm::DenseMapInfo< sampleprof::LineLocation >
llvm::DenseMapInfo< SDValue >
llvm::DenseMapInfo< SimpleValue >
llvm::DenseMapInfo< std::pair< T, U > >
llvm::DenseMapInfo< T * >
llvm::DenseMapInfo< TableGenStringKey >Specialize DenseMapInfo for TableGenStringKey
llvm::DenseMapInfo< unsigned >
llvm::DenseMapInfo< unsigned long >
llvm::DenseMapInfo< unsigned long long >
llvm::DenseMapInfo< ValueMapCallbackVH< KeyT, ValueT, Config > >
llvm::DenseMapIterator< KeyT, ValueT, KeyInfoT, Bucket, IsConst >
llvm::detail::DenseMapPair< KeyT, ValueT >
llvm::DenseSet< ValueT, ValueInfoT >DenseSet - This implements a dense probed hash-table based set
llvm::detail::DenseSetEmpty
llvm::detail::DenseSetPair< KeyT >
llvm::DependenceDependence - This class represents a dependence between two memory memory references in a function
llvm::MemoryDepChecker::DependenceDependece between memory access instructions
llvm::DependenceAnalysisDependenceAnalysis - This class is the main dependence-analysis driver
llvm::deref< T >Binary functor that adapts to any other binary functor after dereferencing operands
llvm::yaml::has_FlowTraits< T, true >::Derived
llvm::cl::desc
llvm::DWARFDebugArangeSet::Descriptor
llvm::df_ext_iterator< T, SetTy >
llvm::df_iterator< GraphT, SetType, ExtStorage, GT >
llvm::df_iterator_storage< SetType, External >
llvm::df_iterator_storage< SetType, true >
llvm::DFAPacketizer
llvm::DFCalculateWorkObject< BlockT >
llvm::DIADataStream
llvm::DIAEnumDebugStreams
llvm::DIAEnumLineNumbers
llvm::DIAEnumSourceFiles
llvm::DIAEnumSymbols
llvm::DiagnosticInfoThis is the base abstract class for diagnostic reporting in the backend
llvm::DiagnosticInfoDebugMetadataVersionDiagnostic information for debug metadata version reporting
llvm::DiagnosticInfoInlineAsmDiagnostic information for inline asm reporting
llvm::DiagnosticInfoMIRParserDiagnostic information for machine IR parser
llvm::DiagnosticInfoOptimizationBaseCommon features for diagnostics dealing with optimization remarks
llvm::DiagnosticInfoOptimizationFailureDiagnostic information for optimization failures
llvm::DiagnosticInfoOptimizationRemarkDiagnostic information for applied optimization remarks
llvm::DiagnosticInfoOptimizationRemarkAnalysisDiagnostic information for optimization analysis remarks
llvm::DiagnosticInfoOptimizationRemarkMissedDiagnostic information for missed-optimization remarks
llvm::DiagnosticInfoSampleProfileDiagnostic information for the sample profiler
llvm::DiagnosticInfoStackSizeDiagnostic information for stack size reporting
llvm::DiagnosticPrinterInterface for custom diagnostic printing
llvm::DiagnosticPrinterRawOStreamBasic diagnostic printer that uses an underlying raw_ostream
llvm::DIALineNumber
llvm::DIARawSymbol
llvm::DIASession
llvm::DIASourceFile
llvm::DIBasicTypeBasic type, like 'int' or 'float'
llvm::DIBuilder
llvm::object::DiceRefDiceRef - This is a value type class that represents a single data in code entry in the table in a Mach-O object file
llvm::DICompileUnitCompile unit
llvm::DICompositeTypeComposite types
llvm::DICompositeTypeBaseBase class for DICompositeType and DISubroutineType
llvm::DIContext
llvm::DIDerivedTypeDerived types
llvm::DIDerivedTypeBaseBase class for DIDerivedType and DICompositeType
llvm::DIEDIE - A structured debug information entry
llvm::DIEAbbrevDIEAbbrev - Dwarf abbreviation, describes the organization of a debug information object
llvm::DIEAbbrevDataDIEAbbrevData - Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation
llvm::DIEBlockDIEBlock - Represents a block of values
llvm::DIEDeltaDIEDelta - A simple label difference DIE
llvm::DIEDwarfExpressionDwarfExpression implementation for singular DW_AT_location
llvm::DIEEntry
llvm::DIEExprDIEExpr - An expression DIE
llvm::DIEHashAn object containing the capability of hashing and adding hash attributes onto a DIE
llvm::DIEIntegerDIEInteger - An integer value DIE
llvm::DIELabelDIELabel - A label DIE
llvm::DIELocDIELoc - Represents an expression location
llvm::DIELocListDIELocList - Represents a pointer to a location list in the debug_loc section
llvm::DIEnumeratorEnumeration value
llvm::DIEStringDIEString - A container for string values
llvm::DIETypeSignatureA signature reference to a type unit
llvm::DIEValue
llvm::DIExpressionDWARF expression
llvm::MCRegisterInfo::DiffListIteratorDiffListIterator - Base iterator class that can traverse the differentially encoded register and regunit lists in DiffLists
llvm::DIFileFile
llvm::DIGlobalVariableGlobal variables
llvm::DIImportedEntityAn imported module (C++ using directive or similar)
llvm::DIInliningInfoDIInliningInfo - a format-neutral container for inlined code description
llvm::DILexicalBlock
llvm::DILexicalBlockBase
llvm::DILexicalBlockFile
llvm::DILineInfoDILineInfo - a format-neutral container for source line information
llvm::DILineInfoSpecifierDILineInfoSpecifier - controls which fields of DILineInfo container should be filled with data
llvm::DILocalScopeA scope for locals
llvm::DILocalVariableLocal variable
llvm::DILocationDebug location
llvm::DINamespace
llvm::DINodeTagged DWARF-like metadata node
llvm::DIObjCProperty
llvm::sys::fs::directory_entryDirectory_entry - A single entry in a directory
llvm::sys::fs::directory_iteratorDirectory_iterator - Iterates through the entries in path
llvm::sys::fs::detail::DirIterStateDirIterState - Keeps state for the directory_iterator
llvm::DIScopeBase class for scope-like contexts
llvm::BlockFrequencyInfoImplBase::DistributionDistribution of unscaled probability weight
llvm::DISubprogramSubprogram description
llvm::DISubrangeArray subrange
llvm::DISubroutineTypeType array for a subprogram
llvm::DITemplateParameterBase class for template parameters
llvm::DITemplateTypeParameter
llvm::DITemplateValueParameter
llvm::DITypeBase class for types
llvm::DITypeRefArray
llvm::DIVariableBase class for variables
true::DivergencePropagator
llvm::yaml::DocumentA YAML Stream is a sequence of Documents
llvm::yaml::document_iteratorIterator abstraction for Documents over a Stream
llvm::yaml::DocumentListTraits< T >This class should be specialized by any type that needs to be converted to/from a list of YAML documents
llvm::DominanceFrontier
llvm::DominanceFrontierBase< BlockT >DominanceFrontierBase - Common base class for computing forward and inverse dominance frontiers for a function
llvm::DominatorBase< NodeT >Base class that other, more interesting dominator analyses inherit from
llvm::DominatorTreeConcrete subclass of DominatorTreeBase that is used to compute a normal dominator tree
llvm::DominatorTreeAnalysisAnalysis pass which computes a DominatorTree
llvm::DominatorTreeBase< NodeT >Core dominator tree base class
llvm::DominatorTreePrinterPassPrinter pass for the DominatorTree
llvm::DominatorTreeVerifierPassVerifier pass for the DominatorTree
llvm::DominatorTreeWrapperPassLegacy analysis pass which computes a DominatorTree
llvm::DomTreeNodeBase< NodeT >Base class for the actual dominator tree node
llvm::orc::DoNothingOnNotifyLoadedDefault (no-op) action to perform when loading objects
llvm::object::dos_headerThe DOS compatible header at the front of all PE/COFF executables
llvm::COFF::DOSHeaderThe DOS compatible header at the front of all PEs
llvm::DOTGraphTraits< Ty >DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot' graphs
llvm::DOTGraphTraits< BlockFrequencyInfo * >
llvm::DOTGraphTraits< CallGraph * >
llvm::DOTGraphTraits< const Function * >
llvm::DOTGraphTraits< const MachineFunction * >
llvm::DOTGraphTraits< DominatorTree * >
llvm::DOTGraphTraits< DomTreeNode * >
llvm::DOTGraphTraits< MachineBlockFrequencyInfo * >
llvm::DOTGraphTraits< PostDominatorTree * >
llvm::DOTGraphTraits< RegionInfoPass * >
llvm::DOTGraphTraits< RegionNode * >
llvm::DOTGraphTraits< ScheduleDAG * >
llvm::DOTGraphTraits< ScheduleDAGMI * >
llvm::DOTGraphTraits< SelectionDAG * >
llvm::DOTGraphTraitsModulePrinter< AnalysisT, IsSimple, GraphT, AnalysisGraphTraitsT >
llvm::DOTGraphTraitsModuleViewer< AnalysisT, IsSimple, GraphT, AnalysisGraphTraitsT >
llvm::DOTGraphTraitsPrinter< AnalysisT, IsSimple, GraphT, AnalysisGraphTraitsT >
llvm::DOTGraphTraitsViewer< AnalysisT, IsSimple, GraphT, AnalysisGraphTraitsT >
llvm::DuplexCandidate
llvm::Dependence::DVEntryDependence::DVEntry - Each level in the distance/direction vector has a direction (or perhaps a union of several directions), and perhaps a distance
llvm::DWARFAbbreviationDeclaration
llvm::DWARFAbbreviationDeclarationSet
llvm::DWARFAcceleratorTable
llvm::DwarfAccelTable
llvm::DwarfCFIException
llvm::DwarfCFIExceptionBase
llvm::DwarfCompileUnit
llvm::DWARFCompileUnit
llvm::DWARFContextDWARFContext This data structure is the top level entity that deals with dwarf debug information parsing
llvm::DWARFContextInMemoryDWARFContextInMemory is the simplest possible implementation of a DWARFContext
llvm::DwarfDebugCollects and handles dwarf debug information
llvm::DWARFDebugAbbrev
llvm::DWARFDebugAranges
llvm::DWARFDebugArangeSet
llvm::DWARFDebugFrameA parsed .debug_frame section
llvm::DWARFDebugInfoEntryInlinedChainDWARFDebugInfoEntryInlinedChain - represents a chain of inlined_subroutine DIEs, (possibly ending with subprogram DIE), all of which are contained in some concrete inlined instance tree
llvm::DWARFDebugInfoEntryMinimalDWARFDebugInfoEntryMinimal - A DIE with only the minimum required data
llvm::DWARFDebugLine
llvm::DWARFDebugLoc
llvm::DWARFDebugLocDWO
llvm::DWARFDebugRangeList
llvm::DwarfExpressionBase class containing the logic for constructing DWARF expressions independently of whether they are emitted into a DIE or into a .debug_loc entry
llvm::DwarfFile
llvm::DWARFFormValue
llvm::MCRegisterInfo::DwarfLLVMRegPairDwarfLLVMRegPair - Emitted by tablegen so Dwarf<->LLVM reg mappings can be performed with a binary search
llvm::DWARFSection
llvm::DwarfStringPool
llvm::DwarfStringPoolEntryData for a string pool entry
llvm::DwarfStringPoolEntryRefString pool entry reference
llvm::DwarfTypeUnit
llvm::DWARFTypeUnit
llvm::DwarfUnitThis dwarf writer support class manages information associated with a source file
llvm::DWARFUnit
llvm::DWARFUnitSectionBaseBase class for all DWARFUnitSection classes
llvm::MachO::dyld_info_command
llvm::MachO::dylib
llvm::MachO::dylib_command
llvm::MachO::dylib_module
llvm::MachO::dylib_module_64
llvm::MachO::dylib_reference
llvm::MachO::dylib_table_of_contents
llvm::MachO::dylinker_command
llvm::sys::DynamicLibraryThis class provides a portable interface to dynamic libraries which also might be known as shared libraries, shared objects, dynamic shared objects, or dynamic link libraries
llvm::MachO::dysymtab_command
llvm::EarlyCSEPassA simple and fast domtree-based CSE pass
llvm::EdgeBundles
llvm::PBQP::Graph< SolverT >::EdgeIdSet
llvm::PBQP::Graph< SolverT >::EdgeItr
llvm::PBQP::RegAlloc::RegAllocSolverImpl::EdgeMetadata
llvm::RuntimeDyldMachO::EHFrameRelatedSections
llvm::EHLabelSDNode
llvm::EHStreamerEmits exception handling directives
llvm::orc::CtorDtorIterator::ElementAccessor for an element of the global_ctors/global_dtors array
llvm::ELF::Elf32_Dyn
llvm::ELF::Elf32_Ehdr
llvm::ELF::Elf32_Phdr
llvm::ELF::Elf32_Rel
llvm::ELF::Elf32_Rela
llvm::ELF::Elf32_Shdr
llvm::ELF::Elf32_Sym
llvm::ELF::Elf64_Dyn
llvm::ELF::Elf64_Ehdr
llvm::ELF::Elf64_Phdr
llvm::ELF::Elf64_Rel
llvm::ELF::Elf64_Rela
llvm::ELF::Elf64_Shdr
llvm::ELF::Elf64_Sym
Elf_Dyn_Base
llvm::object::Elf_Dyn_Base< ELFType< TargetEndianness, false > >
llvm::object::Elf_Dyn_Base< ELFType< TargetEndianness, true > >
llvm::object::Elf_Dyn_Impl< ELFT >Elf_Dyn_Impl: This inherits from Elf_Dyn_Base, adding getters and setters
llvm::object::Elf_Ehdr_Impl< ELFT >
llvm::object::Elf_Mips_ABIFlags< ELFT >
llvm::object::Elf_Mips_Options< ELFT >
llvm::object::Elf_Mips_RegInfo< ELFType< TargetEndianness, false > >
llvm::object::Elf_Mips_RegInfo< ELFType< TargetEndianness, true > >
llvm::object::Elf_Phdr_Impl< ELFType< TargetEndianness, false > >
llvm::object::Elf_Phdr_Impl< ELFType< TargetEndianness, true > >
Elf_Rel_Base
llvm::object::Elf_Rel_Base< ELFType< TargetEndianness, false >, false >
llvm::object::Elf_Rel_Base< ELFType< TargetEndianness, false >, true >
llvm::object::Elf_Rel_Base< ELFType< TargetEndianness, true >, false >
llvm::object::Elf_Rel_Base< ELFType< TargetEndianness, true >, true >
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, false >, isRela >
llvm::object::Elf_Rel_Impl< ELFType< TargetEndianness, true >, isRela >
Elf_Shdr_Base
llvm::object::Elf_Shdr_Base< ELFType< TargetEndianness, false > >
llvm::object::Elf_Shdr_Base< ELFType< TargetEndianness, true > >
llvm::object::Elf_Shdr_Impl< ELFT >
Elf_Sym_Base
llvm::object::Elf_Sym_Base< ELFType< TargetEndianness, false > >
llvm::object::Elf_Sym_Base< ELFType< TargetEndianness, true > >
llvm::object::Elf_Sym_Impl< ELFT >
llvm::object::ELFFile< ELFT >::Elf_Sym_Iter
llvm::object::Elf_Verdaux_Impl< ELFT >Elf_Verdaux: This is the structure of auxiliary data in the SHT_GNU_verdef section (.gnu.version_d)
llvm::object::Elf_Verdef_Impl< ELFT >Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section (.gnu.version_d)
llvm::object::Elf_Vernaux_Impl< ELFT >Elf_Vernaux: This is the structure of auxiliary data in SHT_GNU_verneed section (.gnu.version_r)
llvm::object::Elf_Verneed_Impl< ELFT >Elf_Verneed: This is the structure of entries in the SHT_GNU_verneed section (.gnu.version_r)
llvm::object::Elf_Versym_Impl< ELFT >Elf_Versym: This is the structure of entries in the SHT_GNU_versym section (.gnu.version)
llvm::object::ELFDataTypeTypedefHelper< ELFType< TargetEndianness, false > >ELF 32bit types
llvm::object::ELFDataTypeTypedefHelper< ELFType< TargetEndianness, true > >ELF 64bit types
llvm::object::ELFDataTypeTypedefHelperCommon< target_endianness >
llvm::object::ELFFile< ELFT >::ELFEntityIterator< EntT >Iterate over constant sized entities
llvm::object::ELFFile< ELFT >
llvm::object::ELFObjectFile< ELFT >
llvm::object::ELFObjectFileBase
llvm::ELFRelocationEntry
llvm::object::ELFType< target_endianness, is64Bits >
enable_shared_from_this
llvm::MachO::encryption_info_command
llvm::MachO::encryption_info_command_64
llvm::EngineBuilderBuilder class for ExecutionEngines
llvm::MachineTraceMetrics::EnsembleA trace ensemble is a collection of traces selected using the same strategy, for example 'minimum resource height'
llvm::DebugLocStream::Entry
llvm::SpecialCaseList::EntryRepresents a set of regular expressions
llvm::MachO::entry_point_command
llvm::DebugLocStream::EntryBuilderBuilder for DebugLocStream entries
llvm::EnumAttributeImpl
llvm::ARM::WinEH::EpilogueScopeExceptionDataRecord - An entry in the table of exception data (.xdata)
llvm::equalA functor like C++14's std::equal<void> in its absence
llvm::EquivalenceClasses< ElemTy >EquivalenceClasses - This represents a collection of equivalence classes and supports three efficient operations: insert an element into a class of its own, union two classes, and find the class for a given element
llvm::ErrorOr< T >Represents either an error or a value T
llvm::EVTEVT - Extended Value Type
llvm::PatternMatch::Exact_match< SubPattern_t >
llvm::ARM::WinEH::ExceptionDataRecord
llvm::ExecutionContext
llvm::ExecutionEngineAbstract interface for implementation execution of LLVM modules, designed to support both interpreter and just-in-time (JIT) compiler implementations
llvm::ExecutionEngineStateHelper class for helping synchronize access to the global address map table
llvm::SetTheory::ExpanderExpander - A callback function that can transform a Record representing a set into a fully expanded list of elements
llvm::coverage::ExpansionRecordCoverage information for a macro expansion or #included file
llvm::object::export_address_table_entry
llvm::object::export_directory_table_entry
llvm::object::ExportDirectoryEntryRef
llvm::object::ExportEntryExportEntry encapsulates the current-state-of-the-walk used when doing a non-recursive walk of the trie data structure
llvm::DIExpression::expr_op_iteratorAn iterator for expression operands
llvm::DIExpression::ExprOperandA lightweight wrapper around an expression operand
llvm::ExternalSymbolSDNode
llvm::ExtractElementConstantExprExtractElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement extractelement constant exprs
llvm::ExtractElementInstExtractElementInst - This instruction extracts a single (scalar) element from a VectorType value
llvm::ExtractValueConstantExprExtractValueConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement extractvalue constant exprs
llvm::ExtractValueInstExtractValueInst - This instruction extracts a struct member or array element value from an aggregate value
llvm::ValueMapConfig< KeyT, MutexT >::ExtraData
llvm::cl::extrahelp
llvm::ImmutableMap< KeyT, ValT, ValInfo >::Factory
llvm::ImmutableSet< ValT, ValInfo >::Factory
llvm::yaml::has_FlowTraits< T, true >::Fallback
Fallback
llvm::FastFoldingSetNodeFastFoldingSetNode - This is a subclass of FoldingSetNode which stores a FoldingSetNodeID value rather than requiring the node to recompute it each time it is needed
llvm::FastISelThis is a fast-path instruction selection class that generates poor code and doesn't support illegal types or non-trivial lowering, but runs quickly
llvm::IRBuilderBase::FastMathFlagGuard
llvm::FastMathFlagsConvenience struct for specifying and reasoning about fast-math flags
llvm::MachO::fat_arch
llvm::MachO::fat_header
llvm::FaultMapParserA parser for the __llvm_faultmaps section generated by the FaultMaps class above
llvm::FaultMaps
llvm::FCmpInstThis instruction compares its operands according to the predicate given to the constructor
llvm::FeatureBitset
llvm::FenceInstFenceInst - an instruction for ordering other memory operations
llvm::FieldInitFieldInit - X.Y - Represent a reference to a subfield of a variable
llvm::sys::fs::file_magicFile_magic - An "enum class" enumeration of file types based on magic (the first N bytes of the file)
llvm::sys::fs::file_statusFile_status - Represents the result of a call to stat and friends
FileHandleTraits
llvm::ELFYAML::FileHeader
llvm::FileInfo
llvm::DWARFDebugLine::FileNameEntry
llvm::FileOutputBufferFileOutputBuffer - This interface provides simple way to create an in-memory buffer which will be written to a file
llvm::FileRemoverFileRemover - This class is a simple object meant to be stack allocated
llvm::FilteredPassNameParser< Filter >===----------------------------------------------------------------------===// FilteredPassNameParser class - Make use of the pass registration mechanism to automatically add a command line argument to opt for each pass that satisfies a filter criteria
llvm::yaml::finalA null value
llvm::final< T >FoldingSet - This template class is used to instantiate a specialized implementation of the folding set to the node class T
llvm::opt::finalDerivedArgList - An ordered collection of driver arguments, whose storage may be in another argument list
llvm::cl::final< DataType >
FindHandleTraits
llvm::MachineTraceMetrics::FixedBlockInfoPer-basic block information that doesn't depend on the trace through the block
llvm::FixedNumOperandTraits< SubClass, ARITY >FixedNumOperandTraits - determine the allocation regime of the Use array when it is a prefix to the User object, and the number of Use objects is known at compile time
llvm::FixedStackPseudoSourceValueFixedStackPseudoSourceValue - A specialized PseudoSourceValue for holding FixedStack values, which must include a frame index
fuzzer::FlagDescription
llvm::FlatIt< GraphType >Marker class to iterate over the elements of a Region in flat mode
llvm::fltSemantics
llvm::PatternMatch::fneg_match< LHS_t >
llvm::FoldingSetBucketIterator< T >
llvm::FoldingSetBucketIteratorImplFoldingSetBucketIteratorImpl - This is the common bucket iterator support shared by all folding sets, which knows how to walk a particular bucket of a folding set hash table
llvm::FoldingSetImplFoldingSetImpl - Implements the folding set functionality
llvm::FoldingSetIterator< T >
llvm::FoldingSetIteratorImplFoldingSetIteratorImpl - This is the common iterator support shared by all folding sets, which knows how to walk the folding set hash table
llvm::FoldingSetNodeIDFoldingSetNodeID - This class is used to gather all the unique data bits of a node
llvm::FoldingSetNodeIDRefFoldingSetNodeIDRef - This class describes a reference to an interned FoldingSetNodeID, which can be a useful to store node id data rather than using plain FoldingSetNodeIDs, since the 32-element SmallVector is often much larger than necessary, and the possibility of heap allocation means it requires a non-trivial destructor call
llvm::FoldingSetNodeWrapper< T >FoldingSetNodeWrapper - This template class is used to "wrap" arbitrary types in an enclosing object so that they can be inserted into FoldingSets
llvm::FoldingSetTrait< T >FoldingSetTrait - This trait class is used to define behavior of how to "profile" (in the FoldingSet parlance) an object of a given type
llvm::FoldingSetTrait< SCEV >
llvm::FoldingSetTrait< SDVTListNode >Specialize FoldingSetTrait for SDVTListNode to avoid computing temp FoldingSetNodeID and hash value
llvm::FoldingSetTrait< std::pair< T1, T2 > >
llvm::FoldingSetTrait< T * >
llvm::FoldingSetVector< T, VectorT >FoldingSetVector - This template class combines a FoldingSet and a vector to provide the interface of FoldingSet but with deterministic iteration order based on the insertion order
llvm::ForeachLoopForeachLoop - Record the iteration state associated with a for loop
llvm::format_object_baseThis is a helper class used for handling formatted output
llvm::formatted_raw_ostreamFormatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column position, allowing padding out to specific column boundaries and querying the number of lines written to the stream
llvm::FormattedNumberThis is a helper class used for format_hex() and format_decimal()
llvm::FormattedStringThis is a helper class used for left_justify() and right_justify()
llvm::FortifiedLibCallSimplifierThis class implements simplifications for calls to fortified library functions (__st*cpy_chk, __memcpy_chk, __memmove_chk, __memset_chk), to, when possible, replace them with their non-checking counterparts
llvm::ForwardDominanceFrontierBase< BlockT >DominanceFrontier Class - Concrete subclass of DominanceFrontierBase that is used to compute a forward dominator frontiers
llvm::ForwardedRegisterDescribes a register that needs to be forwarded from the prologue to a musttail call
llvm::types::fp128
llvm::MachO::fp_control_t
llvm::MachO::fp_status_t
llvm::FPExtInstThis class represents an extension of floating point types
llvm::FPMathOperatorUtility class for floating point operations which can have information about relaxed accuracy requirements attached to them
llvm::FPPassManagerFPPassManager manages BBPassManagers and FunctionPasses
llvm::FPToSIInstThis class represents a cast from floating point to signed integer
llvm::FPToUIInstThis class represents a cast from floating point to unsigned integer
llvm::FPTruncInstThis class represents a truncation of floating point types
llvm::FrameEntryAbstract frame entry defining the common interface concrete entries implement
llvm::FrameIndexSDNode
llvm::WinEH::FrameInfo
llvm::FreeDeleter
llvm::BlockFrequencyInfoImplBase::FrequencyDataStats about a block itself
llvm::FullDependenceFullDependence - This class represents a dependence between two memory references in a function
llvm::Mips16HardFloatInfo::FuncNameSignature
llvm::Mips16HardFloatInfo::FuncSignature
llvm::Function
llvm::function_ref< Ret(Params...)>
llvm::FunctionAnalysisManagerCGSCCProxyA CGSCC analysis which acts as a proxy for a function analysis manager
llvm::FunctionAnalysisManagerModuleProxyA module analysis which acts as a proxy for a function analysis manager
llvm::FaultMapParser::FunctionFaultInfoAccessor
llvm::FaultMapParser::FunctionInfoAccessor
llvm::FunctionLoweringInfoFunctionLoweringInfo - This contains information that is global to a function that is used when lowering a region of the function
llvm::FunctionPassFunctionPass class - This class is used to implement most global optimizations
llvm::legacy::FunctionPassManagerFunctionPassManager manages FunctionPasses and BasicBlockPassManagers
llvm::legacy::FunctionPassManagerImplFunctionPassManagerImpl manages FPPassManagers
llvm::coverage::FunctionRecordCode coverage information for a single function
llvm::coverage::FunctionRecordIteratorIterator over Functions, optionally filtered to a single file
llvm::sampleprof::FunctionSamplesRepresentation of the samples collected for a function
llvm::FunctionTypeFunctionType - Class to represent function types
llvm::FunctionTypeKeyInfo
fuzzer::Fuzzer
fuzzer::Fuzzer::FuzzingOptions
llvm::MachO::fvmfile_command
llvm::MachO::fvmlib
llvm::MachO::fvmlib_command
llvm::GCFunctionInfoGarbage collection metadata for a single function
llvm::GCMetadataPrinterGCMetadataPrinter - Emits GC metadata as assembly code
llvm::GCModuleInfoAn analysis pass which caches information about the entire Module
llvm::GCNTargetMachine
llvm::GCOVBlockGCOVBlock - Collects block information
llvm::GCOVBufferGCOVBuffer - A wrapper around MemoryBuffer to provide GCOV specific read operations
llvm::GCOVEdgeGCOVEdge - Collects edge information
llvm::GCOVFileGCOVFile - Collects coverage information for one pair of coverage file (.gcno and .gcda)
llvm::GCOVFunctionGCOVFunction - Collects function information
llvm::GCOVOptionsGCOVOptions - A struct for passing gcov options between functions
llvm::GCPointGCPoint - Metadata for a collector-safe point in machine code
false::GCPtrLivenessData
llvm::GCRelocateOperandsWraps a call to a gc.relocate and provides access to it's operands
llvm::GCRootGCRoot - Metadata for a pointer to an object managed by the garbage collector
llvm::GCStrategyGCStrategy describes a garbage collector algorithm's code generation requirements, and provides overridable hooks for those needs which cannot be abstractly described
llvm::generic_gep_type_iterator< ItTy >
llvm::cl::generic_parser_base
llvm::GenericDINodeGeneric tagged DWARF-like metadata node
llvm::cl::generic_parser_base::GenericOptionInfo
llvm::cl::GenericOptionValue
llvm::GenericSchedulerGenericScheduler shrinks the unscheduled zone using heuristics to balance the schedule
llvm::GenericSchedulerBaseBase class for GenericScheduler
GenericSetCCInfoHelper structure to keep track of ISD::SET_CC operands
llvm::GenericValue
llvm::GEPOperator
llvm::GetElementPtrConstantExprGetElementPtrConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement getelementpr constant exprs
llvm::GetElementPtrInstGetElementPtrInst - an instruction for type-safe pointer arithmetic to access elements of arrays and structs
llvm::GlobalAddressSDNode
llvm::GlobalAlias
llvm::GlobalLayoutBuilderThis class implements a layout algorithm for globals referenced by bit sets that tries to keep members of small bit sets together
llvm::GlobalObject
llvm::orc::GlobalRenamer
llvm::GlobalStatusAs we analyze each global, keep track of some information about it
llvm::GlobalValue
llvm::GlobalVariable
llvm::PBQP::Graph< SolverT >PBQP Graph class
llvm::PBQP::GraphBase
llvm::PBQP::RegAlloc::GraphMetadataHolds graph-level metadata relevent to PBQP RA problems
llvm::GraphTraits< GraphType >
llvm::GraphTraits< ArgumentGraph * >
llvm::GraphTraits< ArgumentGraphNode * >
llvm::GraphTraits< BasicBlock * >
llvm::GraphTraits< BlockFrequencyInfo * >
llvm::GraphTraits< CallGraph * >
llvm::GraphTraits< CallGraphNode * >
llvm::GraphTraits< const BasicBlock * >
llvm::GraphTraits< const CallGraph * >
llvm::GraphTraits< const CallGraphNode * >
llvm::GraphTraits< const Function * >
llvm::GraphTraits< const Loop * >
llvm::GraphTraits< const MachineBasicBlock * >
llvm::GraphTraits< const MachineFunction * >
llvm::GraphTraits< const MachineLoop * >
llvm::GraphTraits< const Type * >
llvm::GraphTraits< DominatorTree * >
llvm::GraphTraits< DomTreeNode * >
llvm::GraphTraits< Function * >
llvm::GraphTraits< Interval * >
llvm::GraphTraits< Inverse< BasicBlock * > >
llvm::GraphTraits< Inverse< const BasicBlock * > >
llvm::GraphTraits< Inverse< const Function * > >
llvm::GraphTraits< Inverse< const MachineBasicBlock * > >
llvm::GraphTraits< Inverse< const MachineFunction * > >
llvm::GraphTraits< Inverse< Function * > >
llvm::GraphTraits< Inverse< Interval * > >
llvm::GraphTraits< Inverse< Inverse< T > > >
llvm::GraphTraits< Inverse< MachineBasicBlock * > >
llvm::GraphTraits< Inverse< MachineFunction * > >
llvm::GraphTraits< IrreducibleGraph >
llvm::GraphTraits< LazyCallGraph * >
llvm::GraphTraits< LazyCallGraph::Node * >
llvm::GraphTraits< Loop * >
llvm::GraphTraits< MachineBasicBlock * >
llvm::GraphTraits< MachineBlockFrequencyInfo * >
llvm::GraphTraits< MachineDominatorTree * >
llvm::GraphTraits< MachineDomTreeNode * >
llvm::GraphTraits< MachineFunction * >
llvm::GraphTraits< MachineLoop * >
llvm::GraphTraits< MachineRegionInfo * >
llvm::GraphTraits< MachineRegionInfoPass * >
llvm::GraphTraits< PostDominatorTree * >
llvm::GraphTraits< RegionInfo * >
llvm::GraphTraits< RegionInfoPass * >
llvm::GraphTraits< ScheduleDAG * >
llvm::GraphTraits< ScheduleDAGMI * >
llvm::GraphTraits< SDNode * >
llvm::GraphTraits< SelectionDAG * >
llvm::GraphTraits< SUnit * >
llvm::GraphTraits< Type * >
llvm::GraphWriter< GraphType >
llvm::greater_ptr< Ty >
llvm::ELFYAML::Group
llvm::GVMaterializer
llvm::DebugEpochBase::HandleBase
llvm::HandleSDNodeThis class is used to form a handle around another node that is persistent and is updated across invocations of replaceAllUsesWith on its operand
llvm::yaml::has_BlockScalarTraits< T >
llvm::yaml::has_DocumentListTraits< T >
llvm::yaml::has_FlowTraits< T, Enabled >
llvm::yaml::has_FlowTraits< T, true >
llvm::yaml::has_MappingTraits< T >
llvm::yaml::has_MappingValidateTraits< T >
llvm::yaml::has_ScalarBitSetTraits< T >
llvm::yaml::has_ScalarEnumerationTraits< T >
llvm::yaml::has_ScalarTraits< T >
llvm::yaml::has_SequenceMethodTraits< T >
llvm::yaml::has_SequenceTraits< T >
llvm::MDNode::HasCachedHash< NodeTy >
llvm::mdconst::detail::HasDereference< T, Result >
std::hash< llvm::PDB_SymType >
llvm::hash_codeAn opaque object representing a hash code
llvm::hashing::detail::hash_combine_recursive_helperHelper class to manage the recursive combining of hash_combine arguments
llvm::hashing::detail::hash_stateThe intermediate state used during hashing
llvm::DwarfAccelTable::HashDataContents
llvm::HashingByteStreamer
llvm::DWARFDebugArangeSet::Header
llvm::COFF::header
llvm::HexagonAsmInstPrinter
llvm::HexagonAsmPrinter
HexagonBid
llvm::HexagonFrameLowering
HexagonGenInstrInfo
HexagonGenRegisterInfo
HexagonGenSubtargetInfo
llvm::HexagonInstPrinterPrints bundles as a newline separated list of individual instructions Duplexes are separated by a vertical tab character A trailing line includes bundle properties such as endloop0/1
llvm::HexagonInstr
llvm::HexagonInstrInfo
llvm::HexagonMachineFunctionInfoHexagon target-specific information for each MachineFunction
llvm::HexagonMCAsmInfo
llvm::HexagonMCCodeEmitter
llvm::HexagonMCELFStreamer
llvm::HexagonMCShuffler
llvm::HexagonRegisterInfo
llvm::HexagonResource
llvm::HexagonSelectionDAGInfo
llvm::HexagonShuffler
llvm::HexagonSubtarget
llvm::HexagonTargetLowering
llvm::HexagonTargetMachine
llvm::HexagonTargetObjectFile
llvm::HexagonTargetStreamer
HexagonUnitAuction
llvm::LiveIntervals::HMEditor
hsa_dim3_s
hsa_ext_control_directives_sThe hsa_ext_control_directives_t specifies the values for the HSAIL control directives
llvm::HungoffOperandTraits< MINARITY >HungoffOperandTraits - determine the allocation regime of the Use array when it is not a prefix to the User object, but allocated at an unrelated heap address
llvm::types::i< num_bits >I<N> corresponds to the LLVM IntegerType with N bits
llvm::AArch64IC::ICMapper
llvm::ICmpInstThis instruction compares its operands according to the predicate given to the constructor
llvm::MachO::ident_command
llvm::Linker::IdentifiedStructTypeSet
llvm::IdentifyingPassPtrDiscriminated union of Pass ID types
llvm::identity< Ty >
llvm::idf_ext_iterator< T, SetTy >
llvm::idf_iterator< T, SetTy, External >
llvm::IDFCalculatorDetermine the iterated dominance frontier, given a set of defining blocks, and optionally, a set of live-in blocks
llvm::Idx2MBBCompare
llvm::types::ieee_double
llvm::types::ieee_float
llvm::Intrinsic::IITDescriptorThis is a type descriptor which explains the type requirements of an intrinsic
llvm::ilist< NodeTy >
llvm::ilist_default_traits< NodeTy >Ilist_default_traits - Default template traits for intrusive list
llvm::ilist_half_node< NodeTy >Ilist_half_node - Base class that provides prev services for sentinels
llvm::ilist_iterator< NodeTy >
llvm::ilist_nextprev_traits< NodeTy >Ilist_nextprev_traits - A fragment for template traits for intrusive list that provides default next/prev implementations for common operations
llvm::ilist_node< NodeTy >Ilist_node - Base class that provides next/prev services for nodes that use ilist_nextprev_traits or ilist_default_traits
llvm::ilist_node_traits< NodeTy >Ilist_node_traits - A fragment for template traits for intrusive list that provides default node related operations
llvm::ilist_node_traits< MCFragment >
llvm::ilist_node_traits< Token >
llvm::ilist_sentinel_traits< NodeTy >Ilist_sentinel_traits - A fragment for template traits for intrusive list that provides default sentinel implementations for common operations
llvm::ilist_sentinel_traits< Token >
llvm::ilist_traits< NodeTy >
llvm::ilist_traits< Argument >
llvm::ilist_traits< BasicBlock >
llvm::ilist_traits< const Ty >
llvm::ilist_traits< Function >
llvm::ilist_traits< GlobalAlias >
llvm::ilist_traits< GlobalVariable >
llvm::ilist_traits< IndexListEntry >
llvm::ilist_traits< Instruction >
llvm::ilist_traits< IVStrideUse >
llvm::ilist_traits< MachineBasicBlock >
llvm::ilist_traits< MachineInstr >
llvm::ilist_traits< NamedMDNode >
llvm::ilist_traits< RecyclerStruct >
llvm::ilist_traits< SDNode >
llvm::ilist_traits< SparseBitVectorElement< ElementSize > >
llvm::ilist_traits< SymbolRewriter::RewriteDescriptor >
llvm::ILPValueRepresent the ILP of the subDAG rooted at a DAG node
llvm::X86Operand::ImmOp
llvm::ImmutableCallSiteImmutableCallSite - establish a view to a call site for examination
llvm::ImmutableList< T >ImmutableList - This class represents an immutable (functional) list
llvm::ImmutableListFactory< T >
llvm::ImmutableListImpl< T >
llvm::ImmutableMap< KeyT, ValT, ValInfo >
llvm::ImmutableMapRef< KeyT, ValT, ValInfo >
llvm::ImmutablePassImmutablePass class - This class is used to provide information that does not need to be run
llvm::ImmutableSet< ValT, ValInfo >
llvm::ImmutableSetRef< ValT, ValInfo >
llvm::ImmutableStatepointA specialization of it's base class for read only access to a gc.statepoint
llvm::object::import_directory_table_entry
llvm::object::import_lookup_table_entry< IntTy >
llvm::object::ImportDirectoryEntryRef
llvm::COFF::ImportDirectoryTableEntryThe Import Directory Table
llvm::object::ImportedSymbolRef
llvm::COFF::ImportHeader
llvm::COFF::ImportLookupTableEntry32The PE32 Import Lookup Table
llvm::ImutAVLFactory< ImutInfo >
llvm::ImutAVLTree< ImutInfo >
llvm::ImutAVLTreeGenericIterator< ImutInfo >
llvm::ImutAVLTreeInOrderIterator< ImutInfo >
llvm::ImutAVLValueIterator< T >Generic iterator that wraps a T::TreeTy::iterator and exposes iterator::getValue() on dereference
llvm::ImutContainerInfo< T >ImutContainerInfo - Generic definition of comparison operations for elements of immutable containers that defaults to using std::equal_to<> and std::less<> to perform comparison of elements
llvm::ImutContainerInfo< T * >ImutContainerInfo - Specialization for pointer values to treat pointers as references to unique objects
llvm::ImutKeyValueInfo< T, S >ImutKeyValueInfo -Traits class used by ImmutableMap
llvm::ImutProfileInfo< T >Generic profile template
llvm::ImutProfileInfo< bool >Profile traits for booleans
llvm::ImutProfileInfo< T * >Generic profile trait for pointer types
llvm::ImutProfileInteger< T >Profile traits for integers
llvm::index_sequence< I >Alias for the common case of a sequence of size_ts
llvm::index_sequence_for< Ts >Creates a compile-time integer sequence for a parameter pack
llvm::IndexedInstrProfReaderReader for the indexed binary instrprof format
llvm::IndexedMap< T, ToIndexT >
llvm::IndexListEntryThis class represents an entry in the slot index list held in the SlotIndexes pass
llvm::IndirectBrInstIndirectBrInst - Indirect Branch Instruction
llvm::IndirectSymbolData
llvm::opt::OptTable::InfoEntry for a single option instance in the option data table
llvm::DominatorTreeBase< NodeT >::InfoRec
llvm::Init
llvm::sys::InitializeCOMRAII
llvm::cl::initializer< Ty >
llvm::InlineAsm
llvm::InlineAsmIdentifierInfo
llvm::InlineAsmKeyType
llvm::InlineCostRepresents the cost of inlining a function
llvm::InlineCostAnalysisCost analyzer used by inliner
llvm::InlineFunctionInfoInlineFunctionInfo - This class captures the data input to the InlineFunction call, and records the auxiliary results produced by it
llvm::InlinerInliner - This class contains all of the helper code which is used to perform the inlining operations that do not depend on the policy
llvm::yaml::InputUsed to parse a yaml document into in-memory structs and vectors
llvm::ISD::InputArgInputArg - This struct carries flags and type information about a single incoming (formal) argument or incoming (from the perspective of the caller) return value virtual register
llvm::InsertElementConstantExprInsertElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement insertelement constant exprs
llvm::InsertElementInstInsertElementInst - This instruction inserts a single (scalar) element into a VectorType value
llvm::IRBuilderBase::InsertPointInsertPoint - A saved insertion point
llvm::IRBuilderBase::InsertPointGuard
llvm::InsertValueConstantExprInsertValueConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement insertvalue constant exprs
llvm::InsertValueInstInsertValueInst - This instruction inserts a struct field of array element value into an aggregate value
llvm::MipsAnalyzeImmediate::Inst
llvm::InstCombineIRInserterAn IRBuilder inserter that adds new instructions to the instcombine worklist
llvm::InstCombinePass
llvm::InstCombinerThe core instruction combiner logic
llvm::InstCombineWorklistInstCombineWorklist - This is the worklist management logic for InstCombine
llvm::RecurrenceDescriptor::InstDescThis POD struct holds information about a potential recurrence operation
llvm::InstIterator< BB_t, BB_i_t, BI_t, II_t >
llvm::MachineTraceMetrics::InstrCyclesInstrCycles represents the cycle height and depth of an instruction in a trace
llvm::InstrEmitter
llvm::InstrItineraryAn itinerary represents the scheduling information for an instruction
llvm::InstrItineraryDataItinerary data supplied by a subtarget to be used by a target
llvm::InstrProfIncrementInstThis represents the llvm.instrprof_increment intrinsic
llvm::InstrProfIteratorA file format agnostic iterator over profiling data
llvm::InstrProfLookupTraitTrait for lookups into the on-disk hash table for the binary instrprof format
llvm::InstrProfOptionsOptions for the frontend instrumentation based profiling pass
llvm::InstrProfReaderBase class and interface for reading profiling data of any known instrprof format
llvm::InstrProfRecordProfiling information for a single function
llvm::InstrProfWriterWriter for instrumentation based profile data
llvm::InstrStageThese values represent a non-pipelined step in the execution of an instruction
llvm::Instruction
llvm::FrameEntry::Instruction
llvm::Win64EH::Instruction
llvm::WinEH::Instruction
llvm::X86Disassembler::InstructionSpecifierThe specification for how to extract and interpret a full instruction and its operands
llvm::InstVisitor< SubClass, RetTy >Base class for instruction visitors
llvm::IntAttributeImpl
llvm::integer_sequence< T, I >Represents a compile-time sequence of integers
llvm::IntegerTypeClass to represent integer types
integral_constant
llvm::IntelJITEventsWrapper
llvm::IntEqClasses
llvm::InterferenceCache
llvm::LineEditor::InternalData
llvm::X86Disassembler::InternalInstructionThe x86 internal instruction, which is produced by the decoder
llvm::Interpreter
llvm::IntervalInterval Class - An Interval is a set of nodes defined such that every node in the interval has all of its predecessors in the interval (except for the header)
llvm::IntervalIterator< NodeTy, OrigContainer_t, GT, IGT >
llvm::IntervalMap< KeyT, ValT, N, Traits >
llvm::IntervalMapHalfOpenInfo< T >
llvm::IntervalMapInfo< T >
llvm::IntervalMapInfo< SlotIndex >
llvm::IntervalMapOverlaps< MapA, MapB >IntervalMapOverlaps - Iterate over the overlaps of mapped intervals in two IntervalMaps
llvm::IntervalPartition
llvm::IntervalPressureRegisterPressure computed within a region of instructions delimited by TopIdx and BottomIdx
false::IntervalSorter
llvm::IntInitIntInit - 7 - Represent an initialization by a literal integer value
llvm::GenericValue::IntPair
llvm::IntRecTyIntRecTy - 'int' - Represent an integer value of no particular size
llvm::IntrinsicData
llvm::PatternMatch::IntrinsicID_matchIntrinsic matchers
llvm::TargetLoweringBase::IntrinsicInfo
llvm::IntrinsicInstIntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions
llvm::IntrinsicLowering
llvm::IntrusiveRefCntPtr< T >IntrusiveRefCntPtr - A template class that implements a "smart pointer" that assumes the wrapped object has a reference count associated with it that can be managed via calls to IntrusivePtrAddRef/IntrusivePtrRelease
llvm::IntrusiveRefCntPtrInfo< T >
llvm::IntToPtrInstThis class represents a cast from an integer to a pointer
llvm::InvalidateAllAnalysesPassA utility pass that does nothing but preserves no analyses
llvm::InvalidateAnalysisPass< AnalysisT >A template utility pass to force an analysis result to be invalidated
llvm::Inverse< GraphType >
llvm::InvokeInstInvokeInst - Invoke instruction
llvm::yaml::IO
llvm::IPDBDataStreamIPDBDataStream defines an interface used to represent a stream consisting of a name and a series of records whose formats depend on the particular stream type
llvm::IPDBEnumChildren< ChildType >
llvm::IPDBLineNumber
llvm::IPDBRawSymbolIPDBRawSymbol defines an interface used to represent an arbitrary symbol
llvm::IPDBSessionIPDBSession defines an interface used to provide a context for querying debug information from a debug data source (for example, a PDB)
llvm::IPDBSourceFileIPDBSourceFile defines an interface used to represent source files whose information are stored in the PDB
llvm::iplist< NodeTy, Traits >Iplist - The subset of list functionality that can safely be used on nodes of polymorphic types, i.e
llvm::ipo_ext_iterator< T, SetType >
llvm::ipo_iterator< T, SetType, External >
llvm::IRBuilder< preserveNames, T, Inserter >This provides a uniform API for creating instructions and inserting them into a basic block: either at the end of a BasicBlock, or at a specific iterator location in a block
llvm::IRBuilderBaseCommon base class shared among various IRBuilders
llvm::IRBuilderDefaultInserter< preserveNames >This provides the default implementation of the IRBuilder 'InsertHelper' method that is called whenever an instruction is created by IRBuilder and needs to be inserted
llvm::orc::IRCompileLayer< BaseLayerT >Eager IR compiling layer
llvm::object::IRObjectFile
llvm::bfi_detail::IrreducibleGraphGraph of irreducible control flow
llvm::bfi_detail::IrreducibleGraph::IrrNode
llvm::orc::IRTransformLayer< BaseLayerT, TransformFtor >IR mutating layer
llvm::PatternMatch::is_all_ones
std::is_error_code_enum< llvm::BitcodeError >
std::is_error_code_enum< llvm::coveragemap_error >
std::is_error_code_enum< llvm::errc >
std::is_error_code_enum< llvm::instrprof_error >
std::is_error_code_enum< llvm::object::object_error >
std::is_error_code_enum< llvm::sampleprof_error >
llvm::hashing::detail::is_hashable_data< T >Trait to indicate whether a type's bits can be hashed directly
llvm::hashing::detail::is_hashable_data< std::pair< T, U > >
llvm::is_integral_or_enum< T >Metafunction that determines whether the given type is either an integral type or an enumeration type
llvm::PatternMatch::is_maxsignedvalue
llvm::PatternMatch::is_one
llvm::PatternMatch::is_power2
llvm::PatternMatch::is_sign_bit
llvm::is_simple_type< X >
llvm::isa_impl< To, From, Enabler >
llvm::isa_impl< Argument, Value >
llvm::isa_impl< BasicBlock, Value >
llvm::isa_impl< Constant, Value >
llvm::isa_impl< Function, Value >
llvm::isa_impl< GlobalAlias, Value >
llvm::isa_impl< GlobalObject, Value >
llvm::isa_impl< GlobalValue, Value >
llvm::isa_impl< GlobalVariable, Value >
llvm::isa_impl< InlineAsm, Value >
llvm::isa_impl< Instruction, Value >
llvm::isa_impl< PointerType, Type >
llvm::isa_impl< To, From, typename std::enable_if< std::is_base_of< To, From >::value >::type >Always allow upcasts, and perform no dynamic check for them
llvm::isa_impl_cl< To, From >
llvm::isa_impl_cl< To, const From * >
llvm::isa_impl_cl< To, const From *const >
llvm::isa_impl_cl< To, const From >
llvm::isa_impl_cl< To, From * >
llvm::isa_impl_cl< To, From *const >
llvm::isa_impl_wrap< To, From, SimpleFrom >
llvm::isa_impl_wrap< To, FromTy, FromTy >
llvm::AArch64ISB::ISBMapper
llvm::isPodLike< T >IsPodLike - This is a type trait that is used to determine whether a given type can be copied around with memcpy instead of running ctors etc
llvm::isPodLike< ArrayRef< T > >
llvm::isPodLike< AssertingVH< T > >
llvm::isPodLike< bfi_detail::BlockMass >
llvm::isPodLike< BitCodeAbbrevOp >
llvm::isPodLike< IdentifyingPassPtr >
llvm::isPodLike< ImmutableList< T > >
llvm::isPodLike< MCOperand >
llvm::isPodLike< Optional< T > >
llvm::isPodLike< PointerIntPair< PointerTy, IntBits, IntType > >
llvm::isPodLike< PressureChange >
llvm::isPodLike< ScaledNumber< T > >
llvm::isPodLike< SDep >
llvm::isPodLike< SDValue >
llvm::isPodLike< Slice >
llvm::isPodLike< SlotIndex >
llvm::isPodLike< std::pair< T, U > >
llvm::isPodLike< StringRef >
llvm::isPodLike< SuccIterator< T, U > >
llvm::mdconst::detail::IsValidPointer< V, M >
llvm::mdconst::detail::IsValidReference< V, M >
llvm::IntervalMap< KeyT, ValT, N, Traits >::iterator
llvm::DITypeRefArray::iterator
llvm::AliasSet::iteratorDefine an iterator for alias sets... this is just a forward iterator
llvm::OnDiskChainedHashTable< Info >::iterator
llvm::Registry< T, U >::iteratorIterators for registry entries
llvm::DenseSet< ValueT, ValueInfoT >::Iterator
llvm::TargetRegistry::iterator
llvm::ImmutableList< T >::iterator
llvm::LazyCallGraph::iteratorA lazy iterator used for both the entry nodes and child nodes
llvm::ImmutableMap< KeyT, ValT, ValInfo >::iterator
llvm::ImmutableMapRef< KeyT, ValT, ValInfo >::iterator
iterator
llvm::iterator_adaptor_base< DerivedT, WrappedIteratorT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT, WrappedTraitsT >CRTP base class for adapting an iterator to a different type
llvm::SparseMultiSet< ValueT, KeyFunctorT, SparseT >::iterator_base< SMSPtrTy >Our iterators are iterators over the collection of objects that share a key
llvm::iterator_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of the interface
llvm::iterator_range< IteratorT >A range adaptor for a pair of iterators
llvm::IVStrideUseIVStrideUse - Keep track of one use of a strided induction variable
llvm::IVUsers
llvm::IVVisitorInterface for visiting interesting IV users that are recognized but not simplified by this utility
jit_code_entry
jit_descriptor
llvm::orc::JITCompileCallbackManager< JITLayerT, TargetT >Manage compile callbacks
llvm::orc::JITCompileCallbackManagerBaseBase class for JITLayer independent aspects of JITCompileCallbackManager
llvm::JITEvent_EmittedFunctionDetailsJITEvent_EmittedFunctionDetails - Helper struct for containing information about a generated machine code function
llvm::JITEventListenerJITEventListener - Abstract interface for use by the JIT to notify clients about significant events during compilation
llvm::orc::JITSymbolRepresents a symbol in the JIT
llvm::JITSymbolBaseBase class for symbols in the JIT
JobHandleTraits
llvm::JumpInstrTableInfoThis class stores information about jump-instruction tables created by the JumpInstrTables pass (in lib/CodeGen/JumpInstrTables.cpp)
llvm::JumpTableSDNode
llvm::OnDiskIterableChainedHashTable< Info >::key_iteratorIterates over all of the keys in the table
llvm::AnonStructTypeKeyInfo::KeyTy
llvm::Linker::StructTypeKeyInfo::KeyTy
llvm::FunctionTypeKeyInfo::KeyTy
fuzzer::LabelRange
llvm::orc::LambdaResolver< ExternalLookupFtorT, DylibLookupFtorT >
llvm::LandingPadInfoLandingPadInfo - This structure is used to retain landing pad info for the current function
llvm::LandingPadInstLandingPadInst - The landingpad instruction holds all of the information necessary to generate correct exception handling
llvm::latency_sortSorting functions for the Available queue
llvm::LatencyPriorityQueue
llvm::LayoutAlignElemLayout alignment element
llvm::LazyCallGraphA lazily constructed view of the call graph of a module
llvm::LazyCallGraphAnalysisAn analysis pass which computes the call graph for a module
llvm::LazyCallGraphPrinterPassA pass which prints the call graph to a raw_ostream
llvm::orc::LazyEmittingLayer< BaseLayerT >Lazy-emitting IR layer
llvm::LazyValueInfoThis pass computes, caches, and vends lazy value constraint information
LdStNInstrDesc
llvm::detail::LeadingZerosCounter< T, SizeOfT >
llvm::IntervalMapImpl::LeafNode< KeyT, ValT, N, Traits >
llvm::lessA functor like C++14's std::less<void> in its absence
llvm::less_firstFunction object to check whether the first component of a std::pair compares less than the first component of another std::pair
llvm::less_ptr< Ty >
llvm::less_secondFunction object to check whether the second component of a std::pair compares less than the second component of another std::pair
llvm::LessRecordLessRecord - Sorting predicate to sort record pointers by name
llvm::LessRecordByIDLessRecordByID - Sorting predicate to sort record pointers by their unique ID
llvm::LessRecordFieldNameLessRecordFieldName - Sorting predicate to sort record pointers by their name field
llvm::LessRecordRegister
llvm::LetRecord
llvm::LexicalScopeLexicalScope - This class is used to track scope information
llvm::LexicalScopesLexicalScopes - This class provides interface to collect and use lexical scoping information from machine instruction
llvm::LibCallAliasAnalysisLibCallAliasAnalysis - Alias analysis driven from LibCallInfo
llvm::LibCallFunctionInfoLibCallFunctionInfo - Each record in the array of FunctionInfo structs records the behavior of one libcall that is known by the optimizer
llvm::LibCallInfoLibCallInfo - Abstract interface to query about library call information
llvm::LibCallLocationInfoLibCallLocationInfo - This struct describes a set of memory locations that are accessed by libcalls
llvm::LibCallSimplifierLibCallSimplifier - This class implements a collection of optimizations that replace well formed calls to library functions with a more optimal form
llvm::LICMSafetyInfoCaptures loop safety information
llvm::line_iteratorA forward iterator which reads text lines from a buffer
llvm::LineEditor
llvm::sampleprof::LineLocationRepresents the relative location of an instruction
llvm::LineReader
llvm::JITEvent_EmittedFunctionDetails::LineStart
llvm::DWARFDebugLine::LineTable
llvm::MachO::linkedit_data_command
llvm::orc::ObjectLinkingLayerBase::LinkedObjectSetHolds a set of objects to be allocated/linked as a unit in the JIT
llvm::LinkerThis class provides the core functionality of linking in LLVM
llvm::MachO::linker_option_command
llvm::LinkingSymbolResolver
llvm::DebugLocStream::List
llvm::cl::list< DataType, StorageClass, ParserClass >
llvm::cl::list_storage< DataType, StorageClass >
llvm::cl::list_storage< DataType, bool >
llvm::DebugLocStream::ListBuilderBuilder for DebugLocStream lists
llvm::Registry< T, U >::listenerAbstract base class for registry listeners, which are informed when new entries are added to the registry
llvm::ListInitListInit - [AL, AH, CL] - Represent a list of defs
llvm::ListRecTyListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of the specified type
llvm::LiveDebugVariables
llvm::MachineTraceMetrics::LiveInRegA virtual register or regunit required by a basic block or its trace successors
llvm::LiveIntervalLiveInterval - This class represents the liveness of a register, or stack slot
llvm::LiveIntervals
llvm::LiveIntervalUnionUnion of live intervals that are strong candidates for coalescing into a single register (either physical or virtual depending on the context)
llvm::FunctionLoweringInfo::LiveOutInfo
llvm::StackMaps::LiveOutReg
llvm::LivePhysRegsA set of live physical registers with functions to track liveness when walking backward/forward through a basic block
llvm::LiveQueryResultResult of a LiveRange query
llvm::LiveRangeThis class represents the liveness of a register, stack slot, etc
llvm::LiveRangeCalc
llvm::LiveRangeEdit
llvm::LiveRangeUpdaterHelper class for performant LiveRange bulk updates
llvm::LiveRegMatrix
llvm::LiveRegSetA set of live virtual registers and physical register units
llvm::LiveStacks
llvm::LiveVariables
llvm::LLLexer
llvm::LLParser
llvm_regex
llvm_regmatch_t
llvm::llvm_shutdown_objLlvm_shutdown_obj - This is a simple helper class that calls llvm_shutdown() when it is destroyed
llvm::LLVMContextThis is an important class for using LLVM in a threaded context
llvm::LLVMContextImpl
llvm::LLVMDisasmContext
LLVMMCJITCompilerOptions
LLVMOpInfo1
LLVMOpInfoSymbol1The initial support in LLVM MC for the most general form of a relocatable expression is "AddSymbol - SubtractSymbol + Offset"
llvm::LLVMTargetMachineThis class describes a target machine that is implemented with the LLVM target-independent code generator
llvm::MachO::load_command
llvm::LoadAndStorePromoterHelper class for promoting a collection of loads and stores into SSA Form using the SSAUpdater
llvm::object::MachOObjectFile::LoadCommandInfo
llvm::LoadedObjectInfoAn inferface for inquiring the load address of a loaded object file to be used by the DIContext implementations when applying relocations on the fly
llvm::RuntimeDyld::LoadedObjectInfoInformation about the loaded object
llvm::RuntimeDyld::LoadedObjectInfoHelper< Derived >
llvm::LoadInstLoadInst - an instruction for reading from memory
llvm::LoadSDNodeThis class is used to represent ISD::LOAD nodes
llvm::LocalAsMetadata
llvm::orc::LocalCXXRuntimeOverridesSupport class for static dtor execution
llvm::ELFYAML::LocalGlobalWeakSymbols
llvm::StackMaps::Location
llvm::cl::LocationClass< Ty >
llvm::LibCallFunctionInfo::LocationMRInfoLocationMRInfo - This pair captures info about whether a specific location is modified or referenced by a libcall
llvm::LockFileManagerClass that manages the creation of a lock file to aid implicit coordination between different processes
llvm::orc::LogicalDylib< BaseLayerT, LogicalModuleResources, LogicalDylibResources >
llvm::Loop
llvm::LoopAccessAnalysisThis analysis provides dependence information for the memory accesses of a loop
llvm::LoopAccessInfoDrive the analysis of memory accesses in the loop
llvm::LoopAccessReportOptimization analysis message produced during vectorization
llvm::LoopAnalysisAnalysis pass that exposes the LoopInfo for a function
llvm::LoopBase< BlockT, LoopT >LoopBase class - Instances of this class are used to represent loops that are detected in the flow graph
llvm::LoopBlocksDFSStore the result of a depth first search within basic blocks contained by a single loop
llvm::LoopBlocksTraversalTraverse the blocks in a loop using a depth-first search
llvm::BlockFrequencyInfoImplBase::LoopDataData about a loop
llvm::LoopInfo
llvm::LoopInfoBase< BlockT, LoopT >LoopInfo - This class builds and contains all of the top level loop structures in the specified function
llvm::LoopInfoWrapperPassThe legacy pass manager's analysis pass to compute loop information
llvm::LoopPass
llvm::LoopPrinterPassPrinter pass for the LoopAnalysis results
llvm::LowerExpectIntrinsicPass
llvm::LPPassManager
llvm::LSBaseSDNodeBase class for LoadSDNode and StoreSDNode
llvm::LShrOperator
llvm::LTOCodeGeneratorC++ class which implements the opaque lto_code_gen_t type
llvm::LTOModuleC++ class which implements the opaque lto_module_t type
llvm::MipsTargetLowering::LTStr
llvm::PatternMatch::m_Intrinsic_Ty< T0 >
llvm::PatternMatch::m_Intrinsic_Ty< T0, T1 >
llvm::PatternMatch::m_Intrinsic_Ty< T0, T1, T2 >
llvm::PatternMatch::m_Intrinsic_Ty< T0, T1, T2, T3 >
llvm::MachO::mach_header
llvm::MachO::mach_header_64
llvm::MachineBasicBlock
llvm::yaml::MachineBasicBlock
llvm::MachineBlockFrequencyInfoMachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic block frequencies
llvm::TargetInstrInfo::MachineBranchPredicateRepresents a predicate at the MachineFunction level
llvm::MachineBranchProbabilityInfo
llvm::MachineConstantPoolKeeps track of constants referenced by a function which must be spilled to memory
llvm::MachineConstantPoolEntryThis class is a data container for one entry in a MachineConstantPool
llvm::MachineConstantPoolValueAbstract base class for all machine specific constantpool value subclasses
llvm::MachineDominanceFrontier
llvm::MachineDominatorTreeDominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree
llvm::MachineFrameInfoAbstract stack frame until prolog/epilog code is inserted
llvm::MachineFunction
llvm::yaml::MachineFunction
llvm::MachineFunctionAnalysisMachineFunctionAnalysis - This class is a Pass that manages a MachineFunction object
llvm::MachineFunctionInfoMachineFunctionInfo - This class can be derived from and used by targets to hold private target-specific information for each MachineFunction
llvm::MachineFunctionInitializerThis interface provides a way to initialize machine functions after they are created by the machine function analysis pass
llvm::MachineFunctionPassMachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of passes that operate on the MachineFunction representation
llvm::MachineInstrRepresentation of each machine instruction
llvm::MachineInstrBuilder
llvm::MachineInstrExpressionTraitSpecial DenseMapInfo traits to compare MachineInstr* by *value* of the instruction rather than by pointer value
llvm::MachineInstrSpanMachineInstrSpan provides an interface to get an iteration range containing the instruction it was initialized with, along with all those instructions inserted prior to or following that instruction at some point after the MachineInstrSpan is constructed
llvm::MachineJumpTableEntryMachineJumpTableEntry - One jump table in the jump table info
llvm::MachineJumpTableInfo
llvm::MachineLocation
llvm::MachineLoop
llvm::MachineLoopInfo
llvm::MachineMemOperandMachineMemOperand - A description of a memory reference used in the backend
llvm::MachineModuleInfoMachineModuleInfo - This class contains meta information specific to a module
llvm::MachineModuleInfoELFMachineModuleInfoELF - This is a MachineModuleInfoImpl implementation for ELF targets
llvm::MachineModuleInfoImplMachineModuleInfoImpl - This class can be derived from and used by targets to hold private target-specific information for each Module
llvm::MachineModuleInfoMachOMachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets
llvm::MachineOperandMachineOperand class - Representation of each machine instruction operand
llvm::MachineOperandIteratorBaseMachineOperandIteratorBase - Iterator that can visit all operands on a MachineInstr, or all operands on a bundle of MachineInstrs
llvm::MachinePassRegistryMachinePassRegistry - Track the registration of machine passes
llvm::MachinePassRegistryListenerMachinePassRegistryListener - Listener to adds and removals of nodes in registration list
llvm::MachinePassRegistryNodeMachinePassRegistryNode - Machine pass node stored in registration list
llvm::MachinePointerInfoMachinePointerInfo - This class contains a discriminated union of information about pointers in memory operands, relating them back to LLVM IR or to virtual locations (such as frame indices) that are exposed during codegen
llvm::MachinePostDominatorTreePostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominator tree
llvm::MachineRegion
llvm::MachineRegionInfo
llvm::MachineRegionInfoPass
llvm::MachineRegionNode
llvm::MachineRegisterInfoMachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc
llvm::MachineSchedContextMachineSchedContext provides enough context from the MachineScheduler pass for the target to instantiate a scheduler
llvm::MachineSchedPolicyDefine a generic scheduling policy for targets that don't provide their own MachineSchedStrategy
llvm::MachineSchedRegistryMachineSchedRegistry provides a selection of available machine instruction schedulers
llvm::MachineSchedStrategyMachineSchedStrategy - Interface to the scheduling algorithm used by ScheduleDAGMI
llvm::MachineSDNodeAn SDNode that represents everything that will be needed to construct a MachineInstr
llvm::MachineSSAUpdaterMachineSSAUpdater - This class updates SSA form for a set of virtual registers defined in multiple blocks
llvm::MachineTraceMetrics
llvm::object::MachOBindEntryMachOBindEntry encapsulates the current state in the decompression of binding opcodes
llvm::MachObjectWriter
llvm::object::MachOObjectFile
llvm::object::MachORebaseEntryMachORebaseEntry encapsulates the current state in the decompression of rebasing opcodes
llvm::MachORelocationMachORelocation - This struct contains information about each relocation that needs to be emitted to the file
llvm::object::MachOUniversalBinary
llvm::MallocAllocator
llvm::ManagedStatic< C >ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on demand (good for reducing startup times of dynamic libraries that link in LLVM components) and for making destruction be explicit through the llvm_shutdown() function call
llvm::ManagedStaticBaseManagedStaticBase - Common base class for ManagedStatic instances
llvm::ManagedStringPoolManagedStringPool - The strings allocated from a managed string pool are owned by the string pool and will be deleted together with the managed string pool
llvm::Mangler
llvm::sys::fs::mapped_file_regionThis class represents a memory mapped file
llvm::mapped_iterator< RootIt, UnaryFunc >
llvm::AArch64NamedImmMapper::Mapping
llvm::yaml::MappingNormalization< TNorm, TFinal >
llvm::yaml::MappingNormalizationHeap< TNorm, TFinal >
llvm::yaml::MappingTraits< T >This class should be specialized by any type that needs to be converted to/from a YAML mapping
llvm::yaml::MappingTraits< COFF::AuxiliarybfAndefSymbol >
llvm::yaml::MappingTraits< COFF::AuxiliaryCLRToken >
llvm::yaml::MappingTraits< COFF::AuxiliaryFunctionDefinition >
llvm::yaml::MappingTraits< COFF::AuxiliarySectionDefinition >
llvm::yaml::MappingTraits< COFF::AuxiliaryWeakExternal >
llvm::yaml::MappingTraits< COFF::DataDirectory >
llvm::yaml::MappingTraits< COFF::header >
llvm::yaml::MappingTraits< COFFYAML::Object >
llvm::yaml::MappingTraits< COFFYAML::PEHeader >
llvm::yaml::MappingTraits< COFFYAML::Relocation >
llvm::yaml::MappingTraits< COFFYAML::Section >
llvm::yaml::MappingTraits< COFFYAML::Symbol >
llvm::yaml::MappingTraits< ELFYAML::FileHeader >
llvm::yaml::MappingTraits< ELFYAML::LocalGlobalWeakSymbols >
llvm::yaml::MappingTraits< ELFYAML::Object >
llvm::yaml::MappingTraits< ELFYAML::Relocation >
llvm::yaml::MappingTraits< ELFYAML::SectionOrType >
llvm::yaml::MappingTraits< ELFYAML::Symbol >
llvm::yaml::MappingTraits< MachineBasicBlock >
llvm::yaml::MappingTraits< MachineFunction >
llvm::yaml::MappingTraits< std::unique_ptr< ELFYAML::Section > >
llvm::MapVector< KeyT, ValueT, MapType, VectorType >This class implements a map that also provides access to all stored values in a deterministic order
MarkPendingLoopPredicateRAII wrapper to prevent recursive application of isImpliedCond
llvm::MaskedGatherScatterSDNodeThis is a base class used to represent MGATHER and MSCATTER nodes
llvm::MaskedGatherSDNodeThis class is used to represent an MGATHER node
llvm::MaskedLoadSDNodeThis class is used to represent an MLOAD node
llvm::MaskedLoadStoreSDNodeThis base class is used to represent MLOAD and MSTORE nodes
llvm::MaskedScatterSDNodeThis class is used to represent an MSCATTER node
llvm::MaskedStoreSDNodeThis class is used to represent an MSTORE node
llvm::PatternMatch::match_combine_and< LTy, RTy >
llvm::PatternMatch::match_combine_or< LTy, RTy >Matching combinators
llvm::PatternMatch::match_neg_zero
llvm::PatternMatch::match_zero
llvm::PBQP::MatrixPBQP Matrix class
llvm::PBQP::RegAlloc::MatrixMetadataMetadata to speed allocatability test
llvm::MaximumSpanningTree< T >MaximumSpanningTree - A MST implementation
llvm::PatternMatch::MaxMin_match< CmpInst_t, LHS_t, RHS_t, Pred_t >
llvm::MBB2NumberFunctor
llvm::MCAlignFragment
llvm::MCAsmBackendGeneric interface to target specific assembler backends
llvm::MCAsmInfoThis class is intended to be used as a base class for asm properties and features specific to the target
llvm::MCAsmInfoCOFF
llvm::MCAsmInfoDarwin
llvm::MCAsmInfoELF
llvm::MCAsmInfoGNUCOFF
llvm::MCAsmInfoMicrosoft
llvm::MCAsmLayoutEncapsulates the layout of an assembly file at a particular point in time
llvm::MCAsmLexerGeneric assembler lexer interface, for use by target specific assembly lexers
llvm::MCAsmParserGeneric assembler parser interface, for use by target specific assembly parsers
llvm::MCAsmParserExtensionGeneric interface for extending the MCAsmParser, which is implemented by target and object file assembly parser implementations
llvm::MCAsmParserSemaCallbackGeneric Sema callback for assembly parser
llvm::MCAssembler
llvm::MCBinaryExprBinary assembler expressions
llvm::MCCFIInstruction
llvm::MCCodeEmitterMCCodeEmitter - Generic instruction encoding interface
llvm::MCCodeGenInfo
llvm::MCCompactEncodedInstFragmentThis is a compact (memory-size-wise) fragment for holding an encoded instruction (non-relaxable) that has no fixups registered
llvm::MCConstantExpr
llvm::MCContextContext object for machine code objects
llvm::MCDataFragmentFragment for data and encoded instructions
llvm::MCDisassemblerSuperclass for all disassemblers
llvm::MCDwarfCallFrameFragment
llvm::MCDwarfDwoLineTable
llvm::MCDwarfFileInstances of this class represent the name of the dwarf .file directive and its associated dwarf file number in the MC file, and MCDwarfFile's are created and uniqued by the MCContext class where the file number for each is its index into the vector of DwarfFiles (note index 0 is not used and not a valid dwarf file number)
llvm::MCDwarfFrameEmitter
llvm::MCDwarfFrameInfo
llvm::MCDwarfLineAddr
llvm::MCDwarfLineAddrFragment
llvm::MCDwarfLineTable
llvm::MCDwarfLineTableHeader
llvm::MCDwarfLocInstances of this class represent the information from a dwarf .loc directive
llvm::MCELFObjectTargetWriter
llvm::MCELFStreamer
llvm::MCEncodedFragmentInterface implemented by fragments that contain encoded instructions and/or data
llvm::MCEncodedFragmentWithContents< ContentsSize >Interface implemented by fragments that contain encoded instructions and/or data
llvm::MCEncodedFragmentWithFixups< ContentsSize, FixupsSize >Interface implemented by fragments that contain encoded instructions and/or data and also have fixups registered
llvm::MCExprBase class for the full range of assembler expressions which are needed for parsing
llvm::MCExternalSymbolizerSymbolize using user-provided, C API, callbacks
llvm::MCFillFragment
llvm::MCFixupEncode information on a single operation to perform on a byte sequence (e.g., an encoded instruction) which requires assemble- or run- time patching
llvm::MCFixupKindInfoTarget independent information on a fixup kind
llvm::MCFragment
llvm::MCGenDwarfInfo
llvm::MCGenDwarfLabelEntry
llvm::MCInstInstances of this class represent a single low-level machine instruction
llvm::MCInstBuilder
llvm::MCInstPrinterThis is an instance of a target assembly language printer that converts an MCInst to valid target assembly syntax
llvm::MCInstrAnalysis
llvm::MCInstrDescDescribe properties that are true of each instruction in the target description file
llvm::MCInstrInfoInterface to description of machine instruction set
llvm::MCJIT
llvm::MCJITMemoryManager
llvm::MCLabelInstances of this class represent a label name in the MC file, and MCLabel are created and uniqued by the MCContext class
llvm::MCLEBFragment
llvm::MCLineEntryInstances of this class represent the line information for the dwarf line table entries
llvm::MCLineSectionInstances of this class represent the line information for a compile unit where machine instructions have been assembled after seeing .loc directives
llvm::MCLOHContainer
llvm::MCLOHDirectiveStore Linker Optimization Hint information (LOH)
llvm::MCMachObjectTargetWriter
llvm::MCObjectFileInfo
llvm::MCObjectStreamerStreaming object file generation interface
llvm::MCObjectWriterDefines the object file and target independent interfaces used by the assembler backend to write native file format object files
llvm::MCOperandInstances of this class represent operands of the MCInst class
llvm::MCOperandInfoThis holds information about one operand of a machine instruction, indicating the register class for register operands, etc
llvm::MCOrgFragment
llvm::MCParsedAsmOperandMCParsedAsmOperand - This abstract class represents a source-level assembly instruction operand
llvm::MCProcResourceDescDefine a kind of processor resource that will be modeled by the scheduler
llvm::MCReadAdvanceEntrySpecify the number of cycles allowed after instruction issue before a particular use operand reads its registers
llvm::MCRegAliasIteratorMCRegAliasIterator enumerates all registers aliasing Reg
llvm::MCRegisterClassMCRegisterClass - Base class of TargetRegisterClass
llvm::MCRegisterDescMCRegisterDesc - This record contains information about a particular register
llvm::MCRegisterInfoMCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc objects that represent all of the machine registers that the target has
llvm::MCRegUnitIterator
llvm::MCRegUnitMaskIteratorMCRegUnitIterator enumerates a list of register units and their associated lane masks for Reg
llvm::MCRegUnitRootIteratorMCRegUnitRootIterator enumerates the root registers of a register unit
llvm::MCRelaxableFragmentA relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler layout and relaxation stage
llvm::MCRelocationInfoCreate MCExprs from relocations found in an object file
llvm::MCSafeSEHFragment
llvm::MCSchedClassDescSummarize the scheduling resources required for an instruction of a particular scheduling class
llvm::MCSchedModelMachine model for scheduling, bundling, and heuristics
llvm::MCSectionInstances of this class represent a uniqued identifier for a section in the current translation unit
llvm::MCSectionCOFFMCSectionCOFF - This represents a section on Windows
llvm::MCSectionELFMCSectionELF - This represents a section on linux, lots of unix variants and some bare metal systems
llvm::MCSectionMachOMCSectionMachO - This represents a section on a Mach-O system (used by Mac OS X)
llvm::MCStreamerStreaming machine code generation interface
llvm::MCSubRegIndexIteratorIterator that enumerates the sub-registers of a Reg and the associated sub-register indices
llvm::MCSubRegIteratorMCSubRegIterator enumerates all sub-registers of Reg
llvm::MCSubtargetInfoMCSubtargetInfo - Generic base class for all target subtargets
llvm::MCSuperRegIteratorMCSuperRegIterator enumerates all super-registers of Reg
llvm::MCSymbolMCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created and uniqued by the MCContext class
llvm::MCSymbolCOFF
llvm::MCSymbolELF
llvm::MCSymbolizerSymbolize and annotate disassembled instructions
llvm::MCSymbolMachO
llvm::MCSymbolRefExprRepresent a reference to a symbol from inside an expression
llvm::MCSymbolSDNode
llvm::MCTargetAsmParserMCTargetAsmParser - Generic interface to target specific assembly parsers
llvm::MCTargetExprThis is an extension point for target-specific MCExpr subclasses to implement
llvm::MCTargetOptions
llvm::MCTargetStreamerTarget specific streamer interface
llvm::MCUnaryExprUnary assembler expressions
llvm::MCValueThis represents an "assembler immediate"
llvm::MCWinCOFFObjectTargetWriter
llvm::MCWinCOFFStreamer
llvm::MCWriteLatencyEntrySpecify the latency in cpu cycles for a particular scheduling class and def index
llvm::MCWriteProcResEntryIdentify one of the processor resource kinds consumed by a particular scheduling class for the specified number of cycles
llvm::MD5
llvm::MDAttachmentMapMap-like storage for metadata attachments
llvm::MDBuilder
llvm::PBQP::MDMatrix< Metadata >
llvm::MDNodeMetadata node
llvm::MDNodeInfo< NodeTy >DenseMapInfo for MDNode subclasses
llvm::MDNodeKeyImpl< DIBasicType >
llvm::MDNodeKeyImpl< DICompileUnit >
llvm::MDNodeKeyImpl< DICompositeType >
llvm::MDNodeKeyImpl< DIDerivedType >
llvm::MDNodeKeyImpl< DIEnumerator >
llvm::MDNodeKeyImpl< DIExpression >
llvm::MDNodeKeyImpl< DIFile >
llvm::MDNodeKeyImpl< DIGlobalVariable >
llvm::MDNodeKeyImpl< DIImportedEntity >
llvm::MDNodeKeyImpl< DILexicalBlock >
llvm::MDNodeKeyImpl< DILexicalBlockFile >
llvm::MDNodeKeyImpl< DILocalVariable >
llvm::MDNodeKeyImpl< DILocation >DenseMapInfo for DILocation
llvm::MDNodeKeyImpl< DINamespace >
llvm::MDNodeKeyImpl< DIObjCProperty >
llvm::MDNodeKeyImpl< DISubprogram >
llvm::MDNodeKeyImpl< DISubrange >
llvm::MDNodeKeyImpl< DISubroutineType >
llvm::MDNodeKeyImpl< DITemplateTypeParameter >
llvm::MDNodeKeyImpl< DITemplateValueParameter >
llvm::MDNodeKeyImpl< GenericDINode >DenseMapInfo for GenericDINode
llvm::MDNodeKeyImpl< MDTuple >DenseMapInfo for MDTuple
llvm::MDNodeOpsKeyStructure for hashing arbitrary MDNode operands
llvm::MDNodeSDNode
llvm::MDOperandTracking metadata reference owned by Metadata
llvm::MDStringA single uniqued string
llvm::MDTupleTuple of metadata
llvm::MDTupleTypedArrayWrapper< T >Typed, array-like tuple of metadata
llvm::PBQP::MDVector< Metadata >
llvm::EquivalenceClasses< ElemTy >::member_iterator
llvm::MemCpyInstMemCpyInst - This class wraps the llvm.memcpy intrinsic
llvm::MemDepResultMemDepResult - A memory dependence query can return one of three different answers, described below
llvm::MemIntrinsicMemIntrinsic - This is the common base class for memset/memcpy/memmove
llvm::MemIntrinsicInfoInformation about a load/store intrinsic defined by the target
llvm::MemIntrinsicSDNodeThis SDNode is used for target intrinsics that touch memory and need an associated MachineMemOperand
llvm::MemMoveInstMemMoveInst - This class wraps the llvm.memmove intrinsic
llvm::X86Operand::MemOp
llvm::sys::MemoryThis class provides various memory handling functions that manipulate MemoryBlock instances
llvm::sys::MemoryBlockThis class encapsulates the notion of a memory block which has an address and a size
llvm::MemoryBufferThis interface provides simple read-only access to a block of memory, and provides simple methods for reading files and standard input into a memory buffer
llvm::MemoryBufferRef
llvm::MemoryDepCheckerChecks memory dependences among accesses to the same underlying object to determine whether there vectorization is legal or not (and at which vectorization factor)
llvm::MemoryDependenceAnalysisMemoryDependenceAnalysis - This is an analysis that determines, for a given memory operation, what preceding memory operations it depends on
llvm::MemoryLocationRepresentation for a specific memory location
llvm::RuntimeDyld::MemoryManagerMemory Management
llvm::MemoryObjectInterface to data which might be streamed
llvm::MemSDNodeThis is an abstract virtual class for memory operations
llvm::MemSetInstMemSetInst - This class wraps the llvm.memset intrinsic
llvm::MemTransferInstMemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics
llvm::MetadataRoot of the metadata hierarchy
llvm::MetadataAsValueMetadata wrapper in the Value hierarchy
llvm::MetadataTrackingAPI for tracking metadata references through RAUW and deletion
llvm::MIBundleBuilderHelper class for constructing bundles of MachineInstrs
llvm::MIBundleOperandsMIBundleOperands - Iterate over all operands in a bundle of machine instructions
llvm::AArch64FunctionInfo::MILOHDirective
llvm::MIOperandsMIOperands - Iterate over operands of a single instruction
llvm::Mips16DAGToDAGISel
llvm::Mips16FrameLowering
llvm::Mips16InstrInfo
llvm::Mips16RegisterInfo
llvm::Mips16TargetLowering
llvm::ELFYAML::MipsABIFlags
llvm::MipsABIFlagsSection
llvm::MipsABIInfo
llvm::MipsAnalyzeImmediate
llvm::MipsAsmBackend
llvm::MipsAsmPrinter
llvm::MipsCallEntryA class derived from PseudoSourceValue that represents a GOT entry resolved by lazy-binding
llvm::MipsCCState
llvm::MipsDAGToDAGISel
llvm::MipsebTargetMachineMipsebTargetMachine - Mips32/64 big endian target machine
llvm::MipsELFStreamer
llvm::MipselTargetMachineMipselTargetMachine - Mips32/64 little endian target machine
llvm::MipsFrameLowering
llvm::MipsFunctionInfoMipsFunctionInfo - This class is derived from MachineFunction private Mips target-specific information for each MachineFunction
MipsGenInstrInfo
MipsGenRegisterInfo
MipsGenSubtargetInfo
llvm::MipsInstPrinter
llvm::MipsInstrInfo
llvm::MipsMCAsmInfo
llvm::MipsMCCodeEmitter
llvm::MipsMCExpr
llvm::MipsMCInstLowerMipsMCInstLower - This class is used to lower an MachineInstr into an
llvm::MipsOptionRecord
llvm::MipsRegInfoRecord
llvm::MipsRegisterInfo
llvm::MipsSEDAGToDAGISel
llvm::MipsSEFrameLowering
llvm::MipsSEInstrInfo
llvm::MipsSelectionDAGInfo
llvm::MipsSERegisterInfo
llvm::MipsSETargetLowering
llvm::MipsSubtarget
llvm::MipsTargetAsmStreamer
llvm::MipsTargetELFStreamer
llvm::MipsTargetLowering
llvm::MipsTargetMachine
llvm::MipsTargetObjectFile
llvm::MipsTargetStreamer
llvm::MIRParserThis class initializes machine functions by applying the state loaded from a MIR file
llvm::MIRParserImplThis class implements the parsing of LLVM IR that's embedded inside a MIR file
llvm::yaml::missingTraits< T >
llvm::MITokenA token produced by the machine instruction lexer
llvm::MMIAddrLabelMap
llvm::MMIAddrLabelMapCallbackPtr
llvm::MachO::mmst_reg_t
ModRMDecisionSpecifies whether a ModR/M byte is needed and (if so) which instruction each possible value of the ModR/M byte corresponds to
llvm::ModuleA Module instance is used to store all the information related to an LLVM module
llvm::ModuleAnalysisManagerCGSCCProxyA CGSCC analysis which acts as a proxy for a module analysis manager
llvm::ModuleAnalysisManagerFunctionProxyA function analysis which acts as a proxy for a module analysis manager
llvm::Module::ModuleFlagEntry
llvm::ModulePassModulePass class - This class is used to implement unstructured interprocedural optimizations and analyses
llvm::ModuleToFunctionPassAdaptor< FunctionPassT >Trivial adaptor that maps from a module to its functions
llvm::ModuleToPostOrderCGSCCPassAdaptor< CGSCCPassT >The core module pass which does a post-order walk of the SCCs and runs a CGSCC pass over each one
llvm::AArch64SysReg::MRSMapper
llvm::APInt::msMagic data for optimising signed division by a constant
llvm::MSP430FrameLowering
MSP430GenInstrInfo
MSP430GenRegisterInfo
MSP430GenSubtargetInfo
llvm::MSP430InstPrinter
llvm::MSP430InstrInfo
llvm::MSP430MachineFunctionInfoMSP430MachineFunctionInfo - This class is derived from MachineFunction and contains private MSP430 target-specific information for each MachineFunction
llvm::MSP430MCAsmInfo
llvm::MSP430MCInstLowerMSP430MCInstLower - This class is used to lower an MachineInstr into an MCInst
llvm::MSP430RegisterInfo
llvm::MSP430SelectionDAGInfo
llvm::MSP430Subtarget
llvm::MSP430TargetLowering
llvm::MSP430TargetMachineMSP430TargetMachine
llvm::AArch64SysReg::MSRMapper
llvm::APInt::muMagic data for optimising unsigned division by a constant
llvm::MulOperator
llvm::cl::multi_val
llvm::MultiClass
llvm::MutableArrayRef< T >MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memory), i.e
llvm::MutexGuardInstances of this class acquire a given Mutex Lock when constructed and hold that lock until destruction
llvm::sys::MutexImplPlatform agnostic Mutex class
llvm::MVTMVT - Machine Value Type
MyFuzzer
llvm::NamedMDNodeA tuple of MDNodes
llvm::NamedRegionTimerNamedRegionTimer - This class is basically a combination of TimeRegion and Timer
llvm::MCSymbol::NameEntryStorageTyThe name for a symbol
llvm::PatternMatch::neg_match< LHS_t >
llvm::NewArchiveIterator
llvm::MachO::nlist
llvm::MachO::nlist_64
llvm::MachO::nlist_base
llvm::yaml::NodeAbstract base class for all Nodes
llvm::Registry< T, U >::nodeNode in linked list of entries
llvm::LazyCallGraph::NodeA node in the call graph
llvm::SpillPlacement::NodeNode - Each edge bundle corresponds to a Hopfield node
llvm::FoldingSetImpl::NodeNode - This class is used to maintain the singly linked bucket list in a folding set
llvm::IntervalMapImpl::NodeBase< T1, T2, N >
llvm::PBQP::Graph< SolverT >::NodeIdSet
llvm::PBQP::Graph< SolverT >::NodeItr
llvm::PBQP::RegAlloc::NodeMetadataHolds solver state and other metadata relevant to each PBQP RA node
llvm::IntervalMapImpl::NodeRef
llvm::IntervalMapImpl::NodeSizer< KeyT, ValT >
llvm::NoFolderNoFolder - Create "constants" (actually, instructions) with no folding
llvm::NonLocalDepEntryNonLocalDepEntry - This is an entry in the NonLocalDepInfo cache
llvm::NonLocalDepResultNonLocalDepResult - This is a result from a NonLocal dependence query
llvm::PatternMatch::not_match< LHS_t >
llvm::orc::NullResolverSymbolResolver impliementation that rejects all resolution requests
llvm::NVPTXAsmPrinter
llvm::NVPTXFloatMCExpr
llvm::NVPTXFrameLowering
llvm::NVPTXGenericMCSymbolRefExprA wrapper for MCSymbolRefExpr that tells the assembly printer that the symbol should be enclosed by generic()
NVPTXGenInstrInfo
NVPTXGenRegisterInfo
NVPTXGenSubtargetInfo
llvm::NVPTXInstPrinter
llvm::NVPTXInstrInfo
llvm::NVPTXMachineFunctionInfo
llvm::NVPTXMCAsmInfo
llvm::NVPTXRegisterInfo
llvm::NVPTXSectionNVPTXSection - Represents a section in PTX PTX does not have sections
llvm::NVPTXSubtarget
llvm::NVPTXTargetLowering
llvm::NVPTXTargetMachineNVPTXTargetMachine
llvm::NVPTXTargetMachine32
llvm::NVPTXTargetMachine64
llvm::NVPTXTargetObjectFile
llvm::NVPTXTTIImpl
llvm::objcarc::ObjCARCAliasAnalysisThis is a simple alias analysis implementation that uses knowledge of ARC constructs to answer queries
llvm::COFFYAML::Object
llvm::ELFYAML::Object
llvm::object_deleter< T >Object_deleter - Helper method for ManagedStatic
llvm::object_deleter< T[N]>
llvm::object::MachOUniversalBinary::object_iterator
llvm::ObjectCacheThis is the base ObjectCache type which can be provided to an ExecutionEngine for the purpose of avoiding compilation for Modules that have already been compiled and an object file is available
llvm::object::ObjectFileThis class is the base class for all object file types
llvm::object::MachOUniversalBinary::ObjectForArch
llvm::orc::ObjectLinkingLayer< NotifyLoadedFtor >Bare bones object linking layer
llvm::orc::ObjectLinkingLayerBase
llvm::ObjectMemoryBufferSmallVector-backed MemoryBuffer instance
llvm::ObjectSizeOffsetEvaluatorEvaluate the size and offset of an object pointed to by a Value*
llvm::ObjectSizeOffsetVisitorEvaluate the size and offset of an object pointed to by a Value* statically
llvm::PatternMatch::ofmax_pred_tyHelper class for identifying ordered max predicates
llvm::PatternMatch::ofmin_pred_tyHelper class for identifying ordered min predicates
llvm::OnDiskChainedHashTable< Info >Provides lookup on an on disk hash table
llvm::OnDiskChainedHashTableGenerator< Info >Generates an on disk hash table
llvm::OnDiskIterableChainedHashTable< Info >Provides lookup and iteration over an on disk hash table
llvm::PatternMatch::OneUse_match< SubPattern_t >
OpcodeDecisionSpecifies which set of ModR/M->instruction tables to look at given a particular opcode
llvm::X86Disassembler::OperandSpecifierThe specification for how to extract and interpret one operand
llvm::OperandTraits< AtomicCmpXchgInst >
llvm::OperandTraits< AtomicRMWInst >
llvm::OperandTraits< BinaryConstantExpr >
llvm::OperandTraits< BinaryOperator >
llvm::OperandTraits< BlockAddress >
llvm::OperandTraits< BranchInst >
llvm::OperandTraits< CallInst >
llvm::OperandTraits< CmpInst >
llvm::OperandTraits< CompareConstantExpr >
llvm::OperandTraits< ConstantArray >
llvm::OperandTraits< ConstantExpr >
llvm::OperandTraits< ConstantPlaceHolder >
llvm::OperandTraits< ConstantStruct >
llvm::OperandTraits< ConstantVector >
llvm::OperandTraits< ExtractElementConstantExpr >
llvm::OperandTraits< ExtractElementInst >
llvm::OperandTraits< ExtractValueConstantExpr >
llvm::OperandTraits< Function >
llvm::OperandTraits< GetElementPtrConstantExpr >
llvm::OperandTraits< GetElementPtrInst >
llvm::OperandTraits< GlobalAlias >
llvm::OperandTraits< GlobalVariable >
llvm::OperandTraits< IndirectBrInst >
llvm::OperandTraits< InsertElementConstantExpr >
llvm::OperandTraits< InsertElementInst >
llvm::OperandTraits< InsertValueConstantExpr >
llvm::OperandTraits< InsertValueInst >
llvm::OperandTraits< InvokeInst >
llvm::OperandTraits< LandingPadInst >
llvm::OperandTraits< PHINode >
llvm::OperandTraits< ResumeInst >
llvm::OperandTraits< ReturnInst >
llvm::OperandTraits< SelectConstantExpr >
llvm::OperandTraits< SelectInst >
llvm::OperandTraits< ShuffleVectorConstantExpr >
llvm::OperandTraits< ShuffleVectorInst >
llvm::OperandTraits< StoreInst >
llvm::OperandTraits< SwitchInst >
llvm::OperandTraits< UnaryConstantExpr >
llvm::OperandTraits< UnaryInstruction >
llvm::SetTheory::OperatorOperator - A callback representing a DAG operator
llvm::OperatorThis is a utility class that provides an abstraction for the common functionality between Instructions and ConstantExprs
llvm::OpInitOpInit - Base class for operators
llvm::OProfileWrapper
llvm::cl::opt< DataType, ExternalStorage, ParserClass >
llvm::cl::opt_storage< DataType, ExternalStorage, isClass >
llvm::cl::opt_storage< DataType, false, false >
llvm::cl::opt_storage< DataType, false, true >
llvm::opt::OptionOption - Abstract representation for a single form of driver argument
llvm::cl::Option
llvm::Optional< T >
llvm::OptionalOperandTraits< SubClass, ARITY >OptionalOperandTraits - when the number of operands may change at runtime
llvm::cl::OptionCategory
llvm::cl::OptionDiffPrinter< ParserDT, ValDT >
llvm::cl::OptionDiffPrinter< DT, DT >
llvm::cl::parser< DataType >::OptionInfo
llvm::detail::OptionKey< ValT, Base, Mem >
llvm::OptionRegistrySingleton class used to register debug options
llvm::cl::OptionValueBase< DataType, isClass >
llvm::cl::OptionValueBase< DataType, false >
llvm::cl::OptionValueCopy< DataType >
llvm::OptLevelChangerThis class is used by SelectionDAGISel to temporarily override the optimization level on a per-function basis
llvm::opt::OptSpecifierOptSpecifier - Wrapper class for abstracting references to option IDs
llvm::opt::OptTableProvide access to the Option info table
llvm::orc::OrcMCJITReplacement
llvm::orc::OrcX86_64
llvm::yaml::OutputUsed to generate a yaml document from in-memory structs and vectors
llvm::ISD::OutputArgOutputArg - This struct carries flags and a value for a single outgoing (actual) argument or outgoing (from the perspective of the caller) return value virtual register
llvm::OutputBuffer
llvm::PatternMatch::OverflowingBinaryOp_match< LHS_t, RHS_t, Opcode, WrapFlags >
llvm::OverflowingBinaryOperatorUtility class for integer arithmetic operators which may exhibit overflow - Add, Sub, and Mul
llvm::object::OwningBinary< T >
llvm::support::detail::packed_endian_specific_integral< value_type, endian, alignment >
llvm::PackedVector< T, BitNum, BitVectorTy >Store a vector of values using a specific number of bits for each value
PackedVectorBase
llvm::PackedVectorBase< T, BitNum, BitVectorTy, false >
llvm::PackedVectorBase< T, BitNum, BitVectorTy, true >
llvm::EHStreamer::PadRangeStructure holding a try-range and the associated landing pad
pair
llvm::pair_hash< First, Second >
parse
llvm::ParseInstructionInfo
llvm::cl::parser< DataType >
false::PartiallyConstructedSafepointRecord
llvm::PassPass interface - Implemented by all 'passes'
llvm::PassArgFilter< Args >===----------------------------------------------------------------------===// PassArgFilter - A filter for use with PassNameFilterParser that only accepts a Pass whose Arg matches certain strings
llvm::PassBuilderThis class provides access to building LLVM's passes
llvm::detail::PassConcept< IRUnitT >Template for the abstract base class used to dispatch polymorphically over pass objects
llvm::PassConfigImpl
llvm::PassInfoPassInfo class - An instance of this class exists for every pass known by the system, and can be obtained from a live Pass by calling its getPassInfo() method
llvm::legacy::PassManagerPassManager manages ModulePassManagers
llvm::PassManager< IRUnitT >Manages a sequence of passes over units of IR
llvm::legacy::PassManagerBasePassManagerBase - An abstract interface to allow code to add passes to a pass manager without having to hard-code what kind of pass manager it is
llvm::PassManagerBuilderPassManagerBuilder - This class is used to set up a standard optimization sequence for languages like C and C++, allowing some APIs to customize the pass sequence in various ways
llvm::legacy::PassManagerImplPassManagerImpl manages MPPassManagers
llvm::PassManagerPrettyStackEntryPassManagerPrettyStackEntry - This is used to print informative information about what pass is running when/if a stack trace is generated
llvm::detail::PassModel< IRUnitT, PassT, PreservedAnalysesT, false >Specialization of PassModel for passes that accept an analyis manager
llvm::detail::PassModel< IRUnitT, PassT, PreservedAnalysesT, true >Specialization of PassModel for passes that accept an analyis manager
llvm::PassNameParser
llvm::PassRegistrationListenerPassRegistrationListener class - This class is meant to be derived from by clients that are interested in which passes get registered and unregistered at runtime (which can be because of the RegisterPass constructors being run as the program starts up, or may be because a shared object just got loaded)
llvm::PassRegistryPassRegistry - This class manages the registration and intitialization of the pass subsystem as application startup, and assists the PassManager in resolving pass dependencies
llvm::detail::PassRunAcceptsAnalysisManager< IRUnitT, PassT, ResultT >SFINAE metafunction for computing whether PassT has a run method accepting an AnalysisManager<IRUnitT>
llvm::PatchPointOpersMI-level patchpoint operands
llvm::IntervalMapImpl::Path
llvm::PBQPRAConstraintAbstract base for classes implementing PBQP register allocation constraints (e.g
llvm::PBQPRAConstraintListPBQP register allocation constraint composer
llvm::PBQP::RegAlloc::PBQPRAGraph
llvm::PDB_UniqueIdDefines a 128-bit unique identifier
llvm::PDBContextPDBContext This data structure is the top level entity that deals with PDB debug information parsing
llvm::PDBSymbolPDBSymbol defines the base of the inheritance hierarchy for concrete symbol types (e.g
llvm::PDBSymbolAnnotation
llvm::PDBSymbolBlock
llvm::PDBSymbolCompiland
llvm::PDBSymbolCompilandDetails
llvm::PDBSymbolCompilandEnv
llvm::PDBSymbolCustomPDBSymbolCustom represents symbols that are compiler-specific and do not fit anywhere else in the lexical hierarchy
llvm::PDBSymbolData
llvm::PDBSymbolExe
llvm::PDBSymbolFunc
llvm::PDBSymbolFuncDebugEnd
llvm::PDBSymbolFuncDebugStart
llvm::PDBSymbolLabel
llvm::PDBSymbolPublicSymbol
llvm::PDBSymbolThunk
llvm::PDBSymbolTypeArray
llvm::PDBSymbolTypeBaseClass
llvm::PDBSymbolTypeBuiltin
llvm::PDBSymbolTypeCustom
llvm::PDBSymbolTypeDimension
llvm::PDBSymbolTypeEnum
llvm::PDBSymbolTypeFriend
llvm::PDBSymbolTypeFunctionArg
llvm::PDBSymbolTypeFunctionSig
llvm::PDBSymbolTypeManaged
llvm::PDBSymbolTypePointer
llvm::PDBSymbolTypeTypedef
llvm::PDBSymbolTypeUDT
llvm::PDBSymbolTypeVTable
llvm::PDBSymbolTypeVTableShape
llvm::PDBSymbolUnknown
llvm::PDBSymbolUsingNamespace
llvm::PDBSymDumper
llvm::object::pe32_headerThe 32-bit PE header that follows the COFF header
llvm::COFF::PE32Header
llvm::object::pe32plus_headerThe 64-bit PE header that follows the COFF header
llvm::COFFYAML::PEHeader
llvm::WinCodeViewLineTables::FileNameRegistryTy::PerFileInfo
llvm::SSAUpdaterTraits< SSAUpdater >::PHI_iterator
llvm::SSAUpdaterTraits< MachineSSAUpdater >::PHI_iteratorIterator for PHI operands
llvm::PHINode
llvm::PHITransAddrPHITransAddr - An address value which tracks and handles phi translation
llvm::MachineOperandIteratorBase::PhysRegInfoPhysRegInfo - Information about a physical register used by a set of operands
llvm::PhysRegSUOperRecord a physical register access
llvm::support::detail::PickAlignment< T, alignment >::value is either alignment, or alignof(T) if alignment is 0
llvm::PluginLoader
llvm::PMDataManagerPMDataManager provides the common place to manage the analysis data used by pass managers
llvm::PMStackPMStack - This class implements a stack data structure of PMDataManager pointers
llvm::PMTopLevelManagerPMTopLevelManager manages LastUser info and collects common APIs used by top level pass managers
llvm::po_ext_iterator< T, SetType >
llvm::po_iterator< GraphT, SetType, ExtStorage, GT >
llvm::po_iterator_storage< SetType, External >Default po_iterator_storage implementation with an internal set object
llvm::po_iterator_storage< LoopBlocksTraversal, true >Specialize po_iterator_storage to record postorder numbers
llvm::po_iterator_storage< LoopBounds, true >
llvm::po_iterator_storage< SetType, true >Specialization of po_iterator_storage that references an external set
llvm::pointee_iterator< WrappedIteratorT, T >An iterator type that allows iterating over the pointees via some other iterator
llvm::PointerAlignElemLayout pointer alignment element
llvm::PointerIntPair< PointerTy, IntBits, IntType, PtrTraits >PointerIntPair - This class implements a pair of a pointer and small integer
llvm::PointerLikeTypeTraits< T >PointerLikeTypeTraits - This is a traits object that is used to handle pointer types and things that are just wrappers for pointers as a uniform entity
llvm::PointerLikeTypeTraits< const T * >
llvm::PointerLikeTypeTraits< Instruction * >
llvm::PointerLikeTypeTraits< PointerIntPair< PointerTy, IntBits, IntType, PtrTraits > >
llvm::PointerLikeTypeTraits< PointerUnion3< PT1, PT2, PT3 > >
llvm::PointerLikeTypeTraits< PointerUnion4< PT1, PT2, PT3, PT4 > >
llvm::PointerLikeTypeTraits< PointerUnion< PT1, PT2 > >
llvm::PointerLikeTypeTraits< T * >
llvm::PointerLikeTypeTraits< uintptr_t >
llvm::PointerLikeTypeTraits< Use ** >
llvm::PointerLikeTypeTraits< Value * >
llvm::PointerLikeTypeTraits< ValueHandleBase ** >
llvm::PointerTypePointerType - Class to represent pointers
llvm::PointerUnion< PT1, PT2 >PointerUnion - This implements a discriminated union of two pointer types, and keeps the discriminator bit-mangled into the low bits of the pointer
llvm::PointerUnion3< PT1, PT2, PT3 >PointerUnion3 - This is a pointer union of three pointer types
llvm::PointerUnion4< PT1, PT2, PT3, PT4 >PointerUnion4 - This is a pointer union of four pointer types
llvm::PointerUnionTypeSelector< T1, T2, RET_EQ, RET_NE >Get a type based on whether two types are the same or not
llvm::PointerUnionTypeSelector< T, T, RET_EQ, RET_NE >
llvm::PointerUnionTypeSelectorReturn< T >
llvm::PointerUnionTypeSelectorReturn< PointerUnionTypeSelector< T1, T2, RET_EQ, RET_NE > >
llvm::PointerUnionUIntTraits< PT1, PT2 >Provide PointerLikeTypeTraits for void* that is used by PointerUnion for the two template arguments
llvm::PBQP::PoolCostAllocator< VectorT, MatrixT >
llvm::PooledStringPtrPooledStringPtr - A pointer to an interned string
llvm::PopulateLoopsDFS< BlockT, LoopT >Populate all loop data in a stable order during a single forward DFS
llvm::detail::PopulationCounter< T, SizeOfT >
llvm::detail::PopulationCounter< T, 8 >
llvm::PossiblyExactOperatorA udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed
llvm::PostDominatorTreePostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominator tree
llvm::PostGenericSchedulerPostGenericScheduler - Interface to the scheduling algorithm used by ScheduleDAGMI
llvm::LazyCallGraph::postorder_scc_iteratorA post-order depth-first SCC iterator over the call graph
llvm::PPC32TargetMachinePPC32TargetMachine - PowerPC 32-bit target machine
llvm::PPC64LinuxTargetObjectFilePPC64LinuxTargetObjectFile - This implementation is used for 64-bit PowerPC Linux
llvm::PPC64TargetMachinePPC64TargetMachine - PowerPC 64-bit target machine
llvm::types::ppc_fp128
llvm::PPCDispatchGroupSBHazardRecognizerPPCDispatchGroupSBHazardRecognizer - This class implements a scoreboard-based hazard recognizer for PPC ooo processors with dispatch-group hazards
llvm::PPCELFMCAsmInfo
llvm::PPCFrameLowering
llvm::PPCFunctionInfoPPCFunctionInfo - This class is derived from MachineFunction private PowerPC target-specific information for each MachineFunction
PPCGenInstrInfo
PPCGenRegisterInfo
PPCGenSubtargetInfo
llvm::PPCHazardRecognizer970PPCHazardRecognizer970 - This class defines a finite state automata that models the dispatch logic on the PowerPC 970 (aka G5) processor
llvm::PPCInstPrinter
llvm::PPCInstrInfo
llvm::PPCMCAsmInfoDarwin
llvm::PPCMCExpr
llvm::PPCRegisterInfo
llvm::PPCSelectionDAGInfo
llvm::PPCSubtarget
llvm::PPCTargetLowering
llvm::PPCTargetMachinePPCTargetMachine - Common code between 32-bit and 64-bit PowerPC targets
llvm::PPCTargetStreamer
llvm::PPCTTIImpl
llvm::MachO::prebind_cksum_command
llvm::MachO::prebound_dylib_command
Predicate
llvm::PredIterator< Ptr, USE_iterator >
llvm::PredIteratorCachePredIteratorCache - This class is an extremely trivial cache for predecessor iterator queries
llvm::PreservedAnalysesAn abstract set of preserved analyses following a transformation pass run
llvm::PressureChangeCapture a change in pressure for a single pressure set
llvm::PressureDiffList of PressureChanges in order of increasing, unique PSetID
llvm::PressureDiffsArray of PressureDiffs
llvm::PrettyStackTraceEntryPrettyStackTraceEntry - This class is used to represent a frame of the "pretty" stack trace that is dumped when a program crashes
llvm::PrettyStackTraceProgramPrettyStackTraceProgram - This object prints a specified program arguments to the stream as the stack trace when a crash occurs
llvm::PrettyStackTraceStringPrettyStackTraceString - This object prints a specified string (which should not contain newlines) to the stream as the stack trace when a crash occurs
llvm::AArch64PRFM::PRFMMapper
llvm::PrintFunctionPassPass for printing a Function as LLVM's text IR assembly
llvm::PrintModulePassPass for printing a Module as LLVM's text IR assembly
llvm::PrintRegPrintReg - Helper class for printing registers on a raw_ostream
llvm::PrintRegUnitPrintRegUnit - Helper class for printing register units on a raw_ostream
llvm::PrintVRegOrUnitPrintVRegOrUnit - It is often convenient to track virtual registers and physical register units in the same list
priority_queue
llvm::PriorityQueue< T, Sequence, Compare >PriorityQueue - This class behaves like std::priority_queue and provides a few additional convenience functions
llvm::sys::ProcessA collection of legacy interfaces for querying information about the current executing process
llvm::sys::ProcessInfoThis struct encapsulates information about a process
llvm::coverage::BinaryCoverageReader::ProfileMappingRecord
llvm::DWARFDebugLine::Prologue
llvm::objcarc::ProvenanceAnalysisThis is similar to BasicAliasAnalysis, and it uses many of the same techniques, except it uses special ObjC-specific reasoning about pointer relationships
llvm::PSetIteratorIterate over the pressure sets affected by the given physical or virtual register
llvm::PseudoSourceValuePseudoSourceValue - Special value supplied for machine level alias analysis
llvm::AArch64PState::PStateMapper
llvm::detail::PtrUseVisitorBase::PtrInfoThis class provides information about the result of a visit
llvm::objcarc::PtrStateThis class summarizes several per-pointer runtime properties which are propogated through the flow graph
llvm::PtrToIntInstThis class represents a cast from a pointer to an integer
llvm::PtrToIntOperator
llvm::PtrUseVisitor< DerivedT >A base class for visitors over the uses of a pointer value
llvm::detail::PtrUseVisitorBaseImplementation of non-dependent functionality for PtrUseVisitor
llvm::dwarf::PubIndexEntryDescriptorDecsribes an entry of the various gnu_pub* debug sections
llvm::LiveIntervalUnion::QueryQuery interferences between a single live virtual register and a live interval union
llvm::R600InstrInfo
llvm::R600MachineFunctionInfo
llvm::R600RegisterInfo
llvm::R600SchedStrategy
llvm::R600TargetLowering
llvm::R600TargetMachine
llvm::RandomNumberGeneratorA random number generator
llvm::DWARFDebugRangeList::RangeListEntry
llvm::RangeSpan
llvm::RangeSpanList
llvm::raw_fd_ostreamA raw_ostream that writes to a file descriptor
llvm::raw_null_ostreamA raw_ostream that discards all output
llvm::raw_os_ostreamRaw_os_ostream - A raw_ostream that writes to an std::ostream
llvm::raw_ostreamThis class implements an extremely fast bulk output stream that can *only* output to a stream
llvm::raw_pwrite_streamAn abstract base class for streams implementations that also support a pwrite operation
llvm::raw_string_ostreamA raw_ostream that writes to an std::string
llvm::raw_svector_ostreamA raw_ostream that writes to an SmallVector or SmallString
llvm::ELFYAML::RawContentSection
llvm::coverage::RawCoverageFilenamesReaderReader for the raw coverage filenames
llvm::coverage::RawCoverageMappingReaderReader for the raw coverage mapping data
llvm::coverage::RawCoverageReaderBase class for the raw coverage mapping and filenames data readers
llvm::RawInstrProfReader< IntPtrT >Reader for the raw instrprof binary format from runtime
re_guts
llvm::ReadyQueueHelpers for implementing custom MachineSchedStrategy classes
llvm::sys::fs::detail::RecDirIterStateRecDirIterState - Keeps state for the recursive_directory_iterator
llvm::Record
llvm::RecordKeeper
llvm::LessRecordRegister::RecordParts
llvm::RecordRecTyRecordRecTy - '[classname]' - Represent an instance of a class, such as: (R32 X = EAX)
llvm::RecordStreamer
llvm::RecordVal
llvm::RecTy
llvm::RecurrenceDescriptorThe RecurrenceDescriptor is used to identify recurrences variables in a loop
llvm::sys::fs::recursive_directory_iteratorRecursive_directory_iterator - Same as directory_iterator except for it recurses down into child directories
llvm::Recycler< T, Size, Align >Recycler - This class manages a linked-list of deallocated nodes and facilitates reusing deallocated memory in place of allocating new memory
llvm::RecyclerStructRecyclerStruct - Implementation detail for Recycler
llvm::RecyclingAllocator< AllocatorType, T, Size, Align >RecyclingAllocator - This class wraps an Allocator, adding the functionality of recycling deleted objects
llvm::support::detail::packed_endian_specific_integral< value_type, endian, alignment >::ref
llvm::RefCountedBase< Derived >RefCountedBase - A generic base class for objects that wish to have their lifetimes managed using reference counts
llvm::RefCountedBaseVPTRRefCountedBaseVPTR - A class that has the same function as RefCountedBase, but with a virtual destructor
llvm::PackedVector< T, BitNum, BitVectorTy >::reference
llvm::BitVector::reference
llvm::SmallBitVector::reference
llvm::ReferenceStorage< T >Stores a reference that can be changed
llvm::RegAllocBaseRegAllocBase provides the register allocation driver and interface that can be extended to add interesting heuristics
llvm::PBQP::RegAlloc::RegAllocSolverImpl
llvm::RegClassWeightEach TargetRegisterClass has a per register weight, and weight limit which must be less than the limits of its pressure sets
llvm::ScheduleDAGSDNodes::RegDefIterRegDefIter - In place iteration over the values defined by an SUnit
llvm::Regex
Region
llvm::Region
llvm::RegionBase< Tr >A single entry single exit Region
llvm::RegionInfo
llvm::RegionInfoBase< Tr >Analysis that detects all canonical Regions
llvm::RegionInfoPass
llvm::RegionNode
llvm::RegionNodeBase< Tr >A RegionNode represents a subregion or a BasicBlock that is part of a Region
llvm::RegionPassA pass that runs on each Region in a function
llvm::RegionPressureRegisterPressure computed within a region of instructions delimited by TopPos and BottomPos
llvm::RegionTraits< FuncT_ >
llvm::RegionTraits< Function >
llvm::RegionTraits< MachineFunction >
llvm::RegisterAGBaseRegisterAnalysisGroup - Register a Pass as a member of an analysis _group_
llvm::RegisterAnalysisGroup< Interface, Default >
llvm::RegisterAsmPrinter< AsmPrinterImpl >RegisterAsmPrinter - Helper template for registering a target specific assembly printer, for use in the target machine initialization function
llvm::RegisterClassInfo
llvm::RegisterMaskSDNode
llvm::RegisterMCAsmBackend< MCAsmBackendImpl >RegisterMCAsmBackend - Helper template for registering a target specific assembler backend
llvm::RegisterMCAsmInfo< MCAsmInfoImpl >RegisterMCAsmInfo - Helper template for registering a target assembly info implementation
llvm::RegisterMCAsmInfoFnRegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation
llvm::RegisterMCAsmParser< MCAsmParserImpl >RegisterMCAsmParser - Helper template for registering a target specific assembly parser, for use in the target machine initialization function
llvm::RegisterMCCodeEmitter< MCCodeEmitterImpl >RegisterMCCodeEmitter - Helper template for registering a target specific machine code emitter, for use in the target initialization function
llvm::RegisterMCCodeGenInfo< MCCodeGenInfoImpl >RegisterMCCodeGenInfo - Helper template for registering a target codegen info implementation
llvm::RegisterMCCodeGenInfoFnRegisterMCCodeGenInfoFn - Helper template for registering a target codegen info implementation
llvm::RegisterMCInstrAnalysis< MCInstrAnalysisImpl >RegisterMCInstrAnalysis - Helper template for registering a target instruction analyzer implementation
llvm::RegisterMCInstrAnalysisFnRegisterMCInstrAnalysisFn - Helper template for registering a target instruction analyzer implementation
llvm::RegisterMCInstrInfo< MCInstrInfoImpl >RegisterMCInstrInfo - Helper template for registering a target instruction info implementation
llvm::RegisterMCInstrInfoFnRegisterMCInstrInfoFn - Helper template for registering a target instruction info implementation
llvm::RegisterMCRegInfo< MCRegisterInfoImpl >RegisterMCRegInfo - Helper template for registering a target register info implementation
llvm::RegisterMCRegInfoFnRegisterMCRegInfoFn - Helper template for registering a target register info implementation
llvm::RegisterMCSubtargetInfo< MCSubtargetInfoImpl >RegisterMCSubtargetInfo - Helper template for registering a target subtarget info implementation
llvm::RegisterMCSubtargetInfoFnRegisterMCSubtargetInfoFn - Helper template for registering a target subtarget info implementation
llvm::RegisterPass< passName >RegisterPass<t> template - This template class is used to notify the system that a Pass is available for use, and registers it into the internal database maintained by the PassManager
llvm::RegisterPassParser< RegistryClass >RegisterPassParser class - Handle the addition of new machine passes
llvm::RegisterPressureBase class for register pressure results
llvm::AggressiveAntiDepState::RegisterReferenceInformation about a register reference within a liverange
llvm::RegisterRegAllocRegisterRegAlloc class - Track the registration of register allocators
llvm::RegisterScheduler
llvm::RegisterSDNode
llvm::RegisterStandardPassesRegisters a function for adding a standard set of passes
llvm::RegisterTarget< TargetArchType, HasJIT >RegisterTarget - Helper template for registering a target, for use in the target's initialization function
llvm::RegisterTargetMachine< TargetMachineImpl >RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function
llvm::Registry< T, U >A global registry used in conjunction with static constructors to make pluggable components (like targets or garbage collectors) "just work" when linked with an executable
llvm::RegistryParser< T, U >A command-line parser for a registry
llvm::RegistryTraits< T >Traits for registry entries
llvm::X86Operand::RegOp
llvm::RegPressureDeltaStore the effects of a change in pressure on things that MI scheduler cares about
llvm::RegPressureTrackerTrack the current register pressure at some position in the instruction stream, and remember the high water mark within the region traversed
llvm::RegScavenger
llvm::RegsForValueRegsForValue - This struct represents the registers (physical or virtual) that a particular set of values is assigned, and the type information about the value
llvm::TargetInstrInfo::RegSubRegPairA pair composed of a register and a sub-register index
llvm::TargetInstrInfo::RegSubRegPairAndIdxA pair composed of a pair of a register and a sub-register index, and another sub-register index
llvm::COFFYAML::Relocation
llvm::ELFYAML::Relocation
llvm::COFF::relocation
llvm::MachO::relocation_info
llvm::RelocationEntryRelocationEntry - used to represent relocations internally in the dynamic linker
llvm::object::RelocationRefThis is a value type class that represents a single relocation in the list of relocations in the object file
llvm::ELFYAML::RelocationSection
llvm::RelocationValueRef
llvm::object::RelocToApply
llvm::object::RelocVisitorBase class for object file relocation visitors
llvm::LiveRangeEdit::RematRemat - Information needed to rematerialize at a specific location
llvm::ReplaceableMetadataImplShared implementation of use-lists for replaceable metadata
llvm::RequireAnalysisPass< AnalysisT >A template utility pass to force an analysis result to be available
rerr
llvm::resource_sortSorting functions for the Available queue
llvm::ResourcePriorityQueue
llvm::CGSCCAnalysisManagerModuleProxy::Result
llvm::ModuleAnalysisManagerCGSCCProxy::ResultResult proxy object for ModuleAnalysisManagerCGSCCProxy
llvm::FunctionAnalysisManagerCGSCCProxy::Result
llvm::CGSCCAnalysisManagerFunctionProxy::ResultResult proxy object for ModuleAnalysisManagerFunctionProxy
llvm::FunctionAnalysisManagerModuleProxy::ResultThe result proxy object for the FunctionAnalysisManagerModuleProxy
llvm::ModuleAnalysisManagerFunctionProxy::ResultResult proxy object for ModuleAnalysisManagerFunctionProxy
llvm::detail::ResultHasInvalidateMethod< IRUnitT, ResultT >SFINAE metafunction for computing whether ResultT provides an invalidate member function
llvm::ResumeInstResumeInst - Resume the propagation of an exception
llvm::ReturnInstReturnInst - Return a value (possibly void), from a function
llvm::sys::path::reverse_iteratorReverse path iterator
llvm::ReversePostOrderTraversal< GraphT, GT >
llvm::SymbolRewriter::RewriteDescriptorThe basic entity representing a rewrite operation
llvm::SymbolRewriter::RewriteMapParser
llvm::RGPassManagerThe pass manager to schedule RegionPasses
llvm::RNSuccIterator< NodeType, BlockT, RegionT >Hierarchical RegionNode successor iterator
llvm::RNSuccIterator< FlatIt< NodeType >, BlockT, RegionT >Flat RegionNode iterator
llvm::RoundUpToPowerOfTwo< N >
llvm::RoundUpToPowerOfTwoH< N, isPowerTwo >RoundUpToPowerOfTwoH - If N is not a power of two, increase it
llvm::RoundUpToPowerOfTwoH< N, false >
llvm::MachO::routines_command
llvm::MachO::routines_command_64
llvm::DWARFDebugLine::Row
llvm::MachO::rpath_command
llvm::objcarc::RRInfoUnidirectional information about either a retain-decrement-use-release sequence or release-use-decrement-retain reverse sequence
llvm::RTDyldMemoryManager
llvm::RuntimeDyld
llvm::RuntimeDyldCheckerRuntimeDyld invariant checker for verifying that RuntimeDyld has correctly applied relocations
llvm::RuntimeDyldCheckerExprEval
llvm::RuntimeDyldCheckerImpl
llvm::RuntimeDyldCOFF
llvm::RuntimeDyldCOFFX86_64
llvm::RuntimeDyldELF
llvm::RuntimeDyldImpl
llvm::RuntimeDyldMachO
llvm::RuntimeDyldMachOAArch64
llvm::RuntimeDyldMachOARM
llvm::RuntimeDyldMachOCRTPBase< Impl >RuntimeDyldMachOTarget - Templated base class for generic MachO linker algorithms and data structures
llvm::RuntimeDyldMachOI386
llvm::RuntimeDyldMachOX86_64
llvm::Win64EH::RuntimeFunctionRuntimeFunction - An entry in the table of functions with unwind info
llvm::ARM::WinEH::RuntimeFunctionRuntimeFunction - An entry in the table of procedure data (.pdata)
llvm::LoopAccessInfo::RuntimePointerCheckThis struct holds information about the memory runtime legality check that a group of pointers do not overlap
llvm::sys::RWMutexImplPlatform agnostic RWMutex class
llvm::sampleprof::SampleProfileReaderSample-based profile reader
llvm::sampleprof::SampleProfileReaderBinary
llvm::sampleprof::SampleProfileReaderText
llvm::sampleprof::SampleProfileWriterSample-based profile writer. Base class
llvm::sampleprof::SampleProfileWriterBinarySample-based profile writer (binary format)
llvm::sampleprof::SampleProfileWriterTextSample-based profile writer (text format)
llvm::sampleprof::SampleRecordRepresentation of a single sample record
llvm::SanitizerCoverageOptions
llvm::SaveAndRestore< T >A utility class that uses RAII to save and restore the value of a variable
llvm::SaveOrSimilar to SaveAndRestore
llvm::FastISel::SavePoint
llvm::yaml::ScalarBitSetTraits< T >This class should be specialized by any integer type that is a union of bit values and the YAML representation is a flow sequence of strings
llvm::yaml::ScalarBitSetTraits< COFF::Characteristics >
llvm::yaml::ScalarBitSetTraits< COFF::DLLCharacteristics >
llvm::yaml::ScalarBitSetTraits< COFF::SectionCharacteristics >
llvm::yaml::ScalarBitSetTraits< ELFYAML::ELF_EF >
llvm::yaml::ScalarBitSetTraits< ELFYAML::ELF_SHF >
llvm::yaml::ScalarBitSetTraits< ELFYAML::ELF_STO >
llvm::yaml::ScalarBitSetTraits< ELFYAML::MIPS_AFL_ASE >
llvm::yaml::ScalarBitSetTraits< ELFYAML::MIPS_AFL_FLAGS1 >
llvm::yaml::ScalarEnumerationTraits< T >This class should be specialized by any integral type that converts to/from a YAML scalar where there is a one-to-one mapping between in-memory values and a string in YAML
llvm::yaml::ScalarEnumerationTraits< COFF::MachineTypes >
llvm::yaml::ScalarEnumerationTraits< COFF::RelocationTypeAMD64 >
llvm::yaml::ScalarEnumerationTraits< COFF::RelocationTypeI386 >
llvm::yaml::ScalarEnumerationTraits< COFF::SymbolBaseType >
llvm::yaml::ScalarEnumerationTraits< COFF::SymbolComplexType >
llvm::yaml::ScalarEnumerationTraits< COFF::SymbolStorageClass >
llvm::yaml::ScalarEnumerationTraits< COFF::WindowsSubsystem >
llvm::yaml::ScalarEnumerationTraits< COFFYAML::AuxSymbolType >
llvm::yaml::ScalarEnumerationTraits< COFFYAML::COMDATType >
llvm::yaml::ScalarEnumerationTraits< COFFYAML::WeakExternalCharacteristics >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_ELFCLASS >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_ELFDATA >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_ELFOSABI >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_EM >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_ET >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_REL >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_RSS >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_SHT >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_STT >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::ELF_STV >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::MIPS_ABI_FP >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::MIPS_AFL_EXT >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::MIPS_AFL_REG >
llvm::yaml::ScalarEnumerationTraits< ELFYAML::MIPS_ISA >
llvm::ScalarEvolutionScalarEvolution - This class is the main scalar evolution driver
llvm::yaml::ScalarTraits< T >This class should be specialized by type that requires custom conversion to/from a yaml scalar
llvm::yaml::ScalarTraits< BinaryRef >
llvm::yaml::ScalarTraits< bool >
llvm::yaml::ScalarTraits< double >
llvm::yaml::ScalarTraits< float >
llvm::yaml::ScalarTraits< Hex16 >
llvm::yaml::ScalarTraits< Hex32 >
llvm::yaml::ScalarTraits< Hex64 >
llvm::yaml::ScalarTraits< Hex8 >Use these types instead of uintXX_t in any mapping to have its yaml output formatted as hexadecimal
llvm::yaml::ScalarTraits< int16_t >
llvm::yaml::ScalarTraits< int32_t >
llvm::yaml::ScalarTraits< int64_t >
llvm::yaml::ScalarTraits< int8_t >
llvm::yaml::ScalarTraits< std::string >
llvm::yaml::ScalarTraits< StringRef >
llvm::yaml::ScalarTraits< StringValue >
llvm::yaml::ScalarTraits< uint16_t >
llvm::yaml::ScalarTraits< uint32_t >
llvm::yaml::ScalarTraits< uint64_t >
llvm::yaml::ScalarTraits< uint8_t >
llvm::ScaledNumber< DigitsT >Simple representation of a scaled number
llvm::ScaledNumberBase
llvm::yaml::ScannerScans YAML tokens from a MemoryBuffer
llvm::MachO::scattered_relocation_info
llvm::LazyCallGraph::SCCAn SCC of the call graph
llvm::scc_iterator< GraphT, GT >Enumerate the SCCs of a directed graph in reverse topological order of the SCC DAG
llvm::SCEVSCEV - This class represents an analyzed expression in the program
llvm::SCEVAddExprSCEVAddExpr - This node represents an addition of some number of SCEVs
llvm::SCEVAddRecExprSCEVAddRecExpr - This node represents a polynomial recurrence on the trip count of the specified loop
llvm::SCEVApplyRewriterThe SCEVApplyRewriter takes a scalar evolution expression and applies the Map (Loop -> SCEV) to all AddRecExprs
llvm::SCEVCastExprSCEVCastExpr - This is the base class for unary cast operator classes
llvm::SCEVCommutativeExprSCEVCommutativeExpr - This node is the base class for n'ary commutative operators
llvm::SCEVConstantSCEVConstant - This class represents a constant integer value
llvm::SCEVCouldNotComputeSCEVCouldNotCompute - An object of this class is returned by queries that could not be answered
llvm::SCEVExpanderThis class uses information about analyze scalars to rewrite expressions in canonical form
llvm::SCEVMulExprSCEVMulExpr - This node represents multiplication of some number of SCEVs
llvm::SCEVNAryExprSCEVNAryExpr - This node is a base class providing common functionality for n'ary operators
llvm::SCEVParameterRewriterThe SCEVParameterRewriter takes a scalar evolution expression and updates the SCEVUnknown components following the Map (Value -> Value)
llvm::SCEVSignExtendExprSCEVSignExtendExpr - This class represents a sign extension of a small integer value to a larger integer value
llvm::SCEVSMaxExprSCEVSMaxExpr - This class represents a signed maximum selection
llvm::SCEVTraversal< SV >Visit all nodes in the expression tree using worklist traversal
llvm::SCEVTruncateExprSCEVTruncateExpr - This class represents a truncation of an integer value to a smaller integer value
llvm::SCEVUDivExprSCEVUDivExpr - This class represents a binary unsigned division operation
llvm::SCEVUMaxExprSCEVUMaxExpr - This class represents an unsigned maximum selection
llvm::SCEVUnknownSCEVUnknown - This means that we are dealing with an entirely unknown SCEV value, and only represent it as its LLVM Value
llvm::SCEVVisitor< SC, RetVal >SCEVVisitor - This class defines a simple visitor class that may be used for various SCEV analysis purposes
llvm::SCEVZeroExtendExprSCEVZeroExtendExpr - This class represents a zero extension of a small integer value to a larger integer value
llvm::SchedBoundaryEach Scheduling boundary is associated with ready queues
llvm::GenericSchedulerBase::SchedCandidateStore the state used by GenericScheduler heuristics, required for the lifetime of one invocation of pickNode()
llvm::SchedDFSImplInternal state used to compute SchedDFSResult
llvm::SchedDFSResultCompute the values of each DAG node for various metrics during DFS
llvm::SchedRemainderSummarize the unscheduled region
llvm::GenericSchedulerBase::SchedResourceDeltaStatus of an instruction's critical resource consumption
llvm::ScheduleDAG
llvm::ScheduleDAGInstrsScheduleDAGInstrs - A ScheduleDAG subclass for scheduling lists of MachineInstrs
llvm::ScheduleDAGMIScheduleDAGMI is an implementation of ScheduleDAGInstrs that simply schedules machine instructions according to the given MachineSchedStrategy without much extra book-keeping
llvm::ScheduleDAGMILiveScheduleDAGMILive is an implementation of ScheduleDAGInstrs that schedules machine instructions while updating LiveIntervals and tracking regpressure
llvm::ScheduleDAGMutationMutate the DAG as a postpass after normal DAG building
llvm::ScheduleDAGSDNodesScheduleDAGSDNodes - A ScheduleDAG for scheduling SDNode-based DAGs
llvm::ScheduleDAGTopologicalSortScheduleDAGTopologicalSort is a class that computes a topological ordering for SUnits and provides methods for dynamically updating the ordering as new edges are added
llvm::ScheduleHazardRecognizerHazardRecognizer - This determines whether or not an instruction can be issued this cycle, and whether or not a noop needs to be inserted to handle the hazard
llvm::SchedulingPriorityQueueSchedulingPriorityQueue - This interface is used to plug different priorities computation algorithms into the list scheduler
llvm::ScopedFatalErrorHandlerScopedFatalErrorHandler - This is a simple helper class which just calls install_fatal_error_handler in its constructor and remove_fatal_error_handler in its destructor
ScopedHandle< HandleTraits >
llvm::ScopedHashTable< K, V, KInfo, AllocatorTy >
llvm::ScopedHashTableIterator< K, V, KInfo >
llvm::ScopedHashTableScope< K, V, KInfo, AllocatorTy >
llvm::ScopedHashTableVal< K, V >
llvm::ScoreboardHazardRecognizer
llvm::SDDbgInfoKeeps track of dbg_value information through SDISel
llvm::SDDbgValueSDDbgValue - Holds the information from a dbg_value node through SDISel
llvm::SDepSDep - Scheduling dependency
llvm::SDivOperator
llvm::SDLocWrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation functions
llvm::SDNodeRepresents one node in the SelectionDAG
llvm::SDNodeFlagsThese are IR-level optimization flags that may be propagated to SDNodes
llvm::SDNodeIterator
llvm::SDUseRepresents a use of a SDNode
llvm::SDValueUnlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation
llvm::SDVTListThis represents a list of ValueType's that has been intern'd by a SelectionDAG
llvm::SDVTListNode
llvm::COFFYAML::Section
llvm::ELFYAML::Section
llvm::COFF::section
llvm::MachO::section
llvm::MachO::section_64
llvm::SectionEntrySectionEntry - represents a section emitted into memory by the dynamic linker
llvm::SectionKindSectionKind - This is a simple POD value that classifies the properties of a section
llvm::SectionMemoryManagerThis is a simple memory manager which implements the methods called by the RuntimeDyld class to allocate memory for section-based loading of objects, usually those generated by the MCJIT execution engine
llvm::RuntimeDyldMachO::SectionOffsetPair
llvm::ELFYAML::SectionOrType
llvm::RelocationEntry::SectionPair
llvm::object::SectionRefThis is a value type class that represents a single section in the list of sections in the object file
llvm::LiveRange::SegmentThis represents a simple continuous liveness interval for a value
llvm::MachO::segment_command
llvm::MachO::segment_command_64
llvm::SEHHandler
llvm::PatternMatch::SelectClass_match< Cond_t, LHS_t, RHS_t >
llvm::SelectConstantExprSelectConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement select constant exprs
llvm::SelectInstSelectInst - This class represents the LLVM 'select' instruction
llvm::SelectionDAGThis is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representation suitable for instruction selection
llvm::SelectionDAGBuilderSelectionDAGBuilder - This is the common target-independent lowering implementation that is parameterized by a TargetLowering object
llvm::SelectionDAGISelSelectionDAGISel - This is the common base class used for SelectionDAG-based pattern-matching instruction selectors
llvm::DWARFDebugLine::Sequence
llvm::yaml::SequenceTraits< T >This class should be specialized by any type that needs to be converted to/from a YAML sequence
llvm::SequentialTypeSequentialType - This is the superclass of the array, pointer and vector type classes
SetCCInfoHelper structure to keep track of SetCC information
SetCCInfoAndKindHelper structure to be able to read SetCC information
llvm::SetTheory
llvm::SetVector< T, Vector, Set >A vector that has set insertion semantics
llvm::SExtInstThis class represents a sign extension of integer types
llvm::mdconst::detail::HasDereference< T, Result >::SFINAE< N >
llvm::MDNode::HasCachedHash< NodeTy >::SFINAE< U, Val >
llvm::ShlOperator
llvm::ShuffleVectorConstantExprShuffleVectorConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement shufflevector constant exprs
llvm::ShuffleVectorInstShuffleVectorInst - This instruction constructs a fixed permutation of two input vectors
llvm::ShuffleVectorSDNodeThis SDNode is used to implement the code generator support for the llvm IR shufflevector instruction
llvm::SIInstrInfo
llvm::SIMachineFunctionInfoThis class keeps track of the SPI_SP_INPUT_ADDR config register, which tells the hardware which interpolation parameters to load
llvm::orc::SimpleCompilerSimple compile functor: Takes a single IR module and returns an ObjectFile
llvm::SimpleRegistryEntry< T >A simple registry entry which provides only a name, description, and no-argument constructor
fuzzer::SimpleUserSuppliedFuzzer
llvm::simplify_type< From >
llvm::simplify_type< const From >
llvm::simplify_type< const ilist_iterator< NodeTy > >
llvm::simplify_type< const IntrusiveRefCntPtr< T > >
llvm::simplify_type< const MDOperand >
llvm::simplify_type< const SDValue >
llvm::simplify_type< const TrackingMDRef >
llvm::simplify_type< const TypedDINodeRef< T > >
llvm::simplify_type< const TypedTrackingMDRef< T > >
llvm::simplify_type< const Use >
llvm::simplify_type< ilist_iterator< NodeTy > >
llvm::simplify_type< IntrusiveRefCntPtr< T > >
llvm::simplify_type< MDOperand >
llvm::simplify_type< SDUse >Simplify_type specializations - Allow casting operators to work directly on SDValues as if they were SDNode*'s
llvm::simplify_type< SDValue >Allow casting operators to work directly on SDValues as if they were SDNode*'s
llvm::simplify_type< TrackingMDRef >
llvm::simplify_type< TypedDINodeRef< T > >
llvm::simplify_type< TypedTrackingMDRef< T > >
llvm::simplify_type< Use >Allow clients to treat uses just like values when using casting operators
llvm::simplify_type< User::const_op_iterator >
llvm::simplify_type< User::op_iterator >
llvm::simplify_type< WeakVH >
llvm::SimplifyCFGPassA pass to simplify and canonicalize the CFG of a function
llvm::LiveInterval::SingleLinkedListIterator< T >
false::SingleLoopExtractorSingleLoopExtractor - For bugpoint
llvm::SIRegisterInfo
llvm::SITargetLowering
llvm::SIToFPInstThis class represents a cast from signed integer to floating point
llvm::detail::SizerImpl< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >
AllocaSlices::SliceBuilderBuilder for the alloca slices
llvm::SlotIndexSlotIndex - An opaque wrapper around machine indexes
llvm::SlotIndexesSlotIndexes pass
llvm::SlotMappingThis struct contains the mapping from the slot numbers to unnamed metadata nodes and global values
llvm::SmallBitVectorSmallBitVector - This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is small
llvm::SmallDenseMap< KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT >
llvm::SmallMapVector< KeyT, ValueT, N >A MapVector that performs no allocations if smaller than a certain size
llvm::SmallPtrSet< PtrType, SmallSize >SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements
llvm::SmallPtrSetImpl< PtrType >A templated base class for SmallPtrSet which provides the typesafe interface that is common across all small sizes
llvm::SmallPtrSetImplBaseSmallPtrSetImplBase - This is the common code shared among all the SmallPtrSet<>'s, which is almost everything
llvm::SmallPtrSetIterator< PtrTy >SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet
llvm::SmallPtrSetIteratorImplSmallPtrSetIteratorImpl - This is the common base class shared between all instances of SmallPtrSetIterator
llvm::SmallSet< T, N, C >SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less than N)
llvm::SmallSet< PointeeType *, N >If this set is of pointer values, transparently switch over to using SmallPtrSet for performance
llvm::SmallSetVector< T, N >A SetVector that performs no allocations if smaller than a certain size
llvm::SmallString< InternalLen >SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better as a string (e.g
llvm::SmallVector< T, N >This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small
llvm::SmallVectorBaseThis is all the non-templated stuff common to all SmallVectors
llvm::SmallVectorImpl< T >This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter
llvm::SmallVectorStorage< T, N >Storage for the SmallVector elements which aren't contained in SmallVectorTemplateCommon
llvm::SmallVectorStorage< T, 0 >
llvm::SmallVectorStorage< T, 1 >
llvm::SmallVectorTemplateBase< T, isPodLike >SmallVectorTemplateBase<isPodLike = false> - This is where we put method implementations that are designed to work with non-POD-like T's
llvm::SmallVectorTemplateBase< T, true >SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's
llvm::SmallVectorTemplateCommon< T, typename >This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD
llvm::sys::SmartMutex< mt_only >SmartMutex - A mutex with a compile time constant parameter that indicates whether this mutex should become a no-op when we're not running in multithreaded mode
llvm::sys::SmartRWMutex< mt_only >SmartMutex - An R/W mutex with a compile time constant parameter that indicates whether this mutex should become a no-op when we're not running in multithreaded mode
llvm::sys::SmartScopedLock< mt_only >
llvm::sys::SmartScopedReader< mt_only >ScopedReader - RAII acquisition of a reader lock
llvm::sys::SmartScopedWriter< mt_only >ScopedWriter - RAII acquisition of a writer lock
llvm::PatternMatch::smax_pred_tyHelper class for identifying signed max predicates
llvm::SMDiagnosticInstances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a caret diagnostic
llvm::SMFixItRepresents a single fixit, a replacement of one range of text with another
llvm::PatternMatch::smin_pred_tyHelper class for identifying signed min predicates
llvm::SMLocRepresents a location in source code
llvm::SMRangeRepresents a range in source code
llvm::PBQP::SolutionRepresents a solution to a PBQP problem
llvm::MachO::source_version_command
llvm::SourceMgrThis owns the files read by a parser, handles include stacks, and handles diagnostic wrangling
llvm::sys::fs::space_infoSpace_info - Self explanatory
llvm::SparcELFMCAsmInfo
llvm::SparcELFTargetObjectFile
llvm::SparcelTargetMachine
llvm::SparcFrameLowering
SparcGenInstrInfo
SparcGenRegisterInfo
SparcGenSubtargetInfo
llvm::SparcInstPrinter
llvm::SparcInstrInfo
llvm::SparcMachineFunctionInfo
llvm::SparcMCExpr
llvm::SparcRegisterInfo
llvm::SparcSelectionDAGInfo
llvm::SparcSubtarget
llvm::SparcTargetAsmStreamer
llvm::SparcTargetELFStreamer
llvm::SparcTargetLowering
llvm::SparcTargetMachine
llvm::SparcTargetStreamer
llvm::SparcV8TargetMachineSparcV8TargetMachine - Sparc 32-bit target machine
llvm::SparcV9TargetMachineSparcV9TargetMachine - Sparc 64-bit target machine
llvm::SparseBitVector< ElementSize >
llvm::SparseBitVectorElement< ElementSize >SparseBitVector is an implementation of a bitvector that is sparse by only storing the elements that have non-zero bits set
llvm::SparseMultiSet< ValueT, KeyFunctorT, SparseT >Fast multiset implementation for objects that can be identified by small unsigned keys
llvm::SparseSet< ValueT, KeyFunctorT, SparseT >SparseSet - Fast set implmentation for objects that can be identified by small unsigned keys
llvm::SparseSetValFunctor< KeyT, ValueT, KeyFunctorT >SparseSetValFunctor - Helper class for selecting SparseSetValTraits
llvm::SparseSetValFunctor< KeyT, KeyT, KeyFunctorT >SparseSetValFunctor<KeyT, KeyT> - Helper class for the common case of identity key/value sets
llvm::SparseSetValTraits< ValueT >SparseSetValTraits - Objects in a SparseSet are identified by keys that can be uniquely converted to a small integer less than the set's universe
llvm::SparseSolverSparseSolver - This class is a general purpose solver for Sparse Conditional Propagation with a programmable lattice function
llvm::SpecialCaseList
llvm::PatternMatch::specific_fpvalMatch a specified floating point value or vector of all elements of that value
llvm::PatternMatch::specific_intvalMatch a specified integer value or vector of all elements of that
llvm::SpecificBumpPtrAllocator< T >A BumpPtrAllocator that allows only elements of a specific type to be allocated
llvm::PatternMatch::specificval_tyMatch a specified Value*
llvm::SIMachineFunctionInfo::SpilledReg
llvm::SpillerSpiller interface
llvm::SpillPlacement
llvm::TargetFrameLowering::SpillSlot
llvm::SplitAnalysisSplitAnalysis - Analyze a LiveInterval, looking for live range splitting opportunities
llvm::SplitEditorSplitEditor - Edit machine code and LiveIntervals for live range splitting
llvm::SrcLineInfoThis class is used to record source line correspondence
llvm::SrcValueSDNodeAn SDNode that holds an arbitrary LLVM IR Value
llvm::SSAUpdaterHelper class for SSA formation on a set of values defined in multiple blocks
llvm::SSAUpdaterImpl< UpdaterT >
llvm::SSAUpdaterTraits< MachineSSAUpdater >
llvm::SSAUpdaterTraits< SSAUpdater >
llvm::StackMaps
llvm::StackProtector
llvm::StatepointA specialization of it's base class for read-write access to a gc.statepoint
llvm::StatepointBase< InstructionTy, ValueTy, CallSiteTy >Analogous to CallSiteBase, this provides most of the actual functionality for Statepoint and ImmutableStatepoint
llvm::StatepointLoweringStateThis class tracks both per-statepoint and per-selectiondag information
llvm::StatepointOpersMI-level Statepoint operands
llvm::Statistic
llvm::StoreInstStoreInst - an instruction for storing to memory
llvm::StoreSDNodeThis class is used to represent ISD::STORE nodes
llvm::StratifiedInfo
llvm::StratifiedLink
llvm::StratifiedSets< T >
llvm::StratifiedSetsBuilder< T >
llvm::yaml::StreamThis class represents a YAML stream potentially containing multiple documents
llvm::StreamingMemoryObjectInterface to data which is actually streamed from a DataStreamer
llvm::StringAttributeImpl
llvm::StringInitStringInit - "foo" - Represent an initialization by a string value
llvm::StringMap< ValueTy, AllocatorTy >StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes
llvm::StringMapConstIterator< ValueTy >
llvm::StringMapEntry< ValueTy >StringMapEntry - This is used to represent one value that is inserted into a StringMap
llvm::StringMapEntryBaseStringMapEntryBase - Shared base class of StringMapEntry instances
llvm::StringMapImplStringMapImpl - This is the base class of StringMap that is shared among all of its instantiations
llvm::StringMapIterator< ValueTy >
llvm::StringMatcherStringMatcher - Given a list of strings and code to execute when they match, output a simple switch tree to classify the input string
llvm::StringPoolStringPool - An interned string pool
llvm::StringRecTyStringRecTy - 'string' - Represent an string value
llvm::StringRefStringRef - Represent a constant reference to a string, i.e
llvm::StringSaverSaves strings in the inheritor's stable storage and returns a stable raw character pointer
llvm::StringSet< AllocatorTy >StringSet - A wrapper for StringMap that provides set-like functionality
llvm::StringSwitch< T, R >A switch()-like statement whose cases are string literals
llvm::StringTableBuilderUtility for building string tables with deduplicated suffixes
llvm::object::StringTableOffset
llvm::StringToOffsetTableStringToOffsetTable - This class uniques a bunch of nul-terminated strings and keeps track of their offset in a massive contiguous string allocation
llvm::yaml::StringValueA wrapper around std::string which contains a source range that's being set during parsing
llvm::StructLayoutUsed to lazily calculate structure layout information for a target machine, based on the DataLayout structure
llvm::StructTypeStructType - Class to represent struct types
llvm::Linker::StructTypeKeyInfo
llvm::MachO::sub_client_command
llvm::MachO::sub_framework_command
llvm::MachO::sub_library_command
llvm::MachO::sub_umbrella_command
llvm::SubClassReference
llvm::InlineAsm::SubConstraintInfo
llvm::SubMultiClassReference
llvm::SubOperator
llvm::LiveInterval::SubRangeA live range for subregisters
llvm::MCRegisterInfo::SubRegCoveredBitsSubRegCoveredBits - Emitted by tablegen: bit range covered by a subreg index, -1 in any being invalid
llvm::SubtargetFeatureKVSubtargetFeatureKV - Used to provide key value pairs for feature and CPU bit flags
llvm::SubtargetFeaturesSubtargetFeatures - Manages the enabling and disabling of subtarget specific features
llvm::SubtargetInfoKVSubtargetInfoKV - Used to provide key value pairs for CPU and arbitrary pointers
llvm::SuccIterator< Term_, BB_ >
llvm::SUnitSUnit - Scheduling unit. This is a node in the scheduling DAG
llvm::SUnitIterator
llvm::SuperRegClassIterator
llvm::SwitchInstSwitchInst - Multiway switch
llvm::COFFYAML::Symbol
llvm::object::Archive::Symbol
llvm::ELFYAML::Symbol
llvm::COFF::symbol
llvm::object::Archive::symbol_iterator
llvm::object::symbol_iterator
llvm::SymbolCUHelper used to pair up a symbol and its DWARF compile unit
llvm::object::SymbolicFile
llvm::RuntimeDyld::SymbolInfoInformation about a named symbol
llvm::object::SymbolRefThis is a value type class that represents a single symbol in the list of symbols in the object file
llvm::RuntimeDyld::SymbolResolverSymbol resolution
llvm::SymbolTableEntrySymbol info for RuntimeDyld
llvm::SymbolTableListTraits< ValueSubClass, ItemParentClass >
llvm::MachO::symseg_command
llvm::MachO::symtab_command
llvm::AArch64SysReg::SysRegMapper
llvm::SystemZAsmPrinter
llvm::SystemZCCState
llvm::SystemZConstantPoolValueA SystemZ-specific constant pool value
llvm::SystemZFrameLowering
SystemZGenInstrInfo
SystemZGenRegisterInfo
SystemZGenSubtargetInfo
llvm::SystemZInstPrinter
llvm::SystemZInstrInfo
llvm::SystemZMachineFunctionInfo
llvm::SystemZMCAsmInfo
llvm::SystemZMCInstLower
llvm::SystemZRegisterInfo
llvm::SystemZSelectionDAGInfo
llvm::SystemZSubtarget
llvm::SystemZTargetLowering
llvm::SystemZTargetMachine
llvm::SystemZTTIImpl
T
llvm::TableGenStringKeyTableGenStringKey - This is a wrapper for std::string suitable for using as a key to a DenseMap
llvm::TargetTarget - Wrapper for Target specific information
llvm::TargetFolderTargetFolder - Create constants with target dependent folding
llvm::TargetFrameLoweringInformation about stack frame layout on the target
llvm::TargetIndexSDNodeCompletely target-dependent object reference
llvm::TargetInstrInfoTargetInstrInfo - Interface to description of machine instruction set
llvm::TargetIntrinsicInfoTargetIntrinsicInfo - Interface to description of machine instruction set
llvm::TargetIRAnalysisAnalysis pass providing the TargetTransformInfo
llvm::TargetLibraryAnalysisAnalysis pass providing the TargetLibraryInfo
llvm::TargetLibraryInfoProvides information about what library functions are available for the current target
llvm::TargetLibraryInfoImplImplementation of the target library information
llvm::TargetLibraryInfoWrapperPass
llvm::TargetLoweringThis class defines information used to lower LLVM code to legal SelectionDAG operators that the target instruction selector can accept natively
llvm::TargetLoweringBaseThis base class for TargetLowering contains the SelectionDAG-independent parts that can be used from the rest of CodeGen
llvm::TargetLoweringObjectFile
llvm::TargetLoweringObjectFileCOFF
llvm::TargetLoweringObjectFileELF
llvm::TargetLoweringObjectFileMachO
llvm::TargetLowering::TargetLoweringOptA convenience struct that encapsulates a DAG, and two SDValues for returning information from TargetLowering to its clients that want to combine
llvm::TargetMachinePrimary interface to the complete machine description for the target machine
llvm::TargetOptions
llvm::TargetPassConfigTarget-Independent Code Generator Pass Configuration Options
llvm::TargetRecip
llvm::TargetRegisterClass
llvm::TargetRegisterInfoTargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDesc objects that represent all of the machine registers that the target has
llvm::TargetRegisterInfoDescTargetRegisterInfoDesc - Extra information, not in MCRegisterDesc, about registers
llvm::TargetRegistryTargetRegistry - Generic interface to target specific features
llvm::TargetSchedModelProvide an instruction scheduling machine model to CodeGen passes
llvm::TargetSelectionDAGInfoTargetSelectionDAGInfo - Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process
llvm::TargetSubtargetInfoTargetSubtargetInfo - Generic base class for all target subtargets
llvm::TargetTransformInfoThis pass provides access to the codegen interfaces that are needed for IR-level transformations
llvm::TargetTransformInfoImplBaseBase class for use as a mix-in that aids implementing a TargetTransformInfo-compatible class
llvm::TargetTransformInfoImplCRTPBase< T >CRTP base class for use as a mix-in that aids implementing a TargetTransformInfo-compatible class
llvm::TargetTransformInfoWrapperPassWrapper pass for TargetTransformInfo
llvm::MDBuilder::TBAAStructField
llvm::TempMDNodeDeleter
llvm::TerminatorInstSubclasses of this class are all able to terminate a basic block
llvm::TernarySDNodeThis class is used for three-operand SDNodes
llvm::TernOpInitTernOpInit - !op (X, Y, Z) - Combine two inits
llvm::TextInstrProfReaderReader for the simple text based instrprof format
llvm::TGLexerTGLexer - TableGen Lexer class
llvm::TGParser
llvm::MachO::thread_command
ThreadInfo
llvm::sys::ThreadLocal< T >ThreadLocal - A class used to abstract thread-local storage
llvm::sys::ThreadLocalImpl
llvm::ThreadSafeRefCountedBase< Derived >A thread-safe version of llvm::RefCountedBase
ThreadStack
llvm::Thumb1FrameLowering
llvm::Thumb1InstrInfo
llvm::Thumb2InstrInfo
llvm::ThumbBETargetMachineThumbBETargetMachine - Thumb big endian target machine
llvm::ThumbLETargetMachineThumbLETargetMachine - Thumb little endian target machine
llvm::ThumbRegisterInfo
llvm::ThumbTargetMachineThumbTargetMachine - Thumb target machine
llvm::TimerTimer - This class is used to track the amount of time spent between invocations of its startTimer()/stopTimer() methods
llvm::TimeRecord
llvm::TimeRegionUsed as a helper class to call the startTimer() and stopTimer() methods of the Timer class
llvm::TimerGroupUsed to group together related timers into a single report that is printed when the TimerGroup is destroyed
llvm::sys::TimeValueThis class is used where a precise fixed point in time is required
llvm::TinyPtrVector< EltTy >TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vector, but is general enough to go beyond that when required
llvm::AArch64TLBI::TLBIMapper
llvm::MachO::tlv_descriptor
llvm::MachO::tlv_descriptor_32
llvm::MachO::tlv_descriptor_64
llvm::yaml::TokenToken - A single YAML token
llvm::X86Operand::TokOp
llvm::tool_output_fileThis class contains a raw_fd_ostream and adds a few extra features commonly needed for compiler-like tool output files:
llvm::objcarc::TopDownPtrState
llvm::Trace
llvm::MachineTraceMetrics::TraceA trace represents a plausible sequence of executed basic blocks that passes through the current basic block one
fuzzer::TraceBasedMutation
llvm::MachineTraceMetrics::TraceBlockInfoPer-basic block information that relates to a specific trace through the block
fuzzer::TraceState
llvm::TrackingMDRefTracking metadata reference
llvm::TrackingVH< ValueTy >Value handle that tracks a Value across RAUW
llvm::detail::TrailingZerosCounter< T, SizeOfT >
llvm::TripleTriple - Helper class for working with autoconf configuration names
true_type
llvm::TruncInstThis class represents a truncation of integer types
llvm::TwineTwine - A lightweight data structure for efficiently representing the concatenation of temporary values as strings
llvm::MachO::twolevel_hint
llvm::MachO::twolevel_hints_command
llvm::TypeThe instances of the Type class are immutable: once they are created, they are never changed
llvm::TypeBuilder< T, cross_compilable >TypeBuilder - This provides a uniform API for looking up types known at compile time
llvm::TypeBuilder< const T, cross >
llvm::TypeBuilder< const void *, false >
llvm::TypeBuilder< const volatile T, cross >
llvm::TypeBuilder< const volatile void *, false >
llvm::TypeBuilder< double, false >
llvm::TypeBuilder< double, true >
llvm::TypeBuilder< float, false >
llvm::TypeBuilder< float, true >
llvm::TypeBuilder< R(), cross >
llvm::TypeBuilder< R(...), cross >
llvm::TypeBuilder< R(A1), cross >
llvm::TypeBuilder< R(A1, A2), cross >
llvm::TypeBuilder< R(A1, A2, A3), cross >
llvm::TypeBuilder< R(A1, A2, A3, A4), cross >
llvm::TypeBuilder< R(A1, A2, A3, A4, A5), cross >
llvm::TypeBuilder< R(A1, A2, A3, A4, A5,...), cross >
llvm::TypeBuilder< R(A1, A2, A3, A4,...), cross >
llvm::TypeBuilder< R(A1, A2, A3,...), cross >
llvm::TypeBuilder< R(A1, A2,...), cross >
llvm::TypeBuilder< R(A1,...), cross >
llvm::TypeBuilder< T &, cross >There is no support for references
llvm::TypeBuilder< T *, cross >
llvm::TypeBuilder< T[], cross >LLVM uses an array of length 0 to represent an unknown-length array
llvm::TypeBuilder< T[N], cross >
llvm::TypeBuilder< types::fp128, cross >
llvm::TypeBuilder< types::i< num_bits >, cross >
llvm::TypeBuilder< types::ieee_double, cross >
llvm::TypeBuilder< types::ieee_float, cross >
llvm::TypeBuilder< types::ppc_fp128, cross >
llvm::TypeBuilder< types::x86_fp80, cross >
llvm::TypeBuilder< types::x86_mmx, cross >
llvm::TypeBuilder< void *, false >Void* is disallowed in LLVM types, but it occurs often enough in C code that we special case it
llvm::TypeBuilder< void, cross >
llvm::TypeBuilder< volatile T, cross >
llvm::TypeBuilder< volatile void *, false >
llvm::TypeConversionCostTblEntry< TypeTy >Type Conversion Cost Table
llvm::TypedDINodeRef< T >Pointer union between a subclass of DINode and MDString
llvm::TypedInitTypedInit - This is the common super-class of types that have a specific, explicit, type
llvm::TypedMDOperandIterator< T >Typed iterator through MDNode operands
llvm::TypedTrackingMDRef< T >Typed tracking ref
llvm::TypeFinderTypeFinder - Walk over a module, identifying all of the types that are used by the module
llvm::bfi_detail::TypeMap< BlockT >
llvm::bfi_detail::TypeMap< BasicBlock >
llvm::bfi_detail::TypeMap< MachineBasicBlock >
llvm::PatternMatch::UAddWithOverflow_match< LHS_t, RHS_t, Sum_t >
llvm::UDivOperator
llvm::PatternMatch::ufmax_pred_tyHelper class for identifying unordered max predicates
llvm::PatternMatch::ufmin_pred_tyHelper class for identifying unordered min predicates
llvm::UIToFPInstThis class represents a cast unsigned integer to floating point
llvm::PatternMatch::umax_pred_tyHelper class for identifying unsigned max predicates
llvm::PatternMatch::umin_pred_tyHelper class for identifying unsigned min predicates
unary_function
llvm::UnaryConstantExprUnaryConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement unary constant exprs
llvm::UnaryInstruction
llvm::UnarySDNodeThis class is used for single-operand SDNodes
llvm::UndefValueUndefValue - 'undef' values are things that do not have specified contents
llvm::sys::UnicodeCharRangeRepresents a closed range of Unicode code points [Lower, Upper]
llvm::sys::UnicodeCharSetHolds a reference to an ordered array of UnicodeCharRange and allows to quickly check if a code point is contained in the set represented by this array
llvm::UnifyFunctionExitNodes
llvm::unique_lock< MutexT >A pared-down imitation of std::unique_lock from C++11
llvm::sys::fs::UniqueID
llvm::UniqueVector< T >UniqueVector - This class produces a sequential ID number (base 1) for each unique entry that is added
llvm::UnOpInitUnOpInit - !op (X) - Transform an init
llvm::UnreachableInstUnreachableInst - This function has undefined behavior
llvm::TargetTransformInfo::UnrollingPreferencesParameters that control the generic loop unrolling transformation
llvm::UnsetInitUnsetInit - ? - Represents an uninitialized value
llvm::yaml::unvalidatedMappingTraits< T >
llvm::Win64EH::UnwindCodeUnwindCode - This union describes a single operation in a function prolog, or part thereof
llvm::WinEH::UnwindEmitter
llvm::Win64EH::UnwindEmitter
llvm::Win64EH::UnwindInfoUnwindInfo - An entry in the exception table
llvm::UnwindOpcodeAssembler
llvm::UseA Use represents the edge between a Value definition and its users
llvm::SDNode::use_iteratorThis class provides iterator support for SDUse operands that use a specific SDNode
llvm::UseListOrderStructure to hold a use-list order
llvm::User
fuzzer::UserSuppliedFuzzerAn abstract class that allows to use user-supplied mutators with libFuzzer
llvm::detail::PtrUseVisitorBase::UseToVisitA struct of the data needed to visit a particular use
llvm::MachO::uuid_command
llvm::VAArgInstVAArgInst - This class represents the va_arg llvm instruction, which returns an argument of the specified type given a va_list and increments that list
llvm::VACopyInstVACopyInst - This represents the llvm.va_copy intrinsic
llvm::VAEndInstVAEndInst - This represents the llvm.va_end intrinsic
llvm::ValIDValID - Represents a reference of a definition of some sort with no type
llvm::yaml::validatedMappingTraits< T >
llvm::ValueLLVM Value Representation
llvm::DebugLocEntry::ValueA single location or constant
llvm::cl::value_desc
llvm::User::value_op_iteratorIterator for directly iterating over the operand Values
llvm::ValueAsMetadataValue wrapper in the Metadata hierarchy
llvm::ValueEnumerator
llvm::ValueHandleBaseThis is the common base class of value handles
llvm::ValueMap< KeyT, ValueT, Config >See the file comment
llvm::ValueMapCallbackVH< KeyT, ValueT, Config >
llvm::ValueMapConfig< KeyT, MutexT >This class defines the default behavior for configurable aspects of ValueMap<>
llvm::ValueMapConstIterator< DenseMapT, KeyT >
llvm::ValueMapIterator< DenseMapT, KeyT >
llvm::ValueMapTypeRemapperValueMapTypeRemapper - This is a class that can be implemented by clients to remap types when cloning constants and instructions
llvm::ValueMaterializerValueMaterializer - This is a class that can be implemented by clients to materialize Values on demand
llvm::PBQP::ValuePool< ValueT >
llvm::cl::ValuesClass< DataType >
llvm::ValueSymbolTableThis class provides a symbol table of name/value pairs
llvm::TargetLoweringBase::ValueTypeActionImpl
llvm::ValueMapConstIterator< DenseMapT, KeyT >::ValueTypeProxy
llvm::ValueMapIterator< DenseMapT, KeyT >::ValueTypeProxy
llvm::VarBitInitVarBitInit - Opcode{0} - Represent access to one bit of a variable or field
llvm::MachineModuleInfo::VariableDbgInfo
llvm::VariadicFunction< ResultT, ArgT, Func >Class which can simulate a type-safe variadic function
llvm::VariadicFunction1< ResultT, Param0T, ArgT, Func >
llvm::VariadicFunction2< ResultT, Param0T, Param1T, ArgT, Func >
llvm::VariadicFunction3< ResultT, Param0T, Param1T, Param2T, ArgT, Func >
llvm::VariadicOperandTraits< SubClass, MINARITY >VariadicOperandTraits - determine the allocation regime of the Use array when it is a prefix to the User object, and the number of Use objects is only known at allocation time
llvm::Variant
llvm::LiveVariables::VarInfoVarInfo - This represents the regions where a virtual register is live in the program
llvm::VarInitVarInit - 'Opcode' - Represent a reference to an entire variable object
llvm::VarListElementInitVarListElementInit - List[4] - Represent access to one element of a var or field
llvm::VAStartInstVAStartInst - This represents the llvm.va_start intrinsic
llvm::VecDescVecDesc - Describes a possible vectorization of a function
llvm::PBQP::VectorPBQP Vector class
llvm::VectorizeConfigVectorize configuration
llvm::VectorizerParamsCollection of parameters shared beetween the Loop Vectorizer and the Loop Access Analysis
llvm::VectorTypeVectorType - Class to represent vector types
llvm::VerifierPass
llvm::MachO::version_min_command
llvm::VersionInfo
llvm::MCAssembler::VersionMinInfoTypeMachO specific deployment target version info
llvm::VirtReg2IndexFunctor
llvm::VirtRegAuxInfoCalculate auxiliary information for a virtual register such as its spill weight and allocation hint
llvm::MachineOperandIteratorBase::VirtRegInfoVirtRegInfo - Information about a virtual register used by a set of operands
llvm::VirtRegMap
llvm::VLIWMachineSchedulerExtend the standard ScheduleDAGMI to provide more context and override the top-level schedule() driver
llvm::VLIWPacketizerList
llvm::VLIWResourceModel
llvm::VNInfoVNInfo - Value Number Information
llvm::VReg2SUnitAn individual mapping from virtual register number to SUnit
llvm::VTSDNodeThis class is used to represent EVT's, which are used to parameterize some operations
llvm::sys::WatchdogThis class provides an abstraction for a timeout around an operation that must complete in a given amount of time
llvm::WeakVHValue handle that is nullable, but tries to track the Value
llvm::BlockFrequencyInfoImplBase::WeightUnscaled probability weight
llvm::WinCodeViewLineTablesCollects and handles line tables information in a CodeView format
llvm::WinEHFuncInfo
llvm::WinEHHandlerType
llvm::WinEHTryBlockMapEntry
llvm::WinEHUnwindMapEntry
llvm::WinException
llvm::dwarf::syntax::WithColorAn RAII object that temporarily switches an output stream to a specific color
llvm::BlockFrequencyInfoImplBase::WorkingDataIndex of loop information
llvm::support::endian::Writer< endian >Adapter to write values to a stream in a particular byte order
llvm::X86_64MachoTargetObjectFileX86_64MachoTargetObjectFile - This TLOF implementation is used for Darwin x86-64
llvm::X86_64MCAsmInfoDarwin
llvm::MachO::x86_exception_state64_t
llvm::MachO::x86_exception_state_t
llvm::MachO::x86_float_state64_t
llvm::MachO::x86_float_state_t
llvm::types::x86_fp80
llvm::types::x86_mmx
llvm::MachO::x86_state_hdr_t
llvm::MachO::x86_thread_state64_t
llvm::MachO::x86_thread_state_t
llvm::X86AddressModeX86AddressMode - This struct holds a generalized full x86 address mode
llvm::X86AsmInstrumentation
llvm::X86AsmPrinter
llvm::X86ELFMCAsmInfo
llvm::X86ELFTargetObjectFileThis implemenatation is used for X86 ELF targets that don't have a further specialization
llvm::X86FrameLowering
llvm::X86Disassembler::X86GenericDisassemblerGeneric disassembler for all X86 platforms
X86GenInstrInfo
X86GenRegisterInfo
X86GenSubtargetInfo
llvm::X86LinuxNaClTargetObjectFileX86LinuxNaClTargetObjectFile - This implementation is used for linux and Native Client on x86 and x86-64
llvm::X86MachineFunctionInfoX86MachineFunctionInfo - This class is derived from MachineFunction and contains private X86 target-specific information for each MachineFunction
llvm::X86MCAsmInfoDarwin
llvm::X86MCAsmInfoGNUCOFF
llvm::X86MCAsmInfoMicrosoft
X86MemoryFoldTableEntry
llvm::X86OperandX86Operand - Instances of this class represent a parsed X86 machine instruction
llvm::X86SelectionDAGInfo
llvm::X86TTIImpl
llvm::X86WindowsTargetObjectFileThis implementation is used for Windows targets on x86 and x86-64
llvm::XCoreFrameLowering
llvm::XCoreFunctionInfoXCoreFunctionInfo - This class is derived from MachineFunction private XCore target-specific information for each MachineFunction
XCoreGenInstrInfo
XCoreGenRegisterInfo
XCoreGenSubtargetInfo
llvm::XCoreInstPrinter
llvm::XCoreInstrInfo
llvm::XCoreMCAsmInfo
llvm::XCoreMCInstLowerThis class is used to lower an MachineInstr into an MCInst
llvm::XCoreRegisterInfo
llvm::XCoreSelectionDAGInfo
llvm::XCoreSubtarget
llvm::XCoreTargetLowering
llvm::XCoreTargetMachine
llvm::XCoreTargetObjectFile
llvm::XCoreTargetStreamer
llvm::XCoreTTIImpl
llvm::MachO::xmm_reg_t
llvm::ZExtInstThis class represents zero extension of integer types
llvm::ZExtOperator