| ►Nadjust | |
| ►NAllocaSlices | |
| Cpartition_iterator | An iterator over partitions of the alloca's slices |
| CSliceBuilder | Builder for the alloca slices |
| ►NAMDGPU | |
| ►Nfalse | |
| CChain | A Chain is a sequence of instructions that are linked together by an accumulation operand |
| CGCPtrLivenessData | |
| CGepNode | |
| Cin_set | |
| CIntervalSorter | |
| CLibCallsShrinkWrap | |
| CPartiallyConstructedSafepointRecord | |
| CSingleLoopExtractor | SingleLoopExtractor - For bugpoint |
| ►NINITIALIZE_PASS | TargetPassConfig |
| CInsertedPass | |
| ►Nllvm | This class represents lattice values for constants |
| ►NAArch64AT | |
| CAT | |
| ►NAArch64BTIHint | |
| CBTI | |
| ►NAArch64DB | |
| CDB | |
| ►NAArch64DC | |
| CDC | |
| ►NAArch64ExactFPImm | |
| CExactFPImm | |
| ►NAArch64IC | |
| CIC | |
| ►NAArch64ISB | |
| CISB | |
| ►NAArch64PRCTX | |
| CPRCTX | |
| ►NAArch64PRFM | |
| CPRFM | |
| ►NAArch64PSBHint | |
| CPSB | |
| ►NAArch64PState | |
| CPState | |
| ►NAArch64SVEPredPattern | |
| CSVEPREDPAT | |
| ►NAArch64SVEPRFM | |
| CSVEPRFM | |
| ►NAArch64SysReg | |
| CSysReg | |
| ►NAArch64TLBI | |
| CTLBI | |
| ►NAArch64TSB | |
| CTSB | |
| ►NAMDGPU | |
| ►NHSAMD | |
| ►NKernel | |
| ►NArg | |
| CMetadata | In-memory representation of kernel argument metadata |
| ►NAttrs | |
| CMetadata | In-memory representation of kernel attributes metadata |
| ►NCodeProps | |
| CMetadata | In-memory representation of kernel code properties metadata |
| ►NDebugProps | |
| CMetadata | In-memory representation of kernel debug properties metadata |
| CMetadata | In-memory representation of kernel metadata |
| ►NV3 | |
| CMetadataVerifier | Verifier for AMDGPU HSA metadata |
| CMetadata | In-memory representation of HSA metadata |
| CMetadataStreamer | |
| CMetadataStreamerV2 | |
| CMetadataStreamerV3 | |
| CD16ImageDimIntrinsic | |
| CImageDimIntrinsicInfo | |
| CIsaVersion | Instruction set architecture version |
| CMIMGBaseOpcodeInfo | |
| CMIMGDimInfo | |
| CMIMGInfo | |
| CMIMGLZMappingInfo | |
| CMUBUFInfo | |
| CRsrcIntrinsic | |
| CWaitcnt | Represents the counter values to wait for in an s_waitcnt instruction |
| ►Namdhsa | |
| Ckernel_descriptor_t | |
| ►NARM | Define some predicates that are used for node matching |
| ►NWinEH | |
| CEpilogueScope | ExceptionDataRecord - An entry in the table of exception data (.xdata) |
| CExceptionDataRecord | |
| CRuntimeFunction | RuntimeFunction - An entry in the table of procedure data (.pdata) |
| CArchNames | |
| CCpuNames | |
| CExtName | |
| CFPUName | |
| ►NARMBankedReg | |
| CBankedReg | |
| ►NARMSysReg | |
| CMClassSysReg | |
| ►NAVR | Contains the AVR backend |
| ►Nbfi_detail | |
| CBlockEdgesAdder | |
| CBlockMass | Mass of a block |
| ►CIrreducibleGraph | Graph of irreducible control flow |
| CIrrNode | |
| CTypeMap | |
| CTypeMap< BasicBlock > | |
| CTypeMap< MachineBasicBlock > | |
| ►NBTF | |
| CBPFFuncInfo | Specifying one function info |
| CBPFLineInfo | Specifying one line info |
| CBTFArray | BTF_KIND_ARRAY is followed by one "struct BTFArray" |
| CBTFEnum | BTF_KIND_ENUM is followed by multiple "struct BTFEnum" |
| CBTFMember | BTF_KIND_STRUCT and BTF_KIND_UNION are followed by multiple "struct BTFMember" |
| CBTFParam | BTF_KIND_FUNC_PROTO are followed by multiple "struct BTFParam" |
| CCommonType | The BTF common type definition |
| CExtHeader | The .BTF.ext section header definition |
| CHeader | The .BTF section header definition |
| CSecFuncInfo | Specifying function info's in one section |
| CSecLineInfo | Specifying line info's in one section |
| ►Ncfg | |
| CUpdate | |
| ►Ncflaa | |
| CAliasSummary | AliasSummary is just a collection of ExternalRelation and ExternalAttribute |
| ►CCFLGraph | 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 |
| CEdge | |
| CNodeInfo | |
| CValueInfo | |
| CCFLGraphBuilder | 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 |
| CExternalAttribute | We use ExternalAttribute to describe an externally visible AliasAttrs for parameters/return value |
| CExternalRelation | We use ExternalRelation to describe an externally visible aliasing relations between parameters/return value of a function |
| CFunctionHandle | |
| CInstantiatedAttr | This is the result of instantiating ExternalAttribute at a particular callsite |
| CInstantiatedRelation | This is the result of instantiating ExternalRelation at a particular callsite |
| CInstantiatedValue | This is the result of instantiating InterfaceValue at a particular callsite |
| CInterfaceValue | 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 |
| CStratifiedInfo | NOTE: ^ This can't be a short – bootstrapping clang has a case where ~1M sets exist |
| CStratifiedLink | A "link" between two StratifiedSets |
| CStratifiedSets | 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 |
| CStratifiedSetsBuilder | Generic Builder class that produces StratifiedSets instances |
| ►NCGSCCAnalysisManagerModuleProxy | |
| CResult | 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 |
| ►NCheck | |
| CFileCheckType | |
| ►Ncl | Cl Namespace - This namespace contains all of the command line option processing machinery |
| Calias | |
| Caliasopt | |
| Capplicator | |
| Capplicator< char[n]> | |
| Capplicator< const char[n]> | |
| Capplicator< FormattingFlags > | |
| Capplicator< MiscFlags > | |
| Capplicator< NumOccurrencesFlag > | |
| Capplicator< OptionHidden > | |
| Capplicator< StringRef > | |
| Capplicator< ValueExpected > | |
| Cbasic_parser | |
| Cbasic_parser_impl | |
| Cbits | |
| Cbits_storage | |
| Cbits_storage< DataType, bool > | |
| Ccat | |
| Cdesc | |
| Cextrahelp | |
| ►Cgeneric_parser_base | |
| CGenericOptionInfo | |
| CGenericOptionValue | |
| Cinitializer | |
| Clist | |
| Clist_storage | |
| Clist_storage< DataType, bool > | |
| CLocationClass | |
| Cmulti_val | |
| Copt | |
| Copt_storage | |
| Copt_storage< DataType, false, false > | |
| Copt_storage< DataType, false, true > | |
| COption | |
| COptionCategory | |
| COptionDiffPrinter | |
| COptionDiffPrinter< DT, DT > | |
| COptionEnumValue | |
| COptionValue | |
| COptionValue< cl::boolOrDefault > | |
| COptionValue< std::string > | |
| COptionValueBase | |
| COptionValueBase< DataType, false > | |
| COptionValueCopy | |
| ►Cparser | |
| COptionInfo | |
| Cparser< bool > | |
| Cparser< boolOrDefault > | |
| Cparser< char > | |
| Cparser< double > | |
| Cparser< float > | |
| Cparser< int > | |
| Cparser< std::string > | |
| Cparser< unsigned > | |
| Cparser< unsigned long long > | |
| Csub | |
| CSubCommand | |
| Cvalue_desc | |
| CValuesClass | |
| ►Ncodeview | |
| ►Ndetail | |
| CGuidAdapter | |
| CAppendingTypeTableBuilder | |
| CArgListRecord | |
| CArrayRecord | |
| CBaseClassRecord | |
| ►CBinaryAnnotationIterator | |
| CAnnotationData | |
| CBitFieldRecord | |
| CBlockSym | |
| CBPRelativeSym | |
| CBuildInfoRecord | |
| CBuildInfoSym | |
| CCallerSym | |
| CCallSiteInfoSym | |
| CClassRecord | |
| CCodeViewError | Base class for errors originating when parsing raw PDB files |
| CCodeViewRecordIO | |
| CCoffGroupSym | |
| CColumnInfo | |
| CColumnNumberEntry | |
| CCompile2Sym | |
| CCompile3Sym | |
| CConstantSym | |
| CContinuationRecordBuilder | |
| CCrossModuleExport | |
| CCrossModuleImport | |
| CCrossModuleImportItem | |
| CCVMemberRecord | |
| CCVRecord | |
| CCVSymbolDumper | Dumper for CodeView symbol streams found in COFF object files and PDB files |
| CCVSymbolVisitor | |
| CDataMemberRecord | |
| CDataSym | |
| CDebugChecksumsSubsection | |
| CDebugChecksumsSubsectionRef | |
| CDebugCrossModuleExportsSubsection | |
| CDebugCrossModuleExportsSubsectionRef | |
| CDebugCrossModuleImportsSubsection | |
| CDebugCrossModuleImportsSubsectionRef | |
| CDebugFrameDataSubsection | |
| CDebugFrameDataSubsectionRef | |
| CDebugInfo | |
| ►CDebugInlineeLinesSubsection | |
| CEntry | |
| CDebugInlineeLinesSubsectionRef | |
| CDebugLinesSubsection | |
| CDebugLinesSubsectionRef | |
| CDebugStringTableSubsection | Represents a read-write view of a CodeView string table |
| CDebugStringTableSubsectionRef | Represents a read-only view of a CodeView string table |
| CDebugSubsection | |
| CDebugSubsectionHeader | |
| CDebugSubsectionRecord | |
| CDebugSubsectionRecordBuilder | |
| CDebugSubsectionRef | |
| CDebugSubsectionVisitor | |
| CDebugSymbolRVASubsection | |
| CDebugSymbolRVASubsectionRef | |
| CDebugSymbolsSubsection | |
| CDebugSymbolsSubsectionRef | |
| CDebugUnknownSubsectionRef | |
| CDefRangeFramePointerRelFullScopeSym | |
| CDefRangeFramePointerRelSym | |
| ►CDefRangeRegisterRelSym | |
| CHeader | |
| ►CDefRangeRegisterSym | |
| CHeader | |
| ►CDefRangeSubfieldRegisterSym | |
| CHeader | |
| CDefRangeSubfieldSym | |
| CDefRangeSym | |
| CEndPrecompRecord | |
| CEnumeratorRecord | |
| CEnumRecord | |
| CEnvBlockSym | |
| CExportSym | |
| CFieldListDeserializer | |
| CFieldListRecord | |
| CFileChecksumEntry | |
| CFileStaticSym | |
| CFrameCookieSym | |
| CFrameData | Data in the SUBSEC_FRAMEDATA subection |
| CFrameProcSym | |
| CFuncIdRecord | |
| CFunctionId | |
| CGloballyHashedType | A globally hashed type represents a hash value that is sufficient to uniquely identify a record across multiple type streams or type sequences |
| CGlobalTypeTableBuilder | |
| CGUID | This represents the 'GUID' type from windows.h |
| CHeapAllocationSiteSym | |
| CInlineeSourceLine | |
| CInlineeSourceLineHeader | |
| CInlineSiteSym | |
| CLabelRecord | |
| CLabelSym | |
| CLazyRandomTypeCollection | Provides amortized O(1) random access to a CodeView type stream |
| CLine | |
| CLineBlockFragmentHeader | |
| CLineColumnEntry | |
| CLineColumnExtractor | |
| CLineFragmentHeader | |
| CLineInfo | |
| CLineNumberEntry | |
| CListContinuationRecord | LF_INDEX - Used to chain two large LF_FIELDLIST or LF_METHODLIST records together |
| CLocallyHashedType | A locally hashed type represents a straightforward hash code of a serialized record |
| CLocalSym | |
| CLocalVariableAddrGap | |
| CLocalVariableAddrRange | |
| CMemberAttributes | Equvalent to CV_fldattr_t in cvinfo.h |
| CMemberFuncIdRecord | |
| CMemberFunctionRecord | |
| CMemberPointerInfo | |
| CMergingTypeTableBuilder | |
| CMethodOverloadListRecord | |
| CModifierRecord | |
| CNestedTypeRecord | |
| CObjNameSym | |
| COneMethodRecord | |
| COverloadedMethodRecord | For method overload sets. LF_METHOD |
| CPDB20DebugInfo | |
| CPDB70DebugInfo | |
| CPointerRecord | |
| CPrecompRecord | |
| CProcedureRecord | |
| CProcRefSym | |
| CProcSym | |
| CPublicSym32 | |
| CRecordPrefix | |
| CRegisterSym | |
| CRegRelativeSym | |
| CRemappedRecord | |
| CScopeEndSym | |
| CSectionSym | |
| Cserialize_array_impl | |
| Cserialize_arrayref_tail_impl | |
| Cserialize_conditional_impl | |
| Cserialize_null_term_string_array_impl | |
| Cserialize_numeric_impl | |
| Cserialize_vector_tail_impl | |
| CSimpleTypeSerializer | |
| CStaticDataMemberRecord | |
| CStringIdRecord | |
| CStringListRecord | |
| CStringsAndChecksums | |
| CStringsAndChecksumsRef | |
| CSymbolDeserializer | |
| CSymbolDumpDelegate | |
| CSymbolRecord | |
| CSymbolRecordMapping | |
| CSymbolSerializer | |
| CSymbolVisitorCallbackPipeline | |
| CSymbolVisitorCallbacks | |
| CSymbolVisitorDelegate | |
| CTagRecord | |
| CThreadLocalDataSym | |
| CThunk32Sym | |
| CTiReference | |
| CTrampolineSym | |
| CTypeCollection | |
| CTypeDeserializer | |
| CTypeDumpVisitor | Dumper for CodeView type streams found in COFF object files and PDB files |
| CTypeIndex | A 32-bit type reference |
| CTypeIndexOffset | |
| CTypeRecord | |
| CTypeRecordMapping | |
| CTypeServer2Record | |
| CTypeSymbolEmitter | |
| CTypeTableCollection | |
| CTypeVisitorCallbackPipeline | |
| CTypeVisitorCallbacks | |
| CUdtModSourceLineRecord | |
| CUdtSourceLineRecord | |
| CUDTSym | |
| CUnionRecord | |
| CUsingNamespaceSym | |
| CVFPtrRecord | |
| CVFTableRecord | |
| CVFTableShapeRecord | |
| CVirtualBaseClassRecord | |
| ►NCodeViewYAML | |
| ►Ndetail | |
| CLeafRecordBase | |
| CLeafRecordImpl | |
| CLeafRecordImpl< FieldListRecord > | |
| CMemberRecordBase | |
| CMemberRecordImpl | |
| CSymbolRecordBase | |
| CSymbolRecordImpl | |
| CUnknownSymbolRecord | |
| CYAMLSubsectionBase | |
| CDebugHSection | |
| CDebugSubsectionState | |
| CGlobalHash | |
| CHexFormattedString | |
| CInlineeInfo | |
| CInlineeSite | |
| CLeafRecord | |
| CMemberRecord | |
| CSourceColumnEntry | |
| CSourceFileChecksumEntry | |
| CSourceLineBlock | |
| CSourceLineEntry | |
| CSourceLineInfo | |
| CSymbolRecord | |
| CYAMLCrossModuleImport | |
| CYAMLDebugSubsection | |
| CYAMLFrameData | |
| ►NCOFF | |
| CAuxiliary | |
| CAuxiliarybfAndefSymbol | |
| CAuxiliaryCLRToken | |
| CAuxiliaryFunctionDefinition | |
| CAuxiliarySectionDefinition | |
| CAuxiliaryWeakExternal | |
| CBigObjHeader | |
| CDataDirectory | |
| CDOSHeader | The DOS compatible header at the front of all PEs |
| Cheader | |
| CImportDirectoryTableEntry | The Import Directory Table |
| CImportHeader | |
| CImportLookupTableEntry32 | The PE32 Import Lookup Table |
| CPE32Header | |
| Crelocation | |
| Csection | |
| Csymbol | |
| ►NCOFFYAML | |
| CObject | |
| CPEHeader | |
| CRelocation | |
| CSection | |
| CSymbol | |
| ►Nconsthoist | A private "module" namespace for types and utilities used by ConstantHoisting |
| CConstantCandidate | Keeps track of a constant candidate and its uses |
| CConstantInfo | A base constant and all its rebased constants |
| CConstantUser | Keeps track of the user of a constant and the operand index where the constant is used |
| CRebasedConstantInfo | This represents a constant that has been rebased with respect to a base constant |
| ►Ncoro | |
| CLowererBase | |
| CShape | |
| ►Ncoverage | |
| ►CBinaryCoverageReader | Reader for the coverage mapping data that is emitted by the frontend and stored in an object file |
| CProfileMappingRecord | |
| CCountedRegion | Associates a source range with an execution count |
| CCounter | 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 |
| CCounterExpression | A Counter expression is a value that represents an arithmetic operation with two counters |
| CCounterExpressionBuilder | A Counter expression builder is used to construct the counter expressions |
| CCounterMappingContext | A Counter mapping context is used to connect the counters, expressions and the obtained counter values |
| CCounterMappingRegion | A Counter mapping region associates a source range with a specific counter |
| CCoverageData | Coverage information to be processed or displayed |
| CCoverageFilenamesSectionWriter | Writer of the filenames section for the instrumentation based code coverage |
| CCoverageMapError | |
| CCoverageMapping | The mapping of profile information to coverage data |
| CCoverageMappingIterator | A file format agnostic iterator over coverage mapping data |
| CCoverageMappingReader | |
| CCoverageMappingRecord | Coverage mapping information for a single function |
| CCoverageMappingWriter | Writer for instrumentation based coverage mapping data |
| CCoverageSegment | The execution count information starting at a point in a file |
| CCovMapFunctionRecord | |
| CCovMapFunctionRecordV1 | |
| CCovMapHeader | |
| CCovMapTraits | |
| CCovMapTraits< CovMapVersion::Version1, IntPtrT > | |
| CExpansionRecord | Coverage information for a macro expansion or #included file |
| CFunctionRecord | Code coverage information for a single function |
| CFunctionRecordIterator | Iterator over Functions, optionally filtered to a single file |
| CInstantiationGroup | An instantiation group contains a FunctionRecord list, such that each record corresponds to a distinct instantiation of the same function |
| CLineCoverageIterator | An iterator over the LineCoverageStats objects for lines described by a CoverageData instance |
| CLineCoverageStats | Coverage statistics for a single line |
| CRawCoverageFilenamesReader | Reader for the raw coverage filenames |
| CRawCoverageMappingDummyChecker | Checks if the given coverage mapping data is exported for an unused function |
| CRawCoverageMappingReader | Reader for the raw coverage mapping data |
| CRawCoverageReader | Base class for the raw coverage mapping and filenames data readers |
| ►Ndetail | Implementation details of the pass manager interfaces |
| CAlignAdapter | |
| CAlignerImpl | |
| CAnalysisPassConcept | Abstract concept of an analysis pass |
| CAnalysisPassModel | Wrapper to model the analysis pass concept |
| CAnalysisResultConcept | Abstract concept of an analysis result |
| CAnalysisResultModel | Wrapper to model the analysis result concept |
| CAnalysisResultModel< IRUnitT, PassT, ResultT, PreservedAnalysesT, InvalidatorT, false > | Specialization of AnalysisResultModel which provides the default invalidate functionality |
| CAnalysisResultModel< IRUnitT, PassT, ResultT, PreservedAnalysesT, InvalidatorT, true > | Specialization of AnalysisResultModel which delegates invalidate handling to ResultT |
| Cconcat_range | Helper to store a sequence of ranges being concatenated and access them |
| CConstantLog2 | A tiny meta function to compute the log2 of a compile time constant |
| CConstantLog2< 1 > | |
| Ccopy_construction_triviality_helper | Internal utility to detect trivial copy construction |
| CDenseMapPair | |
| CDenseSetEmpty | |
| ►CDenseSetImpl | Base class for DenseSet and DenseSmallSet |
| CConstIterator | |
| CIterator | |
| CDenseSetPair | |
| CDoubleAPFloat | |
| Cenumerator | |
| Cenumerator_iter | |
| CErrorAdapter | |
| CErrorHolder | |
| CErrorMatchesMono | |
| CExpectedHolder | |
| Cformat_adapter | |
| Cfwd_or_bidi_tag | Helper which sets its type member to forward_iterator_tag if the category of IterT does not derive from bidirectional_iterator_tag, and to bidirectional_iterator_tag otherwise |
| Cfwd_or_bidi_tag_impl | |
| Cfwd_or_bidi_tag_impl< true > | |
| CGenericLayer | |
| CGenericLayerImpl | |
| CGenericLayerImpl< orc::LegacyRTDyldObjectLinkingLayer > | |
| Chas_FormatProvider | |
| Chas_StreamOperator | |
| CHasPointerLikeTypeTraits | |
| CHasPointerLikeTypeTraits< T, decltype((sizeof(PointerLikeTypeTraits< T >)+sizeof(T)), void())> | |
| CHelperFunctions | |
| CIEEEFloat | |
| Cis_cstring | |
| CIsPointerLike | |
| CIsPointerLike< T * > | |
| CLeadingZerosCounter | |
| Cmissing_format_adapter | |
| Cmove_construction_triviality_helper | Internal utility to detect trivial move construction |
| COptionKey | |
| CPadAdapter | |
| CPassConcept | Template for the abstract base class used to dispatch polymorphically over pass objects |
| CPassModel | A template wrapper used to implement the polymorphic API |
| ►CPointerSumTypeHelper | A helper template for implementing PointerSumType |
| CChecker | |
| CChecker< MemberT > | |
| CLookup | |
| CMin | |
| CMin< V > | |
| CPopulationCounter | |
| CPopulationCounter< T, 8 > | |
| Cprovider_format_adapter | |
| ►CPtrUseVisitorBase | Implementation of non-dependent functionality for PtrUseVisitor |
| CPtrInfo | This class provides information about the result of a visit |
| CUseToVisit | A struct of the data needed to visit a particular use |
| Crange_item_has_provider | |
| CRepeatAdapter | |
| Cresult_pair | |
| CResultHasInvalidateMethod | SFINAE metafunction for computing whether ResultT provides an invalidate member function |
| Cscope_exit | |
| CSizerImpl | |
| Cstream_operator_format_adapter | |
| CTrailingZerosCounter | |
| Cunit | |
| Cunit< std::micro > | |
| Cunit< std::milli > | |
| Cunit< std::nano > | |
| Cunit< std::ratio< 1 > > | |
| Cunit< std::ratio< 3600 > > | |
| Cunit< std::ratio< 60 > > | |
| Cuse_char_formatter | |
| Cuse_double_formatter | |
| Cuse_integral_formatter | |
| Cuse_pointer_formatter | |
| Cuse_string_formatter | |
| Cuses_format_member | |
| Cuses_format_provider | |
| Cuses_missing_provider | |
| Cuses_stream_operator | |
| Cvalue_sequence_iterator | |
| CValueMatchesMono | |
| CValueMatchesPoly | |
| Czip_common | |
| Czip_first | |
| Czip_longest_iterator | |
| Czip_longest_range | |
| Czip_shortest | |
| CZipLongestItemType | |
| CZipLongestTupleType | |
| Czippy | |
| CZipTupleType | |
| ►NDomTreeBuilder | |
| ►CSemiNCAInfo | |
| CBatchUpdateInfo | |
| CBlockNamePrinter | |
| CChildrenGetter | |
| CInfoRec | |
| ►CInsertionInfo | |
| CDecreasingLevel | |
| ►Ndwarf | |
| ►CCFIProgram | Represent a sequence of Call Frame Information instructions that, when read in order, construct a table mapping PC to frame state |
| CInstruction | An instruction consists of a DWARF CFI opcode and an optional sequence of operands |
| CCIE | DWARF Common Information Entry (CIE) |
| CEnumTraits | |
| CEnumTraits< Attribute > | |
| CEnumTraits< Form > | |
| CEnumTraits< Index > | |
| CEnumTraits< Tag > | |
| CFDE | DWARF Frame Description Entry (FDE) |
| CFormParams | A helper struct providing information about the byte size of DW_FORM values that vary in size depending on the DWARF version, address byte size, or DWARF32/DWARF64 |
| CFrameEntry | An entry in either debug_frame or eh_frame |
| CPubIndexEntryDescriptor | Describes an entry of the various gnu_pub* debug sections |
| ►NDWARFYAML | |
| CAbbrev | |
| CARange | |
| CARangeDescriptor | |
| CAttributeAbbrev | |
| CConstVisitor | |
| CData | |
| CEntry | |
| CFile | |
| CFormValue | |
| CInitialLength | |
| CLineTable | |
| CLineTableOpcode | |
| CPubEntry | |
| CPubSection | |
| CUnit | |
| CVisitor | |
| CVisitorImpl | A class to visits DWARFYAML Compile Units and DIEs in preorder |
| ►NELF | |
| CElf32_Chdr | |
| CElf32_Dyn | |
| CElf32_Ehdr | |
| CElf32_Nhdr | |
| CElf32_Phdr | |
| CElf32_Rel | |
| CElf32_Rela | |
| CElf32_Shdr | |
| CElf32_Sym | |
| CElf64_Chdr | |
| CElf64_Dyn | |
| CElf64_Ehdr | |
| CElf64_Nhdr | |
| CElf64_Phdr | |
| CElf64_Rel | |
| CElf64_Rela | |
| CElf64_Shdr | |
| CElf64_Sym | |
| ►Nelfabi | |
| CELFStub | |
| CELFSymbol | |
| ►NELFYAML | |
| CFileHeader | |
| CGroup | |
| CLocalGlobalWeakSymbols | |
| CMipsABIFlags | |
| CNoBitsSection | |
| CObject | |
| CProgramHeader | |
| CRawContentSection | |
| CRelocation | |
| CRelocationSection | |
| CSection | |
| CSectionName | |
| CSectionOrType | |
| CSymbol | |
| ►Nfuzzerop | |
| COpDescriptor | A description of some operation we can build while fuzzing IR |
| CSourcePred | A matcher/generator for finding suitable values for the next source in an operation's partially completed argument list |
| ►NGCOV | |
| COptions | A struct for passing gcov options between functions |
| ►Ngvn | |
| CAvailableValue | Represents a particular available value that we know how to materialize |
| CAvailableValueInBlock | Represents an AvailableValue which can be rematerialized at the end of the associated BasicBlock |
| CGVNLegacyPass | |
| ►NGVNExpression | |
| CAggregateValueExpression | |
| CBasicExpression | |
| CCallExpression | |
| CConstantExpression | |
| CDeadExpression | |
| CExpression | |
| Cint_op_inserter | |
| CLoadExpression | |
| CMemoryExpression | |
| Cop_inserter | |
| CPHIExpression | |
| CStoreExpression | |
| CUnknownExpression | |
| CVariableExpression | |
| ►Nhashing | |
| ►Ndetail | |
| Chash_combine_recursive_helper | Helper class to manage the recursive combining of hash_combine arguments |
| Chash_state | The intermediate state used during hashing |
| Cis_hashable_data | Trait to indicate whether a type's bits can be hashed directly |
| Cis_hashable_data< std::pair< T, U > > | |
| ►NHexagon | |
| CPacketIterator | |
| ►NHexagonMCInstrInfo | |
| CPredicateInfo | |
| ►Nilist_detail | |
| Ccheck_options | Check whether options are valid |
| Ccheck_options< Option1, Options... > | |
| Ccheck_options<> | |
| Ccompute_node_options | |
| Cexplicitness | Helper trait for recording whether an option is specified explicitly |
| Cextract_sentinel_tracking | Extract sentinel tracking option |
| Cextract_sentinel_tracking< ilist_sentinel_tracking< EnableSentinelTracking >, Options... > | |
| Cextract_sentinel_tracking< Option1, Options... > | |
| Cextract_sentinel_tracking<> | |
| Cextract_tag | Extract custom tag option |
| Cextract_tag< ilist_tag< Tag >, Options... > | |
| Cextract_tag< Option1, Options... > | |
| Cextract_tag<> | |
| ►CHasCreateNode | Type trait to check for a traits class that has a createNode member |
| CSFINAE | |
| CHasCreateSentinel | Type trait to check for a traits class that has a createSentinel member (as a canary for any of the ilist_sentinel_traits API) |
| ►CHasGetNext | Type trait to check for a traits class that has a getNext member (as a canary for any of the ilist_nextprev_traits API) |
| CSFINAE | |
| CHasObsoleteCustomization | |
| Cis_valid_option | Check whether an option is valid |
| Cis_valid_option< ilist_sentinel_tracking< EnableSentinelTracking > > | |
| Cis_valid_option< ilist_tag< Tag > > | |
| CIteratorHelper | |
| CIteratorHelper< false > | |
| CIteratorHelper< true > | |
| CIteratorTraits | Find const-correct node types |
| CIteratorTraits< OptionsT, false > | |
| CIteratorTraits< OptionsT, true > | |
| Cnode_options | Traits for options for ilist_node |
| CNodeAccess | An access class for ilist_node private API |
| CSpecificNodeAccess | |
| ►NIndexedInstrProf | |
| CHeader | |
| ►CSummary | |
| CEntry | |
| ►NIntervalMapImpl | IntervalMapImpl - Namespace used for IntervalMap implementation details |
| CBranchNode | |
| CLeafNode | |
| CNodeBase | |
| CNodeRef | |
| CNodeSizer | |
| CPath | |
| ►NIntrinsic | This namespace contains an enum with a value for every intrinsic/builtin function known by LLVM |
| CIITDescriptor | This is a type descriptor which explains the type requirements of an intrinsic |
| ►Nirsymtab | |
| ►Nstorage | |
| CComdat | This is equivalent to an IR comdat |
| CHeader | |
| CModule | Describes the range of a particular module's symbols within the symbol table |
| CRange | A reference to a range of objects in the symbol table |
| CStr | A reference to a string in the string table |
| CSymbol | Contains the information needed by linkers for symbol resolution, as well as by the LTO implementation itself |
| CUncommon | This data structure contains rarely used symbol fields and is optionally referenced by a Symbol |
| CFileContents | The contents of the irsymtab in a bitcode file |
| ►CReader | This class can be used to read a Symtab and Strtab produced by irsymtab::build |
| CSymbolRef | Ephemeral symbols produced by Reader::symbols() and Reader::module_symbols() |
| CSymbol | This represents a symbol that has been read from a storage::Symbol and possibly a storage::Uncommon |
| ►NISD | ISD namespace - This namespace contains an enum which represents all of the SelectionDAG node types and value types |
| CArgFlagsTy | |
| CInputArg | 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 |
| COutputArg | 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 |
| ►Nitanium_demangle | |
| CAbiTagAttr | |
| ►CAbstractManglingParser | |
| CNameState | Holds some extra information about a <name> that is being parsed |
| CArraySubscriptExpr | |
| CArrayType | |
| CBinaryExpr | |
| CBoolExpr | |
| CBracedExpr | |
| CBracedRangeExpr | |
| CCallExpr | |
| CCastExpr | |
| CClosureTypeName | |
| CConditionalExpr | |
| CConversionExpr | |
| CConversionOperatorType | |
| CCtorDtorName | |
| CCtorVtableSpecialName | |
| CDeleteExpr | |
| CDotSuffix | |
| CDtorName | |
| CDynamicExceptionSpec | |
| CElaboratedTypeSpefType | |
| CEnableIfAttr | |
| CEnclosingExpr | |
| CExpandedSpecialSubstitution | |
| CFloatData | |
| CFloatData< double > | |
| CFloatData< float > | |
| CFloatData< long double > | |
| CFloatLiteralImpl | |
| CFoldExpr | |
| CForwardTemplateReference | A forward-reference to a template argument that was not known at the point where the template parameter name was parsed in a mangling |
| CFunctionEncoding | |
| CFunctionParam | |
| CFunctionType | |
| CGlobalQualifiedName | |
| CInitListExpr | |
| CIntegerCastExpr | |
| CIntegerLiteral | |
| CLiteralOperator | |
| CLocalName | |
| CManglingParser | |
| CMemberExpr | |
| CNameType | |
| CNameWithTemplateArgs | |
| CNestedName | |
| CNewExpr | |
| CNode | |
| CNodeArray | |
| CNodeArrayNode | |
| CNodeKind | Determine the kind of a node from its type |
| CNodeOrString | |
| CNoexceptSpec | |
| CObjCProtoName | |
| CParameterPack | An unexpanded parameter pack (either in the expression or type context) |
| CParameterPackExpansion | A pack expansion |
| CPixelVectorType | |
| CPODSmallVector | |
| CPointerToMemberType | |
| CPointerType | |
| CPostfixExpr | |
| CPostfixQualifiedType | |
| CPrefixExpr | |
| CQualifiedName | |
| CQualType | |
| CReferenceType | |
| CSizeofParamPackExpr | |
| CSpecialName | |
| CSpecialSubstitution | |
| CStdQualifiedName | |
| CStructuredBindingName | |
| CTemplateArgs | |
| CTemplateArgumentPack | A variadic template argument |
| CThrowExpr | |
| CUnnamedTypeName | |
| CVectorType | |
| CVendorExtQualType | |
| ►Njson | |
| CArray | An Array is a JSON array, which contains heterogeneous JSON values |
| ►CObject | An Object is a JSON object, which maps strings to heterogenous JSON values |
| CKV | |
| CObjectKey | ObjectKey is a used to capture keys in Object |
| CObjectMapper | Helper for mapping JSON objects onto protocol structs |
| CParseError | |
| CValue | A Value is an JSON value of unknown type |
| ►Nlegacy | |
| CFunctionPassManager | FunctionPassManager manages FunctionPasses and BasicBlockPassManagers |
| CFunctionPassManagerImpl | FunctionPassManagerImpl manages FPPassManagers |
| CPassManager | PassManager manages ModulePassManagers |
| CPassManagerBase | 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 |
| CPassManagerImpl | PassManagerImpl manages MPPassManagers |
| ►NLegalityPredicates | |
| CTypePairAndMemSize | |
| ►NLoopAnalysisManagerFunctionProxy | |
| CResult | A specialized result for the LoopAnalysisManagerFunctionProxy which retains a LoopInfo reference |
| ►Nlowertypetests | |
| CBitSetBuilder | |
| CBitSetInfo | |
| CByteArrayBuilder | This class is used to build a byte array containing overlapping bit sets |
| CGlobalLayoutBuilder | This class implements a layout algorithm for globals referenced by bit sets that tries to keep members of small bit sets together |
| ►Nlto | |
| CConfig | LTO configuration |
| ►CInputFile | An input file |
| CSymbol | The purpose of this class is to only expose the symbol information that an LTO client should need in order to do symbol resolution |
| CLTO | This class implements a resolution-based interface to LLVM's LTO functionality |
| CLTOLLVMContext | A derived class of LLVMContext that initializes itself according to a given Config object |
| CLTOLLVMDiagnosticHandler | |
| CNativeObjectStream | This class wraps an output stream for a native object |
| CSymbolResolution | The resolution for a symbol |
| CThinBackendProc | This class defines the interface to the ThinLTO backend |
| ►NMachO | |
| Cany_relocation_info | |
| Carm_state_hdr_t | |
| Carm_thread_state32_t | |
| Carm_thread_state64_t | |
| Carm_thread_state_t | |
| Cbuild_tool_version | |
| Cbuild_version_command | |
| Cdata_in_code_entry | |
| Cdyld_info_command | |
| Cdylib | |
| Cdylib_command | |
| Cdylib_module | |
| Cdylib_module_64 | |
| Cdylib_reference | |
| Cdylib_table_of_contents | |
| Cdylinker_command | |
| Cdysymtab_command | |
| Cencryption_info_command | |
| Cencryption_info_command_64 | |
| Centry_point_command | |
| Cfat_arch | |
| Cfat_arch_64 | |
| Cfat_header | |
| Cfp_control_t | |
| Cfp_status_t | |
| Cfvmfile_command | |
| Cfvmlib | |
| Cfvmlib_command | |
| Cident_command | |
| Clinkedit_data_command | |
| Clinker_option_command | |
| Cload_command | |
| Cmach_header | |
| Cmach_header_64 | |
| Cmacho_load_command | |
| Cmmst_reg_t | |
| Cnlist | |
| Cnlist_64 | |
| Cnlist_base | |
| Cnote_command | |
| Cppc_state_hdr_t | |
| Cppc_thread_state32_t | |
| Cppc_thread_state_t | |
| Cprebind_cksum_command | |
| Cprebound_dylib_command | |
| Crelocation_info | |
| Croutines_command | |
| Croutines_command_64 | |
| Crpath_command | |
| Cscattered_relocation_info | |
| Csection | |
| Csection_64 | |
| Csegment_command | |
| Csegment_command_64 | |
| Csource_version_command | |
| Csub_client_command | |
| Csub_framework_command | |
| Csub_library_command | |
| Csub_umbrella_command | |
| Csymseg_command | |
| Csymtab_command | |
| Cthread_command | |
| Ctlv_descriptor | |
| Ctlv_descriptor_32 | |
| Ctlv_descriptor_64 | |
| Ctwolevel_hint | |
| Ctwolevel_hints_command | |
| Cuuid_command | |
| Cversion_min_command | |
| Cx86_exception_state64_t | |
| Cx86_exception_state_t | |
| Cx86_float_state64_t | |
| Cx86_float_state_t | |
| Cx86_state_hdr_t | |
| Cx86_thread_state32_t | |
| Cx86_thread_state64_t | |
| Cx86_thread_state_t | |
| Cxmm_reg_t | |
| ►NMachOYAML | |
| CBindOpcode | |
| CExportEntry | |
| CFatArch | |
| CFatHeader | |
| CFileHeader | |
| CLinkEditData | |
| CLoadCommand | |
| CNListEntry | |
| CObject | |
| CRebaseOpcode | |
| CSection | |
| CUniversalBinary | |
| ►Nmca | |
| CContext | |
| CCycleSegment | A sequence of cycles |
| CDefaultResourceStrategy | Default resource allocation strategy used by processor resource groups and processor resources with multiple units |
| CDefaultSchedulerStrategy | Default instruction selection strategy used by class Scheduler |
| CDispatchStage | |
| CEntryStage | |
| CExecuteStage | |
| CHardwareUnit | |
| CHWEventListener | |
| CHWInstructionDispatchedEvent | |
| CHWInstructionEvent | |
| CHWInstructionIssuedEvent | |
| CHWInstructionRetiredEvent | |
| CHWStallEvent | |
| CInstrBuilder | A builder class that knows how to construct Instruction objects |
| CInstrDesc | An instruction descriptor |
| CInstRef | An InstRef contains both a SourceMgr index and Instruction pair |
| CInstruction | An instruction propagated through the simulated instruction pipeline |
| CInstructionBase | Base class for instructions consumed by the simulation pipeline |
| CInstructionError | |
| CInstructionTables | |
| CLSUnit | A Load/Store Unit implementing a load and store queues |
| CPipeline | A pipeline for a specific subtarget |
| CPipelineOptions | This is a convenience struct to hold the parameters necessary for creating the pre-built "default" out-of-order pipeline |
| CReadDescriptor | A register read descriptor |
| CReadState | Tracks register operand latency in cycles |
| CRegisterFile | Manages hardware register files, and tracks register definitions for register renaming purposes |
| CResourceCycles | This class represents the number of cycles per resource (fractions of cycles) |
| CResourceManager | A resource manager for processor resource units and groups |
| CResourceState | A processor resource descriptor |
| CResourceStrategy | Resource allocation strategy used by hardware scheduler resources |
| CResourceUsage | Helper used by class InstrDesc to describe how hardware resources are used |
| ►CRetireControlUnit | This class tracks which instructions are in-flight (i.e., dispatched but not retired) in the OoO backend |
| CRUToken | |
| CRetireStage | |
| CScheduler | Class Scheduler is responsible for issuing instructions to pipeline resources |
| CSchedulerStrategy | |
| CSourceMgr | |
| CStage | |
| CWriteDescriptor | A register write descriptor |
| CWriteRef | A reference to a register write |
| CWriteState | Tracks uses of a register definition (e.g |
| ►Nmdconst | Transitional API for extracting constants from Metadata |
| ►Ndetail | |
| ►CHasDereference | |
| CSFINAE | |
| CIsValidPointer | |
| CIsValidReference | |
| ►NMIPatternMatch | |
| CAnd | Matching combinators |
| CAnd< Pred, Preds... > | |
| CBinaryOp_match | |
| Cbind_helper | |
| Cbind_helper< const ConstantFP * > | |
| Cbind_helper< LLT > | |
| Cbind_helper< MachineInstr * > | |
| Cbind_ty | |
| CCheckType | |
| CConstantMatch | |
| COneUse_match | |
| Coperand_type_match | |
| COr | |
| COr< Pred, Preds... > | |
| CUnaryOp_match | |
| ►NMips16HardFloatInfo | |
| CFuncNameSignature | |
| CFuncSignature | |
| ►Nms_demangle | |
| CArenaAllocator | |
| CArrayTypeNode | |
| CBackrefContext | |
| CConversionOperatorIdentifierNode | |
| CCustomTypeNode | |
| CDemangler | |
| CDynamicStructorIdentifierNode | |
| CEncodedStringLiteralNode | |
| CFunctionSignatureNode | |
| CFunctionSymbolNode | |
| CIdentifierNode | |
| CIntegerLiteralNode | |
| CIntrinsicFunctionIdentifierNode | |
| CIntrinsicNode | |
| CLiteralOperatorIdentifierNode | |
| CLocalStaticGuardIdentifierNode | |
| CLocalStaticGuardVariableNode | |
| CNamedIdentifierNode | |
| CNode | |
| CNodeArrayNode | |
| CPointerTypeNode | |
| CPrimitiveTypeNode | |
| CQualifiedNameNode | |
| CRttiBaseClassDescriptorNode | |
| CSpecialTableSymbolNode | |
| CStructorIdentifierNode | |
| CSymbolNode | |
| CTagTypeNode | |
| CTemplateParameterReferenceNode | |
| ►CThunkSignatureNode | |
| CThisAdjustor | |
| CTypeNode | |
| CVariableSymbolNode | |
| CVcallThunkIdentifierNode | |
| ►Nmsf | |
| CIMSFFile | |
| CMappedBlockStream | 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 |
| CMSFBuilder | |
| CMSFError | Base class for errors originating when parsing raw PDB files |
| CMSFLayout | |
| CMSFStreamLayout | Describes the layout of a stream in an MSF layout |
| CSuperBlock | |
| CWritableMappedBlockStream | |
| ►Nmsgpack | |
| CArrayNode | |
| CExtensionType | Extension types are composed of a user-defined type ID and an uninterpreted sequence of bytes |
| CMapNode | |
| CNode | Abstract base-class which can be any MessagePack type |
| CObject | MessagePack object, represented as a tagged union of C++ types |
| CReader | Reads MessagePack objects from memory, one at a time |
| CScalarNode | A MessagePack scalar |
| CWriter | Writes MessagePack objects to an output stream, one at a time |
| ►NMSSAHelpers | |
| CAllAccessTag | |
| CDefsOnlyTag | |
| ►NNVPTX | |
| ►Nobjcarc | |
| CARCMDKindCache | A cache of MDKinds used by various ARC optimizations |
| CARCRuntimeEntryPoints | Declarations for ObjC runtime functions and constants |
| CBottomUpPtrState | |
| CObjCARCAA | Analysis pass providing a never-invalidated alias analysis result |
| CObjCARCAAResult | This is a simple alias analysis implementation that uses knowledge of ARC constructs to answer queries |
| CObjCARCAAWrapperPass | Legacy wrapper pass to provide the ObjCARCAAResult object |
| CProvenanceAnalysis | This is similar to BasicAliasAnalysis, and it uses many of the same techniques, except it uses special ObjC-specific reasoning about pointer relationships |
| CPtrState | This class summarizes several per-pointer runtime properties which are propagated through the flow graph |
| CRRInfo | Unidirectional information about either a retain-decrement-use-release sequence or release-use-decrement-retain reverse sequence |
| CTopDownPtrState | |
| ►Nobject | |
| ►CArchive | |
| CChild | |
| Cchild_iterator | |
| CSymbol | |
| Csymbol_iterator | |
| CArchiveMemberHeader | |
| CBaseRelocRef | |
| CBasicSymbolRef | This is a value type class that represents a single symbol in the list of symbols in the object file |
| CBinary | |
| CBinaryError | Base class for all errors indicating malformed binary files |
| CBindRebaseSegInfo | |
| Ccoff_aux_bf_and_ef_symbol | |
| Ccoff_aux_clr_token | |
| Ccoff_aux_function_definition | |
| Ccoff_aux_section_definition | |
| Ccoff_aux_weak_external | |
| Ccoff_base_reloc_block_entry | |
| Ccoff_base_reloc_block_header | |
| Ccoff_bigobj_file_header | |
| Ccoff_file_header | |
| Ccoff_import_directory_table_entry | |
| Ccoff_import_header | |
| Ccoff_load_config_code_integrity | |
| Ccoff_load_configuration32 | 32-bit load config (IMAGE_LOAD_CONFIG_DIRECTORY32) |
| Ccoff_load_configuration64 | 64-bit load config (IMAGE_LOAD_CONFIG_DIRECTORY64) |
| Ccoff_relocation | |
| Ccoff_resource_data_entry | |
| Ccoff_resource_dir_entry | |
| Ccoff_resource_dir_table | |
| Ccoff_runtime_function_x64 | |
| Ccoff_section | |
| Ccoff_symbol | |
| Ccoff_symbol_generic | |
| Ccoff_tls_directory | |
| CCOFFImportFile | |
| CCOFFModuleDefinition | |
| CCOFFObjectFile | |
| CCOFFShortExport | |
| CCOFFSymbolRef | |
| Ccontent_iterator | |
| Cdata_directory | |
| CDataRefImpl | |
| Cdebug_directory | |
| Cdebug_h_header | |
| CDecompressor | Decompressor helps to handle decompression of compressed sections |
| Cdelay_import_directory_table_entry | |
| CDelayImportDirectoryEntryRef | |
| CDiceRef | DiceRef - This is a value type class that represents a single data in code entry in the table in a Mach-O object file |
| Cdos_header | The DOS compatible header at the front of all PE/COFF executables |
| CElf_CGProfile_Impl | |
| CElf_Chdr_Impl | |
| CElf_Chdr_Impl< ELFType< TargetEndianness, false > > | |
| CElf_Chdr_Impl< ELFType< TargetEndianness, true > > | |
| CElf_Dyn_Base | Elf_Dyn_Base: This structure matches the form of entries in the dynamic table section (.dynamic) look like |
| CElf_Dyn_Base< ELFType< TargetEndianness, false > > | |
| CElf_Dyn_Base< ELFType< TargetEndianness, true > > | |
| CElf_Dyn_Impl | Elf_Dyn_Impl: This inherits from Elf_Dyn_Base, adding getters |
| CElf_Ehdr_Impl | |
| CElf_GnuHash_Impl | |
| CElf_Hash_Impl | |
| CElf_Mips_ABIFlags | |
| CElf_Mips_Options | |
| CElf_Mips_RegInfo | |
| CElf_Mips_RegInfo< ELFType< TargetEndianness, false > > | |
| CElf_Mips_RegInfo< ELFType< TargetEndianness, true > > | |
| CElf_Nhdr_Impl | Note header |
| CElf_Note_Impl | An ELF note |
| CElf_Note_Iterator_Impl | |
| CElf_Phdr_Impl | |
| CElf_Phdr_Impl< ELFType< TargetEndianness, false > > | |
| CElf_Phdr_Impl< ELFType< TargetEndianness, true > > | |
| CElf_Rel_Impl | |
| CElf_Rel_Impl< ELFType< TargetEndianness, false >, false > | |
| CElf_Rel_Impl< ELFType< TargetEndianness, false >, true > | |
| CElf_Rel_Impl< ELFType< TargetEndianness, true >, false > | |
| CElf_Rel_Impl< ELFType< TargetEndianness, true >, true > | |
| Celf_relocation_iterator | |
| Celf_section_iterator | |
| CElf_Shdr_Base | |
| CElf_Shdr_Base< ELFType< TargetEndianness, false > > | |
| CElf_Shdr_Base< ELFType< TargetEndianness, true > > | |
| CElf_Shdr_Impl | |
| CElf_Sym_Base | |
| CElf_Sym_Base< ELFType< TargetEndianness, false > > | |
| CElf_Sym_Base< ELFType< TargetEndianness, true > > | |
| CElf_Sym_Impl | |
| Celf_symbol_iterator | |
| CElf_Verdaux_Impl | Elf_Verdaux: This is the structure of auxiliary data in the SHT_GNU_verdef section (.gnu.version_d) |
| CElf_Verdef_Impl | Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section (.gnu.version_d) |
| CElf_Vernaux_Impl | Elf_Vernaux: This is the structure of auxiliary data in SHT_GNU_verneed section (.gnu.version_r) |
| CElf_Verneed_Impl | Elf_Verneed: This is the structure of entries in the SHT_GNU_verneed section (.gnu.version_r) |
| CElf_Versym_Impl | Elf_Versym: This is the structure of entries in the SHT_GNU_versym section (.gnu.version) |
| CELFFile | |
| CELFObjectFile | |
| CELFObjectFileBase | |
| CELFRelocationRef | |
| CELFSectionRef | |
| CELFSymbolRef | |
| CELFType | |
| CEmptyResError | |
| Cexport_address_table_entry | |
| Cexport_directory_table_entry | |
| CExportDirectoryEntryRef | |
| CExportEntry | ExportEntry encapsulates the current-state-of-the-walk used when doing a non-recursive walk of the trie data structure |
| CFpoData | |
| CGenericBinaryError | Generic binary error |
| Cimport_lookup_table_entry | |
| CImportDirectoryEntryRef | |
| CImportedSymbolRef | |
| CIRObjectFile | |
| CIRSymtabFile | The contents of a bitcode file and its irsymtab |
| CLexer | |
| CMachOBindEntry | MachOBindEntry encapsulates the current state in the decompression of binding opcodes |
| ►CMachOObjectFile | |
| CLoadCommandInfo | |
| CMachORebaseEntry | MachORebaseEntry encapsulates the current state in the decompression of rebasing opcodes |
| ►CMachOUniversalBinary | |
| Cobject_iterator | |
| CObjectForArch | |
| CObjectFile | This class is the base class for all object file types |
| COwningBinary | |
| CParser | |
| Cpe32_header | The 32-bit PE header that follows the COFF header |
| Cpe32plus_header | The 64-bit PE header that follows the COFF header |
| CRelocationRef | This is a value type class that represents a single relocation in the list of relocations in the object file |
| CRelocVisitor | Base class for object file relocation visitors |
| CResourceEntryRef | |
| CResourceSectionRef | |
| CSectionRef | This is a value type class that represents a single section in the list of sections in the object file |
| CStringTableOffset | |
| Csymbol_iterator | |
| CSymbolicFile | |
| CSymbolRef | This is a value type class that represents a single symbol in the list of symbols in the object file |
| CSymEntry | |
| CToken | |
| ►CWasmObjectFile | |
| CReadContext | |
| CWasmSection | |
| CWasmSectionOrderChecker | |
| CWasmSegment | |
| CWasmSymbol | |
| CWindowsResource | |
| CWindowsResourceCOFFWriter | |
| ►CWindowsResourceParser | |
| CTreeNode | |
| CWinResHeaderPrefix | |
| CWinResHeaderSuffix | |
| CWinResIDs | |
| ►NOMF | |
| CSignature | |
| ►Nopt | |
| CArg | A concrete instance of a particular driver option |
| Carg_iterator | Arg_iterator - Iterates through arguments stored inside an ArgList |
| CArgList | ArgList - Ordered collection of driver arguments |
| CDerivedArgList | DerivedArgList - An ordered collection of driver arguments, whose storage may be in another argument list |
| CInputArgList | |
| COption | Option - Abstract representation for a single form of driver argument |
| COptSpecifier | OptSpecifier - Wrapper class for abstracting references to option IDs |
| ►COptTable | Provide access to the Option info table |
| CInfo | Entry for a single option instance in the option data table |
| ►Noptional_detail | |
| COptionalStorage | Storage for any type |
| ►Norc | |
| ►Nremote | |
| ►Neh | Registers EH frames on the remote |
| CDeregisterEHFrames | Deregisters EH frames on the remote |
| CRegisterEHFrames | Registers EH frames on the remote |
| ►Nexec | RPC functions for executing remote code |
| CCallIntVoid | Call an 'int32_t()'-type function on the remote, returns the called function's return value |
| CCallMain | Call an 'int32_t(int32_t, char**)'-type function on the remote, returns the called function's return value |
| CCallVoidVoid | Calls a 'void()'-type function on the remote, returns when the called function completes |
| ►Nmem | RPC functions for remote memory management / inspection / modification |
| CCreateRemoteAllocator | Creates a memory allocator on the remote |
| CDestroyRemoteAllocator | Destroys a remote allocator, freeing any memory allocated by it |
| CReadMem | Read a remote memory block |
| CReserveMem | Reserve a block of memory on the remote via the given allocator |
| CSetProtections | Set the memory protection on a memory block |
| CWriteMem | Write to a remote memory block |
| CWritePtr | Write to a remote pointer |
| ►Nstubs | RPC functions for remote stub and trampoline management |
| CCreateIndirectStubsOwner | Creates an indirect stub owner on the remote |
| CDestroyIndirectStubsOwner | RPC function for destroying an indirect stubs owner |
| CEmitIndirectStubs | EmitIndirectStubs result is (StubsBase, PtrsBase, NumStubsEmitted) |
| CEmitResolverBlock | RPC function to emit the resolver block and return its address |
| CEmitTrampolineBlock | EmitTrampolineBlock result is (BlockAddr, NumTrampolines) |
| ►Nutils | Miscelaneous RPC functions for dealing with remotes |
| CGetRemoteInfo | GetRemoteInfo result is (Triple, PointerSize, PageSize, TrampolineSize, IndirectStubsSize) |
| CGetSymbolAddress | Get the address of a remote symbol |
| CRequestCompile | Request that the host execute a compile callback |
| CTerminateSession | Notify the remote and terminate the session |
| CDirectBufferWriter | |
| ►COrcRemoteTargetClient | This class provides utilities (including memory manager, indirect stubs manager, and compile callback manager types) that support remote JITing in ORC |
| CRemoteCompileCallbackManager | Remote compile callback manager |
| CRemoteIndirectStubsManager | Remote indirect stubs manager |
| CRemoteRTDyldMemoryManager | Remote-mapped RuntimeDyld-compatible memory manager |
| CRemoteTrampolinePool | |
| COrcRemoteTargetRPCAPI | |
| COrcRemoteTargetServer | |
| CResourceIdMgr | |
| CResourceNotFound | Template error for missing resources |
| ►Nrpc | |
| ►Ndetail | |
| CAsyncHandlerTraits | |
| CAsyncHandlerTraits< Error(ResponseHandlerT, ArgTs...)> | |
| CAsyncHandlerTraits< Error(std::function< Error(Error)>, ArgTs...)> | |
| CAsyncHandlerTraits< Error(std::function< Error(Expected< ResultT >)>, ArgTs...)> | |
| CAsyncHandlerTraits< ErrorSuccess(std::function< Error(Error)>, ArgTs...)> | |
| CAsyncHandlerTraits< void(std::function< Error(Error)>, ArgTs...)> | |
| CCanDeserialize | |
| CCanSerialize | |
| CFunctionArgsTuple | Provides a typedef for a tuple containing the decayed argument types |
| CFunctionArgsTuple< RetT(ArgTs...)> | |
| CHandlerTraits | |
| CHandlerTraits< RetT(*)(ArgTs...)> | |
| CHandlerTraits< RetT(ArgTs...)> | |
| CHandlerTraits< RetT(Class::*)(ArgTs...) const > | |
| CHandlerTraits< RetT(Class::*)(ArgTs...)> | |
| CMemberFnWrapper | |
| CReadArgs | |
| CReadArgs< ArgT, ArgTs... > | |
| CRespondHelper | |
| CRespondHelper< false > | |
| CRespondHelper< true > | |
| CResponseHandler | |
| CResponseHandlerArg | |
| CResponseHandlerArg< Error(Error)> | |
| CResponseHandlerArg< Error(Expected< ArgT >)> | |
| CResponseHandlerArg< ErrorSuccess(Error)> | |
| CResponseHandlerArg< ErrorSuccess(Expected< ArgT >)> | |
| CResponseHandlerImpl | |
| CResponseHandlerImpl< ChannelT, Error, HandlerT > | |
| CResponseHandlerImpl< ChannelT, Expected< FuncRetT >, HandlerT > | |
| CResponseHandlerImpl< ChannelT, void, HandlerT > | |
| CResultTraits | |
| CResultTraits< Error > | |
| CResultTraits< Expected< RetT > > | |
| CResultTraits< void > | |
| CRPCArgTypeCheck | |
| CRPCArgTypeCheckHelper | |
| CRPCArgTypeCheckHelper< P, std::tuple< T, Ts... >, std::tuple< U, Us... > > | |
| CRPCArgTypeCheckHelper< P, std::tuple<>, std::tuple<> > | |
| ►CRPCEndpointBase | Contains primitive utilities for defining, calling and handling calls to remote procedures |
| CCanDeserializeCheck | |
| CCanSerializeCheck | |
| COrcRPCInvalid | |
| COrcRPCNegotiate | |
| COrcRPCResponse | |
| CSequenceNumberManager | |
| CSupportsErrorReturn | |
| CSupportsErrorReturn< Error > | |
| CSupportsErrorReturn< Expected< T > > | |
| CWrappedHandlerReturn | |
| CWrappedHandlerReturn< Error > | |
| CWrappedHandlerReturn< ErrorSuccess > | |
| CWrappedHandlerReturn< Expected< T > > | |
| CWrappedHandlerReturn< void > | |
| ►CAPICalls | Convenience class for grouping RPC Functions into APIs that can be negotiated as a block |
| CContains | Test whether this API contains Function F |
| ►CAPICalls< APICalls< InnerFuncs... >, Funcs... > | |
| CContains | |
| ►CAPICalls< Func, Funcs... > | |
| CContains | |
| CBadFunctionCall | BadFunctionCall is returned from handleOne when the remote makes a call with an unrecognized function id |
| CConnectionClosed | RPCConnectionClosed is returned from RPC operations if the RPC connection has already been closed due to either an error or graceful disconnection |
| CCouldNotNegotiate | This error is returned if the remote does not have a handler installed for the given RPC function |
| CFunction | |
| CFunction< DerivedFunc, RetT(ArgTs...)> | |
| CInvalidSequenceNumberForResponse | InvalidSequenceNumberForResponse is returned from handleOne when a response call arrives with a sequence number that doesn't correspond to any in-flight function call |
| CMultiThreadedRPCEndpoint | |
| CParallelCallGroup | Allows a set of asynchrounous calls to be dispatched, and then waited on as a group |
| CRawByteChannel | Interface for byte-streams to be used with RPC |
| CResponseAbandoned | This non-fatal error will be passed to asynchronous result handlers in place of a result if the connection goes down before a result returns, or if the function to be called cannot be negotiated with the remote |
| CRPCAsyncDispatch | Asynchronous dispatch for a function on an RPC endpoint |
| CRPCFatalError | Base class of all fatal RPC errors (those that necessarily result in the termination of the RPC session) |
| CRPCFunctionIdAllocator | Allocates RPC function ids during autonegotiation |
| CRPCFunctionIdAllocator< T, typename std::enable_if< std::is_integral< T >::value >::type > | This specialization of RPCFunctionIdAllocator provides a default implementation for integral types |
| CRPCTypeName | |
| CRPCTypeName< bool > | |
| CRPCTypeName< Error > | |
| CRPCTypeName< Expected< T > > | |
| CRPCTypeName< int16_t > | |
| CRPCTypeName< int32_t > | |
| CRPCTypeName< int64_t > | |
| CRPCTypeName< int8_t > | |
| CRPCTypeName< JITSymbolFlags > | |
| CRPCTypeName< remote::DirectBufferWriter > | |
| CRPCTypeName< std::map< K, V > > | |
| CRPCTypeName< std::pair< T1, T2 > > | |
| CRPCTypeName< std::set< T > > | |
| CRPCTypeName< std::string > | |
| CRPCTypeName< std::tuple< ArgTs... > > | |
| CRPCTypeName< std::vector< T > > | |
| CRPCTypeName< uint16_t > | |
| CRPCTypeName< uint32_t > | |
| CRPCTypeName< uint64_t > | |
| CRPCTypeName< uint8_t > | |
| CRPCTypeName< void > | |
| CRPCTypeNameSequence | TypeNameSequence is a utility for rendering sequences of types to a string by rendering each type, separated by ", " |
| CSequenceSerialization | Utility class for serializing sequences of values of varying types |
| CSequenceSerialization< ChannelT > | |
| CSequenceSerialization< ChannelT, ArgT > | |
| CSequenceSerialization< ChannelT, ArgT, ArgTs... > | |
| CSequenceTraits | |
| CSerializationTraits | The SerializationTraits<ChannelT, T> class describes how to serialize and deserialize an instance of type T to/from an abstract channel of type ChannelT |
| CSerializationTraits< ChannelT, bool, bool, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value >::type > | |
| CSerializationTraits< ChannelT, Error > | |
| CSerializationTraits< ChannelT, Expected< T >, Error > | SerializationTraits for Expected<T1> from an Error |
| CSerializationTraits< ChannelT, Expected< T1 >, Expected< T2 > > | SerializationTraits for Expected<T1> from an Expected<T2> |
| CSerializationTraits< ChannelT, Expected< T1 >, T2 > | SerializationTraits for Expected<T1> from a T2 |
| CSerializationTraits< ChannelT, JITSymbolFlags > | |
| CSerializationTraits< ChannelT, remote::DirectBufferWriter, remote::DirectBufferWriter, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value >::type > | |
| CSerializationTraits< ChannelT, std::map< K, V >, std::map< K2, V2 > > | |
| CSerializationTraits< ChannelT, std::pair< T1, T2 >, std::pair< T3, T4 > > | SerializationTraits default specialization for std::pair |
| CSerializationTraits< ChannelT, std::set< T >, std::set< T2 > > | |
| CSerializationTraits< ChannelT, std::string, std::string, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value >::type > | |
| CSerializationTraits< ChannelT, std::string, StringRef, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value >::type > | |
| CSerializationTraits< ChannelT, std::string, T, typename std::enable_if< std::is_base_of< RawByteChannel, ChannelT >::value &&(std::is_same< T, const char * >::value||std::is_same< T, char * >::value)>::type > | |
| CSerializationTraits< ChannelT, std::tuple< ArgTs... > > | SerializationTraits default specialization for std::tuple |
| CSerializationTraits< ChannelT, std::vector< T > > | SerializationTraits default specialization for std::vector |
| CSerializationTraits< 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 > | |
| CSingleThreadedRPCEndpoint | |
| CAbsoluteSymbolsMaterializationUnit | A MaterializationUnit implementation for pre-existing absolute symbols |
| CAsynchronousSymbolQuery | A symbol query that returns results via a callback when results are ready |
| CBasicIRLayerMaterializationUnit | MaterializationUnit that materializes modules by calling the 'emit' method on the given IRLayer |
| CBasicObjectLayerMaterializationUnit | Materializes the given object file (represented by a MemoryBuffer instance) by calling 'emit' on the given ObjectLayer |
| CCompileOnDemandLayer | |
| CConcurrentIRCompiler | A thread-safe version of SimpleCompiler |
| ►CCtorDtorIterator | This iterator provides a convenient way to iterate over the elements of an llvm.global_ctors/llvm.global_dtors instance |
| CElement | Accessor for an element of the global_ctors/global_dtors array |
| CCtorDtorRunner | |
| CDuplicateDefinition | |
| CDynamicLibrarySearchGenerator | A utility class to expose symbols found via dlsym to the JIT |
| CExecutionSession | An ExecutionSession represents a running JIT program |
| CFailedToMaterialize | Used to notify a JITDylib that the given set of symbols failed to materialize |
| CGenericIndirectStubsInfo | Provide information about stub blocks generated by the makeIndirectStubsBlock function |
| CGlobalMappingLayer | Global mapping layer |
| CIndirectStubsManager | Base class for managing collections of named indirect stubs |
| CIRCompileLayer | |
| CIRLayer | Interface for layers that accept LLVM IR |
| CIRMaterializationUnit | IRMaterializationUnit is a convenient base class for MaterializationUnits wrapping LLVM IR |
| CIRTransformLayer | |
| CJITCompileCallbackManager | Target-independent base class for compile callback management |
| CJITDylib | A symbol table that supports asynchoronous symbol queries |
| CJITSymbolNotFound | |
| CJITSymbolResolverAdapter | Legacy adapter. Remove once we kill off the old ORC layers |
| CJITTargetMachineBuilder | A utility class for building TargetMachines for JITs |
| CLambdaResolver | |
| CLambdaSymbolResolver | Implements SymbolResolver with a pair of supplied function objects for convenience |
| ►CLazyCallThroughManager | Manages a set of 'lazy call-through' trampolines |
| CNotifyResolvedFunction | Clients will want to take some action on first resolution, e.g |
| CNotifyResolvedFunctionImpl | |
| CLazyEmittingLayer | Lazy-emitting IR layer |
| CLazyReexportsMaterializationUnit | A materialization unit that builds lazy re-exports |
| CLegacyCompileOnDemandLayer | Compile-on-demand layer |
| CLegacyCtorDtorRunner | Convenience class for recording constructor/destructor names for later execution |
| CLegacyIRCompileLayer | Eager IR compiling layer |
| CLegacyIRTransformLayer | IR mutating layer |
| CLegacyLocalCXXRuntimeOverrides | |
| CLegacyLookupFnResolver | An ORC SymbolResolver implementation that uses a legacy findSymbol-like function to perform lookup; |
| CLegacyObjectTransformLayer | Object mutating layer |
| ►CLegacyRTDyldObjectLinkingLayer | Bare bones object linking layer |
| CResources | |
| ►CLegacyRTDyldObjectLinkingLayerBase | |
| CLinkedObject | Holds an object to be allocated/linked as a unit in the JIT |
| CLLJIT | A pre-fabricated ORC JIT stack that can serve as an alternative to MCJIT |
| CLLLazyJIT | An extended version of LLJIT that supports lazy function-at-a-time compilation of LLVM IR |
| CLocalCXXRuntimeOverrides | |
| CLocalCXXRuntimeOverridesBase | Support class for static dtor execution |
| CLocalIndirectStubsManager | IndirectStubsManager implementation for the host architecture, e.g |
| CLocalJITCompileCallbackManager | Manage compile callbacks for in-process JITs |
| CLocalLazyCallThroughManager | A lazy call-through manager that builds trampolines in the current process |
| CLocalTrampolinePool | A trampoline pool for trampolines within the current process |
| CMangleAndInterner | Mangles symbol names then uniques them in the context of an ExecutionSession |
| CMaterializationResponsibility | Tracks responsibility for materialization, and mediates interactions between MaterializationUnits and JDs |
| CMaterializationUnit | A MaterializationUnit represents a set of symbol definitions that can be materialized as a group, or individually discarded (when overriding definitions are encountered) |
| CNullLegacyResolver | SymbolResolver impliementation that rejects all resolution requests |
| CNullResolver | |
| CObjectLayer | Interface for Layers that accept object files |
| CObjectTransformLayer | |
| COrcAArch64 | |
| ►COrcGenericABI | Generic ORC ABI support |
| CIndirectStubsInfo | |
| COrcI386 | I386 support |
| COrcMCJITReplacement | |
| COrcMips32_Base | |
| COrcMips32Be | |
| COrcMips32Le | |
| COrcMips64 | |
| COrcX86_64_Base | X86_64 code that's common to all ABIs |
| COrcX86_64_SysV | X86_64 support for SysV ABI (Linux, MacOSX) |
| COrcX86_64_Win32 | X86_64 support for Win32 |
| CPartitioningIRMaterializationUnit | |
| CReexportsGenerator | ReexportsGenerator can be used with JITDylib::setGenerator to automatically re-export a subset of the source JITDylib's symbols in the target |
| CReExportsMaterializationUnit | A materialization unit for symbol aliases |
| CRemoteObjectClientLayer | RemoteObjectClientLayer forwards the ORC Object Layer API over an RPC connection |
| ►CRemoteObjectLayer | Base class containing common utilities for RemoteObjectClientLayer and RemoteObjectServerLayer |
| CRemoteSymbolMaterializer | This class is used as the symbol materializer for JITSymbols returned by RemoteObjectLayerClient/RemoteObjectLayerServer – the materializer knows how to call back to the other RPC endpoint to get the address when requested |
| ►CRemoteObjectLayerAPI | RPC API needed by RemoteObjectClientLayer and RemoteObjectServerLayer |
| CAddObject | |
| CEmitAndFinalize | |
| CFindSymbol | |
| CFindSymbolIn | |
| CLookup | |
| CLookupInLogicalDylib | |
| CMaterializeRemoteSymbol | |
| CReleaseRemoteSymbol | |
| CRemoveObject | |
| CRemoteObjectServerLayer | RemoteObjectServerLayer acts as a server and handling RPC calls for the object layer API from the given RPC connection |
| CRTDyldObjectLinkingLayer | |
| CSimpleCompiler | Simple compile functor: Takes a single IR module and returns an ObjectFile |
| CSymbolAliasMapEntry | |
| CSymbolLinkagePromoter | Promotes private symbols to global hidden, and renames to prevent clashes with other promoted symbols |
| CSymbolResolver | SymbolResolver is a composable interface for looking up symbol flags and addresses using the AsynchronousSymbolQuery type |
| CSymbolsCouldNotBeRemoved | Used to notify clients that a set of symbols could not be removed |
| CSymbolsNotFound | Used to notify clients when symbols can not be found during a lookup |
| CSymbolStringPool | String pool for symbol names used by the JIT |
| CSymbolStringPtr | Pointer to a pooled string representing a symbol name |
| ►CThreadSafeContext | An LLVMContext together with an associated mutex that can be used to lock the context to prevent concurrent access by other threads |
| CLock | |
| CThreadSafeModule | An LLVM Module together with a shared ThreadSafeContext |
| CTrampolinePool | Base class for pools of compiler re-entry trampolines |
| ►Noutliner | |
| CCandidate | An individual sequence of instructions to be replaced with a call to an outlined function |
| COutlinedFunction | The information necessary to create an outlined function for some class of candidate |
| ►Nparallel | |
| ►Ndetail | |
| CLatch | |
| CTaskGroup | |
| Cis_execution_policy | |
| Cparallel_execution_policy | |
| Csequential_execution_policy | |
| ►NPatternMatch | |
| CAnyBinaryOp_match | |
| Capfloat_match | |
| Capi_pred_ty | This helper class is used to match scalar and vector constants that satisfy a specified predicate, and bind them to an APInt |
| Capint_match | |
| CArgument_match | |
| CBinaryOp_match | |
| Cbind_const_intval_ty | |
| Cbind_ty | |
| CBinOpPred_match | |
| Cbr_match | |
| Cbrc_match | |
| CCastClass_match | |
| Cclass_match | |
| CCmpClass_match | |
| Cconstantint_match | |
| Ccst_pred_ty | This helper class is used to match scalar and vector integer constants that satisfy a specified predicate |
| Ccstfp_pred_ty | This helper class is used to match scalar and vector floating-point constants that satisfy a specified predicate |
| Cdeferredval_ty | Stores a reference to the Value *, not the Value * itself, thus can be used in commutative matchers |
| CExact_match | |
| CFNeg_match | |
| CIntrinsicID_match | Intrinsic matchers |
| Cis_all_ones | |
| Cis_any_zero_fp | |
| Cis_bitwiselogic_op | |
| Cis_idiv_op | |
| Cis_logical_shift_op | |
| Cis_lowbit_mask | |
| Cis_maxsignedvalue | |
| Cis_nan | |
| Cis_neg_zero_fp | |
| Cis_negative | |
| Cis_nonnegative | |
| Cis_one | |
| Cis_pos_zero_fp | |
| Cis_power2 | |
| Cis_power2_or_zero | |
| Cis_right_shift_op | |
| Cis_shift_op | |
| Cis_sign_mask | |
| Cis_zero | |
| Cis_zero_int | |
| Cm_Intrinsic_Ty | Intrinsic matches are combinations of ID matchers, and argument matchers |
| Cm_Intrinsic_Ty< T0 > | |
| Cm_Intrinsic_Ty< T0, T1 > | |
| Cm_Intrinsic_Ty< T0, T1, T2 > | |
| Cm_Intrinsic_Ty< T0, T1, T2, T3 > | |
| Cmatch_combine_and | |
| Cmatch_combine_or | Matching combinators |
| CMaxMin_match | |
| Cofmax_pred_ty | Helper class for identifying ordered max predicates |
| Cofmin_pred_ty | Helper class for identifying ordered min predicates |
| COneOps_match | Matches instructions with Opcode and three operands |
| COneUse_match | |
| COverflowingBinaryOp_match | |
| CSignum_match | |
| Csmax_pred_ty | Helper class for identifying signed max predicates |
| Csmin_pred_ty | Helper class for identifying signed min predicates |
| Cspecific_fpval | Match a specified floating point value or vector of all elements of that value |
| Cspecific_intval | Match a specified integer value or vector of all elements of that |
| Cspecificval_ty | Match a specified Value* |
| CThreeOps_match | Matches instructions with Opcode and three operands |
| CTwoOps_match | Matches instructions with Opcode and three operands |
| CUAddWithOverflow_match | |
| Cufmax_pred_ty | Helper class for identifying unordered max predicates |
| Cufmin_pred_ty | Helper class for identifying unordered min predicates |
| Cumax_pred_ty | Helper class for identifying unsigned max predicates |
| Cumin_pred_ty | Helper class for identifying unsigned min predicates |
| ►NPBQP | |
| ►NRegAlloc | |
| CAllowedRegVector | Holds a vector of the allowed physical regs for a vreg |
| CGraphMetadata | Holds graph-level metadata relevant to PBQP RA problems |
| CMatrixMetadata | Metadata to speed allocatability test |
| CNodeMetadata | Holds solver state and other metadata relevant to each PBQP RA node |
| CPBQPRAGraph | |
| ►CRegAllocSolverImpl | |
| CEdgeMetadata | |
| ►CGraph | PBQP Graph class |
| CAdjEdgeIdSet | |
| CEdgeIdSet | |
| CEdgeItr | |
| CNodeIdSet | |
| CNodeItr | |
| CGraphBase | |
| CMatrix | PBQP Matrix class |
| CMDMatrix | |
| CMDVector | |
| CPoolCostAllocator | |
| CSolution | Represents a solution to a PBQP problem |
| CValuePool | |
| CVector | PBQP Vector class |
| ►Npdb | |
| CBaseClassLayout | |
| CClassLayout | |
| CConcreteSymbolEnumerator | |
| CDataMemberLayoutItem | |
| CDbiBuildNo | |
| CDbiFlags | Some of the values are stored in bitfields |
| CDbiModuleDescriptor | |
| CDbiModuleDescriptorBuilder | |
| CDbiModuleList | |
| CDbiModuleSourceFilesIterator | |
| CDbiStream | |
| CDbiStreamBuilder | |
| CDbiStreamHeader | The fixed size header that appears at the beginning of the DBI Stream |
| CDIADataStream | |
| CDIAEnumDebugStreams | |
| CDIAEnumFrameData | |
| CDIAEnumInjectedSources | |
| CDIAEnumLineNumbers | |
| CDIAEnumSectionContribs | |
| CDIAEnumSourceFiles | |
| CDIAEnumSymbols | |
| CDIAEnumTables | |
| CDIAError | Base class for errors originating in DIA SDK, e.g. COM calls |
| CDIAFrameData | |
| CDIAInjectedSource | |
| CDIALineNumber | |
| CDIARawSymbol | |
| CDIASectionContrib | |
| CDIASession | |
| CDIASourceFile | |
| CDIATable | |
| CFileInfoSubstreamHeader | The header preceeding the File Info Substream of the DBI stream |
| CGlobalsStream | |
| CGSIHashHeader | Header of the hash tables found in the globals and publics sections |
| CGSIHashIterator | Iterator over hash records producing symbol record offsets |
| ►CGSIHashStreamBuilder | |
| CUdtDenseMapInfo | |
| CGSIHashTable | A readonly view of a hash table used in the globals and publics streams |
| CGSIStreamBuilder | |
| CHashTable | |
| CHashTableIterator | |
| CInfoStream | |
| CInfoStreamBuilder | |
| CInfoStreamHeader | The header preceeding the global PDB Stream (Stream 1) |
| CIPDBDataStream | 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 |
| CIPDBEnumChildren | |
| CIPDBFrameData | IPDBFrameData defines an interface used to represent a frame data of some code block |
| CIPDBInjectedSource | IPDBInjectedSource defines an interface used to represent source files which were injected directly into the PDB file during the compilation process |
| CIPDBLineNumber | |
| CIPDBRawSymbol | IPDBRawSymbol defines an interface used to represent an arbitrary symbol |
| CIPDBSectionContrib | IPDBSectionContrib defines an interface used to represent section contributions whose information are stored in the PDB |
| CIPDBSession | IPDBSession defines an interface used to provide a context for querying debug information from a debug data source (for example, a PDB) |
| CIPDBSourceFile | IPDBSourceFile defines an interface used to represent source files whose information are stored in the PDB |
| CIPDBTable | |
| CISectionContribVisitor | |
| CLayoutItemBase | |
| CModInfoFlags | |
| CModuleDebugStreamRef | |
| CModuleInfoHeader | The header preceeding each entry in the Module Info substream of the DBI stream |
| CNamedStreamMap | |
| CNamedStreamMapTraits | |
| CNativeCompilandSymbol | |
| CNativeEnumGlobals | |
| CNativeEnumModules | |
| CNativeEnumTypes | |
| CNativeExeSymbol | |
| CNativeRawSymbol | |
| CNativeSession | |
| CNativeSymbolEnumerator | |
| CNativeTypeArray | |
| CNativeTypeBuiltin | |
| CNativeTypeEnum | |
| CNativeTypeFunctionSig | |
| CNativeTypePointer | |
| CNativeTypeTypedef | |
| CNativeTypeUDT | |
| CNativeTypeVTShape | |
| CNullEnumerator | |
| CPDBContext | PDBContext This data structure is the top level entity that deals with PDB debug information parsing |
| CPDBError | Base class for errors originating when parsing raw PDB files |
| CPDBFile | |
| CPDBFileBuilder | |
| CPdbHashTraits | |
| CPdbHashTraits< uint32_t > | |
| CPDBStringTable | |
| CPDBStringTableBuilder | |
| CPDBStringTableHeader | The header preceeding the /names stream |
| CPDBSymbol | PDBSymbol defines the base of the inheritance hierarchy for concrete symbol types (e.g |
| CPDBSymbolAnnotation | |
| CPDBSymbolBlock | |
| CPDBSymbolCompiland | |
| CPDBSymbolCompilandDetails | |
| CPDBSymbolCompilandEnv | |
| CPDBSymbolCustom | PDBSymbolCustom represents symbols that are compiler-specific and do not fit anywhere else in the lexical hierarchy |
| CPDBSymbolData | |
| CPDBSymbolExe | |
| CPDBSymbolFunc | |
| CPDBSymbolFuncDebugEnd | |
| CPDBSymbolFuncDebugStart | |
| CPDBSymbolLabel | |
| CPDBSymbolPublicSymbol | |
| CPDBSymbolThunk | |
| CPDBSymbolTypeArray | |
| CPDBSymbolTypeBaseClass | |
| CPDBSymbolTypeBuiltin | |
| CPDBSymbolTypeCustom | |
| CPDBSymbolTypeDimension | |
| CPDBSymbolTypeEnum | |
| CPDBSymbolTypeFriend | |
| CPDBSymbolTypeFunctionArg | |
| CPDBSymbolTypeFunctionSig | |
| CPDBSymbolTypeManaged | |
| CPDBSymbolTypePointer | |
| CPDBSymbolTypeTypedef | |
| CPDBSymbolTypeUDT | |
| CPDBSymbolTypeVTable | |
| CPDBSymbolTypeVTableShape | |
| CPDBSymbolUnknown | |
| CPDBSymbolUsingNamespace | |
| CPDBSymDumper | |
| CPSHashRecord | |
| CPublicsStream | |
| CPublicsStreamHeader | |
| CRawError | Base class for errors originating when parsing raw PDB files |
| CSecMapEntry | |
| CSecMapHeader | |
| CSectionContrib | |
| CSectionContrib2 | |
| CSectionOffset | |
| CSrcHeaderBlockEntry | A single file record entry within the /src/headerblock stream |
| CSrcHeaderBlockHeader | The header preceding the /src/headerblock stream |
| CStringTableHashTraits | |
| CSymbolCache | |
| CSymbolStream | |
| CTagRecordHash | |
| CTpiStream | |
| CTpiStreamBuilder | |
| ►CTpiStreamHeader | |
| CEmbeddedBuf | |
| CUDTLayoutBase | |
| CVariant | |
| CVBPtrLayoutItem | |
| CVersionInfo | |
| CVTableLayoutItem | |
| ►NPredicateInfoClasses | |
| CValueDFS | |
| CValueDFS_Compare | |
| ►NRawInstrProf | |
| CHeader | |
| CProfileData | |
| ►Nrdf | |
| CBlockNode | |
| CBuildOptions | |
| CCodeNode | |
| CCopyPropagation | |
| ►CDataFlowGraph | |
| CDefStack | |
| CDeadCodeElimination | |
| CDefNode | |
| CFuncNode | |
| CIndexedSet | |
| CInstrNode | |
| CLaneMaskIndex | |
| ►CLiveness | |
| CLiveMapType | |
| CNodeAddr | |
| CNodeAllocator | |
| CNodeAttrs | |
| ►CNodeBase | |
| CCode_struct | |
| CDef_struct | |
| CPhiU_struct | |
| CRef_struct | |
| CPackedRegisterRef | |
| CPhiNode | |
| CPhiUseNode | |
| CPhysicalRegisterInfo | |
| CPrint | |
| CPrintLaneMaskOpt | |
| CPrintNode | |
| CRefNode | |
| ►CRegisterAggr | |
| Crr_iterator | |
| CRegisterRef | |
| CStmtNode | |
| CTargetOperandInfo | |
| CUseNode | |
| ►Nreassociate | A private "module" namespace for types and utilities used by Reassociate |
| CFactor | Utility class representing a base and exponent pair which form one factor of some product |
| CValueEntry | |
| CXorOpnd | Utility class representing a non-constant Xor-operand |
| ►NRISCVMatInt | |
| CInst | |
| ►NRISCVSysReg | |
| CSysReg | |
| ►Nsafestack | |
| ►CStackColoring | Compute live ranges of allocas |
| CLiveRange | This class represents a set of interesting instructions where an alloca is live |
| CStackLayout | Compute the layout of an unsafe stack frame |
| ►Nsampleprof | |
| ►CFunctionSamples | Representation of the samples collected for a function |
| CGUIDToFuncNameMapper | |
| CLineLocation | Represents the relative location of an instruction |
| CSampleProfileReader | Sample-based profile reader |
| CSampleProfileReaderBinary | |
| CSampleProfileReaderCompactBinary | |
| CSampleProfileReaderGCC | |
| CSampleProfileReaderItaniumRemapper | A profile data reader proxy that remaps the profile data from another sample profile data reader, by applying a provided set of equivalences between components of the symbol names in the profile |
| CSampleProfileReaderRawBinary | |
| CSampleProfileReaderText | |
| CSampleProfileWriter | Sample-based profile writer. Base class |
| CSampleProfileWriterBinary | Sample-based profile writer (binary format) |
| CSampleProfileWriterCompactBinary | |
| CSampleProfileWriterRawBinary | |
| CSampleProfileWriterText | Sample-based profile writer (text format) |
| CSampleRecord | Representation of a single sample record |
| CSampleSorter | Sort a LocationT->SampleT map by LocationT |
| ►NSI | |
| ►Nslpvectorizer | A private "module" namespace for types and utilities used by this pass |
| CBoUpSLP | Bottom Up SLP Vectorizer |
| ►Nsroa | |
| CAllocaSliceRewriter | Visitor to rewrite instructions using p particular slice of an alloca to use a new alloca |
| CAllocaSlices | Representation of the alloca slices |
| CPartition | A partition of the slices |
| CSROALegacyPass | A legacy pass for the legacy pass manager that wraps the SROA pass |
| ►Nsupport | |
| ►Ndetail | |
| ►Cpacked_endian_specific_integral | |
| Cref | |
| CPickAlignment | ::value is either alignment, or alignof(T) if alignment is 0 |
| ►Nendian | |
| CWriter | Adapter to write values to a stream in a particular byte order |
| ►Nsymbolize | |
| CDIPrinter | |
| ►CLLVMSymbolizer | |
| COptions | |
| CSymbolizableModule | |
| CSymbolizableObjectFile | |
| ►NSymbolRewriter | |
| CRewriteDescriptor | The basic entity representing a rewrite operation |
| CRewriteMapParser | |
| ►Nsys | |
| ►Nfs | |
| ►Ndetail | |
| CDirIterState | Keeps state for the directory_iterator |
| CRecDirIterState | Keeps state for the recursive_directory_iterator |
| Cbasic_file_status | Represents the result of a call to directory_iterator::status() |
| Cdirectory_entry | Directory_entry - A single entry in a directory |
| Cdirectory_iterator | Directory_iterator - Iterates through the entries in path |
| Cfile_status | Represents the result of a call to sys::fs::status() |
| Cmapped_file_region | This class represents a memory mapped file |
| Crecursive_directory_iterator | Recursive_directory_iterator - Same as directory_iterator except for it recurses down into child directories |
| Cspace_info | Space_info - Self explanatory |
| CTempFile | Represents a temporary file |
| CUniqueID | |
| ►Npath | |
| Cconst_iterator | Path iterator |
| Creverse_iterator | Reverse path iterator |
| ►CDynamicLibrary | 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 |
| CHandleSet | |
| CInitializeCOMRAII | |
| CMemory | This class provides various memory handling functions that manipulate MemoryBlock instances |
| CMemoryBlock | This class encapsulates the notion of a memory block which has an address and a size |
| CMutexImpl | Platform agnostic Mutex class |
| COwningMemoryBlock | Owning version of MemoryBlock |
| CProcess | A collection of legacy interfaces for querying information about the current executing process |
| CProcessInfo | This struct encapsulates information about a process |
| CRWMutexImpl | Platform agnostic RWMutex class |
| CSmartMutex | 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 |
| CSmartRWMutex | 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 |
| CSmartScopedLock | |
| CSmartScopedReader | ScopedReader - RAII acquisition of a reader lock |
| CSmartScopedWriter | ScopedWriter - RAII acquisition of a writer lock |
| CThreadLocal | ThreadLocal - A class used to abstract thread-local storage |
| CThreadLocalImpl | |
| CUnicodeCharRange | Represents a closed range of Unicode code points [Lower, Upper] |
| CUnicodeCharSet | 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 |
| CWatchdog | This class provides an abstraction for a timeout around an operation that must complete in a given amount of time |
| ►NSystemZII | |
| CBranch | |
| ►Ntrailing_objects_internal | |
| CAlignmentCalcHelper | Helper template to calculate the max alignment requirement for a set of objects |
| CAlignmentCalcHelper< First > | |
| CExtractSecondType | |
| CTrailingObjectsAligner | This helper template works-around MSVC 2013's lack of useful alignas() support |
| CTrailingObjectsAligner< 1 > | |
| CTrailingObjectsAligner< 16 > | |
| CTrailingObjectsAligner< 2 > | |
| CTrailingObjectsAligner< 32 > | |
| CTrailingObjectsAligner< 4 > | |
| CTrailingObjectsAligner< 8 > | |
| ►CTrailingObjectsBase | The base class for TrailingObjects* classes |
| COverloadToken | OverloadToken's purpose is to allow specifying function overloads for different types, without actually taking the types as parameters |
| CTrailingObjectsImpl | |
| CTrailingObjectsImpl< Align, BaseTy, TopTrailingObj, PrevTy > | |
| CTrailingObjectsImpl< Align, BaseTy, TopTrailingObj, PrevTy, NextTy, MoreTys... > | |
| ►Nvfs | |
| ►Ndetail | |
| CDirIterImpl | An interface for virtual file systems to provide an iterator over the (non-recursive) contents of a directory |
| CInMemoryDirectory | |
| CInMemoryFile | |
| CInMemoryNode | The in memory file system is a tree of Nodes |
| CRecDirIterState | Keeps state for the recursive_directory_iterator |
| Cdirectory_entry | A member of a directory, yielded by a directory_iterator |
| Cdirectory_iterator | An input iterator over the entries in a virtual path, similar to llvm::sys::fs::directory_iterator |
| CFile | Represents an open file |
| CFileSystem | The virtual file system interface |
| CInMemoryFileSystem | An in-memory file system |
| COverlayFileSystem | A file system that allows overlaying one AbstractFileSystem on top of another |
| CProxyFileSystem | By default, this delegates all calls to the underlying file system |
| Crecursive_directory_iterator | An input iterator over the recursive contents of a virtual path, similar to llvm::sys::fs::recursive_directory_iterator |
| ►CRedirectingFileSystem | A virtual file system parsed from a YAML file |
| CEntry | A single file or directory in the VFS |
| CRedirectingDirectoryEntry | |
| CRedirectingFileEntry | |
| CRedirectingFileSystemParser | A helper class to hold the common YAML parsing state |
| CStatus | The result of a status operation |
| CVFSFromYamlDirIterImpl | |
| CYAMLVFSEntry | |
| CYAMLVFSWriter | |
| ►Nwasm | |
| CWasmDataReference | |
| CWasmDataSegment | |
| CWasmDylinkInfo | |
| CWasmElemSegment | |
| CWasmEvent | |
| CWasmEventType | |
| CWasmExport | |
| CWasmFunction | |
| CWasmFunctionName | |
| CWasmGlobal | |
| CWasmGlobalType | |
| CWasmImport | |
| CWasmInitExpr | |
| CWasmInitFunc | |
| CWasmLimits | |
| CWasmLinkingData | |
| CWasmLocalDecl | |
| CWasmObjectHeader | |
| CWasmRelocation | |
| CWasmSignature | |
| CWasmSymbolInfo | |
| CWasmTable | |
| ►NWasmYAML | |
| CCodeSection | |
| CComdat | |
| CComdatEntry | |
| CCustomSection | |
| CDataSection | |
| CDataSegment | |
| CDylinkSection | |
| CElemSection | |
| CElemSegment | |
| CEvent | |
| CEventSection | |
| CExport | |
| CExportSection | |
| CFileHeader | |
| CFunction | |
| CFunctionSection | |
| CGlobal | |
| CGlobalSection | |
| CImport | |
| CImportSection | |
| CInitFunction | |
| CLimits | |
| CLinkingSection | |
| CLocalDecl | |
| CMemorySection | |
| CNameEntry | |
| CNameSection | |
| CObject | |
| CRelocation | |
| CSection | |
| CSegmentInfo | |
| CSignature | |
| CStartSection | |
| CSymbolInfo | |
| CTable | |
| CTableSection | |
| CTypeSection | |
| ►Nwholeprogramdevirt | |
| CAccumBitVector | |
| CTypeMemberInfo | |
| CVirtualCallTarget | |
| CVTableBits | |
| ►NWin64EH | |
| CARM64UnwindEmitter | |
| CInstruction | |
| CRuntimeFunction | RuntimeFunction - An entry in the table of functions with unwind info |
| CUnwindCode | UnwindCode - This union describes a single operation in a function prolog, or part thereof |
| CUnwindEmitter | |
| CUnwindInfo | UnwindInfo - An entry in the exception table |
| ►Nwindows_manifest | |
| CWindowsManifestError | |
| ►CWindowsManifestMerger | |
| CWindowsManifestMergerImpl | |
| ►NWinEH | |
| CFrameInfo | |
| CInstruction | |
| CUnwindEmitter | |
| ►NX86_MC | |
| CX86MCInstrAnalysis | |
| ►NX86Disassembler | |
| CInstructionSpecifier | The specification for how to extract and interpret a full instruction and its operands |
| CInternalInstruction | The x86 internal instruction, which is produced by the decoder |
| COperandSpecifier | The specification for how to extract and interpret one operand |
| ►Nxray | |
| ►CBlockIndexer | |
| CBlock | |
| CBlockPrinter | |
| CBlockVerifier | |
| CBufferExtents | |
| CCallArgRecord | |
| CCustomEventRecord | |
| CCustomEventRecordV5 | |
| CEndBufferRecord | |
| CFDRTraceWriter | The FDRTraceWriter allows us to hand-craft an XRay Flight Data Recorder (FDR) mode log file |
| CFileBasedRecordProducer | |
| CFunctionRecord | |
| ►CGraph | A Graph object represents a Directed Graph and is used in XRay to compute and store function call graphs and associated statistical information |
| CEdgeView | A class for ranging over all the edges in the graph |
| CInOutEdgeView | A class for ranging over the incoming edges incident to a vertex |
| CVertexView | A class for ranging over the vertices in the graph |
| CInstrumentationMap | The InstrumentationMap represents the computed function id's and indicated function addresses from an object file (or a YAML file) |
| CLogBuilder | Allows for creating ad-hoc collections of records through the add<...>(...) function |
| CLogBuilderConsumer | |
| CMetadataRecord | |
| CNewBufferRecord | |
| CNewCPUIDRecord | |
| CPIDRecord | |
| CPipelineConsumer | |
| ►CProfile | Profile instances are thread-compatible |
| CBlock | |
| CData | |
| CRecord | |
| CRecordConsumer | |
| CRecordInitializer | |
| CRecordPrinter | |
| CRecordProducer | |
| CRecordVisitor | |
| CSledEntry | Represents an XRay instrumentation sled entry from an object file |
| CTrace | A Trace object represents the records that have been loaded from XRay log files generated by instrumented binaries |
| CTraceExpander | |
| CTSCWrapRecord | |
| CTypedEventRecord | |
| CWallclockRecord | |
| CXRayFileHeader | 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 |
| CXRayRecord | An XRayRecord is the denormalized view of data associated in a trace |
| CYAMLXRayFileHeader | |
| CYAMLXRayRecord | |
| CYAMLXRaySledEntry | |
| CYAMLXRayTrace | |
| ►Nyaml | |
| CAliasNode | Represents an alias to a Node with an anchor |
| Cbasic_collection_iterator | This is an iterator abstraction over YAML collections shared by both sequences and maps |
| CBinaryRef | Specialized YAMLIO scalar type for representing a binary blob |
| CBlockScalarNode | A block scalar node is an opaque datum that can be presented as a series of zero or more Unicode scalar values |
| CBlockScalarTraits< BlockStringValue > | |
| CBlockScalarTraits< Module > | This struct serializes the LLVM IR module |
| CBlockStringValue | |
| CCustomMappingTraits< GlobalValueSummaryMapTy > | |
| CCustomMappingTraits< msgpack::MapNode > | |
| CCustomMappingTraits< std::map< std::vector< uint64_t >, WholeProgramDevirtResolution::ByArg > > | |
| CCustomMappingTraits< std::map< uint64_t, WholeProgramDevirtResolution > > | |
| CCustomMappingTraits< std::set< ELFSymbol > > | YAML traits for set of ELFSymbols |
| CCustomMappingTraits< TypeIdSummaryMapTy > | |
| CDocument | A YAML Stream is a sequence of Documents |
| Cdocument_iterator | Iterator abstraction for Documents over a Stream |
| CFixedMachineStackObject | Serializable representation of the fixed stack object from the MachineFrameInfo class |
| CFlowStringValue | |
| CFunctionSummaryYaml | |
| CKeyValueNode | A key and value pair |
| CMachineConstantPoolValue | |
| CMachineFrameInfo | Serializable representation of MachineFrameInfo |
| CMachineFunction | |
| CMachineFunctionLiveIn | |
| ►CMachineJumpTable | |
| CEntry | |
| CMachineStackObject | Serializable representation of stack object from the MachineFrameInfo class |
| CMappingNode | Represents a YAML map created from either a block map for a flow map |
| CMappingTraits | |
| CMappingTraits< COFF::AuxiliarybfAndefSymbol > | |
| CMappingTraits< COFF::AuxiliaryCLRToken > | |
| CMappingTraits< COFF::AuxiliaryFunctionDefinition > | |
| CMappingTraits< COFF::AuxiliarySectionDefinition > | |
| CMappingTraits< COFF::AuxiliaryWeakExternal > | |
| CMappingTraits< COFF::DataDirectory > | |
| CMappingTraits< COFF::header > | |
| CMappingTraits< COFFYAML::Object > | |
| CMappingTraits< COFFYAML::PEHeader > | |
| CMappingTraits< COFFYAML::Relocation > | |
| CMappingTraits< COFFYAML::Section > | |
| CMappingTraits< COFFYAML::Symbol > | |
| CMappingTraits< DiagnosticInfoOptimizationBase * > | |
| CMappingTraits< DiagnosticInfoOptimizationBase::Argument > | |
| CMappingTraits< DiagnosticLocation > | |
| CMappingTraits< DWARFYAML::Abbrev > | |
| CMappingTraits< DWARFYAML::ARange > | |
| CMappingTraits< DWARFYAML::ARangeDescriptor > | |
| CMappingTraits< DWARFYAML::AttributeAbbrev > | |
| CMappingTraits< DWARFYAML::Data > | |
| CMappingTraits< DWARFYAML::Entry > | |
| CMappingTraits< DWARFYAML::File > | |
| CMappingTraits< DWARFYAML::FormValue > | |
| CMappingTraits< DWARFYAML::InitialLength > | |
| CMappingTraits< DWARFYAML::LineTable > | |
| CMappingTraits< DWARFYAML::LineTableOpcode > | |
| CMappingTraits< DWARFYAML::PubEntry > | |
| CMappingTraits< DWARFYAML::PubSection > | |
| CMappingTraits< DWARFYAML::Unit > | |
| CMappingTraits< ELFStub > | YAML traits for ELFStub objects |
| CMappingTraits< ELFSymbol > | YAML traits for ELFSymbol |
| CMappingTraits< ELFYAML::FileHeader > | |
| CMappingTraits< ELFYAML::LocalGlobalWeakSymbols > | |
| CMappingTraits< ELFYAML::Object > | |
| CMappingTraits< ELFYAML::ProgramHeader > | |
| CMappingTraits< ELFYAML::Relocation > | |
| CMappingTraits< ELFYAML::SectionName > | |
| CMappingTraits< ELFYAML::SectionOrType > | |
| CMappingTraits< ELFYAML::Symbol > | |
| CMappingTraits< FixedMachineStackObject > | |
| CMappingTraits< FunctionSummary::ConstVCall > | |
| CMappingTraits< FunctionSummary::VFuncId > | |
| CMappingTraits< FunctionSummaryYaml > | |
| CMappingTraits< HSAMD::Metadata > | |
| CMappingTraits< Kernel::Arg::Metadata > | |
| CMappingTraits< Kernel::Attrs::Metadata > | |
| CMappingTraits< Kernel::CodeProps::Metadata > | |
| CMappingTraits< Kernel::DebugProps::Metadata > | |
| CMappingTraits< Kernel::Metadata > | |
| CMappingTraits< LeafRecordBase > | |
| CMappingTraits< LocalVariableAddrGap > | |
| CMappingTraits< LocalVariableAddrRange > | |
| CMappingTraits< MachineConstantPoolValue > | |
| CMappingTraits< MachineFrameInfo > | |
| CMappingTraits< MachineFunction > | |
| CMappingTraits< MachineFunctionLiveIn > | |
| CMappingTraits< MachineJumpTable > | |
| CMappingTraits< MachineJumpTable::Entry > | |
| CMappingTraits< MachineStackObject > | |
| CMappingTraits< MachO::build_tool_version > | |
| CMappingTraits< MachO::dylib > | |
| CMappingTraits< MachO::fvmlib > | |
| CMappingTraits< MachO::section > | |
| CMappingTraits< MachO::section_64 > | |
| CMappingTraits< MachOYAML::BindOpcode > | |
| CMappingTraits< MachOYAML::ExportEntry > | |
| CMappingTraits< MachOYAML::FatArch > | |
| CMappingTraits< MachOYAML::FatHeader > | |
| CMappingTraits< MachOYAML::FileHeader > | |
| CMappingTraits< MachOYAML::LinkEditData > | |
| CMappingTraits< MachOYAML::LoadCommand > | |
| CMappingTraits< MachOYAML::NListEntry > | |
| CMappingTraits< MachOYAML::Object > | |
| CMappingTraits< MachOYAML::RebaseOpcode > | |
| CMappingTraits< MachOYAML::Section > | |
| CMappingTraits< MachOYAML::UniversalBinary > | |
| CMappingTraits< MemberRecordBase > | |
| CMappingTraits< ModuleSummaryIndex > | |
| CMappingTraits< std::unique_ptr< ELFYAML::Section > > | |
| CMappingTraits< std::unique_ptr< WasmYAML::Section > > | |
| CMappingTraits< SymbolRecordBase > | |
| CMappingTraits< TypeIdSummary > | |
| CMappingTraits< TypeTestResolution > | |
| CMappingTraits< VirtualRegisterDefinition > | |
| CMappingTraits< wasm::WasmInitExpr > | |
| CMappingTraits< WasmYAML::Comdat > | |
| CMappingTraits< WasmYAML::ComdatEntry > | |
| CMappingTraits< WasmYAML::DataSegment > | |
| CMappingTraits< WasmYAML::ElemSegment > | |
| CMappingTraits< WasmYAML::Event > | |
| CMappingTraits< WasmYAML::Export > | |
| CMappingTraits< WasmYAML::FileHeader > | |
| CMappingTraits< WasmYAML::Function > | |
| CMappingTraits< WasmYAML::Global > | |
| CMappingTraits< WasmYAML::Import > | |
| CMappingTraits< WasmYAML::InitFunction > | |
| CMappingTraits< WasmYAML::Limits > | |
| CMappingTraits< WasmYAML::LocalDecl > | |
| CMappingTraits< WasmYAML::NameEntry > | |
| CMappingTraits< WasmYAML::Object > | |
| CMappingTraits< WasmYAML::Relocation > | |
| CMappingTraits< WasmYAML::SegmentInfo > | |
| CMappingTraits< WasmYAML::Signature > | |
| CMappingTraits< WasmYAML::SymbolInfo > | |
| CMappingTraits< WasmYAML::Table > | |
| CMappingTraits< WholeProgramDevirtResolution > | |
| CMappingTraits< WholeProgramDevirtResolution::ByArg > | |
| CMappingTraits< xray::YAMLXRayFileHeader > | |
| CMappingTraits< xray::YAMLXRayRecord > | |
| CMappingTraits< xray::YAMLXRaySledEntry > | |
| CMappingTraits< xray::YAMLXRayTrace > | |
| CMappingTraits< YamlObjectFile > | |
| CNode | Abstract base class for all Nodes |
| CNullNode | A null value |
| CPolymorphicTraits< msgpack::NodePtr > | |
| CScalarBitSetTraits< COFF::Characteristics > | |
| CScalarBitSetTraits< COFF::DLLCharacteristics > | |
| CScalarBitSetTraits< COFF::SectionCharacteristics > | |
| CScalarBitSetTraits< ELFYAML::ELF_EF > | |
| CScalarBitSetTraits< ELFYAML::ELF_PF > | |
| CScalarBitSetTraits< ELFYAML::ELF_SHF > | |
| CScalarBitSetTraits< ELFYAML::ELF_STO > | |
| CScalarBitSetTraits< ELFYAML::MIPS_AFL_ASE > | |
| CScalarBitSetTraits< ELFYAML::MIPS_AFL_FLAGS1 > | |
| CScalarBitSetTraits< WasmYAML::LimitFlags > | |
| CScalarBitSetTraits< WasmYAML::SegmentFlags > | |
| CScalarBitSetTraits< WasmYAML::SymbolFlags > | |
| CScalarEnumerationTraits< AccessQualifier > | |
| CScalarEnumerationTraits< AddressSpaceQualifier > | |
| CScalarEnumerationTraits< COFF::MachineTypes > | |
| CScalarEnumerationTraits< COFF::RelocationTypeAMD64 > | |
| CScalarEnumerationTraits< COFF::RelocationTypeI386 > | |
| CScalarEnumerationTraits< COFF::RelocationTypesARM > | |
| CScalarEnumerationTraits< COFF::RelocationTypesARM64 > | |
| CScalarEnumerationTraits< COFF::SymbolBaseType > | |
| CScalarEnumerationTraits< COFF::SymbolComplexType > | |
| CScalarEnumerationTraits< COFF::SymbolStorageClass > | |
| CScalarEnumerationTraits< COFF::WindowsSubsystem > | |
| CScalarEnumerationTraits< COFFYAML::AuxSymbolType > | |
| CScalarEnumerationTraits< COFFYAML::COMDATType > | |
| CScalarEnumerationTraits< COFFYAML::WeakExternalCharacteristics > | |
| CScalarEnumerationTraits< dwarf::Attribute > | |
| CScalarEnumerationTraits< dwarf::Constants > | |
| CScalarEnumerationTraits< dwarf::Form > | |
| CScalarEnumerationTraits< dwarf::LineNumberExtendedOps > | |
| CScalarEnumerationTraits< dwarf::LineNumberOps > | |
| CScalarEnumerationTraits< dwarf::Tag > | |
| CScalarEnumerationTraits< dwarf::UnitType > | |
| CScalarEnumerationTraits< ELFSymbolType > | YAML traits for ELFSymbolType |
| CScalarEnumerationTraits< ELFYAML::ELF_ELFCLASS > | |
| CScalarEnumerationTraits< ELFYAML::ELF_ELFDATA > | |
| CScalarEnumerationTraits< ELFYAML::ELF_ELFOSABI > | |
| CScalarEnumerationTraits< ELFYAML::ELF_EM > | |
| CScalarEnumerationTraits< ELFYAML::ELF_ET > | |
| CScalarEnumerationTraits< ELFYAML::ELF_PT > | |
| CScalarEnumerationTraits< ELFYAML::ELF_REL > | |
| CScalarEnumerationTraits< ELFYAML::ELF_RSS > | |
| CScalarEnumerationTraits< ELFYAML::ELF_SHN > | |
| CScalarEnumerationTraits< ELFYAML::ELF_SHT > | |
| CScalarEnumerationTraits< ELFYAML::ELF_STT > | |
| CScalarEnumerationTraits< ELFYAML::ELF_STV > | |
| CScalarEnumerationTraits< ELFYAML::MIPS_ABI_FP > | |
| CScalarEnumerationTraits< ELFYAML::MIPS_AFL_EXT > | |
| CScalarEnumerationTraits< ELFYAML::MIPS_AFL_REG > | |
| CScalarEnumerationTraits< ELFYAML::MIPS_ISA > | |
| CScalarEnumerationTraits< FixedMachineStackObject::ObjectType > | |
| CScalarEnumerationTraits< MachineJumpTableInfo::JTEntryKind > | |
| CScalarEnumerationTraits< MachineStackObject::ObjectType > | |
| CScalarEnumerationTraits< MachO::BindOpcode > | |
| CScalarEnumerationTraits< MachO::LoadCommandType > | |
| CScalarEnumerationTraits< MachO::RebaseOpcode > | |
| CScalarEnumerationTraits< TypeTestResolution::Kind > | |
| CScalarEnumerationTraits< ValueKind > | |
| CScalarEnumerationTraits< ValueType > | |
| CScalarEnumerationTraits< WasmYAML::ComdatKind > | |
| CScalarEnumerationTraits< WasmYAML::ExportKind > | |
| CScalarEnumerationTraits< WasmYAML::Opcode > | |
| CScalarEnumerationTraits< WasmYAML::RelocType > | |
| CScalarEnumerationTraits< WasmYAML::SectionType > | |
| CScalarEnumerationTraits< WasmYAML::SymbolKind > | |
| CScalarEnumerationTraits< WasmYAML::TableType > | |
| CScalarEnumerationTraits< WasmYAML::ValueType > | |
| CScalarEnumerationTraits< WholeProgramDevirtResolution::ByArg::Kind > | |
| CScalarEnumerationTraits< WholeProgramDevirtResolution::Kind > | |
| CScalarEnumerationTraits< xray::RecordTypes > | |
| CScalarEnumerationTraits< xray::SledEntry::FunctionKinds > | |
| CScalarNode | A scalar node is an opaque datum that can be presented as a series of zero or more Unicode scalar values |
| CScalarTraits< BinaryRef > | |
| CScalarTraits< char_16 > | |
| CScalarTraits< ELFArchMapper > | YAML traits for ELFArch |
| CScalarTraits< FlowStringValue > | |
| CScalarTraits< StringValue > | |
| CScalarTraits< UnsignedValue > | |
| CScalarTraits< uuid_t > | |
| CScalarTraits< VersionTuple > | YAML traits for TbeVersion |
| CScanner | Scans YAML tokens from a MemoryBuffer |
| CSequenceNode | Represents a YAML sequence created from either a block sequence for a flow sequence |
| CSequenceTraits< msgpack::ArrayNode > | |
| CStream | This class represents a YAML stream potentially containing multiple documents |
| CStringValue | A wrapper around std::string which contains a source range that's being set during parsing |
| CTaggedScalarTraits< msgpack::ScalarNode > | |
| CToken | Token - A single YAML token |
| CUnsignedValue | A wrapper around unsigned which contains a source range that's being set during parsing |
| CVirtualRegisterDefinition | |
| CYamlObjectFile | |
| CA57ChainingConstraint | Add the accumulator chaining constraint to a PBQP graph |
| CAAEvalLegacyPass | |
| CAAEvaluator | |
| CAAManager | A manager for alias analyses |
| CAAMDNodes | A collection of metadata nodes that might be associated with a memory access used by the alias-analysis infrastructure |
| CAArch64_COFFTargetObjectFile | This implementation is used for AArch64 COFF targets |
| CAArch64_ELFTargetObjectFile | This implementation is used for AArch64 ELF targets (Linux in particular) |
| CAArch64_MachoTargetObjectFile | AArch64_MachoTargetObjectFile - This TLOF implementation is used for Darwin |
| CAArch64AppleInstPrinter | |
| CAArch64beTargetMachine | |
| CAArch64CallLowering | |
| CAArch64Disassembler | |
| CAArch64ExternalSymbolizer | |
| CAArch64FrameLowering | |
| ►CAArch64FunctionInfo | AArch64FunctionInfo - This class is derived from MachineFunctionInfo and contains private AArch64-specific information for each MachineFunction |
| CMILOHDirective | |
| CAArch64GenRegisterBankInfo | |
| CAArch64InstPrinter | |
| CAArch64InstrInfo | |
| CAArch64LegalizerInfo | This class provides the information for the target register banks |
| CAArch64leTargetMachine | |
| CAArch64MCAsmInfoDarwin | |
| CAArch64MCAsmInfoELF | |
| CAArch64MCAsmInfoGNUCOFF | |
| CAArch64MCAsmInfoMicrosoftCOFF | |
| CAArch64MCExpr | |
| CAArch64MCInstLower | AArch64MCInstLower - This class is used to lower an MachineInstr into an MCInst |
| CAArch64RegisterBankInfo | This class provides the information for the target register banks |
| CAArch64RegisterInfo | |
| CAArch64SelectionDAGInfo | |
| CAArch64Subtarget | |
| CAArch64TargetELFStreamer | |
| CAArch64TargetLowering | |
| CAArch64TargetMachine | |
| CAArch64TargetStreamer | |
| CAArch64TargetWinCOFFStreamer | |
| CAArch64TTIImpl | |
| ►CAAResultBase | A CRTP-driven "mixin" base class to help implement the function alias analysis results concept |
| CAAResultsProxy | 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 |
| ►CAAResults | |
| CConcept | A private abstract base class describing the concept of an individual alias analysis implementation |
| CAAResultsWrapperPass | A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object |
| CAbstractLatticeFunction | AbstractLatticeFunction - This class is implemented by the dataflow instance to specify what the lattice values are and how they handle merges etc |
| CAccelTable | This class holds an abstract representation of an Accelerator Table, consisting of a sequence of buckets, each bucket containint a sequence of HashData entries |
| ►CAccelTableBase | A base class holding non-template-dependant functionality of the AccelTable class |
| CHashData | Represents a group of entries with identical name (and hence, hash value) |
| CAccelTableData | Interface which the different types of accelerator table data have to conform |
| CADCEPass | A DCE pass that assumes instructions are dead until proven otherwise |
| Cadd_const_past_pointer | If T is a pointer to X, return a pointer to const X |
| Cadd_const_past_pointer< T, typename std::enable_if< std::is_pointer< T >::value >::type > | |
| Cadd_lvalue_reference_if_not_pointer | If T is a pointer, just return it. If it is not, return T& |
| Cadd_lvalue_reference_if_not_pointer< T, typename std::enable_if< std::is_pointer< T >::value >::type > | |
| CAddDiscriminatorsPass | |
| CAddOperator | |
| CAddressPool | |
| CAddrSpaceCastInst | This class represents a conversion between pointers from one address space to another |
| CAddrSpaceCastSDNode | |
| CAggressiveAntiDepBreaker | |
| ►CAggressiveAntiDepState | Contains all the state necessary for anti-dep breaking |
| CRegisterReference | Information about a register reference within a liverange |
| CAggressiveInstCombinePass | |
| ►CAliasSet | |
| Citerator | Define an iterator for alias sets... this is just a forward iterator |
| CAliasSetTracker | |
| CAliasSummary | Alias summary information |
| CAlignedCharArray | Helper for building an aligned character array type |
| CAlignedCharArrayUnion | This union template exposes a suitably aligned and sized character array member which can hold elements of any of up to ten types |
| CAlignmentFromAssumptionsPass | |
| ►CAlignTo | alignTo for contexts where a constant expression is required |
| Cfrom_value | |
| CAllAnalysesOn | This templated class represents "all analyses that operate over \<a
particular IR unit\>" (e.g |
| CAllocaHolder | |
| CAllocaInst | Instruction to allocate memory on the stack |
| CAllocationOrder | |
| CAllocatorBase | CRTP base class providing obvious overloads for the core Allocate() methods of LLVM-style allocators |
| CAllocatorList | A linked-list with a custom, local allocator |
| CAlwaysInlinerPass | Inlines functions marked as "always_inline" |
| CAMDGPUAA | Analysis pass providing a never-invalidated alias analysis result |
| CAMDGPUAAResult | A simple AA result that uses TBAA metadata to answer queries |
| CAMDGPUAAWrapperPass | Legacy wrapper pass to provide the AMDGPUAAResult object |
| CAMDGPUArgumentUsageInfo | |
| CAMDGPUAsmPrinter | |
| CAMDGPUBufferPseudoSourceValue | |
| CAMDGPUCallLowering | |
| CAMDGPUDisassembler | |
| CAMDGPUExternalAAWrapper | |
| CAMDGPUFrameLowering | Information about the stack frame layout on the AMDGPU targets |
| CAMDGPUFunctionArgInfo | |
| CAMDGPUGenRegisterBankInfo | This class provides the information for the target register banks |
| CAMDGPUImagePseudoSourceValue | |
| CAMDGPUInstPrinter | |
| CAMDGPUInstrInfo | |
| CAMDGPUInstructionSelector | |
| CAMDGPUIntrinsicInfo | |
| CAMDGPULegalizerInfo | This class provides the information for the target register banks |
| CAMDGPULibCalls | |
| CAMDGPULibFunc | Wrapper class for AMDGPULIbFuncImpl |
| ►CAMDGPULibFuncBase | |
| CParam | |
| CAMDGPULibFuncImpl | |
| CAMDGPUMachineFunction | |
| CAMDGPUMachineModuleInfo | |
| CAMDGPUMangledLibFunc | |
| CAMDGPUMCAsmInfo | |
| CAMDGPUMCCodeEmitter | |
| ►CAMDGPUPerfHintAnalysis | |
| CFuncInfo | |
| CAMDGPURegisterBankInfo | |
| CAMDGPURegisterInfo | |
| CAMDGPUSubtarget | |
| CAMDGPUSymbolizer | |
| CAMDGPUTargetAsmStreamer | |
| CAMDGPUTargetELFStreamer | |
| CAMDGPUTargetLowering | |
| CAMDGPUTargetMachine | |
| CAMDGPUTargetObjectFile | |
| CAMDGPUTargetStreamer | |
| CAMDGPUTTIImpl | |
| CAMDGPUUnmangledLibFunc | |
| CAnalysisCallGraphWrapperPassTraits | |
| CAnalysisInfoMixin | A CRTP mix-in that provides informational APIs needed for analysis passes |
| CAnalysisKey | A special type used by analysis passes to provide an address that identifies that particular analysis pass type |
| ►CAnalysisManager | A container for analyses that lazily runs them and caches their results |
| CInvalidator | API to communicate dependencies between analyses during invalidation |
| CAnalysisResolver | AnalysisResolver - Simple interface used by Pass objects to pull all analysis information out of pass manager that is responsible to manage the pass |
| CAnalysisResultsForFn | Helper struct for bundling up the analysis results per function for IPSCCP |
| CAnalysisSetKey | A special type used to provide an address that identifies a set of related analyses |
| CAnalysisUsage | Represent the analysis usage information of a pass |
| ►CAnonStructTypeKeyInfo | |
| CKeyTy | |
| CAntiDepBreaker | This class works in conjunction with the post-RA scheduler to rename registers to break register anti-dependencies (WAR hazards) |
| CAny | |
| CAnyMemCpyInst | This class represents any memcpy intrinsic i.e |
| CAnyMemIntrinsic | |
| CAnyMemMoveInst | This class represents any memmove intrinsic i.e |
| CAnyMemSetInst | This class represents any memset intrinsic |
| CAnyMemTransferInst | |
| CAPByteStreamer | |
| CAPFloat | |
| CAPFloatBase | A self-contained host- and target-independent arbitrary-precision floating-point software implementation |
| ►CAPInt | Class for arbitrary precision integers |
| Cms | Magic data for optimising signed division by a constant |
| Cmu | Magic data for optimising unsigned division by a constant |
| CAppendingBinaryByteStream | An implementation of WritableBinaryStream which can write at its end causing the underlying data to grow |
| ►CAppleAcceleratorTable | This implements the Apple accelerator table format, a precursor of the DWARF 5 accelerator table format |
| CEntry | Apple-specific implementation of an Accelerator Entry |
| CValueIterator | |
| ►CAppleAccelTableData | A base class for different implementations of Data classes for Apple Accelerator Tables |
| CAtom | An Atom defines the form of the data in an Apple accelerator table |
| CAppleAccelTableOffsetData | Accelerator table data implementation for simple Apple accelerator tables with just a DIE reference |
| CAppleAccelTableStaticOffsetData | Accelerator table data implementation for simple Apple accelerator tables with a DIE offset but no actual DIE pointer |
| CAppleAccelTableStaticTypeData | Accelerator table data implementation for type accelerator tables with a DIE offset but no actual DIE pointer |
| CAppleAccelTableTypeData | Accelerator table data implementation for Apple type accelerator tables |
| CAPSInt | |
| CARCFrameLowering | |
| CARCFunctionInfo | ARCFunctionInfo - This class is derived from MachineFunction private ARC target-specific information for each MachineFunction |
| CARCInstPrinter | |
| CARCInstrInfo | |
| CARCMCAsmInfo | |
| CARCMCInstLower | This class is used to lower an MachineInstr into an MCInst |
| CARCRegisterInfo | |
| CARCSubtarget | |
| CARCTargetLowering | |
| CARCTargetMachine | |
| CARCTargetStreamer | |
| CARCTTIImpl | |
| Care_base_of | Traits class for checking whether type T is a base class for all the given types in the variadic list |
| Care_base_of< T, U, Ts... > | |
| CArgDescriptor | |
| CArgument | This class represents an incoming formal argument to a Function |
| CArgumentPromotionPass | Argument promotion pass |
| CARMAsmBackend | |
| CARMAsmBackendDarwin | |
| CARMAsmPrinter | |
| CARMAttributeParser | |
| CARMBaseInstrInfo | |
| CARMBaseRegisterInfo | |
| CARMBaseTargetMachine | |
| CARMBETargetMachine | ARM/Thumb big endian target machine |
| CARMCallLowering | |
| CARMCOFFMCAsmInfoGNU | |
| CARMCOFFMCAsmInfoMicrosoft | |
| CARMConstantPoolConstant | ARMConstantPoolConstant - ARM-specific constant pool values for Constants, Functions, and BlockAddresses |
| CARMConstantPoolMBB | ARMConstantPoolMBB - ARM-specific constantpool value of a machine basic block |
| CARMConstantPoolSymbol | ARMConstantPoolSymbol - ARM-specific constantpool values for external symbols |
| CARMConstantPoolValue | ARMConstantPoolValue - ARM specific constantpool value |
| CARMELFMCAsmInfo | |
| CARMElfTargetObjectFile | |
| CARMException | |
| CARMFrameLowering | |
| CARMFunctionInfo | ARMFunctionInfo - This class is derived from MachineFunctionInfo and contains private ARM-specific information for each MachineFunction |
| CARMGenRegisterBankInfo | |
| CARMHazardRecognizer | ARMHazardRecognizer handles special constraints that are not expressed in the scheduling itinerary |
| CARMInstPrinter | |
| CARMInstrInfo | |
| CARMJITSymbolFlags | ARM-specific JIT symbol flags |
| CARMLegalizerInfo | This class provides the information for the target register banks |
| CARMLETargetMachine | ARM/Thumb little endian target machine |
| CARMMCAsmInfoDarwin | |
| CARMMCExpr | |
| CARMRegisterBankInfo | This class provides the information for the target register banks |
| CARMRegisterInfo | |
| CARMSelectionDAGInfo | |
| CARMSubtarget | |
| CARMTargetLowering | |
| CARMTargetStreamer | |
| CARMTTIImpl | |
| ►CArrayRecycler | Recycle small arrays allocated from a BumpPtrAllocator |
| CCapacity | The size of an allocated array is represented by a Capacity instance |
| CArrayRef | ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory), i.e |
| CArrayType | Class to represent array types |
| CASanStackFrameLayout | |
| CASanStackVariableDescription | |
| CAShrOperator | |
| CAsmCommentConsumer | A callback class which is notified of each comment in an assembly file as it is lexed |
| CAsmCond | AsmCond - Class to support conditional assembly |
| CAsmLexer | AsmLexer - Lexer class for assembly files |
| ►CAsmPrinter | This class is intended to be used as a driving class for all asm writers |
| CHandlerInfo | Protected struct HandlerInfo and Handlers permit target extended AsmPrinter adds their own handlers |
| CSrcMgrDiagInfo | |
| CXRayFunctionEntry | |
| CAsmPrinterHandler | Collects and handles AsmPrinter objects required to build debug or EH information |
| CAsmRewrite | |
| CAsmToken | Target independent representation for an assembler token |
| CAssemblerConstantPools | |
| CAssemblyAnnotationWriter | |
| CAssertingVH | Value handle that asserts if the Value is deleted |
| CAssumptionAnalysis | A function analysis which provides an AssumptionCache |
| CAssumptionCache | A cache of @llvm.assume calls within a function |
| CAssumptionCacheTracker | An immutable pass that tracks lazily created AssumptionCache objects |
| CAssumptionPrinterPass | Printer pass for the AssumptionAnalysis results |
| CAtomicCmpXchgInst | Instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there |
| CAtomicMemCpyInst | This class represents the atomic memcpy intrinsic i.e |
| CAtomicMemIntrinsic | |
| CAtomicMemMoveInst | This class represents the atomic memmove intrinsic i.e |
| CAtomicMemSetInst | This class represents atomic memset intrinsic |
| CAtomicMemTransferInst | |
| CAtomicRMWInst | Instruction that atomically reads a memory location, combines it with another value, and then stores the result back |
| CAtomicSDNode | This is an SDNode representing atomic operations |
| CAttrBuilder | |
| CAttribute | |
| CAttributeImpl | |
| CAttributeList | |
| CAttributeListImpl | |
| CAttributeSet | |
| CAttributeSetNode | |
| CAVRAsmBackend | Utilities for manipulating generated AVR machine code |
| CAVRAsmPrinter | An AVR assembly code printer |
| CAVRDAGToDAGISel | Lowers LLVM IR (in DAG form) to AVR MC instructions (in DAG form) |
| CAVRDynAllocaSR | Create the Dynalloca Stack Pointer Save/Restore pass |
| CAVRELFObjectWriter | Writes AVR machine code into an ELF32 object file |
| CAVRELFStreamer | A target streamer for an AVR ELF object file |
| CAVRFrameAnalyzer | The frame analyzer pass |
| CAVRFrameLowering | Utilities for creating function call frames |
| CAVRInstPrinter | Prints AVR instructions to a textual stream |
| CAVRInstrInfo | Utilities related to the AVR instruction set |
| CAVRMachineFunctionInfo | Contains AVR-specific information for each MachineFunction |
| CAVRMCAsmInfo | Specifies the format of AVR assembly files |
| CAVRMCCodeEmitter | Writes AVR machine code to a stream |
| CAVRMCELFStreamer | |
| CAVRMCExpr | A expression in AVR machine code |
| CAVRMCInstLower | Lowers MachineInstr objects into MCInst objects |
| CAVRRegisterInfo | Utilities relating to AVR registers |
| CAVRSelectionDAGInfo | Holds information about the AVR instruction selection DAG |
| CAVRSubtarget | A specific AVR target MCU |
| CAVRTargetAsmStreamer | A target streamer for textual AVR assembly code |
| CAVRTargetLowering | Performs target lowering for the AVR |
| CAVRTargetMachine | A generic AVR implementation |
| CAVRTargetObjectFile | Lowering for an AVR ELF32 object file |
| CAVRTargetStreamer | A generic AVR target output stream |
| CBaseIndexOffset | Helper struct to parse and store a memory address as base + index + offset |
| CBasicAA | Analysis pass providing a never-invalidated alias analysis result |
| CBasicAAResult | This is the AA result object for the basic, local, and stateless alias analysis |
| CBasicAAWrapperPass | Legacy wrapper pass to provide the BasicAAResult object |
| ►CBasicBlock | LLVM Basic Block Representation |
| Cphi_iterator_impl | Iterator to walk just the phi nodes in the basic block |
| CBasicBlockEdge | |
| CBasicBlockInfo | BasicBlockInfo - Information about the offset and size of a single basic block |
| CBasicBlockPass | BasicBlockPass class - This class is used to implement most local optimizations |
| CBasicBlockSDNode | |
| CBasicDIEUnit | |
| CBasicTTIImpl | Concrete BasicTTIImpl that can be used if no further customization is needed |
| CBasicTTIImplBase | Base class which can be used to help build a TTI implementation |
| CBDCEPass | |
| Cbf_iterator | |
| Cbf_iterator_storage | |
| CBFIDOTGraphTraitsBase | |
| CBinaryByteStream | An implementation of BinaryStream which holds its entire data set in a single contiguous buffer |
| CBinaryConstantExpr | BinaryConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement binary constant exprs |
| CBinaryItemStream | BinaryItemStream represents a sequence of objects stored in some kind of external container but for which it is useful to view as a stream of contiguous bytes |
| CBinaryItemTraits | |
| CBinaryItemTraits< codeview::CVSymbol > | |
| CBinaryItemTraits< llvm::codeview::CVType > | |
| CBinaryOperator | |
| CBinaryStream | An interface for accessing data in a stream-like format, but which discourages copying |
| CBinaryStreamError | Base class for errors originating when parsing raw PDB files |
| CBinaryStreamReader | Provides read only access to a subclass of BinaryStream |
| CBinaryStreamRef | BinaryStreamRef is to BinaryStream what ArrayRef is to an Array |
| CBinaryStreamRefBase | Common stuff for mutable and immutable StreamRefs |
| CBinaryStreamWriter | Provides write only access to a subclass of WritableBinaryStream |
| CBinarySubstreamRef | |
| CBinOpInit | !op (X, Y) - Combine two inits |
| CBitCastInst | This class represents a no-op cast from one type to another |
| CBitCastOperator | |
| CBitCodeAbbrev | BitCodeAbbrev - This class represents an abbreviation record |
| CBitCodeAbbrevOp | BitCodeAbbrevOp - This describes one or more operands in an abbreviation |
| CBitcodeFileContents | |
| CBitcodeLTOInfo | Basic information extracted from a bitcode module to be used for LTO |
| CBitcodeModule | Represents a module in a bitcode file |
| CBitcodeReaderValueList | |
| CBitcodeWriter | |
| CBitcodeWriterPass | Pass for writing a module of IR out to a bitcode file |
| CBitInit | 'true'/'false' - Represent a concrete initializer for a bit |
| CBitMaskClassIterator | This class encapuslates the logic to iterate over bitmask returned by the various RegClass related APIs |
| CBitRecTy | 'bit' - Represent a single bit |
| CBitsInit | '{ a, b, c }' - Represents an initializer for a BitsRecTy value |
| CBitsRecTy | 'bits<n>' - Represent a fixed number of bits |
| ►CBitstreamBlockInfo | This class maintains the abbreviations read from a block info block |
| CBlockInfo | This contains information emitted to BLOCKINFO_BLOCK blocks |
| CBitstreamCursor | This represents a position within a bitcode file, implemented on top of a SimpleBitstreamCursor |
| CBitstreamEntry | When advancing through a bitstream cursor, each advance can discover a few different kinds of entries: |
| CBitstreamWriter | |
| ►CBitTracker | |
| CBitMask | |
| CBitRef | |
| CBitValue | |
| CMachineEvaluator | |
| CRegisterCell | |
| CRegisterRef | |
| ►CBitVector | |
| Creference | |
| CBlockAddress | The address of a basic block |
| CBlockAddressSDNode | |
| CBlockFrequency | |
| CBlockFrequencyAnalysis | Analysis pass which computes BlockFrequencyInfo |
| CBlockFrequencyInfo | BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequencies |
| CBlockFrequencyInfoImpl | Shared implementation for block frequency analysis |
| ►CBlockFrequencyInfoImplBase | Base class for BlockFrequencyInfoImpl |
| CBlockNode | Representative of a block |
| CDistribution | Distribution of unscaled probability weight |
| CFrequencyData | Stats about a block itself |
| CLoopData | Data about a loop |
| CWeight | Unscaled probability weight |
| CWorkingData | Index of loop information |
| CBlockFrequencyInfoWrapperPass | Legacy analysis pass which computes BlockFrequencyInfo |
| CBlockFrequencyPrinterPass | Printer pass for the BlockFrequencyInfo results |
| CBlotMapVector | An associative container with fast insertion-order (deterministic) iteration over its elements |
| CBoundsCheckingPass | A pass to instrument code and perform run-time bounds checking on loads, stores, and other memory intrinsics |
| CBPFFrameLowering | |
| CBPFInstPrinter | |
| CBPFInstrInfo | |
| CBPFMCAsmInfo | |
| CBPFMCInstLower | |
| CBPFRegisterInfo | |
| CBPFSelectionDAGInfo | |
| CBPFSubtarget | |
| CBPFTargetLowering | |
| CBPFTargetMachine | |
| CBPIPassTrait | Simple trait class that provides a mapping between BPI passes and the corresponding BPInfo |
| CBPIPassTrait< LazyBranchProbabilityInfoPass > | |
| ►CBranchFolder | |
| CMBFIWrapper | This class keeps track of branch frequencies of newly created blocks and tail-merged blocks |
| ►CBranchInst | Conditional or Unconditional Branch instruction |
| Cconst_succ_op_iterator | The const version of succ_op_iterator |
| Csucc_op_iterator | Iterator type that casts an operand to a basic block |
| CBranchProbability | |
| CBranchProbabilityAnalysis | Analysis pass which computes BranchProbabilityInfo |
| ►CBranchProbabilityInfo | Analysis providing branch probability information |
| CSccInfo | |
| CBranchProbabilityInfoWrapperPass | Legacy analysis pass which computes BranchProbabilityInfo |
| CBranchProbabilityPrinterPass | Printer pass for the BranchProbabilityAnalysis results |
| CBreakCriticalEdgesPass | |
| CBreakFalseDeps | |
| CBTFDebug | Collect and emit BTF information |
| CBTFFuncInfo | Represent one func and its type id |
| CBTFLineInfo | Represent one line info |
| CBTFStringTable | String table |
| CBTFTypeArray | Handle array type |
| CBTFTypeBase | The base class for BTF type generation |
| CBTFTypeDerived | Handle several derived types include pointer, const, volatile, typedef and restrict |
| CBTFTypeEnum | Handle enumerate type |
| CBTFTypeFunc | Handle subprogram |
| CBTFTypeFuncProto | Handle function pointer |
| CBTFTypeFwd | Handle struct or union forward declaration |
| CBTFTypeInt | Handle int type |
| CBTFTypeStruct | Handle struct/union type |
| Cbuffer_ostream | |
| CBufferByteStreamer | |
| Cbuild_index_impl | |
| Cbuild_index_impl< 0, I... > | |
| CBuildVectorSDNode | A "pseudo-class" with methods for operating on BUILD_VECTORs |
| CBumpPtrAllocatorImpl | Allocate memory in an ever growing pool, as if by bump-pointer |
| CByteStreamer | |
| CCachedHashString | A container which contains a string, which it owns, plus a precomputed hash |
| CCachedHashStringRef | A container which contains a StringRef plus a precomputed hash |
| CCachePruningPolicy | Policy for the pruneCache() function |
| CCallbackVH | Value handle with callbacks on RAUW and destruction |
| ►CCallBase | Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to calling a function |
| CBundleOpInfo | Used to keep track of an operand bundle |
| CCalledValuePropagationPass | |
| CCalleeInfo | Class to accumulate and hold information about a callee |
| CCalleeSavedInfo | Tracks the information need to locate where a callee saved register is in the current frame |
| CCallEntryPseudoSourceValue | |
| CCallGraph | The basic data container for the call graph of a Module of IR |
| CCallGraphAnalysis | An analysis pass to compute the CallGraph for a Module |
| CCallGraphNode | A node in the call graph for a module |
| CCallGraphPrinterPass | Printer pass for the CallGraphAnalysis results |
| CCallGraphSCC | CallGraphSCC - This is a single SCC that a CallGraphSCCPass is run on |
| CCallGraphSCCPass | |
| CCallGraphWrapperPass | The ModulePass which wraps up a CallGraph and the logic to build it |
| CCallInfo | |
| CCallInst | This class represents a function call, abstracting a target machine's calling convention |
| ►CCallLowering | |
| CArgInfo | |
| CValueHandler | 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 |
| CCallSite | |
| CCallSiteBase | |
| CCallSiteSplittingPass | |
| CCanonicalizeAliasesPass | Simple pass that canonicalizes aliases |
| CCaptureTracker | This callback is used in conjunction with PointerMayBeCaptured |
| Ccast_convert_val | |
| Ccast_convert_val< To, FromTy, FromTy > | |
| Ccast_retty | |
| Ccast_retty_impl | |
| Ccast_retty_impl< To, const From * > | |
| Ccast_retty_impl< To, const From *const > | |
| Ccast_retty_impl< To, const From > | |
| Ccast_retty_impl< To, From * > | |
| Ccast_retty_impl< To, std::unique_ptr< From > > | |
| Ccast_retty_wrap | |
| Ccast_retty_wrap< To, FromTy, FromTy > | |
| CCastInst | This is the base class for all instructions that perform data casts |
| CCatchPadInst | |
| CCatchReturnInst | |
| CCatchSwitchInst | |
| CCCState | CCState - This class holds information needed while lowering arguments and return values |
| CCCValAssign | CCValAssign - Represent assignment of one arg/retval to a location |
| CCFGAnalyses | Represents analyses that only rely on functions' control flow |
| CCFGMST | An union-find based Minimum Spanning Tree for CFG |
| CCFGOnlyPrinterPass | |
| CCFGOnlyViewerPass | |
| CCFGPrinterPass | |
| CCFGViewerPass | |
| ►CCFGViewPredecessors | |
| CDeletedEdgesFilter | |
| ►CCFGViewSuccessors | |
| CDeletedEdgesFilter | |
| CCFLAndersAA | Analysis pass providing a never-invalidated alias analysis result |
| ►CCFLAndersAAResult | |
| CFunctionInfo | |
| CCFLAndersAAWrapperPass | Legacy wrapper pass to provide the CFLAndersAAResult object |
| CCFLSteensAA | Analysis pass providing a never-invalidated alias analysis result |
| ►CCFLSteensAAResult | |
| CFunctionInfo | Information we have about a function and would like to keep around |
| CCFLSteensAAWrapperPass | Legacy wrapper pass to provide the CFLSteensAAResult object |
| CCGProfilePass | |
| CCGSCCToFunctionPassAdaptor | Adaptor that maps from a SCC to its functions |
| CCGSCCUpdateResult | Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager infrsatructure |
| CCHIArg | |
| Ccircular_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 |
| ►CClassInfo | |
| CMemberInfo | |
| CCleanupPadInst | |
| CCleanupReturnInst | |
| CClonedCodeInfo | This struct can be used to capture information about code being cloned, while it is being cloned |
| CClrEHUnwindMapEntry | |
| CCmpInst | This class is the base class for the comparison instructions |
| CCoalescerPair | A helper class for register coalescers |
| CCodeExtractor | Utility class for extracting code into a new function |
| CCodeGenCoverage | |
| CCodeInit | |
| CCodeMetrics | Utility to calculate the size and a few similar metrics for a set of basic blocks |
| CCodeRecTy | 'code' - Represent a code fragment |
| CCodeViewContext | Holds state from .cv_file and .cv_loc directives for later emission |
| ►CCodeViewDebug | Collects and handles line tables information in a CodeView format |
| CTypeLoweringScope | |
| CCombiner | |
| CCombinerHelper | |
| CCombinerInfo | |
| CComdat | |
| CCommonHandleTraits | |
| CCompareConstantExpr | |
| CCompositeType | Common super class of ArrayType, StructType and VectorType |
| Cconcat_iterator | Iterator wrapper that concatenates sequences together |
| CConcreteOperator | A helper template for defining operators for individual opcodes |
| CCondCodeSDNode | |
| Cconjunction | |
| Cconjunction< B1 > | |
| Cconjunction< B1, Bn... > | |
| CConnectedVNInfoEqClasses | ConnectedVNInfoEqClasses - Helper class that can divide VNInfos in a LiveInterval into equivalence clases of connected components |
| Cconst_pointer_or_const_ref | |
| Cconst_pointer_or_const_ref< T, typename std::enable_if< std::is_pointer< T >::value >::type > | |
| Cconst_set_bits_iterator_impl | ForwardIterator for the bits that are set |
| CConstant | This is an important base class in LLVM |
| CConstantAggregate | Base class for aggregate constants (with operands) |
| CConstantAggregateZero | All zero aggregate value |
| CConstantAggrKeyType | |
| CConstantArray | ConstantArray - Constant Array Declarations |
| CConstantAsMetadata | |
| CConstantData | Base class for constants with no operands |
| CConstantDataArray | 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 |
| CConstantDataArraySlice | Represents offset+length into a ConstantDataArray |
| CConstantDataSequential | 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 |
| CConstantDataVector | 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 |
| CConstantExpr | A constant value that is initialized with an expression using other constant values |
| CConstantExprKeyType | |
| CConstantFolder | ConstantFolder - Create constants with minimum, target independent, folding |
| CConstantFoldingMIRBuilder | An MIRBuilder which does trivial constant folding of binary ops |
| CConstantFP | ConstantFP - Floating Point Values [float, double] |
| CConstantFPSDNode | |
| CConstantHoistingPass | |
| CConstantInfo | |
| CConstantInfo< ConstantArray > | |
| CConstantInfo< ConstantExpr > | |
| CConstantInfo< ConstantStruct > | |
| CConstantInfo< ConstantVector > | |
| CConstantInfo< InlineAsm > | |
| CConstantInt | This is the shared class of boolean and integer constants |
| CConstantMergePass | A pass that merges duplicate global constants into a single constant |
| CConstantPointerNull | A constant pointer value that points to null |
| CConstantPool | |
| CConstantPoolEntry | |
| CConstantPoolSDNode | |
| CConstantRange | This class represents a range of values |
| CConstantSDNode | |
| CConstantStruct | |
| CConstantTokenNone | A constant token which is empty |
| CConstantUniqueMap | |
| CConstantVector | Constant Vector Declarations |
| CConstMIBundleOperands | ConstMIBundleOperands - Iterate over all operands in a const bundle of machine instructions |
| CConstMIOperands | ConstMIOperands - Iterate over operands of a single const instruction |
| CConstrainedFPIntrinsic | This is the common base class for constrained floating point intrinsics |
| CContextAndReplaceableUses | Pointer to the context, with optional RAUW support |
| CContextualFoldingSet | ContextualFoldingSet - This template class is a further refinement of FoldingSet which provides a context argument when calling Profile on its nodes |
| CContextualFoldingSetTrait | ContextualFoldingSetTrait - Like FoldingSetTrait, but for ContextualFoldingSets |
| CControlHeightReductionPass | |
| CConvergingVLIWScheduler | ConvergingVLIWScheduler shrinks the unscheduled zone using heuristics to balance the schedule |
| CCoroAllocInst | This represents the llvm.coro.alloc instruction |
| CCoroBeginInst | This class represents the llvm.coro.begin instruction |
| CCoroEndInst | This represents the llvm.coro.end instruction |
| CCoroFrameInst | This represents the llvm.coro.frame instruction |
| CCoroFreeInst | This represents the llvm.coro.free instruction |
| ►CCoroIdInst | This represents the llvm.coro.alloc instruction |
| CInfo | |
| CCoroPromiseInst | This represents the llvm.coro.promise instruction |
| CCoroSaveInst | This represents the llvm.coro.save instruction |
| CCoroSizeInst | This represents the llvm.coro.size instruction |
| CCoroSubFnInst | This class represents the llvm.coro.subfn.addr instruction |
| CCoroSuspendInst | This represents the llvm.coro.suspend instruction |
| CCorrelatedValuePropagationPass | |
| CCostTblEntry | Cost Table Entry |
| CCrashRecoveryContext | Crash recovery helper object |
| CCrashRecoveryContextCleanup | Abstract base class of cleanup handlers |
| CCrashRecoveryContextCleanupBase | Base class of cleanup handler that controls recovery of resources of the given type |
| CCrashRecoveryContextCleanupRegistrar | Helper class for managing resource cleanups |
| CCrashRecoveryContextDeleteCleanup | Cleanup handler that reclaims resource by calling 'delete' on it |
| CCrashRecoveryContextDestructorCleanup | Cleanup handler that reclaims resource by calling destructor on it |
| CCrashRecoveryContextReleaseRefCleanup | Cleanup handler that reclaims resource by calling its method 'Release' |
| CCriticalAntiDepBreaker | |
| CCriticalEdgeSplittingOptions | Option class for critical edge splitting |
| CCrossDSOCFIPass | |
| CCryptContextTraits | |
| CCSEConfig | |
| CCSEConfigConstantOnly | |
| CCSEMIRBuilder | Defines a builder that does CSE of MachineInstructions using GISelCSEInfo |
| CCxxUnwindMapEntry | |
| CDAGDeltaAlgorithm | DAGDeltaAlgorithm - Implements a "delta debugging" algorithm for minimizing directed acyclic graphs using a predicate function |
| CDagInit | (v a, b) - Represent a DAG tree value |
| CDagRecTy | 'dag' - Represent a dag fragment |
| CDAGTypeLegalizer | This takes an arbitrary SelectionDAG as input and hacks on it until only value types the target machine can handle are left |
| CDataExtractor | |
| CDataLayout | A parsed version of the target data layout string in and methods for querying it |
| CDataRegionData | |
| CDbgAddrIntrinsic | This represents the llvm.dbg.addr instruction |
| CDbgDeclareInst | This represents the llvm.dbg.declare instruction |
| CDbgEntity | This class is defined as the common parent of DbgVariable and DbgLabel such that it could levarage polymorphism to extract common code for DbgVariable and DbgLabel |
| CDbgInfoIntrinsic | This is the common base class for debug info intrinsics |
| CDbgLabel | This class is used to track label information |
| CDbgLabelInst | This represents the llvm.dbg.label instruction |
| CDbgLabelInstrMap | For each inlined instance of a source-level label, keep the corresponding DBG_LABEL instruction |
| CDbgValueHistoryMap | |
| CDbgValueInst | This represents the llvm.dbg.value instruction |
| CDbgVariable | This class is used to track local variable information |
| CDbgVariableIntrinsic | This is the common base class for debug info intrinsics for variables |
| CDbgVariableLocation | Represents the location at which a variable is stored |
| CDCEPass | Basic Dead Code Elimination pass |
| ►CDeadArgumentEliminationPass | Eliminate dead arguments (and return values) from functions |
| CRetOrArg | Struct that represents (part of) either a return value or a function argument |
| CDebugCounter | |
| ►CDebugEpochBase | A base class for data structure classes wishing to make iterators ("handles") pointing into themselves fail-fast |
| CHandleBase | A base class for iterator classes ("handles") that wish to poll for iterator invalidating modifications in the underlying data structure |
| CDebugHandlerBase | Base class for debug information backends |
| CDebugInfoFinder | Utility to find all debug info in a module |
| CDebugLoc | A debug info location |
| CDebugLocDwarfExpression | DwarfExpression implementation for .debug_loc entries |
| ►CDebugLocEntry | This struct describes location entries emitted in the .debug_loc section |
| CValue | A single location or constant |
| ►CDebugLocStream | Byte stream of .debug_loc entries |
| CEntry | |
| CEntryBuilder | Builder for DebugLocStream entries |
| CList | |
| CListBuilder | Builder for DebugLocStream lists |
| CdecimalInfo | |
| Cdef_chain_iterator | Walks the defining accesses of MemoryDefs |
| CDefaultAnalysisGraphTraits | Default traits class for extracting a graph from an analysis pass |
| CDefaultContextualFoldingSetTrait | DefaultContextualFoldingSetTrait - Like DefaultFoldingSetTrait, but for ContextualFoldingSets |
| CDefaultDOTGraphTraits | DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits methods |
| CDefaultFoldingSetTrait | DefaultFoldingSetTrait - This class provides default implementations for FoldingSetTrait implementations |
| CDefaultVLIWScheduler | |
| CDefInit | AL - Represent a reference to a 'def' in the description |
| CDefsetRecord | |
| CDelimitedScope | |
| CDeltaAlgorithm | DeltaAlgorithm - Implements the delta debugging algorithm (A |
| CDemandedBits | |
| CDemandedBitsAnalysis | An analysis that produces DemandedBits for a function |
| CDemandedBitsPrinterPass | Printer pass for DemandedBits |
| CDemandedBitsWrapperPass | |
| CDenseMap | |
| CDenseMapAPFloatKeyInfo | |
| CDenseMapAPIntKeyInfo | |
| CDenseMapBase | |
| CDenseMapInfo | |
| CDenseMapInfo< AAMDNodes > | |
| CDenseMapInfo< ArrayRef< T > > | |
| CDenseMapInfo< AssertingVH< T > > | |
| CDenseMapInfo< AttributeList > | |
| CDenseMapInfo< AttributeSet > | |
| CDenseMapInfo< BasicBlockEdge > | |
| CDenseMapInfo< CachedHashString > | |
| CDenseMapInfo< CachedHashStringRef > | |
| CDenseMapInfo< CallSite > | |
| CDenseMapInfo< CallValue > | |
| CDenseMapInfo< cflaa::InstantiatedValue > | |
| CDenseMapInfo< char > | |
| CDenseMapInfo< CIEKey > | |
| CDenseMapInfo< codeview::GloballyHashedType > | |
| CDenseMapInfo< codeview::LocallyHashedType > | |
| CDenseMapInfo< codeview::TypeIndex > | |
| CDenseMapInfo< const Expression * > | |
| CDenseMapInfo< coverage::CounterExpression > | Provide DenseMapInfo for CounterExpression |
| CDenseMapInfo< DivRemMapKey > | |
| CDenseMapInfo< ExitLimitQuery > | |
| CDenseMapInfo< FunctionSummary::ConstVCall > | |
| CDenseMapInfo< FunctionSummary::VFuncId > | |
| CDenseMapInfo< GVN::Expression > | |
| CDenseMapInfo< hash_code > | |
| CDenseMapInfo< ImmutableList< T > > | |
| CDenseMapInfo< int > | |
| CDenseMapInfo< LLT > | |
| CDenseMapInfo< LocationSize > | |
| CDenseMapInfo< long > | |
| CDenseMapInfo< long long > | |
| CDenseMapInfo< LoweredPHIRecord > | |
| CDenseMapInfo< MachineOperand > | |
| CDenseMapInfo< MemOpKey > | |
| CDenseMapInfo< MemoryLocation > | |
| CDenseMapInfo< MemoryLocOrCall > | |
| CDenseMapInfo< OffsetInstantiatedValue > | |
| CDenseMapInfo< OffsetValue > | |
| CDenseMapInfo< orc::SymbolStringPtr > | |
| CDenseMapInfo< PointerEmbeddedInt< IntT, Bits > > | |
| CDenseMapInfo< PointerIntPair< PointerTy, IntBits, IntType > > | |
| CDenseMapInfo< PointerSumType< TagT, MemberTs... > > | |
| CDenseMapInfo< PointerUnion< T, U > > | |
| CDenseMapInfo< PoisoningVH< T > > | |
| CDenseMapInfo< SDValue > | |
| CDenseMapInfo< short > | |
| CDenseMapInfo< SimpleValue > | |
| CDenseMapInfo< std::pair< T, U > > | |
| CDenseMapInfo< StringRef > | |
| CDenseMapInfo< T * > | |
| CDenseMapInfo< TargetInstrInfo::RegSubRegPair > | Provide DenseMapInfo for TargetInstrInfo::RegSubRegPair |
| CDenseMapInfo< unsigned > | |
| CDenseMapInfo< unsigned long > | |
| CDenseMapInfo< unsigned long long > | |
| CDenseMapInfo< unsigned short > | |
| CDenseMapInfo< ValueInfo > | |
| CDenseMapInfo< ValueMapCallbackVH< KeyT, ValueT, Config > > | |
| CDenseMapInfo< VTableSlot > | |
| CDenseMapInfo< wasm::WasmGlobalType > | |
| CDenseMapInfo< wasm::WasmSignature > | |
| CDenseMapIterator | |
| CDenseSet | Implements a dense probed hash-table based set |
| ►CDependence | Dependence - This class represents a dependence between two memory memory references in a function |
| CDVEntry | Dependence::DVEntry - Each level in the distance/direction vector has a direction (or perhaps a union of several directions), and perhaps a distance |
| CDependenceAnalysis | AnalysisPass to compute dependence information in a function |
| CDependenceAnalysisPrinterPass | Printer pass to dump DA results |
| CDependenceAnalysisWrapperPass | Legacy pass manager pass to access dependence information |
| CDependenceInfo | DependenceInfo - This class is the main dependence-analysis driver |
| Cderef | Binary functor that adapts to any other binary functor after dereferencing operands |
| CDerivedUser | Extension point for the Value hierarchy |
| CDescriptorInfo | |
| CDetectRoundChange | |
| CDevirtCallSite | A call site that could be devirtualized |
| CDevirtSCCRepeatedPass | A helper that repeats an SCC pass each time an indirect call is refined to a direct call by that pass |
| Cdf_ext_iterator | |
| Cdf_iterator | |
| Cdf_iterator_default_set | |
| Cdf_iterator_storage | |
| Cdf_iterator_storage< SetType, true > | |
| CDFAPacketizer | |
| CDFCalculateWorkObject | |
| CDiagnosticHandler | This is the base class for diagnostic handling in LLVM |
| CDiagnosticInfo | This is the base abstract class for diagnostic reporting in the backend |
| CDiagnosticInfoDebugMetadataVersion | Diagnostic information for debug metadata version reporting |
| CDiagnosticInfoIgnoringInvalidDebugMetadata | Diagnostic information for stripping invalid debug metadata |
| CDiagnosticInfoInlineAsm | Diagnostic information for inline asm reporting |
| CDiagnosticInfoIROptimization | Common features for diagnostics dealing with optimization remarks that are used by IR passes |
| CDiagnosticInfoISelFallback | Diagnostic information for ISel fallback path |
| ►CDiagnosticInfoMIROptimization | Common features for diagnostics dealing with optimization remarks that are used by machine passes |
| CMachineArgument | MI-specific kinds of diagnostic Arguments |
| CDiagnosticInfoMIRParser | Diagnostic information for machine IR parser |
| ►CDiagnosticInfoOptimizationBase | Common features for diagnostics dealing with optimization remarks that are used by both IR and MIR passes |
| CArgument | Used in the streaming interface as the general argument type |
| CsetExtraArgs | 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) |
| CsetIsVerbose | Used to set IsVerbose via the stream interface |
| CDiagnosticInfoOptimizationFailure | Diagnostic information for optimization failures |
| CDiagnosticInfoPGOProfile | Diagnostic information for the PGO profiler |
| CDiagnosticInfoResourceLimit | Diagnostic information for stack size etc |
| CDiagnosticInfoSampleProfile | Diagnostic information for the sample profiler |
| CDiagnosticInfoStackSize | |
| CDiagnosticInfoUnsupported | Diagnostic information for unsupported feature in backend |
| CDiagnosticInfoWithLocationBase | Common features for diagnostics with an associated location |
| CDiagnosticLocation | |
| CDiagnosticPredicate | |
| CDiagnosticPrinter | Interface for custom diagnostic printing |
| CDiagnosticPrinterRawOStream | Basic diagnostic printer that uses an underlying raw_ostream |
| CDIBasicType | Basic type, like 'int' or 'float' |
| CDIBuilder | |
| CDICompileUnit | Compile unit |
| CDICompositeType | Composite types |
| CDIContext | |
| CDIDerivedType | Derived types |
| CDIDumpOptions | Container for dump options that control which debug information will be dumped |
| CDIE | A structured debug information entry |
| CDIEAbbrev | Dwarf abbreviation, describes the organization of a debug information object |
| CDIEAbbrevData | Dwarf abbreviation data, describes one attribute of a Dwarf abbreviation |
| CDIEAbbrevSet | Helps unique DIEAbbrev objects and assigns abbreviation numbers |
| CDIEBlock | DIEBlock - Represents a block of values |
| CDIEDelta | A simple label difference DIE |
| CDIEDwarfExpression | DwarfExpression implementation for singular DW_AT_location |
| CDIEEntry | A pointer to another debug information entry |
| CDIEExpr | An expression DIE |
| CDIEHash | An object containing the capability of hashing and adding hash attributes onto a DIE |
| CDIEInlineString | A container for inline string values |
| CDIEInteger | An integer value DIE |
| CDIELabel | A label DIE |
| CDIELoc | DIELoc - Represents an expression location |
| CDIELocList | Represents a pointer to a location list in the debug_loc section |
| CDIEnumerator | Enumeration value |
| CDIEString | A container for string pool string values |
| CDIEUnit | Represents a compile or type unit |
| CDIEValue | |
| ►CDIEValueList | A list of DIE values |
| Cconst_value_iterator | |
| Cvalue_iterator | |
| ►CDIExpression | DWARF expression |
| Cexpr_op_iterator | An iterator for expression operands |
| CExprOperand | A lightweight wrapper around an expression operand |
| CFragmentInfo | Holds the characteristics of one fragment of a larger variable |
| CDIExpressionCursor | Holds a DIExpression and keeps track of how many operands have been consumed so far |
| ►CDIFile | File |
| CChecksumInfo | A single checksum, represented by a Kind and a Value (a string) |
| CDIGlobal | Container for description of a global variable |
| CDIGlobalVariable | Global variables |
| CDIGlobalVariableExpression | A pair of DIGlobalVariable and DIExpression |
| CDIImportedEntity | An imported module (C++ using directive or similar) |
| CDIInliningInfo | A format-neutral container for inlined code description |
| CDILabel | Label |
| CDILexicalBlock | |
| CDILexicalBlockBase | |
| CDILexicalBlockFile | |
| CDILineInfo | A format-neutral container for source line information |
| CDILineInfoSpecifier | Controls which fields of DILineInfo container should be filled with data |
| CDILocalScope | A scope for locals |
| CDILocalVariable | Local variable |
| CDILocation | Debug location |
| CDIMacro | |
| CDIMacroFile | |
| CDIMacroNode | Macro Info DWARF-like metadata node |
| CDIModule | A (clang) module that has been imported by the compile unit |
| CDINamespace | |
| CDINode | Tagged DWARF-like metadata node |
| CDIObjCProperty | |
| CDIScope | Base class for scope-like contexts |
| CDistinctMDOperandPlaceholder | Placeholder metadata for operands of distinct MDNodes |
| CDISubprogram | Subprogram description |
| CDISubrange | Array subrange |
| CDISubroutineType | Type array for a subprogram |
| CDITemplateParameter | Base class for template parameters |
| CDITemplateTypeParameter | |
| CDITemplateValueParameter | |
| CDIType | Base class for types |
| ►CDITypeRefArray | |
| Citerator | |
| CDIVariable | Base class for variables |
| CDivergenceAnalysis | Generic divergence analysis for reducible CFGs |
| CDivergencePropagator | |
| CDivRemMapKey | |
| CDivRemPairsPass | Hoist/decompose integer division and remainder instructions to enable CFG improvements and better codegen |
| CDomainValue | A DomainValue is a bit like LiveIntervals' ValNo, but it also keeps track of execution domains |
| CDominanceFrontier | |
| CDominanceFrontierAnalysis | Analysis pass which computes a DominanceFrontier |
| CDominanceFrontierBase | DominanceFrontierBase - Common base class for computing forward and inverse dominance frontiers for a function |
| CDominanceFrontierPrinterPass | Printer pass for the DominanceFrontier |
| CDominanceFrontierWrapperPass | |
| CDominatorTree | Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree |
| CDominatorTreeAnalysis | Analysis pass which computes a DominatorTree |
| CDominatorTreeBase | Core dominator tree base class |
| CDominatorTreePrinterPass | Printer pass for the DominatorTree |
| CDominatorTreeVerifierPass | Verifier pass for the DominatorTree |
| CDominatorTreeWrapperPass | Legacy analysis pass which computes a DominatorTree |
| CDomTreeGraphTraitsBase | |
| CDomTreeNodeBase | Base class for the actual dominator tree node |
| CDomTreeUpdater | |
| CDoNothingMemorySSAWalker | A MemorySSAWalker that does no alias queries, or anything else |
| CDOTGraphTraits | DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot' graphs |
| CDOTGraphTraits< BlockFrequencyInfo * > | |
| CDOTGraphTraits< BoUpSLP * > | |
| CDOTGraphTraits< CallGraph * > | |
| CDOTGraphTraits< const Function * > | |
| CDOTGraphTraits< const MachineFunction * > | |
| CDOTGraphTraits< DominatorTree * > | |
| CDOTGraphTraits< DomTreeNode * > | |
| CDOTGraphTraits< MachineBlockFrequencyInfo * > | |
| CDOTGraphTraits< PGOUseFunc * > | |
| CDOTGraphTraits< PostDominatorTree * > | |
| CDOTGraphTraits< RegionInfo * > | |
| CDOTGraphTraits< RegionNode * > | |
| CDOTGraphTraits< ScheduleDAG * > | |
| CDOTGraphTraits< ScheduleDAGMI * > | |
| CDOTGraphTraits< SelectionDAG * > | |
| CDOTGraphTraitsModulePrinter | |
| CDOTGraphTraitsModuleViewer | |
| CDOTGraphTraitsPrinter | |
| CDOTGraphTraitsViewer | |
| CDSEPass | This class implements a trivial dead store elimination |
| CDstOp | |
| CDummyCGSCCPass | This pass is required by interprocedural register allocation |
| CDuplexCandidate | |
| CDWARF5AccelTableData | The Data class implementation for DWARF v5 accelerator table |
| CDWARF5AccelTableStaticData | |
| ►CDWARFAbbreviationDeclaration | |
| CAttributeSpec | |
| CDWARFAbbreviationDeclarationSet | |
| ►CDWARFAcceleratorTable | The accelerator tables are designed to allow efficient random access (using a symbol name as a key) into debug info by providing an index of the debug info DIEs |
| CEntry | An abstract class representing a single entry in the accelerator tables |
| CDWARFAddressRange | |
| CDWARFAttribute | Encapsulates a DWARF attribute value and all of the data required to describe the attribute value |
| CDwarfCFIException | |
| CDwarfCFIExceptionBase | |
| ►CDwarfCompileUnit | |
| CGlobalExpr | A pair of GlobalVariable and DIExpression |
| CDWARFCompileUnit | |
| ►CDWARFContext | DWARFContext This data structure is the top level entity that deals with dwarf debug information parsing |
| CDIEsForAddress | Wraps the returned DIEs for a given address |
| CDWARFDataExtractor | A DataExtractor (typically for an in-memory copy of an object-file section) plus a relocation map for that section, if there is one |
| CDwarfDebug | Collects and handles dwarf debug information |
| CDWARFDebugAbbrev | |
| ►CDWARFDebugAddrTable | A class representing an address table as specified in DWARF v5 |
| CHeader | |
| CDWARFDebugAranges | |
| ►CDWARFDebugArangeSet | |
| CDescriptor | |
| CHeader | |
| CDWARFDebugFrame | A parsed .debug_frame or .eh_frame section |
| CDWARFDebugInfoEntry | DWARFDebugInfoEntry - A DIE with only the minimum required data |
| ►CDWARFDebugLine | |
| CContentTypeTracker | Tracks which optional content types are present in a DWARF file name entry format |
| CFileNameEntry | |
| CLineTable | |
| CPrologue | |
| CRow | Standard .debug_line state machine structure |
| CSectionParser | Helper to allow for parsing of an entire .debug_line section in sequence |
| CSequence | Represents a series of contiguous machine instructions |
| ►CDWARFDebugLoc | |
| CEntry | A single location within a location list |
| CLocationList | A list of locations that contain one variable |
| ►CDWARFDebugLoclists | |
| CEntry | |
| CLocationList | |
| CDWARFDebugMacro | |
| ►CDWARFDebugNames | .debug_names section consists of one or more units |
| CAbbrev | Abbreviation describing the encoding of Name Index entries |
| CAttributeEncoding | Index attribute and its encoding |
| CEntry | DWARF v5-specific implementation of an Accelerator Entry |
| CHeader | Dwarf 5 Name Index header |
| CNameIndex | Represents a single accelerator table within the Dwarf 5 .debug_names section |
| CNameIterator | |
| CNameTableEntry | A single entry in the Name Table (Dwarf 5 sect |
| CSentinelError | Error returned by NameIndex::getEntry to report it has reached the end of the entry list |
| CValueIterator | |
| ►CDWARFDebugPubTable | Represents structure for holding and parsing .debug_pub* tables |
| CEntry | |
| CSet | Each table consists of sets of variable length entries |
| ►CDWARFDebugRangeList | |
| CRangeListEntry | |
| CDWARFDebugRnglist | A class representing a single rangelist |
| CDWARFDebugRnglistTable | |
| ►CDWARFDie | Utility class that carries the DWARF compile/type unit and the debug info entry in an object |
| Cattribute_iterator | |
| Citerator | |
| ►CDWARFExpression | |
| Citerator | An iterator to go through the expression operations |
| ►COperation | This class represents an Operation in the Expression |
| CDescription | Description of the encoding of one expression Op |
| ►CDwarfExpression | Base class containing the logic for constructing DWARF expressions independently of whether they are emitted into a DIE or into a .debug_loc entry |
| CRegister | Holds information about all subregisters comprising a register location |
| CDwarfFile | |
| CDWARFFormValue | |
| CDWARFGdbIndex | |
| CDWARFListEntryBase | A base class for DWARF list entries, such as range or location list entries |
| CDWARFListTableBase | A class representing a table of lists as specified in the DWARF v5 standard for location lists and range lists |
| CDWARFListTableHeader | A class representing the header of a list table such as the range list table in the .debug_rnglists section |
| CDWARFListType | A base class for lists of entries that are extracted from a particular section, such as range lists or location lists |
| CDWARFObject | |
| CDWARFSection | |
| CDwarfStringPool | |
| CDwarfStringPoolEntry | Data for a string pool entry |
| CDwarfStringPoolEntryRef | String pool entry reference |
| CDWARFTypeUnit | |
| CDwarfTypeUnit | |
| CDWARFUnit | |
| CDwarfUnit | This dwarf writer support class manages information associated with a source file |
| CDWARFUnitHeader | Base class describing the header of any kind of "unit." Some information is specific to certain unit types |
| ►CDWARFUnitIndex | |
| ►CEntry | |
| CSectionContribution | |
| CDWARFUnitVector | Describe a collection of units |
| ►CDWARFVerifier | A class that verifies DWARF debug information given a DWARF Context |
| CDieRangeInfo | A class that keeps the address range information for a single DIE |
| Cearly_inc_iterator_impl | A pseudo-iterator adaptor that is designed to implement "early increment" style loops |
| CEarlyCSEPass | A simple and fast domtree-based CSE pass |
| CECError | This class wraps a std::error_code in a Error |
| CEdgeBundles | |
| CEfficiencySanitizerOptions | |
| ►CEHStreamer | Emits exception handling directives |
| CActionEntry | Structure describing an entry in the actions table |
| CCallSiteEntry | Structure describing an entry in the call-site table |
| CPadRange | Structure holding a try-range and the associated landing pad |
| CELFRelocationEntry | |
| CEliminateAvailableExternallyPass | A pass that transforms external global definitions into declarations |
| CEngineBuilder | Builder class for ExecutionEngines |
| CEntryExitInstrumenterPass | |
| CEnumAttributeImpl | |
| CEnumEntry | |
| Cequal | A functor like C++14's std::equal<void> in its absence |
| ►CEquivalenceClasses | 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 |
| Cmember_iterator | |
| CError | Lightweight error class with error context and mandatory checking |
| CErrorAsOutParameter | Helper for Errors used as out-parameters |
| CErrorHandlerTraits | Helper for testing applicability of, and applying, handlers for ErrorInfo types |
| CErrorHandlerTraits< Error(&)(ErrT &)> | |
| CErrorHandlerTraits< Error(&)(std::unique_ptr< ErrT >)> | Specialization for functions of the form 'Error (std::unique_ptr<ErrT>)' |
| CErrorHandlerTraits< RetT(C::*)(const ErrT &) const > | |
| CErrorHandlerTraits< RetT(C::*)(const ErrT &)> | |
| CErrorHandlerTraits< RetT(C::*)(ErrT &) const > | |
| CErrorHandlerTraits< RetT(C::*)(ErrT &)> | |
| CErrorHandlerTraits< RetT(C::*)(std::unique_ptr< ErrT >) const > | Specialization for member functions of the form 'RetT (std::unique_ptr<ErrT>) const' |
| CErrorHandlerTraits< RetT(C::*)(std::unique_ptr< ErrT >)> | Specialization for member functions of the form 'RetT (std::unique_ptr<ErrT>)' |
| CErrorHandlerTraits< void(&)(ErrT &)> | |
| CErrorHandlerTraits< void(&)(std::unique_ptr< ErrT >)> | Specialization for functions of the form 'void (std::unique_ptr<ErrT>)' |
| CErrorInfo | Base class for user error types |
| CErrorInfoBase | Base class for error info classes |
| CErrorList | Special ErrorInfo subclass representing a list of ErrorInfos |
| CErrorOr | Represents either an error or a value T |
| CErrorSuccess | Subclass of Error for the sole purpose of identifying the success path in the type system |
| CEscapeEnumerator | EscapeEnumerator - This is a little algorithm to find all escape points from a function so that "finally"-style code can be inserted |
| CEvaluator | This class evaluates LLVM IR, producing the Constant representing each SSA instruction |
| ►CEVT | Extended Value Type |
| CcompareRawBits | A meaningless but well-behaved order, useful for constructing containers |
| CExactEqualsExpression | |
| CExecutionContext | |
| CExecutionDomainFix | |
| CExecutionEngine | Abstract interface for implementation execution of LLVM modules, designed to support both interpreter and just-in-time (JIT) compiler implementations |
| CExecutionEngineState | Helper class for helping synchronize access to the global address map table |
| CExitLimitQuery | |
| CExitOnError | Helper for check-and-exit error handling |
| CExpandReductionsPass | |
| CExpected | Tagged union holding either a T or a Error |
| CExpectedAsOutParameter | Helper for Expected<T>s used as out-parameters |
| CExternalAAWrapperPass | A wrapper pass for external alias analyses |
| CExternalSymbolPseudoSourceValue | A specialized pseudo source value for holding external symbol values |
| CExternalSymbolSDNode | |
| CExtractElementConstantExpr | ExtractElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement extractelement constant exprs |
| CExtractElementInst | This instruction extracts a single (scalar) element from a VectorType value |
| CExtractValueConstantExpr | ExtractValueConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement extractvalue constant exprs |
| CExtractValueInst | This instruction extracts a struct member or array element value from an aggregate value |
| CFastFoldingSetNode | 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 |
| ►CFastISel | 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 |
| CCallLoweringInfo | |
| CSavePoint | |
| CFastMathFlags | Convenience struct for specifying and reasoning about fast-math flags |
| ►CFaultMapParser | A parser for the __llvm_faultmaps section generated by the FaultMaps class above |
| CFunctionFaultInfoAccessor | |
| CFunctionInfoAccessor | |
| CFaultMaps | |
| CFCmpInst | This instruction compares its operands according to the predicate given to the constructor |
| CFeatureBitset | Container class for subtarget features |
| CFenceInst | An instruction for ordering other memory operations |
| CFieldInit | X.Y - Represent a reference to a subfield of a variable |
| Cfile_magic | File_magic - An "enum class" enumeration of file types based on magic (the first N bytes of the file) |
| CFileBufferByteStream | An implementation of WritableBinaryStream backed by an llvm FileOutputBuffer |
| CFileCheck | FileCheck class takes the request and exposes various methods that use information from the request |
| CFileCheckDiag | Summary of a FileCheck diagnostic |
| CFileCheckPattern | |
| CFileCheckRequest | Contains info about various FileCheck options |
| CFileCheckString | A check that we found in the input file |
| CFileError | This class wraps a filename and another Error |
| CFileHandleTraits | |
| ►CFileInfo | |
| CGCOVCoverage | |
| CLineData | |
| CFileOutputBuffer | FileOutputBuffer - This interface provides simple way to create an in-memory buffer which will be written to a file |
| CFileRemover | FileRemover - This class is a simple object meant to be stack allocated |
| Cfilter_iterator_base | An iterator adaptor that filters the elements of given inner iterators |
| Cfilter_iterator_impl | Specialization of filter_iterator_base for forward iteration only |
| Cfilter_iterator_impl< WrappedIteratorT, PredicateT, std::bidirectional_iterator_tag > | Specialization of filter_iterator_base for bidirectional iteration |
| CFilteredPassNameParser | ===-------------------------------------------------------------------—===// 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 |
| CFindHandleTraits | |
| CFixAllFDIVSQRT | |
| CFixedNumOperandTraits | 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 |
| CFixedStackPseudoSourceValue | A specialized PseudoSourceValue for holding FixedStack values, which must include a frame index |
| CFixedStreamArray | FixedStreamArray is similar to VarStreamArray, except with each record having a fixed-length |
| CFixedStreamArrayIterator | |
| CFlagsOp | |
| CFlatIt | Marker class to iterate over the elements of a Region in flat mode |
| CFloat2IntPass | |
| CfltSemantics | |
| CFmtAlign | |
| CFoldingSet | FoldingSet - This template class is used to instantiate a specialized implementation of the folding set to the node class T |
| ►CFoldingSetBase | FoldingSetBase - Implements the folding set functionality |
| CNode | Node - This class is used to maintain the singly linked bucket list in a folding set |
| CFoldingSetBucketIterator | |
| CFoldingSetBucketIteratorImpl | 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 |
| CFoldingSetImpl | FoldingSetImpl - An implementation detail that lets us share code between FoldingSet and ContextualFoldingSet |
| CFoldingSetIterator | |
| CFoldingSetIteratorImpl | FoldingSetIteratorImpl - This is the common iterator support shared by all folding sets, which knows how to walk the folding set hash table |
| CFoldingSetNodeID | FoldingSetNodeID - This class is used to gather all the unique data bits of a node |
| CFoldingSetNodeIDRef | 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 |
| CFoldingSetNodeWrapper | FoldingSetNodeWrapper - This template class is used to "wrap" arbitrary types in an enclosing object so that they can be inserted into FoldingSets |
| CFoldingSetTrait | FoldingSetTrait - This trait class is used to define behavior of how to "profile" (in the FoldingSet parlance) an object of a given type |
| CFoldingSetTrait< SCEV > | |
| CFoldingSetTrait< SCEVPredicate > | |
| CFoldingSetTrait< SDVTListNode > | Specialize FoldingSetTrait for SDVTListNode to avoid computing temp FoldingSetNodeID and hash value |
| CFoldingSetTrait< std::pair< T1, T2 > > | |
| CFoldingSetTrait< T * > | |
| CFoldingSetVector | 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 |
| CFoldOpInit | !foldl (a, b, expr, start, lst) - Fold over a list |
| CForceFunctionAttrsPass | Pass which forces specific function attributes into the IR, primarily as a debugging tool |
| CForeachLoop | ForeachLoop - Record the iteration state associated with a for loop |
| Cformat_object | |
| Cformat_object_base | This is a helper class used for handling formatted output |
| Cformat_provider | |
| Cformat_provider< bool > | Implementation of format_provider<T> for type bool |
| Cformat_provider< codeview::GloballyHashedType > | |
| Cformat_provider< codeview::GUID > | |
| Cformat_provider< codeview::LocallyHashedType > | |
| Cformat_provider< codeview::TypeIndex > | |
| Cformat_provider< Enum, typename std::enable_if< dwarf::EnumTraits< Enum >::value >::type > | Dwarf constants format_provider |
| Cformat_provider< llvm::iterator_range< IterT > > | Implementation of format_provider<T> for ranges |
| Cformat_provider< llvm::json::Value > | Allow printing json::Value with formatv() |
| Cformat_provider< pdb::PdbRaw_ImplVer > | |
| Cformat_provider< std::chrono::duration< Rep, Period > > | |
| Cformat_provider< sys::TimePoint<> > | Format provider for TimePoint<> |
| Cformat_provider< T, typename std::enable_if< detail::use_char_formatter< T >::value >::type > | Implementation of format_provider<T> for characters |
| Cformat_provider< T, typename std::enable_if< detail::use_double_formatter< T >::value >::type > | Implementation of format_provider<T> for floating point types |
| Cformat_provider< T, typename std::enable_if< detail::use_integral_formatter< T >::value >::type > | Implementation of format_provider<T> for integral arithmetic types |
| Cformat_provider< T, typename std::enable_if< detail::use_pointer_formatter< T >::value >::type > | Implementation of format_provider<T> for integral pointer types |
| Cformat_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 |
| Cformat_provider< Twine > | Implementation of format_provider<T> for llvm::Twine |
| CFormatAdapter | |
| Cformatted_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 |
| CFormattedBytes | |
| CFormattedNumber | This is a helper class used for format_hex() and format_decimal() |
| CFormattedString | This is a helper class for left_justify, right_justify, and center_justify |
| Cformatv_object | |
| ►Cformatv_object_base | |
| Ccreate_adapters | |
| CFortifiedLibCallSimplifier | 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 |
| CForwardDominanceFrontierBase | DominanceFrontier Class - Concrete subclass of DominanceFrontierBase that is used to compute a forward dominator frontiers |
| CForwardedRegister | Describes a register that needs to be forwarded from the prologue to a musttail call |
| CFPExtInst | This class represents an extension of floating point types |
| CFPMathOperator | Utility class for floating point operations which can have information about relaxed accuracy requirements attached to them |
| CFPPassManager | FPPassManager manages BBPassManagers and FunctionPasses |
| CFPToSIInst | This class represents a cast from floating point to signed integer |
| CFPToUIInst | This class represents a cast from floating point to unsigned integer |
| CFPTruncInst | This class represents a truncation of floating point types |
| CFrameIndexSDNode | |
| CFreeDeleter | |
| CFullDependence | FullDependence - This class represents a dependence between two memory references in a function |
| CFuncletPadInst | |
| ►CFunction | |
| CProfileCount | Class to represent profile counts |
| Cfunction_ref | An efficient, type-erasing, non-owning reference to a callable |
| Cfunction_ref< Ret(Params...)> | |
| ►CFunctionAnalysisManagerCGSCCProxy | A proxy from a FunctionAnalysisManager to an SCC |
| CResult | |
| CFunctionComparator | FunctionComparator - Compares two functions to determine whether or not they will generate machine code with the same behaviour |
| ►CFunctionImporter | The function importer is automatically importing function from other modules based on the provided summary informations |
| CImportFailureInfo | Information optionally tracked for candidates the importer decided not to import |
| CFunctionImportGlobalProcessing | Class to handle necessary GlobalValue changes required by ThinLTO function importing, including linkage changes and any necessary renaming |
| CFunctionImportPass | The function importing pass |
| ►CFunctionLoweringInfo | FunctionLoweringInfo - This contains information that is global to a function that is used when lowering a region of the function |
| CLiveOutInfo | |
| CStatepointSpillMap | Keep track of frame indices allocated for statepoints as they could be used across basic block boundaries |
| CFunctionPass | FunctionPass class - This class is used to implement most global optimizations |
| CFunctionPointerLikeTypeTraits | Provide suitable custom traits struct for function pointers |
| ►CFunctionSummary | Function summary information to aid decisions and implementation of importing |
| CConstVCall | A specification for a virtual function call with all constant integer arguments |
| CFFlags | Flags specific to function summaries |
| CTypeIdInfo | All type identifier related information |
| CVFuncId | An "identifier" for a virtual function |
| CFunctionToLoopPassAdaptor | Adaptor that maps from a function to its loops |
| CFunctionType | Class to represent function types |
| ►CFunctionTypeKeyInfo | |
| CKeyTy | |
| CGCFunctionInfo | Garbage collection metadata for a single function |
| CGCMetadataPrinter | GCMetadataPrinter - Emits GC metadata as assembly code |
| CGCModuleInfo | An analysis pass which caches information about the entire Module |
| CGCNDownwardRPTracker | |
| CGCNHazardRecognizer | |
| ►CGCNIterativeScheduler | |
| CBuildDAG | |
| COverrideLegacyStrategy | |
| CRegion | |
| CTentativeSchedule | |
| CGCNMaxOccupancySchedStrategy | This is a minimal scheduler strategy |
| CGCNRegPressure | |
| CGCNRPTracker | |
| CGCNScheduleDAGMILive | |
| CGCNSubtarget | |
| CGCNTargetMachine | |
| CGCNTTIImpl | |
| CGCNUpwardRPTracker | |
| CGCOVBlock | GCOVBlock - Collects block information |
| CGCOVBuffer | GCOVBuffer - A wrapper around MemoryBuffer to provide GCOV specific read operations |
| CGCOVEdge | GCOVEdge - Collects edge information |
| CGCOVFile | GCOVFile - Collects coverage information for one pair of coverage file (.gcno and .gcda) |
| CGCOVFunction | GCOVFunction - Collects function information |
| CGCOVOptions | |
| CGCOVProfilerPass | The gcov-style instrumentation pass |
| CGCPoint | GCPoint - Metadata for a collector-safe point in machine code |
| CGCProjectionInst | Common base class for representing values projected from a statepoint |
| CGCRelocateInst | Represents calls to the gc.relocate intrinsic |
| CGCResultInst | Represents calls to the gc.result intrinsic |
| CGCRoot | GCRoot - Metadata for a pointer to an object managed by the garbage collector |
| CGCStrategy | GCStrategy describes a garbage collector algorithm's code generation requirements, and provides overridable hooks for those needs which cannot be abstractly described |
| Cgeneric_gep_type_iterator | |
| CGenericDINode | Generic tagged DWARF-like metadata node |
| CGenericScheduler | GenericScheduler shrinks the unscheduled zone using heuristics to balance the schedule |
| ►CGenericSchedulerBase | Base class for GenericScheduler |
| CCandPolicy | Policy for scheduling the next instruction in the candidate's zone |
| CSchedCandidate | Store the state used by GenericScheduler heuristics, required for the lifetime of one invocation of pickNode() |
| CSchedResourceDelta | Status of an instruction's critical resource consumption |
| ►CGenericValue | |
| CIntPair | |
| CGEPOperator | |
| CGetElementPtrConstantExpr | GetElementPtrConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement getelementpr constant exprs |
| CGetElementPtrInst | Instruction for type-safe pointer arithmetic to access elements of arrays and structs |
| CGISelChangeObserver | Abstract class that contains various methods for clients to notify about changes |
| CGISelCSEAnalysisWrapper | Simple wrapper that does the following |
| CGISelCSEAnalysisWrapperPass | The actual analysis pass wrapper |
| CGISelCSEInfo | The CSE Analysis object |
| CGISelInstProfileBuilder | |
| CGISelObserverWrapper | Simple wrapper observer that takes several observers, and calls each one for each event |
| CGISelWorkList | |
| CGlobalAddressSDNode | |
| CGlobalAlias | |
| CGlobalDCEPass | Pass to remove unused function declarations |
| CGlobalIFunc | |
| CGlobalIndirectSymbol | |
| CGlobalNumberState | GlobalNumberState assigns an integer to each global value in the program, which is used by the comparison routine to order references to globals |
| CGlobalObject | |
| CGlobalOptPass | Optimize globals that never have their address taken |
| CGlobalsAA | Analysis pass providing a never-invalidated alias analysis result |
| ►CGlobalsAAResult | An alias analysis result set for globals |
| CFunctionInfo | The mod/ref information collected for a particular function |
| CGlobalsAAWrapperPass | Legacy wrapper pass to provide the GlobalsAAResult object |
| CGlobalSplitPass | Pass to perform split of global variables |
| CGlobalStatus | As we analyze each global, keep track of some information about it |
| CGlobalValue | |
| CGlobalValuePseudoSourceValue | A specialized pseudo soruce value for holding GlobalValue values |
| ►CGlobalValueSummary | Function and variable summary information to aid decisions and implementation of importing |
| CGVFlags | Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield |
| ►CGlobalValueSummaryInfo | |
| CNameOrGV | |
| CGlobalVariable | |
| ►CGlobalVarSummary | Global variable summary information to aid decisions and implementation of importing |
| CGVarFlags | |
| CGlobPattern | |
| CGPUDivergenceAnalysis | Divergence analysis frontend for GPU kernels |
| CGraphDiff | |
| ►CGraphTraits | |
| CChildIteratorType | Add the VectorizableTree to the index iterator to be able to return TreeEntry pointers |
| CGraphTraits< ArgumentGraph * > | |
| CGraphTraits< ArgumentGraphNode * > | |
| CGraphTraits< BasicBlock * > | |
| CGraphTraits< BlockFrequencyInfo * > | |
| CGraphTraits< BoUpSLP * > | |
| CGraphTraits< CallGraph * > | |
| CGraphTraits< CallGraphNode * > | |
| CGraphTraits< const BasicBlock * > | |
| CGraphTraits< const CallGraph * > | |
| CGraphTraits< const CallGraphNode * > | |
| CGraphTraits< const DomTreeNode * > | |
| CGraphTraits< const Function * > | |
| CGraphTraits< const Loop * > | |
| CGraphTraits< const MachineBasicBlock * > | |
| CGraphTraits< const MachineDomTreeNode * > | |
| CGraphTraits< const MachineFunction * > | |
| CGraphTraits< const MachineLoop * > | |
| CGraphTraits< const Type * > | |
| CGraphTraits< const VPBlockBase * > | |
| CGraphTraits< const VPDomTreeNode * > | |
| CGraphTraits< const VPRegionBlock * > | |
| CGraphTraits< DominatorTree * > | |
| CGraphTraits< DomTreeNode * > | |
| CGraphTraits< Function * > | |
| CGraphTraits< Interval * > | |
| CGraphTraits< Inverse< BasicBlock * > > | |
| CGraphTraits< Inverse< const BasicBlock * > > | |
| CGraphTraits< Inverse< const Function * > > | |
| CGraphTraits< Inverse< const MachineBasicBlock * > > | |
| CGraphTraits< Inverse< const MachineFunction * > > | |
| CGraphTraits< Inverse< Function * > > | |
| CGraphTraits< Inverse< Interval * > > | |
| CGraphTraits< Inverse< Inverse< T > > > | |
| CGraphTraits< Inverse< MachineBasicBlock * > > | |
| CGraphTraits< Inverse< MachineFunction * > > | |
| CGraphTraits< Inverse< MemoryAccess * > > | |
| CGraphTraits< Inverse< VPBlockBase * > > | |
| CGraphTraits< Inverse< VPRegionBlock * > > | |
| CGraphTraits< IrreducibleGraph > | |
| CGraphTraits< LazyCallGraph * > | |
| CGraphTraits< LazyCallGraph::Node * > | |
| CGraphTraits< Loop * > | |
| CGraphTraits< MachineBasicBlock * > | |
| CGraphTraits< MachineBlockFrequencyInfo * > | |
| CGraphTraits< MachineDominatorTree * > | |
| CGraphTraits< MachineDomTreeNode * > | |
| CGraphTraits< MachineFunction * > | |
| CGraphTraits< MachineLoop * > | |
| CGraphTraits< MachineRegionInfo * > | |
| CGraphTraits< MachineRegionInfoPass * > | |
| CGraphTraits< MemoryAccess * > | GraphTraits for a MemoryAccess, which walks defs in the normal case, and uses in the inverse case |
| CGraphTraits< ModuleSummaryIndex * > | |
| CGraphTraits< PGOUseFunc * > | |
| CGraphTraits< PostDominatorTree * > | |
| CGraphTraits< RegionInfo * > | |
| CGraphTraits< RegionInfoPass * > | |
| CGraphTraits< ScheduleDAG * > | |
| CGraphTraits< ScheduleDAGMI * > | |
| CGraphTraits< SDNode * > | |
| CGraphTraits< SelectionDAG * > | |
| CGraphTraits< std::pair< const GraphDiff< BasicBlock *, false > *, BasicBlock * > > | |
| CGraphTraits< std::pair< const GraphDiff< BasicBlock *, false > *, Inverse< BasicBlock * > > > | |
| CGraphTraits< std::pair< const GraphDiff< BasicBlock *, true > *, BasicBlock * > > | |
| CGraphTraits< std::pair< const GraphDiff< BasicBlock *, true > *, Inverse< BasicBlock * > > > | |
| CGraphTraits< SUnit * > | |
| CGraphTraits< Type * > | |
| CGraphTraits< ValueInfo > | GraphTraits definition to build SCC for the index |
| CGraphTraits< VPBlockBase * > | |
| CGraphTraits< VPDomTreeNode * > | Template specializations of GraphTraits for VPDomTreeNode |
| CGraphTraits< VPRegionBlock * > | |
| CGraphWriter | |
| Cgreater_ptr | |
| CGuardWideningPass | |
| CGVMaterializer | |
| ►CGVN | The core GVN pass object |
| CExpression | |
| CValueTable | This class holds the mapping between values and value numbers |
| CGVNHoist | |
| CGVNHoistLegacyPass | |
| CGVNHoistPass | A simple and fast domtree-based GVN pass to hoist common expressions from sibling branches |
| CGVNSinkPass | Uses an "inverted" value numbering to decide the similarity of expressions and sinks similar expressions into successors |
| CHandleSDNode | This class is used to form a handle around another node that is persistent and is updated across invocations of replaceAllUsesWith on its operand |
| Chas_rbegin | Metafunction to determine if T& or T has a member called rbegin() |
| Chas_rbegin_impl | Helper to determine if type T has a member called rbegin() |
| Chash_code | An opaque object representing a hash code |
| CHashingByteStreamer | |
| CHasReferenceResolver | Do not resolve anything, but keep track of whether a given variable was referenced |
| CHexagonAsmPrinter | |
| ►CHexagonBlockRanges | |
| CIndexRange | |
| CIndexType | |
| CInstrIndexMap | |
| CPrintRangeMap | |
| CRangeList | |
| CRegisterRef | |
| CHexagonCVIResource | |
| CHexagonDAGToDAGISel | |
| CHexagonEvaluator | |
| CHexagonFrameLowering | |
| CHexagonHazardRecognizer | |
| CHexagonInstPrinter | 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 |
| CHexagonInstr | |
| CHexagonInstrInfo | |
| CHexagonMachineFunctionInfo | Hexagon target-specific information for each MachineFunction |
| CHexagonMCAsmInfo | |
| CHexagonMCChecker | Check for a valid bundle |
| CHexagonMCCodeEmitter | |
| CHexagonMCELFStreamer | |
| CHexagonMCExpr | |
| CHexagonMCShuffler | |
| CHexagonPacketizerList | |
| CHexagonRegisterInfo | |
| CHexagonResource | |
| CHexagonSelectionDAGInfo | |
| CHexagonShuffler | |
| ►CHexagonSubtarget | |
| CBankConflictMutation | |
| CCallMutation | |
| CHVXMemLatencyMutation | |
| CUsrOverflowMutation | |
| CHexagonTargetLowering | |
| CHexagonTargetMachine | |
| CHexagonTargetObjectFile | |
| CHexagonTargetStreamer | |
| CHexagonTTIImpl | |
| CHexNumber | |
| CHotColdSplittingPass | Pass to outline cold regions |
| CHungoffOperandTraits | 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 |
| CHvxSelector | |
| CICallPromotionAnalysis | |
| CICFLoopSafetyInfo | This implementation of LoopSafetyInfo use ImplicitControlFlowTracking to give precise answers on "may throw" queries |
| CICmpInst | This instruction compares its operands according to the predicate given to the constructor |
| CIdentifyingPassPtr | Discriminated union of Pass ID types |
| Cidentity | |
| Cidf_ext_iterator | |
| Cidf_iterator | |
| CIDFCalculator | Determine the iterated dominance frontier, given a set of defining blocks, and optionally, a set of live-in blocks |
| CIdx2MBBCompare | |
| Cilist_alloc_traits | Use delete by default for iplist and ilist |
| Cilist_alloc_traits< IndexListEntry > | |
| Cilist_alloc_traits< Instruction > | |
| Cilist_alloc_traits< MachineBasicBlock > | |
| Cilist_alloc_traits< MCFragment > | |
| Cilist_alloc_traits< MemoryAccess > | |
| Cilist_alloc_traits< SDNode > | |
| Cilist_base | Implementations of list algorithms using ilist_node_base |
| Cilist_callback_traits | Callbacks do nothing by default in iplist and ilist |
| Cilist_callback_traits< MachineBasicBlock > | |
| Cilist_iterator | Iterator for intrusive lists based on ilist_node |
| Cilist_noalloc_traits | Custom traits to do nothing on deletion |
| Cilist_node | |
| Cilist_node_base | Base class for ilist nodes |
| Cilist_node_base< false > | |
| Cilist_node_base< true > | |
| Cilist_node_impl | Implementation for an ilist node |
| Cilist_node_traits | A fragment for template traits for intrusive list that provides default node related operations |
| Cilist_node_with_parent | An ilist node that can access its parent list |
| Cilist_sentinel | |
| Cilist_sentinel_tracking | Option to choose whether to track sentinels |
| Cilist_tag | Option to specify a tag for the node type |
| Cilist_traits | Template traits for intrusive list |
| Cilist_traits< const Ty > | Const traits should never be instantiated |
| Cilist_traits< MachineInstr > | |
| CILPValue | Represent the ILP of the subDAG rooted at a DAG node |
| CImmInstrInfo | |
| CImmutableCallSite | Establish a view to a call site for examination |
| ►CImmutableList | ImmutableList - This class represents an immutable (functional) list |
| Citerator | |
| CImmutableListFactory | |
| CImmutableListImpl | |
| ►CImmutableMap | |
| CFactory | |
| Citerator | |
| ►CImmutableMapRef | |
| Citerator | |
| CImmutablePass | ImmutablePass class - This class is used to provide information that does not need to be run |
| ►CImmutableSet | |
| CFactory | |
| CImmutableSetRef | |
| CImmutableStatepoint | A specialization of it's base class for read only access to a gc.statepoint |
| CImplicitControlFlowTracking | This class allows to keep track on instructions with implicit control flow |
| CImportedFunctionsInliningStatistics | Calculate and dump ThinLTO specific inliner stats |
| CImutAVLFactory | |
| CImutAVLTree | |
| CImutAVLTreeGenericIterator | |
| CImutAVLTreeInOrderIterator | |
| CImutAVLValueIterator | Generic iterator that wraps a T::TreeTy::iterator and exposes iterator::getValue() on dereference |
| CImutContainerInfo | 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 |
| CImutContainerInfo< T * > | ImutContainerInfo - Specialization for pointer values to treat pointers as references to unique objects |
| CImutIntervalAVLFactory | |
| CImutKeyValueInfo | ImutKeyValueInfo -Traits class used by ImmutableMap |
| CImutProfileInfo | Generic profile template |
| CImutProfileInfo< bool > | Profile traits for booleans |
| CImutProfileInfo< T * > | Generic profile trait for pointer types |
| CImutProfileInteger | Profile traits for integers |
| Cindex_sequence | Alias for the common case of a sequence of size_ts |
| Cindex_sequence_for | Creates a compile-time integer sequence for a parameter pack |
| CIndexedInstrProfReader | Reader for the indexed binary instrprof format |
| CIndexedMap | |
| CIndexListEntry | This class represents an entry in the slot index list held in the SlotIndexes pass |
| ►CIndirectBrInst | Indirect Branch Instruction |
| Cconst_succ_op_iterator | The const version of succ_op_iterator |
| Csucc_op_iterator | Iterator type that casts an operand to a basic block |
| CIndirectSymbolData | |
| CInductionDescriptor | A struct for saving information about induction variables |
| CIndVarSimplifyPass | |
| CInferFunctionAttrsPass | A pass which infers function attributes from the names and signatures of function declarations in a module |
| CInit | |
| CInitLLVM | |
| CInjectorIRStrategy | Strategy that injects operations into the function |
| ►CInlineAsm | |
| CConstraintInfo | |
| CSubConstraintInfo | |
| ►CInlineAsmIdentifierInfo | |
| CEnumIdentifier | |
| CLabelIdentifier | |
| CVariableIdentifier | |
| CInlineAsmKeyType | |
| CInlineCost | Represents the cost of inlining a function |
| CInlineFunctionInfo | This class captures the data input to the InlineFunction call, and records the auxiliary results produced by it |
| CInlineParams | Thresholds to tune inline cost analysis |
| CInlineResult | InlineResult is basically true or false |
| CInlinerPass | The inliner pass for the new pass manager |
| ►CInnerAnalysisManagerProxy | An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR unit |
| CResult | |
| CInnerLoopUnroller | |
| CInnerLoopVectorizer | InnerLoopVectorizer vectorizes loops which contain only one basic block to a specified vectorization factor (VF) |
| CInsertElementConstantExpr | InsertElementConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement insertelement constant exprs |
| CInsertElementInst | This instruction inserts a single (scalar) element into a VectorType value |
| CInsertNOPLoad | |
| CInsertPointAnalysis | Determines the latest safe point in a block in which we can insert a split, spill or other instruction related with CurLI |
| CInsertValueConstantExpr | InsertValueConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement insertvalue constant exprs |
| CInsertValueInst | This instruction inserts a struct field of array element value into an aggregate value |
| CInsnInfo | |
| CInstCombinePass | |
| CInstCombiner | The core instruction combiner logic |
| CInstCombineWorklist | InstCombineWorklist - This is the worklist management logic for InstCombine |
| CInstDeleterIRStrategy | |
| CInstIterator | |
| CInstrAspect | Legalization is decided based on an instruction's opcode, which type slot we're considering, and what the existing type is |
| CInstrEmitter | |
| CInstrInfoQuery | InstrInfoQuery provides an interface to query additional information for instructions like metadata or keywords like nsw, which provides conservative results if the users specified it is safe to use |
| CInstrItinerary | An itinerary represents the scheduling information for an instruction |
| CInstrItineraryData | Itinerary data supplied by a subtarget to be used by a target |
| CInstrProfError | |
| CInstrProfiling | Instrumentation based profiling lowering pass |
| CInstrProfIncrementInst | This represents the llvm.instrprof_increment intrinsic |
| CInstrProfIncrementInstStep | |
| CInstrProfIterator | A file format agnostic iterator over profiling data |
| CInstrProfLookupTrait | Trait for lookups into the on-disk hash table for the binary instrprof format |
| CInstrProfOptions | Options for the frontend instrumentation based profiling pass |
| CInstrProfReader | Base class and interface for reading profiling data of any known instrprof format |
| CInstrProfReaderIndex | |
| CInstrProfReaderIndexBase | |
| CInstrProfReaderItaniumRemapper | A remapper that applies remappings based on a symbol remapping file |
| CInstrProfReaderRemapper | Name matcher supporting fuzzy matching of symbol names to names in profiles |
| CInstrProfRecord | Profiling information for a single function |
| CInstrProfRecordWriterTrait | |
| CInstrProfSummaryBuilder | |
| CInstrProfSymtab | A symbol table used for function PGO name look-up with keys (such as pointers, md5hash values) to the function |
| CInstrProfValueProfileInst | This represents the llvm.instrprof_value_profile intrinsic |
| CInstrProfValueSiteRecord | |
| CInstrProfWriter | |
| CInstrStage | These values represent a non-pipelined step in the execution of an instruction |
| CInstruction | |
| CInstructionCombiningPass | The legacy pass manager's instcombine pass |
| CInstructionPrecedenceTracking | |
| CInstructionSelect | This pass is responsible for selecting generic machine instructions to target-specific instructions |
| ►CInstructionSelector | Provides the logic to select generic machine instructions |
| CISelInfoTy | |
| CMatcherState | |
| CInstSimplifyPass | Run instruction simplification across each instruction in the function |
| CInstVisitor | Base class for instruction visitors |
| CIntAttributeImpl | |
| Cinteger_sequence | Represents a compile-time sequence of integers |
| CIntegerType | Class to represent integer types |
| CIntelExpr | |
| CIntelJITEventsWrapper | |
| CIntEqClasses | |
| ►CInterferenceCache | |
| CCursor | Cursor - The primary query interface for the block interference cache |
| CInterleavedAccessInfo | Drive the analysis of interleaved memory accesses in the loop |
| CInterleaveGroup | The group of interleaved loads/stores sharing the same stride and close to each other |
| CInternalizePass | A pass that internalizes all functions and variables other than those that must be preserved according to MustPreserveGV |
| CInterpreter | |
| CInterval | 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) |
| CIntervalIterator | |
| ►CIntervalMap | |
| Cconst_iterator | |
| Citerator | |
| CIntervalMapHalfOpenInfo | |
| CIntervalMapInfo | |
| CIntervalMapInfo< SlotIndex > | |
| CIntervalMapOverlaps | IntervalMapOverlaps - Iterate over the overlaps of mapped intervals in two IntervalMaps |
| CIntervalPartition | |
| CIntervalPressure | RegisterPressure computed within a region of instructions delimited by TopIdx and BottomIdx |
| CIntInit | '7' - Represent an initialization by a literal integer value |
| CIntRecTy | 'int' - Represent an integer value of no particular size |
| CIntrinsicData | |
| CIntrinsicInst | A wrapper class for inspecting calls to intrinsic functions |
| CIntrinsicLowering | |
| ►CIntrusiveBackList | |
| Cconst_iterator | |
| Citerator | |
| CIntrusiveBackListBase | |
| CIntrusiveBackListNode | |
| CIntrusiveRefCntPtr | A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCountedBase |
| CIntrusiveRefCntPtrInfo | Class you can specialize to provide custom retain/release functionality for a type |
| CIntToPtrInst | This class represents a cast from an integer to a pointer |
| CInvalidateAllAnalysesPass | A utility pass that does nothing, but preserves no analyses |
| CInvalidateAnalysisPass | A no-op pass template which simply forces a specific analysis result to be invalidated |
| CInverse | |
| CInvokeInst | Invoke instruction |
| Ciplist | An intrusive list with ownership and callbacks specified/controlled by ilist_traits, only with API safe for polymorphic types |
| Ciplist_impl | A wrapper around an intrusive list with callbacks and non-intrusive ownership |
| Cipo_ext_iterator | |
| Cipo_iterator | |
| CIPSCCPPass | Pass to perform interprocedural constant propagation |
| CIRBuilder | 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 |
| ►CIRBuilderBase | Common base class shared among various IRBuilders |
| CFastMathFlagGuard | |
| CInsertPoint | InsertPoint - A saved insertion point |
| CInsertPointGuard | |
| CIRBuilderCallbackInserter | Provides an 'InsertHelper' that calls a user-provided callback after performing the default insertion |
| CIRBuilderDefaultInserter | 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 |
| CIRCEPass | |
| ►CIRMover | |
| CIdentifiedStructTypeSet | |
| CIRMutationStrategy | Base class for describing how to mutate a module |
| CIRMutator | Entry point for configuring and running IR mutations |
| CIRTranslator | |
| ►Cis_bitmask_enum | Traits class to determine whether an enum has a LLVM_BITMASK_LARGEST_ENUMERATOR enumerator |
| Ctype | |
| Cis_integral_or_enum | Metafunction that determines whether the given type is either an integral type or an enumeration type, including enum classes |
| Cis_one_of | Traits class for checking whether type T is one of any of the given types in the variadic list |
| Cis_one_of< T, U, Ts... > | |
| Cis_simple_type | |
| Cis_trivially_copy_constructible | An implementation of std::is_trivially_copy_constructible since we have users with STLs that don't yet include it |
| Cis_trivially_copy_constructible< T & > | |
| Cis_trivially_copy_constructible< T && > | |
| Cis_trivially_move_constructible | An implementation of std::is_trivially_move_constructible since we have users with STLs that don't yet include it |
| Cis_trivially_move_constructible< T & > | |
| Cis_trivially_move_constructible< T && > | |
| Cisa_impl | |
| Cisa_impl< Argument, Value > | |
| Cisa_impl< BasicBlock, Value > | |
| Cisa_impl< Constant, Value > | |
| Cisa_impl< ConstantAggregate, Value > | |
| Cisa_impl< ConstantData, Value > | |
| Cisa_impl< Function, Value > | |
| Cisa_impl< GlobalAlias, Value > | |
| Cisa_impl< GlobalIFunc, Value > | |
| Cisa_impl< GlobalIndirectSymbol, Value > | |
| Cisa_impl< GlobalObject, Value > | |
| Cisa_impl< GlobalValue, Value > | |
| Cisa_impl< GlobalVariable, Value > | |
| Cisa_impl< InlineAsm, Value > | |
| Cisa_impl< Instruction, Value > | |
| Cisa_impl< PointerType, Type > | |
| Cisa_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 |
| Cisa_impl_cl | |
| Cisa_impl_cl< To, const From * > | |
| Cisa_impl_cl< To, const From *const > | |
| Cisa_impl_cl< To, const From > | |
| Cisa_impl_cl< To, const std::unique_ptr< From > > | |
| Cisa_impl_cl< To, From * > | |
| Cisa_impl_cl< To, From *const > | |
| Cisa_impl_wrap | |
| Cisa_impl_wrap< To, FromTy, FromTy > | |
| CIsAOpInit | !isa<type>(expr) - Dynamically determine the type of an expression |
| CisPodLike | 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 |
| CisPodLike< ArrayRef< T > > | |
| CisPodLike< AssertingVH< T > > | |
| CisPodLike< bfi_detail::BlockMass > | |
| CisPodLike< BitCodeAbbrevOp > | |
| CisPodLike< IdentifyingPassPtr > | |
| CisPodLike< ImmutableList< T > > | |
| CisPodLike< MCOperand > | |
| CisPodLike< Optional< T > > | |
| CisPodLike< PointerIntPair< PointerTy, IntBits, IntType > > | |
| CisPodLike< PoisoningVH< T > > | |
| CisPodLike< PressureChange > | |
| CisPodLike< ScaledNumber< T > > | |
| CisPodLike< SDep > | |
| CisPodLike< SDValue > | |
| CisPodLike< Slice > | |
| CisPodLike< SlotIndex > | |
| CisPodLike< std::pair< T, U > > | |
| CisPodLike< StringRef > | |
| CisPodLike< SuccIterator< T, U > > | |
| ►CItaniumManglingCanonicalizer | Canonicalizer for mangled names |
| CImpl | |
| CItaniumPartialDemangler | "Partial" demangler |
| Citerator_adaptor_base | CRTP base class for adapting an iterator to a different type |
| ►Citerator_facade_base | CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of the interface |
| CReferenceProxy | A proxy object for computing a reference via indirecting a copy of an iterator |
| Citerator_range | A range adaptor for a pair of iterators |
| CIVStrideUse | IVStrideUse - Keep track of one use of a strided induction variable |
| CIVUsers | |
| CIVUsersAnalysis | Analysis pass that exposes the IVUsers for a loop |
| CIVUsersPrinterPass | Printer pass for the IVUsers for a loop |
| CIVUsersWrapperPass | |
| CIVVisitor | Interface for visiting interesting IV users that are recognized but not simplified by this utility |
| CJamCRC | |
| CJITEvaluatedSymbol | Represents a symbol that has been evaluated to an address already |
| CJITEventListener | JITEventListener - Abstract interface for use by the JIT to notify clients about significant events during compilation |
| CJITSymbol | Represents a symbol in the JIT |
| CJITSymbolFlags | Flags for symbols in the JIT |
| CJITSymbolResolver | Symbol resolution interface |
| CJobHandleTraits | |
| CJumpTableSDNode | |
| CJumpThreadingPass | This pass performs 'jump threading', which looks at blocks that have multiple predecessors and multiple successors |
| CKnownBits | |
| CLabelSDNode | |
| CLanaiDisassembler | |
| CLanaiFrameLowering | |
| CLanaiInstPrinter | |
| CLanaiInstrInfo | |
| CLanaiMachineFunctionInfo | |
| CLanaiMCAsmInfo | |
| CLanaiMCExpr | |
| CLanaiMCInstLower | |
| CLanaiRegisterInfo | |
| CLanaiSelectionDAGInfo | |
| CLanaiSubtarget | |
| CLanaiTargetLowering | |
| CLanaiTargetMachine | |
| CLanaiTargetObjectFile | |
| CLanaiTTIImpl | |
| CLandingPadInfo | This structure is used to retain landing pad info for the current function |
| CLandingPadInst | The landingpad instruction holds all of the information necessary to generate correct exception handling |
| CLaneBitmask | |
| Clatency_sort | Sorting functions for the Available queue |
| CLatencyPriorityQueue | |
| CLatticeKeyInfo | A template for translating between LLVM Values and LatticeKeys |
| CLatticeKeyInfo< CVPLatticeKey > | A specialization of LatticeKeyInfo for CVPLatticeKeys |
| CLayoutAlignElem | Layout alignment element |
| CLazyBlockFrequencyInfo | Wraps a BFI to allow lazy computation of the block frequencies |
| CLazyBlockFrequencyInfoPass | This is an alternative analysis pass to BlockFrequencyInfoWrapperPass |
| CLazyBranchProbabilityInfoPass | This is an alternative analysis pass to BranchProbabilityInfoWrapperPass |
| ►CLazyCallGraph | A lazily constructed view of the call graph of a module |
| CEdge | A class used to represent edges in the call graph |
| ►CEdgeSequence | The edge sequence object |
| Ccall_iterator | An iterator over specifically call edges |
| Citerator | An iterator used for the edges to both entry nodes and child nodes |
| CNode | A node in the call graph |
| Cpostorder_ref_scc_iterator | A post-order depth-first RefSCC iterator over the call graph |
| CRefSCC | A RefSCC of the call graph |
| CSCC | An SCC of the call graph |
| CLazyCallGraphAnalysis | An analysis pass which computes the call graph for a module |
| CLazyCallGraphDOTPrinterPass | A pass which prints the call graph as a DOT file to a raw_ostream |
| CLazyCallGraphPrinterPass | A pass which prints the call graph to a raw_ostream |
| CLazyMachineBlockFrequencyInfoPass | This is an alternative analysis pass to MachineBlockFrequencyInfo |
| CLazyValueAnalysis | Analysis to compute lazy value information |
| CLazyValueInfo | This pass computes, caches, and vends lazy value constraint information |
| CLazyValueInfoWrapperPass | Wrapper around LazyValueInfo |
| CLCSSAPass | Converts loops into loop-closed SSA form |
| CLCSSAVerificationPass | |
| CLegacyAARGetter | This class is a functor to be used in legacy module or SCC passes for computing AA results for a function |
| CLegacyDivergenceAnalysis | |
| CLegacyInlinerBase | This class contains all of the helper code which is used to perform the inlining operations that do not depend on the policy |
| CLegacyJITSymbolResolver | Legacy symbol resolution interface |
| ►CLegalityQuery | The LegalityQuery object bundles together all the information that's needed to decide whether a given operation is legal or not |
| CMemDesc | |
| CLegalizationArtifactCombiner | |
| CLegalizeActionStep | The result of a query |
| CLegalizer | |
| CLegalizerHelper | |
| CLegalizerInfo | |
| CLegalizeRule | A single rule in a legalizer info ruleset |
| CLegalizeRuleSet | |
| CLEONMachineFunctionPass | |
| Cless | A functor like C++14's std::less<void> in its absence |
| Cless_first | Function object to check whether the first component of a std::pair compares less than the first component of another std::pair |
| Cless_ptr | |
| Cless_second | Function object to check whether the second component of a std::pair compares less than the second component of another std::pair |
| CLessRecord | Sorting predicate to sort record pointers by name |
| CLessRecordByID | Sorting predicate to sort record pointers by their unique ID |
| CLessRecordFieldName | Sorting predicate to sort record pointers by their name field |
| ►CLessRecordRegister | |
| CRecordParts | |
| CLetRecord | |
| CLexicalScope | LexicalScope - This class is used to track scope information |
| CLexicalScopes | LexicalScopes - This class provides interface to collect and use lexical scoping information from machine instruction |
| CLibCallSimplifier | LibCallSimplifier - This class implements a collection of optimizations that replace well formed calls to library functions with a more optimal form |
| CLibCallsShrinkWrapPass | |
| CLICMPass | Performs Loop Invariant Code Motion Pass |
| Cline_iterator | A forward iterator which reads text lines from a buffer |
| ►CLineEditor | |
| CCompletion | A possible completion at a given cursor position |
| CCompletionAction | The action to perform upon a completion request |
| CInternalData | |
| CLinkDiagnosticInfo | |
| CLinker | This class provides the core functionality of linking in LLVM |
| CLinkingSymbolResolver | |
| CListInit | [AL, AH, CL] - Represent a list of defs |
| CListRecTy | 'list<Ty>' - Represent a list of values, all of which must be of the specified type |
| CLiveDebugVariables | |
| ►CLiveInterval | LiveInterval - This class represents the liveness of a register, or stack slot |
| CSingleLinkedListIterator | |
| CSubRange | A live range for subregisters |
| ►CLiveIntervals | |
| CHMEditor | Toolkit used by handleMove to trim or extend live intervals |
| ►CLiveIntervalUnion | Union of live intervals that are strong candidates for coalescing into a single register (either physical or virtual depending on the context) |
| CArray | |
| CQuery | Query interferences between a single live virtual register and a live interval union |
| CLivePhysRegs | A set of physical registers with utility functions to track liveness when walking backward/forward through a basic block |
| CLiveQueryResult | Result of a LiveRange query |
| ►CLiveRange | This class represents the liveness of a register, stack slot, etc |
| CSegment | This represents a simple continuous liveness interval for a value |
| CLiveRangeCalc | |
| ►CLiveRangeEdit | |
| CDelegate | Callback methods for LiveRangeEdit owners |
| CRemat | Remat - Information needed to rematerialize at a specific location |
| CLiveRangeUpdater | Helper class for performant LiveRange bulk updates |
| CLiveRegMatrix | |
| CLiveRegSet | A set of live virtual registers and physical register units |
| CLiveRegUnit | |
| CLiveRegUnits | A set of register units used to track register liveness |
| CLiveStacks | |
| ►CLiveVariables | |
| CVarInfo | VarInfo - This represents the regions where a virtual register is live in the program |
| CLLLexer | |
| CLLParser | |
| CLLT | |
| Cllvm_shutdown_obj | Llvm_shutdown_obj - This is a simple helper class that calls llvm_shutdown() when it is destroyed |
| CLLVMContext | This is an important class for using LLVM in a threaded context |
| CLLVMContextImpl | |
| CLLVMDisasmContext | |
| CLLVMTargetMachine | This class describes a target machine that is implemented with the LLVM target-independent code generator |
| CLoadAndStorePromoter | Helper class for promoting a collection of loads and stores into SSA Form using the SSAUpdater |
| CLoadedObjectInfo | 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 |
| CLoadedObjectInfoHelper | |
| CLoadImmediateInfo | |
| CLoadInfo | |
| CLoadInst | An instruction for reading from memory |
| CLoadSDNode | This class is used to represent ISD::LOAD nodes |
| CLoadStoreVectorizerPass | |
| CLocalAsMetadata | |
| CLocalizer | This pass implements the localization mechanism described at the top of this file |
| CLocationSize | |
| CLockFileManager | Class that manages the creation of a lock file to aid implicit coordination between different processes |
| ►CLoop | Represents a single loop in the control flow graph |
| CLocRange | A range representing the start and end location of a loop |
| CLoopAccessAnalysis | This analysis provides dependence information for the memory accesses of a loop |
| CLoopAccessInfo | Drive the analysis of memory accesses in the loop |
| CLoopAccessInfoPrinterPass | Printer pass for the LoopAccessInfo results |
| CLoopAccessLegacyAnalysis | This analysis provides dependence information for the memory accesses of a loop |
| CLoopAnalysis | Analysis pass that exposes the LoopInfo for a function |
| CLoopBase | Instances of this class are used to represent loops that are detected in the flow graph |
| CLoopBlocksDFS | Store the result of a depth first search within basic blocks contained by a single loop |
| CLoopBlocksRPO | Wrapper class to LoopBlocksDFS that provides a standard begin()/end() interface for the DFS reverse post-order traversal of blocks in a loop body |
| CLoopBlocksTraversal | Traverse the blocks in a loop using a depth-first search |
| ►CLoopBodyTraits | |
| CLoopBodyFilter | |
| CWrappedSuccIterator | |
| CLoopDataPrefetchPass | An optimization pass inserting data prefetches in loops |
| CLoopDeletionPass | |
| CLoopDistributePass | |
| CLoopFullUnrollPass | Loop unroll pass that only does full loop unrolling |
| CLoopIdiomRecognizePass | Performs Loop Idiom Recognize Pass |
| CLoopInfo | |
| CLoopInfoBase | This class builds and contains all of the top-level loop structures in the specified function |
| CLoopInfoWrapperPass | The legacy pass manager's analysis pass to compute loop information |
| CLoopInstSimplifyPass | Performs Loop Inst Simplify Pass |
| CLoopLoadEliminationPass | Pass to forward loads in a loop around the backedge to subsequent iterations |
| CLoopPass | |
| CLoopPredicationPass | Performs Loop Predication Pass |
| CLoopPrinterPass | Printer pass for the LoopAnalysis results |
| CLoopRotatePass | A simple loop rotation transformation |
| CLoopSafetyInfo | Captures loop safety information |
| CLoopSimplifyCFGPass | Performs basic CFG simplifications to assist other loop passes |
| CLoopSimplifyPass | This pass is responsible for loop canonicalization |
| CLoopSinkPass | A pass that does profile-guided sinking of instructions into loops |
| CLoopStandardAnalysisResults | The adaptor from a function pass to a loop pass computes these analyses and makes them available to the loop passes "for free" |
| CLoopStrengthReducePass | Performs Loop Strength Reduce Pass |
| ►CLoopTraversal | This class provides the basic blocks traversal order used by passes like ReachingDefAnalysis and ExecutionDomainFix |
| CTraversedMBBInfo | |
| CLoopUnrollAndJamPass | A simple loop rotation transformation |
| CLoopUnrollOptions | A set of parameters used to control various transforms performed by the LoopUnroll pass |
| CLoopUnrollPass | Loop unroll pass that will support both full and partial unrolling |
| ►CLoopVectorizationCostModel | LoopVectorizationCostModel - estimates the expected speedups due to vectorization |
| CRegisterUsage | A struct that represents some properties of the register usage of a loop |
| CLoopVectorizationLegality | LoopVectorizationLegality checks if it is legal to vectorize a loop, and to what vectorization factor |
| CLoopVectorizationPlanner | Planner drives the vectorization process after having passed Legality checks |
| CLoopVectorizationRequirements | This holds vectorization requirements that must be verified late in the process |
| CLoopVectorizeHints | Utility class for getting and setting loop vectorizer hints in the form of loop metadata |
| CLoopVectorizePass | The LoopVectorize Pass |
| CLoopVerifierPass | Verifier pass for the LoopAnalysis results |
| CLoopVersioning | This class emits a version of the loop where run-time checks ensure that may-alias pointers can't overlap |
| CLowerAtomicPass | A pass that lowers atomic intrinsic into non-atomic intrinsics |
| CLowerExpectIntrinsicPass | |
| CLowerGuardIntrinsicPass | |
| CLowerInvokePass | |
| CLowerTypeTestsPass | |
| CLPMUpdater | This class provides an interface for updating the loop pass manager based on mutations to the loop nest |
| CLPPassManager | |
| CLSBaseSDNode | Base class for LoadSDNode and StoreSDNode |
| CLShrOperator | |
| CLTOCodeGenerator | C++ class which implements the opaque lto_code_gen_t type |
| CLTOModule | C++ class which implements the opaque lto_module_t type |
| ►CMachineBasicBlock | |
| CRegisterMaskPair | Pair of physical register and lane mask |
| CMachineBlockFrequencyInfo | MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic block frequencies |
| CMachineBranchProbabilityInfo | |
| CMachineConstantPool | Keeps track of constants referenced by a function which must be spilled to memory |
| CMachineConstantPoolEntry | This class is a data container for one entry in a MachineConstantPool |
| CMachineConstantPoolValue | Abstract base class for all machine specific constantpool value subclasses |
| CMachineDominanceFrontier | |
| CMachineDominatorTree | DominatorTree Class - Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree |
| CMachineDomTreeGraphTraitsBase | DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterators |
| CMachineFrameInfo | Abstract stack frame until prolog/epilog code is inserted |
| ►CMachineFunction | |
| CDelegate | |
| CVariableDbgInfo | |
| CMachineFunctionInfo | MachineFunctionInfo - This class can be derived from and used by targets to hold private target-specific information for each MachineFunction |
| CMachineFunctionPass | MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of passes that operate on the MachineFunction representation |
| CMachineFunctionProperties | Properties which a MachineFunction may have at a given point in time |
| CMachineInstr | Representation of each machine instruction |
| CMachineInstrBuilder | |
| CMachineInstrBundleIterator | MachineBasicBlock iterator that automatically skips over MIs that are inside bundles (i.e |
| CMachineInstrBundleIteratorHelper | |
| CMachineInstrBundleIteratorHelper< false > | |
| CMachineInstrBundleIteratorHelper< true > | |
| CMachineInstrBundleIteratorTraits | |
| CMachineInstrBundleIteratorTraits< const T, false > | |
| CMachineInstrBundleIteratorTraits< const T, true > | |
| CMachineInstrBundleIteratorTraits< T, false > | |
| CMachineInstrBundleIteratorTraits< T, true > | |
| CMachineInstrExpressionTrait | Special DenseMapInfo traits to compare MachineInstr* by value of the instruction rather than by pointer value |
| CMachineInstrSpan | 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 |
| CMachineIRBuilder | Helper class to build MachineInstr |
| CMachineIRBuilderState | Class which stores all the state required in a MachineIRBuilder |
| CMachineJumpTableEntry | MachineJumpTableEntry - One jump table in the jump table info |
| CMachineJumpTableInfo | |
| CMachineLocation | |
| CMachineLoop | |
| CMachineLoopInfo | |
| CMachineMemOperand | A description of a memory reference used in the backend |
| CMachineModuleInfo | This class contains meta information specific to a module |
| CMachineModuleInfoCOFF | MachineModuleInfoCOFF - This is a MachineModuleInfoImpl implementation for COFF targets |
| CMachineModuleInfoELF | MachineModuleInfoELF - This is a MachineModuleInfoImpl implementation for ELF targets |
| CMachineModuleInfoImpl | This class can be derived from and used by targets to hold private target-specific information for each Module |
| CMachineModuleInfoMachO | MachineModuleInfoMachO - This is a MachineModuleInfoImpl implementation for MachO targets |
| CMachineOperand | MachineOperand class - Representation of each machine instruction operand |
| ►CMachineOperandIteratorBase | MachineOperandIteratorBase - Iterator that can visit all operands on a MachineInstr, or all operands on a bundle of MachineInstrs |
| CPhysRegInfo | Information about how a physical register Reg is used by a set of operands |
| CVirtRegInfo | VirtRegInfo - Information about a virtual register used by a set of operands |
| CMachineOptimizationRemark | Diagnostic information for applied optimization remarks |
| CMachineOptimizationRemarkAnalysis | Diagnostic information for optimization analysis remarks |
| CMachineOptimizationRemarkEmitter | The optimization diagnostic interface |
| CMachineOptimizationRemarkEmitterPass | The analysis pass |
| CMachineOptimizationRemarkMissed | Diagnostic information for missed-optimization remarks |
| CMachinePassRegistry | MachinePassRegistry - Track the registration of machine passes |
| CMachinePassRegistryListener | MachinePassRegistryListener - Listener to adds and removals of nodes in registration list |
| CMachinePassRegistryNode | MachinePassRegistryNode - Machine pass node stored in registration list |
| ►CMachinePipeliner | The main class in the implementation of the target independent software pipeliner pass |
| CLoopInfo | Cache the target analysis information about the loop |
| CMachinePointerInfo | 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 |
| CMachinePostDominatorTree | PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominator tree |
| CMachineRegion | |
| CMachineRegionInfo | |
| CMachineRegionInfoPass | |
| CMachineRegionNode | |
| ►CMachineRegisterInfo | MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc |
| Cdefusechain_instr_iterator | Defusechain_iterator - This class provides iterator support for machine operands in the function that use or define a specific register |
| Cdefusechain_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 |
| CDelegate | |
| CMachineSchedContext | MachineSchedContext provides enough context from the MachineScheduler pass for the target to instantiate a scheduler |
| CMachineSchedPolicy | Define a generic scheduling policy for targets that don't provide their own MachineSchedStrategy |
| CMachineSchedRegistry | MachineSchedRegistry provides a selection of available machine instruction schedulers |
| CMachineSchedStrategy | MachineSchedStrategy - Interface to the scheduling algorithm used by ScheduleDAGMI |
| CMachineSDNode | An SDNode that represents everything that will be needed to construct a MachineInstr |
| CMachineSSAUpdater | MachineSSAUpdater - This class updates SSA form for a set of virtual registers defined in multiple blocks |
| ►CMachineTraceMetrics | |
| CEnsemble | A trace ensemble is a collection of traces selected using the same strategy, for example 'minimum resource height' |
| CFixedBlockInfo | Per-basic block information that doesn't depend on the trace through the block |
| CInstrCycles | InstrCycles represents the cycle height and depth of an instruction in a trace |
| CLiveInReg | A virtual register or regunit required by a basic block or its trace successors |
| CTrace | A trace represents a plausible sequence of executed basic blocks that passes through the current basic block one |
| CTraceBlockInfo | Per-basic block information that relates to a specific trace through the block |
| CMachObjectWriter | |
| CMachORelocation | MachORelocation - This struct contains information about each relocation that needs to be emitted to the file |
| Cmake_const_ptr | |
| Cmake_const_ref | |
| CMakeGuardsExplicitPass | |
| CMallocAllocator | |
| CManagedStatic | 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 |
| CManagedStaticBase | ManagedStaticBase - Common base class for ManagedStatic instances |
| CManagedStringPool | 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 |
| CMangler | |
| Cmapped_iterator | |
| CMapResolver | Resolve arbitrary mappings |
| CMapVector | This class implements a map that also provides access to all stored values in a deterministic order |
| CMaskedGatherScatterSDNode | This is a base class used to represent MGATHER and MSCATTER nodes |
| CMaskedGatherSDNode | This class is used to represent an MGATHER node |
| CMaskedLoadSDNode | This class is used to represent an MLOAD node |
| CMaskedLoadStoreSDNode | This base class is used to represent MLOAD and MSTORE nodes |
| CMaskedScatterSDNode | This class is used to represent an MSCATTER node |
| CMaskedStoreSDNode | This class is used to represent an MSTORE node |
| CMaskedTruncSStoreSDNode | |
| CMaskedTruncUSStoreSDNode | |
| CMaximumSpanningTree | MaximumSpanningTree - A MST implementation |
| CMBB2NumberFunctor | |
| CMCAlignFragment | |
| CMCAsmBackend | Generic interface to target specific assembler backends |
| CMCAsmInfo | This class is intended to be used as a base class for asm properties and features specific to the target |
| CMCAsmInfoCOFF | |
| CMCAsmInfoDarwin | |
| CMCAsmInfoELF | |
| CMCAsmInfoGNUCOFF | |
| CMCAsmInfoMicrosoft | |
| CMCAsmInfoWasm | |
| CMCAsmLayout | Encapsulates the layout of an assembly file at a particular point in time |
| CMCAsmLexer | Generic assembler lexer interface, for use by target specific assembly lexers |
| CMCAsmMacro | |
| CMCAsmMacroParameter | |
| ►CMCAsmParser | Generic assembler parser interface, for use by target specific assembly parsers |
| CMCPendingError | |
| CMCAsmParserExtension | Generic interface for extending the MCAsmParser, which is implemented by target and object file assembly parser implementations |
| CMCAsmParserSemaCallback | Generic Sema callback for assembly parser |
| ►CMCAssembler | |
| CCGProfileEntry | |
| CMCBinaryExpr | Binary assembler expressions |
| CMCCFIInstruction | |
| CMCCodeEmitter | MCCodeEmitter - Generic instruction encoding interface |
| CMCCodePadder | Target-independent base class incharge of all code padding decisions for a target |
| CMCCodePaddingContext | |
| CMCCodePaddingPolicy | The base class for all padding policies, i.e |
| CMCCompactEncodedInstFragment | This is a compact (memory-size-wise) fragment for holding an encoded instruction (non-relaxable) that has no fixups registered |
| CMCConstantExpr | |
| CMCContext | Context object for machine code objects |
| CMCCVDefRangeFragment | Fragment representing the .cv_def_range directive |
| ►CMCCVFunctionInfo | Information describing a function or inlined call site introduced by .cv_func_id or .cv_inline_site_id |
| CLineInfo | |
| CMCCVInlineLineTableFragment | Fragment representing the binary annotations produced by the .cv_inline_linetable directive |
| CMCCVLoc | Instances of this class represent the information from a .cv_loc directive |
| CMCDataFragment | Fragment for data and encoded instructions |
| CMCDisassembler | Superclass for all disassemblers |
| CMCDummyFragment | |
| CMCDwarfCallFrameFragment | |
| CMCDwarfDwoLineTable | |
| CMCDwarfFile | 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) |
| CMCDwarfFrameEmitter | |
| CMCDwarfFrameInfo | |
| CMCDwarfLineAddr | |
| CMCDwarfLineAddrFragment | |
| CMCDwarfLineEntry | Instances of this class represent the line information for the dwarf line table entries |
| CMCDwarfLineStr | Manage the .debug_line_str section contents, if we use it |
| CMCDwarfLineTable | |
| CMCDwarfLineTableHeader | |
| CMCDwarfLineTableParams | |
| CMCDwarfLoc | Instances of this class represent the information from a dwarf .loc directive |
| CMCELFObjectTargetWriter | |
| CMCELFStreamer | |
| CMCEncodedFragment | Interface implemented by fragments that contain encoded instructions and/or data |
| CMCEncodedFragmentWithContents | Interface implemented by fragments that contain encoded instructions and/or data |
| CMCEncodedFragmentWithFixups | Interface implemented by fragments that contain encoded instructions and/or data and also have fixups registered |
| CMCExpr | Base class for the full range of assembler expressions which are needed for parsing |
| CMCExternalSymbolizer | Symbolize using user-provided, C API, callbacks |
| CMCExtraProcessorInfo | Provide extra details about the machine processor |
| CMCFillFragment | |
| CMCFixup | Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction) which requires assemble- or run- time patching |
| CMCFixupKindInfo | Target independent information on a fixup kind |
| CMCFragment | |
| CMCGenDwarfInfo | |
| CMCGenDwarfLabelEntry | |
| CMCInst | Instances of this class represent a single low-level machine instruction |
| CMCInstBuilder | |
| CMCInstPrinter | This is an instance of a target assembly language printer that converts an MCInst to valid target assembly syntax |
| CMCInstrAnalysis | |
| CMCInstrDesc | Describe properties that are true of each instruction in the target description file |
| CMCInstrInfo | Interface to description of machine instruction set |
| CMCJIT | |
| CMCJITMemoryManager | |
| CMCLabel | Instances of this class represent a label name in the MC file, and MCLabel are created and uniqued by the MCContext class |
| CMCLEBFragment | |
| CMCLineSection | Instances of this class represent the line information for a compile unit where machine instructions have been assembled after seeing .loc directives |
| CMCLOHContainer | |
| CMCLOHDirective | Store Linker Optimization Hint information (LOH) |
| CMCMachObjectTargetWriter | |
| CMCObjectFileInfo | |
| CMCObjectStreamer | Streaming object file generation interface |
| CMCObjectTargetWriter | Base class for classes that define behaviour that is specific to both the target and the object format |
| CMCObjectWriter | Defines the object file and target independent interfaces used by the assembler backend to write native file format object files |
| CMCOperand | Instances of this class represent operands of the MCInst class |
| CMCOperandInfo | This holds information about one operand of a machine instruction, indicating the register class for register operands, etc |
| CMCOrgFragment | |
| CMCPaddingFragment | Fragment for adding required padding |
| CMCParsedAsmOperand | MCParsedAsmOperand - This abstract class represents a source-level assembly instruction operand |
| CMCProcResourceDesc | Define a kind of processor resource that will be modeled by the scheduler |
| CMCReadAdvanceEntry | Specify the number of cycles allowed after instruction issue before a particular use operand reads its registers |
| CMCRegAliasIterator | MCRegAliasIterator enumerates all registers aliasing Reg |
| CMCRegisterClass | MCRegisterClass - Base class of TargetRegisterClass |
| CMCRegisterCostEntry | Specify the cost of a register definition in terms of number of physical register allocated at register renaming stage |
| CMCRegisterDesc | MCRegisterDesc - This record contains information about a particular register |
| CMCRegisterFileDesc | A register file descriptor |
| ►CMCRegisterInfo | 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 |
| CDiffListIterator | DiffListIterator - Base iterator class that can traverse the differentially encoded register and regunit lists in DiffLists |
| CDwarfLLVMRegPair | DwarfLLVMRegPair - Emitted by tablegen so Dwarf<->LLVM reg mappings can be performed with a binary search |
| CSubRegCoveredBits | SubRegCoveredBits - Emitted by tablegen: bit range covered by a subreg index, -1 in any being invalid |
| CMCRegUnitIterator | |
| CMCRegUnitMaskIterator | MCRegUnitMaskIterator enumerates a list of register units and their associated lane masks for Reg |
| CMCRegUnitRootIterator | MCRegUnitRootIterator enumerates the root registers of a register unit |
| CMCRelaxableFragment | A relaxable fragment holds on to its MCInst, since it may need to be relaxed during the assembler layout and relaxation stage |
| CMCRelocationInfo | Create MCExprs from relocations found in an object file |
| CMCSchedClassDesc | Summarize the scheduling resources required for an instruction of a particular scheduling class |
| CMCSchedModel | Machine model for scheduling, bundling, and heuristics |
| CMCSection | Instances of this class represent a uniqued identifier for a section in the current translation unit |
| CMCSectionCOFF | This represents a section on Windows |
| CMCSectionELF | This represents a section on linux, lots of unix variants and some bare metal systems |
| CMCSectionMachO | This represents a section on a Mach-O system (used by Mac OS X) |
| CMCSectionWasm | This represents a section on wasm |
| CMCStreamer | Streaming machine code generation interface |
| CMCSubRegIndexIterator | Iterator that enumerates the sub-registers of a Reg and the associated sub-register indices |
| CMCSubRegIterator | MCSubRegIterator enumerates all sub-registers of Reg |
| CMCSubtargetInfo | Generic base class for all target subtargets |
| CMCSuperRegIterator | MCSuperRegIterator enumerates all super-registers of Reg |
| CMCSymbol | MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created and uniqued by the MCContext class |
| CMCSymbolCOFF | |
| CMCSymbolELF | |
| CMCSymbolIdFragment | Represents a symbol table index fragment |
| CMCSymbolizer | Symbolize and annotate disassembled instructions |
| CMCSymbolMachO | |
| CMCSymbolRefExpr | Represent a reference to a symbol from inside an expression |
| CMCSymbolSDNode | |
| CMCSymbolWasm | |
| CMCTargetAsmParser | MCTargetAsmParser - Generic interface to target specific assembly parsers |
| CMCTargetExpr | This is an extension point for target-specific MCExpr subclasses to implement |
| CMCTargetOptions | |
| CMCTargetStreamer | Target specific streamer interface |
| CMCUnaryExpr | Unary assembler expressions |
| CMCValue | This represents an "assembler immediate" |
| CMCWasmObjectTargetWriter | |
| CMCWasmStreamer | |
| CMCWinCOFFObjectTargetWriter | |
| CMCWinCOFFStreamer | |
| CMCWriteLatencyEntry | Specify the latency in cpu cycles for a particular scheduling class and def index |
| CMCWriteProcResEntry | Identify one of the processor resource kinds consumed by a particular scheduling class for the specified number of cycles |
| ►CMD5 | |
| CMD5Result | |
| CMDAttachmentMap | Map-like storage for metadata attachments |
| ►CMDBuilder | |
| CTBAAStructField | |
| CMDGlobalAttachmentMap | Multimap-like storage for metadata attachments for globals |
| ►CMDNode | Metadata node |
| ►CHasCachedHash | |
| CSFINAE | |
| CMDNodeInfo | DenseMapInfo for MDNode subclasses |
| CMDNodeKeyImpl | |
| CMDNodeKeyImpl< DIBasicType > | |
| CMDNodeKeyImpl< DICompositeType > | |
| CMDNodeKeyImpl< DIDerivedType > | |
| CMDNodeKeyImpl< DIEnumerator > | |
| CMDNodeKeyImpl< DIExpression > | |
| CMDNodeKeyImpl< DIFile > | |
| CMDNodeKeyImpl< DIGlobalVariable > | |
| CMDNodeKeyImpl< DIGlobalVariableExpression > | |
| CMDNodeKeyImpl< DIImportedEntity > | |
| CMDNodeKeyImpl< DILabel > | |
| CMDNodeKeyImpl< DILexicalBlock > | |
| CMDNodeKeyImpl< DILexicalBlockFile > | |
| CMDNodeKeyImpl< DILocalVariable > | |
| CMDNodeKeyImpl< DILocation > | DenseMapInfo for DILocation |
| CMDNodeKeyImpl< DIMacro > | |
| CMDNodeKeyImpl< DIMacroFile > | |
| CMDNodeKeyImpl< DIModule > | |
| CMDNodeKeyImpl< DINamespace > | |
| CMDNodeKeyImpl< DIObjCProperty > | |
| CMDNodeKeyImpl< DISubprogram > | |
| CMDNodeKeyImpl< DISubrange > | |
| CMDNodeKeyImpl< DISubroutineType > | |
| CMDNodeKeyImpl< DITemplateTypeParameter > | |
| CMDNodeKeyImpl< DITemplateValueParameter > | |
| CMDNodeKeyImpl< GenericDINode > | DenseMapInfo for GenericDINode |
| CMDNodeKeyImpl< MDTuple > | DenseMapInfo for MDTuple |
| CMDNodeOpsKey | Structure for hashing arbitrary MDNode operands |
| CMDNodeSDNode | |
| CMDNodeSubsetEqualImpl | Configuration point for MDNodeInfo::isEqual() |
| CMDNodeSubsetEqualImpl< DIDerivedType > | |
| CMDNodeSubsetEqualImpl< DISubprogram > | |
| CMDOperand | Tracking metadata reference owned by Metadata |
| CMDString | A single uniqued string |
| CMDTuple | Tuple of metadata |
| CMDTupleTypedArrayWrapper | Typed, array-like tuple of metadata |
| CMemCpyInst | This class wraps the llvm.memcpy intrinsic |
| CMemCpyOptPass | |
| CMemDepResult | A memory dependence query can return one of three different answers |
| CMemIntrinsic | This is the common base class for memset/memcpy/memmove |
| CMemIntrinsicBase | Common base class for all memory intrinsics |
| CMemIntrinsicInfo | Information about a load/store intrinsic defined by the target |
| CMemIntrinsicSDNode | This SDNode is used for target intrinsics that touch memory and need an associated MachineMemOperand |
| CMemMoveInst | This class wraps the llvm.memmove intrinsic |
| CMemoryAccess | |
| Cmemoryaccess_def_iterator_base | Iterator base class used to implement const and non-const iterators over the defining accesses of a MemoryAccess |
| CMemoryBuffer | 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 |
| CMemoryBufferByteStream | An implementation of BinaryStream whose data is backed by an llvm MemoryBuffer object |
| CMemoryBufferRef | |
| CMemoryDef | Represents a read-write access to memory, whether it is a must-alias, or a may-alias |
| ►CMemoryDepChecker | Checks memory dependences among accesses to the same underlying object to determine whether there vectorization is legal or not (and at which vectorization factor) |
| CDependence | Dependece between memory access instructions |
| CMemoryDependenceAnalysis | An analysis that produces MemoryDependenceResults for a function |
| CMemoryDependenceResults | Provides a lazy, caching interface for making common memory aliasing information queries, backed by LLVM's alias analysis passes |
| CMemoryDependenceWrapperPass | A wrapper analysis pass for the legacy pass manager that exposes a MemoryDepnedenceResults instance |
| CMemoryLocation | Representation for a specific memory location |
| CMemoryPhi | Represents phi nodes for memory accesses |
| CMemorySanitizerPass | A function pass for msan instrumentation |
| ►CMemorySSA | Encapsulates MemorySSA, including all data associated with memory accesses |
| CCachingWalker | A MemorySSAWalker that does AA walks to disambiguate accesses |
| CClobberWalkerBase | |
| COptimizeUses | 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 |
| CSkipSelfWalker | |
| ►CMemorySSAAnalysis | An analysis that produces MemorySSA for a function |
| CResult | |
| CMemorySSAAnnotatedWriter | An assembly annotator class to print Memory SSA information in comments |
| CMemorySSAPrinterLegacyPass | |
| CMemorySSAPrinterPass | Printer pass for MemorySSA |
| CMemorySSAUpdater | |
| CMemorySSAUtil | |
| CMemorySSAVerifierPass | Verifier pass for MemorySSA |
| CMemorySSAWalker | This is the generic walker interface for walkers of MemorySSA |
| CMemorySSAWrapperPass | Legacy analysis pass which computes MemorySSA |
| CMemoryUse | Represents read-only accesses to memory |
| CMemoryUseOrDef | Class that has the common methods + fields of memory uses/defs |
| CMemoryWriteTracking | |
| CMemSDNode | This is an abstract virtual class for memory operations |
| CMemSetBase | Common base class for all memset intrinsics |
| CMemSetInst | This class wraps the llvm.memset intrinsic |
| CMemTransferBase | Common base class for all memory transfer intrinsics |
| CMemTransferInst | This class wraps the llvm.memcpy/memmove intrinsics |
| CMergedLoadStoreMotionPass | |
| CMetadata | Root of the metadata hierarchy |
| CMetadataAsValue | Metadata wrapper in the Value hierarchy |
| ►CMetadataLoader | Helper class that handles loading Metadatas and keeping them available |
| CMetadataLoaderImpl | |
| CMetadataTracking | API for tracking metadata references through RAUW and deletion |
| CMIBundleBuilder | Helper class for constructing bundles of MachineInstrs |
| CMIBundleOperands | MIBundleOperands - Iterate over all operands in a bundle of machine instructions |
| CMIOperands | MIOperands - Iterate over operands of a single instruction |
| CMIPrinter | This class prints out the machine instructions using the MIR serialization format |
| CMips16DAGToDAGISel | |
| CMips16FrameLowering | |
| CMips16InstrInfo | |
| CMips16RegisterInfo | |
| CMips16TargetLowering | |
| CMipsABIFlagsSection | |
| CMipsABIInfo | |
| ►CMipsAnalyzeImmediate | |
| CInst | |
| CMipsAsmBackend | |
| CMipsAsmPrinter | |
| ►CMipsCallLowering | |
| CMipsHandler | |
| CMipsCCState | |
| CMipsDAGToDAGISel | |
| CMipsebTargetMachine | Mips32/64 big endian target machine |
| CMipsELFStreamer | |
| CMipselTargetMachine | Mips32/64 little endian target machine |
| CMipsFrameLowering | |
| CMipsFunctionInfo | MipsFunctionInfo - This class is derived from MachineFunction private Mips target-specific information for each MachineFunction |
| CMipsGenRegisterBankInfo | |
| CMipsInstPrinter | |
| CMipsInstrInfo | |
| CMipsLegalizerInfo | This class provides legalization strategies |
| CMipsMCAsmInfo | |
| CMipsMCCodeEmitter | |
| CMipsMCExpr | |
| CMipsMCInstLower | MipsMCInstLower - This class is used to lower an MachineInstr into an MCInst |
| CMipsOptionRecord | |
| CMipsRegInfoRecord | |
| CMipsRegisterBankInfo | This class provides the information for the target register banks |
| CMipsRegisterInfo | |
| CMipsSEDAGToDAGISel | |
| CMipsSEFrameLowering | |
| CMipsSEInstrInfo | |
| CMipsSERegisterInfo | |
| CMipsSETargetLowering | |
| CMipsSubtarget | |
| CMipsTargetAsmStreamer | |
| CMipsTargetELFStreamer | |
| CMipsTargetLowering | |
| CMipsTargetMachine | |
| CMipsTargetObjectFile | |
| CMipsTargetStreamer | |
| CMIRParser | This class initializes machine functions by applying the state loaded from a MIR file |
| CMIRParserImpl | This class implements the parsing of LLVM IR that's embedded inside a MIR file |
| CMIRPrinter | This class prints out the machine functions using the MIR serialization format |
| CMIToken | A token produced by the machine instruction lexer |
| CMMIAddrLabelMap | |
| CMMIAddrLabelMapCallbackPtr | |
| ►CModule | A Module instance is used to store all the information related to an LLVM module |
| Cdebug_compile_units_iterator | An iterator for DICompileUnits that skips those marked NoDebug |
| CModuleFlagEntry | |
| CModulePass | ModulePass class - This class is used to implement unstructured interprocedural optimizations and analyses |
| CModuleSlotTracker | Manage lifetime of a slot tracker for printing IR |
| CModuleSummaryIndex | Class to hold module path string table and global value map, and encapsulate methods for operating on them |
| CModuleSummaryIndexAnalysis | Analysis pass to provide the ModuleSummaryIndex object |
| CModuleSummaryIndexWrapperPass | Legacy wrapper pass to provide the ModuleSummaryIndex object |
| CModuleSymbolTable | |
| CModuleToFunctionPassAdaptor | Trivial adaptor that maps from a module to its functions |
| CModuleToPostOrderCGSCCPassAdaptor | The core module pass which does a post-order walk of the SCCs and runs a CGSCC pass over each one |
| CMSP430FrameLowering | |
| CMSP430InstPrinter | |
| CMSP430InstrInfo | |
| CMSP430MachineFunctionInfo | MSP430MachineFunctionInfo - This class is derived from MachineFunction and contains private MSP430 target-specific information for each MachineFunction |
| CMSP430MCAsmInfo | |
| CMSP430MCCodeEmitter | |
| CMSP430MCInstLower | MSP430MCInstLower - This class is used to lower an MachineInstr into an MCInst |
| CMSP430RegisterInfo | |
| CMSP430Subtarget | |
| CMSP430TargetELFStreamer | |
| CMSP430TargetLowering | |
| CMSP430TargetMachine | MSP430TargetMachine |
| CMSVCPError | |
| CMSVCPExpected | |
| CMulOperator | |
| CMultiClass | |
| CMutableArrayRef | MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memory), i.e |
| CMutableBinaryByteStream | An implementation of BinaryStream which holds its entire data set in a single contiguous buffer |
| CMutexGuard | Instances of this class acquire a given Mutex Lock when constructed and hold that lock until destruction |
| ►CMVT | Machine Value Type |
| CElementCount | |
| CNameAnonGlobalPass | Simple pass that provides a name to every anonymous globals |
| CNamedInstrProfRecord | |
| CNamedMDNode | A tuple of MDNodes |
| CNamedRegionTimer | This class is basically a combination of TimeRegion and Timer |
| CNaryReassociatePass | |
| CNearMissInfo | |
| Cnegation | |
| CNewArchiveMember | |
| CNewGVNPass | |
| CNodeSet | A NodeSet contains a set of SUnit DAG nodes with additional information that assigns a priority to the set |
| CNoFolder | NoFolder - Create "constants" (actually, instructions) with no folding |
| CNonLocalDepEntry | This is an entry in the NonLocalDepInfo cache |
| CNonLocalDepResult | This is a result from a NonLocal dependence query |
| CNVPTXAsmPrinter | |
| CNVPTXDAGToDAGISel | |
| CNVPTXFloatMCExpr | |
| CNVPTXFrameLowering | |
| CNVPTXGenericMCSymbolRefExpr | A wrapper for MCSymbolRefExpr that tells the assembly printer that the symbol should be enclosed by generic() |
| CNVPTXInstPrinter | |
| CNVPTXInstrInfo | |
| CNVPTXMachineFunctionInfo | |
| CNVPTXMCAsmInfo | |
| CNVPTXRegisterInfo | |
| CNVPTXSubtarget | |
| CNVPTXTargetLowering | |
| CNVPTXTargetMachine | NVPTXTargetMachine |
| CNVPTXTargetMachine32 | |
| CNVPTXTargetMachine64 | |
| CNVPTXTargetObjectFile | |
| CNVPTXTargetStreamer | Implments NVPTX-specific streamer |
| CNVPTXTTIImpl | |
| Cobject_creator | Object_creator - Helper method for ManagedStatic |
| Cobject_deleter | Object_deleter - Helper method for ManagedStatic |
| Cobject_deleter< T[N]> | |
| CObjectCache | 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 |
| CObjectSizeOffsetEvaluator | Evaluate the size and offset of an object pointed to by a Value* |
| CObjectSizeOffsetVisitor | Evaluate the size and offset of an object pointed to by a Value* statically |
| CObjectSizeOpts | Various options to control the behavior of getObjectSize |
| Con_first | Function object to apply a binary function to the first component of a std::pair |
| ►COnDiskChainedHashTable | Provides lookup on an on disk hash table |
| Citerator | |
| COnDiskChainedHashTableGenerator | Generates an on disk hash table |
| ►COnDiskIterableChainedHashTable | Provides lookup and iteration over an on disk hash table |
| Cdata_iterator | Iterates over all the entries in the table, returning the data |
| Ckey_iterator | Iterates over all of the keys in the table |
| COperandBundleDefT | A container for an operand bundle being viewed as a set of values rather than a set of uses |
| COperandBundleUse | A lightweight accessor for an operand bundle meant to be passed around by value |
| COperandTraits | Compile-time customization of User operands |
| COperandTraits< AtomicCmpXchgInst > | |
| COperandTraits< AtomicRMWInst > | |
| COperandTraits< BinaryConstantExpr > | |
| COperandTraits< BinaryOperator > | |
| COperandTraits< BlockAddress > | |
| COperandTraits< BranchInst > | |
| COperandTraits< CallBase > | |
| COperandTraits< CatchReturnInst > | |
| COperandTraits< CatchSwitchInst > | |
| COperandTraits< CleanupReturnInst > | |
| COperandTraits< CmpInst > | |
| COperandTraits< CompareConstantExpr > | |
| COperandTraits< ConstantAggregate > | |
| COperandTraits< ConstantExpr > | |
| COperandTraits< ConstantPlaceHolder > | |
| COperandTraits< ExtractElementConstantExpr > | |
| COperandTraits< ExtractElementInst > | |
| COperandTraits< ExtractValueConstantExpr > | |
| COperandTraits< FuncletPadInst > | |
| COperandTraits< Function > | |
| COperandTraits< GetElementPtrConstantExpr > | |
| COperandTraits< GetElementPtrInst > | |
| COperandTraits< GlobalIndirectSymbol > | |
| COperandTraits< GlobalVariable > | |
| COperandTraits< IndirectBrInst > | |
| COperandTraits< InsertElementConstantExpr > | |
| COperandTraits< InsertElementInst > | |
| COperandTraits< InsertValueConstantExpr > | |
| COperandTraits< InsertValueInst > | |
| COperandTraits< LandingPadInst > | |
| COperandTraits< MemoryDef > | |
| COperandTraits< MemoryPhi > | |
| COperandTraits< MemoryUse > | |
| COperandTraits< MemoryUseOrDef > | |
| COperandTraits< PHINode > | |
| COperandTraits< ResumeInst > | |
| COperandTraits< ReturnInst > | |
| COperandTraits< SelectConstantExpr > | |
| COperandTraits< SelectInst > | |
| COperandTraits< ShuffleVectorConstantExpr > | |
| COperandTraits< ShuffleVectorInst > | |
| COperandTraits< StoreInst > | |
| COperandTraits< SwitchInst > | |
| COperandTraits< UnaryConstantExpr > | |
| COperandTraits< UnaryInstruction > | |
| COperator | This is a utility class that provides an abstraction for the common functionality between Instructions and ConstantExprs |
| COpInit | Base class for operators |
| COProfileWrapper | |
| COptBisect | 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 |
| COptimizationRemark | Diagnostic information for applied optimization remarks |
| COptimizationRemarkAnalysis | Diagnostic information for optimization analysis remarks |
| COptimizationRemarkAnalysisAliasing | Diagnostic information for optimization analysis remarks related to pointer aliasing |
| COptimizationRemarkAnalysisFPCommute | Diagnostic information for optimization analysis remarks related to floating-point non-commutativity |
| COptimizationRemarkEmitter | The optimization diagnostic interface |
| COptimizationRemarkEmitterAnalysis | |
| COptimizationRemarkEmitterWrapperPass | OptimizationRemarkEmitter legacy analysis pass |
| COptimizationRemarkMissed | Diagnostic information for missed-optimization remarks |
| COptional | |
| COptionalOperandTraits | OptionalOperandTraits - when the number of operands may change at runtime |
| COptionRegistry | Singleton class used to register debug options |
| COptLevelChanger | This class is used by SelectionDAGISel to temporarily override the optimization level on a per-function basis |
| COptPassGate | Extensions to this class implement mechanisms to disable passes and individual optimizations at compile time |
| COrcCBindingsStack | |
| COrderedBasicBlock | |
| COrderedInstructions | |
| ►COuterAnalysisManagerProxy | An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR unit |
| CResult | Result proxy object for OuterAnalysisManagerProxy |
| COverflowingBinaryOperator | Utility class for integer operators which may exhibit overflow - Add, Sub, Mul, and Shl |
| COwningArrayRef | This is a MutableArrayRef that owns its array |
| ►CPackedVector | Store a vector of values using a specific number of bits for each value |
| Creference | |
| CPackedVectorBase | |
| CPackedVectorBase< T, BitNum, BitVectorTy, false > | |
| CPackedVectorBase< T, BitNum, BitVectorTy, true > | |
| Cpair_hash | |
| CParsedModuleAndIndex | Holds the Module and ModuleSummaryIndex returned by the interfaces that parse both |
| CParseInstructionInfo | |
| CPartialInlinerPass | Pass to remove unused function declarations |
| CPartiallyInlineLibCallsPass | |
| CPass | Pass interface - Implemented by all 'passes' |
| CPassArgFilter | ===-------------------------------------------------------------------—===// PassArgFilter - A filter for use with PassNameFilterParser that only accepts a Pass whose Arg matches certain strings |
| ►CPassBuilder | This class provides access to building LLVM's passes |
| CPipelineElement | A struct to capture parsed pass pipeline names |
| CPassConfigImpl | |
| CPassInfo | 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 |
| CPassInfoMixin | A CRTP mix-in to automatically provide informational APIs needed for passes |
| CPassInstrumentation | This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks registered in PassInstrumentationCallbacks |
| CPassInstrumentationAnalysis | Pseudo-analysis pass that exposes the PassInstrumentation to pass managers |
| CPassInstrumentationCallbacks | This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass control to the registered callbacks |
| CPassManager | Manages a sequence of passes over a particular unit of IR |
| CPassManagerBuilder | 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 |
| CPassManagerPrettyStackEntry | PassManagerPrettyStackEntry - This is used to print informative information about what pass is running when/if a stack trace is generated |
| CPassNameParser | |
| CPassPlugin | A loaded pass plugin |
| CPassPluginLibraryInfo | Information about the plugin required to load its passes |
| CPassRegistrationListener | 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) |
| CPassRegistry | PassRegistry - This class manages the registration and intitialization of the pass subsystem as application startup, and assists the PassManager in resolving pass dependencies |
| CPatchPointOpers | MI-level patchpoint operands |
| CPBQPRAConstraint | Abstract base for classes implementing PBQP register allocation constraints (e.g |
| CPBQPRAConstraintList | PBQP register allocation constraint composer |
| CPerFunctionMIParsingState | |
| CPGOIndirectCallPromotion | The indirect function call promotion pass |
| CPGOIndirectCallVisitor | |
| CPGOInstrumentationGen | The instrumentation (profile-instr-gen) pass for IR based PGO |
| CPGOInstrumentationUse | The profile annotation (profile-instr-use) pass for IR based PGO |
| CPGOMemOPSizeOpt | The profile size based optimization pass for memory intrinsics |
| CPGOOptions | A struct capturing PGO tunables |
| CPHINode | |
| CPHITransAddr | PHITransAddr - An address value which tracks and handles phi translation |
| CPhiValues | Class for calculating and caching the underlying values of phis in a function |
| CPhiValuesAnalysis | The analysis pass which yields a PhiValues |
| CPhiValuesPrinterPass | A pass for printing the PhiValues for a function |
| CPhiValuesWrapperPass | Wrapper pass for the legacy pass manager |
| CPhysicalRegisterUsageInfo | |
| CPhysRegSUOper | Record a physical register access |
| CPluginLoader | |
| CPMDataManager | PMDataManager provides the common place to manage the analysis data used by pass managers |
| CPMStack | PMStack - This class implements a stack data structure of PMDataManager pointers |
| CPMTopLevelManager | PMTopLevelManager manages LastUser info and collects common APIs used by top level pass managers |
| Cpo_ext_iterator | |
| Cpo_iterator | |
| Cpo_iterator_storage | Default po_iterator_storage implementation with an internal set object |
| Cpo_iterator_storage< LoopBlocksTraversal, true > | Specialize po_iterator_storage to record postorder numbers |
| Cpo_iterator_storage< LoopBounds, true > | |
| Cpo_iterator_storage< SetType, true > | Specialization of po_iterator_storage that references an external set |
| Cpointee_iterator | An iterator type that allows iterating over the pointees via some other iterator |
| Cpointer_iterator | |
| CPointerAlignElem | Layout pointer alignment element |
| CPointerEmbeddedInt | Utility to embed an integer into a pointer-like type |
| CPointerIntPair | PointerIntPair - This class implements a pair of a pointer and small integer |
| CPointerIntPairInfo | |
| CPointerLikeTypeTraits | A traits type that is used to handle pointer types and things that are just wrappers for pointers as a uniform entity |
| CPointerLikeTypeTraits< const T * > | |
| CPointerLikeTypeTraits< const T > | |
| CPointerLikeTypeTraits< PointerEmbeddedInt< IntT, Bits > > | |
| CPointerLikeTypeTraits< PointerIntPair< PointerTy, IntBits, IntType, PtrTraits > > | |
| CPointerLikeTypeTraits< PointerUnion3< PT1, PT2, PT3 > > | |
| CPointerLikeTypeTraits< PointerUnion4< PT1, PT2, PT3, PT4 > > | |
| CPointerLikeTypeTraits< PointerUnion< PT1, PT2 > > | |
| CPointerLikeTypeTraits< ReturnT(*)(ParamTs...)> | Provide a default specialization for function pointers that assumes 4-byte alignment |
| CPointerLikeTypeTraits< T * > | |
| CPointerLikeTypeTraits< uintptr_t > | |
| CPointerLikeTypeTraits< void * > | |
| CPointerSumType | A sum type over pointer-like types |
| CPointerSumTypeMember | A compile time pair of an integer tag and the pointer-like type which it indexes within a sum type |
| CPointerType | Class to represent pointers |
| CPointerUnion | A discriminated union of two pointer types, with the discriminator in the low bit of the pointer |
| CPointerUnion3 | A pointer union of three pointer types |
| CPointerUnion4 | A pointer union of four pointer types |
| CPointerUnionTypeSelector | Get a type based on whether two types are the same or not |
| CPointerUnionTypeSelector< T, T, RET_EQ, RET_NE > | |
| CPointerUnionTypeSelectorReturn | |
| CPointerUnionTypeSelectorReturn< PointerUnionTypeSelector< T1, T2, RET_EQ, RET_NE > > | |
| CPointerUnionUIntTraits | Provide PointerLikeTypeTraits for void* that is used by PointerUnion for the two template arguments |
| CPoisoningVH | Value handle that poisons itself if the Value is deleted |
| CPooledStringPtr | PooledStringPtr - A pointer to an interned string |
| CPopulateLoopsDFS | Populate all loop data in a stable order during a single forward DFS |
| CPossiblyExactOperator | A udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed |
| CPostDominatorTree | PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominator tree |
| CPostDominatorTreeAnalysis | Analysis pass which computes a PostDominatorTree |
| CPostDominatorTreePrinterPass | Printer pass for the PostDominatorTree |
| CPostDominatorTreeWrapperPass | |
| CPostGenericScheduler | PostGenericScheduler - Interface to the scheduling algorithm used by ScheduleDAGMI |
| CPostOrderFunctionAttrsPass | Computes function attributes in post-order over the call graph |
| CPPC64LinuxTargetObjectFile | PPC64LinuxTargetObjectFile - This implementation is used for 64-bit PowerPC Linux |
| CPPCCCState | |
| CPPCDispatchGroupSBHazardRecognizer | PPCDispatchGroupSBHazardRecognizer - This class implements a scoreboard-based hazard recognizer for PPC ooo processors with dispatch-group hazards |
| CPPCELFMCAsmInfo | |
| CPPCFrameLowering | |
| CPPCFunctionInfo | PPCFunctionInfo - This class is derived from MachineFunction private PowerPC target-specific information for each MachineFunction |
| CPPCHazardRecognizer970 | PPCHazardRecognizer970 - This class defines a finite state automata that models the dispatch logic on the PowerPC 970 (aka G5) processor |
| CPPCInstPrinter | |
| CPPCInstrInfo | |
| CPPCMCAsmInfoDarwin | |
| CPPCMCCodeEmitter | |
| CPPCMCExpr | |
| CPPCRegisterInfo | |
| CPPCSubtarget | |
| CPPCTargetLowering | |
| CPPCTargetMachine | Common code between 32-bit and 64-bit PowerPC targets |
| CPPCTargetStreamer | |
| CPPCTTIImpl | |
| CPredicateAssume | |
| CPredicateBase | |
| CPredicateBitsetImpl | Container class for CodeGen predicate results |
| CPredicateBranch | |
| CPredicatedScalarEvolution | An interface layer with SCEV used to manage how we see SCEV expressions for values in the context of existing predicates |
| CPredicateInfo | Encapsulates PredicateInfo, including all data associated with memory accesses |
| CPredicateInfoAnnotatedWriter | An assembly annotator class to print PredicateInfo information in comments |
| CPredicateInfoPrinterLegacyPass | |
| CPredicateInfoPrinterPass | Printer pass for PredicateInfo |
| CPredicateInfoVerifierPass | Verifier pass for PredicateInfo |
| CPredicateSwitch | |
| CPredicateWithCondition | |
| CPredicateWithEdge | |
| CPredIterator | |
| CPredIteratorCache | PredIteratorCache - This class is an extremely trivial cache for predecessor iterator queries |
| CPreISelIntrinsicLoweringPass | |
| ►CPreservedAnalyses | A set of analyses that are preserved following a run of a transformation pass |
| CPreservedAnalysisChecker | A checker object that makes it easy to query for whether an analysis or some set covering it is preserved |
| CPressureChange | Capture a change in pressure for a single pressure set |
| CPressureDiff | List of PressureChanges in order of increasing, unique PSetID |
| CPressureDiffs | Array of PressureDiffs |
| CPrettyStackTraceEntry | PrettyStackTraceEntry - This class is used to represent a frame of the "pretty" stack trace that is dumped when a program crashes |
| CPrettyStackTraceFormat | 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 |
| CPrettyStackTraceProgram | PrettyStackTraceProgram - This object prints a specified program arguments to the stream as the stack trace when a crash occurs |
| CPrettyStackTraceString | PrettyStackTraceString - This object prints a specified string (which should not contain newlines) to the stream as the stack trace when a crash occurs |
| CPrintable | Simple wrapper around std::function<void(raw_ostream&)> |
| CPrintFunctionPass | Pass for printing a Function as LLVM's text IR assembly |
| CPrintIRInstrumentation | Instrumentation to print IR before/after passes |
| CPrintLoopPass | Pass for printing a loop's contents as textual IR |
| CPrintModulePass | Pass for printing a Module as LLVM's text IR assembly |
| CPriorityQueue | PriorityQueue - This class behaves like std::priority_queue and provides a few additional convenience functions |
| CPriorityWorklist | A FILO worklist that prioritizes on re-insertion without duplication |
| CProfileSummary | |
| CProfileSummaryAnalysis | An analysis pass based on the new PM to deliver ProfileSummaryInfo |
| CProfileSummaryBuilder | |
| CProfileSummaryEntry | |
| CProfileSummaryInfo | Analysis providing profile information |
| CProfileSummaryInfoWrapperPass | An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo |
| CProfileSummaryPrinterPass | Printer pass that uses ProfileSummaryAnalysis |
| CProfOStream | |
| CPromotePass | |
| CPSetIterator | Iterate over the pressure sets affected by the given physical or virtual register |
| CPseudoSourceValue | Special value supplied for machine level alias analysis |
| CPseudoSourceValueManager | Manages creation of pseudo source values |
| CPtrToIntInst | This class represents a cast from a pointer to an integer |
| CPtrToIntOperator | |
| CPtrUseVisitor | A base class for visitors over the uses of a pointer value |
| CR600AsmPrinter | |
| CR600FrameLowering | |
| CR600InstPrinter | |
| CR600InstrInfo | |
| CR600MachineFunctionInfo | |
| CR600RegisterInfo | |
| CR600SchedStrategy | |
| CR600Subtarget | |
| CR600TargetLowering | |
| CR600TargetMachine | |
| CR600TTIImpl | |
| CRAIIDelegateInstaller | A simple RAII based CSEInfo installer |
| CRandomIRBuilder | |
| CRandomNumberGenerator | A random number generator |
| CRangeListEntry | A class representing a single range list entry |
| CRangeSpan | |
| CRangeSpanList | |
| Crank | Utility type to build an inheritance chain that makes it easy to rank overload candidates |
| Crank< 0 > | |
| Craw_fd_ostream | A raw_ostream that writes to a file descriptor |
| Craw_null_ostream | A raw_ostream that discards all output |
| Craw_os_ostream | Raw_os_ostream - A raw_ostream that writes to an std::ostream |
| Craw_ostream | This class implements an extremely fast bulk output stream that can only output to a stream |
| Craw_pwrite_stream | An abstract base class for streams implementations that also support a pwrite operation |
| Craw_sha1_ostream | A raw_ostream that hash the content using the sha1 algorithm |
| Craw_string_ostream | A raw_ostream that writes to an std::string |
| Craw_svector_ostream | A raw_ostream that writes to an SmallVector or SmallString |
| CRawInstrProfReader | Reader for the raw instrprof binary format from runtime |
| CRCToken | |
| CReachingDefAnalysis | This class provides the reaching def analysis |
| CReadyQueue | Helpers for implementing custom MachineSchedStrategy classes |
| CReassociatePass | Reassociate commutative expressions |
| CRecord | |
| CRecordKeeper | |
| CRecordRecTy | '[classname]' - Type of record values that have zero or more superclasses |
| CRecordResolver | Resolve all variables from a record except for unset variables |
| CRecordsEntry | RecordsEntry - Can be either a record or a foreach loop |
| CRecordStreamer | |
| CRecordVal | |
| CRecordValResolver | Resolve all references to a specific RecordVal |
| CRecTy | |
| ►CRecurrenceDescriptor | The RecurrenceDescriptor is used to identify recurrences variables in a loop |
| CInstDesc | This POD struct holds information about a potential recurrence operation |
| CRecycler | Recycler - This class manages a linked-list of deallocated nodes and facilitates reusing deallocated memory in place of allocating new memory |
| CRecyclingAllocator | RecyclingAllocator - This class wraps an Allocator, adding the functionality of recycling deleted objects |
| CRefCountedBase | A CRTP mixin class that adds reference counting to a type |
| CRegAllocBase | RegAllocBase provides the register allocation driver and interface that can be extended to add interesting heuristics |
| ►CRegBankSelect | This pass implements the reg bank selector pass used in the GlobalISel pipeline |
| CEdgeInsertPoint | Insertion point on an edge |
| CInsertPoint | Abstract class used to represent an insertion point in a CFG |
| CInstrInsertPoint | Insertion point before or after an instruction |
| CMBBInsertPoint | Insertion point at the beginning or end of a basic block |
| CRepairingPlacement | Struct used to represent the placement of a repairing point for a given operand |
| CRegClassWeight | Each TargetRegisterClass has a per register weight, and weight limit which must be less than the limits of its pressure sets |
| CRegex | |
| CRegion | |
| ►CRegionBase | A single entry single exit Region |
| Cblock_iterator_wrapper | |
| CRegionInfo | |
| CRegionInfoAnalysis | Analysis pass that exposes the RegionInfo for a function |
| CRegionInfoBase | Analysis that detects all canonical Regions |
| CRegionInfoPass | |
| CRegionInfoPrinterPass | Printer pass for the RegionInfo |
| CRegionInfoVerifierPass | Verifier pass for the RegionInfo |
| CRegionNode | |
| CRegionNodeBase | A RegionNode represents a subregion or a BasicBlock that is part of a Region |
| CRegionPass | A pass that runs on each Region in a function |
| CRegionPressure | RegisterPressure computed within a region of instructions delimited by TopPos and BottomPos |
| CRegionTraits | |
| CRegionTraits< Function > | |
| CRegionTraits< MachineFunction > | |
| CRegisterAGBase | RegisterAnalysisGroup - Register a Pass as a member of an analysis group |
| CRegisterAnalysisGroup | |
| CRegisterBank | This class implements the register bank concept |
| ►CRegisterBankInfo | Holds all the information related to register banks |
| CInstructionMapping | Helper class that represents how the value of an instruction may be mapped and what is the related cost of such mapping |
| COperandsMapper | Helper class used to get/create the virtual registers that will be used to replace the MachineOperand when applying a mapping |
| CPartialMapping | Helper struct that represents how a value is partially mapped into a register |
| CValueMapping | Helper struct that represents how a value is mapped through different register banks |
| CRegisterClassInfo | |
| CRegisterMaskPair | |
| CRegisterMaskSDNode | |
| CRegisterOperands | List of registers defined and used by a machine instruction |
| CRegisterPass | 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 |
| CRegisterPassParser | RegisterPassParser class - Handle the addition of new machine passes |
| CRegisterPressure | Base class for register pressure results |
| CRegisterRegAlloc | RegisterRegAlloc class - Track the registration of register allocators |
| CRegisterScheduler | |
| CRegisterSDNode | |
| CRegisterStandardPasses | Registers a function for adding a standard set of passes |
| ►CRegistry | 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 |
| CAdd | A static registration template |
| Citerator | Iterators for registry entries |
| Cnode | Node in linked list of entries |
| CRegPressureDelta | Store the effects of a change in pressure on things that MI scheduler cares about |
| CRegPressureTracker | Track the current register pressure at some position in the instruction stream, and remember the high water mark within the region traversed |
| CRegScavenger | |
| CRegsForValue | RegsForValue - This struct represents the registers (physical or virtual) that a particular set of values is assigned, and the type information about the value |
| CRegTraits | |
| CRelocAddrEntry | RelocAddrEntry contains relocated value and section index |
| ►CRelocationEntry | RelocationEntry - used to represent relocations internally in the dynamic linker |
| CSectionPair | |
| CRelocationValueRef | |
| CRepeatedPass | A utility pass template that simply runs another pass multiple times |
| CReplaceableMetadataImpl | Shared implementation of use-lists for replaceable metadata |
| CReplacementItem | |
| CRequireAnalysisPass | A utility pass template to force an analysis result to be available |
| CRequireAnalysisPass< AnalysisT, LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult & > | An explicit specialization of the require analysis template pass |
| CRequireAnalysisPass< 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 |
| CReservoirSampler | Randomly selects an item by sampling into a set with an unknown number of elements, which may each be weighted to be more likely choices |
| CResolver | Interface for looking up the initializer for a variable name, used by Init::resolveReferences |
| Cresource_sort | Sorting functions for the Available queue |
| CResourcePriorityQueue | |
| CResumeInst | Resume the propagation of an exception |
| CReturnInst | Return a value (possibly void), from a function |
| CReversePostOrderFunctionAttrsPass | A pass to do RPO deduction and propagation of function attributes |
| CReversePostOrderTraversal | |
| CRewriteStatepointsForGC | |
| CRewriteSymbolPass | |
| CRGPassManager | The pass manager to schedule RegionPasses |
| CRISCVAsmBackend | |
| CRISCVELFTargetObjectFile | This implementation is used for RISCV ELF targets |
| CRISCVFrameLowering | |
| CRISCVInstPrinter | |
| CRISCVInstrInfo | |
| CRISCVMachineFunctionInfo | RISCVMachineFunctionInfo - This class is derived from MachineFunctionInfo and contains private RISCV-specific information for each MachineFunction |
| CRISCVMCAsmInfo | |
| CRISCVMCExpr | |
| CRISCVRegisterInfo | |
| CRISCVSubtarget | |
| CRISCVTargetAsmStreamer | |
| CRISCVTargetELFStreamer | |
| CRISCVTargetLowering | |
| CRISCVTargetMachine | |
| CRISCVTargetStreamer | |
| CRNSuccIterator | Hierarchical RegionNode successor iterator |
| CRNSuccIterator< FlatIt< NodeRef >, BlockT, RegionT > | Flat RegionNode iterator |
| CRoundUpToPowerOfTwo | 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) |
| CRoundUpToPowerOfTwoH | RoundUpToPowerOfTwoH - If N is not a power of two, increase it |
| CRoundUpToPowerOfTwoH< N, false > | |
| ►CRTDyldMemoryManager | |
| CEHFrame | |
| ►CRuntimeDyld | |
| CLoadedObjectInfo | Information about the loaded object |
| CMemoryManager | Memory Management |
| CRuntimeDyldChecker | RuntimeDyld invariant checker for verifying that RuntimeDyld has correctly applied relocations |
| CRuntimeDyldCheckerExprEval | |
| CRuntimeDyldCheckerImpl | |
| CRuntimeDyldCOFF | |
| CRuntimeDyldCOFFI386 | |
| CRuntimeDyldCOFFThumb | |
| CRuntimeDyldCOFFX86_64 | |
| CRuntimeDyldELF | |
| CRuntimeDyldELFMips | |
| CRuntimeDyldError | Base class for errors originating in RuntimeDyld, e.g |
| CRuntimeDyldImpl | |
| ►CRuntimeDyldMachO | |
| CEHFrameRelatedSections | |
| CSectionOffsetPair | |
| CRuntimeDyldMachOAArch64 | |
| CRuntimeDyldMachOARM | |
| CRuntimeDyldMachOCRTPBase | RuntimeDyldMachOTarget - Templated base class for generic MachO linker algorithms and data structures |
| CRuntimeDyldMachOI386 | |
| CRuntimeDyldMachOX86_64 | |
| ►CRuntimePointerChecking | Holds information about the memory runtime legality checks to verify that a group of pointers do not overlap |
| CCheckingPtrGroup | A grouping of pointers |
| CPointerInfo | |
| CSameType | |
| CSampleProfileLoaderPass | The sample profiler data loader pass |
| CSampleProfileSummaryBuilder | |
| CSanitizerCoverageOptions | |
| CSanitizerStatReport | |
| CSaveAndRestore | A utility class that uses RAII to save and restore the value of a variable |
| CScalarEvolution | The main scalar evolution driver |
| CScalarEvolutionAnalysis | Analysis pass that exposes the ScalarEvolution for a function |
| CScalarEvolutionPrinterPass | Printer pass for the ScalarEvolutionAnalysis results |
| CScalarEvolutionWrapperPass | |
| CScalarizerPass | |
| CScaledNumber | Simple representation of a scaled number |
| CScaledNumberBase | |
| Cscc_iterator | Enumerate the SCCs of a directed graph in reverse topological order of the SCC DAG |
| CSCCPPass | This pass performs function-level constant propagation and merging |
| CSCEV | This class represents an analyzed expression in the program |
| CSCEVAA | Analysis pass providing a never-invalidated alias analysis result |
| CSCEVAAResult | A simple alias analysis implementation that uses ScalarEvolution to answer queries |
| CSCEVAAWrapperPass | Legacy wrapper pass to provide the SCEVAAResult object |
| CSCEVAddExpr | This node represents an addition of some number of SCEVs |
| CSCEVAddRecExpr | This node represents a polynomial recurrence on the trip count of the specified loop |
| CSCEVCastExpr | This is the base class for unary cast operator classes |
| CSCEVCommutativeExpr | This node is the base class for n'ary commutative operators |
| CSCEVConstant | This class represents a constant integer value |
| CSCEVCouldNotCompute | An object of this class is returned by queries that could not be answered |
| CSCEVEqualPredicate | This class represents an assumption that two SCEV expressions are equal, and this can be checked at run-time |
| CSCEVExpander | This class uses information about analyze scalars to rewrite expressions in canonical form |
| CSCEVLoopAddRecRewriter | The SCEVLoopAddRecRewriter takes a scalar evolution expression and applies the Map (Loop -> SCEV) to all AddRecExprs |
| CSCEVMulExpr | This node represents multiplication of some number of SCEVs |
| CSCEVNAryExpr | This node is a base class providing common functionality for n'ary operators |
| CSCEVParameterRewriter | The SCEVParameterRewriter takes a scalar evolution expression and updates the SCEVUnknown components following the Map (Value -> Value) |
| CSCEVPredicate | This class represents an assumption made using SCEV expressions which can be checked at run-time |
| CSCEVRewriteVisitor | This visitor recursively visits a SCEV expression and re-writes it |
| CSCEVSignExtendExpr | This class represents a sign extension of a small integer value to a larger integer value |
| CSCEVSMaxExpr | This class represents a signed maximum selection |
| CSCEVTraversal | Visit all nodes in the expression tree using worklist traversal |
| CSCEVTruncateExpr | This class represents a truncation of an integer value to a smaller integer value |
| CSCEVUDivExpr | This class represents a binary unsigned division operation |
| CSCEVUMaxExpr | This class represents an unsigned maximum selection |
| CSCEVUnionPredicate | This class represents a composition of other SCEV predicates, and is the class that most clients will interact with |
| CSCEVUnknown | This means that we are dealing with an entirely unknown SCEV value, and only represent it as its LLVM Value |
| CSCEVVisitor | This class defines a simple visitor class that may be used for various SCEV analysis purposes |
| CSCEVWrapPredicate | This class represents an assumption made on an AddRec expression |
| CSCEVZeroExtendExpr | This class represents a zero extension of a small integer value to a larger integer value |
| CSchedBoundary | Each Scheduling boundary is associated with ready queues |
| CSchedDFSImpl | Internal state used to compute SchedDFSResult |
| CSchedDFSResult | Compute the values of each DAG node for various metrics during DFS |
| CSchedRemainder | Summarize the unscheduled region |
| CScheduleDAG | |
| ►CScheduleDAGInstrs | A ScheduleDAG for scheduling lists of MachineInstr |
| CValue2SUsMap | |
| CScheduleDAGMI | ScheduleDAGMI is an implementation of ScheduleDAGInstrs that simply schedules machine instructions according to the given MachineSchedStrategy without much extra book-keeping |
| CScheduleDAGMILive | ScheduleDAGMILive is an implementation of ScheduleDAGInstrs that schedules machine instructions while updating LiveIntervals and tracking regpressure |
| CScheduleDAGMutation | Mutate the DAG as a postpass after normal DAG building |
| ►CScheduleDAGSDNodes | ScheduleDAGSDNodes - A ScheduleDAG for scheduling SDNode-based DAGs |
| CRegDefIter | RegDefIter - In place iteration over the values defined by an SUnit |
| CScheduleDAGTopologicalSort | This class can compute a topological ordering for SUnits and provides methods for dynamically updating the ordering as new edges are added |
| CScheduleHazardRecognizer | 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 |
| CSchedulingPriorityQueue | This interface is used to plug different priorities computation algorithms into the list scheduler |
| CScopedFatalErrorHandler | 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 |
| CScopedHandle | |
| CScopedHashTable | |
| CScopedHashTableIterator | |
| CScopedHashTableScope | |
| CScopedHashTableVal | |
| CScopedNoAliasAA | Analysis pass providing a never-invalidated alias analysis result |
| CScopedNoAliasAAResult | A simple AA result which uses scoped-noalias metadata to answer queries |
| CScopedNoAliasAAWrapperPass | Legacy wrapper pass to provide the ScopedNoAliasAAResult object |
| CScopedPrinter | |
| CScoreboardHazardRecognizer | |
| CSDDbgInfo | Keeps track of dbg_value information through SDISel |
| CSDDbgLabel | Holds the information from a dbg_label node through SDISel |
| CSDDbgValue | Holds the information from a dbg_value node through SDISel |
| CSDep | Scheduling dependency |
| CSDivOperator | |
| CSDLoc | Wrapper class for IR location info (IR ordering and DebugLoc) to be passed into SDNode creation functions |
| ►CSDNode | Represents one node in the SelectionDAG |
| CConstantSDNodeBitfields | |
| CLoadSDNodeBitfields | |
| CLSBaseSDNodeBitfields | |
| CMemSDNodeBitfields | |
| CSDNodeBitfields | |
| CStoreSDNodeBitfields | |
| Cuse_iterator | This class provides iterator support for SDUse operands that use a specific SDNode |
| Cvalue_op_iterator | Iterator for directly iterating over the operand SDValue's |
| CSDNodeFlags | These are IR-level optimization flags that may be propagated to SDNodes |
| CSDNodeIterator | |
| CSDUse | Represents a use of a SDNode |
| CSDValue | Unlike LLVM values, Selection DAG nodes may return multiple values as the result of a computation |
| CSDVTList | This represents a list of ValueType's that has been intern'd by a SelectionDAG |
| CSDVTListNode | |
| CSectionedAddress | |
| CSectionEntry | SectionEntry - represents a section emitted into memory by the dynamic linker |
| CSectionKind | SectionKind - This is a simple POD value that classifies the properties of a section |
| ►CSectionMemoryManager | 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 |
| CMemoryMapper | Implementations of this interface are used by SectionMemoryManager to request pages from the operating system |
| CSectionName | |
| CSEHHandler | |
| CSEHUnwindMapEntry | Similar to CxxUnwindMapEntry, but supports SEH filters |
| CSelectConstantExpr | SelectConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement select constant exprs |
| CSelectInst | This class represents the LLVM 'select' instruction |
| ►CSelectionDAG | This is used to represent a portion of an LLVM function in a low-level Data Dependence DAG representation suitable for instruction selection |
| CDAGNodeDeletedListener | |
| CDAGUpdateListener | Clients of various APIs that cause global effects on the DAG can optionally implement this interface |
| ►CSelectionDAGBuilder | SelectionDAGBuilder - This is the common target-independent lowering implementation that is parameterized by a TargetLowering object |
| CStatepointLoweringInfo | Describes a gc.statepoint or a gc.statepoint like thing for the purposes of lowering into a STATEPOINT node |
| CSelectionDAGISel | SelectionDAGISel - This is the common base class used for SelectionDAG-based pattern-matching instruction selectors |
| CSelectionDAGTargetInfo | Targets can subclass this to parameterize the SelectionDAG lowering and instruction selection process |
| CSelectPatternResult | |
| CSequentialType | This is the superclass of the array and vector type classes |
| ►CSetTheory | |
| CExpander | Expander - A callback function that can transform a Record representing a set into a fully expanded list of elements |
| COperator | Operator - A callback representing a DAG operator |
| CSetVector | A vector that has set insertion semantics |
| CSExtInst | This class represents a sign extension of integer types |
| CSHA1 | A class that wrap the SHA1 algorithm |
| CShadowResolver | Delegate resolving to a sub-resolver, but shadow some variable names |
| CShlOperator | |
| CShuffleVectorConstantExpr | ShuffleVectorConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement shufflevector constant exprs |
| CShuffleVectorInst | This instruction constructs a fixed permutation of two input vectors |
| CShuffleVectorSDNode | This SDNode is used to implement the code generator support for the llvm IR shufflevector instruction |
| CSIFrameLowering | |
| CSIInstrInfo | |
| ►CSIMachineFunctionInfo | This class keeps track of the SPI_SP_INPUT_ADDR config register, which tells the hardware which interpolation parameters to load |
| CSGPRSpillVGPRCSR | |
| CSpilledReg | |
| Csimple_ilist | A simple intrusive list implementation |
| CSimpleBitstreamCursor | This represents a position within a bitstream |
| CSimpleLoopSafetyInfo | Simple and conservative implementation of LoopSafetyInfo that can give false-positive answers to its queries in order to avoid complicated analysis |
| CSimpleLoopUnswitchPass | This pass transforms loops that contain branches or switches on loop- invariant conditions to have multiple loops |
| CSimpleRegistryEntry | A simple registry entry which provides only a name, description, and no-argument constructor |
| Csimplify_type | |
| Csimplify_type< const From > | |
| Csimplify_type< const ilist_iterator< OptionsT, false, IsConst > > | |
| Csimplify_type< const IntrusiveRefCntPtr< T > > | |
| Csimplify_type< const MDOperand > | |
| Csimplify_type< const SDValue > | |
| Csimplify_type< const TrackingMDRef > | |
| Csimplify_type< const TypedDINodeRef< T > > | |
| Csimplify_type< const TypedTrackingMDRef< T > > | |
| Csimplify_type< const Use > | |
| Csimplify_type< const WeakTrackingVH > | |
| Csimplify_type< const WeakVH > | |
| Csimplify_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.. |
| Csimplify_type< IntrusiveRefCntPtr< T > > | |
| Csimplify_type< MDOperand > | |
| Csimplify_type< SDUse > | Simplify_type specializations - Allow casting operators to work directly on SDValues as if they were SDNode*'s |
| Csimplify_type< SDValue > | Allow casting operators to work directly on SDValues as if they were SDNode*'s |
| Csimplify_type< TrackingMDRef > | |
| Csimplify_type< TypedDINodeRef< T > > | |
| Csimplify_type< TypedTrackingMDRef< T > > | |
| Csimplify_type< Use > | Allow clients to treat uses just like values when using casting operators |
| Csimplify_type< User::const_op_iterator > | |
| Csimplify_type< User::op_iterator > | |
| Csimplify_type< WeakTrackingVH > | |
| Csimplify_type< WeakVH > | |
| CSimplifyCFGOptions | A set of parameters used to control the transforms in the SimplifyCFG pass |
| CSimplifyCFGPass | A pass to simplify and canonicalize the CFG of a function |
| CSimplifyQuery | |
| CSinkingPass | Move instructions into successor blocks when possible |
| CSIProgramInfo | Track resource usage for kernels / entry functions |
| CSIRegisterInfo | |
| CSIScheduleBlock | |
| CSIScheduleBlockCreator | |
| CSIScheduleBlockResult | |
| CSIScheduleBlocks | |
| CSIScheduleBlockScheduler | |
| CSIScheduleDAGMI | |
| CSIScheduler | |
| CSISchedulerCandidate | |
| CSITargetLowering | |
| CSIToFPInst | This class represents a cast from signed integer to floating point |
| CSlotIndex | SlotIndex - An opaque wrapper around machine indexes |
| CSlotIndexes | SlotIndexes pass |
| CSlotMapping | This struct contains the mappings from the slot numbers to unnamed metadata nodes, global values and types |
| CSlotTracker | This class provides computation of slot numbers for LLVM Assembly writing |
| CSLPVectorizerPass | |
| ►CSmallBitVector | This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is small |
| Creference | |
| CSmallDenseMap | |
| CSmallDenseSet | Implements a dense probed hash-table based set with some number of buckets stored inline |
| CSmallMapVector | A MapVector that performs no allocations if smaller than a certain size |
| CSmallPriorityWorklist | A version of PriorityWorklist that selects small size optimized data structures for the vector and map |
| CSmallPtrSet | SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements |
| CSmallPtrSetImpl | A templated base class for SmallPtrSet which provides the typesafe interface that is common across all small sizes |
| CSmallPtrSetImplBase | SmallPtrSetImplBase - This is the common code shared among all the SmallPtrSet<>'s, which is almost everything |
| CSmallPtrSetIterator | SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet |
| CSmallPtrSetIteratorImpl | SmallPtrSetIteratorImpl - This is the common base class shared between all instances of SmallPtrSetIterator |
| CSmallSet | SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less than N) |
| CSmallSet< PointeeType *, N > | If this set is of pointer values, transparently switch over to using SmallPtrSet for performance |
| CSmallSetIterator | SmallSetIterator - This class implements a const_iterator for SmallSet by delegating to the underlying SmallVector or Set iterators |
| CSmallSetVector | A SetVector that performs no allocations if smaller than a certain size |
| CSmallString | SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better as a string (e.g |
| CSmallVector | This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small |
| CSmallVectorAlignmentAndSize | Figure out the offset of the first element |
| CSmallVectorBase | This is all the non-templated stuff common to all SmallVectors |
| CSmallVectorImpl | This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter |
| CSmallVectorMemoryBuffer | SmallVector-backed MemoryBuffer instance |
| CSmallVectorStorage | Storage for the SmallVector elements |
| CSmallVectorStorage< T, 0 > | We need the storage to be properly aligned even for small-size of 0 so that the pointer math in SmallVectorTemplateCommon::getFirstEl() is well-defined |
| CSmallVectorTemplateBase | SmallVectorTemplateBase<isPodLike = false> - This is where we put method implementations that are designed to work with non-POD-like T's |
| CSmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<isPodLike = true> - This is where we put method implementations that are designed to work with POD-like T's |
| CSmallVectorTemplateCommon | This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD |
| CSMDiagnostic | Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a caret diagnostic |
| CSMFixIt | Represents a single fixit, a replacement of one range of text with another |
| CSMLoc | Represents a location in source code |
| CSMRange | Represents a range in source code |
| CSMSchedule | This class represents the scheduled code |
| CSoftInstrProfErrors | |
| CSourceMgr | This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling |
| CSparcELFMCAsmInfo | |
| CSparcELFTargetObjectFile | |
| CSparcelTargetMachine | |
| CSparcFrameLowering | |
| CSparcInstPrinter | |
| CSparcInstrInfo | |
| CSparcMachineFunctionInfo | |
| CSparcMCExpr | |
| CSparcRegisterInfo | |
| CSparcSubtarget | |
| CSparcTargetAsmStreamer | |
| CSparcTargetELFStreamer | |
| CSparcTargetLowering | |
| CSparcTargetMachine | |
| CSparcTargetStreamer | |
| CSparcV8TargetMachine | Sparc 32-bit target machine |
| CSparcV9TargetMachine | Sparc 64-bit target machine |
| CSparseBitVector | |
| CSparseBitVectorElement | SparseBitVector is an implementation of a bitvector that is sparse by only storing the elements that have non-zero bits set |
| ►CSparseMultiSet | Fast multiset implementation for objects that can be identified by small unsigned keys |
| Citerator_base | Our iterators are iterators over the collection of objects that share a key |
| CSparseSet | SparseSet - Fast set implmentation for objects that can be identified by small unsigned keys |
| CSparseSetValFunctor | SparseSetValFunctor - Helper class for selecting SparseSetValTraits |
| CSparseSetValFunctor< KeyT, KeyT, KeyFunctorT > | SparseSetValFunctor<KeyT, KeyT> - Helper class for the common case of identity key/value sets |
| CSparseSetValTraits | SparseSetValTraits - Objects in a SparseSet are identified by keys that can be uniquely converted to a small integer less than the set's universe |
| CSparseSolver | SparseSolver - This class is a general purpose solver for Sparse Conditional Propagation with a programmable lattice function |
| ►CSpecialCaseList | |
| CMatcher | Represents a set of regular expressions |
| CSection | |
| CSpecificBumpPtrAllocator | A BumpPtrAllocator that allows only elements of a specific type to be allocated |
| CSpeculateAroundPHIsPass | This pass handles simple speculating of instructions around PHIs when doing so is profitable for a particular target despite duplicated instructions |
| CSpeculativeExecutionPass | |
| CSpiller | Spiller interface |
| ►CSpillPlacement | |
| CBlockConstraint | BlockConstraint - Entry and exit constraints for a basic block |
| CNode | Node - Each edge bundle corresponds to a Hopfield node |
| ►CSplitAnalysis | SplitAnalysis - Analyze a LiveInterval, looking for live range splitting opportunities |
| CBlockInfo | Additional information about basic blocks where the current variable is live |
| CSplitEditor | SplitEditor - Edit machine code and LiveIntervals for live range splitting |
| CSrcOp | |
| CSrcValueSDNode | An SDNode that holds an arbitrary LLVM IR Value |
| CSROA | An optimization pass providing Scalar Replacement of Aggregates |
| CSSAUpdater | Helper class for SSA formation on a set of values defined in multiple blocks |
| CSSAUpdaterBulk | Helper class for SSA formation on a set of values defined in multiple blocks |
| CSSAUpdaterImpl | |
| CSSAUpdaterTraits | |
| ►CSSAUpdaterTraits< MachineSSAUpdater > | |
| CPHI_iterator | Iterator for PHI operands |
| ►CSSAUpdaterTraits< SSAUpdater > | |
| CPHI_iterator | |
| CStackMapOpers | MI-level stackmap operands |
| ►CStackMaps | |
| CCallsiteInfo | |
| CFunctionInfo | |
| CLiveOutReg | |
| CLocation | |
| ►CStackMapV2Parser | |
| CAccessorIterator | |
| CConstantAccessor | Accessor for constants |
| CFunctionAccessor | Accessor for function records |
| CLiveOutAccessor | Accessor for stackmap live-out fields |
| CLocationAccessor | Accessor for location records |
| CRecordAccessor | Accessor for stackmap records |
| CStackProtector | |
| CStackSafetyAnalysis | StackSafetyInfo wrapper for the new pass manager |
| CStackSafetyGlobalAnalysis | This pass performs the global (interprocedural) stack safety analysis (new pass manager) |
| CStackSafetyGlobalInfoWrapperPass | This pass performs the global (interprocedural) stack safety analysis (legacy pass manager) |
| CStackSafetyGlobalPrinterPass | Printer pass for the StackSafetyGlobalAnalysis results |
| ►CStackSafetyInfo | Interface to access stack safety analysis results for single function |
| CFunctionInfo | Describes uses of allocas and parameters inside of a single function |
| CStackSafetyInfoWrapperPass | StackSafetyInfo wrapper for the legacy pass manager |
| CStackSafetyPrinterPass | Printer pass for the StackSafetyAnalysis results |
| CStandardInstrumentations | This class provides an interface to register all the standard pass instrumentations and manages their state (if any) |
| CStatepoint | A specialization of it's base class for read-write access to a gc.statepoint |
| CStatepointBase | Analogous to CallSiteBase, this provides most of the actual functionality for Statepoint and ImmutableStatepoint |
| CStatepointDirectives | 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 |
| CStatepointLoweringState | This class tracks both per-statepoint and per-selectiondag information |
| CStatepointOpers | MI-level Statepoint operands |
| CStatistic | |
| CStoreInfo | |
| CStoreInst | An instruction for storing to memory |
| CStoreSDNode | This class is used to represent ISD::STORE nodes |
| CStringAttributeImpl | |
| CStringError | This class wraps a string in an Error |
| CStringInit | "foo" - Represent an initialization by a string value |
| CStringLiteral | A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs with the length computed at compile time |
| CStringMap | StringMap - This is an unconventional map that is specialized for handling keys that are "strings", which are basically ranges of bytes |
| CStringMapConstIterator | |
| CStringMapEntry | StringMapEntry - This is used to represent one value that is inserted into a StringMap |
| CStringMapEntryBase | StringMapEntryBase - Shared base class of StringMapEntry instances |
| CStringMapImpl | StringMapImpl - This is the base class of StringMap that is shared among all of its instantiations |
| CStringMapIterator | |
| CStringMapIterBase | |
| CStringMapKeyIterator | |
| CStringMatcher | Given a list of strings and code to execute when they match, output a simple switch tree to classify the input string |
| CStringPool | StringPool - An interned string pool |
| CStringRecTy | 'string' - Represent an string value |
| CStringRef | StringRef - Represent a constant reference to a string, i.e |
| CStringSaver | Saves strings in the provided stable storage and returns a StringRef with a stable character pointer |
| CStringSet | StringSet - A wrapper for StringMap that provides set-like functionality |
| CStringSwitch | A switch()-like statement whose cases are string literals |
| CStringTableBuilder | Utility for building string tables with deduplicated suffixes |
| CStringToOffsetTable | StringToOffsetTable - This class uniques a bunch of nul-terminated strings and keeps track of their offset in a massive contiguous string allocation |
| CStripDeadPrototypesPass | Pass to remove unused function declarations |
| CStrOffsetsContributionDescriptor | Represents base address of the CU |
| CStructLayout | Used to lazily calculate structure layout information for a target machine, based on the DataLayout structure |
| CStructType | Class to represent struct types |
| CSubClassReference | |
| CSubMultiClassReference | |
| CSubOperator | |
| CSubtargetFeatureKV | Used to provide key value pairs for feature and CPU bit flags |
| CSubtargetFeatures | Manages the enabling and disabling of subtarget specific features |
| CSubtargetInfoKV | Used to provide key value pairs for CPU and arbitrary pointers |
| CSuccIterator | |
| CSUnit | Scheduling unit. This is a node in the scheduling DAG |
| CSUnitIterator | |
| CSuperRegClassIterator | |
| CSwingSchedulerDAG | This class builds the dependence graph for the instructions in a loop, and attempts to schedule the instructions using the SMS algorithm |
| ►CSwitchInst | Multiway switch |
| CCaseHandle | |
| CCaseHandleImpl | A handle to a particular switch case |
| CCaseIteratorImpl | |
| CSymbolCU | Helper used to pair up a symbol and its DWARF compile unit |
| CSymbolRemappingParseError | |
| CSymbolRemappingReader | Reader for symbol remapping files |
| CSymbolTableEntry | Symbol info for RuntimeDyld |
| CSymbolTableList | List that automatically updates parent links and symbol tables |
| CSymbolTableListParentType | Template metafunction to get the parent type for a symbol table list |
| CSymbolTableListTraits | |
| CSyncDependenceAnalysis | Relates points of divergent control to join points in reducible CFGs |
| CSyntheticCountsPropagation | |
| CSyntheticCountsUtils | Class with methods to propagate synthetic entry counts |
| CSysAlias | |
| CSysAliasReg | |
| CSystemZAsmPrinter | |
| CSystemZCCState | |
| CSystemZConstantPoolValue | A SystemZ-specific constant pool value |
| CSystemZFrameLowering | |
| CSystemZHazardRecognizer | SystemZHazardRecognizer maintains the state for one MBB during scheduling |
| CSystemZInstPrinter | |
| CSystemZInstrInfo | |
| CSystemZMachineFunctionInfo | |
| CSystemZMCAsmInfo | |
| CSystemZMCInstLower | |
| CSystemZPostRASchedStrategy | A MachineSchedStrategy implementation for SystemZ post RA scheduling |
| CSystemZRegisterInfo | |
| CSystemZSelectionDAGInfo | |
| CSystemZSubtarget | |
| CSystemZTargetLowering | |
| CSystemZTargetMachine | |
| CSystemZTTIImpl | |
| CTailCallElimPass | |
| CTailDuplicator | Utility class to perform tail duplication |
| CTarget | Target - Wrapper for Target specific information |
| CTargetFolder | TargetFolder - Create constants with target dependent folding |
| ►CTargetFrameLowering | Information about stack frame layout on the target |
| CSpillSlot | |
| CTargetIndexSDNode | Completely target-dependent object reference |
| ►CTargetInstrInfo | TargetInstrInfo - Interface to description of machine instruction set |
| CMachineBranchPredicate | Represents a predicate at the MachineFunction level |
| CRegSubRegPair | A pair composed of a register and a sub-register index |
| CRegSubRegPairAndIdx | A pair composed of a pair of a register and a sub-register index, and another sub-register index |
| CTargetIntrinsicInfo | TargetIntrinsicInfo - Interface to description of machine instruction set |
| CTargetIRAnalysis | Analysis pass providing the TargetTransformInfo |
| CTargetLibraryAnalysis | Analysis pass providing the TargetLibraryInfo |
| CTargetLibraryInfo | Provides information about what library functions are available for the current target |
| CTargetLibraryInfoImpl | Implementation of the target library information |
| CTargetLibraryInfoWrapperPass | |
| ►CTargetLowering | This class defines information used to lower LLVM code to legal SelectionDAG operators that the target instruction selector can accept natively |
| CAsmOperandInfo | This contains information for each constraint that we are lowering |
| CCallLoweringInfo | This structure contains all information that is necessary for lowering calls |
| CDAGCombinerInfo | |
| CTargetLoweringOpt | A convenience struct that encapsulates a DAG, and two SDValues for returning information from TargetLowering to its clients that want to combine |
| ►CTargetLoweringBase | This base class for TargetLowering contains the SelectionDAG-independent parts that can be used from the rest of CodeGen |
| CAddrMode | This represents an addressing mode of: BaseGV + BaseOffs + BaseReg + Scale*ScaleReg If BaseGV is null, there is no BaseGV |
| CArgListEntry | |
| CIntrinsicInfo | |
| CValueTypeActionImpl | |
| CTargetLoweringObjectFile | |
| CTargetLoweringObjectFileCOFF | |
| CTargetLoweringObjectFileELF | |
| CTargetLoweringObjectFileMachO | |
| CTargetLoweringObjectFileWasm | |
| CTargetMachine | Primary interface to the complete machine description for the target machine |
| CTargetMachineBuilder | Helper to gather options relevant to the target machine creation |
| CTargetOptions | |
| CTargetPassConfig | Target-Independent Code Generator Pass Configuration Options |
| CTargetRegisterClass | |
| ►CTargetRegisterInfo | 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 |
| CRegClassInfo | |
| CTargetRegisterInfoDesc | Extra information, not in MCRegisterDesc, about registers |
| ►CTargetRegistry | TargetRegistry - Generic interface to target specific features |
| Citerator | |
| CTargetSchedModel | Provide an instruction scheduling machine model to CodeGen passes |
| CTargetSubtargetInfo | TargetSubtargetInfo - Generic base class for all target subtargets |
| ►CTargetTransformInfo | This pass provides access to the codegen interfaces that are needed for IR-level transformations |
| CConcept | |
| CLSRCost | |
| CMemCmpExpansionOptions | If not nullptr, enable inline expansion of memcmp |
| CReductionFlags | Flags describing the kind of vector reduction |
| CUnrollingPreferences | Parameters that control the generic loop unrolling transformation |
| CTargetTransformInfoImplBase | Base class for use as a mix-in that aids implementing a TargetTransformInfo-compatible class |
| CTargetTransformInfoImplCRTPBase | CRTP base class for use as a mix-in that aids implementing a TargetTransformInfo-compatible class |
| CTargetTransformInfoWrapperPass | Wrapper pass for TargetTransformInfo |
| CTarWriter | |
| CTaskQueue | TaskQueue executes serialized work on a user-defined Thread Pool |
| CTBAAVerifier | Verify that the TBAA Metadatas are valid |
| CTempMDNodeDeleter | |
| CTernOpInit | !op (X, Y, Z) - Combine two inits |
| CTextInstrProfReader | Reader for the simple text based instrprof format |
| CTGLexer | TGLexer - TableGen Lexer class |
| CTGParser | |
| CThinLTOBitcodeWriterPass | |
| CThinLTOBuffer | Wrapper around MemoryBufferRef, owning the identifier |
| ►CThinLTOCodeGenerator | This class define an interface similar to the LTOCodeGenerator, but adapted for ThinLTO processing |
| CCachingOptions | |
| CThreadPool | A ThreadPool for asynchronous parallel execution on a defined number of threads |
| CThreadSafeRefCountedBase | A thread-safe version of RefCountedBase |
| CThreadSanitizerPass | A function pass for tsan instrumentation |
| CThumb1FrameLowering | |
| CThumb1InstrInfo | |
| CThumb2InstrInfo | |
| CThumbRegisterInfo | |
| CTimePassesHandler | This class implements -time-passes functionality for new pass manager |
| CTimer | This class is used to track the amount of time spent between invocations of its startTimer()/stopTimer() methods |
| CTimeRecord | |
| CTimeRegion | Used as a helper class to call the startTimer() and stopTimer() methods of the Timer class |
| CTimerGroup | Used to group together related timers into a single report that is printed when the TimerGroup is destroyed |
| CTinyPtrVector | 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 |
| CToolOutputFile | This class contains a raw_fd_ostream and adds a few extra features commonly needed for compiler-like tool output files: |
| CTrace | |
| CTrackingMDRef | Tracking metadata reference |
| CTrackingVH | Value handle that tracks a Value across RAUW |
| CTrackUnresolvedResolver | (Optionally) delegate resolving to a sub-resolver, and keep track whether there were unresolved references |
| ►CTrailingObjects | See the file comment for details on the usage of the TrailingObjects type |
| ►CFixedSizeStorage | 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 |
| Cwith_counts | |
| CFixedSizeStorageOwner | A type that acts as the owner for an object placed into fixed storage |
| CTrigramIndex | |
| CTriple | Triple - Helper class for working with autoconf configuration names |
| CTruncInst | This class represents a truncation of integer types |
| CTruncInstCombine | |
| CTruncSStoreSDNode | |
| CTruncUSStoreSDNode | |
| CTwine | Twine - A lightweight data structure for efficiently representing the concatenation of temporary values as strings |
| CType | The instances of the Type class are immutable: once they are created, they are never changed |
| CTypeBasedAA | Analysis pass providing a never-invalidated alias analysis result |
| CTypeBasedAAResult | A simple AA result that uses TBAA metadata to answer queries |
| CTypeBasedAAWrapperPass | Legacy wrapper pass to provide the TypeBasedAAResult object |
| CTypeConversionCostTblEntry | Type Conversion Cost Table |
| CTypedDINodeRef | Holds a subclass of DINode |
| CTypedInit | This is the common super-class of types that have a specific, explicit, type |
| CTypedMDOperandIterator | Typed iterator through MDNode operands |
| CTypedTrackingMDRef | Typed tracking ref |
| CTypeFinder | TypeFinder - Walk over a module, identifying all of the types that are used by the module |
| CTypeIdSummary | |
| CTypeTestResolution | |
| CUDivOperator | |
| CUint24 | An auxiliary type to facilitate extraction of 3-byte entities |
| CUIToFPInst | This class represents a cast unsigned integer to floating point |
| CUnaryConstantExpr | UnaryConstantExpr - This class is private to Constants.cpp, and is used behind the scenes to implement unary constant exprs |
| CUnaryInstruction | |
| CUnaryOperator | Unary instruction |
| CUndefValue | 'undef' values are things that do not have specified contents |
| CUnderlyingObject | |
| CUnifyFunctionExitNodes | |
| Cunique_function | |
| Cunique_function< ReturnT(ParamTs...)> | |
| Cunique_lock | A pared-down imitation of std::unique_lock from C++11 |
| CUniqueMachineInstr | A class that wraps MachineInstrs and derives from FoldingSetNode in order to be uniqued in a CSEMap |
| CUniqueStringSaver | Saves strings in the provided stable storage and returns a StringRef with a stable character pointer |
| CUniqueVector | UniqueVector - This class produces a sequential ID number (base 1) for each unique entry that is added |
| CUnOpInit | !op (X) - Transform an init |
| CUnreachableBlockElimPass | |
| CUnreachableInst | This function has undefined behavior |
| CUnrolledInstAnalyzer | |
| CUnsetInit | '?' - Represents an uninitialized value |
| CUnwindOpcodeAssembler | |
| Cupward_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 |
| ►CUse | A Use represents the edge between a Value definition and its users |
| CPrevPointerTraits | Pointer traits for the Prev PointerIntPair |
| CUserRefPointerTraits | Pointer traits for the UserRef PointerIntPair |
| CUseListOrder | Structure to hold a use-list order |
| ►CUser | |
| Cconst_value_op_iterator | |
| Cvalue_op_iterator | Iterator for directly iterating over the operand Values |
| CVAArgInst | This class represents the va_arg llvm instruction, which returns an argument of the specified type given a va_list and increments that list |
| CVACopyInst | This represents the llvm.va_copy intrinsic |
| CVAEndInst | This represents the llvm.va_end intrinsic |
| CValID | ValID - Represents a reference of a definition of some sort with no type |
| Cvalidate_format_parameters | These are templated helper classes used by the format function that capture the object to be formatted and the format string |
| Cvalidate_format_parameters< Arg, Args... > | |
| Cvalidate_format_parameters<> | |
| CValue | LLVM Value Representation |
| CValueAsMetadata | Value wrapper in the Metadata hierarchy |
| CValueDeleter | |
| CValueEnumerator | |
| CValueHandleBase | This is the common base class of value handles |
| CValueInfo | Struct that holds a reference to a particular GUID in a global value summary |
| CValueLatticeElement | |
| CValueMap | See the file comment |
| CValueMapCallbackVH | |
| ►CValueMapConfig | This class defines the default behavior for configurable aspects of ValueMap<> |
| CExtraData | |
| ►CValueMapConstIterator | |
| CValueTypeProxy | |
| ►CValueMapIterator | |
| CValueTypeProxy | |
| CValueMapper | Context for (re-)mapping values (and metadata) |
| CValueMapTypeRemapper | This is a class that can be implemented by clients to remap types when cloning constants and instructions |
| CValueMaterializer | This is a class that can be implemented by clients to materialize Values on demand |
| CValueSymbolTable | This class provides a symbol table of name/value pairs |
| CVarBitInit | Opcode{0} - Represent access to one bit of a variable or field |
| CVarDefInit | Classname<targs...> - Represent an uninstantiated anonymous class instantiation |
| CVariadicFunction | Class which can simulate a type-safe variadic function |
| CVariadicFunction1 | |
| CVariadicFunction2 | |
| CVariadicFunction3 | |
| CVariadicOperandTraits | 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 |
| CVarInit | 'Opcode' - Represent a reference to an entire variable object |
| CVarListElementInit | List[4] - Represent access to one element of a var or field |
| CVarStreamArray | |
| CVarStreamArrayExtractor | VarStreamArrayExtractor is intended to be specialized to provide customized extraction logic |
| CVarStreamArrayExtractor< codeview::CrossModuleImportItem > | |
| CVarStreamArrayExtractor< codeview::CVRecord< Kind > > | |
| CVarStreamArrayExtractor< codeview::DebugSubsectionRecord > | |
| CVarStreamArrayExtractor< codeview::FileChecksumEntry > | |
| CVarStreamArrayExtractor< codeview::InlineeSourceLine > | |
| CVarStreamArrayExtractor< pdb::DbiModuleDescriptor > | |
| CVarStreamArrayIterator | VarStreamArray represents an array of variable length records backed by a stream |
| CVAStartInst | This represents the llvm.va_start intrinsic |
| CVecDesc | Describes a possible vectorization of a function |
| CVectorizationFactor | TODO: The following VectorizationFactor was pulled out of LoopVectorizationCostModel class |
| CVectorizeConfig | Vectorize configuration |
| CVectorizerParams | Collection of parameters shared beetween the Loop Vectorizer and the Loop Access Analysis |
| CVectorizerValueMap | This is a helper struct for maintaining vectorization state |
| CVectorType | Class to represent vector types |
| ►CVerifierAnalysis | Check a module for errors, and report separate error states for IR and debug info errors |
| CResult | |
| CVerifierPass | Create a verifier pass |
| CVerifierSupport | |
| CVersionTuple | Represents a version number in the form major[.minor[.subminor[.build]]] |
| CVFRange | A range of powers-of-2 vectorization factors with fixed start and adjustable end |
| CVirtReg2IndexFunctor | |
| CVirtRegAuxInfo | Calculate auxiliary information for a virtual register such as its spill weight and allocation hint |
| CVirtRegMap | |
| CVLIWMachineScheduler | Extend the standard ScheduleDAGMI to provide more context and override the top-level schedule() driver |
| CVLIWPacketizerList | |
| CVLIWResourceModel | |
| CVNInfo | VNInfo - Value Number Information |
| CVPBasicBlock | VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph |
| CVPBlendRecipe | A recipe for vectorizing a phi-node as a sequence of mask-based select instructions |
| CVPBlockBase | VPBlockBase is the building block of the Hierarchical Control-Flow Graph |
| CVPBlockUtils | Class that provides utilities for VPBlockBases in VPlan |
| CVPBranchOnMaskRecipe | A recipe for generating conditional branches on the bits of a mask |
| ►CVPBuilder | VPlan-based builder utility analogous to IRBuilder |
| CInsertPointGuard | RAII object that stores the current insertion point and restores it when the object is destroyed |
| CVPInsertPoint | InsertPoint - A saved insertion point |
| CVPCallback | This class is used to enable the VPlan to invoke a method of ILV |
| CVPInstruction | This is a concrete Recipe that models a single VPlan-level instruction |
| CVPInterleavedAccessInfo | |
| CVPInterleaveRecipe | VPInterleaveRecipe is a recipe for transforming an interleave group of load or stores into one wide load/store and shuffles |
| CVPIteration | In what follows, the term "input IR" refers to code that is fed into the vectorizer whereas the term "output IR" refers to code that is generated by the vectorizer |
| CVPlan | VPlan models a candidate for vectorization, encoding various decisions take to produce efficient output IR, including which branches, basic-blocks and output IR instructions to generate, and their cost |
| CVPlanHCFGBuilder | Main class to build the VPlan H-CFG for an incoming IR |
| CVPlanHCFGTransforms | |
| CVPlanIngredient | |
| CVPlanPrinter | VPlanPrinter prints a given VPlan to a given output stream |
| CVPlanSlp | Class that maps (parts of) an existing VPlan to trees of combined VPInstructions |
| CVPlanVerifier | Class with utility functions that can be used to check the consistency and invariants of a VPlan, including the components of its H-CFG |
| CVPLoop | Hold analysis information for every loop detected by VPLoopInfo |
| CVPPredInstPHIRecipe | VPPredInstPHIRecipe is a recipe for generating the phi nodes needed when control converges back from a Branch-on-Mask |
| CVPRecipeBase | VPRecipeBase is a base class modeling a sequence of one or more output IR instructions |
| CVPRecipeBuilder | Helper class to create VPRecipies from IR instructions |
| CVPRegionBlock | VPRegionBlock represents a collection of VPBasicBlocks and VPRegionBlocks which form a Single-Entry-Single-Exit subgraph of the output IR CFG |
| CVPReplicateRecipe | VPReplicateRecipe replicates a given instruction producing multiple scalar copies of the original scalar type, one per lane, instead of producing a single copy of widened type for all lanes |
| ►CVPTransformState | VPTransformState holds information passed down when "executing" a VPlan, needed for generating the output IR |
| CCFGState | Hold state information used when constructing the CFG of the output IR, traversing the VPBasicBlocks and generating corresponding IR BasicBlocks |
| CDataState | |
| CVPUser | This class augments VPValue with operands which provide the inverse def-use edges from VPValue's users to their defs |
| CVPValue | |
| CVPWidenIntOrFpInductionRecipe | A recipe for handling phi nodes of integer and floating-point inductions, producing their vector and scalar values |
| CVPWidenMemoryInstructionRecipe | A Recipe for widening load/store operations |
| CVPWidenPHIRecipe | A recipe for handling all phi nodes except for integer and FP inductions |
| CVPWidenRecipe | VPWidenRecipe is a recipe for producing a copy of vector type for each Instruction in its ingredients independently, in order |
| CVReg2SUnit | An individual mapping from virtual register number to SUnit |
| CVReg2SUnitOperIdx | Mapping from virtual register to SUnit including an operand index |
| CVRegInfo | |
| CVTSDNode | This class is used to represent EVT's, which are used to parameterize some operations |
| CWarnMissedTransformationsPass | |
| CWasmEHFuncInfo | |
| CWasmException | |
| CWeakTrackingVH | Value handle that is nullable, but tries to track the Value |
| CWeakVH | A nullable Value handle that is nullable |
| CWebAssemblyAsmPrinter | |
| CWebAssemblyDebugValueManager | |
| CWebAssemblyException | |
| CWebAssemblyExceptionInfo | |
| CWebAssemblyFrameLowering | |
| CWebAssemblyFunctionInfo | This class is derived from MachineFunctionInfo and contains private WebAssembly-specific information for each MachineFunction |
| CWebAssemblyInstPrinter | |
| CWebAssemblyInstrInfo | |
| CWebAssemblyMCAsmInfo | |
| CWebAssemblyMCInstLower | This class is used to lower an MachineInstr into an MCInst |
| CWebAssemblyRegisterInfo | |
| CWebAssemblySelectionDAGInfo | |
| CWebAssemblySubtarget | |
| CWebAssemblyTargetAsmStreamer | This part is for ascii assembly output |
| CWebAssemblyTargetLowering | |
| CWebAssemblyTargetMachine | |
| CWebAssemblyTargetNullStreamer | This part is for null output |
| CWebAssemblyTargetObjectFile | |
| CWebAssemblyTargetStreamer | WebAssembly-specific streamer interface, to implement support WebAssembly-specific assembly directives |
| CWebAssemblyTargetWasmStreamer | This part is for Wasm object output |
| CWebAssemblyTTIImpl | |
| CWholeProgramDevirtPass | |
| ►CWholeProgramDevirtResolution | |
| CByArg | |
| CWinCFGuard | |
| CWindowsResourceProcessor | |
| CWinEHFuncInfo | |
| CWinEHHandlerType | |
| CWinEHTryBlockMapEntry | |
| CWinException | |
| CWithColor | An RAII object that temporarily switches an output stream to a specific color |
| CWrappedPairNodeDataIterator | |
| CWritableBinaryStream | A BinaryStream which can be read from as well as written to |
| CWritableBinaryStreamRef | |
| CWritableMemoryBuffer | This class is an extension of MemoryBuffer, which allows copy-on-write access to the underlying contents |
| CWriteThroughMemoryBuffer | This class is an extension of MemoryBuffer, which allows write access to the underlying contents and committing those changes to the original source |
| CX86_64MachoTargetObjectFile | X86_64MachoTargetObjectFile - This TLOF implementation is used for Darwin x86-64 |
| CX86_64MCAsmInfoDarwin | |
| CX86AddressMode | X86AddressMode - This struct holds a generalized full x86 address mode |
| CX86AsmInstrumentation | |
| CX86AsmPrinter | |
| CX86ATTInstPrinter | |
| CX86CallLowering | |
| CX86ELFMCAsmInfo | |
| CX86ELFTargetObjectFile | This implemenatation is used for X86 ELF targets that don't have a further specialization |
| CX86FrameLowering | |
| CX86FreeBSDTargetObjectFile | X86FreeBSDTargetObjectFile - This implementation is used for FreeBSD on x86 and x86-64 |
| CX86FuchsiaTargetObjectFile | This implementation is used for Fuchsia on x86-64 |
| CX86GenRegisterBankInfo | |
| CX86InstPrinterCommon | |
| CX86InstrFMA3Group | This class is used to group {132, 213, 231} forms of FMA opcodes together |
| CX86InstrInfo | |
| CX86IntelInstPrinter | |
| CX86LegalizerInfo | This class provides the information for the target register banks |
| CX86LinuxNaClTargetObjectFile | X86LinuxNaClTargetObjectFile - This implementation is used for linux and Native Client on x86 and x86-64 |
| CX86MachineFunctionInfo | X86MachineFunctionInfo - This class is derived from MachineFunction and contains private X86 target-specific information for each MachineFunction |
| CX86MaskedGatherScatterSDNode | |
| CX86MaskedGatherSDNode | |
| CX86MaskedScatterSDNode | |
| CX86MaskedStoreSDNode | |
| CX86MCAsmInfoDarwin | |
| CX86MCAsmInfoGNUCOFF | |
| CX86MCAsmInfoMicrosoft | |
| CX86MCExpr | |
| CX86MemoryFoldTableEntry | |
| ►CX86Operand | X86Operand - Instances of this class represent a parsed X86 machine instruction |
| CImmOp | |
| CMemOp | |
| CPrefOp | |
| CRegOp | |
| CTokOp | |
| CX86RegisterBankInfo | This class provides the information for the target register banks |
| CX86RegisterInfo | |
| CX86SelectionDAGInfo | |
| CX86SolarisTargetObjectFile | This implementation is used for Solaris on x86/x86-64 |
| CX86StoreSDNode | |
| CX86Subtarget | |
| CX86TargetLowering | |
| CX86TargetMachine | |
| CX86TargetStreamer | X86 target streamer implementing x86-only assembly directives |
| CX86TTIImpl | |
| CXCoreFrameLowering | |
| CXCoreFunctionInfo | XCoreFunctionInfo - This class is derived from MachineFunction private XCore target-specific information for each MachineFunction |
| CXCoreInstPrinter | |
| CXCoreInstrInfo | |
| CXCoreMCAsmInfo | |
| CXCoreMCInstLower | This class is used to lower an MachineInstr into an MCInst |
| CXCoreRegisterInfo | |
| CXCoreSelectionDAGInfo | |
| CXCoreSubtarget | |
| CXCoreTargetLowering | |
| CXCoreTargetMachine | |
| CXCoreTargetObjectFile | |
| CXCoreTargetStreamer | |
| CXCoreTTIImpl | |
| CZExtInst | This class represents zero extension of integer types |
| CZExtOperator | |
| ►Nstd | |
| Chash< llvm::pdb::PDB_SymType > | |
| Cis_error_code_enum< llvm::BitcodeError > | |
| Cis_error_code_enum< llvm::codeview::cv_error_code > | |
| Cis_error_code_enum< llvm::errc > | |
| Cis_error_code_enum< llvm::msf::msf_error_code > | |
| Cis_error_code_enum< llvm::object::object_error > | |
| Cis_error_code_enum< llvm::pdb::dia_error_code > | |
| Cis_error_code_enum< llvm::pdb::pdb_error_code > | |
| Cis_error_code_enum< llvm::pdb::raw_error_code > | |
| Cis_error_code_enum< llvm::sampleprof_error > | |
| Creverse_iterator< llvm::DWARFDie::iterator > | |
| C___itt_api_info | |
| C___itt_api_info_20101001 | |
| C___itt_global | |
| C___itt_group_list | |
| C___itt_thread_info | |
| C_iJIT_Method_Id | |
| C_iJIT_Method_Load | |
| C_iJIT_Method_NIDS | |
| C_LineNumberInfo | |
| CAArch64GenInstrInfo | |
| CAArch64GenRegisterInfo | |
| CAArch64GenSubtargetInfo | |
| CAArch64SetCCInfo | Helper structure to keep track of a SET_CC lowered into AArch64 code |
| CAddressingMode | |
| CAddSubFlagsOpcodePair | Map pseudo instructions that imply an 'S' bit onto real opcodes |
| CAllocFnsTy | |
| Camd_kernel_code_s | AMD Kernel Code Object (amd_kernel_code_t) |
| CAMDGPUGenInstrInfo | |
| CAMDGPUGenRegisterInfo | |
| CAMDGPUGenSubtargetInfo | |
| CArangeSpan | |
| CARCGenInstrInfo | |
| CARCGenRegisterInfo | |
| CARCGenSubtargetInfo | |
| CARM_MLxEntry | ARM_MLxEntry - Record information about MLA / MLS instructions |
| CARMGenInstrInfo | |
| CARMGenRegisterInfo | |
| CARMGenSubtargetInfo | |
| CAVRGenInstrInfo | |
| CAVRGenRegisterInfo | |
| CAVRGenSubtargetInfo | |
| CB1 | |
| CBase | |
| CBasicBlockState | State we compute and track per basic block |
| CBinopElts | These are the ingredients in an alternate form binary operator as described below |
| CBlockData | |
| CBlockSplitInfo | |
| CBPFGenInstrInfo | |
| CBPFGenRegisterInfo | |
| CBPFGenSubtargetInfo | |
| CBuiltinTypeEntry | |
| CCallbackAndCookie | |
| Ccclass | |
| Ccname | |
| CCodeViewErrorCategory | |
| CCompareInsn | |
| CContextDecision | Specifies which opcode->instruction tables to look at given a particular context (set of attributes) |
| Ccset | |
| CCVIUnits | |
| CDataType | |
| CDbgValueLocation | Describes a location by number along with some flags about the original usage of the location |
| CDIAErrorCategory | |
| CExtension | |
| CFileChecksumEntryHeader | |
| CFoldableLoadExtendsStruct | |
| CGenericSetCCInfo | Helper structure to keep track of ISD::SET_CC operands |
| CHexagonGenInstrInfo | |
| CHexagonGenRegisterInfo | |
| CHexagonGenSubtargetInfo | |
| Chsa_dim3_s | |
| Chsa_ext_control_directives_s | The hsa_ext_control_directives_t specifies the values for the HSAIL control directives |
| CInsnMatchEntry | |
| CInstructionMapping | Helper class that represents how the value of an instruction may be mapped and what is the related cost of such mapping |
| Cjit_code_entry | |
| Cjit_descriptor | |
| CLanaiGenInstrInfo | |
| CLanaiGenRegisterInfo | |
| CLanaiGenSubtargetInfo | |
| CLdStNInstrDesc | |
| Cllvm_regex | |
| Cllvm_regmatch_t | |
| CLLVMMCJITCompilerOptions | |
| CLLVMOpaqueModuleFlagEntry | |
| CLLVMOpaqueValueMetadataEntry | |
| CLLVMOpInfo1 | |
| CLLVMOpInfoSymbol1 | The initial support in LLVM MC for the most general form of a relocatable expression is "AddSymbol - SubtractSymbol + Offset" |
| CLLVMOptRemarkArg | Element of the "Args" list |
| CLLVMOptRemarkDebugLoc | DebugLoc containing File, Line and Column |
| CLLVMOptRemarkEntry | One remark entry |
| CLLVMOptRemarkStringRef | String containing a buffer and a length |
| CLOHInfo | State tracked per register |
| CLTOObjectBuffer | Type to wrap a single object returned by ThinLTO |
| CMachOElement | |
| CMaskOps | This is used by foldAnyOrAllBitsSet() to capture a source value (Root) and the bit indexes (Mask) needed by a masked compare |
| CMipsGenInstrInfo | |
| CMipsGenRegisterInfo | |
| CMipsGenSubtargetInfo | |
| CModRMDecision | Specifies whether a ModR/M byte is needed and (if so) which instruction each possible value of the ModR/M byte corresponds to |
| CMSFErrorCategory | |
| CMSP430GenInstrInfo | |
| CMSP430GenRegisterInfo | |
| CMSP430GenSubtargetInfo | |
| CNewHandlerInstaller | |
| CNodeList | |
| CNVPTXGenInstrInfo | |
| CNVPTXGenRegisterInfo | |
| CNVPTXGenSubtargetInfo | |
| COpcodeDecision | Specifies which set of ModR/M->instruction tables to look at given a particular opcode |
| COperandsMapper | Helper class used to get/create the virtual registers that will be used to replace the MachineOperand when applying a mapping |
| COutputStream | |
| Cparse | |
| CPartialMapping | Helper struct that represents how a value is partially mapped into a register |
| CPatchItem | |
| CPDBErrorCategory | |
| CPPCGenInstrInfo | |
| CPPCGenRegisterInfo | |
| CPPCGenSubtargetInfo | |
| CPredicate | |
| CR600GenInstrInfo | |
| CR600GenRegisterInfo | |
| CR600GenSubtargetInfo | |
| CRawErrorCategory | |
| Cre_guts | |
| CRegisterAsmPrinter | RegisterAsmPrinter - Helper template for registering a target specific assembly printer, for use in the target machine initialization function |
| CRegisterMCAsmBackend | RegisterMCAsmBackend - Helper template for registering a target specific assembler backend |
| CRegisterMCAsmInfo | RegisterMCAsmInfo - Helper template for registering a target assembly info implementation |
| CRegisterMCAsmInfoFn | RegisterMCAsmInfoFn - Helper template for registering a target assembly info implementation |
| CRegisterMCAsmParser | RegisterMCAsmParser - Helper template for registering a target specific assembly parser, for use in the target machine initialization function |
| CRegisterMCCodeEmitter | RegisterMCCodeEmitter - Helper template for registering a target specific machine code emitter, for use in the target initialization function |
| CRegisterMCInstrAnalysis | RegisterMCInstrAnalysis - Helper template for registering a target instruction analyzer implementation |
| CRegisterMCInstrAnalysisFn | RegisterMCInstrAnalysisFn - Helper template for registering a target instruction analyzer implementation |
| CRegisterMCInstrInfo | RegisterMCInstrInfo - Helper template for registering a target instruction info implementation |
| CRegisterMCInstrInfoFn | RegisterMCInstrInfoFn - Helper template for registering a target instruction info implementation |
| CRegisterMCRegInfo | RegisterMCRegInfo - Helper template for registering a target register info implementation |
| CRegisterMCRegInfoFn | RegisterMCRegInfoFn - Helper template for registering a target register info implementation |
| CRegisterMCSubtargetInfo | RegisterMCSubtargetInfo - Helper template for registering a target subtarget info implementation |
| CRegisterMCSubtargetInfoFn | RegisterMCSubtargetInfoFn - Helper template for registering a target subtarget info implementation |
| CRegisterTarget | |
| CRegisterTargetMachine | RegisterTargetMachine - Helper template for registering a target machine implementation, for use in the target machine initialization function |
| Crerr | |
| CRISCVGenInstrInfo | |
| CRISCVGenRegisterInfo | |
| CRISCVGenSubtargetInfo | |
| CSetCCInfo | Helper structure to keep track of SetCC information |
| CSetCCInfoAndKind | Helper structure to be able to read SetCC information |
| CShadowMemoryParams | |
| CSparcGenInstrInfo | |
| CSparcGenRegisterInfo | |
| CSparcGenSubtargetInfo | |
| CStatus | |
| CStringView | |
| CSwapAndRestore | |
| CSymInfo | SymInfo contains information about symbol: it's address and section index which is -1LL for absolute symbols |
| CSystemZGenInstrInfo | |
| CSystemZGenRegisterInfo | |
| CSystemZGenSubtargetInfo | |
| CT | |
| CTableRef | |
| CThreadStack | |
| Ctype | |
| CTypedVReg | |
| CUnitT | |
| CUstarHeader | |
| CValueMapping | Helper struct that represents how a value is mapped through different register banks |
| CWebAssemblyGenInstrInfo | |
| CWebAssemblyGenRegisterInfo | |
| CWebAssemblyGenSubtargetInfo | |
| CX86EvexToVexCompressTableEntry | |
| CX86GenInstrInfo | |
| CX86GenRegisterInfo | |
| CX86GenSubtargetInfo | |
| CXCoreGenInstrInfo | |
| CXCoreGenRegisterInfo | |
| CXCoreGenSubtargetInfo | |
