 AMDGPUAS | OpenCL uses address spaces to differentiate between various memory regions on the hardware |
 CU | |
 false | |
  IntervalSorter | |
  Chain | A Chain is a sequence of instructions that are linked together by an accumulation operand |
  GepNode | |
  in_set | |
  SingleLoopExtractor | SingleLoopExtractor - For bugpoint |
  GCPtrLivenessData | |
  PartiallyConstructedSafepointRecord | |
 fuzzer | |
  FlagDescription | |
  UserSuppliedFuzzer | An abstract class that allows to use user-supplied mutators with libFuzzer |
  Fuzzer | |
   FuzzingOptions | |
  SimpleUserSuppliedFuzzer | |
  LabelRange | |
  TraceBasedMutation | |
  TraceState | |
 llvm | Compute iterated dominance frontiers using a linear time algorithm |
  AArch64 | |
  AArch64_AM | AArch64_AM - AArch64 Addressing Mode Stuff |
  AArch64AT | |
   ATMapper | |
  AArch64CC | |
  AArch64DB | |
   DBarrierMapper | |
  AArch64DC | |
   DCMapper | |
  AArch64IC | |
   ICMapper | |
  AArch64II | |
  AArch64ISB | |
   ISBMapper | |
  AArch64ISD | |
  AArch64Layout | |
  AArch64PRFM | |
   PRFMMapper | |
  AArch64PState | |
   PStateMapper | |
  AArch64SE | |
  AArch64SysReg | |
   SysRegMapper | |
   MSRMapper | |
   MRSMapper | |
  AArch64TLBI | |
   TLBIMapper | |
  AMDGPU | |
   IsaVersion | |
  AMDGPUIntrinsic | |
  AMDGPUISD | |
  APIntOps | |
  ARM | Define some predicates that are used for node matching |
   EHABI | |
   WinEH | |
    RuntimeFunction | RuntimeFunction - An entry in the table of procedure data (.pdata) |
    EpilogueScope | ExceptionDataRecord - An entry in the table of exception data (.xdata) |
    ExceptionDataRecord | |
  ARM_AM | ARM_AM - ARM Addressing Mode Stuff |
  ARM_ISB | |
  ARM_MB | |
  ARM_MC | |
  ARM_PROC | |
  ARMBuildAttrs | |
  ARMCC | |
  ARMCP | |
  ARMII | ARMII - This namespace holds all of the target specific flags that instruction info tracks |
  ARMISD | |
  ARMRI | Register allocation hints |
  AttributeFuncs | |
  bfi_detail | |
   BlockEdgesAdder | |
   BlockMass | Mass of a block |
   TypeMap | |
   TypeMap< BasicBlock > | |
   TypeMap< MachineBasicBlock > | |
   IrreducibleGraph | Graph of irreducible control flow |
    IrrNode | |
  bitc | |
  BPFISD | |
  CallingConv | CallingConv Namespace - This namespace contains an enum with a value for the well-known calling conventions |
  cl | Cl Namespace - This namespace contains all of the command line option processing machinery |
   OptionCategory | |
   Option | |
   desc | |
   value_desc | |
   initializer | |
   LocationClass | |
   cat | |
   GenericOptionValue | |
   OptionValue | |
   OptionValueBase | |
   OptionValueCopy | |
   OptionValueBase< DataType, false > | |
   OptionValue< cl::boolOrDefault > | |
   OptionValue< std::string > | |
   ValuesClass | |
   generic_parser_base | |
    GenericOptionInfo | |
   parser | |
    OptionInfo | |
   basic_parser_impl | |
   basic_parser | |
   parser< bool > | |
   parser< boolOrDefault > | |
   parser< int > | |
   parser< unsigned > | |
   parser< unsigned long long > | |
   parser< double > | |
   parser< float > | |
   parser< std::string > | |
   parser< char > | |
   OptionDiffPrinter | |
   OptionDiffPrinter< DT, DT > | |
   applicator | |
   applicator< char[n]> | |
   applicator< const char[n]> | |
   applicator< const char * > | |
   applicator< NumOccurrencesFlag > | |
   applicator< ValueExpected > | |
   applicator< OptionHidden > | |
   applicator< FormattingFlags > | |
   applicator< MiscFlags > | |
   opt_storage | |
   opt_storage< DataType, false, true > | |
   opt_storage< DataType, false, false > | |
   opt | |
   list_storage | |
   list_storage< DataType, bool > | |
   list | |
   multi_val | |
   bits_storage | |
   bits_storage< DataType, bool > | |
   bits | |
   alias | |
   aliasopt | |
   extrahelp | |
  CodeGenOpt | |
  CodeModel | |
  COFF | |
   header | |
   BigObjHeader | |
   symbol | |
   section | |
   relocation | |
   AuxiliaryFunctionDefinition | |
   AuxiliarybfAndefSymbol | |
   AuxiliaryWeakExternal | |
   AuxiliarySectionDefinition | |
   AuxiliaryCLRToken | |
   Auxiliary | |
   ImportDirectoryTableEntry | The Import Directory Table |
   ImportLookupTableEntry32 | The PE32 Import Lookup Table |
   DOSHeader | The DOS compatible header at the front of all PEs |
   PE32Header | |
   DataDirectory | |
   ImportHeader | |
  COFFYAML | |
   Relocation | |
   Section | |
   Symbol | |
   PEHeader | |
   Object | |
  coverage | |
   Counter | A Counter is an abstract value that describes how to compute the execution count for a region of code using the collected profile count data |
   CounterExpression | A Counter expression is a value that represents an arithmetic operation with two counters |
   CounterExpressionBuilder | A Counter expression builder is used to construct the counter expressions |
   CounterMappingRegion | A Counter mapping region associates a source range with a specific counter |
   CountedRegion | Associates a source range with an execution count |
   CounterMappingContext | A Counter mapping context is used to connect the counters, expressions and the obtained counter values |
   FunctionRecord | Code coverage information for a single function |
   FunctionRecordIterator | Iterator over Functions, optionally filtered to a single file |
   ExpansionRecord | Coverage information for a macro expansion or #included file |
   CoverageSegment | The execution count information starting at a point in a file |
   CoverageData | Coverage information to be processed or displayed |
   CoverageMapping | The mapping of profile information to coverage data |
   CoverageMappingRecord | Coverage mapping information for a single function |
   CoverageMappingIterator | A file format agnostic iterator over coverage mapping data |
   CoverageMappingReader | |
   RawCoverageReader | Base class for the raw coverage mapping and filenames data readers |
   RawCoverageFilenamesReader | Reader for the raw coverage filenames |
   RawCoverageMappingReader | Reader for the raw coverage mapping data |
   BinaryCoverageReader | Reader for the coverage mapping data that is emitted by the frontend and stored in an object file |
    ProfileMappingRecord | |
   CoverageFilenamesSectionWriter | Writer of the filenames section for the instrumentation based code coverage |
   CoverageMappingWriter | Writer for instrumentation based coverage mapping data |
  detail | Implementation details of the pass manager interfaces |
   DenseMapPair | |
   DenseSetEmpty | |
   DenseSetPair | |
   PtrUseVisitorBase | Implementation of non-dependent functionality for PtrUseVisitor |
    PtrInfo | This class provides information about the result of a visit |
    UseToVisit | A struct of the data needed to visit a particular use |
   AnalysisManagerBase | A CRTP base used to implement analysis managers |
   PassConcept | Template for the abstract base class used to dispatch polymorphically over pass objects |
   PassRunAcceptsAnalysisManager | SFINAE metafunction for computing whether PassT has a run method accepting an AnalysisManager<IRUnitT> |
   PassModel | A template wrapper used to implement the polymorphic API |
   PassModel< IRUnitT, PassT, PreservedAnalysesT, true > | Specialization of PassModel for passes that accept an analyis manager |
   PassModel< IRUnitT, PassT, PreservedAnalysesT, false > | Specialization of PassModel for passes that accept an analyis manager |
   AnalysisResultConcept | Abstract concept of an analysis result |
   ResultHasInvalidateMethod | SFINAE metafunction for computing whether ResultT provides an invalidate member function |
   AnalysisResultModel | Wrapper to model the analysis result concept |
   AnalysisResultModel< IRUnitT, PassT, ResultT, PreservedAnalysesT, false > | Specialization of AnalysisResultModel which provides the default invalidate functionality |
   AnalysisResultModel< IRUnitT, PassT, ResultT, PreservedAnalysesT, true > | Specialization of AnalysisResultModel which delegates invalidate handling to ResultT |
   AnalysisPassConcept | Abstract concept of an analysis pass |
   AnalysisPassModel | Wrapper to model the analysis pass concept |
   AnalysisPassModel< IRUnitT, PassT, true > | Specialization of AnalysisPassModel which passes an AnalysisManager to PassT's run method |
   AnalysisPassModel< IRUnitT, PassT, false > | Specialization of AnalysisPassModel which does not pass an AnalysisManager to PassT's run method |
   AlignerImpl | |
   SizerImpl | |
   TrailingZerosCounter | |
   LeadingZerosCounter | |
   PopulationCounter | |
   PopulationCounter< T, 8 > | |
   OptionKey | |
  DOT | |
  dwarf | |
   syntax | |
    WithColor | An RAII object that temporarily switches an output stream to a specific color |
   PubIndexEntryDescriptor | Decsribes an entry of the various gnu_pub* debug sections |
  DWARFFlavour | Flavour of dwarf regnumbers |
  ELF | |
   Elf32_Ehdr | |
   Elf64_Ehdr | |
   Elf32_Shdr | |
   Elf64_Shdr | |
   Elf32_Sym | |
   Elf64_Sym | |
   Elf32_Rel | |
   Elf32_Rela | |
   Elf64_Rel | |
   Elf64_Rela | |
   Elf32_Phdr | |
   Elf64_Phdr | |
   Elf32_Dyn | |
   Elf64_Dyn | |
  ELFYAML | |
   FileHeader | |
   Symbol | |
   LocalGlobalWeakSymbols | |
   SectionOrType | |
   Section | |
   RawContentSection | |
   NoBitsSection | |
   Group | |
   Relocation | |
   RelocationSection | |
   MipsABIFlags | |
   Object | |
  EngineKind | |
  FloatABI | |
  FPOpFusion | |
  GC | |
  GCOV | |
  GraphProgram | |
  hashing | |
   detail | |
    hash_state | The intermediate state used during hashing |
    is_hashable_data | Trait to indicate whether a type's bits can be hashed directly |
    is_hashable_data< std::pair< T, U > > | |
    hash_combine_recursive_helper | Helper class to manage the recursive combining of hash_combine arguments |
  Hexagon | |
  HexagonII | HexagonII - This namespace holds all of the target specific flags that instruction info tracks |
  HexagonISD | |
  HexagonMCInstrInfo | |
  HexStyle | |
  IndexedInstrProf | |
  InlineConstants | |
  IntervalMapImpl | IntervalMapImpl - Namespace used for IntervalMap implementation details |
   LeafNode | |
   BranchNode | |
   NodeBase | |
   NodeSizer | |
   NodeRef | |
   Path | |
  Intrinsic | This namespace contains an enum with a value for every intrinsic/builtin function known by LLVM |
   IITDescriptor | This is a type descriptor which explains the type requirements of an intrinsic |
  ISD | ISD namespace - This namespace contains an enum which represents all of the SelectionDAG node types and value types |
   ArgFlagsTy | |
   InputArg | InputArg - 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 |
   OutputArg | OutputArg - 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 |
  JumpTable | |
  LCOMM | |
  legacy | |
   PassManagerBase | PassManagerBase - 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 |
   PassManager | PassManager manages ModulePassManagers |
   FunctionPassManager | FunctionPassManager manages FunctionPasses and BasicBlockPassManagers |
   FunctionPassManagerImpl | FunctionPassManagerImpl manages FPPassManagers |
   PassManagerImpl | PassManagerImpl manages MPPassManagers |
  LibFunc | |
  lltok | |
  MachineCombinerPattern | Enumeration of instruction pattern supported by machine combiner |
  MachO | |
   mach_header | |
   mach_header_64 | |
   load_command | |
   segment_command | |
   segment_command_64 | |
   section | |
   section_64 | |
   fvmlib | |
   fvmlib_command | |
   dylib | |
   dylib_command | |
   sub_framework_command | |
   sub_client_command | |
   sub_umbrella_command | |
   sub_library_command | |
   prebound_dylib_command | |
   dylinker_command | |
   thread_command | |
   routines_command | |
   routines_command_64 | |
   symtab_command | |
   dysymtab_command | |
   dylib_table_of_contents | |
   dylib_module | |
   dylib_module_64 | |
   dylib_reference | |
   twolevel_hints_command | |
   twolevel_hint | |
   prebind_cksum_command | |
   uuid_command | |
   rpath_command | |
   linkedit_data_command | |
   data_in_code_entry | |
   source_version_command | |
   encryption_info_command | |
   encryption_info_command_64 | |
   version_min_command | |
   dyld_info_command | |
   linker_option_command | |
   symseg_command | |
   ident_command | |
   fvmfile_command | |
   tlv_descriptor_32 | |
   tlv_descriptor_64 | |
   tlv_descriptor | |
   entry_point_command | |
   fat_header | |
   fat_arch | |
   relocation_info | |
   scattered_relocation_info | |
   any_relocation_info | |
   nlist_base | |
   nlist | |
   nlist_64 | |
   x86_thread_state64_t | |
   fp_control_t | |
   fp_status_t | |
   mmst_reg_t | |
   xmm_reg_t | |
   x86_float_state64_t | |
   x86_exception_state64_t | |
   x86_state_hdr_t | |
   x86_thread_state_t | |
   x86_float_state_t | |
   x86_exception_state_t | |
  MCD | |
  MCID | |
  MCOI | |
  MCParserUtils | |
  mdconst | Transitional API for extracting constants from Metadata |
   detail | |
    HasDereference | |
     SFINAE | |
    IsValidPointer | |
    IsValidReference | |
  Mips | |
  Mips16HardFloatInfo | |
   FuncSignature | |
   FuncNameSignature | |
  MIPS_MC | |
  MipsII | MipsII - This namespace holds all of the target specific flags that instruction info tracks |
  MipsISD | |
  MSP430II | MSP430II - This namespace holds all of the target specific flags that instruction info tracks |
  MSP430ISD | |
  N86 | Native X86 register numbers |
  NVPTX | |
   PTXCmpMode | PTXCmpMode - Comparison mode enumeration |
   PTXCvtMode | PTXCvtMode - Conversion code enumeration |
   PTXLdStInstCode | |
  NVPTXCC | |
  NVPTXII | |
  NVPTXISD | |
  objcarc | |
   ARCRuntimeEntryPoints | Declarations for ObjC runtime functions and constants |
   ARCMDKindCache | A cache of MDKinds used by various ARC optimizations |
   ObjCARCAliasAnalysis | This is a simple alias analysis implementation that uses knowledge of ARC constructs to answer queries |
   ProvenanceAnalysis | This is similar to BasicAliasAnalysis, and it uses many of the same techniques, except it uses special ObjC-specific reasoning about pointer relationships |
   RRInfo | Unidirectional information about either a retain-decrement-use-release sequence or release-use-decrement-retain reverse sequence |
   PtrState | This class summarizes several per-pointer runtime properties which are propogated through the flow graph |
   BottomUpPtrState | |
   TopDownPtrState | |
  object | |
   OwningBinary | |
   ArchiveMemberHeader | |
   Archive | |
    Child | |
    child_iterator | |
    Symbol | |
    symbol_iterator | |
   Binary | |
   dos_header | The DOS compatible header at the front of all PE/COFF executables |
   coff_file_header | |
   coff_bigobj_file_header | |
   pe32_header | The 32-bit PE header that follows the COFF header |
   pe32plus_header | The 64-bit PE header that follows the COFF header |
   data_directory | |
   import_directory_table_entry | |
   import_lookup_table_entry | |
   delay_import_directory_table_entry | |
   export_directory_table_entry | |
   export_address_table_entry | |
   StringTableOffset | |
   coff_symbol | |
   coff_symbol_generic | |
   COFFSymbolRef | |
   coff_section | |
   coff_relocation | |
   coff_aux_function_definition | |
   coff_aux_bf_and_ef_symbol | |
   coff_aux_weak_external | |
   coff_aux_section_definition | |
   coff_aux_clr_token | |
   coff_import_header | |
   coff_import_directory_table_entry | |
   coff_load_configuration32 | |
   coff_load_configuration64 | |
   coff_runtime_function_x64 | |
   coff_base_reloc_block_header | |
   coff_base_reloc_block_entry | |
   COFFObjectFile | |
   ImportDirectoryEntryRef | |
   DelayImportDirectoryEntryRef | |
   ExportDirectoryEntryRef | |
   ImportedSymbolRef | |
   BaseRelocRef | |
   ELFFile | |
    ArchivePointerTypeTraits | Archive files are 2 byte aligned, so we need this for PointerIntPair to work |
    ELFEntityIterator | Iterate over constant sized entities |
   ELFObjectFileBase | |
   ELFSectionRef | |
   elf_section_iterator | |
   ELFSymbolRef | |
   elf_symbol_iterator | |
   ELFRelocationRef | |
   elf_relocation_iterator | |
   ELFObjectFile | |
   ELFType | |
   ELFDataTypeTypedefHelperCommon | |
   ELFDataTypeTypedefHelper | |
   ELFDataTypeTypedefHelper< ELFType< TargetEndianness, false > > | ELF 32bit types |
   ELFDataTypeTypedefHelper< ELFType< TargetEndianness, true > > | ELF 64bit types |
   Elf_Shdr_Base | |
   Elf_Shdr_Base< ELFType< TargetEndianness, false > > | |
   Elf_Shdr_Base< ELFType< TargetEndianness, true > > | |
   Elf_Shdr_Impl | |
   Elf_Sym_Base | |
   Elf_Sym_Base< ELFType< TargetEndianness, false > > | |
   Elf_Sym_Base< ELFType< TargetEndianness, true > > | |
   Elf_Sym_Impl | |
   Elf_Versym_Impl | Elf_Versym: This is the structure of entries in the SHT_GNU_versym section (.gnu.version) |
   Elf_Verdaux_Impl | Elf_Verdaux: This is the structure of auxiliary data in the SHT_GNU_verdef section (.gnu.version_d) |
   Elf_Verdef_Impl | Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section (.gnu.version_d) |
   Elf_Verneed_Impl | Elf_Verneed: This is the structure of entries in the SHT_GNU_verneed section (.gnu.version_r) |
   Elf_Vernaux_Impl | Elf_Vernaux: This is the structure of auxiliary data in SHT_GNU_verneed section (.gnu.version_r) |
   Elf_Dyn_Base | Elf_Dyn_Base: This structure matches the form of entries in the dynamic table section (.dynamic) look like |
   Elf_Dyn_Base< ELFType< TargetEndianness, false > > | |
   Elf_Dyn_Base< ELFType< TargetEndianness, true > > | |
   Elf_Dyn_Impl | Elf_Dyn_Impl: This inherits from Elf_Dyn_Base, adding getters and setters |
   Elf_Rel_Impl | |
   Elf_Rel_Impl< ELFType< TargetEndianness, false >, false > | |
   Elf_Rel_Impl< ELFType< TargetEndianness, false >, true > | |
   Elf_Rel_Impl< ELFType< TargetEndianness, true >, false > | |
   Elf_Rel_Impl< ELFType< TargetEndianness, true >, true > | |
   Elf_Ehdr_Impl | |
   Elf_Phdr_Impl | |
   Elf_Phdr_Impl< ELFType< TargetEndianness, false > > | |
   Elf_Phdr_Impl< ELFType< TargetEndianness, true > > | |
   Elf_Hash_Impl | |
   Elf_Mips_RegInfo | |
   Elf_Mips_RegInfo< ELFType< TargetEndianness, false > > | |
   Elf_Mips_RegInfo< ELFType< TargetEndianness, true > > | |
   Elf_Mips_Options | |
   Elf_Mips_ABIFlags | |
   IRObjectFile | |
   DiceRef | DiceRef - This is a value type class that represents a single data in code entry in the table in a Mach-O object file |
   ExportEntry | ExportEntry encapsulates the current-state-of-the-walk used when doing a non-recursive walk of the trie data structure |
   MachORebaseEntry | MachORebaseEntry encapsulates the current state in the decompression of rebasing opcodes |
   MachOBindEntry | MachOBindEntry encapsulates the current state in the decompression of binding opcodes |
   MachOObjectFile | |
    LoadCommandInfo | |
   MachOUniversalBinary | |
    object_iterator | |
    ObjectForArch | |
   RelocationRef | This is a value type class that represents a single relocation in the list of relocations in the object file |
   SectionRef | This is a value type class that represents a single section in the list of sections in the object file |
   SymbolRef | This is a value type class that represents a single symbol in the list of symbols in the object file |
   symbol_iterator | |
   ObjectFile | This class is the base class for all object file types |
   RelocToApply | |
   RelocVisitor | Base class for object file relocation visitors |
   DataRefImpl | |
   content_iterator | |
   BasicSymbolRef | This is a value type class that represents a single symbol in the list of symbols in the object file |
   SymbolicFile | |
  opt | |
   Arg | A concrete instance of a particular driver option |
   arg_iterator | Arg_iterator - Iterates through arguments stored inside an ArgList |
   ArgList | ArgList - Ordered collection of driver arguments |
   InputArgList | |
   DerivedArgList | DerivedArgList - An ordered collection of driver arguments, whose storage may be in another argument list |
   Option | Option - Abstract representation for a single form of driver argument |
   OptSpecifier | OptSpecifier - Wrapper class for abstracting references to option IDs |
   OptTable | Provide access to the Option info table |
    Info | Entry for a single option instance in the option data table |
  orc | |
   CompileOnDemandLayer | Compile-on-demand layer |
   SimpleCompiler | Simple compile functor: Takes a single IR module and returns an ObjectFile |
   CtorDtorIterator | This iterator provides a convenient way to iterate over the elements of an llvm.global_ctors/llvm.global_dtors instance |
    Element | Accessor for an element of the global_ctors/global_dtors array |
   CtorDtorRunner | Convenience class for recording constructor/destructor names for later execution |
   LocalCXXRuntimeOverrides | Support class for static dtor execution |
   JITCompileCallbackManagerBase | Base class for JITLayer independent aspects of JITCompileCallbackManager |
    CompileCallbackInfo | Handle to a newly created compile callback |
   JITCompileCallbackManager | Manage compile callbacks |
   IRCompileLayer | Eager IR compiling layer |
   IRTransformLayer | IR mutating layer |
   JITSymbol | Represents a symbol in the JIT |
   LambdaResolver | |
   LazyEmittingLayer | Lazy-emitting IR layer |
   LogicalDylib | |
   NullResolver | SymbolResolver impliementation that rejects all resolution requests |
   ObjectLinkingLayerBase | |
    LinkedObjectSet | Holds a set of objects to be allocated/linked as a unit in the JIT |
   DoNothingOnNotifyLoaded | Default (no-op) action to perform when loading objects |
   ObjectLinkingLayer | Bare bones object linking layer |
   ObjectTransformLayer | Object mutating layer |
   OrcX86_64 | |
   GlobalRenamer | |
   OrcMCJITReplacement | |
  PatternMatch | |
   OneUse_match | |
   class_match | |
   match_combine_or | Matching combinators |
   match_combine_and | |
   match_zero | |
   match_neg_zero | |
   apint_match | |
   constantint_match | |
   cst_pred_ty | This helper class is used to match scalar and vector constants that satisfy a specified predicate |
   api_pred_ty | This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to an APInt |
   is_one | |
   is_all_ones | |
   is_sign_bit | |
   is_power2 | |
   is_maxsignedvalue | |
   bind_ty | |
   specificval_ty | Match a specified Value* |
   specific_fpval | Match a specified floating point value or vector of all elements of that value |
   bind_const_intval_ty | |
   specific_intval | Match a specified integer value or vector of all elements of that |
   AnyBinaryOp_match | |
   BinaryOp_match | |
   OverflowingBinaryOp_match | |
   BinOp2_match | |
   Exact_match | |
   CmpClass_match | |
   SelectClass_match | |
   CastClass_match | |
   not_match | |
   neg_match | |
   fneg_match | |
   br_match | |
   brc_match | |
   MaxMin_match | |
   smax_pred_ty | Helper class for identifying signed max predicates |
   smin_pred_ty | Helper class for identifying signed min predicates |
   umax_pred_ty | Helper class for identifying unsigned max predicates |
   umin_pred_ty | Helper class for identifying unsigned min predicates |
   ofmax_pred_ty | Helper class for identifying ordered max predicates |
   ofmin_pred_ty | Helper class for identifying ordered min predicates |
   ufmax_pred_ty | Helper class for identifying unordered max predicates |
   ufmin_pred_ty | Helper class for identifying unordered min predicates |
   UAddWithOverflow_match | |
   Argument_match | |
   IntrinsicID_match | Intrinsic matchers |
   m_Intrinsic_Ty | Intrinsic matches are combinations of ID matchers, and argument matchers |
   m_Intrinsic_Ty< T0 > | |
   m_Intrinsic_Ty< T0, T1 > | |
   m_Intrinsic_Ty< T0, T1, T2 > | |
   m_Intrinsic_Ty< T0, T1, T2, T3 > | |
  PBQP | |
   RegAlloc | |
    MatrixMetadata | Metadata to speed allocatability test |
    AllowedRegVector | Holds a vector of the allowed physical regs for a vreg |
    GraphMetadata | Holds graph-level metadata relevent to PBQP RA problems |
    NodeMetadata | Holds solver state and other metadata relevant to each PBQP RA node |
    RegAllocSolverImpl | |
     EdgeMetadata | |
    PBQPRAGraph | |
   ValuePool | |
   PoolCostAllocator | |
   GraphBase | |
   Graph | PBQP Graph class |
    AdjEdgeIdSet | |
    EdgeIdSet | |
    EdgeItr | |
    NodeIdSet | |
    NodeItr | |
   Vector | PBQP Vector class |
   Matrix | PBQP Matrix class |
   MDVector | |
   MDMatrix | |
   Solution | Represents a solution to a PBQP problem |
  PICLevel | |
  PICStyles | The X86 backend supports a number of different styles of PIC |
  PPC | Define some predicates that are used for node matching |
  PPCII | PPCII - This namespace holds all of the PowerPC target-specific per-instruction flags |
  PPCISD | |
  RegState | |
  Reloc | |
  RTLIB | |
  sampleprof | |
   LineLocation | Represents the relative location of an instruction |
   SampleRecord | Representation of a single sample record |
   FunctionSamples | Representation of the samples collected for a function |
   SampleProfileReader | Sample-based profile reader |
   SampleProfileReaderText | |
   SampleProfileReaderBinary | |
   SampleProfileWriter | Sample-based profile writer. Base class |
   SampleProfileWriterText | Sample-based profile writer (text format) |
   SampleProfileWriterBinary | Sample-based profile writer (binary format) |
  ScaledNumbers | |
  Sched | |
  SI | |
   KernelInputOffsets | |
  Sparc | |
  SPCC | |
  SPII | SPII - This namespace holds all of the target specific flags that instruction info tracks |
  SPISD | |
  support | |
   detail | |
    PickAlignment | ::value is either alignment, or alignof(T) if alignment is 0 |
    packed_endian_specific_integral | |
     ref | |
   endian | |
    Writer | Adapter to write values to a stream in a particular byte order |
  SymbolRewriter | |
   RewriteDescriptor | The basic entity representing a rewrite operation |
   RewriteMapParser | |
  sys | |
   fs | |
    detail | |
     DirIterState | DirIterState - Keeps state for the directory_iterator |
     RecDirIterState | RecDirIterState - Keeps state for the recursive_directory_iterator |
    space_info | Space_info - Self explanatory |
    UniqueID | |
    file_status | File_status - Represents the result of a call to stat and friends |
    file_magic | File_magic - An "enum class" enumeration of file types based on magic (the first N bytes of the file) |
    mapped_file_region | This class represents a memory mapped file |
    directory_entry | Directory_entry - A single entry in a directory |
    directory_iterator | Directory_iterator - Iterates through the entries in path |
    recursive_directory_iterator | Recursive_directory_iterator - Same as directory_iterator except for it recurses down into child directories |
   locale | |
   path | |
    const_iterator | Path iterator |
    reverse_iterator | Reverse path iterator |
   unicode | |
   windows | |
   InitializeCOMRAII | |
   DynamicLibrary | This 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 |
   MemoryBlock | This class encapsulates the notion of a memory block which has an address and a size |
   Memory | This class provides various memory handling functions that manipulate MemoryBlock instances |
   MutexImpl | Platform agnostic Mutex class |
   SmartMutex | 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 |
   SmartScopedLock | |
   Process | A collection of legacy interfaces for querying information about the current executing process |
   ProcessInfo | This is the OS-specific separator for PATH like environment variables: |
   RWMutexImpl | Platform agnostic RWMutex class |
   SmartRWMutex | 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 |
   SmartScopedReader | ScopedReader - RAII acquisition of a reader lock |
   SmartScopedWriter | ScopedWriter - RAII acquisition of a writer lock |
   ThreadLocalImpl | |
   ThreadLocal | ThreadLocal - A class used to abstract thread-local storage |
   TimeValue | This class is used where a precise fixed point in time is required |
   UnicodeCharRange | Represents a closed range of Unicode code points [Lower, Upper] |
   UnicodeCharSet | Holds 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 |
   Watchdog | This class provides an abstraction for a timeout around an operation that must complete in a given amount of time |
  SystemZ | |
  SystemZCP | |
  SystemZICMP | |
  SystemZII | |
   Branch | |
  SystemZISD | |
  SystemZMC | |
  TargetOpcode | Invariant opcodes: All instruction sets have these as their low opcodes |
  tgtok | |
  ThreadModel | |
  TLSModel | |
  types | |
   i | I<N> corresponds to the LLVM IntegerType with N bits |
   ieee_float | |
   ieee_double | |
   x86_fp80 | |
   fp128 | |
   ppc_fp128 | |
   x86_mmx | |
  WebAssemblyISD | |
  Win64EH | |
   Instruction | |
   UnwindEmitter | |
   UnwindCode | UnwindCode - This union describes a single operation in a function prolog, or part thereof |
   RuntimeFunction | RuntimeFunction - An entry in the table of functions with unwind info |
   UnwindInfo | UnwindInfo - An entry in the exception table |
  WinEH | |
   Instruction | |
   FrameInfo | |
   UnwindEmitter | |
  X86 | Define some predicates that are used for node matching |
  X86_MC | |
  X86Disassembler | |
   X86GenericDisassembler | Generic disassembler for all X86 platforms |
   InstructionSpecifier | The specification for how to extract and interpret a full instruction and its operands |
   InternalInstruction | The x86 internal instruction, which is produced by the decoder |
   OperandSpecifier | The specification for how to extract and interpret one operand |
  X86II | X86II - This namespace holds all of the target specific flags that instruction info tracks |
  X86ISD | |
  XCore | |
  XCoreISD | |
  yaml | |
   StringValue | A wrapper around std::string which contains a source range that's being set during parsing |
   ScalarTraits< StringValue > | |
   FlowStringValue | |
   ScalarTraits< FlowStringValue > | |
   VirtualRegisterDefinition | |
   MappingTraits< VirtualRegisterDefinition > | |
   MachineBasicBlock | |
   MappingTraits< MachineBasicBlock > | |
   MachineStackObject | Serializable representation of stack object from the MachineFrameInfo class |
   ScalarEnumerationTraits< MachineStackObject::ObjectType > | |
   MappingTraits< MachineStackObject > | |
   FixedMachineStackObject | Serializable representation of the fixed stack object from the MachineFrameInfo class |
   ScalarEnumerationTraits< FixedMachineStackObject::ObjectType > | |
   MappingTraits< FixedMachineStackObject > | |
   MachineFrameInfo | Serializable representation of MachineFrameInfo |
   MappingTraits< MachineFrameInfo > | |
   MachineFunction | |
   MappingTraits< MachineFunction > | |
   BinaryRef | Specialized YAMLIO scalar type for representing a binary blob |
   ScalarTraits< BinaryRef > | |
   ScalarEnumerationTraits< COFFYAML::WeakExternalCharacteristics > | |
   ScalarEnumerationTraits< COFFYAML::AuxSymbolType > | |
   ScalarEnumerationTraits< COFFYAML::COMDATType > | |
   ScalarEnumerationTraits< COFF::MachineTypes > | |
   ScalarEnumerationTraits< COFF::SymbolBaseType > | |
   ScalarEnumerationTraits< COFF::SymbolStorageClass > | |
   ScalarEnumerationTraits< COFF::SymbolComplexType > | |
   ScalarEnumerationTraits< COFF::RelocationTypeI386 > | |
   ScalarEnumerationTraits< COFF::RelocationTypeAMD64 > | |
   ScalarEnumerationTraits< COFF::WindowsSubsystem > | |
   ScalarBitSetTraits< COFF::Characteristics > | |
   ScalarBitSetTraits< COFF::SectionCharacteristics > | |
   ScalarBitSetTraits< COFF::DLLCharacteristics > | |
   MappingTraits< COFFYAML::Relocation > | |
   MappingTraits< COFFYAML::PEHeader > | |
   MappingTraits< COFF::DataDirectory > | |
   MappingTraits< COFF::header > | |
   MappingTraits< COFF::AuxiliaryFunctionDefinition > | |
   MappingTraits< COFF::AuxiliarybfAndefSymbol > | |
   MappingTraits< COFF::AuxiliaryWeakExternal > | |
   MappingTraits< COFF::AuxiliarySectionDefinition > | |
   MappingTraits< COFF::AuxiliaryCLRToken > | |
   MappingTraits< COFFYAML::Symbol > | |
   MappingTraits< COFFYAML::Section > | |
   MappingTraits< COFFYAML::Object > | |
   ScalarEnumerationTraits< ELFYAML::ELF_ET > | |
   ScalarEnumerationTraits< ELFYAML::ELF_EM > | |
   ScalarEnumerationTraits< ELFYAML::ELF_ELFCLASS > | |
   ScalarEnumerationTraits< ELFYAML::ELF_ELFDATA > | |
   ScalarEnumerationTraits< ELFYAML::ELF_ELFOSABI > | |
   ScalarBitSetTraits< ELFYAML::ELF_EF > | |
   ScalarEnumerationTraits< ELFYAML::ELF_SHT > | |
   ScalarBitSetTraits< ELFYAML::ELF_SHF > | |
   ScalarEnumerationTraits< ELFYAML::ELF_STT > | |
   ScalarEnumerationTraits< ELFYAML::ELF_STV > | |
   ScalarBitSetTraits< ELFYAML::ELF_STO > | |
   ScalarEnumerationTraits< ELFYAML::ELF_REL > | |
   ScalarEnumerationTraits< ELFYAML::ELF_RSS > | |
   ScalarEnumerationTraits< ELFYAML::MIPS_AFL_REG > | |
   ScalarEnumerationTraits< ELFYAML::MIPS_ABI_FP > | |
   ScalarEnumerationTraits< ELFYAML::MIPS_AFL_EXT > | |
   ScalarEnumerationTraits< ELFYAML::MIPS_ISA > | |
   ScalarBitSetTraits< ELFYAML::MIPS_AFL_ASE > | |
   ScalarBitSetTraits< ELFYAML::MIPS_AFL_FLAGS1 > | |
   MappingTraits< ELFYAML::FileHeader > | |
   MappingTraits< ELFYAML::Symbol > | |
   MappingTraits< ELFYAML::LocalGlobalWeakSymbols > | |
   MappingTraits< ELFYAML::Relocation > | |
   MappingTraits< std::unique_ptr< ELFYAML::Section > > | |
   MappingTraits< ELFYAML::Object > | |
   MappingTraits< ELFYAML::SectionOrType > | |
   Stream | This class represents a YAML stream potentially containing multiple documents |
   Node | Abstract base class for all Nodes |
   NullNode | A null value |
   ScalarNode | A scalar node is an opaque datum that can be presented as a series of zero or more Unicode scalar values |
   BlockScalarNode | A block scalar node is an opaque datum that can be presented as a series of zero or more Unicode scalar values |
   KeyValueNode | A key and value pair |
   basic_collection_iterator | This is an iterator abstraction over YAML collections shared by both sequences and maps |
   MappingNode | Represents a YAML map created from either a block map for a flow map |
   SequenceNode | Represents a YAML sequence created from either a block sequence for a flow sequence |
   AliasNode | Represents an alias to a Node with an anchor |
   Document | A YAML Stream is a sequence of Documents |
   document_iterator | Iterator abstraction for Documents over a Stream |
   MappingTraits | This class should be specialized by any type that needs to be converted to/from a YAML mapping |
   ScalarEnumerationTraits | 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 |
   ScalarBitSetTraits | 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 |
   ScalarTraits | This class should be specialized by type that requires custom conversion to/from a yaml scalar |
   BlockScalarTraits | This class should be specialized by type that requires custom conversion to/from a YAML literal block scalar |
   SequenceTraits | This class should be specialized by any type that needs to be converted to/from a YAML sequence |
   DocumentListTraits | This class should be specialized by any type that needs to be converted to/from a list of YAML documents |
   SameType | |
   MissingTrait | |
   has_ScalarEnumerationTraits | |
   has_ScalarBitSetTraits | |
   has_ScalarTraits | |
   has_BlockScalarTraits | |
   has_MappingTraits | |
   has_MappingValidateTraits | |
   has_SequenceMethodTraits | |
   has_FlowTraits | |
   has_FlowTraits< T, true > | |
    Derived | |
    Fallback | |
   has_SequenceTraits | |
   has_DocumentListTraits | |
   missingTraits | |
   validatedMappingTraits | |
   unvalidatedMappingTraits | |
   IO | |
   ScalarTraits< bool > | |
   ScalarTraits< StringRef > | |
   ScalarTraits< std::string > | |
   ScalarTraits< uint8_t > | |
   ScalarTraits< uint16_t > | |
   ScalarTraits< uint32_t > | |
   ScalarTraits< uint64_t > | |
   ScalarTraits< int8_t > | |
   ScalarTraits< int16_t > | |
   ScalarTraits< int32_t > | |
   ScalarTraits< int64_t > | |
   ScalarTraits< float > | |
   ScalarTraits< double > | |
   MappingNormalization | |
   MappingNormalizationHeap | |
   Input | Used to parse a yaml document into in-memory structs and vectors |
   Output | Used to generate a yaml document from in-memory structs and vectors |
   ScalarTraits< Hex8 > | Use these types instead of uintXX_t in any mapping to have its yaml output formatted as hexadecimal |
   ScalarTraits< Hex16 > | |
   ScalarTraits< Hex32 > | |
   ScalarTraits< Hex64 > | |
   BlockScalarTraits< Module > | This struct serializes the LLVM IR module |
   Token | Token - A single YAML token |
   Scanner | Scans YAML tokens from a MemoryBuffer |
  zlib | |
  APFloat | A self-contained host- and target-independent arbitrary-precision floating-point software implementation |
  SmallVectorImpl | This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter |
  APInt | Class for arbitrary precision integers |
   ms | Magic data for optimising signed division by a constant |
   mu | Magic data for optimising unsigned division by a constant |
  APSInt | |
  ArrayRef | ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory), i.e |
  MutableArrayRef | MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memory), i.e |
  isPodLike | 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 |
  isPodLike< ArrayRef< T > > | |
  BitVector | |
   reference | |
  DAGDeltaAlgorithm | DAGDeltaAlgorithm - Implements a "delta debugging" algorithm for minimizing directed acyclic graphs using a predicate function |
  DeltaAlgorithm | DeltaAlgorithm - Implements the delta debugging algorithm (A |
  DenseMapIterator | |
  DenseMapBase | |
  DenseMap | |
  SmallDenseMap | |
  DenseMapInfo | |
  DenseMapInfo< T * > | |
  DenseMapInfo< char > | |
  DenseMapInfo< unsigned > | |
  DenseMapInfo< unsigned long > | |
  DenseMapInfo< unsigned long long > | |
  DenseMapInfo< int > | |
  DenseMapInfo< long > | |
  DenseMapInfo< long long > | |
  DenseMapInfo< std::pair< T, U > > | |
  DenseMapInfo< StringRef > | |
  DenseSet | DenseSet - This implements a dense probed hash-table based set |
   ConstIterator | |
   Iterator | |
  df_iterator_storage | |
  df_iterator_storage< SetType, true > | |
  df_iterator | |
  df_ext_iterator | |
  idf_iterator | |
  idf_ext_iterator | |
  DebugEpochBase | |
   HandleBase | |
  EquivalenceClasses | 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 |
   member_iterator | |
  FoldingSetImpl | FoldingSetImpl - Implements the folding set functionality |
   Node | Node - This class is used to maintain the singly linked bucket list in a folding set |
  FoldingSetTrait | FoldingSetTrait - This trait class is used to define behavior of how to "profile" (in the FoldingSet parlance) an object of a given type |
  DefaultFoldingSetTrait | DefaultFoldingSetTrait - This class provides default implementations for FoldingSetTrait implementations |
  ContextualFoldingSetTrait | ContextualFoldingSetTrait - Like FoldingSetTrait, but for ContextualFoldingSets |
  DefaultContextualFoldingSetTrait | DefaultContextualFoldingSetTrait - Like DefaultFoldingSetTrait, but for ContextualFoldingSets |
  FoldingSetNodeIDRef | FoldingSetNodeIDRef - 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 |
  FoldingSetNodeID | FoldingSetNodeID - This class is used to gather all the unique data bits of a node |
  FoldingSetIterator | |
  FoldingSetBucketIterator | |
  FoldingSet | FoldingSet - This template class is used to instantiate a specialized implementation of the folding set to the node class T |
  ContextualFoldingSet | ContextualFoldingSet - This template class is a further refinement of FoldingSet which provides a context argument when calling Profile on its nodes |
  FoldingSetVector | 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 |
  FoldingSetIteratorImpl | FoldingSetIteratorImpl - This is the common iterator support shared by all folding sets, which knows how to walk the folding set hash table |
  FoldingSetBucketIteratorImpl | FoldingSetBucketIteratorImpl - 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 |
  FoldingSetNodeWrapper | FoldingSetNodeWrapper - This template class is used to "wrap" arbitrary types in an enclosing object so that they can be inserted into FoldingSets |
  FastFoldingSetNode | FastFoldingSetNode - This is a subclass of FoldingSetNode which stores a FoldingSetNodeID value rather than requiring the node to recompute it each time it is needed |
  FoldingSetTrait< T * > | |
  FoldingSetTrait< std::pair< T1, T2 > > | |
  GraphTraits | DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterators |
  Inverse | |
  GraphTraits< Inverse< Inverse< T > > > | |
  hash_code | An opaque object representing a hash code |
  iplist | Iplist - The subset of list functionality that can safely be used on nodes of polymorphic types, i.e |
  ilist_iterator | |
  ilist_nextprev_traits | Ilist_nextprev_traits - A fragment for template traits for intrusive list that provides default next/prev implementations for common operations |
  ilist_traits | |
  ilist_sentinel_traits | Ilist_sentinel_traits - A fragment for template traits for intrusive list that provides default sentinel implementations for common operations |
  ilist_node_traits | Ilist_node_traits - A fragment for template traits for intrusive list that provides default node related operations |
  ilist_default_traits | Ilist_default_traits - Default template traits for intrusive list |
  ilist_traits< const Ty > | |
  simplify_type | |
  simplify_type< ilist_iterator< NodeTy > > | |
  simplify_type< const ilist_iterator< NodeTy > > | |
  ilist | |
  ilist_half_node | Ilist_half_node - Base class that provides prev services for sentinels |
  ilist_node | Ilist_node - Base class that provides next/prev services for nodes that use ilist_nextprev_traits or ilist_default_traits |
  ImmutableListFactory | |
  ImmutableListImpl | |
  ImmutableList | ImmutableList - This class represents an immutable (functional) list |
   iterator | |
  DenseMapInfo< ImmutableList< T > > | |
  isPodLike< ImmutableList< T > > | |
  ImutKeyValueInfo | ImutKeyValueInfo -Traits class used by ImmutableMap |
  ImmutableMap | |
   Factory | |
   iterator | |
  ImmutableMapRef | |
   iterator | |
  ImutAVLFactory | |
  ImutIntervalAVLFactory | |
  ImutAVLTreeInOrderIterator | |
  ImutAVLTreeGenericIterator | |
  ImutAVLTree | |
  ImutAVLValueIterator | Generic iterator that wraps a T::TreeTy::iterator and exposes iterator::getValue() on dereference |
  ImutProfileInfo | Generic profile template |
  ImutProfileInteger | Profile traits for integers |
  ImutProfileInfo< bool > | Profile traits for booleans |
  ImutProfileInfo< T * > | Generic profile trait for pointer types |
  ImutContainerInfo | 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 |
  ImutContainerInfo< T * > | ImutContainerInfo - Specialization for pointer values to treat pointers as references to unique objects |
  ImmutableSet | |
   Factory | |
  ImmutableSetRef | |
  IndexedMap | |
  IntEqClasses | |
  IntervalMapInfo | |
  IntervalMapHalfOpenInfo | |
  IntervalMap | |
   const_iterator | |
   iterator | |
  IntervalMapOverlaps | IntervalMapOverlaps - Iterate over the overlaps of mapped intervals in two IntervalMaps |
  IntrusiveRefCntPtr | 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 |
  RefCountedBase | RefCountedBase - A generic base class for objects that wish to have their lifetimes managed using reference counts |
  RefCountedBaseVPTR | RefCountedBaseVPTR - A class that has the same function as RefCountedBase, but with a virtual destructor |
  IntrusiveRefCntPtrInfo | |
  ThreadSafeRefCountedBase | A thread-safe version of llvm::RefCountedBase |
  simplify_type< IntrusiveRefCntPtr< T > > | |
  simplify_type< const IntrusiveRefCntPtr< T > > | |
  iterator_facade_base | CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of the interface |
  iterator_adaptor_base | CRTP base class for adapting an iterator to a different type |
  pointee_iterator | An iterator type that allows iterating over the pointees via some other iterator |
  iterator_range | A range adaptor for a pair of iterators |
  MapVector | This class implements a map that also provides access to all stored values in a deterministic order |
  SmallMapVector | A MapVector that performs no allocations if smaller than a certain size |
  Optional | |
  isPodLike< Optional< T > > | |
  PackedVectorBase | |
  PackedVectorBase< T, BitNum, BitVectorTy, false > | |
  PackedVectorBase< T, BitNum, BitVectorTy, true > | |
  PackedVector | Store a vector of values using a specific number of bits for each value |
   reference | |
  PointerIntPair | PointerIntPair - This class implements a pair of a pointer and small integer |
  isPodLike< PointerIntPair< PointerTy, IntBits, IntType > > | |
  DenseMapInfo< PointerIntPair< PointerTy, IntBits, IntType > > | |
  PointerLikeTypeTraits< PointerIntPair< PointerTy, IntBits, IntType, PtrTraits > > | |
  PointerUnionTypeSelectorReturn | |
  PointerUnionTypeSelector | Get a type based on whether two types are the same or not |
  PointerUnionTypeSelector< T, T, RET_EQ, RET_NE > | |
  PointerUnionTypeSelectorReturn< PointerUnionTypeSelector< T1, T2, RET_EQ, RET_NE > > | |
  PointerUnionUIntTraits | Provide PointerLikeTypeTraits for void* that is used by PointerUnion for the two template arguments |
  PointerUnion | PointerUnion - This implements a discriminated union of two pointer types, and keeps the discriminator bit-mangled into the low bits of the pointer |
  PointerLikeTypeTraits< PointerUnion< PT1, PT2 > > | |
  PointerUnion3 | PointerUnion3 - This is a pointer union of three pointer types |
  PointerLikeTypeTraits< PointerUnion3< PT1, PT2, PT3 > > | |
  PointerUnion4 | PointerUnion4 - This is a pointer union of four pointer types |
  PointerLikeTypeTraits< PointerUnion4< PT1, PT2, PT3, PT4 > > | |
  DenseMapInfo< PointerUnion< T, U > > | |
  po_iterator_storage | Default po_iterator_storage implementation with an internal set object |
  po_iterator_storage< SetType, true > | Specialization of po_iterator_storage that references an external set |
  po_iterator | |
  po_ext_iterator | |
  ipo_iterator | |
  ipo_ext_iterator | |
  ReversePostOrderTraversal | |
  PriorityQueue | PriorityQueue - This class behaves like std::priority_queue and provides a few additional convenience functions |
  scc_iterator | Enumerate the SCCs of a directed graph in reverse topological order of the SCC DAG |
  ScopedHashTable | |
  ScopedHashTableVal | |
  ScopedHashTableScope | |
  ScopedHashTableIterator | |
  SetVector | A vector that has set insertion semantics |
  SmallSetVector | A SetVector that performs no allocations if smaller than a certain size |
  SmallBitVector | SmallBitVector - This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is small |
   reference | |
  SmallPtrSetImplBase | SmallPtrSetImplBase - This is the common code shared among all the SmallPtrSet<>'s, which is almost everything |
  SmallPtrSetIteratorImpl | SmallPtrSetIteratorImpl - This is the common base class shared between all instances of SmallPtrSetIterator |
  SmallPtrSetIterator | SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet |
  RoundUpToPowerOfTwo | RoundUpToPowerOfTwo - This is a helper template that rounds N up to the next power of two (which means N itself if N is already a power of two) |
  RoundUpToPowerOfTwoH | RoundUpToPowerOfTwoH - If N is not a power of two, increase it |
  RoundUpToPowerOfTwoH< N, false > | |
  SmallPtrSetImpl | A templated base class for SmallPtrSet which provides the typesafe interface that is common across all small sizes |
  SmallPtrSet | SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements |
  SmallSet | SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less than N) |
  SmallSet< PointeeType *, N > | If this set is of pointer values, transparently switch over to using SmallPtrSet for performance |
  SmallString | SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better as a string (e.g |
  SmallVectorBase | This is all the non-templated stuff common to all SmallVectors |
  SmallVectorStorage | Storage for the SmallVector elements which aren't contained in SmallVectorTemplateCommon |
  SmallVectorTemplateCommon | This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD |
  SmallVectorTemplateBase | SmallVectorTemplateBase<isPodLike = false> - This is where we put method implementations that are designed to work with non-POD-like T's |
  SmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's |
  SmallVectorStorage< T, 1 > | |
  SmallVectorStorage< T, 0 > | |
  SmallVector | This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small |
  SparseBitVectorElement | SparseBitVector is an implementation of a bitvector that is sparse by only storing the elements that have non-zero bits set |
  ilist_traits< SparseBitVectorElement< ElementSize > > | |
  SparseBitVector | |
  SparseMultiSet | Fast multiset implementation for objects that can be identified by small unsigned keys |
   iterator_base | Our iterators are iterators over the collection of objects that share a key |
  SparseSetValTraits | SparseSetValTraits - Objects in a SparseSet are identified by keys that can be uniquely converted to a small integer less than the set's universe |
  SparseSetValFunctor | SparseSetValFunctor - Helper class for selecting SparseSetValTraits |
  SparseSetValFunctor< KeyT, KeyT, KeyFunctorT > | SparseSetValFunctor<KeyT, KeyT> - Helper class for the common case of identity key/value sets |
  SparseSet | SparseSet - Fast set implmentation for objects that can be identified by small unsigned keys |
  Statistic | |
  identity | |
  less_ptr | |
  greater_ptr | |
  function_ref | An efficient, type-erasing, non-owning reference to a callable |
  function_ref< Ret(Params...)> | |
  mapped_iterator | |
  less_first | Function object to check whether the first component of a std::pair compares less than the first component of another std::pair |
  less_second | Function object to check whether the second component of a std::pair compares less than the second component of another std::pair |
  integer_sequence | Represents a compile-time sequence of integers |
  index_sequence | Alias for the common case of a sequence of size_ts |
  build_index_impl | |
  build_index_impl< 0, I...> | |
  index_sequence_for | Creates a compile-time integer sequence for a parameter pack |
  FreeDeleter | |
  pair_hash | |
  less | A functor like C++14's std::less<void> in its absence |
  equal | A functor like C++14's std::equal<void> in its absence |
  deref | Binary functor that adapts to any other binary functor after dereferencing operands |
  StringMapConstIterator | |
  StringMapIterator | |
  StringMapEntry | StringMapEntry - This is used to represent one value that is inserted into a StringMap |
  StringMapEntryBase | StringMapEntryBase - Shared base class of StringMapEntry instances |
  StringMapImpl | StringMapImpl - This is the base class of StringMap that is shared among all of its instantiations |
  StringMap | StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes |
  StringRef | StringRef - Represent a constant reference to a string, i.e |
  isPodLike< StringRef > | |
  StringSet | StringSet - A wrapper for StringMap that provides set-like functionality |
  StringSwitch | A switch()-like statement whose cases are string literals |
  TinyPtrVector | 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 |
  Triple | Triple - Helper class for working with autoconf configuration names |
  Twine | Twine - A lightweight data structure for efficiently representing the concatenation of temporary values as strings |
  UniqueVector | UniqueVector - This class produces a sequential ID number (base 1) for each unique entry that is added |
  VariadicFunction | Class which can simulate a type-safe variadic function |
  VariadicFunction1 | |
  VariadicFunction2 | |
  VariadicFunction3 | |
  AliasAnalysis | |
  AliasSet | |
   iterator | Define an iterator for alias sets... this is just a forward iterator |
  AliasSetTracker | |
  AnalysisManager | A generic analysis pass manager with lazy running and caching of results |
  AssumptionCache | A cache of .assume calls within a function |
  AssumptionAnalysis | A function analysis which provides an AssumptionCache |
  AssumptionPrinterPass | Printer pass for the AssumptionAnalysis results |
  AssumptionCacheTracker | An immutable pass that tracks lazily created AssumptionCache objects |
  BlockFrequencyInfoImpl | Shared implementation for block frequency analysis |
  BlockFrequencyInfo | BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequencies |
  isPodLike< bfi_detail::BlockMass > | |
  BlockFrequencyInfoImplBase | Base class for BlockFrequencyInfoImpl |
   BlockNode | Representative of a block |
   Distribution | Distribution of unscaled probability weight |
   FrequencyData | Stats about a block itself |
   LoopData | Data about a loop |
   Weight | Unscaled probability weight |
   WorkingData | Index of loop information |
  BranchProbabilityInfo | Analysis pass providing branch probability information |
  CallGraph | The basic data container for the call graph of a Module of IR |
  CallGraphNode | A node in the call graph for a module |
  CallGraphAnalysis | An analysis pass to compute the CallGraph for a Module |
  CallGraphWrapperPass | The ModulePass which wraps up a CallGraph and the logic to build it |
  GraphTraits< CallGraphNode * > | |
  GraphTraits< const CallGraphNode * > | |
  GraphTraits< CallGraph * > | |
  GraphTraits< const CallGraph * > | |
  CallGraphSCCPass | |
  CallGraphSCC | CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on |
  CaptureTracker | This callback is used in conjunction with PointerMayBeCaptured |
  DOTGraphTraits< const Function * > | |
  CGSCCAnalysisManagerModuleProxy | A module analysis which acts as a proxy for a CGSCC analysis manager |
   Result | |
  ModuleAnalysisManagerCGSCCProxy | A CGSCC analysis which acts as a proxy for a module analysis manager |
   Result | Result proxy object for ModuleAnalysisManagerCGSCCProxy |
  ModuleToPostOrderCGSCCPassAdaptor | The core module pass which does a post-order walk of the SCCs and runs a CGSCC pass over each one |
  FunctionAnalysisManagerCGSCCProxy | A CGSCC analysis which acts as a proxy for a function analysis manager |
   Result | |
  CGSCCAnalysisManagerFunctionProxy | A function analysis which acts as a proxy for a CGSCC analysis manager |
   Result | Result proxy object for ModuleAnalysisManagerFunctionProxy |
  CGSCCToFunctionPassAdaptor | Adaptor that maps from a SCC to its functions |
  CodeMetrics | Utility to calculate the size and a few similar metrics for a set of basic blocks |
  Dependence | Dependence - This class represents a dependence between two memory memory references in a function |
   DVEntry | Dependence::DVEntry - Each level in the distance/direction vector has a direction (or perhaps a union of several directions), and perhaps a distance |
  FullDependence | FullDependence - This class represents a dependence between two memory references in a function |
  DependenceAnalysis | DependenceAnalysis - This class is the main dependence-analysis driver |
  DominanceFrontierBase | DominanceFrontierBase - Common base class for computing forward and inverse dominance frontiers for a function |
  ForwardDominanceFrontierBase | DominanceFrontier Class - Concrete subclass of DominanceFrontierBase that is used to compute a forward dominator frontiers |
  DominanceFrontier | |
  DFCalculateWorkObject | |
  DefaultAnalysisGraphTraits | Default traits class for extracting a graph from an analysis pass |
  DOTGraphTraitsViewer | |
  DOTGraphTraitsPrinter | |
  DOTGraphTraitsModuleViewer | |
  DOTGraphTraitsModulePrinter | |
  InlineCost | Represents the cost of inlining a function |
  InlineCostAnalysis | Cost analyzer used by inliner |
  Interval | Interval 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) |
  GraphTraits< Interval * > | |
  GraphTraits< Inverse< Interval * > > | |
  IntervalIterator | |
  IntervalPartition | |
  DomTreeNodeBase | Base class for the actual dominator tree node |
  IDFCalculator | Determine the iterated dominance frontier, given a set of defining blocks, and optionally, a set of live-in blocks |
  IVStrideUse | IVStrideUse - Keep track of one use of a strided induction variable |
  ilist_traits< IVStrideUse > | |
  IVUsers | |
  LazyCallGraph | A lazily constructed view of the call graph of a module |
   iterator | A lazy iterator used for both the entry nodes and child nodes |
   Node | A node in the call graph |
   postorder_scc_iterator | A post-order depth-first SCC iterator over the call graph |
   SCC | An SCC of the call graph |
  GraphTraits< LazyCallGraph::Node * > | |
  GraphTraits< LazyCallGraph * > | |
  LazyCallGraphAnalysis | An analysis pass which computes the call graph for a module |
  LazyCallGraphPrinterPass | A pass which prints the call graph to a raw_ostream |
  LazyValueInfo | This pass computes, caches, and vends lazy value constraint information |
  LibCallAliasAnalysis | LibCallAliasAnalysis - Alias analysis driven from LibCallInfo |
  LibCallLocationInfo | LibCallLocationInfo - This struct describes a set of memory locations that are accessed by libcalls |
  LibCallFunctionInfo | LibCallFunctionInfo - Each record in the array of FunctionInfo structs records the behavior of one libcall that is known by the optimizer |
   LocationMRInfo | LocationMRInfo - This pair captures info about whether a specific location is modified or referenced by a libcall |
  LibCallInfo | LibCallInfo - Abstract interface to query about library call information |
  LoopAccessReport | Optimization analysis message produced during vectorization |
  VectorizerParams | Collection of parameters shared beetween the Loop Vectorizer and the Loop Access Analysis |
  MemoryDepChecker | Checks memory dependences among accesses to the same underlying object to determine whether there vectorization is legal or not (and at which vectorization factor) |
   Dependence | Dependece between memory access instructions |
  RuntimePointerChecking | Holds information about the memory runtime legality checks to verify that a group of pointers do not overlap |
   CheckingPtrGroup | A grouping of pointers |
   PointerInfo | |
  LoopAccessInfo | Drive the analysis of memory accesses in the loop |
  LoopAccessAnalysis | This analysis provides dependence information for the memory accesses of a loop |
  DominatorTreeBase | Core dominator tree base class |
   InfoRec | |
  LoopInfoBase | LoopInfo - This class builds and contains all of the top level loop structures in the specified function |
  LoopBase | LoopBase class - Instances of this class are used to represent loops that are detected in the flow graph |
  Loop | |
  LoopInfo | |
  GraphTraits< const Loop * > | |
  GraphTraits< Loop * > | |
  LoopAnalysis | Analysis pass that exposes the LoopInfo for a function |
  LoopPrinterPass | Printer pass for the LoopAnalysis results |
  LoopInfoWrapperPass | The legacy pass manager's analysis pass to compute loop information |
  PopulateLoopsDFS | Populate all loop data in a stable order during a single forward DFS |
  LoopBlocksDFS | Store the result of a depth first search within basic blocks contained by a single loop |
  po_iterator_storage< LoopBlocksTraversal, true > | Specialize po_iterator_storage to record postorder numbers |
  LoopBlocksTraversal | Traverse the blocks in a loop using a depth-first search |
  LoopPass | |
  LPPassManager | |
  ObjectSizeOffsetVisitor | Evaluate the size and offset of an object pointed to by a Value* statically |
  ObjectSizeOffsetEvaluator | Evaluate the size and offset of an object pointed to by a Value* |
  MemDepResult | MemDepResult - A memory dependence query can return one of three different answers, described below |
  NonLocalDepEntry | NonLocalDepEntry - This is an entry in the NonLocalDepInfo cache |
  NonLocalDepResult | NonLocalDepResult - This is a result from a NonLocal dependence query |
  MemoryDependenceAnalysis | MemoryDependenceAnalysis - This is an analysis that determines, for a given memory operation, what preceding memory operations it depends on |
  MemoryLocation | Representation for a specific memory location |
  DenseMapInfo< MemoryLocation > | |
  PHITransAddr | PHITransAddr - An address value which tracks and handles phi translation |
  PostDominatorTree | PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominator tree |
  GraphTraits< PostDominatorTree * > | |
  PtrUseVisitor | A base class for visitors over the uses of a pointer value |
  RegionTraits | |
  RegionBase | A single entry single exit Region |
   block_iterator_wrapper | |
  RegionInfoBase | Analysis that detects all canonical Regions |
  RegionTraits< Function > | |
  FlatIt | Marker class to iterate over the elements of a Region in flat mode |
  RegionNodeBase | A RegionNode represents a subregion or a BasicBlock that is part of a Region |
  RegionNode | |
  Region | |
  RegionInfo | |
  RegionInfoPass | |
  RNSuccIterator | Hierarchical RegionNode successor iterator |
  RNSuccIterator< FlatIt< NodeType >, BlockT, RegionT > | Flat RegionNode iterator |
  GraphTraits< RegionInfo * > | |
  GraphTraits< RegionInfoPass * > | |
  RegionPass | A pass that runs on each Region in a function |
  RGPassManager | The pass manager to schedule RegionPasses |
  SCEV | SCEV - This class represents an analyzed expression in the program |
  FoldingSetTrait< SCEV > | |
  SCEVCouldNotCompute | SCEVCouldNotCompute - An object of this class is returned by queries that could not be answered |
  ScalarEvolution | ScalarEvolution - This class is the main scalar evolution driver |
  SCEVExpander | This class uses information about analyze scalars to rewrite expressions in canonical form |
  SCEVConstant | SCEVConstant - This class represents a constant integer value |
  SCEVCastExpr | SCEVCastExpr - This is the base class for unary cast operator classes |
  SCEVTruncateExpr | SCEVTruncateExpr - This class represents a truncation of an integer value to a smaller integer value |
  SCEVZeroExtendExpr | SCEVZeroExtendExpr - This class represents a zero extension of a small integer value to a larger integer value |
  SCEVSignExtendExpr | SCEVSignExtendExpr - This class represents a sign extension of a small integer value to a larger integer value |
  SCEVNAryExpr | SCEVNAryExpr - This node is a base class providing common functionality for n'ary operators |
  SCEVCommutativeExpr | SCEVCommutativeExpr - This node is the base class for n'ary commutative operators |
  SCEVAddExpr | SCEVAddExpr - This node represents an addition of some number of SCEVs |
  SCEVMulExpr | SCEVMulExpr - This node represents multiplication of some number of SCEVs |
  SCEVUDivExpr | SCEVUDivExpr - This class represents a binary unsigned division operation |
  SCEVAddRecExpr | SCEVAddRecExpr - This node represents a polynomial recurrence on the trip count of the specified loop |
  SCEVSMaxExpr | SCEVSMaxExpr - This class represents a signed maximum selection |
  SCEVUMaxExpr | SCEVUMaxExpr - This class represents an unsigned maximum selection |
  SCEVUnknown | SCEVUnknown - This means that we are dealing with an entirely unknown SCEV value, and only represent it as its LLVM Value |
  SCEVVisitor | SCEVVisitor - This class defines a simple visitor class that may be used for various SCEV analysis purposes |
  SCEVTraversal | Visit all nodes in the expression tree using worklist traversal |
  SCEVParameterRewriter | The SCEVParameterRewriter takes a scalar evolution expression and updates the SCEVUnknown components following the Map (Value -> Value) |
  SCEVApplyRewriter | The SCEVApplyRewriter takes a scalar evolution expression and applies the Map (Loop -> SCEV) to all AddRecExprs |
  AbstractLatticeFunction | AbstractLatticeFunction - This class is implemented by the dataflow instance to specify what the lattice values are and how they handle merges etc |
  SparseSolver | SparseSolver - This class is a general purpose solver for Sparse Conditional Propagation with a programmable lattice function |
  TargetFolder | TargetFolder - Create constants with target dependent folding |
  VecDesc | VecDesc - Describes a possible vectorization of a function |
  TargetLibraryInfoImpl | Implementation of the target library information |
  TargetLibraryInfo | Provides information about what library functions are available for the current target |
  TargetLibraryAnalysis | Analysis pass providing the TargetLibraryInfo |
  TargetLibraryInfoWrapperPass | |
  MemIntrinsicInfo | Information about a load/store intrinsic defined by the target |
  TargetTransformInfo | This pass provides access to the codegen interfaces that are needed for IR-level transformations |
   Concept | |
   UnrollingPreferences | Parameters that control the generic loop unrolling transformation |
  TargetIRAnalysis | Analysis pass providing the TargetTransformInfo |
  TargetTransformInfoWrapperPass | Wrapper pass for TargetTransformInfo |
  TargetTransformInfoImplBase | Base class for use as a mix-in that aids implementing a TargetTransformInfo-compatible class |
  TargetTransformInfoImplCRTPBase | CRTP base class for use as a mix-in that aids implementing a TargetTransformInfo-compatible class |
  Trace | |
  SlotMapping | This struct contains the mapping from the slot numbers to unnamed metadata nodes and global values |
  BitCodeAbbrevOp | BitCodeAbbrevOp - This describes one or more operands in an abbreviation |
  isPodLike< BitCodeAbbrevOp > | |
  BitCodeAbbrev | BitCodeAbbrev - This class represents an abbreviation record |
  BitcodeWriterPass | Pass for writing a module of IR out to a bitcode file |
  BitstreamReader | This class is used to read from an LLVM bitcode stream, maintaining information that is global to decoding the entire file |
   BlockInfo | This contains information emitted to BLOCKINFO_BLOCK blocks |
  BitstreamEntry | When advancing through a bitstream cursor, each advance can discover a few different kinds of entries: |
  BitstreamCursor | This represents a position within a bitcode file |
  BitstreamWriter | |
  BitcodeDiagnosticInfo | |
  AsmPrinter | This class is intended to be used as a driving class for all asm writers |
  BasicTTIImplBase | Base class which can be used to help build a TTI implementation |
  BasicTTIImpl | Concrete BasicTTIImpl that can be used if no further customization is needed |
  VirtRegAuxInfo | Calculate auxiliary information for a virtual register such as its spill weight and allocation hint |
  CCValAssign | CCValAssign - Represent assignment of one arg/retval to a location |
  ForwardedRegister | Describes a register that needs to be forwarded from the prologue to a musttail call |
  CCState | CCState - This class holds information needed while lowering arguments and return values |
  DFAPacketizer | |
  VLIWPacketizerList | |
  DIEAbbrevData | DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation |
  DIEAbbrev | DIEAbbrev - Dwarf abbreviation, describes the organization of a debug information object |
  DIEInteger | DIEInteger - An integer value DIE |
  DIEExpr | DIEExpr - An expression DIE |
  DIELabel | DIELabel - A label DIE |
  DIEDelta | DIEDelta - A simple label difference DIE |
  DIEString | DIEString - A container for string values |
  DIEEntry | |
  DIETypeSignature | A signature reference to a type unit |
  DIELocList | DIELocList - Represents a pointer to a location list in the debug_loc section |
  DIEValue | |
  IntrusiveBackListNode | |
  IntrusiveBackListBase | |
  IntrusiveBackList | |
   const_iterator | |
   iterator | |
  DIEValueList | A list of DIE values |
   const_iterator | |
   iterator | |
  DIE | DIE - A structured debug information entry |
  DIELoc | DIELoc - Represents an expression location |
  DIEBlock | DIEBlock - Represents a block of values |
  DwarfStringPoolEntry | Data for a string pool entry |
  DwarfStringPoolEntryRef | String pool entry reference |
  EdgeBundles | |
  FastISel | This is a fast-path instruction selection class that generates poor code and doesn't support illegal types or non-trivial lowering, but runs quickly |
   ArgListEntry | |
   CallLoweringInfo | |
   SavePoint | |
  FaultMaps | |
  FaultMapParser | A parser for the __llvm_faultmaps section generated by the FaultMaps class above |
   FunctionFaultInfoAccessor | |
   FunctionInfoAccessor | |
  FunctionLoweringInfo | FunctionLoweringInfo - This contains information that is global to a function that is used when lowering a region of the function |
   LiveOutInfo | |
  GCPoint | GCPoint - Metadata for a collector-safe point in machine code |
  GCRoot | GCRoot - Metadata for a pointer to an object managed by the garbage collector |
  GCFunctionInfo | Garbage collection metadata for a single function |
  GCModuleInfo | An analysis pass which caches information about the entire Module |
  GCMetadataPrinter | GCMetadataPrinter - Emits GC metadata as assembly code |
  GCStrategy | GCStrategy describes a garbage collector algorithm's code generation requirements, and provides overridable hooks for those needs which cannot be abstractly described |
  IntrinsicLowering | |
  latency_sort | Sorting functions for the Available queue |
  LatencyPriorityQueue | |
  LexicalScope | LexicalScope - This class is used to track scope information |
  LexicalScopes | LexicalScopes - This class provides interface to collect and use lexical scoping information from machine instruction |
  VNInfo | VNInfo - Value Number Information |
  LiveQueryResult | Result of a LiveRange query |
  LiveRange | This class represents the liveness of a register, stack slot, etc |
   Segment | This represents a simple continuous liveness interval for a value |
  LiveInterval | LiveInterval - This class represents the liveness of a register, or stack slot |
   SingleLinkedListIterator | |
   SubRange | A live range for subregisters |
  LiveRangeUpdater | Helper class for performant LiveRange bulk updates |
  ConnectedVNInfoEqClasses | ConnectedVNInfoEqClasses - Helper class that can divide VNInfos in a LiveInterval into equivalence clases of connected components |
  LiveIntervals | |
   HMEditor | |
  LiveIntervalUnion | Union of live intervals that are strong candidates for coalescing into a single register (either physical or virtual depending on the context) |
   Array | |
   Query | Query interferences between a single live virtual register and a live interval union |
  LivePhysRegs | A set of live physical registers with functions to track liveness when walking backward/forward through a basic block |
  LiveRangeEdit | |
   Delegate | Callback methods for LiveRangeEdit owners |
   Remat | Remat - Information needed to rematerialize at a specific location |
  LiveRegMatrix | |
  LiveStacks | |
  LiveVariables | |
   VarInfo | VarInfo - This represents the regions where a virtual register is live in the program |
  ilist_traits< MachineInstr > | |
  MachineBasicBlock | |
   bundle_iterator | Bundle_iterator - MachineBasicBlock iterator that automatically skips over MIs that are inside bundles (i.e |
  MBB2NumberFunctor | |
  GraphTraits< MachineBasicBlock * > | |
  GraphTraits< const MachineBasicBlock * > | |
  GraphTraits< Inverse< MachineBasicBlock * > > | |
  GraphTraits< Inverse< const MachineBasicBlock * > > | |
  MachineInstrSpan | MachineInstrSpan 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 |
  MachineBlockFrequencyInfo | MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic block frequencies |
  MachineBranchProbabilityInfo | |
  MachineConstantPoolValue | Abstract base class for all machine specific constantpool value subclasses |
  MachineConstantPoolEntry | This class is a data container for one entry in a MachineConstantPool |
  MachineConstantPool | Keeps track of constants referenced by a function which must be spilled to memory |
  MachineDominanceFrontier | |
  MachineDominatorTree | DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree |
  GraphTraits< MachineDomTreeNode * > | |
  GraphTraits< MachineDominatorTree * > | |
  CalleeSavedInfo | Tracks the information need to locate where a callee saved register is in the current frame |
  MachineFrameInfo | Abstract stack frame until prolog/epilog code is inserted |
  ilist_traits< MachineBasicBlock > | |
  MachineFunctionInfo | MachineFunctionInfo - This class can be derived from and used by targets to hold private target-specific information for each MachineFunction |
  MachineFunction | |
  GraphTraits< MachineFunction * > | |
  GraphTraits< const MachineFunction * > | |
  GraphTraits< Inverse< MachineFunction * > > | |
  GraphTraits< Inverse< const MachineFunction * > > | |
  MachineFunctionAnalysis | MachineFunctionAnalysis - This class is a Pass that manages a MachineFunction object |
  MachineFunctionInitializer | This interface provides a way to initialize machine functions after they are created by the machine function analysis pass |
  MachineFunctionPass | MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of passes that operate on the MachineFunction representation |
  MachineInstr | Representation of each machine instruction |
  MachineInstrExpressionTrait | Special DenseMapInfo traits to compare MachineInstr* by value of the instruction rather than by pointer value |
  MachineInstrBuilder | |
  MIBundleBuilder | Helper class for constructing bundles of MachineInstrs |
  MachineOperandIteratorBase | MachineOperandIteratorBase - Iterator that can visit all operands on a MachineInstr, or all operands on a bundle of MachineInstrs |
   PhysRegInfo | PhysRegInfo - Information about a physical register used by a set of operands |
   VirtRegInfo | VirtRegInfo - Information about a virtual register used by a set of operands |
  MIOperands | MIOperands - Iterate over operands of a single instruction |
  ConstMIOperands | ConstMIOperands - Iterate over operands of a single const instruction |
  MIBundleOperands | MIBundleOperands - Iterate over all operands in a bundle of machine instructions |
  ConstMIBundleOperands | ConstMIBundleOperands - Iterate over all operands in a const bundle of machine instructions |
  MachineJumpTableEntry | MachineJumpTableEntry - One jump table in the jump table info |
  MachineJumpTableInfo | |
  MachineLoop | |
  MachineLoopInfo | |
  GraphTraits< const MachineLoop * > | |
  GraphTraits< MachineLoop * > | |
  MachinePointerInfo | MachinePointerInfo - 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 |
  MachineMemOperand | MachineMemOperand - A description of a memory reference used in the backend |
  SEHHandler | |
  LandingPadInfo | LandingPadInfo - This structure is used to retain landing pad info for the current function |
  MachineModuleInfoImpl | MachineModuleInfoImpl - This class can be derived from and used by targets to hold private target-specific information for each Module |
  MachineModuleInfo | MachineModuleInfo - This class contains meta information specific to a module |
   VariableDbgInfo | |
  MachineModuleInfoMachO | MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets |
  MachineModuleInfoELF | MachineModuleInfoELF - This is a MachineModuleInfoImpl implementation for ELF targets |
  MachineOperand | MachineOperand class - Representation of each machine instruction operand |
  MachinePassRegistryListener | MachinePassRegistryListener - Listener to adds and removals of nodes in registration list |
  MachinePassRegistryNode | MachinePassRegistryNode - Machine pass node stored in registration list |
  MachinePassRegistry | MachinePassRegistry - Track the registration of machine passes |
  RegisterPassParser | RegisterPassParser class - Handle the addition of new machine passes |
  MachinePostDominatorTree | PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominator tree |
  RegionTraits< MachineFunction > | |
  MachineRegionNode | |
  MachineRegion | |
  MachineRegionInfo | |
  MachineRegionInfoPass | |
  GraphTraits< MachineRegionInfo * > | |
  GraphTraits< MachineRegionInfoPass * > | |
  MachineRegisterInfo | MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc |
   defusechain_instr_iterator | Defusechain_iterator - This class provides iterator support for machine operands in the function that use or define a specific register |
   defusechain_iterator | Reg_begin/reg_end - Provide iteration support to walk over all definitions and uses of a register within the MachineFunction that corresponds to this MachineRegisterInfo object |
   Delegate | |
  PSetIterator | Iterate over the pressure sets affected by the given physical or virtual register |
  MachineSchedContext | MachineSchedContext provides enough context from the MachineScheduler pass for the target to instantiate a scheduler |
  MachineSchedRegistry | MachineSchedRegistry provides a selection of available machine instruction schedulers |
  MachineSchedPolicy | Define a generic scheduling policy for targets that don't provide their own MachineSchedStrategy |
  MachineSchedStrategy | MachineSchedStrategy - Interface to the scheduling algorithm used by ScheduleDAGMI |
  ScheduleDAGMutation | Mutate the DAG as a postpass after normal DAG building |
  ScheduleDAGMI | ScheduleDAGMI is an implementation of ScheduleDAGInstrs that simply schedules machine instructions according to the given MachineSchedStrategy without much extra book-keeping |
  ScheduleDAGMILive | ScheduleDAGMILive is an implementation of ScheduleDAGInstrs that schedules machine instructions while updating LiveIntervals and tracking regpressure |
  ReadyQueue | Helpers for implementing custom MachineSchedStrategy classes |
  SchedRemainder | Summarize the unscheduled region |
  SchedBoundary | Each Scheduling boundary is associated with ready queues |
  GenericSchedulerBase | Base class for GenericScheduler |
   CandPolicy | Policy for scheduling the next instruction in the candidate's zone |
   SchedCandidate | Store the state used by GenericScheduler heuristics, required for the lifetime of one invocation of pickNode() |
   SchedResourceDelta | Status of an instruction's critical resource consumption |
  GenericScheduler | GenericScheduler shrinks the unscheduled zone using heuristics to balance the schedule |
  PostGenericScheduler | PostGenericScheduler - Interface to the scheduling algorithm used by ScheduleDAGMI |
  SSAUpdaterTraits | |
  MachineSSAUpdater | MachineSSAUpdater - This class updates SSA form for a set of virtual registers defined in multiple blocks |
  MachineTraceMetrics | |
   Ensemble | A trace ensemble is a collection of traces selected using the same strategy, for example 'minimum resource height' |
   FixedBlockInfo | Per-basic block information that doesn't depend on the trace through the block |
   InstrCycles | InstrCycles represents the cycle height and depth of an instruction in a trace |
   LiveInReg | A virtual register or regunit required by a basic block or its trace successors |
   Trace | A trace represents a plausible sequence of executed basic blocks that passes through the current basic block one |
   TraceBlockInfo | Per-basic block information that relates to a specific trace through the block |
  MVT | MVT - Machine Value Type |
  MachORelocation | MachORelocation - This struct contains information about each relocation that needs to be emitted to the file |
  MIRParser | This class initializes machine functions by applying the state loaded from a MIR file |
  IdentifyingPassPtr | Discriminated union of Pass ID types |
  isPodLike< IdentifyingPassPtr > | |
  TargetPassConfig | Target-Independent Code Generator Pass Configuration Options |
  PBQPRAConstraint | Abstract base for classes implementing PBQP register allocation constraints (e.g |
  PBQPRAConstraintList | PBQP register allocation constraint composer |
  PseudoSourceValue | PseudoSourceValue - Special value supplied for machine level alias analysis |
  FixedStackPseudoSourceValue | FixedStackPseudoSourceValue - A specialized PseudoSourceValue for holding FixedStack values, which must include a frame index |
  RegisterRegAlloc | RegisterRegAlloc class - Track the registration of register allocators |
  RegisterClassInfo | |
  RegisterPressure | Base class for register pressure results |
  IntervalPressure | RegisterPressure computed within a region of instructions delimited by TopIdx and BottomIdx |
  RegionPressure | RegisterPressure computed within a region of instructions delimited by TopPos and BottomPos |
  PressureChange | Capture a change in pressure for a single pressure set |
  isPodLike< PressureChange > | |
  PressureDiff | List of PressureChanges in order of increasing, unique PSetID |
  PressureDiffs | Array of PressureDiffs |
  RegPressureDelta | Store the effects of a change in pressure on things that MI scheduler cares about |
  LiveRegSet | A set of live virtual registers and physical register units |
  RegPressureTracker | Track the current register pressure at some position in the instruction stream, and remember the high water mark within the region traversed |
  RegScavenger | |
  resource_sort | Sorting functions for the Available queue |
  ResourcePriorityQueue | |
  GraphWriter | |
  SDep | SDep - Scheduling dependency |
  isPodLike< SDep > | |
  SUnit | SUnit - Scheduling unit. This is a node in the scheduling DAG |
  SchedulingPriorityQueue | SchedulingPriorityQueue - This interface is used to plug different priorities computation algorithms into the list scheduler |
  ScheduleDAG | |
  SUnitIterator | |
  GraphTraits< SUnit * > | |
  GraphTraits< ScheduleDAG * > | |
  ScheduleDAGTopologicalSort | ScheduleDAGTopologicalSort is a class that computes a topological ordering for SUnits and provides methods for dynamically updating the ordering as new edges are added |
  VReg2SUnit | An individual mapping from virtual register number to SUnit |
  PhysRegSUOper | Record a physical register access |
  ScheduleDAGInstrs | ScheduleDAGInstrs - A ScheduleDAG subclass for scheduling lists of MachineInstrs |
  ILPValue | Represent the ILP of the subDAG rooted at a DAG node |
  SchedDFSResult | Compute the values of each DAG node for various metrics during DFS |
  ScheduleHazardRecognizer | HazardRecognizer - 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 |
  RegisterScheduler | |
  ScoreboardHazardRecognizer | |
  SDVTListNode | |
  FoldingSetTrait< SDVTListNode > | Specialize FoldingSetTrait for SDVTListNode to avoid computing temp FoldingSetNodeID and hash value |
  ilist_traits< SDNode > | |
  SDDbgInfo | Keeps track of dbg_value information through SDISel |
  SelectionDAG | This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representation suitable for instruction selection |
   DAGUpdateListener | Clients of various APIs that cause global effects on the DAG can optionally implement this interface |
  GraphTraits< SelectionDAG * > | |
  SelectionDAGISel | SelectionDAGISel - This is the common base class used for SelectionDAG-based pattern-matching instruction selectors |
  SDVTList | This represents a list of ValueType's that has been intern'd by a SelectionDAG |
  SDValue | Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation |
  DenseMapInfo< SDValue > | |
  isPodLike< SDValue > | |
  simplify_type< SDValue > | Allow casting operators to work directly on SDValues as if they were SDNode*'s |
  simplify_type< const SDValue > | |
  SDUse | Represents a use of a SDNode |
  simplify_type< SDUse > | Simplify_type specializations - Allow casting operators to work directly on SDValues as if they were SDNode*'s |
  SDNode | Represents one node in the SelectionDAG |
   use_iterator | This class provides iterator support for SDUse operands that use a specific SDNode |
   value_op_iterator | Iterator for directly iterating over the operand SDValue's |
  SDLoc | Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation functions |
  SDNodeFlags | These are IR-level optimization flags that may be propagated to SDNodes |
  UnarySDNode | This class is used for single-operand SDNodes |
  BinarySDNode | This class is used for two-operand SDNodes |
  BinaryWithFlagsSDNode | This class is an extension of BinarySDNode used from those opcodes that have associated extra flags |
  TernarySDNode | This class is used for three-operand SDNodes |
  HandleSDNode | This class is used to form a handle around another node that is persistent and is updated across invocations of replaceAllUsesWith on its operand |
  AddrSpaceCastSDNode | |
  MemSDNode | This is an abstract virtual class for memory operations |
  AtomicSDNode | This is an SDNode representing atomic operations |
  MemIntrinsicSDNode | This SDNode is used for target intrinsics that touch memory and need an associated MachineMemOperand |
  ShuffleVectorSDNode | This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction |
  ConstantSDNode | |
  ConstantFPSDNode | |
  GlobalAddressSDNode | |
  FrameIndexSDNode | |
  JumpTableSDNode | |
  ConstantPoolSDNode | |
  TargetIndexSDNode | Completely target-dependent object reference |
  BasicBlockSDNode | |
  BuildVectorSDNode | A "pseudo-class" with methods for operating on BUILD_VECTORs |
  SrcValueSDNode | An SDNode that holds an arbitrary LLVM IR Value |
  MDNodeSDNode | |
  RegisterSDNode | |
  RegisterMaskSDNode | |
  BlockAddressSDNode | |
  EHLabelSDNode | |
  ExternalSymbolSDNode | |
  MCSymbolSDNode | |
  CondCodeSDNode | |
  CvtRndSatSDNode | NOTE: avoid using this node as this may disappear in the future and most targets don't support it |
  VTSDNode | This class is used to represent EVT's, which are used to parameterize some operations |
  LSBaseSDNode | Base class for LoadSDNode and StoreSDNode |
  LoadSDNode | This class is used to represent ISD::LOAD nodes |
  StoreSDNode | This class is used to represent ISD::STORE nodes |
  MaskedLoadStoreSDNode | This base class is used to represent MLOAD and MSTORE nodes |
  MaskedLoadSDNode | This class is used to represent an MLOAD node |
  MaskedStoreSDNode | This class is used to represent an MSTORE node |
  MaskedGatherScatterSDNode | This is a base class used to represent MGATHER and MSCATTER nodes |
  MaskedGatherSDNode | This class is used to represent an MGATHER node |
  MaskedScatterSDNode | This class is used to represent an MSCATTER node |
  MachineSDNode | An SDNode that represents everything that will be needed to construct a MachineInstr |
  SDNodeIterator | |
  GraphTraits< SDNode * > | |
  IndexListEntry | This class represents an entry in the slot index list held in the SlotIndexes pass |
  ilist_traits< IndexListEntry > | |
  SlotIndex | SlotIndex - An opaque wrapper around machine indexes |
  isPodLike< SlotIndex > | |
  Idx2MBBCompare | |
  SlotIndexes | SlotIndexes pass |
  IntervalMapInfo< SlotIndex > | |
  PatchPointOpers | MI-level patchpoint operands |
  StatepointOpers | MI-level Statepoint operands |
  StackMaps | |
   LiveOutReg | |
   Location | |
  StackProtector | |
  TargetLoweringObjectFileELF | |
  TargetLoweringObjectFileMachO | |
  TargetLoweringObjectFileCOFF | |
  TargetSchedModel | Provide an instruction scheduling machine model to CodeGen passes |
  EVT | EVT - Extended Value Type |
   compareRawBits | CompareRawBits - A meaningless but well-behaved order, useful for constructing containers |
  VirtRegMap | |
  ActionHandler | |
  CatchHandler | |
  CleanupHandler | |
  WinEHUnwindMapEntry | |
  WinEHHandlerType | |
  WinEHTryBlockMapEntry | |
  WinEHFuncInfo | |
  DILineInfo | DILineInfo - a format-neutral container for source line information |
  DIInliningInfo | DIInliningInfo - a format-neutral container for inlined code description |
  DILineInfoSpecifier | DILineInfoSpecifier - controls which fields of DILineInfo container should be filled with data |
  DIContext | |
  LoadedObjectInfo | An inferface for inquiring the load address of a loaded object file to be used by the DIContext implementations when applying relocations on the fly |
  DWARFAbbreviationDeclaration | |
   AttributeSpec | |
  DWARFAcceleratorTable | |
  DWARFCompileUnit | |
  DWARFContext | DWARFContext This data structure is the top level entity that deals with dwarf debug information parsing |
  DWARFContextInMemory | DWARFContextInMemory is the simplest possible implementation of a DWARFContext |
  DWARFAbbreviationDeclarationSet | |
  DWARFDebugAbbrev | |
  DWARFDebugAranges | |
  DWARFDebugArangeSet | |
   Descriptor | |
   Header | |
  DWARFDebugFrame | A parsed .debug_frame section |
  DWARFDebugInfoEntryMinimal | DWARFDebugInfoEntryMinimal - A DIE with only the minimum required data |
  DWARFDebugInfoEntryInlinedChain | DWARFDebugInfoEntryInlinedChain - represents a chain of inlined_subroutine DIEs, (possibly ending with subprogram DIE), all of which are contained in some concrete inlined instance tree |
  DWARFDebugLine | |
   FileNameEntry | |
   LineTable | |
   Prologue | |
   Row | |
   Sequence | |
  DWARFDebugLoc | |
  DWARFDebugLocDWO | |
  DWARFDebugRangeList | |
   RangeListEntry | |
  DWARFFormValue | |
  DWARFSection | |
  DWARFTypeUnit | |
  DWARFUnitSectionBase | Base class for all DWARFUnitSection classes |
  DWARFUnitSection | Concrete instance of DWARFUnitSection, specialized for one Unit type |
  DWARFUnit | |
  ConcreteSymbolEnumerator | |
  DIADataStream | |
  DIAEnumDebugStreams | |
  DIAEnumLineNumbers | |
  DIAEnumSourceFiles | |
  DIAEnumSymbols | |
  DIALineNumber | |
  DIARawSymbol | |
  DIASession | |
  DIASourceFile | |
  IPDBDataStream | IPDBDataStream 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 |
  IPDBEnumChildren | |
  IPDBLineNumber | |
  IPDBRawSymbol | IPDBRawSymbol defines an interface used to represent an arbitrary symbol |
  IPDBSession | IPDBSession defines an interface used to provide a context for querying debug information from a debug data source (for example, a PDB) |
  IPDBSourceFile | IPDBSourceFile defines an interface used to represent source files whose information are stored in the PDB |
  PDBContext | PDBContext This data structure is the top level entity that deals with PDB debug information parsing |
  PDBSymbol | PDBSymbol defines the base of the inheritance hierarchy for concrete symbol types (e.g |
  PDBSymbolAnnotation | |
  PDBSymbolBlock | |
  PDBSymbolCompiland | |
  PDBSymbolCompilandDetails | |
  PDBSymbolCompilandEnv | |
  PDBSymbolCustom | PDBSymbolCustom represents symbols that are compiler-specific and do not fit anywhere else in the lexical hierarchy |
  PDBSymbolData | |
  PDBSymbolExe | |
  PDBSymbolFunc | |
  PDBSymbolFuncDebugEnd | |
  PDBSymbolFuncDebugStart | |
  PDBSymbolLabel | |
  PDBSymbolPublicSymbol | |
  PDBSymbolThunk | |
  PDBSymbolTypeArray | |
  PDBSymbolTypeBaseClass | |
  PDBSymbolTypeBuiltin | |
  PDBSymbolTypeCustom | |
  PDBSymbolTypeDimension | |
  PDBSymbolTypeEnum | |
  PDBSymbolTypeFriend | |
  PDBSymbolTypeFunctionArg | |
  PDBSymbolTypeFunctionSig | |
  PDBSymbolTypeManaged | |
  PDBSymbolTypePointer | |
  PDBSymbolTypeTypedef | |
  PDBSymbolTypeUDT | |
  PDBSymbolTypeVTable | |
  PDBSymbolTypeVTableShape | |
  PDBSymbolUnknown | |
  PDBSymbolUsingNamespace | |
  PDBSymDumper | |
  PDB_UniqueId | Defines a 128-bit unique identifier |
  VersionInfo | |
  Variant | |
  ExecutionEngineState | Helper class for helping synchronize access to the global address map table |
  ExecutionEngine | Abstract interface for implementation execution of LLVM modules, designed to support both interpreter and just-in-time (JIT) compiler implementations |
  EngineBuilder | Builder class for ExecutionEngines |
  GenericValue | |
   IntPair | |
  JITEvent_EmittedFunctionDetails | JITEvent_EmittedFunctionDetails - Helper struct for containing information about a generated machine code function |
   LineStart | |
  JITEventListener | JITEventListener - Abstract interface for use by the JIT to notify clients about significant events during compilation |
  JITSymbolBase | Base class for symbols in the JIT |
  ObjectCache | This 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 |
  ObjectMemoryBuffer | SmallVector-backed MemoryBuffer instance |
  OProfileWrapper | |
  MCJITMemoryManager | |
  RTDyldMemoryManager | |
  RuntimeDyld | |
   LoadedObjectInfo | Information about the loaded object |
   LoadedObjectInfoHelper | |
   MemoryManager | Memory Management |
   SymbolInfo | Information about a named symbol |
   SymbolResolver | Symbol resolution |
  RuntimeDyldChecker | RuntimeDyld invariant checker for verifying that RuntimeDyld has correctly applied relocations |
  SectionMemoryManager | This 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 |
  SymbolTableListTraits | |
  Argument | LLVM Argument representation |
  AssemblyAnnotationWriter | |
  Attribute | |
  AttributeSet | |
  DenseMapInfo< AttributeSet > | |
  AttrBuilder | |
  ilist_traits< BasicBlock > | |
  BasicBlock | LLVM Basic Block Representation |
  CallSiteBase | |
  CallSite | |
  ImmutableCallSite | ImmutableCallSite - establish a view to a call site for examination |
  PredIterator | |
  SuccIterator | |
  isPodLike< SuccIterator< T, U > > | |
  GraphTraits< BasicBlock * > | |
  GraphTraits< const BasicBlock * > | |
  GraphTraits< Inverse< BasicBlock * > > | |
  GraphTraits< Inverse< const BasicBlock * > > | |
  GraphTraits< Function * > | |
  GraphTraits< const Function * > | |
  GraphTraits< Inverse< Function * > > | |
  GraphTraits< Inverse< const Function * > > | |
  Comdat | |
  Constant | This is an important base class in LLVM |
  ConstantFolder | ConstantFolder - Create constants with minimum, target independent, folding |
  ConstantRange | This class represents a range of values |
  ConstantAggrKeyType | |
  ConstantInt | This is the shared class of boolean and integer constants |
  ConstantFP | ConstantFP - Floating Point Values [float, double] |
  ConstantAggregateZero | ConstantAggregateZero - All zero aggregate value |
  ConstantArray | ConstantArray - Constant Array Declarations |
  OperandTraits< ConstantArray > | |
  ConstantStruct | |
  OperandTraits< ConstantStruct > | |
  ConstantVector | ConstantVector - Constant Vector Declarations |
  OperandTraits< ConstantVector > | |
  ConstantPointerNull | ConstantPointerNull - a constant pointer value that points to null |
  ConstantDataSequential | ConstantDataSequential - 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 |
  ConstantDataArray | ConstantDataArray - 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 |
  ConstantDataVector | ConstantDataVector - 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 |
  BlockAddress | BlockAddress - The address of a basic block |
  OperandTraits< BlockAddress > | |
  ConstantExpr | ConstantExpr - a constant value that is initialized with an expression using other constant values |
  OperandTraits< ConstantExpr > | |
  UndefValue | UndefValue - 'undef' values are things that do not have specified contents |
  LayoutAlignElem | Layout alignment element |
  PointerAlignElem | Layout pointer alignment element |
  DataLayout | A parsed version of the target data layout string in and methods for querying it |
  StructLayout | Used to lazily calculate structure layout information for a target machine, based on the DataLayout structure |
  DebugInfoFinder | Utility to find all debug info in a module |
  TypedDINodeRef | Pointer union between a subclass of DINode and MDString |
  DITypeRefArray | |
   iterator | |
  DINode | Tagged DWARF-like metadata node |
  simplify_type< const TypedDINodeRef< T > > | |
  simplify_type< TypedDINodeRef< T > > | |
  GenericDINode | Generic tagged DWARF-like metadata node |
  DISubrange | Array subrange |
  DIEnumerator | Enumeration value |
  DIScope | Base class for scope-like contexts |
  DIFile | File |
  DIType | Base class for types |
  DIBasicType | Basic type, like 'int' or 'float' |
  DIDerivedTypeBase | Base class for DIDerivedType and DICompositeType |
  DIDerivedType | Derived types |
  DICompositeTypeBase | Base class for DICompositeType and DISubroutineType |
  DICompositeType | Composite types |
  DISubroutineType | Type array for a subprogram |
  DICompileUnit | Compile unit |
  DILocalScope | A scope for locals |
  DILocation | Debug location |
  DISubprogram | Subprogram description |
  DILexicalBlockBase | |
  DILexicalBlock | |
  DILexicalBlockFile | |
  DINamespace | |
  DIModule | A (clang) module that has been imported by the compile unit |
  DITemplateParameter | Base class for template parameters |
  DITemplateTypeParameter | |
  DITemplateValueParameter | |
  DIVariable | Base class for variables |
  DIGlobalVariable | Global variables |
  DILocalVariable | Local variable |
  DIExpression | DWARF expression |
   expr_op_iterator | An iterator for expression operands |
   ExprOperand | A lightweight wrapper around an expression operand |
  DIObjCProperty | |
  DIImportedEntity | An imported module (C++ using directive or similar) |
  DebugLoc | A debug info location |
  IntegerType | Class to represent integer types |
  FunctionType | FunctionType - Class to represent function types |
  CompositeType | CompositeType - Common super class of ArrayType, StructType, PointerType and VectorType |
  StructType | StructType - Class to represent struct types |
  SequentialType | SequentialType - This is the superclass of the array, pointer and vector type classes |
  ArrayType | ArrayType - Class to represent array types |
  VectorType | VectorType - Class to represent vector types |
  PointerType | PointerType - Class to represent pointers |
  DiagnosticInfo | This is the base abstract class for diagnostic reporting in the backend |
  DiagnosticInfoInlineAsm | Diagnostic information for inline asm reporting |
  DiagnosticInfoStackSize | Diagnostic information for stack size reporting |
  DiagnosticInfoDebugMetadataVersion | Diagnostic information for debug metadata version reporting |
  DiagnosticInfoSampleProfile | Diagnostic information for the sample profiler |
  DiagnosticInfoOptimizationBase | Common features for diagnostics dealing with optimization remarks |
  DiagnosticInfoOptimizationRemark | Diagnostic information for applied optimization remarks |
  DiagnosticInfoOptimizationRemarkMissed | Diagnostic information for missed-optimization remarks |
  DiagnosticInfoOptimizationRemarkAnalysis | Diagnostic information for optimization analysis remarks |
  DiagnosticInfoMIRParser | Diagnostic information for machine IR parser |
  DiagnosticInfoOptimizationFailure | Diagnostic information for optimization failures |
  DiagnosticPrinter | Interface for custom diagnostic printing |
  DiagnosticPrinterRawOStream | Basic diagnostic printer that uses an underlying raw_ostream |
  DIBuilder | |
  BasicBlockEdge | |
  DominatorTree | Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree |
  GraphTraits< DomTreeNode * > | |
  GraphTraits< DominatorTree * > | |
  DominatorTreeAnalysis | Analysis pass which computes a DominatorTree |
  DominatorTreePrinterPass | Printer pass for the DominatorTree |
  DominatorTreeVerifierPass | Verifier pass for the DominatorTree |
  DominatorTreeWrapperPass | Legacy analysis pass which computes a DominatorTree |
  ilist_traits< Argument > | |
  Function | |
  OperandTraits< Function > | |
  generic_gep_type_iterator | |
  GlobalAlias | |
  OperandTraits< GlobalAlias > | |
  GlobalObject | |
  GlobalValue | |
  GlobalVariable | |
  OperandTraits< GlobalVariable > | |
  GVMaterializer | |
  ConstantUniqueMap | |
  InlineAsm | |
   ConstraintInfo | |
   SubConstraintInfo | |
  InstIterator | |
  TerminatorInst | Subclasses of this class are all able to terminate a basic block |
  UnaryInstruction | |
  OperandTraits< UnaryInstruction > | |
  BinaryOperator | |
  OperandTraits< BinaryOperator > | |
  CastInst | This is the base class for all instructions that perform data casts |
  CmpInst | This class is the base class for the comparison instructions |
  OperandTraits< CmpInst > | |
  ilist_traits< Instruction > | |
  Instruction | |
  PointerLikeTypeTraits< Instruction * > | |
  AllocaInst | AllocaInst - an instruction to allocate memory on the stack |
  LoadInst | LoadInst - an instruction for reading from memory |
  StoreInst | StoreInst - an instruction for storing to memory |
  OperandTraits< StoreInst > | |
  FenceInst | FenceInst - an instruction for ordering other memory operations |
  AtomicCmpXchgInst | AtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there |
  OperandTraits< AtomicCmpXchgInst > | |
  AtomicRMWInst | AtomicRMWInst - an instruction that atomically reads a memory location, combines it with another value, and then stores the result back |
  OperandTraits< AtomicRMWInst > | |
  GetElementPtrInst | GetElementPtrInst - an instruction for type-safe pointer arithmetic to access elements of arrays and structs |
  OperandTraits< GetElementPtrInst > | |
  ICmpInst | This instruction compares its operands according to the predicate given to the constructor |
  FCmpInst | This instruction compares its operands according to the predicate given to the constructor |
  CallInst | CallInst - This class represents a function call, abstracting a target machine's calling convention |
  OperandTraits< CallInst > | |
  SelectInst | SelectInst - This class represents the LLVM 'select' instruction |
  OperandTraits< SelectInst > | |
  VAArgInst | VAArgInst - This class represents the va_arg llvm instruction, which returns an argument of the specified type given a va_list and increments that list |
  ExtractElementInst | ExtractElementInst - This instruction extracts a single (scalar) element from a VectorType value |
  OperandTraits< ExtractElementInst > | |
  InsertElementInst | InsertElementInst - This instruction inserts a single (scalar) element into a VectorType value |
  OperandTraits< InsertElementInst > | |
  ShuffleVectorInst | ShuffleVectorInst - This instruction constructs a fixed permutation of two input vectors |
  OperandTraits< ShuffleVectorInst > | |
  ExtractValueInst | ExtractValueInst - This instruction extracts a struct member or array element value from an aggregate value |
  InsertValueInst | InsertValueInst - This instruction inserts a struct field of array element value into an aggregate value |
  OperandTraits< InsertValueInst > | |
  PHINode | |
  OperandTraits< PHINode > | |
  LandingPadInst | LandingPadInst - The landingpad instruction holds all of the information necessary to generate correct exception handling |
  OperandTraits< LandingPadInst > | |
  ReturnInst | ReturnInst - Return a value (possibly void), from a function |
  OperandTraits< ReturnInst > | |
  BranchInst | BranchInst - Conditional or Unconditional Branch instruction |
  OperandTraits< BranchInst > | |
  SwitchInst | SwitchInst - Multiway switch |
   CaseIt | |
   CaseIteratorT | |
  OperandTraits< SwitchInst > | |
  IndirectBrInst | IndirectBrInst - Indirect Branch Instruction |
  OperandTraits< IndirectBrInst > | |
  InvokeInst | InvokeInst - Invoke instruction |
  OperandTraits< InvokeInst > | |
  ResumeInst | ResumeInst - Resume the propagation of an exception |
  OperandTraits< ResumeInst > | |
  UnreachableInst | UnreachableInst - This function has undefined behavior |
  TruncInst | This class represents a truncation of integer types |
  ZExtInst | This class represents zero extension of integer types |
  SExtInst | This class represents a sign extension of integer types |
  FPTruncInst | This class represents a truncation of floating point types |
  FPExtInst | This class represents an extension of floating point types |
  UIToFPInst | This class represents a cast unsigned integer to floating point |
  SIToFPInst | This class represents a cast from signed integer to floating point |
  FPToUIInst | This class represents a cast from floating point to unsigned integer |
  FPToSIInst | This class represents a cast from floating point to signed integer |
  IntToPtrInst | This class represents a cast from an integer to a pointer |
  PtrToIntInst | This class represents a cast from a pointer to an integer |
  BitCastInst | This class represents a no-op cast from one type to another |
  AddrSpaceCastInst | This class represents a conversion between pointers from one address space to another |
  InstVisitor | Base class for instruction visitors |
  IntrinsicInst | IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions |
  DbgInfoIntrinsic | DbgInfoIntrinsic - This is the common base class for debug info intrinsics |
  DbgDeclareInst | DbgDeclareInst - This represents the llvm.dbg.declare instruction |
  DbgValueInst | DbgValueInst - This represents the llvm.dbg.value instruction |
  MemIntrinsic | MemIntrinsic - This is the common base class for memset/memcpy/memmove |
  MemSetInst | MemSetInst - This class wraps the llvm.memset intrinsic |
  MemTransferInst | MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics |
  MemCpyInst | MemCpyInst - This class wraps the llvm.memcpy intrinsic |
  MemMoveInst | MemMoveInst - This class wraps the llvm.memmove intrinsic |
  VAStartInst | VAStartInst - This represents the llvm.va_start intrinsic |
  VAEndInst | VAEndInst - This represents the llvm.va_end intrinsic |
  VACopyInst | VACopyInst - This represents the llvm.va_copy intrinsic |
  InstrProfIncrementInst | This represents the llvm.instrprof_increment intrinsic |
  IRBuilderDefaultInserter | 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 |
  IRBuilderBase | Common base class shared among various IRBuilders |
   FastMathFlagGuard | |
   InsertPoint | InsertPoint - A saved insertion point |
   InsertPointGuard | |
  IRBuilder | 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 |
  PrintModulePass | Pass for printing a Module as LLVM's text IR assembly |
  PrintFunctionPass | Pass for printing a Function as LLVM's text IR assembly |
  PassManagerPrettyStackEntry | PassManagerPrettyStackEntry - This is used to print informative information about what pass is running when/if a stack trace is generated |
  PMStack | PMStack - This class implements a stack data structure of PMDataManager pointers |
  PMTopLevelManager | PMTopLevelManager manages LastUser info and collects common APIs used by top level pass managers |
  PMDataManager | PMDataManager provides the common place to manage the analysis data used by pass managers |
  FPPassManager | FPPassManager manages BBPassManagers and FunctionPasses |
  PassNameParser | |
  FilteredPassNameParser | ===-------------------------------------------------------------------—===// 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 |
  PassArgFilter | ===-------------------------------------------------------------------—===// PassArgFilter - A filter for use with PassNameFilterParser that only accepts a Pass whose Arg matches certain strings |
  LLVMContext | This is an important class for using LLVM in a threaded context |
  Mangler | |
  MDBuilder | |
   TBAAStructField | |
  Metadata | Root of the metadata hierarchy |
  MetadataAsValue | Metadata wrapper in the Value hierarchy |
  ReplaceableMetadataImpl | Shared implementation of use-lists for replaceable metadata |
  ValueAsMetadata | Value wrapper in the Metadata hierarchy |
  ConstantAsMetadata | |
  LocalAsMetadata | |
  MDString | A single uniqued string |
  AAMDNodes | A collection of metadata nodes that might be associated with a memory access used by the alias-analysis infrastructure |
  DenseMapInfo< AAMDNodes > | |
  MDOperand | Tracking metadata reference owned by Metadata |
  simplify_type< MDOperand > | |
  simplify_type< const MDOperand > | |
  ContextAndReplaceableUses | Pointer to the context, with optional RAUW support |
  TempMDNodeDeleter | |
  MDNode | Metadata node |
   HasCachedHash | |
    SFINAE | |
  MDTuple | Tuple of metadata |
  TypedMDOperandIterator | Typed iterator through MDNode operands |
  MDTupleTypedArrayWrapper | Typed, array-like tuple of metadata |
  NamedMDNode | A tuple of MDNodes |
  MetadataTracking | API for tracking metadata references through RAUW and deletion |
  ilist_traits< Function > | |
  ilist_traits< GlobalVariable > | |
  ilist_traits< GlobalAlias > | |
  ilist_traits< NamedMDNode > | |
  Module | A Module instance is used to store all the information related to an LLVM module |
   ModuleFlagEntry | |
  ModuleSlotTracker | Manage lifetime of a slot tracker for printing IR |
  NoFolder | NoFolder - Create "constants" (actually, instructions) with no folding |
  FixedNumOperandTraits | 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 |
  OptionalOperandTraits | OptionalOperandTraits - when the number of operands may change at runtime |
  VariadicOperandTraits | 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 |
  HungoffOperandTraits | 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 |
  Operator | This is a utility class that provides an abstraction for the common functionality between Instructions and ConstantExprs |
  OverflowingBinaryOperator | Utility class for integer arithmetic operators which may exhibit overflow - Add, Sub, and Mul |
  PossiblyExactOperator | A udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed |
  FastMathFlags | Convenience struct for specifying and reasoning about fast-math flags |
  FPMathOperator | Utility class for floating point operations which can have information about relaxed accuracy requirements attached to them |
  ConcreteOperator | A helper template for defining operators for individual opcodes |
  AddOperator | |
  SubOperator | |
  MulOperator | |
  ShlOperator | |
  SDivOperator | |
  UDivOperator | |
  AShrOperator | |
  LShrOperator | |
  ZExtOperator | |
  GEPOperator | |
  PtrToIntOperator | |
  BitCastOperator | |
  PreservedAnalyses | An abstract set of preserved analyses following a transformation pass run |
  PassManager | Manages a sequence of passes over units of IR |
  FunctionAnalysisManagerModuleProxy | A module analysis which acts as a proxy for a function analysis manager |
   Result | The result proxy object for the FunctionAnalysisManagerModuleProxy |
  ModuleAnalysisManagerFunctionProxy | A function analysis which acts as a proxy for a module analysis manager |
   Result | Result proxy object for ModuleAnalysisManagerFunctionProxy |
  ModuleToFunctionPassAdaptor | Trivial adaptor that maps from a module to its functions |
  RequireAnalysisPass | A template utility pass to force an analysis result to be available |
  InvalidateAnalysisPass | A template utility pass to force an analysis result to be invalidated |
  InvalidateAllAnalysesPass | A utility pass that does nothing but preserves no analyses |
  PredIteratorCache | PredIteratorCache - This class is an extremely trivial cache for predecessor iterator queries |
  StatepointBase | Analogous to CallSiteBase, this provides most of the actual functionality for Statepoint and ImmutableStatepoint |
  ImmutableStatepoint | A specialization of it's base class for read only access to a gc.statepoint |
  Statepoint | A specialization of it's base class for read-write access to a gc.statepoint |
  GCRelocateOperands | Wraps a call to a gc.relocate and provides access to it's operands |
  TrackingMDRef | Tracking metadata reference |
  TypedTrackingMDRef | Typed tracking ref |
  simplify_type< TrackingMDRef > | |
  simplify_type< const TrackingMDRef > | |
  simplify_type< TypedTrackingMDRef< T > > | |
  simplify_type< const TypedTrackingMDRef< T > > | |
  Type | The instances of the Type class are immutable: once they are created, they are never changed |
  isa_impl< PointerType, Type > | |
  GraphTraits< Type * > | |
  GraphTraits< const Type * > | |
  TypeBuilder | TypeBuilder - This provides a uniform API for looking up types known at compile time |
  TypeBuilder< const T, cross > | |
  TypeBuilder< volatile T, cross > | |
  TypeBuilder< const volatile T, cross > | |
  TypeBuilder< T *, cross > | |
  TypeBuilder< T &, cross > | There is no support for references |
  TypeBuilder< T[N], cross > | |
  TypeBuilder< T[], cross > | LLVM uses an array of length 0 to represent an unknown-length array |
  TypeBuilder< types::i< num_bits >, cross > | |
  TypeBuilder< float, false > | |
  TypeBuilder< float, true > | |
  TypeBuilder< double, false > | |
  TypeBuilder< double, true > | |
  TypeBuilder< types::ieee_float, cross > | |
  TypeBuilder< types::ieee_double, cross > | |
  TypeBuilder< types::x86_fp80, cross > | |
  TypeBuilder< types::fp128, cross > | |
  TypeBuilder< types::ppc_fp128, cross > | |
  TypeBuilder< types::x86_mmx, cross > | |
  TypeBuilder< void, cross > | |
  TypeBuilder< void *, false > | Void* is disallowed in LLVM types, but it occurs often enough in C code that we special case it |
  TypeBuilder< const void *, false > | |
  TypeBuilder< volatile void *, false > | |
  TypeBuilder< const volatile void *, false > | |
  TypeBuilder< R(), cross > | |
  TypeBuilder< R(A1), cross > | |
  TypeBuilder< R(A1, A2), cross > | |
  TypeBuilder< R(A1, A2, A3), cross > | |
  TypeBuilder< R(A1, A2, A3, A4), cross > | |
  TypeBuilder< R(A1, A2, A3, A4, A5), cross > | |
  TypeBuilder< R(...), cross > | |
  TypeBuilder< R(A1,...), cross > | |
  TypeBuilder< R(A1, A2,...), cross > | |
  TypeBuilder< R(A1, A2, A3,...), cross > | |
  TypeBuilder< R(A1, A2, A3, A4,...), cross > | |
  TypeBuilder< R(A1, A2, A3, A4, A5,...), cross > | |
  TypeFinder | TypeFinder - Walk over a module, identifying all of the types that are used by the module |
  PointerLikeTypeTraits< Use ** > | |
  Use | A Use represents the edge between a Value definition and its users |
  simplify_type< Use > | Allow clients to treat uses just like values when using casting operators |
  simplify_type< const Use > | |
  UseListOrder | Structure to hold a use-list order |
  OperandTraits | Compile-time customization of User operands |
  User | |
   value_op_iterator | Iterator for directly iterating over the operand Values |
  simplify_type< User::op_iterator > | |
  simplify_type< User::const_op_iterator > | |
  Value | LLVM Value Representation |
  isa_impl< Constant, Value > | |
  isa_impl< Argument, Value > | |
  isa_impl< InlineAsm, Value > | |
  isa_impl< Instruction, Value > | |
  isa_impl< BasicBlock, Value > | |
  isa_impl< Function, Value > | |
  isa_impl< GlobalVariable, Value > | |
  isa_impl< GlobalAlias, Value > | |
  isa_impl< GlobalValue, Value > | |
  isa_impl< GlobalObject, Value > | |
  PointerLikeTypeTraits< Value * > | |
  PointerLikeTypeTraits< ValueHandleBase ** > | |
  ValueHandleBase | This is the common base class of value handles |
  WeakVH | Value handle that is nullable, but tries to track the Value |
  simplify_type< WeakVH > | |
  simplify_type< const WeakVH > | |
  AssertingVH | Value handle that asserts if the Value is deleted |
  DenseMapInfo< AssertingVH< T > > | |
  isPodLike< AssertingVH< T > > | |
  TrackingVH | Value handle that tracks a Value across RAUW |
  CallbackVH | Value handle with callbacks on RAUW and destruction |
  ValueMapCallbackVH | |
  ValueMapIterator | |
   ValueTypeProxy | |
  ValueMapConstIterator | |
   ValueTypeProxy | |
  ValueMapConfig | This class defines the default behavior for configurable aspects of ValueMap<> |
   ExtraData | |
  ValueMap | See the file comment |
  DenseMapInfo< ValueMapCallbackVH< KeyT, ValueT, Config > > | |
  ValueSymbolTable | This class provides a symbol table of name/value pairs |
  VerifierPass | |
  LineEditor | |
   Completion | A possible completion at a given cursor position |
   CompletionAction | The action to perform upon a completion request |
   InternalData | |
  Linker | This class provides the core functionality of linking in LLVM |
   IdentifiedStructTypeSet | |
   StructTypeKeyInfo | |
    KeyTy | |
  LTOCodeGenerator | C++ class which implements the opaque lto_code_gen_t type |
  LTOModule | C++ class which implements the opaque lto_module_t type |
  ConstantPoolEntry | |
  ConstantPool | |
  AssemblerConstantPools | |
  MachineLocation | |
  MCAsmBackend | Generic interface to target specific assembler backends |
  MCAsmInfo | This class is intended to be used as a base class for asm properties and features specific to the target |
  MCAsmInfoCOFF | |
  MCAsmInfoMicrosoft | |
  MCAsmInfoGNUCOFF | |
  MCAsmInfoDarwin | |
  MCAsmInfoELF | |
  MCAsmLayout | Encapsulates the layout of an assembly file at a particular point in time |
  MCFragment | |
  MCEncodedFragment | Interface implemented by fragments that contain encoded instructions and/or data |
  MCEncodedFragmentWithContents | Interface implemented by fragments that contain encoded instructions and/or data |
  MCEncodedFragmentWithFixups | Interface implemented by fragments that contain encoded instructions and/or data and also have fixups registered |
  MCDataFragment | Fragment for data and encoded instructions |
  MCCompactEncodedInstFragment | This is a compact (memory-size-wise) fragment for holding an encoded instruction (non-relaxable) that has no fixups registered |
  MCRelaxableFragment | A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler layout and relaxation stage |
  MCAlignFragment | |
  MCFillFragment | |
  MCOrgFragment | |
  MCLEBFragment | |
  MCDwarfLineAddrFragment | |
  MCDwarfCallFrameFragment | |
  MCSafeSEHFragment | |
  IndirectSymbolData | |
  DataRegionData | |
  MCAssembler | |
   VersionMinInfoType | MachO specific deployment target version info |
  MCCodeEmitter | MCCodeEmitter - Generic instruction encoding interface |
  MCCodeGenInfo | |
  MCContext | Context object for machine code objects |
  MCDisassembler | Superclass for all disassemblers |
  MCDwarfFile | Instances 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) |
  MCDwarfLoc | Instances of this class represent the information from a dwarf .loc directive |
  MCLineEntry | Instances of this class represent the line information for the dwarf line table entries |
  MCLineSection | Instances of this class represent the line information for a compile unit where machine instructions have been assembled after seeing .loc directives |
  MCDwarfLineTableHeader | |
  MCDwarfDwoLineTable | |
  MCDwarfLineTable | |
  MCDwarfLineAddr | |
  MCGenDwarfInfo | |
  MCGenDwarfLabelEntry | |
  MCCFIInstruction | |
  MCDwarfFrameInfo | |
  MCDwarfFrameEmitter | |
  ELFRelocationEntry | |
  MCELFObjectTargetWriter | |
  MCELFStreamer | |
  MCExpr | Base class for the full range of assembler expressions which are needed for parsing |
  MCConstantExpr | |
  MCSymbolRefExpr | Represent a reference to a symbol from inside an expression |
  MCUnaryExpr | Unary assembler expressions |
  MCBinaryExpr | Binary assembler expressions |
  MCTargetExpr | This is an extension point for target-specific MCExpr subclasses to implement |
  MCExternalSymbolizer | Symbolize using user-provided, C API, callbacks |
  MCFixup | Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction) which requires assemble- or run- time patching |
  MCFixupKindInfo | Target independent information on a fixup kind |
  MCOperand | Instances of this class represent operands of the MCInst class |
  isPodLike< MCOperand > | |
  MCInst | Instances of this class represent a single low-level machine instruction |
  MCInstBuilder | |
  MCInstPrinter | This is an instance of a target assembly language printer that converts an MCInst to valid target assembly syntax |
  MCInstrAnalysis | |
  MCOperandInfo | This holds information about one operand of a machine instruction, indicating the register class for register operands, etc |
  MCInstrDesc | Describe properties that are true of each instruction in the target description file |
  MCInstrInfo | Interface to description of machine instruction set |
  InstrStage | These values represent a non-pipelined step in the execution of an instruction |
  InstrItinerary | An itinerary represents the scheduling information for an instruction |
  InstrItineraryData | Itinerary data supplied by a subtarget to be used by a target |
  MCLabel | Instances of this class represent a label name in the MC file, and MCLabel are created and uniqued by the MCContext class |
  MCLOHDirective | Store Linker Optimization Hint information (LOH) |
  MCLOHContainer | |
  MCMachObjectTargetWriter | |
  MachObjectWriter | |
  MCObjectFileInfo | |
  MCObjectStreamer | Streaming object file generation interface |
  MCObjectWriter | Defines the object file and target independent interfaces used by the assembler backend to write native file format object files |
  AsmCond | AsmCond - Class to support conditional assembly |
  AsmLexer | AsmLexer - Lexer class for assembly files |
  AsmToken | Target independent representation for an assembler token |
  MCAsmLexer | Generic assembler lexer interface, for use by target specific assembly lexers |
  InlineAsmIdentifierInfo | |
  MCAsmParserSemaCallback | Generic Sema callback for assembly parser |
  MCAsmParser | Generic assembler parser interface, for use by target specific assembly parsers |
  MCAsmParserExtension | Generic interface for extending the MCAsmParser, which is implemented by target and object file assembly parser implementations |
  MCParsedAsmOperand | MCParsedAsmOperand - This abstract class represents a source-level assembly instruction operand |
  MCRegisterClass | MCRegisterClass - Base class of TargetRegisterClass |
  MCRegisterDesc | MCRegisterDesc - This record contains information about a particular register |
  MCRegisterInfo | MCRegisterInfo 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 |
   DiffListIterator | DiffListIterator - Base iterator class that can traverse the differentially encoded register and regunit lists in DiffLists |
   DwarfLLVMRegPair | DwarfLLVMRegPair - Emitted by tablegen so Dwarf<->LLVM reg mappings can be performed with a binary search |
   SubRegCoveredBits | SubRegCoveredBits - Emitted by tablegen: bit range covered by a subreg index, -1 in any being invalid |
  MCSubRegIterator | MCSubRegIterator enumerates all sub-registers of Reg |
  MCSubRegIndexIterator | Iterator that enumerates the sub-registers of a Reg and the associated sub-register indices |
  MCSuperRegIterator | MCSuperRegIterator enumerates all super-registers of Reg |
  MCRegUnitIterator | |
  MCRegUnitMaskIterator | MCRegUnitIterator enumerates a list of register units and their associated lane masks for Reg |
  MCRegUnitRootIterator | MCRegUnitRootIterator enumerates the root registers of a register unit |
  MCRegAliasIterator | MCRegAliasIterator enumerates all registers aliasing Reg |
  MCRelocationInfo | Create MCExprs from relocations found in an object file |
  MCProcResourceDesc | Define a kind of processor resource that will be modeled by the scheduler |
  MCWriteProcResEntry | Identify one of the processor resource kinds consumed by a particular scheduling class for the specified number of cycles |
  MCWriteLatencyEntry | Specify the latency in cpu cycles for a particular scheduling class and def index |
  MCReadAdvanceEntry | Specify the number of cycles allowed after instruction issue before a particular use operand reads its registers |
  MCSchedClassDesc | Summarize the scheduling resources required for an instruction of a particular scheduling class |
  MCSchedModel | Machine model for scheduling, bundling, and heuristics |
  ilist_node_traits< MCFragment > | |
  MCSection | Instances of this class represent a uniqued identifier for a section in the current translation unit |
  MCSectionCOFF | MCSectionCOFF - This represents a section on Windows |
  MCSectionELF | MCSectionELF - This represents a section on linux, lots of unix variants and some bare metal systems |
  MCSectionMachO | MCSectionMachO - This represents a section on a Mach-O system (used by Mac OS X) |
  MCTargetStreamer | Target specific streamer interface |
  ARMTargetStreamer | |
  MCStreamer | Streaming machine code generation interface |
  MCSubtargetInfo | MCSubtargetInfo - Generic base class for all target subtargets |
  MCSymbol | MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created and uniqued by the MCContext class |
   NameEntryStorageTy | The name for a symbol |
  MCSymbolCOFF | |
  MCSymbolELF | |
  MCSymbolizer | Symbolize and annotate disassembled instructions |
  MCSymbolMachO | |
  AsmRewrite | |
  ParseInstructionInfo | |
  MCTargetAsmParser | MCTargetAsmParser - Generic interface to target specific assembly parsers |
  MCTargetOptions | |
  MCValue | This represents an "assembler immediate" |
  MCWinCOFFObjectTargetWriter | |
  MCWinCOFFStreamer | |
  SectionKind | SectionKind - This is a simple POD value that classifies the properties of a section |
  StringTableBuilder | Utility for building string tables with deduplicated suffixes |
  FeatureBitset | |
  SubtargetFeatureKV | SubtargetFeatureKV - Used to provide key value pairs for feature and CPU bit flags |
  SubtargetInfoKV | SubtargetInfoKV - Used to provide key value pairs for CPU and arbitrary pointers |
  SubtargetFeatures | SubtargetFeatures - Manages the enabling and disabling of subtarget specific features |
  NewArchiveIterator | |
  StackMapV1Parser | |
   AccessorIterator | |
   ConstantAccessor | Accessor for constants |
   FunctionAccessor | Accessor for function records |
   LiveOutAccessor | Accessor for stackmap live-out fields |
   LocationAccessor | Accessor for location records |
   RecordAccessor | Accessor for stackmap records |
  Pass | Pass interface - Implemented by all 'passes' |
  ModulePass | ModulePass class - This class is used to implement unstructured interprocedural optimizations and analyses |
  ImmutablePass | ImmutablePass class - This class is used to provide information that does not need to be run |
  FunctionPass | FunctionPass class - This class is used to implement most global optimizations |
  BasicBlockPass | BasicBlockPass class - This class is used to implement most local optimizations |
  AnalysisUsage | Represent the analysis usage information of a pass |
  AnalysisResolver | |
  PassBuilder | This class provides access to building LLVM's passes |
  PassInfo | PassInfo 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 |
  PassRegistry | PassRegistry - This class manages the registration and intitialization of the pass subsystem as application startup, and assists the PassManager in resolving pass dependencies |
  RegisterPass | 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 |
  RegisterAGBase | RegisterAnalysisGroup - Register a Pass as a member of an analysis group |
  RegisterAnalysisGroup | |
  PassRegistrationListener | PassRegistrationListener 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) |
  DenseMapInfo< coverage::CounterExpression > | Provide DenseMapInfo for CounterExpression |
  InstrProfRecord | Profiling information for a single function |
  InstrProfIterator | A file format agnostic iterator over profiling data |
  InstrProfReader | Base class and interface for reading profiling data of any known instrprof format |
  TextInstrProfReader | Reader for the simple text based instrprof format |
  RawInstrProfReader | Reader for the raw instrprof binary format from runtime |
  InstrProfLookupTrait | Trait for lookups into the on-disk hash table for the binary instrprof format |
  IndexedInstrProfReader | Reader for the indexed binary instrprof format |
  InstrProfWriter | Writer for instrumentation based profile data |
  DenseMapInfo< sampleprof::LineLocation > | |
  AlignmentCalcImpl | |
  AlignOf | AlignOf - A templated class that contains an enum value representing the alignment of the template argument |
  AlignedCharArrayUnion | This union template exposes a suitably aligned and sized character array member which can hold elements of any of up to ten types |
  AllocatorBase | CRTP base class providing obvious overloads for the core Allocate() methods of LLVM-style allocators |
  MallocAllocator | |
  BumpPtrAllocatorImpl | Allocate memory in an ever growing pool, as if by bump-pointer |
  SpecificBumpPtrAllocator | A BumpPtrAllocator that allows only elements of a specific type to be allocated |
  ArrayRecycler | Recycle small arrays allocated from a BumpPtrAllocator |
   Capacity | The size of an allocated array is represented by a Capacity instance |
  BlockFrequency | |
  BranchProbability | |
  simplify_type< const From > | |
  isa_impl | |
  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 |
  isa_impl_cl | |
  isa_impl_cl< To, const From > | |
  isa_impl_cl< To, From * > | |
  isa_impl_cl< To, From *const > | |
  isa_impl_cl< To, const From * > | |
  isa_impl_cl< To, const From *const > | |
  isa_impl_wrap | |
  isa_impl_wrap< To, FromTy, FromTy > | |
  cast_retty | |
  cast_retty_impl | |
  cast_retty_impl< To, const From > | |
  cast_retty_impl< To, From * > | |
  cast_retty_impl< To, const From * > | |
  cast_retty_impl< To, const From *const > | |
  cast_retty_wrap | |
  cast_retty_wrap< To, FromTy, FromTy > | |
  cast_convert_val | |
  cast_convert_val< To, FromTy, FromTy > | |
  is_simple_type | |
  circular_raw_ostream | Circular_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 |
  CrashRecoveryContext | Crash recovery helper object |
  CrashRecoveryContextCleanup | |
  CrashRecoveryContextCleanupBase | |
  CrashRecoveryContextDestructorCleanup | |
  CrashRecoveryContextDeleteCleanup | |
  CrashRecoveryContextReleaseRefCleanup | |
  CrashRecoveryContextCleanupRegistrar | |
  DataExtractor | |
  DataStreamer | |
  DefaultDOTGraphTraits | DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits methods |
  DOTGraphTraits | DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot' graphs |
  ScopedFatalErrorHandler | ScopedFatalErrorHandler - This is a simple helper class which just calls install_fatal_error_handler in its constructor and remove_fatal_error_handler in its destructor |
  ReferenceStorage | Stores a reference that can be changed |
  ErrorOr | Represents either an error or a value T |
  FileOutputBuffer | FileOutputBuffer - This interface provides simple way to create an in-memory buffer which will be written to a file |
  FileRemover | FileRemover - This class is a simple object meant to be stack allocated |
  format_object_base | This is a helper class used for handling formatted output |
  format_object | These are templated helper classes used by the format function that capture the object to be formated and the format string |
  FormattedString | This is a helper class used for left_justify() and right_justify() |
  FormattedNumber | This is a helper class used for format_hex() and format_decimal() |
  formatted_raw_ostream | Formatted_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 |
  GCOVOptions | GCOVOptions - A struct for passing gcov options between functions |
  GCOVBuffer | GCOVBuffer - A wrapper around MemoryBuffer to provide GCOV specific read operations |
  GCOVFile | GCOVFile - Collects coverage information for one pair of coverage file (.gcno and .gcda) |
  GCOVEdge | GCOVEdge - Collects edge information |
  GCOVFunction | GCOVFunction - Collects function information |
  GCOVBlock | GCOVBlock - Collects block information |
  FileInfo | |
  DominatorBase | Base class that other, more interesting dominator analyses inherit from |
  line_iterator | A forward iterator which reads text lines from a buffer |
  LockFileManager | Class that manages the creation of a lock file to aid implicit coordination between different processes |
  object_deleter | Object_deleter - Helper method for ManagedStatic |
  object_deleter< T[N]> | |
  ManagedStaticBase | ManagedStaticBase - Common base class for ManagedStatic instances |
  ManagedStatic | 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_shutdown_obj | Llvm_shutdown_obj - This is a simple helper class that calls llvm_shutdown() when it is destroyed |
  MD5 | |
  MemoryBuffer | This 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 |
  MemoryBufferRef | |
  MemoryObject | Interface to data which might be streamed |
  MutexGuard | Instances of this class acquire a given Mutex Lock when constructed and hold that lock until destruction |
  OnDiskChainedHashTableGenerator | Generates an on disk hash table |
  OnDiskChainedHashTable | Provides lookup on an on disk hash table |
   iterator | |
  OnDiskIterableChainedHashTable | Provides lookup and iteration over an on disk hash table |
   data_iterator | Iterates over all the entries in the table, returning the data |
   key_iterator | Iterates over all of the keys in the table |
  OptionRegistry | Singleton class used to register debug options |
  OutputBuffer | |
  PluginLoader | |
  PointerLikeTypeTraits | 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 |
  PointerLikeTypeTraits< T * > | |
  PointerLikeTypeTraits< const T * > | |
  PointerLikeTypeTraits< uintptr_t > | |
  PrettyStackTraceEntry | PrettyStackTraceEntry - This class is used to represent a frame of the "pretty" stack trace that is dumped when a program crashes |
  PrettyStackTraceString | PrettyStackTraceString - This object prints a specified string (which should not contain newlines) to the stream as the stack trace when a crash occurs |
  PrettyStackTraceProgram | PrettyStackTraceProgram - This object prints a specified program arguments to the stream as the stack trace when a crash occurs |
  RandomNumberGenerator | A random number generator |
  raw_os_ostream | Raw_os_ostream - A raw_ostream that writes to an std::ostream |
  raw_ostream | This class implements an extremely fast bulk output stream that can only output to a stream |
  raw_pwrite_stream | An abstract base class for streams implementations that also support a pwrite operation |
  raw_fd_ostream | A raw_ostream that writes to a file descriptor |
  raw_string_ostream | A raw_ostream that writes to an std::string |
  raw_svector_ostream | A raw_ostream that writes to an SmallVector or SmallString |
  raw_null_ostream | A raw_ostream that discards all output |
  buffer_ostream | |
  RecyclerStruct | RecyclerStruct - Implementation detail for Recycler |
  ilist_traits< RecyclerStruct > | |
  Recycler | Recycler - This class manages a linked-list of deallocated nodes and facilitates reusing deallocated memory in place of allocating new memory |
  RecyclingAllocator | RecyclingAllocator - This class wraps an Allocator, adding the functionality of recycling deleted objects |
  Regex | |
  SimpleRegistryEntry | A simple registry entry which provides only a name, description, and no-argument constructor |
  RegistryTraits | Traits for registry entries |
  Registry | 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 |
   Add | A static registration template |
   iterator | Iterators for registry entries |
   listener | Abstract base class for registry listeners, which are informed when new entries are added to the registry |
   node | Node in linked list of entries |
  RegistryParser | A command-line parser for a registry |
  SaveAndRestore | A utility class that uses RAII to save and restore the value of a variable |
  SaveOr | Similar to SaveAndRestore |
  ScaledNumberBase | |
  ScaledNumber | Simple representation of a scaled number |
  isPodLike< ScaledNumber< T > > | |
  SMLoc | Represents a location in source code |
  SMRange | Represents a range in source code |
  SourceMgr | This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling |
  SMFixIt | Represents a single fixit, a replacement of one range of text with another |
  SMDiagnostic | Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a caret diagnostic |
  SpecialCaseList | |
   Entry | Represents a set of regular expressions |
  StreamingMemoryObject | Interface to data which is actually streamed from a DataStreamer |
  StringPool | StringPool - An interned string pool |
  PooledStringPtr | PooledStringPtr - A pointer to an interned string |
  StringSaver | Saves strings in the inheritor's stable storage and returns a stable raw character pointer |
  BumpPtrStringSaver | |
  ARMTargetParser | |
  Target | Target - Wrapper for Target specific information |
  TargetRegistry | TargetRegistry - Generic interface to target specific features |
   iterator | |
  RegisterTarget | RegisterTarget - Helper template for registering a target, for use in the target's initialization function |
  RegisterMCAsmInfo | RegisterMCAsmInfo - Helper template for registering a target assembly info implementation |
  RegisterMCAsmInfoFn | RegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation |
  RegisterMCCodeGenInfo | RegisterMCCodeGenInfo - Helper template for registering a target codegen info implementation |
  RegisterMCCodeGenInfoFn | RegisterMCCodeGenInfoFn - Helper template for registering a target codegen info implementation |
  RegisterMCInstrInfo | RegisterMCInstrInfo - Helper template for registering a target instruction info implementation |
  RegisterMCInstrInfoFn | RegisterMCInstrInfoFn - Helper template for registering a target instruction info implementation |
  RegisterMCInstrAnalysis | RegisterMCInstrAnalysis - Helper template for registering a target instruction analyzer implementation |
  RegisterMCInstrAnalysisFn | RegisterMCInstrAnalysisFn - Helper template for registering a target instruction analyzer implementation |
  RegisterMCRegInfo | RegisterMCRegInfo - Helper template for registering a target register info implementation |
  RegisterMCRegInfoFn | RegisterMCRegInfoFn - Helper template for registering a target register info implementation |
  RegisterMCSubtargetInfo | RegisterMCSubtargetInfo - Helper template for registering a target subtarget info implementation |
  RegisterMCSubtargetInfoFn | RegisterMCSubtargetInfoFn - Helper template for registering a target subtarget info implementation |
  RegisterTargetMachine | RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function |
  RegisterMCAsmBackend | RegisterMCAsmBackend - Helper template for registering a target specific assembler backend |
  RegisterMCAsmParser | RegisterMCAsmParser - Helper template for registering a target specific assembly parser, for use in the target machine initialization function |
  RegisterAsmPrinter | RegisterAsmPrinter - Helper template for registering a target specific assembly printer, for use in the target machine initialization function |
  RegisterMCCodeEmitter | RegisterMCCodeEmitter - Helper template for registering a target specific machine code emitter, for use in the target initialization function |
  TimeRecord | |
  Timer | Timer - This class is used to track the amount of time spent between invocations of its startTimer()/stopTimer() methods |
  TimeRegion | Used as a helper class to call the startTimer() and stopTimer() methods of the Timer class |
  NamedRegionTimer | NamedRegionTimer - This class is basically a combination of TimeRegion and Timer |
  TimerGroup | Used to group together related timers into a single report that is printed when the TimerGroup is destroyed |
  tool_output_file | This class contains a raw_fd_ostream and adds a few extra features commonly needed for compiler-like tool output files: |
  isPodLike< std::pair< T, U > > | |
  is_integral_or_enum | Metafunction that determines whether the given type is either an integral type or an enumeration type |
  add_lvalue_reference_if_not_pointer | If T is a pointer, just return it. If it is not, return T& |
  add_lvalue_reference_if_not_pointer< T, typename std::enable_if< std::is_pointer< T >::value >::type > | |
  add_const_past_pointer | If T is a pointer to X, return a pointer to const X |
  add_const_past_pointer< T, typename std::enable_if< std::is_pointer< T >::value >::type > | |
  unique_lock | A pared-down imitation of std::unique_lock from C++11 |
  RecTy | |
  BitRecTy | BitRecTy - 'bit' - Represent a single bit |
  BitsRecTy | BitsRecTy - 'bits<n>' - Represent a fixed number of bits |
  IntRecTy | IntRecTy - 'int' - Represent an integer value of no particular size |
  StringRecTy | StringRecTy - 'string' - Represent an string value |
  ListRecTy | ListRecTy - 'list<Ty>' - Represent a list of values, all of which must be of the specified type |
  DagRecTy | DagRecTy - 'dag' - Represent a dag fragment |
  RecordRecTy | RecordRecTy - '[classname]' - Represent an instance of a class, such as: (R32 X = EAX) |
  Init | |
  TypedInit | TypedInit - This is the common super-class of types that have a specific, explicit, type |
  UnsetInit | UnsetInit - ? - Represents an uninitialized value |
  BitInit | BitInit - true/false - Represent a concrete initializer for a bit |
  BitsInit | BitsInit - { a, b, c } - Represents an initializer for a BitsRecTy value |
  IntInit | IntInit - 7 - Represent an initialization by a literal integer value |
  StringInit | StringInit - "foo" - Represent an initialization by a string value |
  ListInit | ListInit - [AL, AH, CL] - Represent a list of defs |
  OpInit | OpInit - Base class for operators |
  UnOpInit | UnOpInit - !op (X) - Transform an init |
  BinOpInit | BinOpInit - !op (X, Y) - Combine two inits |
  TernOpInit | TernOpInit - !op (X, Y, Z) - Combine two inits |
  VarInit | VarInit - 'Opcode' - Represent a reference to an entire variable object |
  VarBitInit | VarBitInit - Opcode{0} - Represent access to one bit of a variable or field |
  VarListElementInit | VarListElementInit - List[4] - Represent access to one element of a var or field |
  DefInit | DefInit - AL - Represent a reference to a 'def' in the description |
  FieldInit | FieldInit - X.Y - Represent a reference to a subfield of a variable |
  DagInit | DagInit - (v a, b) - Represent a DAG tree value |
  RecordVal | |
  Record | |
  MultiClass | |
  RecordKeeper | |
  LessRecord | LessRecord - Sorting predicate to sort record pointers by name |
  LessRecordByID | LessRecordByID - Sorting predicate to sort record pointers by their unique ID |
  LessRecordFieldName | LessRecordFieldName - Sorting predicate to sort record pointers by their name field |
  LessRecordRegister | |
   RecordParts | |
  SetTheory | |
   Expander | Expander - A callback function that can transform a Record representing a set into a fully expanded list of elements |
   Operator | Operator - A callback representing a DAG operator |
  StringMatcher | StringMatcher - Given a list of strings and code to execute when they match, output a simple switch tree to classify the input string |
  StringToOffsetTable | StringToOffsetTable - This class uniques a bunch of nul-terminated strings and keeps track of their offset in a massive contiguous string allocation |
  CostTblEntry | Cost Table Entry |
  TypeConversionCostTblEntry | Type Conversion Cost Table |
  TargetFrameLowering | Information about stack frame layout on the target |
   SpillSlot | |
  TargetInstrInfo | TargetInstrInfo - Interface to description of machine instruction set |
   MachineBranchPredicate | Represents a predicate at the MachineFunction level |
   RegSubRegPair | A pair composed of a register and a sub-register index |
   RegSubRegPairAndIdx | A pair composed of a pair of a register and a sub-register index, and another sub-register index |
  TargetIntrinsicInfo | TargetIntrinsicInfo - Interface to description of machine instruction set |
  TargetLoweringBase | This base class for TargetLowering contains the SelectionDAG-independent parts that can be used from the rest of CodeGen |
   AddrMode | This represents an addressing mode of: BaseGV + BaseOffs + BaseReg + Scale*ScaleReg If BaseGV is null, there is no BaseGV |
   IntrinsicInfo | |
   ValueTypeActionImpl | |
  TargetLowering | This class defines information used to lower LLVM code to legal SelectionDAG operators that the target instruction selector can accept natively |
   ArgListEntry | |
   AsmOperandInfo | This contains information for each constraint that we are lowering |
   CallLoweringInfo | This structure contains all information that is necessary for lowering calls |
   DAGCombinerInfo | |
   TargetLoweringOpt | A convenience struct that encapsulates a DAG, and two SDValues for returning information from TargetLowering to its clients that want to combine |
  TargetLoweringObjectFile | |
  TargetMachine | Primary interface to the complete machine description for the target machine |
  LLVMTargetMachine | This class describes a target machine that is implemented with the LLVM target-independent code generator |
  TargetOptions | |
  TargetRecip | |
  TargetRegisterClass | |
  TargetRegisterInfoDesc | TargetRegisterInfoDesc - Extra information, not in MCRegisterDesc, about registers |
  RegClassWeight | Each TargetRegisterClass has a per register weight, and weight limit which must be less than the limits of its pressure sets |
  TargetRegisterInfo | TargetRegisterInfo 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 |
  SuperRegClassIterator | |
  VirtReg2IndexFunctor | |
  PrintReg | PrintReg - Helper class for printing registers on a raw_ostream |
  PrintRegUnit | PrintRegUnit - Helper class for printing register units on a raw_ostream |
  PrintVRegOrUnit | PrintVRegOrUnit - It is often convenient to track virtual registers and physical register units in the same list |
  TargetSelectionDAGInfo | TargetSelectionDAGInfo - Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process |
  TargetSubtargetInfo | TargetSubtargetInfo - Generic base class for all target subtargets |
  InstCombinePass | |
  InstCombineWorklist | InstCombineWorklist - This is the worklist management logic for InstCombine |
  InstrProfOptions | Options for the frontend instrumentation based profiling pass |
  SanitizerCoverageOptions | |
  Inliner | Inliner - This class contains all of the helper code which is used to perform the inlining operations that do not depend on the policy |
  BitSetInfo | |
  BitSetBuilder | |
  GlobalLayoutBuilder | This class implements a layout algorithm for globals referenced by bit sets that tries to keep members of small bit sets together |
  ByteArrayBuilder | This class is used to build a byte array containing overlapping bit sets |
  PassManagerBuilder | PassManagerBuilder - 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 |
  RegisterStandardPasses | Registers a function for adding a standard set of passes |
  EarlyCSEPass | A simple and fast domtree-based CSE pass |
  LowerExpectIntrinsicPass | |
  SimplifyCFGPass | A pass to simplify and canonicalize the CFG of a function |
  ASanStackVariableDescription | |
  ASanStackFrameLayout | |
  CriticalEdgeSplittingOptions | Option class for critical edge splitting |
  ClonedCodeInfo | ClonedCodeInfo - This struct can be used to capture information about code being cloned, while it is being cloned |
  CloningDirector | A helper class used with CloneAndPruneIntoFromInst to change the default behavior while instructions are being cloned |
  InlineFunctionInfo | InlineFunctionInfo - This class captures the data input to the InlineFunction call, and records the auxiliary results produced by it |
  CodeExtractor | Utility class for extracting code into a new function |
  GlobalStatus | As we analyze each global, keep track of some information about it |
  LICMSafetyInfo | Captures loop safety information |
  RecurrenceDescriptor | The RecurrenceDescriptor is used to identify recurrences variables in a loop |
   InstDesc | This POD struct holds information about a potential recurrence operation |
  LoopVersioning | This class emits a version of the loop where run-time checks ensure that may-alias pointers can't overlap |
  IVVisitor | Interface for visiting interesting IV users that are recognized but not simplified by this utility |
  FortifiedLibCallSimplifier | This 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 |
  LibCallSimplifier | LibCallSimplifier - This class implements a collection of optimizations that replace well formed calls to library functions with a more optimal form |
  SSAUpdater | Helper class for SSA formation on a set of values defined in multiple blocks |
  LoadAndStorePromoter | Helper class for promoting a collection of loads and stores into SSA Form using the SSAUpdater |
  SSAUpdaterImpl | |
  ilist_traits< SymbolRewriter::RewriteDescriptor > | |
  UnifyFunctionExitNodes | |
  ValueMapTypeRemapper | ValueMapTypeRemapper - This is a class that can be implemented by clients to remap types when cloning constants and instructions |
  ValueMaterializer | ValueMaterializer - This is a class that can be implemented by clients to materialize Values on demand |
  VectorizeConfig | Vectorize configuration |
  GraphTraits< BlockFrequencyInfo * > | |
  DOTGraphTraits< BlockFrequencyInfo * > | |
  GraphTraits< IrreducibleGraph > | |
  DOTGraphTraits< DomTreeNode * > | |
  DOTGraphTraits< DominatorTree * > | |
  DOTGraphTraits< PostDominatorTree * > | |
  DOTGraphTraits< CallGraph * > | |
  AnalysisCallGraphWrapperPassTraits | |
  DOTGraphTraits< RegionNode * > | |
  DOTGraphTraits< RegionInfoPass * > | |
  StratifiedInfo | |
  StratifiedLink | |
  StratifiedSets | |
  StratifiedSetsBuilder | |
  LLLexer | |
  ValID | ValID - Represents a reference of a definition of some sort with no type |
  LLParser | |
  OperandTraits< ConstantPlaceHolder > | |
  ValueEnumerator | |
  AggressiveAntiDepState | Contains all the state necessary for anti-dep breaking |
   RegisterReference | Information about a register reference within a liverange |
  AggressiveAntiDepBreaker | |
  AllocationOrder | |
  AntiDepBreaker | This class works in conjunction with the post-RA scheduler to rename registers to break register anti-dependencies (WAR hazards) |
  AddressPool | |
  AsmPrinterHandler | Collects and handles AsmPrinter objects required to build debug or EH information |
  ByteStreamer | |
  APByteStreamer | |
  HashingByteStreamer | |
  BufferByteStreamer | |
  DbgValueHistoryMap | |
  DebugLocEntry | This struct describes location entries emitted in the .debug_loc section |
   Value | A single location or constant |
  DebugLocStream | Byte stream of .debug_loc entries |
   Entry | |
   EntryBuilder | Builder for DebugLocStream entries |
   List | |
   ListBuilder | Builder for DebugLocStream lists |
  DIEHash | An object containing the capability of hashing and adding hash attributes onto a DIE |
  DwarfAccelTable | |
   Atom | |
   HashDataContents | |
  DwarfCompileUnit | |
  SrcLineInfo | This class is used to record source line correspondence |
  DbgVariable | This class is used to track local variable information |
  SymbolCU | Helper used to pair up a symbol and its DWARF compile unit |
  DwarfDebug | Collects and handles dwarf debug information |
  DwarfCFIExceptionBase | |
  DwarfCFIException | |
  ARMException | |
  DwarfExpression | Base class containing the logic for constructing DWARF expressions independently of whether they are emitted into a DIE or into a .debug_loc entry |
  DebugLocDwarfExpression | DwarfExpression implementation for .debug_loc entries |
  DIEDwarfExpression | DwarfExpression implementation for singular DW_AT_location |
  DwarfFile | |
  DwarfStringPool | |
  RangeSpan | |
  RangeSpanList | |
  DwarfUnit | This dwarf writer support class manages information associated with a source file |
  DwarfTypeUnit | |
  EHStreamer | Emits exception handling directives |
   ActionEntry | Structure describing an entry in the actions table |
   CallSiteEntry | Structure describing an entry in the call-site table |
   PadRange | Structure holding a try-range and the associated landing pad |
  WinCodeViewLineTables | Collects and handles line tables information in a CodeView format |
  WinException | |
  BranchFolder | |
  CriticalAntiDepBreaker | |
  DefaultVLIWScheduler | |
  InterferenceCache | |
   Cursor | Cursor - The primary query interface for the block interference cache |
  LiveDebugVariables | |
  LiveRangeCalc | |
  GraphTraits< MachineBlockFrequencyInfo * > | |
  DOTGraphTraits< MachineBlockFrequencyInfo * > | |
  DOTGraphTraits< const MachineFunction * > | |
  MMIAddrLabelMapCallbackPtr | |
  MMIAddrLabelMap | |
  GraphTraits< ScheduleDAGMI * > | |
  DOTGraphTraits< ScheduleDAGMI * > | |
  SSAUpdaterTraits< MachineSSAUpdater > | |
   PHI_iterator | Iterator for PHI operands |
  po_iterator_storage< LoopBounds, true > | |
  MIToken | A token produced by the machine instruction lexer |
  PerFunctionMIParsingState | |
  MIRParserImpl | This class implements the parsing of LLVM IR that's embedded inside a MIR file |
  PassConfigImpl | |
  RegAllocBase | RegAllocBase provides the register allocation driver and interface that can be extended to add interesting heuristics |
  CoalescerPair | A helper class for register coalescers |
  SchedDFSImpl | Internal state used to compute SchedDFSResult |
  DOTGraphTraits< ScheduleDAG * > | |
  InstrEmitter | |
  DAGTypeLegalizer | DAGTypeLegalizer - This takes an arbitrary SelectionDAG as input and hacks on it until only value types the target machine can handle are left |
  ScheduleDAGSDNodes | ScheduleDAGSDNodes - A ScheduleDAG for scheduling SDNode-based DAGs |
   RegDefIter | RegDefIter - In place iteration over the values defined by an SUnit |
  SDDbgValue | SDDbgValue - Holds the information from a dbg_value node through SDISel |
  SelectionDAGBuilder | SelectionDAGBuilder - This is the common target-independent lowering implementation that is parameterized by a TargetLowering object |
  RegsForValue | RegsForValue - This struct represents the registers (physical or virtual) that a particular set of values is assigned, and the type information about the value |
  OptLevelChanger | This class is used by SelectionDAGISel to temporarily override the optimization level on a per-function basis |
  DOTGraphTraits< SelectionDAG * > | |
  StatepointLoweringState | This class tracks both per-statepoint and per-selectiondag information |
  Spiller | Spiller interface |
  SpillPlacement | |
   BlockConstraint | BlockConstraint - Entry and exit constraints for a basic block |
   Node | Node - Each edge bundle corresponds to a Hopfield node |
  SplitAnalysis | SplitAnalysis - Analyze a LiveInterval, looking for live range splitting opportunities |
   BlockInfo | Additional information about basic blocks where the current variable is live |
  SplitEditor | SplitEditor - Edit machine code and LiveIntervals for live range splitting |
  FrameEntry | Abstract frame entry defining the common interface concrete entries implement |
   Instruction | |
  IntelJITEventsWrapper | |
  AllocaHolder | |
  ExecutionContext | |
  Interpreter | |
  LinkingSymbolResolver | |
  MCJIT | |
  RuntimeDyldCheckerExprEval | |
  RuntimeDyldCheckerImpl | |
  RuntimeDyldCOFF | |
  RuntimeDyldELF | |
  SectionEntry | SectionEntry - represents a section emitted into memory by the dynamic linker |
  RelocationEntry | RelocationEntry - used to represent relocations internally in the dynamic linker |
   SectionPair | |
  RelocationValueRef | |
  SymbolTableEntry | Symbol info for RuntimeDyld |
  RuntimeDyldImpl | |
  RuntimeDyldMachO | |
   EHFrameRelatedSections | |
   SectionOffsetPair | |
  RuntimeDyldMachOCRTPBase | RuntimeDyldMachOTarget - Templated base class for generic MachO linker algorithms and data structures |
  RuntimeDyldCOFFX86_64 | |
  RuntimeDyldMachOAArch64 | |
  RuntimeDyldMachOARM | |
  RuntimeDyldMachOI386 | |
  RuntimeDyldMachOX86_64 | |
  SlotTracker | This class provides computation of slot numbers for LLVM Assembly writing |
  AttributeImpl | |
  EnumAttributeImpl | |
  IntAttributeImpl | |
  StringAttributeImpl | |
  AttributeSetNode | |
  AttributeSetImpl | |
  UnaryConstantExpr | UnaryConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement unary constant exprs |
  BinaryConstantExpr | BinaryConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement binary constant exprs |
  SelectConstantExpr | SelectConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement select constant exprs |
  ExtractElementConstantExpr | ExtractElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement extractelement constant exprs |
  InsertElementConstantExpr | InsertElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement insertelement constant exprs |
  ShuffleVectorConstantExpr | ShuffleVectorConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement shufflevector constant exprs |
  ExtractValueConstantExpr | ExtractValueConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement extractvalue constant exprs |
  InsertValueConstantExpr | InsertValueConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement insertvalue constant exprs |
  GetElementPtrConstantExpr | GetElementPtrConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement getelementpr constant exprs |
  CompareConstantExpr | |
  OperandTraits< UnaryConstantExpr > | |
  OperandTraits< BinaryConstantExpr > | |
  OperandTraits< SelectConstantExpr > | |
  OperandTraits< ExtractElementConstantExpr > | |
  OperandTraits< InsertElementConstantExpr > | |
  OperandTraits< ShuffleVectorConstantExpr > | |
  OperandTraits< ExtractValueConstantExpr > | |
  OperandTraits< InsertValueConstantExpr > | |
  OperandTraits< GetElementPtrConstantExpr > | |
  OperandTraits< CompareConstantExpr > | |
  ConstantInfo | |
  ConstantInfo< ConstantExpr > | |
  ConstantInfo< InlineAsm > | |
  ConstantInfo< ConstantArray > | |
  ConstantInfo< ConstantStruct > | |
  ConstantInfo< ConstantVector > | |
  InlineAsmKeyType | |
  ConstantExprKeyType | |
  DenseMapAPIntKeyInfo | |
  DenseMapAPFloatKeyInfo | |
  AnonStructTypeKeyInfo | |
   KeyTy | |
  FunctionTypeKeyInfo | |
   KeyTy | |
  MDNodeOpsKey | Structure for hashing arbitrary MDNode operands |
  MDNodeKeyImpl | |
  MDNodeInfo | DenseMapInfo for MDNode subclasses |
  MDNodeKeyImpl< MDTuple > | DenseMapInfo for MDTuple |
  MDNodeKeyImpl< DILocation > | DenseMapInfo for DILocation |
  MDNodeKeyImpl< GenericDINode > | DenseMapInfo for GenericDINode |
  MDNodeKeyImpl< DISubrange > | |
  MDNodeKeyImpl< DIEnumerator > | |
  MDNodeKeyImpl< DIBasicType > | |
  MDNodeKeyImpl< DIDerivedType > | |
  MDNodeKeyImpl< DICompositeType > | |
  MDNodeKeyImpl< DISubroutineType > | |
  MDNodeKeyImpl< DIFile > | |
  MDNodeKeyImpl< DICompileUnit > | |
  MDNodeKeyImpl< DISubprogram > | |
  MDNodeKeyImpl< DILexicalBlock > | |
  MDNodeKeyImpl< DILexicalBlockFile > | |
  MDNodeKeyImpl< DINamespace > | |
  MDNodeKeyImpl< DIModule > | |
  MDNodeKeyImpl< DITemplateTypeParameter > | |
  MDNodeKeyImpl< DITemplateValueParameter > | |
  MDNodeKeyImpl< DIGlobalVariable > | |
  MDNodeKeyImpl< DILocalVariable > | |
  MDNodeKeyImpl< DIExpression > | |
  MDNodeKeyImpl< DIObjCProperty > | |
  MDNodeKeyImpl< DIImportedEntity > | |
  MDAttachmentMap | Map-like storage for metadata attachments |
  LLVMContextImpl | |
  LLVMDisasmContext | |
  DenseMapInfo< CIEKey > | |
  RecordStreamer | |
  fltSemantics | |
  ilist_sentinel_traits< Token > | |
  ilist_node_traits< Token > | |
  TableGenStringKey | TableGenStringKey - This is a wrapper for std::string suitable for using as a key to a DenseMap |
  DenseMapInfo< TableGenStringKey > | Specialize DenseMapInfo for TableGenStringKey |
  TGLexer | TGLexer - TableGen Lexer class |
  SubClassReference | |
  SubMultiClassReference | |
  LetRecord | |
  ForeachLoop | ForeachLoop - Record the iteration state associated with a for loop |
  TGParser | |
  AArch64FrameLowering | |
  AArch64InstrInfo | |
  AArch64TargetLowering | |
  AArch64FunctionInfo | AArch64FunctionInfo - This class is derived from MachineFunctionInfo and contains private AArch64-specific information for each MachineFunction |
   MILOHDirective | |
  AArch64MCInstLower | AArch64MCInstLower - This class is used to lower an MachineInstr into an MCInst |
  A57ChainingConstraint | Add the accumulator chaining constraint to a PBQP graph |
  AArch64RegisterInfo | |
  AArch64SelectionDAGInfo | |
  AArch64Subtarget | |
  AArch64TargetMachine | |
  AArch64leTargetMachine | |
  AArch64beTargetMachine | |
  AArch64_ELFTargetObjectFile | This implementation is used for AArch64 ELF targets (Linux in particular) |
  AArch64_MachoTargetObjectFile | AArch64_MachoTargetObjectFile - This TLOF implementation is used for Darwin |
  AArch64TTIImpl | |
  AArch64Disassembler | |
  AArch64ExternalSymbolizer | |
  AArch64InstPrinter | |
  AArch64AppleInstPrinter | |
  AArch64MCAsmInfoDarwin | |
  AArch64MCAsmInfoELF | |
  AArch64MCExpr | |
  AArch64TargetStreamer | |
  AArch64NamedImmMapper | Instances of this class can perform bidirectional mapping from random identifier strings to operand encodings |
   Mapping | |
  AMDGPUAsmPrinter | |
  AMDGPUFrameLowering | Information about the stack frame layout on the AMDGPU targets |
  AMDGPUInstrInfo | |
  AMDGPUIntrinsicInfo | |
  AMDGPUTargetLowering | |
  AMDGPUMachineFunction | |
  AMDGPUMCInstLower | |
  AMDGPURegisterInfo | |
  AMDGPUSubtarget | |
  AMDGPUTargetMachine | |
  R600TargetMachine | |
  GCNTargetMachine | |
  AMDGPUTTIImpl | |
  AMDGPUInstPrinter | |
  AMDGPUMCAsmInfo | |
  AMDGPUMCCodeEmitter | |
  AMDGPUTargetStreamer | |
  AMDGPUTargetAsmStreamer | |
  AMDGPUTargetELFStreamer | |
  R600InstrInfo | |
  R600TargetLowering | |
  R600MachineFunctionInfo | |
  R600SchedStrategy | |
  R600RegisterInfo | |
  SIInstrInfo | |
  SITargetLowering | |
  SIMachineFunctionInfo | This class keeps track of the SPI_SP_INPUT_ADDR config register, which tells the hardware which interpolation parameters to load |
   SpilledReg | |
  SIRegisterInfo | |
  ARMAsmPrinter | |
  ARMBaseInstrInfo | |
  ARMBaseRegisterInfo | |
  ARMConstantPoolValue | ARMConstantPoolValue - ARM specific constantpool value |
  ARMConstantPoolConstant | ARMConstantPoolConstant - ARM-specific constant pool values for Constants, Functions, and BlockAddresses |
  ARMConstantPoolSymbol | ARMConstantPoolSymbol - ARM-specific constantpool values for external symbols |
  ARMConstantPoolMBB | ARMConstantPoolMBB - ARM-specific constantpool value of a machine basic block |
  ARMFrameLowering | |
  ARMHazardRecognizer | ARMHazardRecognizer handles special constraints that are not expressed in the scheduling itinerary |
  ARMInstrInfo | |
  ARMTargetLowering | |
  ARMFunctionInfo | ARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific information for each MachineFunction |
  ARMRegisterInfo | |
  ARMSelectionDAGInfo | |
  ARMSubtarget | |
  ARMBaseTargetMachine | |
  ARMTargetMachine | ARMTargetMachine - ARM target machine |
  ARMLETargetMachine | ARMLETargetMachine - ARM little endian target machine |
  ARMBETargetMachine | ARMBETargetMachine - ARM big endian target machine |
  ThumbTargetMachine | ThumbTargetMachine - Thumb target machine |
  ThumbLETargetMachine | ThumbLETargetMachine - Thumb little endian target machine |
  ThumbBETargetMachine | ThumbBETargetMachine - Thumb big endian target machine |
  ARMElfTargetObjectFile | |
  ARMTTIImpl | |
  ARMInstPrinter | |
  ARMMCAsmInfoDarwin | |
  ARMELFMCAsmInfo | |
  ARMCOFFMCAsmInfoMicrosoft | |
  ARMCOFFMCAsmInfoGNU | |
  ARMMCExpr | |
  UnwindOpcodeAssembler | |
  Thumb1FrameLowering | |
  Thumb1InstrInfo | |
  Thumb2InstrInfo | |
  ThumbRegisterInfo | |
  BPFFrameLowering | |
  BPFInstrInfo | |
  BPFTargetLowering | |
  BPFMCInstLower | |
  BPFRegisterInfo | |
  BPFSubtarget | |
  BPFTargetMachine | |
  BPFInstPrinter | |
  BPFMCAsmInfo | |
  CPPTargetMachine | |
  BitTracker | |
   BitMask | |
   BitRef | |
   BitValue | |
   CellMapType | |
   MachineEvaluator | |
   RegisterCell | |
   RegisterRef | |
  HexagonAsmPrinter | |
  HexagonEvaluator | |
  HexagonFrameLowering | |
  HexagonInstrInfo | |
  HexagonTargetLowering | |
  HexagonMachineFunctionInfo | Hexagon target-specific information for each MachineFunction |
  VLIWResourceModel | |
  VLIWMachineScheduler | Extend the standard ScheduleDAGMI to provide more context and override the top-level schedule() driver |
  ConvergingVLIWScheduler | ConvergingVLIWScheduler shrinks the unscheduled zone using heuristics to balance the schedule |
  HexagonRegisterInfo | |
  HexagonSelectionDAGInfo | |
  HexagonSubtarget | |
  HexagonTargetMachine | |
  HexagonTargetObjectFile | |
  HexagonTargetStreamer | |
  HexagonAsmInstPrinter | |
  HexagonInstPrinter | Prints 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 |
  HexagonMCAsmInfo | |
  HexagonMCCodeEmitter | |
  HexagonMCELFStreamer | |
  DuplexCandidate | |
  HexagonMCShuffler | |
  HexagonResource | |
  HexagonInstr | |
  HexagonShuffler | |
  MipsInstPrinter | |
  MipsABIFlagsSection | |
  MipsABIInfo | |
  MipsAsmBackend | |
  MipsELFStreamer | |
  MipsMCAsmInfo | |
  MipsMCCodeEmitter | |
  MipsMCExpr | |
  Mips16FrameLowering | |
  Mips16InstrInfo | |
  Mips16DAGToDAGISel | |
  Mips16TargetLowering | |
  Mips16RegisterInfo | |
  MipsAnalyzeImmediate | |
   Inst | |
  MipsAsmPrinter | |
  MipsCCState | |
  MipsFrameLowering | |
  MipsInstrInfo | |
  MipsDAGToDAGISel | |
  MipsTargetLowering | |
   LTStr | |
  MipsCallEntry | A class derived from PseudoSourceValue that represents a GOT entry resolved by lazy-binding |
  MipsFunctionInfo | MipsFunctionInfo - This class is derived from MachineFunction private Mips target-specific information for each MachineFunction |
  MipsMCInstLower | MipsMCInstLower - This class is used to lower an MachineInstr into an |
  MipsOptionRecord | |
  MipsRegInfoRecord | |
  MipsRegisterInfo | |
  MipsSEFrameLowering | |
  MipsSEInstrInfo | |
  MipsSEDAGToDAGISel | |
  MipsSETargetLowering | |
  MipsSERegisterInfo | |
  MipsSubtarget | |
  MipsTargetMachine | |
  MipsebTargetMachine | MipsebTargetMachine - Mips32/64 big endian target machine |
  MipselTargetMachine | MipselTargetMachine - Mips32/64 little endian target machine |
  MipsTargetObjectFile | |
  MipsTargetStreamer | |
  MipsTargetAsmStreamer | |
  MipsTargetELFStreamer | |
  MSP430InstPrinter | |
  MSP430MCAsmInfo | |
  MSP430FrameLowering | |
  MSP430InstrInfo | |
  MSP430TargetLowering | |
  MSP430MachineFunctionInfo | MSP430MachineFunctionInfo - This class is derived from MachineFunction and contains private MSP430 target-specific information for each MachineFunction |
  MSP430MCInstLower | MSP430MCInstLower - This class is used to lower an MachineInstr into an MCInst |
  MSP430RegisterInfo | |
  MSP430Subtarget | |
  MSP430TargetMachine | MSP430TargetMachine |
  NVPTXInstPrinter | |
  ManagedStringPool | ManagedStringPool - The strings allocated from a managed string pool are owned by the string pool and will be deleted together with the managed string pool |
  NVPTXMCAsmInfo | |
  LineReader | |
  NVPTXAsmPrinter | |
  NVPTXFrameLowering | |
  NVPTXInstrInfo | |
  NVPTXTargetLowering | |
  NVPTXMachineFunctionInfo | |
  NVPTXFloatMCExpr | |
  NVPTXGenericMCSymbolRefExpr | A wrapper for MCSymbolRefExpr that tells the assembly printer that the symbol should be enclosed by generic() |
  NVPTXRegisterInfo | |
  NVPTXSection | NVPTXSection - Represents a section in PTX PTX does not have sections |
  NVPTXSubtarget | |
  NVPTXTargetMachine | NVPTXTargetMachine |
  NVPTXTargetMachine32 | |
  NVPTXTargetMachine64 | |
  NVPTXTargetObjectFile | |
  NVPTXTTIImpl | |
  PPCInstPrinter | |
  PPCMCAsmInfoDarwin | |
  PPCELFMCAsmInfo | |
  PPCMCExpr | |
  PPCFrameLowering | |
  PPCDispatchGroupSBHazardRecognizer | PPCDispatchGroupSBHazardRecognizer - This class implements a scoreboard-based hazard recognizer for PPC ooo processors with dispatch-group hazards |
  PPCHazardRecognizer970 | PPCHazardRecognizer970 - This class defines a finite state automata that models the dispatch logic on the PowerPC 970 (aka G5) processor |
  PPCInstrInfo | |
  PPCTargetLowering | |
  PPCFunctionInfo | PPCFunctionInfo - This class is derived from MachineFunction private PowerPC target-specific information for each MachineFunction |
  PPCRegisterInfo | |
  PPCSubtarget | |
  PPCTargetMachine | PPCTargetMachine - Common code between 32-bit and 64-bit PowerPC targets |
  PPC32TargetMachine | PPC32TargetMachine - PowerPC 32-bit target machine |
  PPC64TargetMachine | PPC64TargetMachine - PowerPC 64-bit target machine |
  PPC64LinuxTargetObjectFile | PPC64LinuxTargetObjectFile - This implementation is used for 64-bit PowerPC Linux |
  PPCTargetStreamer | |
  PPCTTIImpl | |
  SparcInstPrinter | |
  SparcELFMCAsmInfo | |
  SparcMCExpr | |
  SparcFrameLowering | |
  SparcInstrInfo | |
  SparcTargetLowering | |
  SparcMachineFunctionInfo | |
  SparcRegisterInfo | |
  SparcSubtarget | |
  SparcTargetMachine | |
  SparcV8TargetMachine | SparcV8TargetMachine - Sparc 32-bit target machine |
  SparcV9TargetMachine | SparcV9TargetMachine - Sparc 64-bit target machine |
  SparcelTargetMachine | |
  SparcELFTargetObjectFile | |
  SparcTargetStreamer | |
  SparcTargetAsmStreamer | |
  SparcTargetELFStreamer | |
  SystemZInstPrinter | |
  SystemZMCAsmInfo | |
  SystemZAsmPrinter | |
  SystemZCCState | |
  SystemZConstantPoolValue | A SystemZ-specific constant pool value |
  SystemZFrameLowering | |
  SystemZInstrInfo | |
  SystemZTargetLowering | |
  SystemZMachineFunctionInfo | |
  SystemZMCInstLower | |
  SystemZRegisterInfo | |
  SystemZSelectionDAGInfo | |
  SystemZSubtarget | |
  SystemZTargetMachine | |
  SystemZTTIImpl | |
  WebAssemblyInstPrinter | |
  WebAssemblyMCAsmInfo | |
  WebAssemblyFrameLowering | |
  WebAssemblyInstrInfo | |
  WebAssemblyTargetLowering | |
  WebAssemblyFunctionInfo | This class is derived from MachineFunctionInfo and contains private WebAssembly-specific information for each MachineFunction |
  WebAssemblyRegisterInfo | |
  WebAssemblySelectionDAGInfo | |
  WebAssemblySubtarget | |
  WebAssemblyTargetMachine | |
  WebAssemblyTargetObjectFile | |
  WebAssemblyTTIImpl | |
  X86AsmInstrumentation | |
  X86Operand | X86Operand - Instances of this class represent a parsed X86 machine instruction |
   ImmOp | |
   MemOp | |
   RegOp | |
   TokOp | |
  X86ATTInstPrinter | |
  X86IntelInstPrinter | |
  X86MCAsmInfoDarwin | |
  X86_64MCAsmInfoDarwin | |
  X86ELFMCAsmInfo | |
  X86MCAsmInfoMicrosoft | |
  X86MCAsmInfoGNUCOFF | |
  X86AsmPrinter | |
  X86FrameLowering | |
  X86AddressMode | X86AddressMode - This struct holds a generalized full x86 address mode |
  X86InstrInfo | |
  IntrinsicData | |
  X86TargetLowering | |
  X86MachineFunctionInfo | X86MachineFunctionInfo - This class is derived from MachineFunction and contains private X86 target-specific information for each MachineFunction |
  X86RegisterInfo | |
  X86SelectionDAGInfo | |
  X86Subtarget | |
  X86TargetMachine | |
  X86_64MachoTargetObjectFile | X86_64MachoTargetObjectFile - This TLOF implementation is used for Darwin x86-64 |
  X86ELFTargetObjectFile | This implemenatation is used for X86 ELF targets that don't have a further specialization |
  X86LinuxNaClTargetObjectFile | X86LinuxNaClTargetObjectFile - This implementation is used for linux and Native Client on x86 and x86-64 |
  X86WindowsTargetObjectFile | This implementation is used for Windows targets on x86 and x86-64 |
  X86TTIImpl | |
  XCoreInstPrinter | |
  XCoreMCAsmInfo | |
  XCoreFrameLowering | |
  XCoreInstrInfo | |
  XCoreTargetLowering | |
  XCoreFunctionInfo | XCoreFunctionInfo - This class is derived from MachineFunction private XCore target-specific information for each MachineFunction |
  XCoreMCInstLower | This class is used to lower an MachineInstr into an MCInst |
  XCoreRegisterInfo | |
  XCoreSelectionDAGInfo | |
  XCoreSubtarget | |
  XCoreTargetMachine | |
  XCoreTargetObjectFile | |
  XCoreTargetStreamer | |
  XCoreTTIImpl | |
  InstCombineIRInserter | An IRBuilder inserter that adds new instructions to the instcombine worklist |
  InstCombiner | The core instruction combiner logic |
  DenseMapInfo< LoweredPHIRecord > | |
  MaximumSpanningTree | MaximumSpanningTree - A MST implementation |
  GraphTraits< ArgumentGraphNode * > | |
  GraphTraits< ArgumentGraph * > | |
  BlotMapVector | An associative container with fast insertion-order (deterministic) iteration over its elements |
  DenseMapInfo< SimpleValue > | |
  DenseMapInfo< CallValue > | |
  DenseMapInfo< Expression > | |
  isPodLike< Slice > | |
  DenseMapInfo< DivOpInfo > | |
  SSAUpdaterTraits< SSAUpdater > | |
   PHI_iterator | |
 MemRef | |
 MSP430CC | |
 OpName | |
 R600_InstFlag | |
 ShaderType | |
 SIInstrFlags | |
 SIOutMods | |
 SISrcMods | |
 stats | |
 std | |
  is_error_code_enum< llvm::BitcodeError > | |
  hash< llvm::PDB_SymType > | |
  is_error_code_enum< llvm::object::object_error > | |
  is_error_code_enum< llvm::coveragemap_error > | |
  is_error_code_enum< llvm::instrprof_error > | |
  is_error_code_enum< llvm::sampleprof_error > | |
  is_error_code_enum< llvm::errc > | |
 true | |
  DivergencePropagator | |
 ___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 | |
 AArch64GenInstrInfo | |
 AArch64GenRegisterInfo | |
 AArch64GenSubtargetInfo | |
 AArch64SetCCInfo | Helper structure to keep track of a SET_CC lowered into AArch64 code |
 AddSubFlagsOpcodePair | Map pseudo instructions that imply an 'S' bit onto real opcodes |
 AlignedCharArray | Helper for building an aligned character array type |
 AllocFnsTy | |
 amd_kernel_code_s | AMD Kernel Code Object (amd_kernel_code_t) |
 AMDGPUGenInstrInfo | |
 AMDGPUGenRegisterInfo | |
 AMDGPUGenSubtargetInfo | |
 ArangeSpan | |
 ARM_MLxEntry | ARM_MLxEntry - Record information about MLA / MLS instructions |
 ARMGenInstrInfo | |
 ARMGenRegisterInfo | |
 ARMGenSubtargetInfo | |
 BPFGenInstrInfo | |
 BPFGenRegisterInfo | |
 BPFGenSubtargetInfo | |
 cclass | |
 cname | |
 CommonHandleTraits | |
 ContextDecision | Specifies which opcode->instruction tables to look at given a particular context (set of attributes) |
 CryptContextTraits | |
 cset | |
 DataType | |
 decimalInfo | |
 FileHandleTraits | |
 FindHandleTraits | |
 GenericSetCCInfo | Helper structure to keep track of ISD::SET_CC operands |
 HexagonBid | |
 HexagonGenInstrInfo | |
 HexagonGenRegisterInfo | |
 HexagonGenSubtargetInfo | |
 HexagonUnitAuction | |
 hsa_dim3_s | |
 hsa_ext_control_directives_s | The hsa_ext_control_directives_t specifies the values for the HSAIL control directives |
 jit_code_entry | |
 jit_descriptor | |
 JobHandleTraits | |
 LdStNInstrDesc | |
 llvm_regex | |
 llvm_regmatch_t | |
 LLVMMCJITCompilerOptions | |
 LLVMOpInfo1 | |
 LLVMOpInfoSymbol1 | The initial support in LLVM MC for the most general form of a relocatable expression is "AddSymbol - SubtractSymbol + Offset" |
 MarkPendingLoopPredicate | RAII wrapper to prevent recursive application of isImpliedCond |
 MipsGenInstrInfo | |
 MipsGenRegisterInfo | |
 MipsGenSubtargetInfo | |
 ModRMDecision | Specifies whether a ModR/M byte is needed and (if so) which instruction each possible value of the ModR/M byte corresponds to |
 MSP430GenInstrInfo | |
 MSP430GenRegisterInfo | |
 MSP430GenSubtargetInfo | |
 MyFuzzer | |
 NVPTXGenInstrInfo | |
 NVPTXGenRegisterInfo | |
 NVPTXGenSubtargetInfo | |
 OpcodeDecision | Specifies which set of ModR/M->instruction tables to look at given a particular opcode |
 parse | |
 PPCGenInstrInfo | |
 PPCGenRegisterInfo | |
 PPCGenSubtargetInfo | |
 Predicate | |
 re_guts | |
 Region | |
 rerr | |
 ScopedHandle | |
 SetCCInfo | Helper structure to keep track of SetCC information |
 SetCCInfoAndKind | Helper structure to be able to read SetCC information |
 SparcGenInstrInfo | |
 SparcGenRegisterInfo | |
 SparcGenSubtargetInfo | |
 SystemZGenInstrInfo | |
 SystemZGenRegisterInfo | |
 SystemZGenSubtargetInfo | |
 T | |
 ThreadInfo | |
 ThreadStack | |
 WebAssemblyGenRegisterInfo | |
 WebAssemblyGenSubtargetInfo | |
 X86GenInstrInfo | |
 X86GenRegisterInfo | |
 X86GenSubtargetInfo | |
 X86MemoryFoldTableEntry | |
 XCoreGenInstrInfo | |
 XCoreGenRegisterInfo | |
 XCoreGenSubtargetInfo | |