 adjust | |
  ldi | Fixups relating to the LDI instruction |
 AllocaSlices | |
  partition_iterator | An iterator over partitions of the alloca's slices |
  SliceBuilder | Builder for the alloca slices |
 AMDGPU | |
  PT_NOTE | |
  RuntimeMD | |
   Kernel | |
    Metadata | |
   KernelArg | |
    Metadata | |
   KeyName | |
   Program | |
    Metadata | |
 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 | |
  LibCallsShrinkWrap | |
 fuzzer | |
  InputInfo | |
  InputCorpus | |
  ScopedDoingMyOwnMemmem | |
  FixedWord | |
  DictionaryEntry | |
  Dictionary | |
  FlagDescription | |
  ExternalFunctions | |
  Fuzzer | |
   Coverage | |
  MallocFreeTracer | |
  MergeFileInfo | |
  Merger | |
  MutationDispatcher | |
  FuzzingOptions | |
  Random | |
  TableOfRecentCompares | |
   Pair | |
  TracePC | |
  TraceBasedMutation | |
  TraceState | |
  ValueBitMap | |
 kOCLMD | |
 llvm | Compute iterated dominance frontiers using a linear time algorithm |
  AArch64 | |
  AArch64_AM | AArch64_AM - AArch64 Addressing Mode Stuff |
  AArch64AT | |
   AT | |
  AArch64CC | |
  AArch64DB | |
   DB | |
  AArch64DC | |
   DC | |
  AArch64IC | |
   IC | |
  AArch64II | |
  AArch64ISB | |
   ISB | |
  AArch64ISD | |
  AArch64Layout | |
  AArch64PRFM | |
   PRFM | |
  AArch64PSBHint | |
   PSB | |
  AArch64PState | |
   PState | |
  AArch64SE | |
  AArch64SysReg | |
   SysReg | |
  AArch64TLBI | |
   TLBI | |
  AMDGPU | |
   EncValues | |
   Hwreg | |
   SDWA | |
   SendMsg | |
   IsaVersion | |
  AMDGPUAsmVariants | |
  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 | |
  AVR | Contains the AVR backend |
   fixups | |
  AVRCC | |
  AVRII | |
  AVRISD | |
  bfi_detail | |
   BlockEdgesAdder | |
   BlockMass | Mass of a block |
   TypeMap | |
   TypeMap< BasicBlock > | |
   TypeMap< MachineBasicBlock > | |
   IrreducibleGraph | Graph of irreducible control flow |
    IrrNode | |
  bitc | |
  BitmaskEnumDetail | |
  BPFISD | |
  CallingConv | CallingConv Namespace - This namespace contains an enum with a value for the well-known calling conventions |
  cflaa | |
   InterfaceValue | We use InterfaceValue to describe parameters/return value, as well as potential memory locations that are pointed to by parameters/return value, of a function |
   ExternalRelation | We use ExternalRelation to describe an externally visible aliasing relations between parameters/return value of a function |
   ExternalAttribute | We use ExternalAttribute to describe an externally visible AliasAttrs for parameters/return value |
   AliasSummary | AliasSummary is just a collection of ExternalRelation and ExternalAttribute |
   InstantiatedValue | This is the result of instantiating InterfaceValue at a particular callsite |
   InstantiatedRelation | This is the result of instantiating ExternalRelation at a particular callsite |
   InstantiatedAttr | This is the result of instantiating ExternalAttribute at a particular callsite |
   CFLGraph | The Program Expression Graph (PEG) of CFL analysis CFLGraph is auxiliary data structure used by CFL-based alias analysis to describe flow-insensitive pointer-related behaviors |
    Edge | |
    NodeInfo | |
    ValueInfo | |
   CFLGraphBuilder | A builder class used to create CFLGraph instance from a given function The CFL-AA that uses this builder must provide its own type as a template argument |
   StratifiedInfo | NOTE: ^ This can't be a short – bootstrapping clang has a case where ~1M sets exist |
   StratifiedLink | A "link" between two StratifiedSets |
   StratifiedSets | These are stratified sets, as described in "Fast algorithms for
Dyck-CFL-reachability with applications to Alias Analysis" by Zhang Q, Lyu M R, Yuan H, and Su Z |
   StratifiedSetsBuilder | Generic Builder class that produces StratifiedSets instances |
  CGSCCAnalysisManagerModuleProxy | |
   Result | We need a specialized result for the CGSCCAnalysisManagerModuleProxy so it can have access to the call graph in order to walk all the SCCs when invalidating things |
  cl | Cl Namespace - This namespace contains all of the command line option processing machinery |
   OptionCategory | |
   SubCommand | |
   Option | |
   desc | |
   value_desc | |
   initializer | |
   LocationClass | |
   cat | |
   sub | |
   GenericOptionValue | |
   OptionValue | |
   OptionValueBase | |
   OptionValueCopy | |
   OptionValueBase< DataType, false > | |
   OptionValue< cl::boolOrDefault > | |
   OptionValue< std::string > | |
   OptionEnumValue | |
   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< StringRef > | |
   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 | |
  codeview | |
   CodeViewError | Base class for errors originating when parsing raw PDB files |
   CodeViewRecordIO | |
   PDB70DebugInfo | |
   PDB20DebugInfo | |
   DebugInfo | |
   CVRecord | |
   CVSymbolVisitor | |
   CVTypeDumper | Dumper for CodeView type streams found in COFF object files and PDB files |
   CVTypeVisitor | |
   FunctionId | |
   LineInfo | |
   ColumnInfo | |
   Line | |
   InlineeSourceLine | |
   FileChecksum | |
   ModuleSubsectionHeader | |
   LineSubstreamHeader | |
   LineFileBlockHeader | |
   LineNumberEntry | |
   ColumnNumberEntry | |
   ModuleSubstream | |
   LineColumnEntry | |
   FileChecksumEntry | |
   IModuleSubstreamVisitor | |
   RecordPrefix | |
   serialize_conditional_impl | |
   serialize_array_impl | |
   serialize_vector_tail_impl | |
   serialize_null_term_string_array_impl | |
   serialize_arrayref_tail_impl | |
   serialize_numeric_impl | |
   SymbolDeserializer | |
   SymbolDumpDelegate | |
   CVSymbolDumper | Dumper for CodeView symbol streams found in COFF object files and PDB files |
   SymbolRecord | |
   ProcSym | |
   Thunk32Sym | |
   TrampolineSym | |
   SectionSym | |
   CoffGroupSym | |
   ScopeEndSym | |
   CallerSym | |
   BinaryAnnotationIterator | |
    AnnotationData | |
   InlineSiteSym | |
   PublicSym32 | |
   RegisterSym | |
   ProcRefSym | |
   LocalSym | |
   LocalVariableAddrRange | |
   LocalVariableAddrGap | |
   DefRangeSym | |
   DefRangeSubfieldSym | |
   DefRangeRegisterSym | |
    Header | |
   DefRangeSubfieldRegisterSym | |
    Header | |
   DefRangeFramePointerRelSym | |
   DefRangeRegisterRelSym | |
    Header | |
   DefRangeFramePointerRelFullScopeSym | |
   BlockSym | |
   LabelSym | |
   ObjNameSym | |
   EnvBlockSym | |
   ExportSym | |
   FileStaticSym | |
   Compile2Sym | |
   Compile3Sym | |
   FrameProcSym | |
   CallSiteInfoSym | |
   HeapAllocationSiteSym | |
   FrameCookieSym | |
   UDTSym | |
   BuildInfoSym | |
   BPRelativeSym | |
   RegRelativeSym | |
   ConstantSym | |
   DataSym | |
   ThreadLocalDataSym | |
   SymbolRecordMapping | |
   SymbolSerializer | |
   SymbolVisitorCallbackPipeline | |
   SymbolVisitorCallbacks | |
   SymbolVisitorDelegate | |
   TypeDatabase | |
   TypeDatabaseVisitor | Dumper for CodeView type streams found in COFF object files and PDB files |
   TypeDeserializer | |
   FieldListDeserializer | |
   TypeDumpVisitor | Dumper for CodeView type streams found in COFF object files and PDB files |
   TypeIndex | A 32-bit type reference |
   CVMemberRecord | |
   MemberAttributes | Equvalent to CV_fldattr_t in cvinfo.h |
   MemberPointerInfo | |
   TypeRecord | |
   ModifierRecord | |
   ProcedureRecord | |
   MemberFunctionRecord | |
   MemberFuncIdRecord | |
   ArgListRecord | |
   PointerRecord | |
   NestedTypeRecord | |
   FieldListRecord | |
   ArrayRecord | |
   TagRecord | |
   ClassRecord | |
   UnionRecord | |
   EnumRecord | |
   BitFieldRecord | |
   VFTableShapeRecord | |
   TypeServer2Record | |
   StringIdRecord | |
   FuncIdRecord | |
   UdtSourceLineRecord | |
   UdtModSourceLineRecord | |
   BuildInfoRecord | |
   VFTableRecord | |
   OneMethodRecord | |
   MethodOverloadListRecord | |
   OverloadedMethodRecord | For method overload sets. LF_METHOD |
   DataMemberRecord | |
   StaticDataMemberRecord | |
   EnumeratorRecord | |
   VFPtrRecord | |
   BaseClassRecord | |
   VirtualBaseClassRecord | |
   ListContinuationRecord | LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records together |
   TypeRecordBuilder | |
   TypeRecordMapping | |
   TypeSerializer | |
   TypeSymbolEmitter | |
   TypeTableBuilder | |
   FieldListRecordBuilder | |
   TypeVisitorCallbackPipeline | |
   TypeVisitorCallbacks | |
  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 | |
  consthoist | A private "module" namespace for types and utilities used by ConstantHoisting |
   ConstantUser | Keeps track of the user of a constant and the operand index where the constant is used |
   ConstantCandidate | Keeps track of a constant candidate and its uses |
   RebasedConstantInfo | This represents a constant that has been rebased with respect to a base constant |
   ConstantInfo | A base constant and all its rebased constants |
  coro | |
   LowererBase | |
   Shape | |
  coverage | |
   CoverageMapError | |
   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 |
   CovMapFunctionRecordV1 | |
   CovMapFunctionRecord | |
   CovMapHeader | |
   CovMapTraits | |
   CovMapTraits< CovMapVersion::Version1, IntPtrT > | |
   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 |
   RawCoverageMappingDummyChecker | Checks if the given coverage mapping data is exported for an unused function |
   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 |
   IEEEFloat | |
   DoubleAPFloat | |
   DenseMapPair | |
   DenseSetEmpty | |
   DenseSetPair | |
   DenseSetImpl | Base class for DenseSet and DenseSmallSet |
    ConstIterator | |
    Iterator | |
   PointerSumTypeHelper | A helper template for implementing PointerSumType |
    Checker | |
    Checker< MemberT > | |
    Lookup | |
    Min | |
    Min< V > | |
   scope_exit | |
   value_sequence_iterator | |
   zip_first | |
   zip_shortest | |
   zippy | |
   concat_range | Helper to store a sequence of ranges being concatenated and access them |
   enumerator_impl | |
    iterator | |
    result_pair | |
   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 |
   PassConcept | Template for the abstract base class used to dispatch polymorphically over pass objects |
   PassModel | A template wrapper used to implement the polymorphic API |
   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, InvalidatorT, false > | Specialization of AnalysisResultModel which provides the default invalidate functionality |
   AnalysisResultModel< IRUnitT, PassT, ResultT, PreservedAnalysesT, InvalidatorT, 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 |
   AlignerImpl | |
   SizerImpl | |
   AlignAdapter | |
   PadAdapter | |
   RepeatAdapter | |
   use_integral_formatter | |
   use_char_formatter | |
   is_cstring | |
   use_string_formatter | |
   use_pointer_formatter | |
   use_double_formatter | |
   HelperFunctions | |
   range_item_has_provider | |
   format_adapter | |
   provider_format_adapter | |
   missing_format_adapter | |
   has_FormatProvider | |
   uses_format_member | |
   uses_format_provider | |
   uses_missing_provider | |
   DominatorTreeBaseTraits | |
   TrailingZerosCounter | |
   LeadingZerosCounter | |
   PopulationCounter | |
   PopulationCounter< T, 8 > | |
   OptionKey | |
   ConstantLog2 | A tiny meta function to compute the log2 of a compile time constant |
   ConstantLog2< 1 > | |
  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 |
  DWARFYAML | |
   AttributeAbbrev | |
   Abbrev | |
   ARangeDescriptor | |
   ARange | |
   PubEntry | |
   PubSection | |
   FormValue | |
   Entry | |
   Unit | |
   File | |
   LineTableOpcode | |
   LineTable | |
   Data | |
  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 | |
   Elf32_Chdr | |
   Elf64_Chdr | |
  ELFYAML | |
   FileHeader | |
   Symbol | |
   LocalGlobalWeakSymbols | |
   SectionOrType | |
   Section | |
   RawContentSection | |
   NoBitsSection | |
   Group | |
   Relocation | |
   RelocationSection | |
   MipsABIFlags | |
   Object | |
  EngineKind | |
  FloatABI | |
  FPDenormal | |
  FPOpFusion | |
  GC | |
  GCOV | |
   Options | A struct for passing gcov options between functions |
  GraphProgram | |
  gvn | |
   AvailableValue | Represents a particular available value that we know how to materialize |
   AvailableValueInBlock | Represents an AvailableValue which can be rematerialized at the end of the associated BasicBlock |
   GVNLegacyPass | |
  GVNExpression | |
   Expression | |
   BasicExpression | |
   op_inserter | |
   CallExpression | |
   LoadExpression | |
   StoreExpression | |
   AggregateValueExpression | |
   int_op_inserter | |
   PHIExpression | |
   VariableExpression | |
   ConstantExpression | |
   UnknownExpression | |
  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 | |
  Hexagon_MC | |
  HexagonII | HexagonII - This namespace holds all of the target specific flags that instruction info tracks |
  HexagonISD | |
  HexagonMCInstrInfo | |
  HexStyle | |
  ilist_detail | |
   HasGetNext | Type trait to check for a traits class that has a getNext member (as a canary for any of the ilist_nextprev_traits API) |
    SFINAE | |
   HasCreateSentinel | Type trait to check for a traits class that has a createSentinel member (as a canary for any of the ilist_sentinel_traits API) |
   HasCreateNode | Type trait to check for a traits class that has a createNode member |
    SFINAE | |
   HasObsoleteCustomization | |
   IteratorTraits | Find const-correct node types |
   IteratorTraits< OptionsT, false > | |
   IteratorTraits< OptionsT, true > | |
   IteratorHelper | |
   IteratorHelper< false > | |
   IteratorHelper< true > | |
   NodeAccess | An access class for ilist_node private API |
   SpecificNodeAccess | |
   explicitness | Helper trait for recording whether an option is specified explicitly |
   is_valid_option | Check whether an option is valid |
   extract_sentinel_tracking | Extract sentinel tracking option |
   extract_sentinel_tracking< ilist_sentinel_tracking< EnableSentinelTracking >, Options...> | |
   extract_sentinel_tracking< Option1, Options...> | |
   extract_sentinel_tracking<> | |
   is_valid_option< ilist_sentinel_tracking< EnableSentinelTracking > > | |
   extract_tag | Extract custom tag option |
   extract_tag< ilist_tag< Tag >, Options...> | |
   extract_tag< Option1, Options...> | |
   extract_tag<> | |
   is_valid_option< ilist_tag< Tag > > | |
   check_options | Check whether options are valid |
   check_options<> | |
   check_options< Option1, Options...> | |
   node_options | Traits for options for ilist_node |
   compute_node_options | |
  IndexedInstrProf | |
   Header | |
   Summary | |
    Entry | |
  InlineConstants | |
  internal | |
  IntervalMapImpl | IntervalMapImpl - Namespace used for IntervalMap implementation details |
   NodeBase | |
   NodeSizer | |
   NodeRef | |
   LeafNode | |
   BranchNode | |
   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 | |
  jumpthreading | A private "module" namespace for types and utilities used by JumpThreading |
  Lanai | |
  LanaiII | |
  LanaiISD | |
  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 | |
  LLVM_LIBRARY_VISIBILITY | A private "module" namespace for types and utilities used by GVN |
  LoopAnalysisManagerFunctionProxy | |
   Result | A specialized result for the LoopAnalysisManagerFunctionProxy which retains a LoopInfo reference |
  lowertypetests | |
   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 |
  LPAC | |
  LPCC | |
  lto | |
   Config | LTO configuration |
   LTOLLVMContext | A derived class of LLVMContext that initializes itself according to a given Config object |
   InputFile | An input file |
    InputModule | |
    Symbol | This is a wrapper for ArrayRef<ModuleSymbolTable::Symbol>::iterator that exposes only the information that an LTO client should need in order to do symbol resolution |
    symbol_iterator | |
   NativeObjectStream | This class wraps an output stream for a native object |
   LTO | This class implements a resolution-based interface to LLVM's LTO functionality |
   SymbolResolution | The resolution for a symbol |
   ThinBackendProc | This class defines the interface to the ThinLTO backend |
  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 | |
   fat_arch_64 | |
   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 | |
   arm_thread_state32_t | |
   arm_thread_state64_t | |
   arm_state_hdr_t | |
   arm_thread_state_t | |
   ppc_thread_state32_t | |
   ppc_state_hdr_t | |
   ppc_thread_state_t | |
   macho_load_command | |
  MachOYAML | |
   Section | |
   FileHeader | |
   LoadCommand | |
   NListEntry | |
   RebaseOpcode | |
   BindOpcode | |
   ExportEntry | |
   LinkEditData | |
   Object | |
   FatHeader | |
   FatArch | |
   UniversalBinary | |
  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 | |
  msf | |
   VarStreamArrayExtractor< codeview::CVRecord< Kind > > | |
   VarStreamArrayExtractor< codeview::ModuleSubstream > | |
   VarStreamArrayExtractor< codeview::LineColumnEntry > | |
   VarStreamArrayExtractor< codeview::FileChecksumEntry > | |
   ByteStream | |
   MemoryBufferByteStream | |
   MutableByteStream | |
   FileBufferByteStream | |
   IMSFFile | |
   MappedBlockStream | MappedBlockStream represents data stored in an MSF file into chunks of a particular size (called the Block Size), and whose chunks may not be necessarily contiguous |
   WritableMappedBlockStream | |
   MSFBuilder | |
   SuperBlock | |
   MSFLayout | |
   MSFError | Base class for errors originating when parsing raw PDB files |
   MSFStreamLayout | Describes the layout of a stream in an MSF layout |
   SequencedItemTraits | |
   SequencedItemStream | SequencedItemStream represents a sequence of objects stored in a standard container but for which it is useful to view as a stream of contiguous bytes |
   VarStreamArrayExtractor | VarStreamArrayExtractor is intended to be specialized to provide customized extraction logic |
   VarStreamArrayIterator | VarStreamArray represents an array of variable length records backed by a stream |
   VarStreamArray | |
   FixedStreamArrayIterator | |
   FixedStreamArray | |
   ReadableStream | |
   WritableStream | |
   StreamReader | |
   StreamRefBase | |
   ReadableStreamRef | |
   WritableStreamRef | |
   StreamWriter | |
   VarStreamArrayExtractor< pdb::ModInfo > | |
   SequencedItemTraits< llvm::codeview::CVType > | |
  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 | |
   ObjCARCAAResult | This is a simple alias analysis implementation that uses knowledge of ARC constructs to answer queries |
   ObjCARCAA | Analysis pass providing a never-invalidated alias analysis result |
   ObjCARCAAWrapperPass | Legacy wrapper pass to provide the ObjCARCAAResult object |
   ARCMDKindCache | A cache of MDKinds used by various ARC optimizations |
   ARCRuntimeEntryPoints | Declarations for ObjC runtime functions and constants |
   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 propagated 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 | |
   debug_directory | |
   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_tls_directory | |
   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 | |
   FpoData | |
   COFFImportFile | |
   Decompressor | Decompressor helps to handle decompression of compressed sections |
   ELFFile | |
   ELFObjectFileBase | |
   ELFSectionRef | |
   elf_section_iterator | |
   ELFSymbolRef | |
   elf_symbol_iterator | |
   ELFRelocationRef | |
   elf_relocation_iterator | |
   ELFObjectFile | |
   Elf_Ehdr_Impl | |
   Elf_Shdr_Impl | |
   Elf_Sym_Impl | |
   Elf_Dyn_Impl | Elf_Dyn_Impl: This inherits from Elf_Dyn_Base, adding getters |
   Elf_Phdr_Impl | |
   Elf_Rel_Impl | |
   Elf_Verdef_Impl | Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section (.gnu.version_d) |
   Elf_Verdaux_Impl | Elf_Verdaux: This is the structure of auxiliary data 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_Versym_Impl | Elf_Versym: This is the structure of entries in the SHT_GNU_versym section (.gnu.version) |
   Elf_Hash_Impl | |
   Elf_GnuHash_Impl | |
   Elf_Chdr_Impl | |
   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_Sym_Base | |
   Elf_Sym_Base< ELFType< TargetEndianness, false > > | |
   Elf_Sym_Base< ELFType< TargetEndianness, true > > | |
   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_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_Phdr_Impl< ELFType< TargetEndianness, false > > | |
   Elf_Phdr_Impl< ELFType< TargetEndianness, true > > | |
   Elf_Chdr_Impl< ELFType< TargetEndianness, false > > | |
   Elf_Chdr_Impl< ELFType< TargetEndianness, true > > | |
   Elf_Mips_RegInfo | |
   Elf_Mips_RegInfo< ELFType< TargetEndianness, false > > | |
   Elf_Mips_RegInfo< ELFType< TargetEndianness, true > > | |
   Elf_Mips_Options | |
   Elf_Mips_ABIFlags | |
   BinaryError | Base class for all errors indicating malformed binary files |
   GenericBinaryError | Generic binary error |
   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 | |
   ModuleSummaryIndexObjectFile | This class is used to read just the module summary index related sections out of the given object (which may contain a single module's bitcode or be a combined index bitcode file) |
   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 | |
   SymEntry | |
   WasmObjectFile | |
  OMF | |
   Signature | |
  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 | |
   remote | |
    OrcRemoteTargetClient | This class provides utilities (including memory manager, indirect stubs manager, and compile callback manager types) that support remote JITing in ORC |
     RCCompileCallbackManager | Remote compile callback manager |
     RCIndirectStubsManager | Remote indirect stubs manager |
     RCMemoryManager | Remote memory manager |
    DirectBufferWriter | |
    OrcRemoteTargetRPCAPI | |
     CallIntVoid | |
     CallMain | |
     CallVoidVoid | |
     CreateIndirectStubsOwner | |
     CreateRemoteAllocator | |
     DeregisterEHFrames | |
     DestroyIndirectStubsOwner | |
     DestroyRemoteAllocator | |
     EmitIndirectStubs | EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted) |
     EmitResolverBlock | |
     EmitTrampolineBlock | EmitTrampolineBlock result is (BlockAddr, NumTrampolines) |
     GetRemoteInfo | GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize, IndirectStubsSize) |
     GetSymbolAddress | |
     ReadMem | |
     RegisterEHFrames | |
     RequestCompile | |
     ReserveMem | |
     ResourceIdMgr | |
     SetProtections | |
     TerminateSession | |
     WriteMem | |
     WritePtr | |
    OrcRemoteTargetServer | |
   rpc | |
    detail | |
     ResultTraits | |
     ResultTraits< void > | |
     ResultTraits< Error > | |
     ResultTraits< Expected< RetT > > | |
     WrappedHandlerReturn | |
     WrappedHandlerReturn< Expected< T > > | |
     WrappedHandlerReturn< void > | |
     WrappedHandlerReturn< Error > | |
     WrappedHandlerReturn< ErrorSuccess > | |
     HandlerTraits | |
     HandlerTraits< RetT(ArgTs...)> | |
     HandlerTraits< RetT(Class::*)(ArgTs...)> | |
     HandlerTraits< RetT(Class::*)(ArgTs...) const > | |
     ResponseHandlerArg | |
     ResponseHandlerArg< Error(Expected< ArgT >)> | |
     ResponseHandlerArg< ErrorSuccess(Expected< ArgT >)> | |
     ResponseHandlerArg< Error(Error)> | |
     ResponseHandlerArg< ErrorSuccess(Error)> | |
     ResponseHandler | |
     ResponseHandlerImpl | |
     ResponseHandlerImpl< ChannelT, void, HandlerT > | |
     MemberFnWrapper | |
     ReadArgs | |
     ReadArgs< ArgT, ArgTs...> | |
     SequenceNumberManager | |
     RPCArgTypeCheckHelper | |
     RPCArgTypeCheckHelper< P, std::tuple<>, std::tuple<> > | |
     RPCArgTypeCheckHelper< P, std::tuple< T, Ts...>, std::tuple< U, Us...> > | |
     RPCArgTypeCheck | |
     CanSerialize | |
     CanDeserialize | |
     RPCEndpointBase | Contains primitive utilities for defining, calling and handling calls to remote procedures |
      CanDeserializeCheck | |
      CanSerializeCheck | |
      OrcRPCInvalid | |
      OrcRPCNegotiate | |
      OrcRPCResponse | |
    RPCTypeName< remote::DirectBufferWriter > | |
    SerializationTraits< ChannelT, remote::DirectBufferWriter, remote::DirectBufferWriter, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value >::type > | |
    RawByteChannel | Interface for byte-streams to be used with RPC |
    SerializationTraits< ChannelT, T, T, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value &&(std::is_same< T, uint8_t >::value||std::is_same< T, int8_t >::value||std::is_same< T, uint16_t >::value||std::is_same< T, int16_t >::value||std::is_same< T, uint32_t >::value||std::is_same< T, int32_t >::value||std::is_same< T, uint64_t >::value||std::is_same< T, int64_t >::value||std::is_same< T, char >::value)>::type > | |
    SerializationTraits< ChannelT, bool, bool, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value >::type > | |
    SerializationTraits< ChannelT, std::string, StringRef, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value >::type > | |
    SerializationTraits< ChannelT, std::string, const char *, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value >::type > | |
    SerializationTraits< ChannelT, std::string, std::string, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value >::type > | |
    RPCTypeName | |
    RPCTypeNameSequence | TypeNameSequence is a utility for rendering sequences of types to a string by rendering each type, separated by ", " |
    RPCTypeName< void > | |
    RPCTypeName< int8_t > | |
    RPCTypeName< uint8_t > | |
    RPCTypeName< int16_t > | |
    RPCTypeName< uint16_t > | |
    RPCTypeName< int32_t > | |
    RPCTypeName< uint32_t > | |
    RPCTypeName< int64_t > | |
    RPCTypeName< uint64_t > | |
    RPCTypeName< bool > | |
    RPCTypeName< std::string > | |
    RPCTypeName< std::pair< T1, T2 > > | |
    RPCTypeName< std::tuple< ArgTs...> > | |
    RPCTypeName< std::vector< T > > | |
    SerializationTraits | The SerializationTraits<ChannelT, T> class describes how to serialize and deserialize an instance of type T to/from an abstract channel of type ChannelT |
    SequenceTraits | |
    SequenceSerialization | Utility class for serializing sequences of values of varying types |
    SequenceSerialization< ChannelT > | |
    SequenceSerialization< ChannelT, ArgT > | |
    SequenceSerialization< ChannelT, ArgT, ArgTs...> | |
    SerializationTraits< ChannelT, std::pair< T1, T2 > > | SerializationTraits default specialization for std::pair |
    SerializationTraits< ChannelT, std::tuple< ArgTs...> > | SerializationTraits default specialization for std::tuple |
    SerializationTraits< ChannelT, std::vector< T > > | SerializationTraits default specialization for std::vector |
    Function | |
    Function< DerivedFunc, RetT(ArgTs...)> | |
    FunctionArgsTuple | Provides a typedef for a tuple containing the decayed argument types |
    FunctionArgsTuple< RetT(ArgTs...)> | |
    RPCFunctionIdAllocator | Allocates RPC function ids during autonegotiation |
    RPCFunctionIdAllocator< T, typename std::enable_if< std::is_integral< T >::value >::type > | This specialization of RPCFunctionIdAllocator provides a default implementation for integral types |
    MultiThreadedRPCEndpoint | |
    SingleThreadedRPCEndpoint | |
    ParallelCallGroup | Allows a set of asynchrounous calls to be dispatched, and then waited on as a group |
    APICalls | Convenience class for grouping RPC Functions into APIs that can be negotiated as a block |
     Contains | Test whether this API contains Function F |
    APICalls< Func, Funcs...> | |
     Contains | |
    APICalls< APICalls< InnerFuncs...>, Funcs...> | |
     Contains | |
   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 |
   GlobalMappingLayer | Global mapping layer |
   JITCompileCallbackManager | Target-independent base class for compile callback management |
    CompileCallbackInfo | Handle to a newly created compile callback |
   LocalJITCompileCallbackManager | Manage compile callbacks for in-process JITs |
   IndirectStubsManager | Base class for managing collections of named indirect stubs |
   LocalIndirectStubsManager | IndirectStubsManager implementation for the host architecture, e.g |
   IRCompileLayer | Eager IR compiling layer |
   IRTransformLayer | IR mutating layer |
   LambdaResolver | |
   LazyEmittingLayer | Lazy-emitting IR layer |
   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 |
   OrcGenericABI | Generic ORC ABI support |
    IndirectStubsInfo | |
   GenericIndirectStubsInfo | Provide information about stub blocks generated by the makeIndirectStubsBlock function |
   OrcAArch64 | |
   OrcX86_64_Base | X86_64 code that's common to all ABIs |
   OrcX86_64_SysV | X86_64 support for SysV ABI (Linux, MacOSX) |
   OrcX86_64_Win32 | X86_64 support for Win32 |
   OrcI386 | I386 support |
   GlobalRenamer | |
   OrcMCJITReplacement | |
  ore | Add a small namespace to avoid name clashes with the classes used in the streaming interface |
  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 > | |
   Signum_match | |
  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 relevant 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 |
  pdb | |
   ConcreteSymbolEnumerator | |
   DIADataStream | |
   DIAEnumDebugStreams | |
   DIAEnumLineNumbers | |
   DIAEnumSourceFiles | |
   DIAEnumSymbols | |
   DIAError | Base class for errors originating in DIA SDK, e.g. COM calls |
   DIALineNumber | |
   DIARawSymbol | |
   DIASession | |
   DIASourceFile | |
   GenericError | Base class for errors originating when parsing raw PDB files |
   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 | |
   VersionInfo | |
   Variant | |
   DbiStream | |
   DbiStreamBuilder | |
   GlobalsStream | |
   InfoStream | |
   InfoStreamBuilder | |
   ISectionContribVisitor | |
   ModInfo | |
   ModuleInfoEx | |
   ModStream | |
   NameHashTable | |
   NameMap | |
   NameMapBuilder | |
   PDBFile | |
   PDBFileBuilder | |
   PublicsStream | |
    HeaderInfo | |
   RawError | Base class for errors originating when parsing raw PDB files |
   RawSession | |
   SectionOffset | |
   PSHashRecord | |
   SectionContrib | |
   SectionContrib2 | |
   SecMapHeader | |
   SecMapEntry | |
   TypeIndexOffset | |
   DbiFlags | Some of the values are stored in bitfields |
   DbiBuildNo | |
   DbiStreamHeader | The fixed size header that appears at the beginning of the DBI Stream |
   SectionContribEntry | |
   FileInfoSubstreamHeader | The header preceeding the File Info Substream of the DBI stream |
   ModInfoFlags | |
   ModuleInfoHeader | The header preceeding each entry in the Module Info substream of the DBI stream |
   PDB_UniqueId | Defines a 128-bit unique identifier |
   TpiStreamHeader | |
    EmbeddedBuf | |
   InfoStreamHeader | The header preceeding the global PDB Stream (Stream 1) |
   SymbolStream | |
   TpiHashUpdater | |
   TpiHashVerifier | |
   TpiStream | |
   TpiStreamBuilder | |
   GSIHashHeader | Header of the hash tables found in the globals and publics sections |
  PICLevel | |
  PICStyles | The X86 backend supports a number of different styles of PIC |
  PIELevel | |
  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 | |
  R600InstrFlags | |
  RawInstrProf | |
   Header | |
  rdf | |
   CopyPropagation | |
   DeadCodeElimination | |
   NodeAttrs | |
   BuildOptions | |
   NodeAddr | |
   NodeAllocator | |
   RegisterRef | |
   TargetOperandInfo | |
   PackedRegisterRef | |
   IndexedSet | |
   LaneMaskIndex | |
   RegisterAggr | |
   NodeBase | |
    Code_struct | |
    Def_struct | |
    PhiU_struct | |
    Ref_struct | |
   RefNode | |
   DefNode | |
   UseNode | |
   PhiUseNode | |
   CodeNode | |
   InstrNode | |
   PhiNode | |
   StmtNode | |
   BlockNode | |
   FuncNode | |
   DataFlowGraph | |
    DefStack | |
   PrintLaneMaskOpt | |
   Print | |
   PrintNode | |
   Liveness | |
    LiveMapType | |
  reassociate | A private "module" namespace for types and utilities used by Reassociate |
   ValueEntry | |
   Factor | Utility class representing a base and exponent pair which form one factor of some product |
   XorOpnd | Utility class representing a non-constant Xor-operand |
  RegState | |
  Reloc | |
  RTLIB | |
  safestack | |
   StackColoring | Compute live ranges of allocas |
    LiveRange | This class represents a set of interesting instructions where an alloca is live |
   StackLayout | Compute the layout of an unsafe stack frame |
  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 |
   SampleSorter | Sort a LocationT->SampleT map by LocationT |
   SampleProfileReader | Sample-based profile reader |
   SampleProfileReaderText | |
   SampleProfileReaderBinary | |
   SampleProfileReaderGCC | |
   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 | |
  SIInstrFlags | |
  SIOutMods | |
  SISrcMods | |
  slpvectorizer | A private "module" namespace for types and utilities used by this pass |
   BoUpSLP | Bottom Up SLP Vectorizer |
  Sparc | |
  SPCC | |
  SPII | SPII - This namespace holds all of the target specific flags that instruction info tracks |
  SPISD | |
  sroa | |
   AllocaSlices | Representation of the alloca slices |
   Partition | A partition of the slices |
   AllocaSliceRewriter | Visitor to rewrite instructions using p particular slice of an alloca to use a new alloca |
   SROALegacyPass | A legacy pass for the legacy pass manager that wraps the SROA pass |
  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 |
  symbolize | |
   DIPrinter | |
   SymbolizableModule | |
   LLVMSymbolizer | |
    Options | |
   SymbolizableObjectFile | |
  SymbolRewriter | |
   RewriteDescriptor | The basic entity representing a rewrite operation |
   RewriteMapParser | |
  sys | |
   fs | |
    detail | |
     DirIterState | Keeps state for the directory_iterator |
     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 |
   OwningMemoryBlock | Owning version of MemoryBlock |
   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 |
   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 | |
  trailing_objects_internal | |
   AlignmentCalcHelper | Helper template to calculate the max alignment requirement for a set of objects |
   AlignmentCalcHelper< First > | |
   TrailingObjectsBase | The base class for TrailingObjects* classes |
    OverloadToken | OverloadToken's purpose is to allow specifying function overloads for different types, without actually taking the types as parameters |
   TrailingObjectsAligner | This helper template works-around MSVC 2013's lack of useful alignas() support |
   ExtractSecondType | |
   TrailingObjectsImpl | |
   TrailingObjectsImpl< Align, BaseTy, TopTrailingObj, PrevTy, NextTy, MoreTys...> | |
   TrailingObjectsImpl< Align, BaseTy, TopTrailingObj, PrevTy > | |
  types | |
   i | I<N> corresponds to the LLVM IntegerType with N bits |
   ieee_float | |
   ieee_double | |
   x86_fp80 | |
   fp128 | |
   ppc_fp128 | |
   x86_mmx | |
  VGPRIndexMode | |
  wasm | |
   WasmObjectHeader | |
   WasmSection | |
  WebAssembly | |
  WebAssemblyII | |
  WebAssemblyISD | |
  wholeprogramdevirt | |
   AccumBitVector | |
   VTableBits | |
   TypeMemberInfo | |
   VirtualCallTarget | |
  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 | |
   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 | |
  xray | |
   Trace | A Trace object represents the records that have been loaded from XRay log files generated by instrumented binaries |
   XRayFileHeader | XRay traces all have a header providing some top-matter information useful to help tools determine how to interpret the information available in the trace |
   XRayRecord | |
   YAMLXRayFileHeader | |
   YAMLXRayRecord | |
   YAMLXRayTrace | |
  yaml | |
   detail | |
   StringValue | A wrapper around std::string which contains a source range that's being set during parsing |
   ScalarTraits< StringValue > | |
   FlowStringValue | |
   ScalarTraits< FlowStringValue > | |
   BlockStringValue | |
   BlockScalarTraits< BlockStringValue > | |
   UnsignedValue | A wrapper around unsigned which contains a source range that's being set during parsing |
   ScalarTraits< UnsignedValue > | |
   ScalarEnumerationTraits< MachineJumpTableInfo::JTEntryKind > | |
   VirtualRegisterDefinition | |
   MappingTraits< VirtualRegisterDefinition > | |
   MachineFunctionLiveIn | |
   MappingTraits< MachineFunctionLiveIn > | |
   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 > | |
   MachineConstantPoolValue | |
   MappingTraits< MachineConstantPoolValue > | |
   MachineJumpTable | |
    Entry | |
   MappingTraits< MachineJumpTable::Entry > | |
   MappingTraits< MachineJumpTable > | |
   MachineFrameInfo | Serializable representation of MachineFrameInfo |
   MappingTraits< MachineFrameInfo > | |
   MachineFunction | |
   MappingTraits< MachineFunction > | |
   MappingTraits | This class should be specialized by any type that needs to be converted to/from a YAML mapping |
   ScalarEnumerationTraits< TypeTestResolution::Kind > | |
   MappingTraits< TypeTestResolution > | |
   MappingTraits< TypeIdSummary > | |
   FunctionSummaryYaml | |
   MappingTraits< FunctionSummaryYaml > | |
   CustomMappingTraits< GlobalValueSummaryMapTy > | |
   MappingTraits< ModuleSummaryIndex > | |
   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 > | |
   MappingTraits< DWARFYAML::Data > | |
   MappingTraits< DWARFYAML::Abbrev > | |
   MappingTraits< DWARFYAML::AttributeAbbrev > | |
   MappingTraits< DWARFYAML::ARangeDescriptor > | |
   MappingTraits< DWARFYAML::ARange > | |
   MappingTraits< DWARFYAML::PubEntry > | |
   MappingTraits< DWARFYAML::PubSection > | |
   MappingTraits< DWARFYAML::Unit > | |
   MappingTraits< DWARFYAML::Entry > | |
   MappingTraits< DWARFYAML::FormValue > | |
   MappingTraits< DWARFYAML::File > | |
   MappingTraits< DWARFYAML::LineTableOpcode > | |
   MappingTraits< DWARFYAML::LineTable > | |
   ScalarEnumerationTraits< dwarf::Tag > | |
   ScalarEnumerationTraits< dwarf::LineNumberOps > | |
   ScalarEnumerationTraits< dwarf::LineNumberExtendedOps > | |
   ScalarEnumerationTraits< dwarf::Attribute > | |
   ScalarEnumerationTraits< dwarf::Form > | |
   ScalarEnumerationTraits< dwarf::Constants > | |
   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 > | |
   MappingTraits< MachOYAML::FileHeader > | |
   MappingTraits< MachOYAML::Object > | |
   MappingTraits< MachOYAML::FatHeader > | |
   MappingTraits< MachOYAML::FatArch > | |
   MappingTraits< MachOYAML::UniversalBinary > | |
   MappingTraits< MachOYAML::LoadCommand > | |
   MappingTraits< MachOYAML::LinkEditData > | |
   MappingTraits< MachOYAML::RebaseOpcode > | |
   MappingTraits< MachOYAML::BindOpcode > | |
   MappingTraits< MachOYAML::ExportEntry > | |
   MappingTraits< MachOYAML::Section > | |
   MappingTraits< MachOYAML::NListEntry > | |
   ScalarEnumerationTraits< MachO::LoadCommandType > | |
   ScalarEnumerationTraits< MachO::RebaseOpcode > | |
   ScalarEnumerationTraits< MachO::BindOpcode > | |
   ScalarTraits< char_16 > | |
   ScalarTraits< uuid_t > | |
   MappingTraits< MachO::dylib > | |
   MappingTraits< MachO::fvmlib > | |
   MappingTraits< MachO::section > | |
   MappingTraits< MachO::section_64 > | |
   YamlObjectFile | |
   MappingTraits< YamlObjectFile > | |
   BinaryRef | Specialized YAMLIO scalar type for representing a binary blob |
   ScalarTraits< BinaryRef > | |
   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 |
   EmptyContext | |
   MappingContextTraits | This class is similar to MappingTraits<T> but allows you to pass in additional context for each map operation |
   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 |
   CustomMappingTraits | This class should be specialized by any type that needs to be converted to/from a YAML mapping in the case where the names of the keys are not known in advance, e.g |
   MissingTrait | |
   has_ScalarEnumerationTraits | |
   has_ScalarBitSetTraits | |
   has_ScalarTraits | |
   has_BlockScalarTraits | |
   has_MappingTraits | |
   has_MappingTraits< T, EmptyContext > | |
   has_MappingValidateTraits | |
   has_MappingValidateTraits< T, EmptyContext > | |
   has_SequenceMethodTraits | |
   has_CustomMappingTraits | |
   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 > | |
   ScalarTraits< support::detail::packed_endian_specific_integral< value_type, endian, alignment > > | |
   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 > | |
   SequenceTraitsImpl | |
   StdMapStringCustomMappingTraitsImpl | Implementation of CustomMappingTraits for std::map<std::string, T> |
   ScalarEnumerationTraits< xray::RecordTypes > | |
   MappingTraits< xray::YAMLXRayFileHeader > | |
   MappingTraits< xray::YAMLXRayRecord > | |
   MappingTraits< xray::YAMLXRayTrace > | |
   MappingTraits< DiagnosticInfoOptimizationBase * > | |
   MappingTraits< DebugLoc > | |
   MappingTraits< DiagnosticInfoOptimizationBase::Argument > | |
   BlockScalarTraits< Module > | This struct serializes the LLVM IR module |
   Token | Token - A single YAML token |
   Scanner | Scans YAML tokens from a MemoryBuffer |
   MappingTraits< KernelArg::Metadata > | |
   MappingTraits< Kernel::Metadata > | |
   MappingTraits< Program::Metadata > | |
  zlib | |
  AllocatorList | A linked-list with a custom, local allocator |
  SmallVectorImpl | This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter |
  APFloatBase | A self-contained host- and target-independent arbitrary-precision floating-point software implementation |
  APFloat | |
  ArrayRef | ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory), i.e |
  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 | |
  MutableArrayRef | MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memory), i.e |
  OwningArrayRef | This is a MutableArrayRef that owns its array |
  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 > > | |
  is_bitmask_enum | Traits class to determine whether an enum has a LLVM_BITMASK_LARGEST_ENUMERATOR enumerator |
   type | |
  BitVector | |
   reference | |
  CachedHashStringRef | A container which contains a StringRef plus a precomputed hash |
  DenseMapInfo< CachedHashStringRef > | |
  CachedHashString | A container which contains a string, which it owns, plus a precomputed hash |
  DenseMapInfo< CachedHashString > | |
  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 > | |
  DenseMapInfo< ArrayRef< T > > | |
  DenseSet | Implements a dense probed hash-table based set |
  SmallDenseSet | Implements a dense probed hash-table based set with some number of buckets stored inline |
  df_iterator_storage | |
  df_iterator_storage< SetType, true > | |
  df_iterator_default_set | |
  df_iterator | |
  df_ext_iterator | |
  idf_iterator | |
  idf_ext_iterator | |
  DebugEpochBase | A base class for data structure classes wishing to make iterators ("handles") pointing into themselves fail-fast |
   HandleBase | A base class for iterator classes ("handles") that wish to poll for iterator invalidating modifications in the underlying data structure |
  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 |
  DefaultFoldingSetTrait | DefaultFoldingSetTrait - This class provides default implementations for FoldingSetTrait implementations |
  FoldingSetTrait | FoldingSetTrait - This trait class is used to define behavior of how to "profile" (in the FoldingSet parlance) an object of a given type |
  DefaultContextualFoldingSetTrait | DefaultContextualFoldingSetTrait - Like DefaultFoldingSetTrait, but for ContextualFoldingSets |
  ContextualFoldingSetTrait | ContextualFoldingSetTrait - Like FoldingSetTrait, 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 | |
  Inverse | |
  GraphTraits< Inverse< Inverse< T > > > | |
  hash_code | An opaque object representing a hash code |
  ilist_alloc_traits | Use delete by default for iplist and ilist |
  ilist_noalloc_traits | Custom traits to do nothing on deletion |
  ilist_callback_traits | Callbacks do nothing by default in iplist and ilist |
  ilist_node_traits | A fragment for template traits for intrusive list that provides default node related operations |
  ilist_default_traits | Default template traits for intrusive list |
  ilist_traits | Template traits for intrusive list |
  ilist_traits< const Ty > | Const traits should never be instantiated |
  iplist_impl | A wrapper around an intrusive list with callbacks and non-intrusive ownership |
  iplist | An intrusive list with ownership and callbacks specified/controlled by ilist_traits, only with API safe for polymorphic types |
  ilist_base | Implementations of list algorithms using ilist_node_base |
  ilist_iterator | Iterator for intrusive lists based on ilist_node |
  simplify_type | |
  simplify_type< ilist_iterator< OptionsT, false, IsConst > > | Allow ilist_iterators to convert into pointers to a node automatically when used by the dyn_cast, cast, isa mechanisms.. |
  simplify_type< const ilist_iterator< OptionsT, false, IsConst > > | |
  ilist_sentinel | |
  ilist_node_impl | Implementation for an ilist node |
  ilist_node | |
  ilist_node_with_parent | An ilist node that can access its parent list |
  ilist_node_base | Base class for ilist nodes |
  ilist_node_base< false > | |
  ilist_node_base< true > | |
  ilist_sentinel_tracking | Option to choose whether to track sentinels |
  ilist_tag | Option to specify a tag for the node type |
  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 |
  RefCountedBase | A CRTP mixin class that adds reference counting to a type |
  ThreadSafeRefCountedBase | A thread-safe version of RefCountedBase |
  IntrusiveRefCntPtrInfo | Class you can specialize to provide custom retain/release functionality for a type |
  IntrusiveRefCntPtr | A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCountedBase |
  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 |
   ReferenceProxy | A proxy object for computing a reference via indirecting a copy of an iterator |
  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 |
  pointer_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 | |
  PointerEmbeddedInt | Utility to embed an integer into a pointer-like type |
  PointerLikeTypeTraits< PointerEmbeddedInt< IntT, Bits > > | |
  DenseMapInfo< PointerEmbeddedInt< IntT, Bits > > | |
  PointerIntPairInfo | |
  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 > > | |
  PointerSumTypeMember | A compile time pair of an integer tag and the pointer-like type which it indexes within a sum type |
  PointerSumType | A sum type over pointer-like types |
  DenseMapInfo< PointerSumType< TagT, MemberTs...> > | |
  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 | A discriminated union of two pointer types, with the discriminator in the low bit of the pointer |
  PointerLikeTypeTraits< PointerUnion< PT1, PT2 > > | |
  PointerUnion3 | A pointer union of three pointer types |
  PointerLikeTypeTraits< PointerUnion3< PT1, PT2, PT3 > > | |
  PointerUnion4 | 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 |
  PriorityWorklist | A FILO worklist that prioritizes on re-insertion without duplication |
  SmallPriorityWorklist | A version of PriorityWorklist that selects small size optimized data structures for the vector and map |
  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 |
  simple_ilist | A simple intrusive list implementation |
  SmallBitVector | This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is small |
   reference | |
  ReverseIterate | |
  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 |
  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 | Storage for the SmallVector elements which aren't contained in SmallVectorTemplateCommon |
  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 |
  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 | |
  SameType | |
  identity | |
  less_ptr | |
  greater_ptr | |
  function_ref | An efficient, type-erasing, non-owning reference to a callable |
  function_ref< Ret(Params...)> | |
  mapped_iterator | |
  has_rbegin_impl | Helper to determine if type T has a member called rbegin() |
  has_rbegin | Metafunction to determine if T& or T has a member called rbegin() |
  filter_iterator | An iterator adaptor that filters the elements of given inner iterators |
  index_sequence | Alias for the common case of a sequence of size_ts |
  index_sequence_for | Creates a compile-time integer sequence for a parameter pack |
  concat_iterator | Iterator wrapper that concatenates sequences together |
  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 |
  build_index_impl | |
  build_index_impl< 0, I...> | |
  rank | Utility type to build an inheritance chain that makes it easy to rank overload candidates |
  rank< 0 > | |
  is_one_of | Traits class for checking whether type T is one of any of the given types in the variadic list |
  is_one_of< T, U, Ts...> | |
  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 |
  StringLiteral | A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs with the length computed at compile time |
  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 | |
  AAResults | |
   Concept | A private abstract base class describing the concept of an individual alias analysis implementation |
  AAResultBase | A CRTP-driven "mixin" base class to help implement the function alias analysis results concept |
   AAResultsProxy | This proxy class models a common pattern where we delegate to either the top-level AAResults aggregation if one is registered, or to the current result if none are registered |
  AAManager | A manager for alias analyses |
  AAResultsWrapperPass | A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object |
  AAEvaluator | |
  AliasSet | |
   iterator | Define an iterator for alias sets... this is just a forward iterator |
  AliasSetTracker | |
  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 |
  BasicAAResult | This is the AA result object for the basic, local, and stateless alias analysis |
  BasicAA | Analysis pass providing a never-invalidated alias analysis result |
  BasicAAWrapperPass | Legacy wrapper pass to provide the BasicAAResult object |
  BlockFrequencyInfoImpl | Shared implementation for block frequency analysis |
  BlockFrequencyInfo | BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequencies |
  BlockFrequencyAnalysis | Analysis pass which computes BlockFrequencyInfo |
  BlockFrequencyPrinterPass | Printer pass for the BlockFrequencyInfo results |
  BlockFrequencyInfoWrapperPass | Legacy analysis pass which computes BlockFrequencyInfo |
  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 |
  BFIDOTGraphTraitsBase | |
  BranchProbabilityInfo | Analysis providing branch probability information |
  BranchProbabilityAnalysis | Analysis pass which computes BranchProbabilityInfo |
  BranchProbabilityPrinterPass | Printer pass for the BranchProbabilityAnalysis results |
  BranchProbabilityInfoWrapperPass | Legacy analysis pass which computes BranchProbabilityInfo |
  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 |
  CallGraphPrinterPass | Printer pass for the CallGraphAnalysis results |
  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 |
  DummyCGSCCPass | This pass is required by interprocedural register allocation |
  CaptureTracker | This callback is used in conjunction with PointerMayBeCaptured |
  CFGViewerPass | |
  CFGOnlyViewerPass | |
  CFGPrinterPass | |
  CFGOnlyPrinterPass | |
  DOTGraphTraits< const Function * > | |
  CFLAndersAAResult | |
   FunctionInfo | |
  CFLAndersAA | Analysis pass providing a never-invalidated alias analysis result |
  CFLAndersAAWrapperPass | Legacy wrapper pass to provide the CFLAndersAAResult object |
  CFLSteensAAResult | |
   FunctionInfo | Information we have about a function and would like to keep around |
  CFLSteensAA | Analysis pass providing a never-invalidated alias analysis result |
  CFLSteensAAWrapperPass | Legacy wrapper pass to provide the CFLSteensAAResult object |
  RequireAnalysisPass< AnalysisT, LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult & > | An explicit specialization of the require analysis template pass |
  CGSCCUpdateResult | Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager infrsatructure |
  ModuleToPostOrderCGSCCPassAdaptor | The core module pass which does a post-order walk of the SCCs and runs a CGSCC pass over each one |
  FunctionAnalysisManagerCGSCCProxy | A proxy from a FunctionAnalysisManager to an SCC |
   Result | |
  CGSCCToFunctionPassAdaptor | Adaptor that maps from a SCC to its functions |
  DevirtSCCRepeatedPass | A helper that repeats an SCC pass each time an indirect call is refined to a direct call by that pass |
  CodeMetrics | Utility to calculate the size and a few similar metrics for a set of basic blocks |
  DemandedBits | |
  DemandedBitsWrapperPass | |
  DemandedBitsAnalysis | An analysis that produces DemandedBits for a function |
  DemandedBitsPrinterPass | Printer pass for DemandedBits |
  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 |
  DependenceInfo | DependenceInfo - This class is the main dependence-analysis driver |
  DependenceAnalysis | AnalysisPass to compute dependence information in a function |
  DependenceAnalysisWrapperPass | Legacy pass manager pass to access dependence information |
  DivergenceAnalysis | |
  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 | |
  DominanceFrontierWrapperPass | |
  DominanceFrontierAnalysis | Analysis pass which computes a DominanceFrontier |
  DominanceFrontierPrinterPass | Printer pass for the DominanceFrontier |
  DFCalculateWorkObject | |
  DefaultAnalysisGraphTraits | Default traits class for extracting a graph from an analysis pass |
  DOTGraphTraitsViewer | |
  DOTGraphTraitsPrinter | |
  DOTGraphTraitsModuleViewer | |
  DOTGraphTraitsModulePrinter | |
  GlobalsAAResult | An alias analysis result set for globals |
   FunctionInfo | The mod/ref information collected for a particular function |
  GlobalsAA | Analysis pass providing a never-invalidated alias analysis result |
  GlobalsAAWrapperPass | Legacy wrapper pass to provide the GlobalsAAResult object |
  ICallPromotionAnalysis | |
  PGOIndirectCallSiteVisitor | |
  InlineCost | Represents the cost of inlining a function |
  InlineParams | Thresholds to tune inline cost analysis |
  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 | |
  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 |
  IVUsers | |
  IVUsersWrapperPass | |
  IVUsersAnalysis | Analysis pass that exposes the IVUsers for a loop |
  LazyBlockFrequencyInfoPass | This is an alternative analysis pass to BlockFrequencyInfoWrapperPass |
  LazyBranchProbabilityInfoPass | This is an alternative analysis pass to BranchProbabilityInfoWrapperPass |
  LazyCallGraph | A lazily constructed view of the call graph of a module |
   call_edge_iterator | A lazy iterator over specifically call edges |
   Edge | A class used to represent edges in the call graph |
   edge_iterator | A lazy iterator used for both the entry nodes and child nodes |
   Node | A node in the call graph |
   postorder_ref_scc_iterator | A post-order depth-first RefSCC iterator over the call graph |
   RefSCC | A RefSCC of 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 |
  LazyCallGraphDOTPrinterPass | A pass which prints the call graph as a DOT file to a raw_ostream |
  LazyValueInfo | This pass computes, caches, and vends lazy value constraint information |
  LazyValueAnalysis | Analysis to compute lazy value information |
  LazyValueInfoWrapperPass | Wrapper around LazyValueInfo |
  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 |
  LoopAccessLegacyAnalysis | This analysis provides dependence information for the memory accesses of a loop |
  LoopAccessAnalysis | This analysis provides dependence information for the memory accesses of a loop |
  LoopStandardAnalysisResults | The adaptor from a function pass to a loop pass computes these analyses and makes them available to the loop passes "for free" |
  DominatorTreeBase | Core dominator tree base class |
   InfoRec | |
  LoopInfoBase | This class builds and contains all of the top-level loop structures in the specified function |
  LoopBase | Instances of this class are used to represent loops that are detected in the flow graph |
  Loop | Represents a single loop in the control flow graph |
   LocRange | A range representing the start and end location of a loop |
  LoopInfo | |
  GraphTraits< const Loop * > | |
  GraphTraits< Loop * > | |
  LoopAnalysis | Analysis pass that exposes the LoopInfo for a function |
  LoopPrinterPass | Printer pass for the LoopAnalysis results |
  LoopVerifierPass | Verifier 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 |
  LoopBodyTraits | |
   LoopBodyFilter | |
   WrappedSuccIterator | |
  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 | |
  LCSSAVerificationPass | |
  UnrolledInstAnalyzer | |
  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 | A memory dependence query can return one of three different answers |
  NonLocalDepEntry | This is an entry in the NonLocalDepInfo cache |
  NonLocalDepResult | This is a result from a NonLocal dependence query |
  MemoryDependenceResults | Provides a lazy, caching interface for making common memory aliasing information queries, backed by LLVM's alias analysis passes |
  MemoryDependenceAnalysis | An analysis that produces MemoryDependenceResults for a function |
  MemoryDependenceWrapperPass | A wrapper analysis pass for the legacy pass manager that exposes a MemoryDepnedenceResults instance |
  MemoryLocation | Representation for a specific memory location |
  DenseMapInfo< MemoryLocation > | |
  ModuleSummaryIndexAnalysis | Analysis pass to provide the ModuleSummaryIndex object |
  ModuleSummaryIndexWrapperPass | Legacy wrapper pass to provide the ModuleSummaryIndex object |
  OptimizationRemarkEmitter | The optimization diagnostic interface |
  OptimizationRemarkEmitterWrapperPass | OptimizationRemarkEmitter legacy analysis pass |
  OptimizationRemarkEmitterAnalysis | |
  OrderedBasicBlock | |
  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 |
  PostDominatorTreeAnalysis | Analysis pass which computes a PostDominatorTree |
  PostDominatorTreePrinterPass | Printer pass for the PostDominatorTree |
  PostDominatorTreeWrapperPass | |
  GraphTraits< PostDominatorTree * > | |
  ProfileSummaryInfo | Analysis providing profile information |
  ProfileSummaryInfoWrapperPass | An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo |
  ProfileSummaryAnalysis | An analysis pass based on the new PM to deliver ProfileSummaryInfo |
  ProfileSummaryPrinterPass | Printer pass that uses ProfileSummaryAnalysis |
  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 | |
  RegionInfoAnalysis | Analysis pass that exposes the RegionInfo for a function |
  RegionInfoPrinterPass | Printer pass for the RegionInfo |
  RegionInfoVerifierPass | Verifier pass for the RegionInfo |
  RNSuccIterator | Hierarchical RegionNode successor iterator |
  RNSuccIterator< FlatIt< NodeRef >, 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 | This class represents an analyzed expression in the program |
  FoldingSetTrait< SCEV > | |
  SCEVCouldNotCompute | An object of this class is returned by queries that could not be answered |
  SCEVPredicate | This class represents an assumption made using SCEV expressions which can be checked at run-time |
  FoldingSetTrait< SCEVPredicate > | |
  SCEVEqualPredicate | This class represents an assumption that two SCEV expressions are equal, and this can be checked at run-time |
  SCEVWrapPredicate | This class represents an assumption made on an AddRec expression |
  SCEVUnionPredicate | This class represents a composition of other SCEV predicates, and is the class that most clients will interact with |
  ScalarEvolution | The main scalar evolution driver |
  ScalarEvolutionAnalysis | Analysis pass that exposes the ScalarEvolution for a function |
  ScalarEvolutionPrinterPass | Printer pass for the ScalarEvolutionAnalysis results |
  ScalarEvolutionWrapperPass | |
  PredicatedScalarEvolution | An interface layer with SCEV used to manage how we see SCEV expressions for values in the context of existing predicates |
  SCEVAAResult | A simple alias analysis implementation that uses ScalarEvolution to answer queries |
  SCEVAA | Analysis pass providing a never-invalidated alias analysis result |
  SCEVAAWrapperPass | Legacy wrapper pass to provide the SCEVAAResult object |
  SCEVExpander | This class uses information about analyze scalars to rewrite expressions in canonical form |
  SCEVConstant | This class represents a constant integer value |
  SCEVCastExpr | This is the base class for unary cast operator classes |
  SCEVTruncateExpr | This class represents a truncation of an integer value to a smaller integer value |
  SCEVZeroExtendExpr | This class represents a zero extension of a small integer value to a larger integer value |
  SCEVSignExtendExpr | This class represents a sign extension of a small integer value to a larger integer value |
  SCEVNAryExpr | This node is a base class providing common functionality for n'ary operators |
  SCEVCommutativeExpr | This node is the base class for n'ary commutative operators |
  SCEVAddExpr | This node represents an addition of some number of SCEVs |
  SCEVMulExpr | This node represents multiplication of some number of SCEVs |
  SCEVUDivExpr | This class represents a binary unsigned division operation |
  SCEVAddRecExpr | This node represents a polynomial recurrence on the trip count of the specified loop |
  SCEVSMaxExpr | This class represents a signed maximum selection |
  SCEVUMaxExpr | This class represents an unsigned maximum selection |
  SCEVUnknown | This means that we are dealing with an entirely unknown SCEV value, and only represent it as its LLVM Value |
  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 |
  SCEVRewriteVisitor | This visitor recursively visits a SCEV expression and re-writes it |
  SCEVParameterRewriter | The SCEVParameterRewriter takes a scalar evolution expression and updates the SCEVUnknown components following the Map (Value -> Value) |
  SCEVLoopAddRecRewriter | The SCEVLoopAddRecRewriter takes a scalar evolution expression and applies the Map (Loop -> SCEV) to all AddRecExprs |
  ScopedNoAliasAAResult | A simple AA result which uses scoped-noalias metadata to answer queries |
  ScopedNoAliasAA | Analysis pass providing a never-invalidated alias analysis result |
  ScopedNoAliasAAWrapperPass | Legacy wrapper pass to provide the ScopedNoAliasAAResult object |
  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 | 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 | |
  TypeBasedAAResult | A simple AA result that uses TBAA metadata to answer queries |
  TypeBasedAA | Analysis pass providing a never-invalidated alias analysis result |
  TypeBasedAAWrapperPass | Legacy wrapper pass to provide the TypeBasedAAResult object |
  DevirtCallSite | A call site that could be devirtualized |
  SelectPatternResult | |
  SlotMapping | This struct contains the mappings from the slot numbers to unnamed metadata nodes, global values and types |
  BitcodeModule | Represents a module in a bitcode file |
  BitCodeAbbrevOp | BitCodeAbbrevOp - This describes one or more operands in an abbreviation |
  isPodLike< BitCodeAbbrevOp > | |
  BitCodeAbbrev | BitCodeAbbrev - This class represents an abbreviation record |
  BitcodeWriter | |
  BitcodeWriterPass | Pass for writing a module of IR out to a bitcode file |
  BitstreamBlockInfo | This class maintains the abbreviations read from a block info block |
   BlockInfo | This contains information emitted to BLOCKINFO_BLOCK blocks |
  SimpleBitstreamCursor | This represents a position within a bitstream |
  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, implemented on top of a SimpleBitstreamCursor |
  BitstreamWriter | |
  AsmPrinter | This class is intended to be used as a driving class for all asm writers |
   XRayFunctionEntry | |
  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 | Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation |
  DIEAbbrev | Dwarf abbreviation, describes the organization of a debug information object |
  DIEAbbrevSet | Helps unique DIEAbbrev objects and assigns abbreviation numbers |
  DIEInteger | An integer value DIE |
  DIEExpr | An expression DIE |
  DIELabel | A label DIE |
  DIEDelta | A simple label difference DIE |
  DIEString | A container for string pool string values |
  DIEInlineString | A container for inline string values |
  DIEEntry | |
  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_value_iterator | |
   value_iterator | |
  DIE | A structured debug information entry |
  DIEUnit | Represents a compile or type unit |
  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 | |
   StatepointSpillMap | Keep track of frame indices allocated for statepoints as they could be used across basic block boundaries |
  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 |
  CallLowering | |
   ArgInfo | |
   ValueHandler | Argument handling is mostly uniform between the four places that make these decisions: function formal arguments, call instruction args, call instruction returns and function returns |
  GISelAccessor | The goal of this helper class is to gather the accessor to all the APIs related to GlobalISel |
  InstructionSelect | This pass is responsible for selecting generic machine instructions to target-specific instructions |
  InstructionSelector | Provides the logic to select generic machine instructions |
  IRTranslator | |
  Legalizer | |
  LegalizerHelper | |
  InstrAspect | Legalization is decided based on an instruction's opcode, which type slot we're considering, and what the existing type is |
  LegalizerInfo | |
  MachineIRBuilder | Helper class to build MachineInstr |
  RegBankSelect | This pass implements the reg bank selector pass used in the GlobalISel pipeline |
   EdgeInsertPoint | Insertion point on an edge |
   InsertPoint | Abstract class used to represent an insertion point in a CFG |
   InstrInsertPoint | Insertion point before or after an instruction |
   MBBInsertPoint | Insertion point at the beginning or end of a basic block |
   RepairingPlacement | Struct used to represent the placement of a repairing point for a given operand |
  RegisterBank | This class implements the register bank concept |
  RegisterBankInfo | Holds all the information related to register banks |
   InstructionMapping | Helper class that represents how the value of an instruction may be mapped and what is the related cost of such mapping |
   OperandsMapper | Helper class used to get/create the virtual registers that will be used to replace the MachineOperand when applying a mapping |
   PartialMapping | Helper struct that represents how a value is partially mapped into a register |
   ValueMapping | Helper struct that represents how a value is mapped through different register banks |
  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 |
  LLT | |
  DenseMapInfo< LLT > | |
  ilist_traits< MachineInstr > | |
  MachineBasicBlock | |
   RegisterMaskPair | Pair of physical register and lane mask |
  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 |
  MachineDomTreeGraphTraitsBase | DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterators |
  GraphTraits< MachineDomTreeNode * > | |
  GraphTraits< const 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_alloc_traits< MachineBasicBlock > | |
  ilist_callback_traits< MachineBasicBlock > | |
  MachineFunctionInfo | MachineFunctionInfo - This class can be derived from and used by targets to hold private target-specific information for each MachineFunction |
  MachineFunctionProperties | Properties which a MachineFunction may have at a given point in time |
  SEHHandler | |
  LandingPadInfo | This structure is used to retain landing pad info for the current function |
  MachineFunction | |
   VariableDbgInfo | |
  GraphTraits< MachineFunction * > | |
  GraphTraits< const MachineFunction * > | |
  GraphTraits< Inverse< MachineFunction * > > | |
  GraphTraits< Inverse< const MachineFunction * > > | |
  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 | Information about how a physical register Reg is 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 |
  MachineInstrBundleIteratorTraits | |
  MachineInstrBundleIteratorTraits< T, false > | |
  MachineInstrBundleIteratorTraits< T, true > | |
  MachineInstrBundleIteratorTraits< const T, false > | |
  MachineInstrBundleIteratorTraits< const T, true > | |
  MachineInstrBundleIteratorHelper | |
  MachineInstrBundleIteratorHelper< false > | |
  MachineInstrBundleIteratorHelper< true > | |
  MachineInstrBundleIterator | MachineBasicBlock iterator that automatically skips over MIs that are inside bundles (i.e |
  MachineJumpTableEntry | MachineJumpTableEntry - One jump table in the jump table info |
  MachineJumpTableInfo | |
  MachineLoop | |
  MachineLoopInfo | |
  GraphTraits< const MachineLoop * > | |
  GraphTraits< MachineLoop * > | |
  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 | A description of a memory reference used in the backend |
  MachineModuleInfoImpl | This class can be derived from and used by targets to hold private target-specific information for each Module |
  MachineModuleInfo | This class contains meta information specific to a module |
  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 |
  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 |
  PBQPRAConstraint | Abstract base for classes implementing PBQP register allocation constraints (e.g |
  PBQPRAConstraintList | PBQP register allocation constraint composer |
  PreISelIntrinsicLoweringPass | |
  PseudoSourceValue | Special value supplied for machine level alias analysis |
  FixedStackPseudoSourceValue | A specialized PseudoSourceValue for holding FixedStack values, which must include a frame index |
  CallEntryPseudoSourceValue | |
  GlobalValuePseudoSourceValue | A specialized pseudo soruce value for holding GlobalValue values |
  ExternalSymbolPseudoSourceValue | A specialized pseudo source value for holding external symbol values |
  PseudoSourceValueManager | Manages creation of pseudo source values |
  RegisterRegAlloc | RegisterRegAlloc class - Track the registration of register allocators |
  RegisterClassInfo | |
  RegisterMaskPair | |
  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 |
  RegisterOperands | List of registers defined and used by a machine instruction |
  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 | |
  PhysicalRegisterUsageInfo | |
  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 |
  VReg2SUnitOperIdx | Mapping from virtual register to SUnit including an operand index |
  PhysRegSUOper | Record a physical register access |
  UnderlyingObject | |
  ScheduleDAGInstrs | ScheduleDAGInstrs - A ScheduleDAG subclass for scheduling lists of MachineInstrs |
   Value2SUsMap | |
  ScheduleDAGMutation | Mutate the DAG as a postpass after normal DAG building |
  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_alloc_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 |
   DAGNodeDeletedListener | |
   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 |
  SDNodeFlags | These are IR-level optimization flags that may be propagated to SDNodes |
  SDNode | Represents one node in the SelectionDAG |
   ConstantSDNodeBitfields | |
   LoadSDNodeBitfields | |
   LSBaseSDNodeBitfields | |
   MemSDNodeBitfields | |
   SDNodeBitfields | |
   StoreSDNodeBitfields | |
   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 |
  BinaryWithFlagsSDNode | This class is an extension of BinarySDNode used from those opcodes that have associated extra flags |
  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 | |
  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 * > | |
  SelectionDAGTargetInfo | Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process |
  IndexListEntry | This class represents an entry in the slot index list held in the SlotIndexes pass |
  ilist_alloc_traits< IndexListEntry > | |
  SlotIndex | SlotIndex - An opaque wrapper around machine indexes |
  isPodLike< SlotIndex > | |
  Idx2MBBCompare | |
  SlotIndexes | SlotIndexes pass |
  IntervalMapInfo< SlotIndex > | |
  StackMapOpers | MI-level stackmap operands |
  PatchPointOpers | MI-level patchpoint operands |
  StatepointOpers | MI-level Statepoint operands |
  StackMaps | |
   LiveOutReg | |
   Location | |
  StackProtector | |
  TailDuplicator | Utility class to perform tail duplication |
  TargetLoweringObjectFileELF | |
  TargetLoweringObjectFileMachO | |
  TargetLoweringObjectFileCOFF | |
  IdentifyingPassPtr | Discriminated union of Pass ID types |
  isPodLike< IdentifyingPassPtr > | |
  TargetPassConfig | Target-Independent Code Generator Pass Configuration Options |
  TargetSchedModel | Provide an instruction scheduling machine model to CodeGen passes |
  UnreachableBlockElimPass | |
  EVT | EVT - Extended Value Type |
   compareRawBits | CompareRawBits - A meaningless but well-behaved order, useful for constructing containers |
  VirtRegMap | |
  CxxUnwindMapEntry | |
  SEHUnwindMapEntry | Similar to CxxUnwindMapEntry, but supports SEH filters |
  WinEHHandlerType | |
  WinEHTryBlockMapEntry | |
  ClrEHUnwindMapEntry | |
  WinEHFuncInfo | |
  DILineInfo | DILineInfo - a format-neutral container for source line information |
  DIInliningInfo | DIInliningInfo - a format-neutral container for inlined code description |
  DIGlobal | DIGlobal - container for description of a global variable |
  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 or .eh_frame section |
  DWARFDebugInfoEntry | DWARFDebugInfoEntry - A DIE with only the minimum required data |
  DWARFDebugLine | |
   FileNameEntry | |
   LineTable | |
   Prologue | |
   Row | |
   Sequence | |
  DWARFDebugLoc | |
  DWARFDebugLocDWO | |
  DWARFDebugMacro | |
  DWARFDebugPubTable | Represents structure for holding and parsing .debug_pub* tables |
   Entry | |
   Set | Each table consists of sets of variable length entries |
  DWARFDebugRangeList | |
   RangeListEntry | |
  DWARFDie | Utility class that carries the DWARF compile/type unit and the debug info entry in an object |
   iterator | |
  DWARFFormValue | |
  DWARFGdbIndex | |
  DWARFSection | |
  DWARFTypeUnit | |
  DWARFUnitSectionBase | Base class for all DWARFUnitSection classes |
  DWARFUnitSection | Concrete instance of DWARFUnitSection, specialized for one Unit type |
  DWARFUnit | |
  DWARFUnitIndex | |
   Entry | |
    SectionContribution | |
  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 |
  JITSymbolFlags | Flags for symbols in the JIT |
  JITEvaluatedSymbol | Represents a symbol that has been evaluated to an address already |
  JITSymbol | Represents a symbol in the JIT |
  JITSymbolResolver | Symbol resolution |
  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 | |
  RuntimeDyldError | Base class for errors originating in RuntimeDyld, e.g |
  RuntimeDyld | |
   LoadedObjectInfo | Information about the loaded object |
   LoadedObjectInfoHelper | |
   MemoryManager | Memory Management |
  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 | |
  BasicBlock | LLVM Basic Block Representation |
  CallSiteBase | |
  CallSite | |
  DenseMapInfo< CallSite > | |
  ImmutableCallSite | ImmutableCallSite - establish a view to a call site for examination |
  PredIterator | |
  isPodLike< TerminatorInst::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 | |
  ConstantData | Base class for constants with no operands |
  ConstantInt | This is the shared class of boolean and integer constants |
  ConstantFP | ConstantFP - Floating Point Values [float, double] |
  ConstantAggregateZero | All zero aggregate value |
  ConstantAggregate | Base class for aggregate constants (with operands) |
  OperandTraits< ConstantAggregate > | |
  ConstantArray | ConstantArray - Constant Array Declarations |
  ConstantStruct | |
  ConstantVector | Constant Vector Declarations |
  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 | 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 | 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 |
  ConstantTokenNone | A constant token which is empty |
  BlockAddress | The address of a basic block |
  OperandTraits< BlockAddress > | |
  ConstantExpr | A constant value that is initialized with an expression using other constant values |
  OperandTraits< ConstantExpr > | |
  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 | Holds a subclass of DINode |
  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' |
  DIDerivedType | Derived types |
  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 |
  DIExpression | DWARF expression |
   expr_op_iterator | An iterator for expression operands |
   ExprOperand | A lightweight wrapper around an expression operand |
   FragmentInfo | Holds the characteristics of one fragment of a larger variable |
  DIGlobalVariable | Global variables |
  DILocalVariable | Local variable |
  DIObjCProperty | |
  DIImportedEntity | An imported module (C++ using directive or similar) |
  DIGlobalVariableExpression | A pair of DIGlobalVariable and DIExpression |
  DIMacroNode | Macro Info DWARF-like metadata node |
  DIMacro | |
  DIMacroFile | |
  DebugLoc | A debug info location |
  IntegerType | Class to represent integer types |
  FunctionType | Class to represent function types |
  CompositeType | Common super class of ArrayType, StructType and VectorType |
  StructType | Class to represent struct types |
  SequentialType | This is the superclass of the array and vector type classes |
  ArrayType | Class to represent array types |
  VectorType | Class to represent vector types |
  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 |
  DiagnosticInfoResourceLimit | Diagnostic information for stack size etc |
  DiagnosticInfoStackSize | |
  DiagnosticInfoDebugMetadataVersion | Diagnostic information for debug metadata version reporting |
  DiagnosticInfoIgnoringInvalidDebugMetadata | Diagnostic information for stripping invalid debug metadata |
  DiagnosticInfoSampleProfile | Diagnostic information for the sample profiler |
  DiagnosticInfoPGOProfile | Diagnostic information for the PGO profiler |
  DiagnosticInfoWithDebugLocBase | Common features for diagnostics with an associated DebugLoc |
  DiagnosticInfoOptimizationBase | Common features for diagnostics dealing with optimization remarks |
   Argument | Used in the streaming interface as the general argument type |
   setExtraArgs | When an instance of this is inserted into the stream, the arguments following will not appear in the remark printed in the compiler output (-Rpass) but only in the optimization record file (-fsave-optimization-record) |
   setIsVerbose | Used to set IsVerbose via the stream interface |
  OptimizationRemark | Diagnostic information for applied optimization remarks |
  OptimizationRemarkMissed | Diagnostic information for missed-optimization remarks |
  OptimizationRemarkAnalysis | Diagnostic information for optimization analysis remarks |
  OptimizationRemarkAnalysisFPCommute | Diagnostic information for optimization analysis remarks related to floating-point non-commutativity |
  OptimizationRemarkAnalysisAliasing | Diagnostic information for optimization analysis remarks related to pointer aliasing |
  DiagnosticInfoMIRParser | Diagnostic information for machine IR parser |
  DiagnosticInfoISelFallback | Diagnostic information for ISel fallback path |
  DiagnosticInfoOptimizationFailure | Diagnostic information for optimization failures |
  DiagnosticInfoUnsupported | Diagnostic information for unsupported feature in backend |
  DiagnosticPrinter | Interface for custom diagnostic printing |
  DiagnosticPrinterRawOStream | Basic diagnostic printer that uses an underlying raw_ostream |
  DIBuilder | |
  BasicBlockEdge | |
  DenseMapInfo< BasicBlockEdge > | |
  DominatorTree | Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree |
  DomTreeGraphTraitsBase | |
  GraphTraits< DomTreeNode * > | |
  GraphTraits< const 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 |
  Function | |
  OperandTraits< Function > | |
  generic_gep_type_iterator | |
  GlobalAlias | |
  GlobalIFunc | |
  GlobalIndirectSymbol | |
  OperandTraits< GlobalIndirectSymbol > | |
  GlobalObject | |
  GlobalValue | |
  GlobalVariable | |
  OperandTraits< GlobalVariable > | |
  GVMaterializer | |
  ConstantUniqueMap | |
  InlineAsm | |
   ConstraintInfo | |
   SubConstraintInfo | |
  InstIterator | |
  TerminatorInst | Subclasses of this class are all able to terminate a basic block |
   SuccIterator | |
  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 > | |
  FuncletPadInst | |
  OperandTraits< FuncletPadInst > | |
  OperandBundleUse | A lightweight accessor for an operand bundle meant to be passed around by value |
  OperandBundleDefT | A container for an operand bundle being viewed as a set of values rather than a set of uses |
  OperandBundleUser | A mixin to add operand bundle functionality to llvm instruction classes |
   BundleOpInfo | Used to keep track of an operand bundle |
  Instruction | |
  AllocaInst | Instruction to allocate memory on the stack |
  LoadInst | An instruction for reading from memory |
  StoreInst | An instruction for storing to memory |
  OperandTraits< StoreInst > | |
  FenceInst | An instruction for ordering other memory operations |
  AtomicCmpXchgInst | 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 | Instruction that atomically reads a memory location, combines it with another value, and then stores the result back |
  OperandTraits< AtomicRMWInst > | |
  GetElementPtrInst | 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 | This class represents a function call, abstracting a target machine's calling convention |
  OperandTraits< CallInst > | |
  SelectInst | This class represents the LLVM 'select' instruction |
  OperandTraits< SelectInst > | |
  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 | This instruction extracts a single (scalar) element from a VectorType value |
  OperandTraits< ExtractElementInst > | |
  InsertElementInst | This instruction inserts a single (scalar) element into a VectorType value |
  OperandTraits< InsertElementInst > | |
  ShuffleVectorInst | This instruction constructs a fixed permutation of two input vectors |
  OperandTraits< ShuffleVectorInst > | |
  ExtractValueInst | This instruction extracts a struct member or array element value from an aggregate value |
  InsertValueInst | This instruction inserts a struct field of array element value into an aggregate value |
  OperandTraits< InsertValueInst > | |
  PHINode | |
  OperandTraits< PHINode > | |
  LandingPadInst | The landingpad instruction holds all of the information necessary to generate correct exception handling |
  OperandTraits< LandingPadInst > | |
  ReturnInst | Return a value (possibly void), from a function |
  OperandTraits< ReturnInst > | |
  BranchInst | Conditional or Unconditional Branch instruction |
  OperandTraits< BranchInst > | |
  SwitchInst | Multiway switch |
   CaseIt | |
   CaseIteratorT | |
  OperandTraits< SwitchInst > | |
  IndirectBrInst | Indirect Branch Instruction |
  OperandTraits< IndirectBrInst > | |
  InvokeInst | Invoke instruction |
  OperandTraits< InvokeInst > | |
  ResumeInst | Resume the propagation of an exception |
  OperandTraits< ResumeInst > | |
  CatchSwitchInst | |
  OperandTraits< CatchSwitchInst > | |
  CleanupPadInst | |
  CatchPadInst | |
  CatchReturnInst | |
  OperandTraits< CatchReturnInst > | |
  CleanupReturnInst | |
  OperandTraits< CleanupReturnInst > | |
  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 | A wrapper class for inspecting calls to intrinsic functions |
  DbgInfoIntrinsic | This is the common base class for debug info intrinsics |
  DbgDeclareInst | This represents the llvm.dbg.declare instruction |
  DbgValueInst | This represents the llvm.dbg.value instruction |
  MemIntrinsic | This is the common base class for memset/memcpy/memmove |
  MemSetInst | This class wraps the llvm.memset intrinsic |
  MemTransferInst | This class wraps the llvm.memcpy/memmove intrinsics |
  MemCpyInst | This class wraps the llvm.memcpy intrinsic |
  MemMoveInst | This class wraps the llvm.memmove intrinsic |
  VAStartInst | This represents the llvm.va_start intrinsic |
  VAEndInst | This represents the llvm.va_end intrinsic |
  VACopyInst | This represents the llvm.va_copy intrinsic |
  InstrProfIncrementInst | This represents the llvm.instrprof_increment intrinsic |
  InstrProfIncrementInstStep | |
  InstrProfValueProfileInst | This represents the llvm.instrprof_value_profile 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 |
  IRBuilderCallbackInserter | Provides an 'InsertHelper' that calls a user-provided callback after performing the default insertion |
  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 |
  AnalysisManager | A container for analyses that lazily runs them and caches their results |
   Invalidator | API to communicate dependencies between analyses during invalidation |
  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 |
  MetadataTracking | API for tracking metadata references through RAUW and deletion |
  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 |
  DistinctMDOperandPlaceholder | Placeholder metadata for operands of distinct MDNodes |
  NamedMDNode | A tuple of MDNodes |
  Module | A Module instance is used to store all the information related to an LLVM module |
   debug_compile_units_iterator | An iterator for DICompileUnits that skips those marked NoDebug |
   ModuleFlagEntry | |
  ModuleSlotTracker | Manage lifetime of a slot tracker for printing IR |
  CalleeInfo | Class to accumulate and hold information about a callee |
  ValueInfo | Struct to hold value either by GUID or GlobalValue* |
   ValueUnion | Union of the two possible value types |
  DenseMapInfo< ValueInfo > | |
  GlobalValueSummary | Function and variable summary information to aid decisions and implementation of importing |
   GVFlags | Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield |
  AliasSummary | Alias summary information |
  FunctionSummary | Function summary information to aid decisions and implementation of importing |
  GlobalVarSummary | Global variable summary information to aid decisions and implementation of importing |
  TypeTestResolution | |
  TypeIdSummary | |
  ModuleSummaryIndex | Class to hold module path string table and global value map, and encapsulate methods for operating on them |
  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 | |
  OptBisect | This class implements a mechanism to disable passes and individual optimizations at compile time based on a command line option (-opt-bisect-limit) in order to perform a bisecting search for optimization-related problems |
  AnalysisKey | A special type used by analysis passes to provide an address that identifies that particular analysis pass type |
  AnalysisSetKey | A special type used to provide an address that identifies a set of related analyses |
  PreservedAnalyses | A set of analyses that are preserved following a run of a transformation pass |
   PreservedAnalysisChecker | A checker object that makes it easy to query for whether an analysis or some set covering it is preserved |
  PassInfoMixin | A CRTP mix-in to automatically provide informational APIs needed for passes |
  AnalysisInfoMixin | A CRTP mix-in that provides informational APIs needed for analysis passes |
  AllAnalysesOn | This templated class represents "all analyses that operate over \<a
particular IR unit\>" (e.g |
  PassManager | Manages a sequence of passes over a particular unit of IR |
  InnerAnalysisManagerProxy | An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR unit |
   Result | |
  OuterAnalysisManagerProxy | An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR unit |
   Result | Result proxy object for OuterAnalysisManagerProxy |
  ModuleToFunctionPassAdaptor | Trivial adaptor that maps from a module to its functions |
  RequireAnalysisPass | A utility pass template to force an analysis result to be available |
  InvalidateAnalysisPass | A no-op pass template which simply forces a specific analysis result to be invalidated |
  InvalidateAllAnalysesPass | A utility pass that does nothing, but preserves no analyses |
  RepeatedPass | A utility pass template that simply runs another pass multiple times |
  PredIteratorCache | PredIteratorCache - This class is an extremely trivial cache for predecessor iterator queries |
  ProfileSummaryEntry | |
  ProfileSummary | |
  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 |
  GCProjectionInst | Common base class for representing values projected from a statepoint |
  GCRelocateInst | Represents calls to the gc.relocate intrinsic |
  GCResultInst | Represents calls to the gc.result intrinsic |
  StatepointDirectives | Call sites that get wrapped by a gc.statepoint (currently only in RewriteStatepointsForGC and potentially in other passes in the future) can have attributes that describe properties of gc.statepoint call they will be eventually be wrapped in |
  SymbolTableListParentType | Template metafunction to get the parent type for a symbol table list |
  SymbolTableList | List that automatically updates parent links and symbol tables |
  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 |
  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 | |
   const_value_op_iterator | |
   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< ConstantData, Value > | |
  isa_impl< ConstantAggregate, 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< GlobalIFunc, Value > | |
  isa_impl< GlobalIndirectSymbol, Value > | |
  isa_impl< GlobalValue, Value > | |
  isa_impl< GlobalObject, Value > | |
  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 |
  TBAAVerifier | Verify that the TBAA Metadatas are valid |
  VerifierAnalysis | Check a module for errors, and report separate error states for IR and debug info errors |
   Result | |
  VerifierPass | Create a verifier pass |
  LineEditor | |
   Completion | A possible completion at a given cursor position |
   CompletionAction | The action to perform upon a completion request |
   InternalData | |
  IRMover | |
   IdentifiedStructTypeSet | |
  Linker | This class provides the core functionality of linking in LLVM |
  LTOCodeGenerator | C++ class which implements the opaque lto_code_gen_t type |
  LTOModule | C++ class which implements the opaque lto_module_t type |
  ThinLTOBuffer | Wrapper around MemoryBufferRef, owning the identifier |
  TargetMachineBuilder | Helper to gather options relevant to the target machine creation |
  ThinLTOCodeGenerator | This class define an interface similar to the LTOCodeGenerator, but adapted for ThinLTO processing |
   CachingOptions | |
  ConstantPoolEntry | |
  ConstantPool | |
  AssemblerConstantPools | |
  LaneBitmask | |
  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 |
  IndirectSymbolData | |
  DataRegionData | |
  MCAssembler | |
   VersionMinInfoType | MachO specific deployment target version info |
  MCCodeEmitter | MCCodeEmitter - Generic instruction encoding interface |
  MCCVLoc | Instances of this class represent the information from a .cv_loc directive |
  MCCVLineEntry | Instances of this class represent the line information for the CodeView line table entries |
  MCCVFunctionInfo | Information describing a function or inlined call site introduced by .cv_func_id or .cv_inline_site_id |
   LineInfo | |
  CodeViewContext | Holds state from .cv_file and .cv_loc directives for later emission |
  MCContext | Context object for machine code objects |
  MCDisassembler | Superclass for all disassemblers |
  MCExternalSymbolizer | Symbolize using user-provided, C API, callbacks |
  MCRelocationInfo | Create MCExprs from relocations found in an object file |
  MCSymbolizer | Symbolize and annotate disassembled instructions |
  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 |
  MCDwarfLineEntry | 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 |
  MCDwarfLineTableParams | |
  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 |
  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 |
  MCFragment | |
  MCDummyFragment | |
  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 | |
  MCCVInlineLineTableFragment | Fragment representing the binary annotations produced by the .cv_inline_linetable directive |
  MCCVDefRangeFragment | Fragment representing the .cv_def_range directive |
  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 |
  AsmCommentConsumer | A callback class which is notified of each comment in an assembly file as it is lexed |
  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 |
   MCPendingError | |
  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 |
  AsmRewrite | |
  ParseInstructionInfo | |
  MCTargetAsmParser | MCTargetAsmParser - Generic interface to target specific assembly parsers |
  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 | MCRegUnitMaskIterator 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 |
  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_alloc_traits< MCFragment > | |
  MCSection | Instances of this class represent a uniqued identifier for a section in the current translation unit |
  MCSectionCOFF | This represents a section on Windows |
  MCSectionELF | This represents a section on linux, lots of unix variants and some bare metal systems |
  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 | |
  MCSymbolMachO | |
  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 |
  NewArchiveMember | |
  ModuleSymbolTable | |
  StackMapV2Parser | |
   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 |
  InstrProfError | |
  SoftInstrProfErrors | |
  InstrProfSymtab | A symbol table used for function PGO name look-up with keys (such as pointers, md5hash values) to the function |
  InstrProfValueSiteRecord | |
  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 |
  InstrProfReaderIndexBase | |
  InstrProfReaderIndex | |
  IndexedInstrProfReader | Reader for the indexed binary instrprof format |
  InstrProfWriter | |
  ProfileSummaryBuilder | |
  InstrProfSummaryBuilder | |
  SampleProfileSummaryBuilder | |
  AlignedCharArray | Helper for building an aligned character array type |
  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 | |
  CachePruning | Handle pruning a directory provided a path and some options to control what to prune |
  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 | |
  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 |
  ErrorInfoBase | Base class for error info classes |
  Error | Lightweight error class with error context and mandatory checking |
  ErrorSuccess | Subclass of Error for the sole purpose of identifying the success path in the type system |
  ErrorInfo | Base class for user error types |
  ErrorList | Special ErrorInfo subclass representing a list of ErrorInfos |
  ErrorHandlerTraits | Helper for testing applicability of, and applying, handlers for ErrorInfo types |
  ErrorHandlerTraits< Error(&)(ErrT &)> | |
  ErrorHandlerTraits< void(&)(ErrT &)> | |
  ErrorHandlerTraits< Error(&)(std::unique_ptr< ErrT >)> | Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)' |
  ErrorHandlerTraits< void(&)(std::unique_ptr< ErrT >)> | Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)' |
  ErrorHandlerTraits< RetT(C::*)(ErrT &)> | |
  ErrorHandlerTraits< RetT(C::*)(ErrT &) const > | |
  ErrorHandlerTraits< RetT(C::*)(const ErrT &)> | |
  ErrorHandlerTraits< RetT(C::*)(const ErrT &) const > | |
  ErrorHandlerTraits< RetT(C::*)(std::unique_ptr< ErrT >)> | Specialization for member functions of the form 'RetT (std::unique_ptr<ErrT>) const' |
  ErrorHandlerTraits< RetT(C::*)(std::unique_ptr< ErrT >) const > | Specialization for member functions of the form 'RetT (std::unique_ptr<ErrT>) const' |
  ErrorAsOutParameter | Helper for Errors used as out-parameters |
  Expected | Tagged union holding either a T or a Error |
  ECError | This class wraps a std::error_code in a Error |
  StringError | This class wraps a string in an Error |
  ExitOnError | Helper for check-and-exit error handling |
  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 |
  validate_format_parameters | These are templated helper classes used by the format function that capture the object to be formatted and the format string |
  validate_format_parameters< Arg, Args...> | |
  validate_format_parameters<> | |
  format_object | |
  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() |
  FormattedBytes | |
  FormatAdapter | |
  FmtAlign | |
  format_provider< T, typename std::enable_if< detail::use_integral_formatter< T >::value >::type > | Implementation of format_provider<T> for integral arithmetic types |
  format_provider< T, typename std::enable_if< detail::use_pointer_formatter< T >::value >::type > | Implementation of format_provider<T> for integral pointer types |
  format_provider< T, typename std::enable_if< detail::use_string_formatter< T >::value >::type > | Implementation of format_provider<T> for c-style strings and string objects such as std::string and llvm::StringRef |
  format_provider< T, typename std::enable_if< detail::use_char_formatter< T >::value >::type > | Implementation of format_provider<T> for characters |
  format_provider< bool > | Implementation of format_provider<T> for type bool |
  format_provider< T, typename std::enable_if< detail::use_double_formatter< T >::value >::type > | Implementation of format_provider<T> for floating point types |
  format_provider< llvm::iterator_range< IterT > > | Implementation of format_provider<T> for ranges |
  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 |
  ReplacementItem | |
  formatv_object_base | |
   create_adapters | |
  formatv_object | |
  format_provider | |
  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 |
  DomTreeNodeBase | Base class for the actual dominator tree node |
  GlobPattern | |
  JamCRC | |
  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 |
  AlignTo | alignTo for contexts where a constant expression is required |
   from_value | |
  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 | |
  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 |
  PluginLoader | |
  PointerLikeTypeTraits | A traits type that is used to handle pointer types and things that are just wrappers for pointers as a uniform entity |
  PointerLikeTypeTraits< T * > | |
  PointerLikeTypeTraits< void * > | |
  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 |
  PrettyStackTraceFormat | PrettyStackTraceFormat - This object prints a string (which may use printf-style formatting but 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 |
  Printable | Simple wrapper around std::function<void(raw_ostream&)> |
  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 | |
  raw_sha1_ostream | A raw_ostream that hash the content using the sha1 algorithm |
  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 |
  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 |
   node | Node in linked list of entries |
  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 > > | |
  EnumEntry | |
  HexNumber | |
  ScopedPrinter | |
  DelimitedScope | |
  SHA1 | A class that wrap the SHA1 algorithm |
  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 |
  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 StringRef with a stable character pointer |
  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 |
  RegisterMCAdjustCodeGenOptsFn | |
  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 |
  TarWriter | |
  ThreadPool | A ThreadPool for asynchronous parallel execution on a defined number of threads |
  TimeRecord | |
  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 | 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: |
  TrailingObjects | See the file comment for details on the usage of the TrailingObjects type |
   FixedSizeStorage | A type where its ::with_counts template member has a ::type member suitable for use as uninitialized storage for an object with the given trailing object counts |
    with_counts | |
   FixedSizeStorageOwner | A type that acts as the owner for an object placed into fixed storage |
  TrigramIndex | |
  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, including enum classes |
  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 | 'bit' - Represent a single bit |
  BitsRecTy | 'bits<n>' - Represent a fixed number of bits |
  CodeRecTy | 'code' - Represent a code fragment |
  IntRecTy | 'int' - Represent an integer value of no particular size |
  StringRecTy | 'string' - Represent an string value |
  ListRecTy | 'list<Ty>' - Represent a list of values, all of which must be of the specified type |
  DagRecTy | 'dag' - Represent a dag fragment |
  RecordRecTy | '[classname]' - Represent an instance of a class, such as: (R32 X = EAX) |
  Init | |
  TypedInit | This is the common super-class of types that have a specific, explicit, type |
  UnsetInit | '?' - Represents an uninitialized value |
  BitInit | 'true'/'false' - Represent a concrete initializer for a bit |
  BitsInit | '{ a, b, c }' - Represents an initializer for a BitsRecTy value |
  IntInit | '7' - Represent an initialization by a literal integer value |
  StringInit | "foo" - Represent an initialization by a string value |
  CodeInit | |
  ListInit | [AL, AH, CL] - Represent a list of defs |
  OpInit | Base class for operators |
  UnOpInit | !op (X) - Transform an init |
  BinOpInit | !op (X, Y) - Combine two inits |
  TernOpInit | !op (X, Y, Z) - Combine two inits |
  VarInit | 'Opcode' - Represent a reference to an entire variable object |
  VarBitInit | Opcode{0} - Represent access to one bit of a variable or field |
  VarListElementInit | List[4] - Represent access to one element of a var or field |
  DefInit | AL - Represent a reference to a 'def' in the description |
  FieldInit | X.Y - Represent a reference to a subfield of a variable |
  DagInit | (v a, b) - Represent a DAG tree value |
  RecordVal | |
  Record | |
  MultiClass | |
  RecordKeeper | |
  LessRecord | Sorting predicate to sort record pointers by name |
  LessRecordByID | Sorting predicate to sort record pointers by their unique ID |
  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 |
  DenseMapInfo< TargetInstrInfo::RegSubRegPair > | Provide DenseMapInfo for TargetInstrInfo::RegSubRegPair |
  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 | |
  TargetRegisterClass | |
  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 | |
  BitMaskClassIterator | This class encapuslates the logic to iterate over bitmask returned by the various RegClass related APIs |
  VirtReg2IndexFunctor | |
  TargetSubtargetInfo | TargetSubtargetInfo - Generic base class for all target subtargets |
  GCOVProfilerPass | The gcov-style instrumentation pass |
  InstCombinePass | |
  InstructionCombiningPass | The legacy pass manager's instcombine pass |
  InstCombineWorklist | InstCombineWorklist - This is the worklist management logic for InstCombine |
  InstrProfiling | Instrumentation based profiling lowering pass |
  GCOVOptions | |
  InstrProfOptions | Options for the frontend instrumentation based profiling pass |
  EfficiencySanitizerOptions | |
  SanitizerCoverageOptions | |
  AlwaysInlinerPass | Inlines functions marked as "always_inline" |
  ConstantMergePass | A pass that merges duplicate global constants into a single constant |
  CrossDSOCFIPass | |
  DeadArgumentEliminationPass | Eliminate dead arguments (and return values) from functions |
   RetOrArg | Struct that represents (part of) either a return value or a function argument |
  EliminateAvailableExternallyPass | A pass that transforms external global definitions into declarations |
  ForceFunctionAttrsPass | Pass which forces specific function attributes into the IR, primarily as a debugging tool |
  PostOrderFunctionAttrsPass | Computes function attributes in post-order over the call graph |
  ReversePostOrderFunctionAttrsPass | A pass to do RPO deduction and propagation of function attributes |
  FunctionImporter | The function importer is automatically importing function from other modules based on the provided summary informations |
  FunctionImportPass | The function importing pass |
  GlobalDCEPass | Pass to remove unused function declarations |
  GlobalOptPass | Optimize globals that never have their address taken |
  GlobalSplitPass | Pass to perform split of global variables |
  InferFunctionAttrsPass | A pass which infers function attributes from the names and signatures of function declarations in a module |
  LegacyInlinerBase | This class contains all of the helper code which is used to perform the inlining operations that do not depend on the policy |
  InlinerPass | The inliner pass for the new pass manager |
  InternalizePass | A pass that internalizes all functions and variables other than those that must be preserved according to MustPreserveGV |
  LowerTypeTestsPass | |
  PartialInlinerPass | Pass to remove unused function declarations |
  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 |
  IPSCCPPass | Pass to perform interprocedural constant propagation |
  StripDeadPrototypesPass | Pass to remove unused function declarations |
  WholeProgramDevirtPass | |
  PGOInstrumentationGen | The instrumentation (profile-instr-gen) pass for IR based PGO |
  PGOInstrumentationUse | The profile annotation (profile-instr-use) pass for IR based PGO |
  PGOIndirectCallPromotion | The indirect function call promotion pass |
  SampleProfileLoaderPass | The sample profiler data loader pass |
  ADCEPass | A DCE pass that assumes instructions are dead until proven otherwise |
  AlignmentFromAssumptionsPass | |
  BDCEPass | |
  ConstantHoistingPass | |
  CorrelatedValuePropagationPass | |
  DCEPass | Basic Dead Code Elimination pass |
  DSEPass | This class implements a trivial dead store elimination |
  EarlyCSEPass | A simple and fast domtree-based CSE pass |
  Float2IntPass | |
  GuardWideningPass | |
  GVN | The core GVN pass object |
   Expression | |
   ValueTable | This class holds the mapping between values and value numbers |
  GVNHoistPass | A simple and fast domtree-based GVN pass to hoist common expressions from sibling branches |
  IndVarSimplifyPass | |
  IVUsersPrinterPass | Printer pass for the IVUsers for a loop |
  JumpThreadingPass | This pass performs 'jump threading', which looks at blocks that have multiple predecessors and multiple successors |
  LICMPass | Performs Loop Invariant Code Motion Pass |
  LoopAccessInfoPrinterPass | Printer pass for the LoopAccessInfo results |
  LoopDataPrefetchPass | An optimization pass inserting data prefetches in loops |
  LoopDeletionPass | |
  LoopDistributePass | |
  LoopIdiomRecognizePass | Performs Loop Idiom Recognize Pass |
  LoopInstSimplifyPass | Performs Loop Inst Simplify Pass |
  RequireAnalysisPass< AnalysisT, Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > | A partial specialization of the require analysis template pass to forward the extra parameters from a transformation's run method to the AnalysisManager's getResult |
  FunctionToLoopPassAdaptor | Adaptor that maps from a function to its loops |
  LPMUpdater | This class provides an interface for updating the loop pass manager based on mutations to the loop nest |
  PrintLoopPass | Pass for printing a loop's contents as textual IR |
  LoopRotatePass | A simple loop rotation transformation |
  LoopSimplifyCFGPass | Performs basic CFG simplifications to assist other loop passes |
  LoopStrengthReducePass | Performs Loop Strength Reduce Pass |
  LoopUnrollPass | |
  LowerAtomicPass | A pass that lowers atomic intrinsic into non-atomic intrinsics |
  LowerExpectIntrinsicPass | |
  LowerGuardIntrinsicPass | |
  MemCpyOptPass | |
  MergedLoadStoreMotionPass | |
  NaryReassociatePass | |
  NewGVNPass | |
  PartiallyInlineLibCallsPass | |
  ReassociatePass | Reassociate commutative expressions |
  SCCPPass | This pass performs function-level constant propagation and merging |
  SimplifyCFGPass | A pass to simplify and canonicalize the CFG of a function |
  SinkingPass | Move instructions into successor blocks when possible |
  SpeculativeExecutionPass | |
  SROA | An optimization pass providing Scalar Replacement of Aggregates |
  TailCallElimPass | |
  AddDiscriminatorsPass | |
  ASanStackVariableDescription | |
  ASanStackFrameLayout | |
  CriticalEdgeSplittingOptions | Option class for critical edge splitting |
  BreakCriticalEdgesPass | |
  ClonedCodeInfo | ClonedCodeInfo - This struct can be used to capture information about code being cloned, while it is 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 |
  EscapeEnumerator | EscapeEnumerator - This is a little algorithm to find all escape points from a function so that "finally"-style code can be inserted |
  Evaluator | This class evaluates LLVM IR, producing the Constant representing each SSA instruction |
  GlobalNumberState | GlobalNumberState assigns an integer to each global value in the program, which is used by the comparison routine to order references to globals |
  FunctionComparator | FunctionComparator - Compares two functions to determine whether or not they will generate machine code with the same behaviour |
  FunctionImportGlobalProcessing | Class to handle necessary GlobalValue changes required by ThinLTO function importing, including linkage changes and any necessary renaming |
  GlobalStatus | As we analyze each global, keep track of some information about it |
  ImportedFunctionsInliningStatistics | Calculate and dump ThinLTO specific inliner stats |
  LCSSAPass | Converts loops into loop-closed SSA form |
  LibCallsShrinkWrapPass | |
  LoopSimplifyPass | This pass is responsible for loop canonicalization |
  LoopSafetyInfo | 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 |
  InductionDescriptor | A struct for saving information about induction variables |
  LoopVersioning | This class emits a version of the loop where run-time checks ensure that may-alias pointers can't overlap |
  LowerInvokePass | |
  PromotePass | |
  memoryaccess_def_iterator_base | Iterator base class used to implement const and non-const iterators over the defining accesses of a MemoryAccess |
  MemoryAccess | |
  MemoryUseOrDef | Class that has the common methods + fields of memory uses/defs |
  OperandTraits< MemoryUseOrDef > | |
  MemoryUse | Represents read-only accesses to memory |
  OperandTraits< MemoryUse > | |
  MemoryDef | Represents a read-write access to memory, whether it is a must-alias, or a may-alias |
  OperandTraits< MemoryDef > | |
  MemoryPhi | Represents phi nodes for memory accesses |
  OperandTraits< MemoryPhi > | |
  MemorySSA | Encapsulates MemorySSA, including all data associated with memory accesses |
   CachingWalker | A MemorySSAWalker that does AA walks and caching of lookups to disambiguate accesses |
   OptimizeUses | This class is a batch walker of all MemoryUse's in the program, and points their defining access at the thing that actually clobbers them |
  MemorySSAPrinterLegacyPass | |
  MemorySSAAnalysis | An analysis that produces MemorySSA for a function |
   Result | |
  MemorySSAPrinterPass | Printer pass for MemorySSA |
  MemorySSAVerifierPass | Verifier pass for MemorySSA |
  MemorySSAWrapperPass | Legacy analysis pass which computes MemorySSA |
  MemorySSAWalker | This is the generic walker interface for walkers of MemorySSA |
  DoNothingMemorySSAWalker | A MemorySSAWalker that does no alias queries, or anything else |
  GraphTraits< MemoryAccess * > | GraphTraits for a MemoryAccess, which walks defs in the normal case, and uses in the inverse case |
  GraphTraits< Inverse< MemoryAccess * > > | |
  upward_defs_iterator | Provide an iterator that walks defs, giving both the memory access, and the current pointer location, updating the pointer location as it changes due to phi node translation |
  NameAnonGlobalPass | Simple pass that provides a name to every anonymous globals |
  SanitizerStatReport | |
  IVVisitor | Interface for visiting interesting IV users that are recognized but not simplified by this utility |
  InstSimplifierPass | This pass removes redundant instructions |
  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 | |
  RewriteSymbolPass | |
  UnifyFunctionExitNodes | |
  ValueMapTypeRemapper | This is a class that can be implemented by clients to remap types when cloning constants and instructions |
  ValueMaterializer | This is a class that can be implemented by clients to materialize Values on demand |
  ValueMapper | Context for (re-)mapping values (and metadata) |
  LoopVectorizePass | The LoopVectorize Pass |
  SLPVectorizerPass | |
  VectorizeConfig | Vectorize configuration |
  AAEvalLegacyPass | |
  DenseMapInfo< cflaa::InstantiatedValue > | |
  GraphTraits< BlockFrequencyInfo * > | |
  DOTGraphTraits< BlockFrequencyInfo * > | |
  GraphTraits< IrreducibleGraph > | |
  DOTGraphTraits< CallGraph * > | |
  AnalysisCallGraphWrapperPassTraits | |
  DenseMapInfo< OffsetValue > | |
  DenseMapInfo< OffsetInstantiatedValue > | |
  DOTGraphTraits< DomTreeNode * > | |
  DOTGraphTraits< DominatorTree * > | |
  DOTGraphTraits< PostDominatorTree * > | |
  DOTGraphTraits< RegionNode * > | |
  DOTGraphTraits< RegionInfo * > | |
  LLLexer | |
  ValID | ValID - Represents a reference of a definition of some sort with no type |
  LLParser | |
  MetadataLoader | Helper class that handles loading Metadatas and keeping them available |
   MetadataLoaderImpl | |
  OperandTraits< ConstantPlaceHolder > | |
  BitcodeReaderValueList | |
  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 | |
  ClassInfo | |
   MemberInfo | |
  CodeViewDebug | Collects and handles line tables information in a CodeView format |
   TypeLoweringScope | |
  DbgValueHistoryMap | |
  DebugHandlerBase | Base class for debug information backends |
  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 | |
   GlobalExpr | A pair of GlobalVariable and DIExpression |
  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 | |
  DIExpressionCursor | Holds a DIExpression and keeps track of how many operands have been consumed so far |
  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 |
  WinException | |
  BranchFolder | |
   MBFIWrapper | This class keeps track of branch frequencies of newly created blocks and tail-merged blocks |
  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 |
  VRegInfo | |
  PerFunctionMIParsingState | |
  MIRParserImpl | This class implements the parsing of LLVM IR that's embedded inside a MIR file |
  MIRPrinter | This class prints out the machine functions using the MIR serialization format |
  MIPrinter | This class prints out the machine instructions using the MIR serialization format |
  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 | 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 |
   StatepointLoweringInfo | Describes a gc.statepoint or a gc.statepoint like thing for the purposes of lowering into a STATEPOINT node |
  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 |
  InsertPointAnalysis | Determines the latest safe point in a block in which we can insert a split, spill or other instruction related with CurLI |
  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 |
  PassConfigImpl | |
  FrameEntry | Abstract frame entry defining the common interface concrete entries implement |
   Instruction | |
  IntelJITEventsWrapper | |
  AllocaHolder | |
  ExecutionContext | |
  Interpreter | |
  LinkingSymbolResolver | |
  MCJIT | |
  OrcCBindingsStack | |
  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 |
  RuntimeDyldCOFFI386 | |
  RuntimeDyldCOFFThumb | |
  RuntimeDyldCOFFX86_64 | |
  RuntimeDyldELFMips | |
  RuntimeDyldMachOAArch64 | |
  RuntimeDyldMachOARM | |
  RuntimeDyldMachOI386 | |
  RuntimeDyldMachOX86_64 | |
  SlotTracker | This class provides computation of slot numbers for LLVM Assembly writing |
  AttributeImpl | |
  EnumAttributeImpl | |
  IntAttributeImpl | |
  StringAttributeImpl | |
  AttributeSetImpl | |
  AttributeSetNode | |
  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 |
  MDNodeSubsetEqualImpl | Configuration point for MDNodeInfo::isEqual() |
  MDNodeKeyImpl< MDTuple > | DenseMapInfo for MDTuple |
  MDNodeKeyImpl< DILocation > | DenseMapInfo for DILocation |
  MDNodeKeyImpl< GenericDINode > | DenseMapInfo for GenericDINode |
  MDNodeKeyImpl< DISubrange > | |
  MDNodeKeyImpl< DIEnumerator > | |
  MDNodeKeyImpl< DIBasicType > | |
  MDNodeKeyImpl< DIDerivedType > | |
  MDNodeSubsetEqualImpl< DIDerivedType > | |
  MDNodeKeyImpl< DICompositeType > | |
  MDNodeKeyImpl< DISubroutineType > | |
  MDNodeKeyImpl< DIFile > | |
  MDNodeKeyImpl< DISubprogram > | |
  MDNodeSubsetEqualImpl< DISubprogram > | |
  MDNodeKeyImpl< DILexicalBlock > | |
  MDNodeKeyImpl< DILexicalBlockFile > | |
  MDNodeKeyImpl< DINamespace > | |
  MDNodeKeyImpl< DIModule > | |
  MDNodeKeyImpl< DITemplateTypeParameter > | |
  MDNodeKeyImpl< DITemplateValueParameter > | |
  MDNodeKeyImpl< DIGlobalVariable > | |
  MDNodeKeyImpl< DILocalVariable > | |
  MDNodeKeyImpl< DIExpression > | |
  MDNodeKeyImpl< DIGlobalVariableExpression > | |
  MDNodeKeyImpl< DIObjCProperty > | |
  MDNodeKeyImpl< DIImportedEntity > | |
  MDNodeKeyImpl< DIMacro > | |
  MDNodeKeyImpl< DIMacroFile > | |
  MDAttachmentMap | Map-like storage for metadata attachments |
  MDGlobalAttachmentMap | Multimap-like storage for metadata attachments for globals |
  LLVMContextImpl | |
  DescriptorInfo | |
  VerifierSupport | |
  LinkDiagnosticInfo | |
  LLVMDisasmContext | |
  DenseMapInfo< CIEKey > | |
  RecordStreamer | |
  ProfOStream | |
  InstrProfRecordWriterTrait | |
  fltSemantics | |
  decimalInfo | |
  TGLexer | TGLexer - TableGen Lexer class |
  SubClassReference | |
  SubMultiClassReference | |
  LetRecord | |
  ForeachLoop | ForeachLoop - Record the iteration state associated with a for loop |
  TGParser | |
  AArch64CallLowering | |
  AArch64FrameLowering | |
  AArch64InstrInfo | |
  AArch64InstructionSelector | |
  AArch64TargetLowering | |
  AArch64LegalizerInfo | This class provides the information for the target register banks |
  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 |
  AArch64RegisterBankInfo | This class provides the information for the target register banks |
  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 | |
  AMDGPUAsmPrinter | |
  AMDGPUCallLowering | |
  AMDGPUFrameLowering | Information about the stack frame layout on the AMDGPU targets |
  AMDGPUInstrInfo | |
  AMDGPUIntrinsicInfo | |
  AMDGPUTargetLowering | |
  AMDGPUMachineFunction | |
  AMDGPUMCInstLower | |
  AMDGPURegisterInfo | |
  AMDGPUSubtarget | |
  R600Subtarget | |
  SISubtarget | |
  AMDGPUTargetMachine | |
  R600TargetMachine | |
  GCNTargetMachine | |
  AMDGPUTargetObjectFile | |
  AMDGPUTTIImpl | |
  AMDGPUDisassembler | |
  AMDGPUSymbolizer | |
  GCNHazardRecognizer | |
  GCNMaxOccupancySchedStrategy | This is a minimal scheduler strategy |
  AMDGPUInstPrinter | |
  AMDGPUELFStreamer | |
  AMDGPUMCAsmInfo | |
  AMDGPUMCCodeEmitter | |
  AMDGPUTargetStreamer | |
  AMDGPUTargetAsmStreamer | |
  AMDGPUTargetELFStreamer | |
  R600FrameLowering | |
  R600InstrInfo | |
  R600TargetLowering | |
  R600MachineFunctionInfo | |
  R600SchedStrategy | |
  R600RegisterInfo | |
  SIFrameLowering | |
  SIInstrInfo | |
  SITargetLowering | |
  AMDGPUImagePseudoSourceValue | |
  AMDGPUBufferPseudoSourceValue | |
  SIMachineFunctionInfo | This class keeps track of the SPI_SP_INPUT_ADDR config register, which tells the hardware which interpolation parameters to load |
   SpilledReg | |
  SISchedulerCandidate | |
  SIScheduleBlock | |
  SIScheduleBlocks | |
  SIScheduleBlockCreator | |
  SIScheduleBlockScheduler | |
  SIScheduleBlockResult | |
  SIScheduler | |
  SIScheduleDAGMI | |
  SIRegisterInfo | |
  ARMAsmPrinter | |
  ARMBaseInstrInfo | |
  ARMBaseRegisterInfo | |
  BasicBlockInfo | BasicBlockInfo - Information about the offset and size of a single basic block |
  ARMCallLowering | |
  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 | |
  ARMInstructionSelector | |
  ARMTargetLowering | |
  ARMLegalizerInfo | This class provides the information for the target register banks |
  ARMFunctionInfo | ARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific information for each MachineFunction |
  ARMRegisterBankInfo | This class provides the information for the target register banks |
  ARMRegisterInfo | |
  ARMSelectionDAGInfo | |
  ARMSubtarget | |
  ARMBaseTargetMachine | |
  ARMTargetMachine | ARM target machine |
  ARMLETargetMachine | ARM little endian target machine |
  ARMBETargetMachine | ARM big endian target machine |
  ThumbTargetMachine | Thumb target machine |
  ThumbLETargetMachine | Thumb little endian target machine |
  ThumbBETargetMachine | Thumb big endian target machine |
  ARMElfTargetObjectFile | |
  ARMTTIImpl | |
  ARMInstPrinter | |
  ARMAsmBackend | |
  ARMAsmBackendDarwin | |
  ARMMCAsmInfoDarwin | |
  ARMELFMCAsmInfo | |
  ARMCOFFMCAsmInfoMicrosoft | |
  ARMCOFFMCAsmInfoGNU | |
  ARMMCExpr | |
  UnwindOpcodeAssembler | |
  Thumb1FrameLowering | |
  Thumb1InstrInfo | |
  Thumb2InstrInfo | |
  ThumbRegisterInfo | |
  AVRAsmParser | Parses AVR assembly from a stream |
  AVROperand | An parsed AVR assembly operand |
   RegisterImmediate | |
  AVRAsmPrinter | An AVR assembly code printer |
  AVRFrameAnalyzer | The frame analyzer pass |
  AVRDynAllocaSR | Create the Dynalloca Stack Pointer Save/Restore pass |
  AVRFrameLowering | Utilities for creating function call frames |
  AVRInstrInfo | Utilities related to the AVR instruction set |
  AVRDAGToDAGISel | Lowers LLVM IR (in DAG form) to AVR MC instructions (in DAG form) |
  AVRTargetLowering | Performs target lowering for the AVR |
  AVRMachineFunctionInfo | Contains AVR-specific information for each MachineFunction |
  AVRMCInstLower | Lowers MachineInstr objects into MCInst objects |
  AVRRegisterInfo | Utilities relating to AVR registers |
  AVRSelectionDAGInfo | Holds information about the AVR instruction selection DAG |
  AVRSubtarget | A specific AVR target MCU |
  AVRTargetMachine | A generic AVR implementation |
  AVRTargetObjectFile | Lowering for an AVR ELF32 object file |
  AVRInstPrinter | Prints AVR instructions to a textual stream |
  AVRAsmBackend | Utilities for manipulating generated AVR machine code |
  AVRELFObjectWriter | Writes AVR machine code into an ELF32 object file |
  AVRELFStreamer | A target streamer for an AVR ELF object file |
  AVRMCAsmInfo | Specifies the format of AVR assembly files |
  AVRMCCodeEmitter | Writes AVR machine code to a stream |
  AVRMCExpr | A expression in AVR machine code |
  AVRTargetStreamer | A generic AVR target output stream |
  AVRTargetAsmStreamer | A target streamer for textual AVR assembly code |
  BPFFrameLowering | |
  BPFInstrInfo | |
  BPFTargetLowering | |
  BPFMCInstLower | |
  BPFRegisterInfo | |
  BPFSubtarget | |
  BPFTargetMachine | |
  BPFInstPrinter | |
  BPFMCAsmInfo | |
  BitTracker | |
   BitMask | |
   BitRef | |
   BitValue | |
   MachineEvaluator | |
   RegisterCell | |
   RegisterRef | |
  HexagonAsmPrinter | |
  HexagonEvaluator | |
  HexagonBlockRanges | |
   IndexRange | |
   IndexType | |
   InstrIndexMap | |
   PrintRangeMap | |
   RangeList | |
   RegisterRef | |
  HexagonFrameLowering | |
  HexagonHazardRecognizer | |
  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 | |
   HexagonDAGMutation | |
  HexagonTargetMachine | |
  HexagonTargetObjectFile | |
  HexagonTargetStreamer | |
  HexagonTTIImpl | |
  HexagonPacketizerList | |
  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 | |
  ErrInfo_T | |
  HexagonMCErrInfo | |
  HexagonMCChecker | Check for a valid bundle |
  HexagonMCCodeEmitter | |
  HexagonMCELFStreamer | |
  HexagonMCExpr | |
  DuplexCandidate | |
  HexagonMCShuffler | |
  HexagonResource | |
  HexagonCVIResource | |
  HexagonInstr | |
  HexagonShuffler | |
  LanaiDisassembler | |
  LanaiInstPrinter | |
  LanaiFrameLowering | |
  LanaiInstrInfo | |
  LanaiTargetLowering | |
  LanaiMachineFunctionInfo | |
  LanaiMCInstLower | |
  LanaiRegisterInfo | |
  LanaiSelectionDAGInfo | |
  LanaiSubtarget | |
  LanaiTargetMachine | |
  LanaiTargetObjectFile | |
  LanaiTTIImpl | |
  LanaiMCAsmInfo | |
  LanaiMCExpr | |
  MipsInstPrinter | |
  MipsABIFlagsSection | |
  MipsABIInfo | |
  MipsAsmBackend | |
  MipsELFStreamer | |
  MipsMCAsmInfo | |
  MipsMCCodeEmitter | |
  MipsMCExpr | |
  Mips16FrameLowering | |
  Mips16InstrInfo | |
  Mips16DAGToDAGISel | |
  Mips16TargetLowering | |
  Mips16RegisterInfo | |
  MipsAnalyzeImmediate | |
   Inst | |
  MipsAsmPrinter | |
  MipsCCState | |
  MipsFrameLowering | |
  MipsInstrInfo | |
  MipsDAGToDAGISel | |
  MipsTargetLowering | |
  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 | Mips32/64 big endian target machine |
  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 | |
  NVPTXDAGToDAGISel | |
  NVPTXTargetLowering | |
  NVPTXMachineFunctionInfo | |
  NVPTXFloatMCExpr | |
  NVPTXGenericMCSymbolRefExpr | A wrapper for MCSymbolRefExpr that tells the assembly printer that the symbol should be enclosed by generic() |
  NVPTXRegisterInfo | |
  NVPTXSection | Represents a section in PTX PTX does not have sections |
  NVPTXSubtarget | |
  NVPTXTargetMachine | NVPTXTargetMachine |
  NVPTXTargetMachine32 | |
  NVPTXTargetMachine64 | |
  NVPTXTargetObjectFile | |
  NVPTXTTIImpl | |
  PPCInstPrinter | |
  PPCMCAsmInfoDarwin | |
  PPCELFMCAsmInfo | |
  PPCMCExpr | |
  PPCCCState | |
  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 | Common code between 32-bit and 64-bit PowerPC targets |
  PPC32TargetMachine | PowerPC 32-bit target machine |
  PPC64TargetMachine | PowerPC 64-bit target machine |
  PPC64LinuxTargetObjectFile | PPC64LinuxTargetObjectFile - This implementation is used for 64-bit PowerPC Linux |
  PPCTargetStreamer | |
  PPCTTIImpl | |
  RISCVMCAsmInfo | |
  RISCVTargetMachine | |
  SparcInstPrinter | |
  LEONMachineFunctionPass | |
  InsertNOPLoad | |
  FixFSMULD | |
  ReplaceFMULS | |
  DetectRoundChange | |
  FixAllFDIVSQRT | |
  SparcELFMCAsmInfo | |
  SparcMCExpr | |
  SparcFrameLowering | |
  SparcInstrInfo | |
  SparcTargetLowering | |
  SparcMachineFunctionInfo | |
  SparcRegisterInfo | |
  SparcSubtarget | |
  SparcTargetMachine | |
  SparcV8TargetMachine | Sparc 32-bit target machine |
  SparcV9TargetMachine | Sparc 64-bit target machine |
  SparcelTargetMachine | |
  SparcELFTargetObjectFile | |
  SparcTargetStreamer | |
  SparcTargetAsmStreamer | |
  SparcTargetELFStreamer | |
  SystemZInstPrinter | |
  SystemZMCAsmInfo | |
  SystemZAsmPrinter | |
  SystemZCCState | |
  SystemZConstantPoolValue | A SystemZ-specific constant pool value |
  SystemZFrameLowering | |
  SystemZHazardRecognizer | SystemZHazardRecognizer maintains the state during scheduling |
  SystemZInstrInfo | |
  SystemZTargetLowering | |
  SystemZMachineFunctionInfo | |
  SystemZPostRASchedStrategy | A MachineSchedStrategy implementation for SystemZ post RA scheduling |
  SystemZMCInstLower | |
  SystemZRegisterInfo | |
  SystemZSelectionDAGInfo | |
  SystemZSubtarget | |
  SystemZTargetMachine | |
  SystemZTTIImpl | |
  WebAssemblyInstPrinter | |
  WebAssemblyMCAsmInfo | |
  WebAssemblyTargetStreamer | WebAssembly-specific streamer interface, to implement support WebAssembly-specific assembly directives |
  WebAssemblyTargetAsmStreamer | This part is for ascii assembly output |
  WebAssemblyTargetELFStreamer | This part is for ELF object output |
  WebAssemblyFrameLowering | |
  WebAssemblyInstrInfo | |
  WebAssemblyTargetLowering | |
  WebAssemblyFunctionInfo | This class is derived from MachineFunctionInfo and contains private WebAssembly-specific information for each MachineFunction |
  WebAssemblyMCInstLower | This class is used to lower an MachineInstr into an MCInst |
  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 | |
  X86CallLowering | |
  X86FrameLowering | |
  X86AddressMode | X86AddressMode - This struct holds a generalized full x86 address mode |
  X86InstrFMA3Group | This class is used to group {132, 213, 231} forms of FMA opcodes together |
  X86InstrFMA3Info | This class provides information about all existing FMA3 opcodes |
   rm_iterator | Iterator that is used to walk on FMA register opcodes having memory form equivalents |
  X86InstrInfo | |
  IntrinsicData | |
  X86TargetLowering | |
  X86StoreSDNode | |
  X86MaskedStoreSDNode | |
  TruncSStoreSDNode | |
  TruncUSStoreSDNode | |
  MaskedTruncSStoreSDNode | |
  MaskedTruncUSStoreSDNode | |
  X86MachineFunctionInfo | X86MachineFunctionInfo - This class is derived from MachineFunction and contains private X86 target-specific information for each MachineFunction |
  DenseMapInfo< MemOpKey > | |
  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 |
  X86FreeBSDTargetObjectFile | X86FreeBSDTargetObjectFile - This implementation is used for FreeBSD on x86 and x86-64 |
  X86FuchsiaTargetObjectFile | This implementation is used for Fuchsia on x86-64 |
  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 | |
  CoroSubFnInst | This class represents the llvm.coro.subfn.addr instruction |
  CoroAllocInst | This represents the llvm.coro.alloc instruction |
  CoroIdInst | This represents the llvm.coro.alloc instruction |
   Info | |
  CoroFrameInst | This represents the llvm.coro.frame instruction |
  CoroFreeInst | This represents the llvm.coro.free instruction |
  CoroBeginInst | This class represents the llvm.coro.begin instruction |
  CoroSaveInst | This represents the llvm.coro.save instruction |
  CoroPromiseInst | This represents the llvm.coro.promise instruction |
  CoroSuspendInst | This represents the llvm.coro.suspend instruction |
  CoroSizeInst | This represents the llvm.coro.size instruction |
  CoroEndInst | This represents the llvm.coro.end instruction |
  InstCombiner | The core instruction combiner logic |
  DenseMapInfo< LoweredPHIRecord > | |
  CFGMST | An union-find based Minimum Spanning Tree for CFG |
  MaximumSpanningTree | MaximumSpanningTree - A MST implementation |
  GraphTraits< ArgumentGraphNode * > | |
  GraphTraits< ArgumentGraph * > | |
  DenseMapInfo< VTableSlot > | |
  BlotMapVector | An associative container with fast insertion-order (deterministic) iteration over its elements |
  DenseMapInfo< SimpleValue > | |
  DenseMapInfo< CallValue > | |
  DenseMapInfo< GVN::Expression > | |
  DenseMapInfo< const Expression * > | |
  isPodLike< Slice > | |
  DenseMapInfo< DivOpInfo > | |
  MemorySSAAnnotatedWriter | An assembly annotator class to print Memory SSA information in comments |
  DenseMapInfo< MemoryLocOrCall > | |
  SSAUpdaterTraits< SSAUpdater > | |
   PHI_iterator | |
 MemRef | |
 MSP430CC | |
 OpName | |
 R600_InstFlag | |
 stats | |
 std | |
  is_error_code_enum< llvm::BitcodeError > | |
  hash< llvm::pdb::PDB_SymType > | |
  is_error_code_enum< llvm::object::object_error > | |
  is_error_code_enum< llvm::sampleprof_error > | |
  is_error_code_enum< llvm::errc > | |
 symbols | |
 ___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 |
 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 | |
 AVRGenInstrInfo | |
 AVRGenRegisterInfo | |
 AVRGenSubtargetInfo | |
 BPFGenInstrInfo | |
 BPFGenRegisterInfo | |
 BPFGenSubtargetInfo | |
 CallReturnHandler | |
 cclass | |
 cname | |
 CommonHandleTraits | |
 CompareInsn | |
 CongruenceClass | |
 ContextDecision | Specifies which opcode->instruction tables to look at given a particular context (set of attributes) |
 CryptContextTraits | |
 cset | |
 DataType | |
 DIAErrorCategory | |
 ExtraFlags | |
 FileHandleTraits | |
 FindHandleTraits | |
 FormalArgHandler | |
 GenericSetCCInfo | Helper structure to keep track of ISD::SET_CC operands |
 HexagonGenInstrInfo | |
 HexagonGenRegisterInfo | |
 HexagonGenSubtargetInfo | |
 hsa_dim3_s | |
 hsa_ext_control_directives_s | The hsa_ext_control_directives_t specifies the values for the HSAIL control directives |
 IncomingArgHandler | |
 InsnMatchEntry | |
 InstructionMapping | Helper class that represents how the value of an instruction may be mapped and what is the related cost of such mapping |
 jit_code_entry | |
 jit_descriptor | |
 JobHandleTraits | |
 LanaiGenInstrInfo | |
 LanaiGenRegisterInfo | |
 LanaiGenSubtargetInfo | |
 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" |
 LOHInfo | State tracked per register |
 LTOObjectBuffer | Type to wrap a single object returned by ThinLTO |
 MachOElement | |
 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 | |
 NewGVN | |
  ValueDFS | |
 NVPTXGenInstrInfo | |
 NVPTXGenRegisterInfo | |
 NVPTXGenSubtargetInfo | |
 OpcodeDecision | Specifies which set of ModR/M->instruction tables to look at given a particular opcode |
 OperandsMapper | Helper class used to get/create the virtual registers that will be used to replace the MachineOperand when applying a mapping |
 OutgoingArgHandler | |
 parse | |
 PartialMapping | Helper struct that represents how a value is partially mapped into a register |
 PatchItem | |
 PPCGenInstrInfo | |
 PPCGenRegisterInfo | |
 PPCGenSubtargetInfo | |
 Predicate | |
 re_guts | |
 RegTraits | |
 rerr | |
 ScopedHandle | |
 SetCCInfo | Helper structure to keep track of SetCC information |
 SetCCInfoAndKind | Helper structure to be able to read SetCC information |
 ShadowMemoryParams | |
 SparcGenInstrInfo | |
 SparcGenRegisterInfo | |
 SparcGenSubtargetInfo | |
 Spill | |
 SystemZGenInstrInfo | |
 SystemZGenRegisterInfo | |
 SystemZGenSubtargetInfo | |
 T | |
 ThreadInfo | |
 ThreadStack | |
 UstarHeader | |
 ValueMapping | Helper struct that represents how a value is mapped through different register banks |
 WebAssemblyGenInstrInfo | |
 WebAssemblyGenRegisterInfo | |
 WebAssemblyGenSubtargetInfo | |
 X86EvexToVexCompressTableEntry | |
 X86GenInstrInfo | |
 X86GenRegisterInfo | |
 X86GenSubtargetInfo | |
 X86InterleavedAccessGroup | This class holds necessary information to represent an interleaved access group and supports utilities to lower the group into X86-specific instructions/intrinsics |
 X86MemoryFoldTableEntry | |
 XCoreGenInstrInfo | |
 XCoreGenRegisterInfo | |
 XCoreGenSubtargetInfo | |