Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123456]
| Ncir | |
| Nacc | |
| COpenACCPointerLikeModel | |
| Ndetail | |
| CRecordTypeStorage | Type storage for CIR record types |
| CKeyTy | |
| Ndirect | |
| CCIRAttrToValue | |
| CCIRDialectLLVMIRTranslationInterface | Implementation of the dialect interface that converts CIR attributes to LLVM IR metadata |
| CConvertCIRToLLVMPass | |
| CGlobalInitAttrRewriter | |
| CLLVMBlockAddressInfo | |
| CABIArgInfo | |
| CCIRBaseBuilderTy | |
| CGetMethodResults | |
| CCIRCXXABI | |
| CCIRDataLayout | |
| CCIRGenAction | |
| CCIRGenConsumer | |
| CCIRGenerator | |
| CEmitAssemblyAction | |
| CEmitBCAction | |
| CEmitCIRAction | |
| CEmitLLVMAction | |
| CEmitObjAction | |
| CLowerModule | |
| CMissingFeatures | |
| CTargetLoweringInfo | |
| Nclang | The JSON file list parser is used to communicate input to InstallAPI |
| Nanalyze_format_string | Common components of both fprintf and fscanf format strings |
| CArgType | |
| CConversionSpecifier | |
| CFormatSpecifier | |
| CFormatStringHandler | |
| CLengthModifier | Represents the length modifier in a format string in scanf/printf |
| COptionalAmount | |
| COptionalFlag | Class representing optional flags with location and representation information |
| CSpecifierResult | |
| Nanalyze_os_log | |
| COSLogBufferItem | An OSLogBufferItem represents a single item in the data written by a call to os_log() or os_trace() |
| COSLogBufferLayout | |
| Nanalyze_printf | Pieces specific to fprintf format strings |
| CArgType | |
| CLengthModifier | Represents the length modifier in a format string in scanf/printf |
| COptionalAmount | |
| COptionalFlag | Class representing optional flags with location and representation information |
| CPrintfConversionSpecifier | |
| CPrintfSpecifier | |
| Nanalyze_scanf | Pieces specific to fscanf format strings |
| CArgType | |
| CLengthModifier | Represents the length modifier in a format string in scanf/printf |
| COptionalAmount | |
| COptionalFlag | Class representing optional flags with location and representation information |
| CScanfConversionSpecifier | |
| CScanfSpecifier | |
| Napi_notes | |
| CAPINotesManager | The API notes manager helps find API notes associated with declarations |
| CAPINotesReader | A class that reads API notes data from a binary file that was written by the APINotesWriter |
| CImplementation | |
| CVersionedInfo | Captures the completed versioned information for a particular part of API notes, including both unversioned API notes and each versioned API note for that particular entity |
| CAPINotesWriter | A class that writes API notes data to a binary representation that can be read by the APINotesReader |
| CImplementation | |
| CCommonEntityInfo | Describes API notes data for any entity |
| CCommonTypeInfo | Describes API notes for types |
| CContext | |
| CContextID | Opaque context ID used to refer to an Objective-C class or protocol or a C++ namespace |
| CContextInfo | Describes API notes data for an Objective-C class or protocol or a C++ namespace |
| CContextTableKey | A stored Objective-C or C++ context, represented by the ID of its parent context, the kind of this context (Objective-C class / C++ namespace / etc), and the ID of this context |
| CCXXMethodInfo | Describes API notes data for a C++ method |
| CEnumConstantInfo | Describes API notes data for an enumerator |
| CFieldInfo | Describes API notes data for a C/C++ record field |
| CFunctionInfo | API notes for a function or method |
| CGlobalFunctionInfo | Describes API notes data for a global function |
| CGlobalVariableInfo | Describes API notes data for a global variable |
| CObjCMethodInfo | Describes API notes data for an Objective-C method |
| CObjCPropertyInfo | Describes API notes data for an Objective-C property |
| CObjCSelectorRef | A temporary reference to an Objective-C selector, suitable for referencing selector data on the stack |
| CParamInfo | Describes a function or method parameter |
| CSingleDeclTableKey | A stored Objective-C or C++ declaration, represented by the ID of its parent context, and the name of the declaration |
| CStoredObjCSelector | A stored Objective-C selector |
| CTagInfo | Describes API notes data for a tag |
| CTypedefInfo | Describes API notes data for a typedef |
| CVariableInfo | API notes for a variable/property |
| Nast_matchers | |
| Ndynamic | |
| Ninternal | |
| CAdaptativeOverloadCollector | Helper class used to collect all the possible overloads of an argument adaptative matcher function |
| CArgTypeTraits | Helper template class to just from argument type to the right is/get functions in VariantValue |
| CArgTypeTraits< ast_matchers::internal::Matcher< T > > | |
| CArgTypeTraits< attr::Kind > | |
| CArgTypeTraits< bool > | |
| CArgTypeTraits< CastKind > | |
| CArgTypeTraits< const T & > | |
| CArgTypeTraits< double > | |
| CArgTypeTraits< llvm::Regex::RegexFlags > | |
| CArgTypeTraits< OpenMPClauseKind > | |
| CArgTypeTraits< std::string > | |
| CArgTypeTraits< StringRef > | |
| CArgTypeTraits< UnaryExprOrTypeTrait > | |
| CArgTypeTraits< unsigned > | |
| CBuildReturnTypeVector | |
| CBuildReturnTypeVector< ast_matchers::internal::BindableMatcher< T > > | |
| CBuildReturnTypeVector< ast_matchers::internal::Matcher< T > > | |
| CDynCastAllOfMatcherDescriptor | Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers |
| CFixedArgCountMatcherDescriptor | Simple callback implementation |
| CMapAnyOfBuilderDescriptor | |
| CMapAnyOfMatcherDescriptor | |
| CMatcherDescriptor | Matcher descriptor interface |
| CMatcherDescriptorPtr | A smart (owning) pointer for MatcherDescriptor |
| COverloadedMatcherDescriptor | MatcherDescriptor that wraps multiple "overloads" of the same matcher |
| CRegexMatcherDescriptor | |
| CVariadicFuncMatcherDescriptor | Matcher descriptor for variadic functions |
| CVariadicOperatorMatcherDescriptor | Variadic operator marshaller function |
| CArgKind | Kind identifier |
| CDiagnostics | Helper class to manage error messages |
| CArgStream | Helper stream class |
| CContext | Class defining a parser context |
| CContextFrame | Information stored for one frame of the context |
| CErrorContent | Information stored for each error found |
| CMessage | |
| COverloadContext | Context for overloaded matcher construction |
| CMatcherCompletion | |
| CMatcherDescriptor | Matcher descriptor interface |
| CParser | Matcher expression parser |
| CCodeTokenizer | Simple tokenizer for the parser |
| CRegistrySema | Sema implementation that uses the matcher registry to process the tokens |
| CScopedContextEntry | |
| CSema | Interface to connect the parser with the registry and more |
| CTokenInfo | Simple structure to hold information for one token from the parser |
| CParserValue | A VariantValue instance annotated with its parser context |
| CRegistry | |
| CSourceLocation | |
| CSourceRange | |
| CVariantMatcher | A variant matcher object |
| CPolymorphicPayload | |
| CSinglePayload | |
| CVariadicOpPayload | |
| CVariantValue | Variant value class |
| Ninternal | |
| CCollectMatchesCallback | |
| CBoundNodes | Maps string IDs to AST nodes matched by parts of a matcher |
| CMatchFinder | A class to allow finding matches over the Clang AST |
| CMatchCallback | Called when the Match registered for it was successfully found in the AST |
| CMatchersByType | For each Matcher<> a MatchCallback that will be called when it matches |
| CMatchFinderOptions | |
| CProfiling | |
| CMatchResult | Contains all information for a given match |
| CParsingDoneTestCallback | Called when parsing is finished. Intended for testing only |
| Nattrvisitor | |
| CBase | A simple visitor class that helps create attribute visitors |
| NBuiltin | |
| CContext | Holds information about both target-independent and target-specific builtins, allowing easy queries by clients |
| CInfo | The info used to represent each builtin |
| CStrOffsets | |
| CInfosShard | A shard of a target's builtins string table and info |
| CTargetFeatures | TargetFeatures - This class is used to check whether the builtin function has the required target specific features |
| NCIRGen | |
| CABIInfo | |
| CAddress | |
| CAggValueSlot | An aggregate value slot |
| CBranchFixup | A branch fixup |
| CCallArg | |
| CCallArgList | |
| CCatchTypeInfo | The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler, so we use this wrapper |
| CCGCoroData | |
| CCIRGenBitFieldInfo | Record with information about how a bitfield should be accessed |
| CCIRGenBuilderTy | |
| CCIRGenCallee | |
| CCIRGenCalleeInfo | Abstract information about a function or function prototype |
| CCIRGenCXXABI | Implements C++ ABI-specific code generation functions |
| CAddedStructorArgCounts | Similar to AddedStructorArgs, but only notes the number of additional arguments |
| CAddedStructorArgs | Additional implicit arguments to add to the beginning (Prefix) and end (Suffix) of a constructor / destructor arg list |
| CArg | |
| CCIRGenFunction | |
| CAbstractCallee | An abstract representation of regular/ObjC call/message targets |
| CAutoVarEmission | |
| CInvalid | |
| CCGCoroInfo | |
| CConditionalEvaluation | An object to manage conditionally-evaluated expressions |
| CConditionalInfo | |
| CConstantEmission | |
| CCXXDefaultArgExprScope | |
| CCXXDefaultInitExprScope | The scope of a CXXDefaultInitExpr |
| CDeclMapRevertingRAII | |
| CFieldConstructionScope | A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr |
| CLexicalScope | Represents a scope, including function bodies, compound statements, and the substatements of if/while/do/for/switch/try statements |
| COpaqueValueMapping | An RAII object to set (and then clear) a mapping for an OpaqueValueExpr |
| COpaqueValueMappingData | A non-RAII class containing all the information about a bound opaque value |
| COpenACCDataOperandInfo | |
| CPrototypeWrapper | |
| CRunCleanupsScope | Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited |
| CSourceLocRAIIObject | |
| CStmtExprEvaluation | An RAII object to record that we're evaluating a statement expression |
| CVlaSizePair | |
| CVPtr | |
| CCIRGenFunctionInfo | |
| CCIRGenModule | This class organizes the cross-function state that is used while generating CIR code |
| CCIRGenRecordLayout | This class handles record and union layout info while lowering AST types to CIR types |
| CCIRGenTypeCache | This structure provides a set of types that are commonly used during IR emission |
| CCIRGenTypes | This class organizes the cross-module state that is used while lowering AST types to CIR types |
| CCIRGenVTables | |
| CConstantEmitter | |
| CEHCatchScope | A scope which attempts to handle some, possibly all, types of exceptions |
| CHandler | |
| CEHCleanupScope | A cleanup scope which generates the cleanup blocks lazily |
| CEHPersonality | The exceptions personality for a function |
| CEHScope | A protected scope for zero-cost EH handling |
| CCatchBitFields | |
| CCleanupBitFields | |
| CEHScopeStack | A stack of scopes which respond to exceptions, including cleanups and catch blocks |
| CCleanup | Information for lazily generating a cleanup |
| CFlags | Generation flags |
| Citerator | A non-stable pointer into the scope stack |
| Cstable_iterator | A saved depth on the scope stack |
| CFunctionArgList | Type for representing both the decl and type of parameters to a function |
| CLValue | |
| CLValueBaseInfo | |
| COpenACCRecipeBuilder | |
| COpenACCRecipeBuilderBase | |
| CRequiredArgs | A class for recording the number of arguments that a function signature requires |
| CReturnValueSlot | Contains the address where the return value of a function can be stored, and whether the address is volatile or not |
| CRValue | This trivial value class is used to represent the result of an expression that is evaluated |
| CTargetCIRGenInfo | |
| NCodeGen | |
| NMCDC | |
| CState | Per-Function MC/DC state |
| CBranch | |
| CDecision | |
| Nswiftcall | |
| CSwiftAggLowering | |
| CABIArgInfo | ABIArgInfo - Helper class to encapsulate information about how a specific C type should be passed to or returned from a function |
| CABIInfo | ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions |
| CAddress | Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this class is possibly signed |
| CAggValueSlot | An aggregate value slot |
| CApplyAtomGroup | A scoped helper to set the current source atom group for CGDebugInfo::addInstToCurrentSourceAtom |
| CApplyDebugLocation | A scoped helper to set the current debug location to the specified location or preferred location of the specified Expr |
| CApplyInlineDebugLocation | A scoped helper to set the current debug location to an inlined location |
| CBlockByrefHelpers | A pair of helper functions for a __block variable |
| CBlockByrefInfo | Information about the layout of a __block variable |
| CBlockFieldFlags | |
| CBlockFlags | |
| CBranchFixup | A branch fixup |
| CCallArg | |
| CCallArgList | CallArgList - Type for representing both the value and type of arguments in a call |
| CCallArgCleanup | |
| CWriteback | |
| CCatchRetScope | |
| CCatchTypeInfo | The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler, so we use this wrapper |
| CCGBitFieldInfo | Structure with information about how a bitfield should be accessed |
| CCGBlockInfo | CGBlockInfo - Information to generate a block literal |
| CCapture | |
| CCGBuilderInserter | This is an IRBuilder insertion helper that forwards to CodeGenFunction::InsertHelper, which adds necessary metadata to instructions |
| CCGBuilderTy | |
| CCGCallee | All available information about a concrete callee |
| CCGCalleeInfo | Abstract information about a function or function prototype |
| CCGCoroData | |
| CCGCUDARuntime | |
| CDeviceVarFlags | |
| CCGCXXABI | Implements C++ ABI-specific code generation functions |
| CAddedStructorArgCounts | Similar to AddedStructorArgs, but only notes the number of additional arguments |
| CAddedStructorArgs | Additional implicit arguments to add to the beginning (Prefix) and end (Suffix) of a constructor / destructor arg list |
| CArg | |
| CExactDynamicCastInfo | |
| CCGDebugInfo | This class gathers all debug information during compilation and is responsible for emitting to llvm globals or pass directly to the backend |
| CCGFunctionInfo | CGFunctionInfo - Class to encapsulate the information about a function definition |
| CCGFunctionInfoArgInfo | |
| CCGHLSLOffsetInfo | |
| CCGHLSLRuntime | |
| CCGObjCRuntime | Implements runtime-specific code generation functions |
| CMessageSendInfo | |
| CCGOpenCLRuntime | |
| CEnqueuedBlockInfo | Structure for enqueued block information |
| CCGOpenMPRuntime | |
| CDebugLocThreadIdTy | Stores debug location and ThreadID for the function |
| CDisableAutoDeclareTargetRAII | Allows to disable automatic handling of functions used in target regions as those marked as omp declare target |
| CDispatchRTInput | Struct with the values to be passed to the dispatch runtime function |
| CLastprivateConditionalData | Maps the expression for the lastprivate variable to the global copy used to store new value because original variables are not mapped in inner parallel regions |
| CLastprivateConditionalRAII | Manages list of lastprivate conditional decls for the specified directive |
| CNontemporalDeclsRAII | Manages list of nontemporal decls for the specified directive |
| CReductionOptionsTy | |
| CStaticRTInput | Struct with the values to be passed to the static runtime function |
| CTargetDataInfo | Struct that keeps all the relevant information that should be kept throughout a 'target data' region |
| CTaskResultTy | |
| CUntiedTaskLocalDeclsRAII | Manages list of nontemporal decls for the specified directive |
| CCGOpenMPRuntimeGPU | |
| CCGOpenMPSIMDRuntime | Class supports emissionof SIMD-only code |
| CCGPointerAuthInfo | |
| CCGRecordLayout | CGRecordLayout - This class handles struct and union layout info while lowering AST types to LLVM types |
| CCodeGenFunction | CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code |
| CAbstractCallee | An abstract representation of regular/ObjC call/message targets |
| CAllocaTrackerRAII | |
| CArrayInitLoopExprScope | The scope of an ArrayInitLoopExpr |
| CAutoVarEmission | |
| CAwaitSuspendWrapperInfo | |
| CCallLifetimeEnd | |
| CCGAtomicOptionsRAII | |
| CCGCapturedStmtInfo | API for captured statement code generation |
| CCGCapturedStmtRAII | RAII for correct setting/restoring of CapturedStmtInfo |
| CCGCoroInfo | |
| CCGFPOptionsRAII | |
| CCleanupDeactivationScope | |
| CConditionalEvaluation | An object to manage conditionally-evaluated expressions |
| CConstantEmission | |
| CCXXDefaultArgExprScope | |
| CCXXDefaultInitExprScope | The scope of a CXXDefaultInitExpr |
| CDeferredDeactivateCleanup | |
| CFakeUse | |
| CFieldConstructionScope | A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr |
| CFinallyInfo | A class controlling the emission of a finally block |
| CFMVResolverOption | |
| CInlinedInheritingConstructorScope | |
| CJumpDest | A jump destination is an abstract label, branching to which may require a jump out through normal cleanups |
| CLexicalScope | |
| CLifetimeExtendedCleanupHeader | Header for data within LifetimeExtendedCleanupStack |
| COMPBuilderCBHelpers | |
| CInlinedRegionBodyRAII | RAII for preserving necessary info during inlined region body codegen |
| COMPAllocateCleanupTy | Cleanup action for allocate support |
| COutlinedRegionBodyRAII | RAII for preserving necessary info during Outlined region body codegen |
| COMPCancelStackRAII | Controls insertion of cancellation exit blocks in worksharing constructs |
| COMPLocalDeclMapRAII | Save/restore original map of previously emitted local vars in case when we need to duplicate emission of the same code several times in the same function for OpenMP code |
| COMPMapVars | The class used to assign some variables some temporarily addresses |
| COMPPrivateScope | The scope used to remap some variables as private in the OpenMP loop body (or other captured region emitted without outlining), and to restore old vars back on exit |
| COMPTargetDataInfo | |
| COpaqueValueMapping | An RAII object to set (and then clear) a mapping for an OpaqueValueExpr |
| COpaqueValueMappingData | A non-RAII class containing all the information about a bound opaque value |
| CParamValue | |
| CParentLoopDirectiveForScanRegion | Manages parent directive for scan directives |
| CPeepholeProtection | An object which temporarily prevents a value from being destroyed by aggressive peephole optimizations that assume that all uses of a value have been realized in the IR |
| CPrototypeWrapper | |
| CRunCleanupsScope | Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited |
| CSanitizerScope | RAII object to set/unset CodeGenFunction::IsSanitizerScope |
| CStmtExprEvaluation | An RAII object to record that we're evaluating a statement expression |
| CVlaSizePair | |
| CVPtr | Struct with all information about dynamic [sub]class needed to set vptr |
| CCodeGenModule | This class organizes the cross-function state that is used while generating LLVM code |
| CStructor | |
| CCodeGenPGO | Per-function PGO state |
| CCodeGenTBAA | CodeGenTBAA - This class organizes the cross-module state that is used while lowering AST types to LLVM types |
| CCodeGenTypeCache | This structure provides a set of types that are commonly used during IR emission |
| CCodeGenTypes | This class organizes the cross-module state that is used while lowering AST types to LLVM types |
| CCodeGenVTables | |
| CConstantAddress | A specialization of Address that requires the address to be an LLVM Constant |
| CConstantAggregateBuilderBase | A concrete base class for struct and array aggregate initializer builders |
| CPlaceholderPosition | An opaque class to hold the abstract position of a placeholder |
| CConstantAggregateBuilderTemplateBase | |
| CConstantArrayBuilder | A helper class of ConstantInitBuilder, used for building constant array initializers |
| CConstantArrayBuilderTemplateBase | |
| CConstantEmitter | |
| CConstantInitBuilder | The standard implementation of ConstantInitBuilder used in Clang |
| CConstantInitBuilderBase | A convenience builder class for complex constant initializers, especially for anonymous global structures used by various language runtimes |
| CConstantInitBuilderTemplateBase | A template class designed to allow other frontends to easily customize the builder classes used by ConstantInitBuilder, and thus to extend the API to work with the abstractions they prefer |
| CConstantInitBuilderTraits | |
| CConstantInitFuture | A "future" for a completed constant initializer, which can be passed around independently of any sub-builders (but not the original parent) |
| CConstantStructBuilder | A helper class of ConstantInitBuilder, used for building constant struct initializers |
| CConstantStructBuilderTemplateBase | A template class designed to allow other frontends to easily customize the builder classes used by ConstantInitBuilder, and thus to extend the API to work with the abstractions they prefer |
| CCounterPair | The Counter with an optional additional Counter for branches |
| CValueOpt | Optional value |
| CCoverageMappingGen | Organizes the per-function state that is used while generating code coverage mapping data |
| CCoverageMappingModuleGen | Organizes the cross-function state that is used while generating code coverage mapping data |
| CDefaultABIInfo | DefaultABIInfo - The default implementation for ABI specific details |
| CDisableDebugLocationUpdates | |
| CDominatingLLVMValue | Helper class with most of the code for saving a value for a conditional expression cleanup |
| CDominatingPointer | |
| CDominatingPointer< T, false > | |
| CDominatingPointer< T, true > | A partial specialization of DominatingValue for llvm::Values that might be llvm::Instructions |
| CDominatingValue | A metaprogramming class for ensuring that a value will dominate an arbitrary position in a function |
| CDominatingValue< Address > | A specialization of DominatingValue for Address |
| Csaved_type | |
| CDominatingValue< RValue > | A specialization of DominatingValue for RValue |
| Csaved_type | |
| CDominatingValue< T * > | |
| CEHCatchScope | A scope which attempts to handle some, possibly all, types of exceptions |
| CHandler | |
| CEHCleanupScope | A cleanup scope which generates the cleanup blocks lazily |
| CEHFilterScope | An exceptions scope which filters exceptions thrown through it |
| CEHPersonality | The exceptions personality for a function |
| CEHScope | A protected scope for zero-cost EH handling |
| CCatchBitFields | |
| CCleanupBitFields | |
| CFilterBitFields | |
| CEHScopeStack | A stack of scopes which respond to exceptions, including cleanups and catch blocks |
| CConditionalCleanup | ConditionalCleanup stores the saved form of its parameters, then restores them and performs the cleanup |
| Citerator | A non-stable pointer into the scope stack |
| Cstable_iterator | A saved depth on the scope stack |
| CEHTerminateScope | An exceptions scope which calls std::terminate if any exception reaches it |
| CFunctionArgList | FunctionArgList - Type for representing both the decl and type of parameters to a function |
| CHLSLBufferLayoutBuilder | |
| CImplicitCXXConstructorArgs | Additional implicit arguments to add to a constructor argument list |
| CInstrProfStats | This class records statistics on instrumentation based profiling |
| CInvariantValue | |
| CLoopAttributes | Attributes that may be specified on loops |
| CLoopInfo | Information used when generating a structured loop |
| CLoopInfoStack | A stack of loop information corresponding to loop nesting levels |
| CLValue | LValue - This represents an lvalue references |
| CLValueBaseInfo | |
| CObjCEntrypoints | |
| COMPTaskDataTy | |
| CDependData | |
| COrderGlobalInitsOrStermFinalizers | |
| CPrePostActionTy | A basic class for pre|post-action for advanced codegen sequence for OpenMP region |
| CRawAddress | An abstract representation of an aligned address |
| CReductionCodeGen | Class intended to support codegen of all kind of the reduction clauses |
| CRegionCodeGenTy | Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possible pre|post-actions in codegen |
| CRequiredArgs | A class for recording the number of arguments that a function signature requires |
| CReturnValueSlot | ReturnValueSlot - Contains the address where the return value of a function can be stored, and whether the address is volatile or not |
| CRValue | RValue - This trivial value class is used to represent the result of an expression that is evaluated |
| CSanitizerDebugLocation | |
| CSanitizerMetadata | |
| CSwiftABIInfo | Target specific hooks for defining how a type should be passed or returned from functions with one of the Swift calling conventions |
| CTargetCodeGenInfo | TargetCodeGenInfo - This class organizes various target-specific codegeneration issues, like target-specific attributes, builtins and so on |
| CTargetOpenCLBlockHelper | Interface class for filling custom fields of a block literal for OpenCL |
| CTBAAAccessInfo | |
| CTrapReason | |
| CTrapReasonBuilder | Helper class for stores the "trap reason" built by |
| CVarBypassDetector | The class detects jumps which bypass local variables declaration: goto L; int a; L: |
| Ncomments | |
| CBlockCommandComment | A command that has zero or more word-like arguments (number of word-like arguments depends on command name) and a paragraph as an argument (e |
| CBlockContentComment | Block content (contains inline content) |
| CBriefParser | A very simple comment parser that extracts "a brief description" |
| CCommandInfo | Information about a single command |
| CCommandTraits | This class provides information about commands that can be used in comments |
| CComment | Any part of the comment |
| CArgument | |
| CBlockCommandCommentBitfields | |
| CCommentBitfields | |
| CHTMLStartTagCommentBitfields | |
| CHTMLTagCommentBitfields | |
| CInlineCommandCommentBitfields | |
| CInlineContentCommentBitfields | |
| CParagraphCommentBitfields | |
| CParamCommandCommentBitfields | |
| CTextCommentBitfields | |
| CCommentVisitor | |
| CCommentVisitorBase | |
| CConstCommentVisitor | |
| CDeclInfo | Information about the declaration, useful to clients of FullComment |
| CFullComment | A full comment attached to a declaration, contains block content |
| CHTMLEndTagComment | A closing HTML tag |
| CHTMLStartTagComment | An opening HTML tag with attributes |
| CAttribute | |
| CHTMLTagComment | Abstract class for opening and closing HTML tags |
| CInlineCommandComment | A command with word-like arguments that is considered inline content |
| CInlineContentComment | Inline content (contained within a block) |
| CLexer | Comment lexer |
| CParagraphComment | A single paragraph that contains inline content |
| CParamCommandComment | Doxygen \param command |
| CParser | Doxygen comment parser |
| CSema | |
| CTextComment | Plain text |
| CTextTokenRetokenizer | Re-lexes a sequence of tok::text tokens |
| CToken | Comment token |
| CTParamCommandComment | Doxygen \tparam command, describes a template parameter |
| CVerbatimBlockComment | A verbatim block command (e |
| CVerbatimBlockLineComment | A line of text contained in a verbatim block |
| CVerbatimLineComment | A verbatim line command |
| Nconcepts | |
| CExprRequirement | A requires-expression requirement which queries the validity and properties of an expression ('simple' and 'compound' requirements) |
| CReturnTypeRequirement | |
| CNestedRequirement | A requires-expression requirement which is satisfied when a general constraint expression is satisfied ('nested' requirements) |
| CRequirement | A static requirement that can be used in a requires-expression to check properties of types and expression |
| CSubstitutionDiagnostic | |
| CTypeRequirement | A requires-expression requirement which queries the existence of a type name or type template specialization ('type' requirements) |
| Nconsumed | |
| CConsumedAnalyzer | A class that handles the analysis of uniqueness violations |
| CConsumedBlockInfo | |
| CConsumedStateMap | |
| CConsumedStmtVisitor | |
| CConsumedWarningsHandlerBase | |
| CPropagationInfo | |
| Ncross_tu | |
| CCrossTranslationUnitContext | This class is used for tools that requires cross translation unit capability |
| CIndexError | |
| Ndataflow | Dataflow Directional Tag Classes |
| Ninternal | |
| CStmtToBlockMap | |
| Nstatusor_model | |
| CMatchFinder | A class to allow finding matches over the Clang AST |
| CMatchCallback | Called when the Match registered for it was successfully found in the AST |
| CMatchersByType | For each Matcher<> a MatchCallback that will be called when it matches |
| CMatchFinderOptions | |
| CProfiling | |
| CMatchResult | Contains all information for a given match |
| CParsingDoneTestCallback | Called when parsing is finished. Intended for testing only |
| CUncheckedStatusOrAccessDiagnoser | |
| CUncheckedStatusOrAccessModel | |
| CUncheckedStatusOrAccessModelOptions | |
| CAdornedCFG | Holds CFG with additional information derived from it that is needed to perform dataflow analysis |
| CAnalysisASTVisitor | Specialization of RecursiveASTVisitor that visits those nodes that are relevant to the dataflow analysis; generally, these are the ones that also appear in the CFG |
| CArena | The Arena owns the objects that model data within an analysis |
| CASTMatchSwitchBuilder | Collects cases of a "match switch": a collection of matchers paired with callbacks, which together define a switch that can be applied to a node whose type derives from BaseT |
| CAtomicBoolValue | Models an atomic boolean |
| Cbackward_analysis_tag | |
| CBoolValue | Models a boolean |
| CCachedConstAccessorsLattice | A mixin for a lattice that additionally maintains a cache of stable method call return values to model const accessors methods |
| CCFGEltCallbacks | A pair of callbacks to be called with the state before and after visiting a CFG element |
| CCFGEltCallbacksTypeErased | A pair of callbacks to be called with the state before and after visiting a CFG element |
| CCFGMatchSwitchBuilder | Collects cases of a "match switch": a collection of matchers paired with callbacks, which together define a switch that can be applied to an AST node contained in a CFG element |
| CChromiumCheckModel | Models the behavior of Chromium's CHECK, DCHECK, etc |
| CCNFFormula | A boolean formula in 3-CNF (conjunctive normal form with at most 3 literals per clause) |
| CIterator | An iterator over all literals of all clauses in the formula |
| CContextSensitiveOptions | |
| CDataflowAnalysis | Base class template for dataflow analyses built on a single lattice type |
| CDataflowAnalysisContext | Owns objects that encompass the state of a program and stores context that is used during dataflow analysis |
| COptions | |
| CDataflowAnalysisOptions | |
| CDataflowAnalysisState | |
| CDataflowModel | Abstract base class for dataflow "models": reusable analysis components that model a particular aspect of program semantics in the Environment |
| CDiagnosisCallbacks | A pair of callbacks for performing diagnosis on a CFG element, called with the state before and after visiting that CFG element |
| CEnvironment | Holds the state of the program (store and heap) at a given program point |
| CValueModel | Supplements Environment with non-standard comparison and join operations |
| CFormula | |
| CFormulaBoolValue | Models a compound boolean formula |
| Cforward_analysis_tag | |
| CIntegerValue | Models an integer |
| CLogger | A logger is notified as the analysis progresses |
| CMapLattice | A lattice that maps keys to individual lattice elements |
| CNoopAnalysis | |
| CNoopLattice | Trivial lattice for dataflow analysis with exactly one element |
| COperation | |
| CPointerValue | Models a symbolic pointer. Specifically, any value of type T* |
| CRecordInitListHelper | Helper class for initialization of a record with an InitListExpr |
| CRecordStorageLocation | A storage location for a record (struct, class, or union) |
| CReferencedDecls | A collection of several types of declarations, all referenced from the same function |
| CReferencedDeclsVisitor | |
| CScalarStorageLocation | A storage location that is not subdivided further for the purposes of abstract interpretation |
| CSimpleLogicalContext | A simple representation of essential elements of the logical context used in environments |
| CSimplifyConstraintsInfo | Information on the way a set of constraints was simplified |
| CSolver | An interface for a SAT solver that can be used by dataflow analyses |
| CResult | |
| CStmtToEnvMap | Maps statements to the environments of basic blocks that contain them |
| CStorageLocation | Base class for elements of the local variable store and of the heap |
| CTopBoolValue | A TopBoolValue represents a boolean that is explicitly unconstrained |
| CTransferState | A common form of state shared between the cases of a transfer function |
| CTransferStateForDiagnostics | A read-only version of TransferState |
| CTypeErasedDataflowAnalysis | Type-erased base class for dataflow analyses built on a single lattice type |
| CTypeErasedDataflowAnalysisState | Type-erased model of the program at a given program point |
| CTypeErasedLattice | Type-erased lattice element container |
| CUncheckedOptionalAccessDiagnoser | |
| CUncheckedOptionalAccessDiagnostic | Diagnostic information for an unchecked optional access |
| CUncheckedOptionalAccessModel | Dataflow analysis that models whether optionals hold values or not |
| CUncheckedOptionalAccessModelOptions | |
| CValue | Base class for all values computed by abstract interpretation |
| CWatchedLiteralsSolver | A SAT solver that is an implementation of Algorithm D from Knuth's The Art of Computer Programming Volume 4: Satisfiability, Fascicle 6 |
| CWidenResult | The result of a widen operation |
| Ndeclvisitor | |
| CBase | A simple visitor class that helps create declaration visitors |
| Ndependencies | |
| CCachedFileContents | Contents and directive tokens of a cached file entry |
| CCachedFileSystemEntry | An in-memory representation of a file system entity that is of interest to the dependency scanning filesystem |
| CCallbackActionController | A simple dependency action controller that uses a callback |
| CCommand | A command-line tool invocation that is part of building a TU |
| CCompilerInstanceWithContext | |
| CDependencyActionController | Dependency scanner callbacks that are used during scanning to influence the behaviour of the scan - for example, to customize the scanned invocations |
| CDependencyConsumer | |
| CDependencyScanningAction | |
| CDependencyScanningFilesystemLocalCache | This class is a local cache, that caches the 'stat' and 'open' calls to the underlying real file system |
| CDependencyScanningFilesystemSharedCache | This class is a shared cache, that caches the 'stat' and 'open' calls to the underlying real file system, and the scanned preprocessor directives of files |
| CCacheShard | |
| COutOfDateEntry | |
| CNegativelyCachedInfo | |
| CSizeChangedInfo | |
| CDependencyScanningService | The dependency scanning service contains shared configuration and state that is used by the individual dependency scanning workers |
| CDependencyScanningWorker | An individual dependency scanning worker that is able to run on its own thread |
| CDependencyScanningWorkerFilesystem | A virtual file system optimized for the dependency discovery |
| CDiagnosticsEngineWithDiagOpts | |
| CEntryRef | Reference to a CachedFileSystemEntry |
| CFullDependencyConsumer | |
| CModuleCacheEntries | |
| CModuleCacheEntry | |
| CModuleDepCollector | Collects modular and non-modular dependencies of the main file by attaching ModuleDepCollectorPP to the preprocessor |
| CModuleDepCollectorPP | Callback that records textual includes and direct modular includes/imports during preprocessing |
| CModuleDeps | |
| CModuleID | This is used to identify a specific module |
| CP1689ModuleInfo | P1689ModuleInfo - Represents the needed information of standard C++20 modules for P1689 format |
| CPrebuiltModuleASTAttrs | |
| CPrebuiltModuleDep | Modular dependency that has already been built prior to the dependency scan |
| CTextDiagnosticsPrinterWithOutput | |
| CTranslationUnitDeps | The full dependencies and module graph for a specific input |
| Ndependency_directives_scan | |
| CDirective | Represents a directive that's lexed as part of the dependency directives scanning |
| CToken | Token lexed as part of dependency directive scanning |
| Ndetail | |
| CAvailabilityData | Describes the trailing object for Availability attribute in ParsedAttr |
| CCXXDeductionGuideNameExtra | Contains extra information for the name of a C++ deduction guide |
| CCXXLiteralOperatorIdName | Contains the actual identifier that makes up the name of a C++ literal operator |
| CCXXOperatorIdName | Contains extra information for the name of an overloaded operator in C++, such as "operator+ |
| CCXXSpecialNameExtra | CXXSpecialNameExtra records the type associated with one of the "special" kinds of declaration names in C++, e.g., constructors, destructors, and conversion functions |
| CDeclarationNameExtra | DeclarationNameExtra is used as a base of various uncommon special names |
| Chas_same_member_pointer_type | |
| Chas_same_member_pointer_type< R(T::*)(P...), R(U::*)(P...)> | |
| CMacroExpansionRangeRecorder | |
| CPropertyData | |
| CSarifArtifact | Since every clang artifact MUST have a location (there being no nested artifacts), the creation method SarifArtifact::create requires a SarifArtifactLocation object |
| CSarifArtifactLocation | |
| CSearchDirIteratorImpl | Forward iterator over the search directories of HeaderSearch |
| CTypeTagForDatatypeData | |
| Ndiag | |
| CCustomDiagInfo | |
| Ndiff | |
| CASTDiff | |
| CImpl | |
| CComparisonOptions | |
| CNode | Represents a Clang AST node, alongside some additional information |
| CNodeId | Within a tree, this identifies a node by its preorder offset |
| CSNodeId | Identifies a node in a subtree by its postorder offset, starting at 1 |
| CSubtree | |
| CSyntaxTree | SyntaxTree objects represent subtrees of the AST |
| CImpl | Represents the AST of a TranslationUnit |
| CZhangShashaMatcher | Implementation of Zhang and Shasha's Algorithm for tree edit distance |
| Ndriver | |
| Ncustom_flag | |
| CDeclaration | |
| CValueDetail | |
| CValueNameToDetailMap | |
| Ntoolchains | |
| CAIX | |
| CAMDGPUOpenMPToolChain | |
| CAMDGPUToolChain | |
| CParsedTargetIDType | The struct type returned by getParsedTargetID |
| CAppleMachO | Apple specific MachO extensions |
| CAVRToolChain | |
| CBareMetal | |
| CCrossWindowsToolChain | |
| CCSKYToolChain | |
| CCudaToolChain | |
| CCygwin | |
| CDarwin | Darwin - The base Darwin tool chain |
| CDarwinClang | DarwinClang - The Darwin toolchain used by Clang |
| CDragonFly | |
| CFreeBSD | |
| CFuchsia | |
| CGeneric_ELF | |
| CGeneric_GCC | Generic_GCC - A tool chain using the 'gcc' command to perform all subcommands; this relies on gcc translating the majority of command line options |
| CGCCInstallationDetector | This is a class to find a viable GCC installation for Clang to use |
| CGCCInstallCandidate | |
| CGCCVersion | Struct to store and manipulate GCC versions |
| CHaiku | |
| CHexagonToolChain | |
| CHIPAMDToolChain | |
| CHIPSPVToolChain | |
| CHLSLToolChain | |
| CHurd | |
| CLanaiToolChain | |
| CLFILinux | |
| CLinux | |
| CMachO | |
| CManagarm | |
| CMinGW | |
| CMipsLLVMToolChain | |
| CMSP430ToolChain | |
| CMSVCToolChain | |
| CNetBSD | |
| CNVPTXToolChain | |
| COHOS | |
| COpenBSD | |
| CPPCFreeBSDToolChain | |
| CPPCLinuxToolChain | |
| CPS4CPU | |
| CPS4PS5Base | |
| CPS5CPU | |
| CROCMToolChain | |
| CSolaris | |
| CSPIRVAMDToolChain | |
| CSPIRVOpenMPToolChain | |
| CSPIRVToolChain | |
| CSYCLToolChain | |
| CTCELEToolChain | Toolchain for little endian TCE cores |
| CTCEToolChain | TCEToolChain - A tool chain using the llvm bitcode tools to perform all subcommands |
| CUEFI | |
| CVEToolChain | |
| CWebAssembly | |
| CXCoreToolChain | |
| CZOS | |
| Ntools | |
| Naix | Directly call system default assembler and linker |
| CAssembler | |
| CLinker | |
| NAMDGCN | |
| CLinker | |
| Namdgpu | |
| CLinker | |
| NAVR | |
| CLinker | |
| Nbaremetal | |
| CLinker | |
| CStaticLibTool | |
| NCrossWindows | |
| CAssembler | |
| CLinker | |
| NCSKY | |
| CLinker | |
| Ndarwin | |
| CAssembler | |
| CDsymutil | |
| CLinker | |
| CLipo | |
| CMachOTool | |
| CStaticLibTool | |
| CVerifyDebug | |
| Ndragonfly | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| Nfreebsd | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| Nfuchsia | |
| CLinker | |
| CStaticLibTool | |
| Ngcc | Gcc - Generic GCC tool implementations |
| CCommon | |
| CCompiler | |
| CLinker | |
| CPreprocessor | |
| Ngnutools | Directly call GNU Binutils' assembler and linker |
| CAssembler | |
| CLinker | |
| CStaticLibTool | |
| Nhaiku | Directly call GNU Binutils assembler and linker |
| CLinker | |
| Nhexagon | |
| CAssembler | |
| CLinker | |
| NHIPSPV | |
| CLinker | |
| Nhlsl | |
| CLLVMObjcopy | |
| CMetalConverter | |
| CValidator | |
| Nifstool | |
| CMerger | |
| NMinGW | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| Nmsp430 | |
| CLinker | |
| Nnetbsd | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| NNVPTX | |
| CAssembler | |
| CFatBinary | |
| CLinker | |
| Nopenbsd | Directly call GNU Binutils assembler and linker |
| CAssembler | |
| CLinker | |
| NPS4cpu | |
| CLinker | |
| NPS5cpu | |
| CLinker | |
| NPScpu | |
| CAssembler | |
| Nsolaris | Directly call Solaris assembler and linker |
| CAssembler | |
| CLinker | |
| NSPIRV | |
| CAssembler | |
| CLinker | |
| CTranslator | |
| Nuefi | |
| CLinker | |
| Nvisualstudio | Visual studio tools |
| CLinker | |
| Nwasm | |
| CLinker | |
| NXCore | |
| CAssembler | |
| CLinker | |
| Nzos | Directly call system default assembler and linker |
| CAssembler | |
| CLinker | |
| CClang | Clang compiler tool |
| CClangAs | Clang integrated assembler tool |
| CFlang | Flang compiler tool |
| CLinkerWrapper | Linker wrapper tool |
| COffloadBundler | Offload bundler tool |
| COffloadPackager | Offload binary tool |
| CAction | Action - Represent an abstract compilation step to perform |
| CAnalyzeJobAction | |
| CAssembleJobAction | |
| CBackendJobAction | |
| CBinaryAnalyzeJobAction | |
| CBinaryTranslatorJobAction | |
| CBindArchAction | |
| CCC1Command | Use the CC1 tool callback when available, to avoid creating a new process |
| CCommand | Command - An executable path/name and argument vector to execute |
| CCompilation | Compilation - A set of tasks to perform for a single driver invocation |
| CCompileJobAction | |
| CCrashReportInfo | |
| CCudaInstallationDetector | A class to find a viable CUDA installation |
| CCUIDOptions | Options for specifying CUID used by CUDA/HIP for uniquely identifying compilation units |
| CDetectedMultilibs | |
| CDeviceLibABIVersion | ABI version of device library |
| CDistro | Distro - Helper class for detecting and classifying Linux distributions |
| CDriver | Driver - Encapsulate logic for constructing compilation processes from a set of gcc-driver-like command line arguments |
| CCompilationDiagnosticReport | Contains the files in the compilation diagnostic report generated by generateCompilationDiagnostics |
| CDsymutilJobAction | |
| CExtractAPIJobAction | |
| CIfsMergeJobAction | |
| CInputAction | |
| CInputInfo | InputInfo - Wrapper for information about an input source |
| CJobAction | |
| CJobList | JobList - A sequence of jobs to perform |
| CLinkerWrapperJobAction | |
| CLinkJobAction | |
| CLipoJobAction | |
| CMultilib | This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag |
| CMultilibBuilder | This corresponds to a single GCC multilib, or a segment of one controlled by a command line flag |
| CMultilibSet | See also MultilibSetBuilder for combining multilibs into a set |
| CFlagMatcher | Uses regular expressions to simplify flags used for multilib selection |
| CMultilibSetBuilder | This class can be used to create a MultilibSet, and contains helper functions to add combinations of multilibs before creating a MultilibSet instance with makeMultilibSet() |
| CObjcopyJobAction | |
| COffloadAction | An offload action combines host or/and device actions according to the programming model implementation needs and propagates the offloading kind to its dependences |
| CDeviceDependences | Type used to communicate device actions |
| CHostDependence | Type used to communicate host actions |
| COffloadBundlingJobAction | |
| COffloadPackagerJobAction | |
| COffloadUnbundlingJobAction | |
| CDependentActionInfo | Type that provides information about the actions that depend on this unbundling action |
| CParsedClangName | Helper structure used to pass information extracted from clang executable name such as i686-linux-android-g++ |
| CPrecompileJobAction | |
| CPreprocessJobAction | |
| CRegisterEffectiveTriple | Set a ToolChain's effective triple |
| CResponseFileSupport | |
| CRocmInstallationDetector | A class to find a viable ROCM installation TODO: Generalize to handle libclc |
| CSanitizerArgs | |
| CStaticLibJobAction | |
| CSYCLInstallationDetector | |
| CTool | Tool - Information on a specific compilation tool |
| CToolChain | ToolChain - Access to tools for a single platform |
| CBitCodeLibraryInfo | |
| CVerifyDebugInfoJobAction | |
| CVerifyJobAction | |
| CVerifyPCHJobAction | |
| CXRayArgs | |
| Nedit | |
| CCommit | |
| CEdit | |
| CEditedSource | |
| CEditsReceiver | |
| CFileOffset | |
| Nento | |
| Nbugreporter | |
| CExpressionHandler | Handles expressions during the tracking |
| CStoreHandler | Handles stores during the tracking |
| CStoreInfo | Describes an event when the value got stored into a memory region |
| CTracker | A generalized component for tracking expressions, values, and stores |
| CResult | Describes a tracking result with the most basic information of what was actually done (or not done) |
| CTrackingBugReporterVisitor | Visitor that tracks expressions and values |
| CTrackingOptions | Defines a set of options altering tracking behavior |
| Ncheck | |
| CASTCodeBody | |
| CASTDecl | |
| CBeginFunction | |
| CBind | |
| CBlockEntrance | |
| CBranchCondition | |
| CConstPointerEscape | |
| CDeadSymbols | |
| CEndAnalysis | |
| CEndFunction | |
| CEndOfTranslationUnit | |
| CEvent | |
| CLiveSymbols | |
| CLocation | |
| CNewAllocator | |
| CObjCMessageNil | |
| CPointerEscape | |
| CPostCall | |
| CPostObjCMessage | |
| CPostStmt | |
| CPreCall | |
| CPreObjCMessage | |
| CPreStmt | |
| CRegionChanges | |
| Nchecker_registry | |
| CFullNameLT | |
| Neval | |
| CAssume | |
| CCall | |
| Niterator | |
| CContainerData | |
| CContainerMap | |
| CIteratorPosition | |
| CIteratorRegionMap | |
| CIteratorSymbolMap | |
| Nloc | |
| CConcreteInt | |
| CGotoLabel | |
| CMemRegionVal | |
| Nmpi | |
| CMPIBugReporter | |
| CMPIChecker | |
| CMPIFunctionClassifier | |
| CRequest | |
| CRequestMap | |
| Nnonloc | |
| CCompoundVal | The simplest example of a concrete compound value is nonloc::CompoundVal, which represents a concrete r-value of an initializer-list or a string |
| CConcreteInt | Value representing integer constant |
| CLazyCompoundVal | While nonloc::CompoundVal covers a few simple use cases, nonloc::LazyCompoundVal is a more performant and flexible way to represent an rvalue of record type, so it shows up much more frequently during analysis |
| CLocAsInteger | |
| CPointerToMember | Value representing pointer-to-member |
| CSymbolVal | Represents symbolic expression that isn't a location |
| Nretaincountchecker | |
| CRefCountBug | |
| CRefCountFrontend | |
| CRefCountReport | |
| CRefCountReportVisitor | |
| CRefLeakReport | |
| CRefLeakReportVisitor | |
| CRefVal | Metadata on reference |
| CRetainCountChecker | |
| NsummMgr | |
| CSummaryKey | |
| CAllocaRegion | AllocaRegion - A region that represents an untyped blob of bytes created by a call to 'alloca' |
| CAnalysisAction | |
| CAnalysisASTConsumer | |
| CAnalysisManager | |
| CAnyCXXConstructorCall | Represents any constructor invocation |
| CAnyFunctionCall | Represents a call to any sort of function that might have a FunctionDecl |
| CAPSIntPtr | A safe wrapper around APSInt objects allocated and owned by BasicValueFactory |
| CAPSIntType | A record of the "type" of an APSInt, used for conversions |
| CArgEffect | An ArgEffect summarizes the retain count behavior on an argument or receiver to a function or method |
| CBasicBugReport | |
| CBasicValueFactory | |
| CBinarySymExpr | Represents a symbolic expression involving a binary operator |
| CBinarySymExprImpl | Template implementation for all binary symbolic expressions |
| CBindResult | |
| CBlockCall | Represents a call to a block |
| CBlockCodeRegion | BlockCodeRegion - A region that represents code texts of blocks (closures) |
| CBlockCounter | An abstract data type used to count the number of times a given block has been visited along a path analyzed by CoreEngine |
| CFactory | |
| CBlockDataRegion | BlockDataRegion - A region that represents a block instance |
| Creferenced_vars_iterator | |
| CBranchNodeBuilder | BranchNodeBuilder is responsible for constructing the nodes corresponding to the two branches of the if statement - true and false |
| CBugReport | This class provides an interface through which checkers can create individual bug reports |
| CBugReportEquivClass | |
| CBugReporter | BugReporter is a utility class for generating PathDiagnostics for analysis |
| CBugReporterContext | |
| CBugReporterData | |
| CBugReporterVisitor | BugReporterVisitors are used to add custom diagnostics along a path |
| CBugSuppression | |
| CBugType | |
| CCallDescription | A CallDescription is a pattern that can be used to match calls based on the qualified name and the argument/parameter counts |
| CCallDescriptionMap | An immutable map from CallDescriptions to arbitrary data |
| CCallDescriptionSet | An immutable set of CallDescriptions |
| CCallEvent | Represents an abstract call to a function or method along a particular path |
| CCallEventManager | Manages the lifetime of CallEvent objects |
| CCallEventRef | |
| CChecker | Simple checker classes that implement one frontend (i.e |
| CCheckerBackend | CheckerBackend is an abstract base class that serves as the common ancestor of all the Checker<...> and CheckerFamily<...> classes which can create ExplodedNodes (by acting as a ProgramPointTag) and can be registered to handle various checker callbacks |
| CCheckerBase | The non-templated common ancestor of all the simple Checker<...> classes |
| CCheckerContext | |
| CCheckerDocumentation | This checker documents the callback functions checkers can use to implement the custom handling of the specific events during path exploration as well as reporting bugs |
| CCheckerFamily | Checker families (where a single backend class implements multiple related frontends) should derive from this template and specify all the implemented callbacks (i.e |
| CCheckerFn | |
| CCheckerFn< RET(Ps...)> | |
| CCheckerFrontend | A CheckerFrontend instance is what the user recognizes as "one checker": it has a public canonical name (injected from the CheckerManager), can be enabled or disabled, can have associated checker options and can be printed as the "source" of bug reports |
| CCheckerFrontendWithBugType | Trivial convenience class for the common case when a certain checker frontend always uses the same bug type |
| CCheckerInfo | Specifies a checker |
| CCheckerManager | |
| CCheckerNameRef | This wrapper is used to ensure that only StringRefs originating from the CheckerRegistry are used as check names |
| CCheckerRegistry | Manages a set of available checkers for running a static analysis |
| CCheckerRegistryData | |
| CCmdLineOption | Specifies a command line option |
| CCodeSpaceRegion | CodeSpaceRegion - The memory space that holds the executable code of functions and blocks |
| CCodeTextRegion | |
| CCompoundLiteralRegion | CompoundLiteralRegion - A memory region representing a compound literal |
| CCompoundValData | |
| CConditionBRVisitor | Visitor that tries to report interesting diagnostics from conditions |
| CConditionTruthVal | |
| CConstraintManager | |
| CAssumeStackTy | A helper class to simulate the call stack of nested assume calls |
| CCoreEngine | CoreEngine - Implements the core logic of the graph-reachability analysis |
| CCounterEntryPointTranslationUnitStat | |
| CCounterEPStat | |
| CCXXAllocatorCall | Represents the memory allocation call in a C++ new-expression |
| CCXXBaseObjectRegion | |
| CCXXConstructorCall | Represents a call to a C++ constructor |
| CCXXDeallocatorCall | Represents the memory deallocation call in a C++ delete-expression |
| CCXXDerivedObjectRegion | |
| CCXXDestructorCall | Represents an implicit call to a C++ destructor |
| CCXXInheritedConstructorCall | Represents a call to a C++ inherited constructor |
| CCXXInstanceCall | Represents a non-static C++ member function call, no matter how it is written |
| CCXXLifetimeExtendedObjectRegion | |
| CCXXMemberCall | Represents a non-static C++ member function call |
| CCXXMemberOperatorCall | Represents a C++ overloaded operator call where the operator is implemented as a non-static member function |
| CCXXStaticOperatorCall | Represents a static C++ operator call |
| CCXXTempObjectRegion | |
| CCXXThisRegion | CXXThisRegion - Represents the region for the implicit 'this' parameter in a call to a C++ method |
| CDataTag | The tag that carries some information with it |
| CFactory | |
| CDeclRegion | |
| CDefaultProgramStatePartialTraitImpl | |
| CDefinedOrUnknownSVal | |
| CDefinedSVal | |
| CDynamicCastInfo | |
| CDynamicTypeInfo | Stores the currently inferred strictest bound on the runtime type of a region in a given state along the analysis path |
| CElementRegion | ElementRegion is used to represent both array elements and casts |
| CEntryPointStat | |
| CEnvironment | An immutable map from EnvironemntEntries to SVals |
| CEnvironmentEntry | An entry in the environment consists of a Stmt and an LocationContext |
| CEnvironmentManager | |
| CEvalCallOptions | Hints for figuring out of a call should be inlined during evalCall() |
| CEventDispatcher | |
| CExplodedGraph | |
| CExplodedNode | |
| CExplodedNodeSet | |
| CExprEngine | |
| CFieldChainInfo | Represents a field chain |
| CFieldNode | A lightweight polymorphic wrapper around FieldRegion * |
| CFieldRegion | |
| CFindUninitializedFields | Searches for and stores uninitialized fields in a non-union object |
| CFullSValVisitor | FullSValVisitor - a convenient mixed visitor for all three: SVal, SymExpr and MemRegion subclasses |
| CFunctionCodeRegion | FunctionCodeRegion - A region that represents code texts of function |
| CFunctionSummariesTy | |
| CGlobalImmutableSpaceRegion | The region containing globals which are considered not to be modified or point to data which could be modified as a result of a function call (system or internal) |
| CGlobalInternalSpaceRegion | The region containing globals which can be modified by calls to "internally" defined functions - (for now just) functions other than system calls |
| CGlobalsSpaceRegion | |
| CGlobalSystemSpaceRegion | The region containing globals which are defined in system/external headers and are considered modifiable by system calls (ex: errno) |
| CHeapSpaceRegion | |
| CImplicitNullDerefEvent | We dereferenced a location that may be null |
| CIndirectGotoNodeBuilder | |
| Citerator | |
| CLazyCompoundValData | |
| CLikelyFalsePositiveSuppressionBRVisitor | Suppress reports that might lead to known false positives |
| CLoc | |
| CMemRegion | MemRegion - The root abstract class for all memory regions |
| CMemRegionManager | |
| CMemRegionVisitor | MemRegionVisitor - this class implements a simple visitor for MemRegion subclasses |
| CMemSpaceRegion | MemSpaceRegion - A memory region that represents a "memory space"; for example, the set of global variables, the stack frame, etc |
| CModelConsumer | ASTConsumer to consume model files' AST |
| CModelInjector | |
| CNilReceiverBRVisitor | Prints path notes when a message is sent to a nil receiver |
| CNodeBuilder | This is the simplest builder which generates nodes in the ExplodedGraph |
| CNodeBuilderContext | |
| CNodeBuilderWithSinks | This node builder keeps track of the generated sink nodes |
| CNonLoc | |
| CNonParamVarRegion | |
| CNonStaticGlobalSpaceRegion | The region for all the non-static global variables |
| CNoOwnershipChangeVisitor | |
| CNoStateChangeFuncVisitor | Put a diagnostic on return statement (or on } in its absence) of all inlined functions for which some property remained unchanged |
| CNoStoreFuncVisitor | Put a diagnostic on return statement of all inlined functions for which the region of interest RegionOfInterest was passed into, but not written inside, and it has caused an undefined read or a null pointer dereference outside |
| CNoteTag | The tag upon which the TagVisitor reacts |
| CObjCIvarRegion | |
| CObjCMethodCall | Represents any expression that calls an Objective-C method |
| CObjCStringRegion | The region associated with an ObjCStringLiteral |
| CObjCSummaryCache | |
| CObjCSummaryKey | A key identifying a summary |
| COperatorKind | |
| CPackageInfo | Specifies a package |
| CParamVarRegion | ParamVarRegion - Represents a region for parameters |
| CParseModelFileAction | Frontend action to parse model files |
| CPathDiagnostic | PathDiagnostic - PathDiagnostic objects represent a single path-sensitive diagnostic |
| CPathDiagnosticCallPiece | |
| CPathDiagnosticConsumer | |
| CFilesMade | |
| CPDFileEntry | |
| CPathDiagnosticConsumerOptions | These options tweak the behavior of path diangostic consumers |
| CPathDiagnosticControlFlowPiece | |
| CPathDiagnosticEventPiece | |
| CPathDiagnosticLocation | |
| CPathDiagnosticLocationPair | |
| CPathDiagnosticMacroPiece | |
| CPathDiagnosticNotePiece | |
| CPathDiagnosticPiece | |
| CPathDiagnosticPopUpPiece | |
| CPathDiagnosticRange | |
| CPathDiagnosticSpotPiece | |
| CPathPieces | |
| CPathSensitiveBugReport | |
| CPathSensitiveBugReporter | GRBugReporter is used for generating path-sensitive reports |
| CPointerToMemberData | |
| CPrettyStackTraceLocationContext | While alive, includes the current analysis stack in a crash trace |
| CProgramState | ProgramState - This class encapsulates: |
| CProgramStateManager | |
| CProgramStatePartialTrait | |
| CProgramStatePartialTrait< llvm::ImmutableList< T > > | |
| CProgramStatePartialTrait< llvm::ImmutableMap< Key, Data, Info > > | |
| CProgramStatePartialTrait< llvm::ImmutableSet< Key, Info > > | |
| CProgramStatePartialTrait< T *, void > | |
| CProgramStatePartialTrait< T, std::enable_if_t< std::is_enum< T >::value > > | |
| CProgramStatePartialTrait< T, std::enable_if_t< std::is_integral< T >::value > > | |
| CProgramStateTrait | |
| CProgramStateTrait< iterator::ContainerMap > | |
| CProgramStateTrait< iterator::IteratorRegionMap > | |
| CProgramStateTrait< iterator::IteratorSymbolMap > | |
| CProgramStateTrait< mpi::RequestMap > | |
| CProgramStateTrait< ReplayWithoutInlining > | |
| CRange | A Range represents the closed range [from, to] |
| CRangedConstraintManager | |
| CRangeSet | Persistent set of non-overlapping ranges |
| CFactory | |
| CRegionAndSymbolInvalidationTraits | Information about invalidation for a particular region/symbol |
| CRegionOffset | Represent a region's offset within the top level base region |
| CRegionRawOffset | |
| CReplayWithoutInlining | Traits for storing the call processing policy inside GDM |
| CRetainSummary | Summary for a function with respect to ownership changes |
| CRetainSummaryManager | |
| CRetainSummaryTemplate | |
| CRetEffect | RetEffect summarizes a call's retain/release behavior with respect to its return value |
| CRuntimeDefinition | Defines the runtime definition of the called function |
| CScanReachableSymbols | A utility class that visits the reachable symbols using a custom SymbolVisitor |
| CSimpleConstraintManager | |
| CSimpleFunctionCall | Represents a C function or static C++ member function call |
| CSMTConstraintManager | |
| CSMTConv | |
| CStackArgumentsSpaceRegion | |
| CStackHintGenerator | Interface for classes constructing Stack hints |
| CStackHintGeneratorForSymbol | Constructs a Stack hint for the given symbol |
| CStackLocalsSpaceRegion | |
| CStackSpaceRegion | |
| CStaticGlobalSpaceRegion | The region of the static variables within the current CodeTextRegion scope |
| CStmtNodeBuilder | This builder class is useful for generating nodes that resulted from visiting a statement |
| CStoreManager | |
| CBindingsHandler | |
| CFindUniqueBinding | |
| CStoreRef | |
| CStringRegion | StringRegion - Region associated with a StringLiteral |
| CSubRegion | SubRegion - A region that subsets another larger region |
| CSummaryManager | |
| CSummaryManagerImpl | |
| CSuppressInlineDefensiveChecksVisitor | |
| CSVal | SVal - This represents a symbolic expression, which can be either an L-value or an R-value |
| CSValBuilder | |
| CSValExplainer | |
| CSValVisitor | SValVisitor - this class implements a simple visitor for SVal subclasses |
| CSwitchNodeBuilder | |
| Citerator | |
| CSymbolCast | Represents a cast expression |
| CSymbolConjured | A symbol representing the result of an expression in the case when we do not know anything about what the expression is |
| CSymbolData | A symbol representing data which can be stored in a memory location (region) |
| CSymbolDerived | A symbol representing the value of a MemRegion whose parent region has symbolic value |
| CSymbolExtent | SymbolExtent - Represents the extent (size in bytes) of a bounded region |
| CSymbolicRegion | SymbolicRegion - A special, "non-concrete" region |
| CSymbolManager | |
| CSymbolMetadata | SymbolMetadata - Represents path-dependent metadata about a specific region |
| CSymbolReaper | A class responsible for cleaning up unused symbols |
| CSymbolRegionValue | A symbol representing the value stored at a MemRegion |
| CSymbolVisitor | |
| CSymExpr | Symbolic value |
| Csymbol_iterator | Iterator over symbols that the current symbol depends on |
| CSymExprAllocator | |
| CSymExprVisitor | SymExprVisitor - this class implements a simple visitor for SymExpr subclasses |
| CTagVisitor | The visitor detects NoteTags and displays the event notes they contain |
| CTrackConstraintBRVisitor | |
| CTypedRegion | TypedRegion - An abstract class representing regions that are typed |
| CTypedValueRegion | TypedValueRegion - An abstract class representing regions having a typed value |
| CUnarySymExpr | Represents a symbolic expression involving a unary operator |
| CUndefinedVal | |
| CUndefOrNullArgVisitor | When a region containing undefined value or '0' value is passed as an argument in a call, marks the call as interesting |
| CUninitObjCheckerOptions | |
| CUnknownSpaceRegion | |
| CUnknownVal | |
| CUnsignedEPStat | |
| CUnsignedMaxEntryPointTranslationUnitStatistic | |
| CUnsignedMaxEPStat | |
| CVarRegion | |
| CWorkList | |
| CWorkListUnit | |
| CZ3CrosscheckOracle | The oracle will decide if a report should be accepted or rejected based on the results of the Z3 solver and the statistics of the queries of a report equivalenece class |
| CZ3CrosscheckVisitor | The bug visitor will walk all the nodes in a path and collect all the constraints |
| CZ3Result | |
| Nextractapi | |
| Nimpl | |
| CExtractAPIVisitorBase | |
| CAccessControl | |
| CAPIIgnoresList | A type that provides access to a new line separated list of symbol names to ignore when extracting API information |
| CAPIRecord | The base representation of an API record. Holds common symbol information |
| CAPISet | APISet holds the set of API records collected from given inputs |
| CAPISetVisitor | The base interface of visitors for API information, the interface and usage is almost identical to RecurisveASTVistor |
| CClassTemplatePartialSpecializationRecord | |
| CClassTemplateRecord | |
| CClassTemplateSpecializationRecord | |
| CConceptRecord | |
| CCXXClassRecord | |
| CCXXConstructorRecord | |
| CCXXDestructorRecord | |
| CCXXFieldRecord | |
| CCXXFieldTemplateRecord | |
| CCXXInstanceMethodRecord | |
| CCXXMethodRecord | |
| CCXXMethodTemplateRecord | |
| CCXXMethodTemplateSpecializationRecord | |
| CCXXStaticMethodRecord | |
| CDeclarationFragments | DeclarationFragments is a vector of tagged important parts of a symbol's declaration |
| CFragment | Fragment holds information of a single fragment |
| CDeclarationFragmentsBuilder | A factory class to build DeclarationFragments for different kinds of Decl |
| CEnumConstantRecord | This holds information associated with enum constants |
| CEnumRecord | This holds information associated with enums |
| CExtendedModule | A representation of the contents of a given module symbol graph |
| CExtractAPIVisitor | The RecursiveASTVisitor to traverse symbol declarations and collect API information |
| CFromRecordContextCastInfoWrapper | |
| CFromRecordContextCastInfoWrapper< ToTy, true > | |
| CFunctionSignature | Store function signature information with DeclarationFragments of the return type and parameters |
| CParameter | Parameter holds the name and DeclarationFragments of a single parameter |
| CGlobalFunctionRecord | This holds information associated with global functions |
| CGlobalFunctionTemplateRecord | |
| CGlobalFunctionTemplateSpecializationRecord | |
| CGlobalVariableRecord | This holds information associated with global functions |
| CGlobalVariableTemplatePartialSpecializationRecord | |
| CGlobalVariableTemplateRecord | |
| CGlobalVariableTemplateSpecializationRecord | |
| CIgnoresFileNotFound | |
| CMacroDefinitionRecord | This holds information associated with macro definitions |
| CNamespaceRecord | |
| CObjCCategoryRecord | This holds information associated with Objective-C categories |
| CObjCClassMethodRecord | |
| CObjCClassPropertyRecord | |
| CObjCContainerRecord | The base representation of an Objective-C container record |
| CObjCInstanceMethodRecord | |
| CObjCInstancePropertyRecord | |
| CObjCInstanceVariableRecord | This holds information associated with Objective-C instance variables |
| CObjCInterfaceRecord | This holds information associated with Objective-C interfaces/classes |
| CObjCMethodRecord | This holds information associated with Objective-C methods |
| CObjCPropertyRecord | This holds information associated with Objective-C properties |
| CObjCProtocolRecord | This holds information associated with Objective-C protocols |
| CRecordContext | Base class used for specific record types that have children records this is analogous to the DeclContext for the AST |
| Crecord_iterator | |
| CRecordFieldRecord | This holds information associated with struct or union fields fields |
| CRecordRecord | This holds information associated with structs and unions |
| CStaticFieldRecord | |
| CStructFieldRecord | |
| CStructRecord | |
| CSymbolGraphSerializer | The visitor that organizes API information in the Symbol Graph format |
| CSymbolGraphSerializerOption | Common options to customize the visitor output |
| CSymbolReference | Sources |
| CTagRecord | |
| CTemplate | |
| CToRecordContextCastInfoWrapper | |
| CToRecordContextCastInfoWrapper< FromTy, true > | |
| CTypedefRecord | This holds information associated with typedefs |
| CTypedefUnderlyingTypeResolver | |
| CUnionFieldRecord | |
| CUnionRecord | |
| NFileMgr | |
| CMapEntryOptionalStorage | Customized storage for refs derived from map entires in FileManager, using the private optional_none_tag to keep it to the size of a single pointer |
| Nformat | |
| CAffectedRangeManager | |
| CAnnotatedLine | |
| CBreakableBlockComment | |
| CBreakableComment | |
| CBreakableLineCommentSection | |
| CBreakableStringLiteral | |
| CBreakableStringLiteralUsingOperators | |
| CBreakableToken | Base class for tokens / ranges of tokens that can allow breaking within the tokens - for example, to avoid whitespace beyond the column limit, or to reflow text |
| CCompoundStatementIndenter | |
| CContinuationIndenter | |
| CDefinitionBlockSeparator | |
| CEnvironment | |
| CFatalDiagnosticConsumer | |
| CFormatToken | A wrapper around a Token storing information about the whitespace characters preceding it |
| CFormatTokenLexer | |
| CFormatTokenSource | |
| CIndentationAndAlignment | Represents the spaces at the start of a line, keeping track of what the spaces are for |
| CIndexedTokenSource | |
| CIntegerLiteralSeparatorFixer | |
| CJavaScriptImportSorter | |
| CJsImportedSymbol | |
| CJsModuleReference | |
| CLeftRightQualifierAlignmentFixer | |
| CLineState | The current state when indenting a unwrapped line |
| CMacroCallReconstructor | Converts a sequence of UnwrappedLines containing expanded macros into a single UnwrappedLine containing the macro calls |
| CMacroExpander | Takes a set of macro definitions as strings and allows expanding calls to those macros |
| CDefinition | |
| CDefinitionParser | |
| CMacroExpansion | Contains information on the token's role in a macro expansion |
| CNamespaceEndCommentsFixer | |
| CNumericLiteralCaseFixer | |
| CNumericLiteralInfo | |
| CObjCPropertyAttributeOrderFixer | |
| CObjCPropertyEntry | |
| CParenState | |
| CParseErrorCategory | |
| CRawStringFormatStyleManager | |
| CScopedLineState | |
| CScopedMacroState | |
| CTokenAnalyzer | |
| CTokenAnnotator | Determines extra information about the tokens comprising an UnwrappedLine |
| CUnwrappedLine | An unwrapped line is a sequence of Token, that we would like to put on a single line if there was no column limit |
| CUnwrappedLineConsumer | Interface for users of the UnwrappedLineParser to receive the parsed lines |
| CUnwrappedLineFormatter | |
| CUnwrappedLineNode | |
| CUnwrappedLineParser | |
| CUsingDeclarationsSorter | |
| CWhitespaceManager | Manages the whitespaces around tokens and their replacements |
| CChange | Represents a change before a token, a break inside a token, or the layout of an unchanged token (or whitespace within) |
| CIsBeforeInFile | Functor to sort changes in original source order |
| Nhlsl | |
| CBuiltinTypeDeclBuilder | |
| CBuiltinTypeMethodBuilder | |
| CResourceBindingAttrs | |
| CRootSignatureElement | |
| CRootSignatureLexer | |
| CRootSignatureParser | |
| CRootSignatureToken | |
| CTemplateParameterListBuilder | |
| Nhtml | |
| CRelexRewriteCache | |
| CHighlight | |
| CRawHighlight | |
| Nindex | |
| CCommentToXMLConverter | |
| CDeclOccurrence | |
| CFileIndexRecord | Stores the declaration occurrences seen in a particular source or header file of a translation unit |
| CIndexDataConsumer | |
| CASTNodeInfo | |
| CIndexingContext | |
| CIndexingOptions | |
| CPathPool | Pool of filesystem paths backed by a StringPool |
| CDirPath | |
| CFilePath | |
| CSerializablePathCollection | Stores file paths and produces serialization-friendly representation |
| CStringPool | Pool of strings |
| CStringOffsetSize | |
| CSymbolInfo | |
| CSymbolRelation | Represents a relation to another symbol for a symbol occurrence |
| Ninstallapi | The DirectoryScanner for collecting library files on the file system |
| CDirectoryScanner | |
| CDylibVerifier | Service responsible to tracking state of verification across the lifetime of InstallAPI |
| CDWARFContext | |
| CSymbolContext | Metadata stored about a mapping of a declaration to a symbol |
| CVerifierContext | |
| CFileListReader | |
| CFrontendAttrs | Frontend information captured about records |
| CFrontendRecordsSlice | |
| CHeaderFile | |
| CHeaderGlob | Glob that represents a pattern of header files to retreive |
| CInstallAPIAction | |
| CInstallAPIContext | Struct used for generating validating InstallAPI |
| CInstallAPIVisitor | ASTVisitor for collecting declarations that represent global symbols |
| CLibAttrs | Represents dynamic library specific attributes that are tied to architecture slices |
| CLibrary | |
| CZipperedDeclSource | |
| Ninternal | |
| CCFGIntervalNode | |
| Ninterp | |
| CArrayIndexScope | |
| CBitcastBuffer | Track what bits have been initialized to known values and which ones have indeterminate value |
| CBitRange | A bit range. Both Start and End are inclusive |
| CBits | A quantity in bits |
| CBlock | A memory block, either on the stack or in the heap |
| CBlockPointer | |
| CBoolean | Wrapper around boolean types |
| CByteCodeEmitter | An emitter which links the program to bytecode for later use |
| CBytes | A quantity in bytes |
| CCodePtr | Pointer into the code segment |
| CCompiler | Compilation context for expressions |
| CLabelInfo | |
| CContext | Holds all information required to evaluate constexpr code in a module |
| CDeadBlock | Descriptor for a dead block |
| CDeclScope | Scope used to handle temporaries in toplevel variable declarations |
| CDescriptor | Describes a memory block created by an allocation site |
| CUnknownSize | Token to denote structures of unknown size |
| CDestructorScope | |
| CDynamicAllocator | Manages dynamic memory allocations done during bytecode interpretation |
| CEvalEmitter | An emitter which evaluates opcodes as they are emitted |
| CEvaluationResult | Defines the result of an evaluation |
| CFixedPoint | Wrapper around fixed point types |
| CFloating | If a Floating is constructed from Memory, it DOES NOT OWN THAT MEMORY |
| CFrame | Base class for stack frames, shared between VM and walker |
| CFunction | Bytecode function |
| CParamDescriptor | |
| CFunctionPointer | |
| CGlobalInlineDescriptor | Descriptor used for global variables |
| CInitLink | |
| CInitLinkScope | |
| CInitMap | Bitfield tracking the initialisation status of elements of primitive arrays |
| CInitMapPtr | A pointer-sized struct we use to allocate into data storage |
| CInitStackScope | |
| CInlineDescriptor | Inline descriptor embedded in structures and arrays |
| CIntegral | Wrapper around numeric types |
| CIntegralAP | If an IntegralAP is constructed from Memory, it DOES NOT OWN THAT MEMORY |
| CInterpFrame | Frame storing local variables |
| CInterpStack | Stack frame storing temporaries and parameters |
| CInterpState | Interpreter context |
| CInterpStateCCOverride | |
| CIntPointer | |
| CLabelScope | |
| CLocalScope | Generic scope for local variables |
| CLocOverrideScope | When generating code for e.g |
| CLoopScope | Sets the context for break/continue statements |
| CMemberPointer | |
| COptionScope | Scope used to handle initialization methods |
| COptPrimType | |
| CParamOffset | |
| CPointer | A pointer to a memory block, live or dead |
| CPrimConv | Mapping from primitive types to their representation |
| CPrimConv< PT_Bool > | |
| CPrimConv< PT_FixedPoint > | |
| CPrimConv< PT_Float > | |
| CPrimConv< PT_IntAP > | |
| CPrimConv< PT_IntAPS > | |
| CPrimConv< PT_MemberPtr > | |
| CPrimConv< PT_Ptr > | |
| CPrimConv< PT_Sint16 > | |
| CPrimConv< PT_Sint32 > | |
| CPrimConv< PT_Sint64 > | |
| CPrimConv< PT_Sint8 > | |
| CPrimConv< PT_Uint16 > | |
| CPrimConv< PT_Uint32 > | |
| CPrimConv< PT_Uint64 > | |
| CPrimConv< PT_Uint8 > | |
| CProgram | The program contains and links the bytecode for all functions |
| CDeclScope | Context to manage declaration lifetimes |
| CRecord | Structure/Class descriptor |
| CBase | Describes a base class |
| CField | Describes a record field |
| CRepr | |
| CRepr< 16, false > | |
| CRepr< 16, true > | |
| CRepr< 32, false > | |
| CRepr< 32, true > | |
| CRepr< 64, false > | |
| CRepr< 64, true > | |
| CRepr< 8, false > | |
| CRepr< 8, true > | |
| CScope | Describes a scope block |
| CLocal | Information about a local's storage |
| CSourceInfo | Describes the statement/declaration an opcode was generated from |
| CSourceLocScope | |
| CSourceMapper | Interface for classes which map locations to sources |
| CState | Interface for the VM to interact with the AST walker's context |
| CStdAllocatorCaller | |
| CStmtExprScope | |
| CSwitchScope | |
| CTypeidPointer | |
| CVarCreationState | State encapsulating if a the variable creation has been successful, unsuccessful, or no variable has been created at all |
| CVariableScope | Scope chain managing the variable lifetimes |
| Nlifetimes | |
| Ninternal | |
| Nutils | |
| CID | A generic, type-safe wrapper for an ID, distinguished by its Tag type |
| CAccessPath | Represents the storage location being borrowed, e.g., a specific stack variable |
| CDataflowAnalysis | A generic, policy-based driver for dataflow analyses |
| CExpireFact | |
| CFact | An abstract base class for a single, atomic lifetime-relevant event |
| CFactManager | |
| CFactsGenerator | |
| CFieldEscapeFact | Represents that an origin escapes via assignment to a field |
| CIssueFact | |
| CLifetimeFactory | An object to hold the factories for immutable collections, ensuring that all created states share the same underlying memory management |
| CLifetimeSafetyAnalysis | Running the lifetime safety analysis and querying its results |
| CLivenessInfo | Information about why an origin is live at a program point |
| CLiveOriginsAnalysis | |
| CImpl | |
| CLoan | An abstract base class for a single "Loan" which represents lending a storage in memory |
| CLoanManager | Manages the creation, storage and retrieval of loans |
| CLoanPropagationAnalysis | |
| CImpl | |
| COrigin | An Origin is a symbolic identifier that represents the set of possible loans a pointer-like object could hold at any given time |
| COriginEscapesFact | Represents that an origin escapes the current scope through various means |
| COriginFlowFact | |
| COriginList | A list of origins representing levels of indirection for pointer-like types |
| COriginManager | Manages the creation, storage, and retrieval of origins for pointer-like variables and expressions |
| CPathLoan | PathLoan represents lending a storage location that is visible within the function's scope (e.g., a local variable on stack) |
| CPlaceholderLoan | A placeholder loan held by a function parameter or an implicit 'this' object, representing a borrow from the caller's scope |
| CReturnEscapeFact | Represents that an origin escapes via a return statement |
| CTestPointFact | A dummy-fact used to mark a specific point in the code for testing |
| CUseFact | |
| CLifetimeSafetySemaHelper | Abstract interface for operations requiring Sema access |
| CLifetimeSafetyStats | A structure to hold the statistics related to LifetimeAnalysis |
| Nmodulemap | |
| CConfigMacrosDecl | |
| CConflictDecl | |
| CExcludeDecl | |
| CExportAsDecl | |
| CExportDecl | |
| CExternModuleDecl | |
| CHeaderDecl | |
| CLinkDecl | |
| CModuleDecl | |
| CModuleMapFile | Represents the parsed form of a module map file |
| CRequiresDecl | |
| CRequiresFeature | |
| CUmbrellaDirDecl | |
| CUseDecl | |
| Noptional_detail | |
| COptionalStorage | |
| COptionalStorage< clang::DirectoryEntryRef > | Customize OptionalStorage<DirectoryEntryRef> to use DirectoryEntryRef and its optional_none_tag to keep it the size of a single pointer |
| COptionalStorage< clang::FileEntryRef > | Customize OptionalStorage<FileEntryRef> to use FileEntryRef and its optional_none_tag to keep it the size of a single pointer |
| Nreachable_code | |
| CCallback | |
| NRISCV | RISCV builtins |
| CLMULType | |
| CPolicy | |
| CPrototypeDescriptor | |
| CRVVIntrinsic | |
| CRVVIntrinsicRecord | |
| CRVVType | |
| CRVVTypeCache | |
| Nsema | |
| CAccessedEntity | A declaration being accessed, together with information about how it was accessed |
| CAnalysisBasedWarnings | |
| CInterProceduralData | InterProceduralData aims to be a storage of whatever data should be passed between analyses of different functions |
| CPolicy | |
| CAssignedEntity | Describes an entity that is being assigned |
| CBlockScopeInfo | Retains information about a block that is currently being parsed |
| CCapture | |
| CCapturedRegionScopeInfo | Retains information about a captured region |
| CCapturingEntity | |
| CCapturingScopeInfo | |
| CCompoundScopeInfo | Contains information about the compound statement currently being parsed |
| CDelayedDiagnostic | A diagnostic message which has been conditionally emitted pending the complete parsing of the current declaration |
| CDelayedDiagnosticPool | A collection of diagnostics which were delayed |
| CFunctionScopeInfo | Retains information about a function, method, or block that is currently being parsed |
| CWeakObjectProfileTy | Represents a simple identification of a weak object |
| CDenseMapInfo | |
| CWeakUseTy | Represents a single use of a weak object |
| CLambdaScopeInfo | |
| CShadowedOuterDecl | Contains all of the variables defined in this lambda that shadow variables that were defined in parent contexts |
| CPossiblyUnreachableDiag | |
| CRISCVIntrinsicManager | |
| CSemaPPCallbacks | |
| CTemplateDeductionInfo | Provides information about an attempted template argument deduction, whose success or failure was described by a TemplateDeductionResult value |
| Nserialization | |
| Nreader | |
| CASTDeclContextNameLookupTrait | Class that performs name lookup into a DeclContext stored in an AST file |
| CASTDeclContextNameLookupTraitBase | |
| Cdata_type_builder | |
| CASTIdentifierLookupTrait | Class that performs lookup for an identifier stored in an AST file |
| CASTIdentifierLookupTraitBase | Base class for the trait describing the on-disk hash table for the identifiers in an AST file |
| CASTSelectorLookupTrait | Class that performs lookup for a selector's entries in the global method pool stored in an AST file |
| Cdata_type | |
| CDeclContextLookupTable | |
| CHeaderFileInfoTrait | Trait class used to search the on-disk hash table containing all of the header search information |
| Cinternal_key_type | |
| CLazySpecializationInfoLookupTable | |
| CLazySpecializationInfoLookupTrait | Class that performs lookup to specialized decls |
| Cdata_type_builder | |
| CModuleLocalLookupTable | |
| CModuleLocalNameLookupTrait | |
| CAbstractTypeReader | |
| CAbstractTypeWriter | |
| CBasicReaderBase | |
| CDataStreamBasicReader | DataStreamBasicReader provides convenience implementations for many BasicReader methods based on the assumption that the ultimate reader implementation is based on a variable-length stream of unstructured data (like Clang's module files) |
| CDataStreamBasicWriter | DataStreamBasicWriter provides convenience implementations for many BasicWriter methods based on the assumption that the ultimate writer implementation is based on a variable-length stream of unstructured data (like Clang's module files) |
| CDeclarationNameKey | A key used when looking up entities by DeclarationName |
| CDeclOffset | Source location and bit offset of a declaration |
| CInputFile | The input file that has been loaded from this AST file, along with bools indicating whether this was an overridden buffer or if it was out-of-date or not-found |
| CInputFileInfo | The input file info that has been loaded from an AST file |
| CModuleFile | Information about a module that has been loaded by the ASTReader |
| CModuleManager | Manages the set of modules loaded by an AST reader |
| CMultiOnDiskHashTable | A collection of on-disk hash tables, merged when relevant for performance |
| CMultiOnDiskHashTableGenerator | Writer for the on-disk hash table |
| CObjCCategoriesInfo | Describes the categories of an Objective-C class |
| CPPEntityOffset | Source range/offset of a preprocessed entity |
| CPPSkippedRange | Source range of a skipped preprocessor region |
| CReadMethodPoolVisitor | |
| CTypeIdx | A type index; the type ID with the qualifier bits removed |
| CUnalignedUInt64 | 32 aligned uint64_t in the AST file |
| CUnsafeQualTypeDenseMapInfo | A structure for putting "fast"-unqualified QualTypes into a DenseMap |
| Nserialized_diags | |
| CLocation | A location that is represented in the serialized diagnostics |
| CSerializedDiagnosticReader | A base class that handles reading serialized diagnostics from a file |
| NSrcMgr | Public enums and private classes that are part of the SourceManager implementation |
| CContentCache | One instance of this struct is kept for every file loaded or used |
| CExpansionInfo | Each ExpansionInfo encodes the expansion location - where the token was ultimately expanded, and the SpellingLoc - where the actual character data for the token came from |
| CFileInfo | Information about a FileID, basically just the logical file that it represents and include stack information |
| CLineOffsetMapping | Mapping of line offsets into a source file |
| CSLocEntry | This is a discriminated union of FileInfo and ExpansionInfo |
| Nssaf | |
| CBuildNamespace | Represents a single namespace in the build process |
| CEntityId | Lightweight opaque handle representing an entity in an EntityIdTable |
| CEntityIdTable | Manages entity name interning and provides efficient EntityId handles |
| CEntityName | Uniquely identifies an entity in a program |
| CEntitySummary | Base class for analysis-specific summary data |
| CNestedBuildNamespace | Represents a hierarchical sequence of build namespaces |
| CSerializationFormat | Abstract base class for serialization formats |
| CSummaryName | Uniquely identifies an analysis summary |
| CTUSummary | Data extracted for a given translation unit and for a given set of analyses |
| CTUSummaryBuilder | |
| CTUSummaryExtractor | |
| Nsyntax | |
| CArena | A memory arena for syntax trees |
| CArraySubscript | Array size specified inside a declarator |
| CBinaryOperatorExpression | <lhs> <operator> <rhs> |
| CBreakStatement | Break; |
| CCallArguments | Models arguments of a function call |
| CCaseStatement | Case : <body> |
| CCompoundStatement | { statement1; statement2; … } |
| CContinueStatement | Continue; |
| CDeclaration | A declaration that can appear at the top-level |
| CDeclarationStatement | E.g. 'int a, b = 10;' |
| CDeclarator | Covers a name, an initializer and a part of the type outside declaration specifiers |
| CDeclaratorList | |
| CDefaultStatement | Default: <body> |
| CEmptyDeclaration | A semicolon in the top-level context. Does not declare anything |
| CEmptyStatement | The no-op statement, i.e. ';' |
| CExplicitTemplateInstantiation | Template <declaration> Examples: template struct X<int> template void foo<int>() template int var<double> |
| CExpressionStatement | Expression in a statement position, e.g |
| CFactoryImpl | Exposes private syntax tree APIs required to implement node synthesis |
| CFileRange | A half-open character range inside a particular file, the start offset is included and the end offset is excluded from the range |
| CForStatement | For (<init>; <cond>; <increment>) <body> |
| CIfStatement | If (cond) <then-statement> else <else-statement> FIXME: add condition that models 'expression or variable declaration' |
| CLeaf | A leaf node points to a single token |
| CLinkageSpecificationDeclaration | Extern <string-literal> declaration extern <string-literal> { <decls> } |
| CList | A list of Elements separated or terminated by a fixed token |
| CElementAndDelimiter | |
| CMemberPointer | Member pointer inside a declarator E.g |
| CMutationsImpl | |
| CNamespaceAliasDefinition | Namespace <name> = <namespace-reference> |
| CNamespaceDefinition | Namespace <name> { <decls> } |
| CNestedNameSpecifier | Models a nested-name-specifier |
| CNode | A node in a syntax tree |
| CParameterDeclarationList | Models a parameter-declaration-list which appears within parameters-and-qualifiers |
| CParametersAndQualifiers | Parameter list for a function type and a trailing return type, if the function has one |
| CParenDeclarator | Declarator inside parentheses |
| CPostfixUnaryOperatorExpression | <operand> <operator> |
| CPrefixUnaryOperatorExpression | <operator> <operand> |
| CRangeBasedForStatement | For (<decl> : <init>) <body> |
| CReturnStatement | Return <expr>; return; |
| CSimpleDeclaration | Groups multiple declarators (e.g |
| CSimpleDeclarator | A top-level declarator without parentheses |
| CStatement | An abstract node for C++ statements, e.g |
| CStaticAssertDeclaration | Static_assert(<condition>, <message>) static_assert(<condition>) |
| CSwitchStatement | Switch (<cond>) <body> |
| CTemplateDeclaration | Template <template-parameters> <declaration> |
| CToken | A token coming directly from a file or from a macro invocation |
| CTokenBuffer | A list of tokens obtained by preprocessing a text buffer and operations to map between the expanded and spelled tokens, i.e |
| CExpansion | An expansion produced by the preprocessor, includes macro expansions and preprocessor directives |
| CTokenBufferTokenManager | A TokenBuffer-powered token manager |
| CTokenCollector | Collects tokens for the main file while running the frontend action |
| CTokenManager | Defines interfaces for operating "Token" in the clang syntax-tree |
| CTrailingReturnType | Trailing return type after the parameter list, including the arrow token |
| CTree | A node that has children and represents a syntactic language construct |
| CChildIterator | Child_iterator is not invalidated by mutations |
| CConstChildIterator | |
| CTypeAliasDeclaration | Using <name> = <type> |
| CUnaryOperatorExpression | An abstract class for prefix and postfix unary operators |
| CUnknownDeclaration | Declaration of an unknown kind, e.g. not yet supported in syntax trees |
| CUnknownExpression | An expression of an unknown kind, i.e |
| CUnknownStatement | A statement of an unknown kind, i.e |
| CUnqualifiedId | Models an unqualified-id |
| CUsingDeclaration | Using <scope>::<name> using typename <scope>::<name> |
| CUsingNamespaceDirective | Using namespace <name> |
| CWhileStatement | While (<cond>) <body> |
| Ntargets | |
| CAArch64beTargetInfo | |
| CAArch64leTargetInfo | |
| CAArch64TargetInfo | |
| CAIXPPC32TargetInfo | |
| CAIXPPC64TargetInfo | |
| CAIXTargetInfo | |
| CAMDGPUTargetInfo | |
| CAndroidX86_32TargetInfo | |
| CAndroidX86_64TargetInfo | |
| CAppleMachOAArch64TargetInfo | |
| CAppleMachOARMTargetInfo | |
| CAppleMachOI386TargetInfo | |
| CAppleMachOTargetInfo | |
| CARCTargetInfo | |
| CARMbeTargetInfo | |
| CARMleTargetInfo | |
| CARMTargetInfo | |
| CAVRTargetInfo | |
| CBaseSPIRTargetInfo | |
| CBaseSPIRVTargetInfo | |
| CBPFTargetInfo | |
| CCSKYTargetInfo | |
| CCygwinARMTargetInfo | |
| CCygwinX86_32TargetInfo | |
| CCygwinX86_64TargetInfo | |
| CDarwinAArch64TargetInfo | |
| CDarwinARMTargetInfo | |
| CDarwinI386TargetInfo | |
| CDarwinTargetInfo | |
| CDarwinX86_64TargetInfo | |
| CDirectXTargetInfo | |
| CDragonFlyBSDTargetInfo | |
| CEmscriptenTargetInfo | |
| CFreeBSDTargetInfo | |
| CFuchsiaTargetInfo | |
| CHaikuTargetInfo | |
| CHaikuX86_32TargetInfo | |
| CHexagonTargetInfo | |
| CHurdTargetInfo | |
| CItaniumWindowsARMleTargetInfo | |
| CKFreeBSDTargetInfo | |
| CLanaiTargetInfo | |
| CLinuxTargetInfo | |
| CLoongArch32TargetInfo | |
| CLoongArch64TargetInfo | |
| CLoongArchTargetInfo | |
| CM68kTargetInfo | |
| CManagarmTargetInfo | |
| CMCUInfo | Information about a specific microcontroller |
| CMCUX86_32TargetInfo | |
| CMicrosoftARM64TargetInfo | |
| CMicrosoftARMleTargetInfo | |
| CMicrosoftMipsTargetInfo | |
| CMicrosoftX86_32TargetInfo | |
| CMicrosoftX86_64TargetInfo | |
| CMinGWARM64TargetInfo | |
| CMinGWARMTargetInfo | |
| CMinGWMipsTargetInfo | |
| CMinGWX86_32TargetInfo | |
| CMinGWX86_64TargetInfo | |
| CMipsTargetInfo | |
| CMSP430TargetInfo | |
| CNetBSDI386TargetInfo | |
| CNetBSDTargetInfo | |
| CNVPTXTargetInfo | |
| COHOSTargetInfo | |
| COHOSX86_32TargetInfo | |
| COHOSX86_64TargetInfo | |
| COpenBSDI386TargetInfo | |
| COpenBSDTargetInfo | |
| COpenBSDX86_64TargetInfo | |
| COSTargetInfo | |
| CPPC32TargetInfo | |
| CPPC64TargetInfo | |
| CPPCTargetInfo | |
| CPS3PPUTargetInfo | |
| CPS4OSTargetInfo | |
| CPS5OSTargetInfo | |
| CPSOSTargetInfo | |
| CRISCV32TargetInfo | |
| CRISCV64TargetInfo | |
| CRISCVTargetInfo | |
| CRTEMSTargetInfo | |
| CRTEMSX86_32TargetInfo | |
| CSolarisTargetInfo | |
| CSparcTargetInfo | |
| CSparcV8elTargetInfo | |
| CSparcV8TargetInfo | |
| CSparcV9TargetInfo | |
| CSPIR32TargetInfo | |
| CSPIR64TargetInfo | |
| CSPIRTargetInfo | |
| CSPIRV32TargetInfo | |
| CSPIRV64AMDGCNTargetInfo | |
| CSPIRV64IntelTargetInfo | |
| CSPIRV64TargetInfo | |
| CSPIRVTargetInfo | |
| CSystemZTargetInfo | |
| CTCELETargetInfo | |
| CTCETargetInfo | |
| CUEFITargetInfo | |
| CUEFIX86_64TargetInfo | |
| CVETargetInfo | |
| CWALITargetInfo | |
| CWASIP1TargetInfo | |
| CWASIP2TargetInfo | |
| CWASIP3TargetInfo | |
| CWebAssembly32TargetInfo | |
| CWebAssembly64TargetInfo | |
| CWebAssemblyOSTargetInfo | |
| CWebAssemblyTargetInfo | |
| CWindowsARM64TargetInfo | |
| CWindowsARMTargetInfo | |
| CWindowsMipsTargetInfo | |
| CWindowsTargetInfo | |
| CWindowsX86_32TargetInfo | |
| CWindowsX86_64TargetInfo | |
| CX86_32TargetInfo | |
| CX86_64TargetInfo | |
| CX86TargetInfo | |
| CXCoreTargetInfo | |
| CXtensaTargetInfo | |
| CZOSTargetInfo | |
| Ntemplateargumentvisitor | |
| CBase | A simple visitor class that helps create template argument visitors |
| NthreadSafety | |
| Nlexpr | |
| CAnd | |
| CBinOp | |
| CLExpr | |
| CNot | |
| COr | |
| CTerminal | |
| Ntil | |
| CAlloc | Allocate memory for a new value on the heap or stack |
| CApply | Apply an argument to a function |
| CArrayAdd | Pointer arithmetic, restricted to arrays only |
| CArrayIndex | If p is a reference to an array, then p[i] is a reference to the i'th element of the array |
| CBasicBlock | A basic block is part of an SCFG |
| CTopologyNode | |
| CBinaryOp | Simple arithmetic binary operations, e.g |
| CBranch | A conditional branch to two other blocks |
| CCall | Call a function (after all arguments have been applied) |
| CCast | Cast expressions |
| CCode | A block of code – e.g. the body of a function |
| CComparator | |
| CCopyReducerBase | |
| CContainer | |
| CEqualsComparator | |
| CField | A typed, writable location in memory |
| CFunction | A function – a.k.a |
| CFuture | Placeholder for an expression that has not yet been created |
| CGoto | Jump to another basic block |
| CIdentifier | An identifier, e.g |
| CIfThenElse | An if-then-else expression |
| CLet | A let-expression, e.g |
| CLiteral | |
| CLiteralPtr | A Literal pointer to an object allocated in memory |
| CLiteralT | |
| CLoad | Load a value from memory |
| CMatchComparator | |
| CMemRegionRef | |
| CPhi | Phi Node, for code in SSA form |
| CPrettyPrinter | |
| CProject | Project a named slot from a C++ struct or class |
| CReturn | Return from the enclosing function, passing the return value to the caller |
| CSApply | Apply a self-argument to a self-applicable function |
| CSCFG | An SCFG is a control-flow graph |
| CSExpr | Base class for AST nodes in the typed intermediate language |
| CSFunction | A self-applicable function |
| CSimpleArray | |
| CSimpleReducerBase | |
| CStdPrinter | |
| CStore | Store a value to memory |
| CTerminator | Base class for basic block terminators: Branch, Goto, and Return |
| CTraversal | |
| CUnaryOp | Simple arithmetic unary operations, e.g |
| CUndefined | Placeholder for expressions that cannot be represented in the TIL |
| CValueType | ValueTypes are data types that can actually be held in registers |
| CVariable | A named variable, e.g |
| CVisitReducer | |
| CVisitReducerBase | |
| CContainer | |
| CWildcard | Placeholder for a wildcard that matches any other expression |
| CBeforeSet | |
| CCapabilityExpr | |
| CCFGVisitor | |
| CCFGWalker | |
| CCopyOnWriteVector | |
| CSExprBuilder | |
| CCallingContext | Encapsulates the lexical context of a function call |
| CThreadSafetyHandler | Handler class for thread safety warnings |
| Ntooling | |
| Ndetail | |
| CTransformerImpl | Implementation details of Transformer with type erasure around RewriteRule<T> as well as the corresponding consumers |
| CWithMetadataImpl | Implementation when metadata is generated as a part of the rewrite |
| Ninternal | |
| CAreBaseOf | A type trait that returns true when the given type list contains types that derive from Base |
| CAreBaseOf< Base, T > | |
| CHasBaseOf | A type trait that returns true when the given type list has at least one type whose base is the given base type |
| CHasBaseOf< Base, T > | |
| Nstdlib | |
| CHeader | |
| CRecognizer | |
| CSymbol | |
| Ntraits | |
| Ninternal | |
| CHasHandle | |
| CIsValidOptionType | A type trait that returns true iff the given type is a type that can be stored in a refactoring option |
| CAllTUsToolExecutor | Executes given frontend actions on all files/TUs in the compilation database |
| CAllTUsToolExecutorPlugin | |
| CApplyChangesSpec | |
| CArgumentsAdjustingCompilations | |
| CASTMatchRefactorer | Adaptor between ast_matchers::MatchFinder and tooling::RefactoringTool |
| CASTSelectionRequirement | An AST selection requirement is satisfied when any portion of the AST overlaps with the selection range |
| CAtomicChange | An atomic change is used to create and group a set of source edits, e.g |
| CClangTool | Utility to run a FrontendAction over a set of files |
| CCodeRangeASTSelection | An AST selection value that corresponds to a selection of a set of statements that belong to one body of code (like one function) |
| CCodeRangeASTSelectionRequirement | A selection requirement that is satisfied when the selection range overlaps with a number of neighbouring statements in the AST |
| CCommonOptionsParser | A parser for options common to all command-line Clang tools |
| CCompilationDatabase | Interface for compilation databases |
| CCompilationDatabasePlugin | Interface for compilation database plugins |
| CCompileCommand | Specifies the working directory and command of a compilation |
| CDependencyScanningTool | The high-level implementation of the dependency discovery tool that runs on an individual worker thread |
| CDiagnostic | Represents the diagnostic with the level of severity and possible fixes to be applied |
| CDiagnosticMessage | Represents the diagnostic message with the error message associated and the information on the location of the problem |
| CExecutionContext | The context of an execution, including the information about compilation and results |
| CExtractFunction | An "Extract Function" refactoring moves code into a new function that's then called from the place where the original code was |
| CExtractionSemicolonPolicy | Determines which semicolons should be inserted during extraction |
| CFileByteRange | Represents a range within a specific source file |
| CFileMatchTrie | A trie to efficiently match against the entries of the compilation database in order of matching suffix length |
| CFileMatchTrieNode | A node of the FileMatchTrie |
| CFindSymbolOccurrencesRefactoringRule | A type of refactoring action rule that finds a set of symbol occurrences that reference a particular symbol |
| CFixedCompilationDatabase | A compilation database that returns a single compile command line |
| CFrontendActionFactory | Interface to generate clang::FrontendActions |
| CHeaderIncludes | Generates replacements for inserting or deleting #include directives in a file |
| CIncludeCategoryManager | This class manages priorities of C++ #include categories and calculates priorities for headers |
| CIncludeStyle | Style for sorting and grouping C++ #include directives |
| CIncludeCategory | See documentation of IncludeCategories |
| CInMemoryToolResults | Stores the key-value results in memory |
| CJSONCompilationDatabase | |
| CMatchFinder | A class to allow finding matches over the Clang AST |
| CMatchCallback | Called when the Match registered for it was successfully found in the AST |
| CMatchersByType | For each Matcher<> a MatchCallback that will be called when it matches |
| CMatchFinderOptions | |
| CProfiling | |
| CMatchResult | Contains all information for a given match |
| CParsingDoneTestCallback | Called when parsing is finished. Intended for testing only |
| CNamedDeclFindingConsumer | |
| COptionalRefactoringOption | A refactoring option that stores a value of type T |
| COptionRequirement | A requirement that evaluates to the value of the given OptionType when the OptionType is a required option |
| CP1689Rule | |
| CPathComparator | |
| CQualifiedRenameRule | |
| CQualifiedRenamingAction | Rename all symbols identified by the given USRs |
| CRange | A source range independent of the SourceManager |
| CRecursiveSymbolVisitor | Traverses the AST and visits the occurrence of each named symbol in the given nodes |
| CRefactoringAction | A refactoring action is a class that defines a set of related refactoring action rules |
| CRefactoringActionRule | A refactoring action rule is a wrapper class around a specific refactoring action rule (SourceChangeRefactoringRule, etc) that, in addition to invoking the action, describes the requirements that determine when the action can be initiated |
| CRefactoringActionRuleBase | A common refactoring action rule interface that defines the 'invoke' function that performs the refactoring operation (either fully or partially) |
| CRefactoringActionRuleRequirement | A refactoring action rule requirement determines when a refactoring action rule can be invoked |
| CRefactoringASTConsumer | |
| CRefactoringCallback | Base class for RefactoringCallbacks |
| CRefactoringDescriptor | |
| CRefactoringOption | A refactoring option is an interface that describes a value that has an impact on the outcome of a refactoring |
| CRefactoringOptionsRequirement | A base class for any requirement that requires some refactoring options |
| CRefactoringOptionVisitor | An interface that declares functions that handle different refactoring option types |
| CRefactoringResultConsumer | An abstract interface that consumes the various refactoring results that can be produced by refactoring actions |
| CRefactoringRuleContext | The refactoring rule context stores all of the inputs that might be needed by a refactoring action rule |
| CRefactoringTool | A tool to run refactorings |
| CRenameOccurrences | |
| CRenamingAction | |
| CRenamingASTConsumer | |
| CReplaceIfStmtWithItsBody | Replace an if-statement bound to Id with the outdented text of its body, choosing the consequent or the alternative based on whether PickTrueBranch is true |
| CReplacement | A text replacement |
| CReplacementError | Carries extra error information in replacement-related llvm::Error, e.g |
| CReplacements | Maintains a set of replacements that are conflict-free |
| CReplaceNodeWithTemplate | Replace the text of an AST node bound to FromId with the result of evaluating the template in ToTemplate |
| CReplaceStmtWithStmt | Replace the text of the statement bound to FromId with the text of the statement bound to ToId |
| CReplaceStmtWithText | Replace the text of the statement bound to FromId with the text in ToText |
| CRequiredRefactoringOption | A required refactoring option that stores a value of type T |
| CSelectedASTNode | Represents a selected AST node |
| CSourceChangeRefactoringRule | A type of refactoring action rule that produces source replacements in the form of atomic changes |
| CSourceFileCallbacks | Callbacks called before and after each source file processed by a FrontendAction created by the FrontedActionFactory returned by newFrontendActionFactory |
| CSourceRangeSelectionRequirement | A selection requirement that is satisfied when any portion of the source text is selected |
| CSourceSelectionRequirement | A base class for any requirement that expects some part of the source to be selected in an editor (or the refactoring tool with the -selection option) |
| CStandaloneToolExecutor | A standalone executor that runs FrontendActions on a given set of TUs in sequence |
| CStandaloneToolExecutorPlugin | |
| CSymbolName | A name of a symbol |
| CSymbolOccurrence | An occurrence of a symbol in the source |
| CToolAction | Interface to process a clang::CompilerInvocation |
| CToolExecutor | Interface for executing clang frontend actions |
| CToolExecutorPlugin | Interface for factories that create specific executors |
| CToolInvocation | Utility to run a FrontendAction in a single clang invocation |
| CToolResults | An abstraction for the result of a tool execution |
| CTransformer | Handles the matcher and callback registration for a single RewriteRule, as defined by the arguments of the constructor |
| CTransformerResult | |
| CTransformerResult< void > | |
| CTranslationUnitDiagnostics | Collection of Diagnostics generated from a single translation unit |
| CTranslationUnitReplacements | Collection of Replacements generated from a single translation unit |
| CUSRFindingAction | |
| CUSRSymbolRenamer | |
| Ntransformer | |
| CASTEdit | |
| CEdit | A concrete description of a source edit, represented by a character range in the source to be replaced and a corresponding replacement string |
| CMatchComputation | A failable computation over nodes bound by AST matchers, with (limited) reflection via the toString method |
| CRewriteRuleBase | Description of a source-code transformation |
| CCase | |
| CRewriteRuleWith | A source-code transformation with accompanying metadata |
| CAbstractConditionalOperator | AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOperator |
| CAccessSpecDecl | Represents an access specifier followed by colon ':' |
| CActionResult | The result of parsing/analyzing an expression, statement etc |
| CActionResult< PtrTy, true > | |
| CAddFlagValue | |
| CAdditionalKeywords | Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's lexer |
| CAddrLabelExpr | AddrLabelExpr - The GNU address of label extension, representing &&label |
| CAdjustedLocInfo | |
| CAdjustedType | Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons |
| CAdjustedTypeLoc | |
| CADLResult | A class for storing results from argument-dependent lookup |
| CAmbiguousConversionSequence | Represents an ambiguous user-defined conversion sequence |
| CAnalysisDeclContext | AnalysisDeclContext contains the context data for the function, method or block under analysis |
| CAnalysisDeclContextManager | |
| CAnalyzerOptions | Stores options for the analyzer from the command line |
| CAnyCall | An instance of this class corresponds to a call |
| CAPFloatStorage | |
| CAPINotesOptions | Tracks various options which control how API notes are found and handled |
| CAPIntStorage | |
| CAPNumericStorage | Used by IntegerLiteral/FloatingLiteral/EnumConstantDecl to store the numeric without leaking memory |
| CAPValue | APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat], [Complex APSInt] [Complex APFloat], [Expr + Offset], [Vector: N * APValue], [Array: N * APValue] |
| CConstexprUnknown | |
| CLV | |
| CLValueBase | |
| CLValuePathEntry | A non-discriminated union of a base, field, or array index |
| CLValuePathSerializationHelper | |
| CMemberPointerData | |
| CNoLValuePath | |
| CUninitArray | |
| CUninitStruct | |
| CArgumentConstructionContext | |
| CArrayInitIndexExpr | Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr |
| CArrayInitLoopExpr | Represents a loop initializing the elements of an array |
| CArrayLocInfo | |
| CArrayParameterType | Represents a constant array type that does not decay to a pointer when used as a function parameter |
| CArrayParameterTypeLoc | Wrapper for source info for array parameter types |
| CArrayRef | |
| CArraySectionExpr | This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differentiator |
| CArraySubscriptExpr | ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting |
| CArrayType | Represents an array type, per C99 6.7.5.2 - Array Declarators |
| CArrayTypeLoc | Wrapper for source info for arrays |
| CArrayTypeTraitExpr | An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent |
| CAsmStmt | AsmStmt is the base class for GCCAsmStmt and MSAsmStmt |
| CAssociatedConstraint | |
| CAssumedTemplateStorage | A structure for storing the information associated with a name that has been assumed to be a template name (despite finding no TemplateDecls) |
| CASTConstraintSatisfaction | The result of a constraint satisfaction check, containing the necessary information to diagnose an unsatisfied constraint |
| CASTConsumer | ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs |
| CASTContext | Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic analysis of a file |
| CBuiltinVectorTypeInfo | |
| CCUDAConstantEvalContext | |
| CCUDAConstantEvalContextRAII | |
| CCXXRecordDeclRelocationInfo | |
| CSectionInfo | |
| CASTDeclListAction | |
| CASTDeclMerger | |
| CASTDeclReader | |
| CASTDeclWriter | |
| CASTDeserializationListener | |
| CASTDumpAction | |
| CASTDumper | |
| CASTFileSignature | The signature of a module, which is a hash of the AST content |
| CASTFrontendAction | Abstract base class to use for AST consumer-based frontend actions |
| CASTIdentifierIterator | An identifier-lookup iterator that enumerates all of the identifiers stored within a set of AST files |
| CASTImporter | Imports selected nodes from one AST context into another context, merging AST nodes where appropriate |
| CFunctionDeclImportCycleDetector | |
| CImportPathTy | |
| CASTImporterLookupTable | |
| CASTImportError | |
| CASTImporterSharedState | Importer specific state, which may be shared amongst several ASTImporter objects |
| CASTMergeAction | Frontend action adaptor that merges ASTs together |
| CASTMutationListener | An abstract interface that should be implemented by listeners that want to be notified when an AST entity gets modified after its initial creation |
| CASTNameGenerator | |
| CImplementation | |
| CASTNodeImporter | |
| CASTNodeKind | Kind identifier |
| CDenseMapInfo | Hooks for using ASTNodeKind as a key in a DenseMap |
| CASTNodeTraverser | ASTNodeTraverser traverses the Clang AST for dumping purposes |
| CASTPrintAction | |
| CASTReader | Reads an AST files chain containing the contents of a translation unit |
| CListenerScope | RAII object to temporarily add an AST callback listener |
| CModuleDeclIterator | |
| CASTReaderListener | Abstract interface for callback invocations by the ASTReader |
| CASTRecordLayout | ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/class |
| CVBaseInfo | |
| CASTRecordReader | An object for streaming information from a record |
| CASTRecordWriter | An object for streaming information to a record |
| CASTSourceDescriptor | Abstracts clang modules and precompiled header files and holds everything needed to generate debug info for an imported module or PCH |
| CASTStmtReader | |
| CASTStmtWriter | |
| CASTTemplateArgumentListInfo | Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>" |
| CASTTemplateKWAndArgsInfo | Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>" |
| CASTUnit | Utility class for loading a ASTContext from an AST file |
| CCachedCodeCompletionResult | A cached code-completion result, which may be introduced in one of many different contexts |
| CConcurrencyCheck | |
| CASTUnresolvedSet | An UnresolvedSet-like class which uses the ASTContext's allocator |
| CASTVector | |
| CASTViewAction | |
| CASTWriter | Writes an AST file containing the contents of a translation unit |
| CAsTypeExpr | AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support for reinterpreting a type to another type of the same size |
| CAtomicConstraint | |
| CAtomicExpr | AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>, and corresponding __opencl_atomic_* for OpenCL 2.0 |
| CAtomicOptions | |
| CAtomicScopeGenericModel | Defines the generic atomic scope model |
| CAtomicScopeHIPModel | Defines the sync scope model for HIP |
| CAtomicScopeModel | Defines the interface for sync scope model |
| CAtomicScopeOpenCLModel | Defines the sync scope model for OpenCL |
| CAtomicType | |
| CAtomicTypeLoc | |
| CAtomicTypeLocInfo | |
| CAttr | Attr - This represents one attribute |
| CAttributeCommonInfo | |
| CForm | Combines information about the source-code form of an attribute, including its syntax and spelling |
| CAttributedLocInfo | |
| CAttributedStmt | Represents an attribute applied to a statement |
| CAttributedTypeLoc | Type source information for an attributed type |
| CAttributeFactory | A factory, from which one makes pools, from which one creates individual attributes which are deallocated with the pool |
| CAttributePool | |
| CAttributeScopeInfo | |
| CAttrVisitor | A simple visitor class that helps create attribute visitors |
| CAutoTypeLoc | |
| CAutoTypeLocInfo | |
| CAvailabilityChange | Represents information about a change in availability for an entity, which is part of the encoding of the 'availability' attribute |
| CAvailabilityInfo | Storage of availability attributes for a declaration |
| CAvailabilitySpec | One specifier in an @available expression |
| CBackendConsumer | |
| CBackwardDataflowWorklist | A worklist implementation for backward dataflow analysis |
| CBadConversionSequence | BadConversionSequence - Records information about an invalid conversion sequence |
| CBalancedDelimiterTracker | RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ... } or parentheses ( ... ) |
| CBaseSubobject | |
| CBaseUsingDecl | Represents a C++ declaration that introduces decls from somewhere else |
| Cshadow_iterator | Iterates through the using shadow declarations associated with this using declaration |
| CBeforeThanCompare | Comparison function object |
| CBeforeThanCompare< SourceLocation > | Compare two source locations |
| CBeforeThanCompare< SourceRange > | Compare two non-overlapping source ranges |
| CBinaryConditionalOperator | BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle operand to be omitted |
| CBinaryOperator | A builtin binary operation expression such as "x + y" or "x <= y" |
| CBindingDecl | A binding in a decomposition declaration |
| CBitIntType | A fixed int type of a specified bitwidth |
| CBitIntTypeLoc | |
| CBitsPacker | A simple helper class to pack several bits in order into (a) 32 bit integer(s) |
| CBitsUnpacker | A simple helper class to unpack an integer to bits and consuming the bits in order |
| CBlockDecl | Represents a block literal declaration, which is like an unnamed FunctionDecl |
| CCapture | A class which contains all the information about a particular captured value |
| CBlockEdge | |
| CBlockEntrance | |
| CBlockExit | |
| CBlockExpr | BlockExpr - Adaptor class for mixing a BlockDecl with expressions |
| CBlockInvocationContext | It represents a block invocation (based on BlockCall) |
| CBlockPointerType | Pointer to a block type |
| CBlockPointerTypeLoc | Wrapper for source info for block pointers |
| CBlockVarCopyInit | Copy initialization expr of a __block variable and a boolean flag that indicates whether the expression can throw |
| CBodyFarm | |
| CBoundsAttributedLocInfo | |
| CBoundsAttributedType | [BoundsSafety] Represents a parent type class for CountAttributedType and similar sugar types that will be introduced to represent a type with a bounds attribute |
| CBoundsAttributedTypeLoc | |
| CBreakStmt | BreakStmt - This represents a break |
| CBTFTagAttributedLocInfo | |
| CBTFTagAttributedTypeLoc | Type source information for an btf_tag attributed type |
| CBuildPreambleErrorCategory | |
| CBuildResult | |
| CBuiltinBitCastExpr | Represents a C++2a __builtin_bit_cast(T, v) expression |
| CBuiltinLocInfo | |
| CBuiltinTemplateDecl | Represents the builtin template declaration which is used to implement __make_integer_seq and other builtin templates |
| CBuiltinType | This class is used for builtin types like 'int' |
| CBuiltinTypeLoc | Wrapper for source info for builtin types |
| CBumpVector | |
| CBumpVectorContext | |
| CCalledOnceCheckHandler | |
| CCallEnter | Represents a point when we begin processing an inlined call |
| CCallExitBegin | Represents a point when we start the call exit sequence (for inlined call) |
| CCallExitEnd | Represents a point when we finish the call exit sequence (for inlined call) |
| CCallExpr | CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]) |
| CCallGraph | The AST-based call graph |
| CCallGraphNode | |
| CCallRecord | |
| CCanonicalDeclPtr | A wrapper class around a pointer that always points to its canonical declaration |
| CCanProxy | Canonical proxy type returned when retrieving the members of a canonical type or as the result of the CanQual<T>::getAs member function |
| CCanProxyAdaptor | Replaceable canonical proxy adaptor class that provides the link between a canonical type and the accessors of the type |
| CCanProxyAdaptor< BlockPointerType > | |
| CCanProxyAdaptor< ComplexType > | |
| CCanProxyAdaptor< DecltypeType > | |
| CCanProxyAdaptor< DependentSizedExtVectorType > | |
| CCanProxyAdaptor< EnumType > | |
| CCanProxyAdaptor< ExtVectorType > | |
| CCanProxyAdaptor< FunctionNoProtoType > | |
| CCanProxyAdaptor< FunctionProtoType > | |
| CCanProxyAdaptor< FunctionType > | |
| CCanProxyAdaptor< LValueReferenceType > | |
| CCanProxyAdaptor< MemberPointerType > | |
| CCanProxyAdaptor< ObjCObjectPointerType > | |
| CCanProxyAdaptor< ObjCObjectType > | |
| CCanProxyAdaptor< PointerType > | |
| CCanProxyAdaptor< RecordType > | |
| CCanProxyAdaptor< ReferenceType > | |
| CCanProxyAdaptor< RValueReferenceType > | |
| CCanProxyAdaptor< TagType > | |
| CCanProxyAdaptor< TemplateTypeParmType > | |
| CCanProxyAdaptor< TypeOfType > | |
| CCanProxyAdaptor< UnaryTransformType > | |
| CCanProxyAdaptor< VectorType > | |
| CCanProxyBase | Base class of all canonical proxy types, which is responsible for storing the underlying canonical type and providing basic conversions |
| CCanQual | Represents a canonical, potentially-qualified type |
| CCanTypeIterator | Iterator adaptor that turns an iterator over canonical QualTypes into an iterator over CanQualTypes |
| CCapturedDecl | Represents the body of a CapturedStmt, and serves as its DeclContext |
| CCaptureDroppedDiagnostics | RAII object that optionally captures and filters diagnostics, if there is no diagnostic client to capture them already |
| CCapturedStmt | This captures a statement into a function |
| CCapture | Describes the capture of either a variable, or 'this', or variable-length array type |
| CCaseStmt | CaseStmt - Represent a case statement |
| Ccast_convert_decl_context | |
| Ccast_convert_decl_context< ToTy, true > | |
| CCastExpr | CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit casts that have some representation in the source code (ExplicitCastExpr's derived classes) |
| CCFG | Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt |
| CBuildOptions | |
| CCFGAutomaticObjDtor | Represents C++ object destructor implicitly generated for automatic object or temporary bound to const reference at the point of leaving its local scope |
| CCFGBaseDtor | Represents C++ object destructor implicitly generated for base object in destructor |
| CCFGBlock | Represents a single basic block in a source-level CFG |
| CAdjacentBlock | This class represents a potential adjacent block in the CFG |
| CFilteredCFGBlockIterator | |
| CFilterOptions | |
| CCFGCallback | CFGCallback defines methods that should be called when a logical operator error is found when building the CFG |
| CCFGCleanupFunction | |
| CCFGConstructor | Represents C++ constructor call |
| CCFGCXXRecordTypedCall | Represents a function call that returns a C++ object by value |
| CCFGDeleteDtor | Represents C++ object destructor generated from a call to delete |
| CCFGDominatorTreeImpl | Dominator tree builder for Clang's CFG based on llvm::DominatorTreeBase |
| CCFGElement | Represents a top-level expression in a basic block |
| CCFGImplicitDtor | Represents C++ object destructor implicitly generated by compiler on various occasions |
| CCFGInitializer | Represents C++ base or member initializer from constructor's initialization list |
| CCFGLifetimeEnds | Represents the point where the lifetime of an automatic object ends |
| CCFGLoopExit | Represents the point where a loop ends |
| CCFGMemberDtor | Represents C++ object destructor implicitly generated for member object in destructor |
| CCFGNewAllocator | Represents C++ allocator call |
| CCFGReverseBlockReachabilityAnalysis | |
| CCFGScopeBegin | Represents beginning of a scope implicitly generated by the compiler on encountering a CompoundStmt |
| CCFGScopeEnd | Represents end of a scope implicitly generated by the compiler after the last Stmt in a CompoundStmt's body |
| CCFGStmt | |
| CCFGStmtMap | |
| CCFGTemporaryDtor | Represents C++ object destructor implicitly generated at the end of full expression for temporary object |
| CCFGTerminator | Represents CFGBlock terminator statement |
| CChainedASTReaderListener | Simple wrapper class for chaining listeners |
| CChainedDiagnosticConsumer | ChainedDiagnosticConsumer - Chain two diagnostic clients so that diagnostics go to the first client and then the second |
| CCharacterLiteral | |
| CCharLiteralParser | CharLiteralParser - Perform interpretation and semantic analysis of a character literal |
| CCharSourceRange | Represents a character-granular source range |
| CCharUnits | CharUnits - This is an opaque type for sizes expressed in character units |
| CChildErrorHandlingStrategy | How to handle import errors that occur when import of a child declaration of a DeclContext fails |
| CChooseExpr | ChooseExpr - GNU builtin-in function __builtin_choose_expr |
| CClangDiagnosticHandler | |
| CClassTemplateDecl | Declaration of a class template |
| CCommon | Data that is common to all of the declarations of a given class template |
| CClassTemplatePartialSpecializationDecl | |
| CClassTemplateSpecializationDecl | Represents a class template specialization, which refers to a class template with a given set of template arguments |
| CCleanupInfo | |
| CCloneConstraint | This class is a utility class that contains utility functions for building custom constraints |
| CCloneDetector | Searches for similar subtrees in the AST |
| CCoawaitExpr | Represents a 'co_await' expression |
| CCodeCompleteConsumer | Abstract interface for a consumer of code-completion information |
| COverloadCandidate | |
| CCodeCompleteOptions | Options controlling the behavior of code completion |
| CCodeCompletionAllocator | An allocator used specifically for the purpose of code completion |
| CCodeCompletionBuilder | A builder class used to construct new code-completion strings |
| CCodeCompletionContext | The context in which code completion occurred, so that the code-completion consumer can process the results accordingly |
| CCodeCompletionHandler | Callback handler that receives notifications when performing code completion within the preprocessor |
| CCodeCompletionResult | Captures a result of code completion |
| CCodeCompletionString | A "string" used to describe how code completion can be performed for an entity |
| CChunk | One piece of the code completion string |
| CCodeCompletionTUInfo | |
| CCodeGenAction | |
| CCodeGenerator | The primary public interface to the Clang code generator |
| CCodeGenOptions | CodeGenOptions - Track various options which control how the code is optimized and passed to the backend |
| CBitcodeFileToLink | |
| COptRemark | Optimization remark with an optional regular expression pattern |
| CCodeGenOptionsBase | Bitfields of CodeGenOptions, split out from CodeGenOptions to ensure that this large collection of bitfields is a trivial class type |
| CCodeInjector | CodeInjector is an interface which is responsible for injecting AST of function definitions that may not be available in the original source |
| CColonProtectionRAIIObject | ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed |
| CColorScope | |
| CCommaSeparatedList | |
| CCommentHandler | Abstract base class that describes a handler that will receive source ranges for each of the comments encountered in the source file |
| CCommentOptions | Options for controlling comment parsing |
| CComparisonCategories | |
| CComparisonCategoryInfo | |
| CValueInfo | |
| CCompilerInstance | CompilerInstance - Helper class for managing a single instance of the Clang compiler |
| CThreadSafeCloneConfig | Configuration object for making the result of cloneForModuleCompile() thread-safe |
| CCompilerInvocation | Helper class for holding the data necessary to invoke the compiler |
| CCompilerInvocationBase | The base class of CompilerInvocation |
| CEmptyConstructor | Dummy tag type whose instance can be passed into the constructor to prevent creation of the reference-counted option objects |
| CCompletionContextHandler | The class CompletionContextHandler contains four interfaces, each of which handles one type of completion result |
| CComplexType | Complex values, per C99 6.2.5p11 |
| CComplexTypeLoc | |
| CCompoundAssignOperator | CompoundAssignOperator - For compound assignments (e.g |
| CCompoundConstraint | |
| CCompoundLiteralExpr | CompoundLiteralExpr - [C99 6.5.2.5] |
| CCompoundStmt | CompoundStmt - This represents a group of statements like { stmt stmt } |
| CCompressedOffloadBundle | |
| CCompressedBundleHeader | |
| CConceptDecl | Declaration of a C++20 concept |
| CConceptIdConstraint | |
| CConceptReference | A reference to a concept and its template args, as it appears in the code |
| CConceptSpecializationExpr | Represents the specialization of a concept - evaluates to a prvalue of type bool |
| CConcreteTypeLoc | A metaprogramming base class for TypeLoc classes which correspond to a particular Type subclass |
| CHasNoInnerType | |
| CConditionalOperator | ConditionalOperator - The ? |
| CConstantArrayType | Represents the canonical version of C arrays with a specified constant size |
| CConstantArrayTypeLoc | |
| CConstantExpr | ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluating the expression |
| CConstantMatrixType | Represents a concrete matrix type with constant number of rows and columns |
| CConstantMatrixTypeLoc | |
| CConstAttrVisitor | A simple visitor class that helps create attribute visitors |
| CConstDeclVisitor | A simple visitor class that helps create declaration visitors |
| CConstEvaluatedExprVisitor | ConstEvaluatedExprVisitor - This class visits 'const Expr *'s |
| CConstraintSatisfaction | The result of a constraint satisfaction check, containing the necessary information to diagnose an unsatisfied constraint |
| CConstructionContext | ConstructionContext's subclasses describe different ways of constructing an object in C++ |
| CConstructionContextItem | Represents a single point (AST node) in the program that requires attention during construction of an object |
| CConstructionContextLayer | Construction context can be seen as a linked list of multiple layers |
| CConstructorInfo | |
| CConstructorInitializerConstructionContext | |
| CConstructorUsingShadowDecl | Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that names a constructor |
| CConstStmtIterator | |
| CConstStmtVisitor | ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses |
| CConstTemplateArgumentVisitor | A simple visitor class that helps create template argument visitors |
| CContinueStmt | ContinueStmt - This represents a continue |
| CContinuousRangeMap | A map from continuous integer ranges to some value, with a very specialized interface |
| CBuilder | An object that helps properly build a continuous range map from a set of values |
| CControlDependencyCalculator | |
| CConversionFixItGenerator | The class facilities generation and storage of conversion FixIts |
| CConvertVectorExpr | ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for converting a vector type to another vector type of the same arity |
| CCopiedTypeVisitor | |
| CCoreturnStmt | Represents a 'co_return' statement in the C++ Coroutines TS |
| CCoroutineBodyStmt | Represents the body of a coroutine |
| CCtorArgs | |
| CCoroutineStmtBuilder | |
| CCoroutineSuspendExpr | Represents an expression that might suspend coroutine execution; either a co_await or co_yield expression |
| CCorrectionCandidateCallback | Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo correction |
| CCountAttributedType | Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variants |
| CCountAttributedTypeLoc | |
| CCoverageSourceInfo | Stores additional source code information like skipped ranges which is required by the coverage mapping generator and is obtained from the preprocessor |
| CCowCompilerInvocation | Same as CompilerInvocation, but with copy-on-write optimization |
| CCoyieldExpr | Represents a 'co_yield' expression |
| CCreateInvocationOptions | Optional inputs to createInvocation |
| CCStyleCastExpr | CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr |
| CCUDAKernelCallExpr | Represents a call to a CUDA kernel function |
| CCudaVersionMapEntry | |
| CCurrentSourceLocExprScope | Represents the current source location and context used to determine the value of the source location builtins (ex |
| CSourceLocExprScopeGuard | |
| CCustomizableOptional | |
| CCXX17ElidedCopyConstructorInitializerConstructionContext | Represents construction into a field or a base class within a bigger object via a constructor initializer, with a single constructor, eg |
| CCXX17ElidedCopyReturnedValueConstructionContext | Represents a temporary object that is being immediately returned from a function by value, eg |
| CCXX17ElidedCopyVariableConstructionContext | Represents construction into a simple variable with an initializer syntax, with a single constructor, eg |
| CCXX20ModulesGenerator | |
| CCXXABI | Implements C++ ABI-specific semantic analysis functions |
| CMemberPointerInfo | |
| CCXXAddrspaceCastExpr | A C++ addrspace_cast expression (currently only enabled for OpenCL) |
| CCXXBasePath | Represents a path from a specific derived class (which is not represented as part of the path) to a particular (direct or indirect) base class subobject |
| CCXXBasePathElement | Represents an element in a path from a derived class to a base class |
| CCXXBasePaths | BasePaths - Represents the set of paths from a derived class to one of its (direct or indirect) bases |
| CCXXBaseSpecifier | Represents a base class of a C++ class |
| CCXXBindTemporaryExpr | Represents binding an expression to a temporary |
| CCXXBoolLiteralExpr | A boolean literal, per ([C++ lex.bool] Boolean literals) |
| CCXXCatchStmt | CXXCatchStmt - This represents a C++ catch block |
| CCXXConstCastExpr | A C++ const_cast expression (C++ [expr.const.cast]) |
| CCXXConstructExpr | Represents a call to a C++ constructor |
| CCXXConstructorDecl | Represents a C++ constructor within a class |
| CCXXConversionDecl | Represents a C++ conversion function within a class |
| CCXXCtorInitializer | Represents a C++ base or member initializer |
| CCXXDeductionGuideDecl | Represents a C++ deduction guide declaration |
| CCXXDefaultArgExpr | A default argument (C++ [dcl.fct.default]) |
| CCXXDefaultInitExpr | A use of a default initializer in a constructor or in aggregate initialization |
| CCXXDeleteExpr | Represents a delete expression for memory deallocation and destructor calls, e.g |
| CCXXDependentScopeMemberExpr | Represents a C++ member access expression where the actual member referenced could not be resolved because the base expression or the member name was dependent |
| CCXXDestructorDecl | Represents a C++ destructor within a class |
| CCXXDynamicCastExpr | A C++ dynamic_cast expression (C++ [expr.dynamic.cast]) |
| CCXXFieldCollector | CXXFieldCollector - Used to keep track of CXXFieldDecls during parsing of C++ classes |
| CCXXFinalOverriderMap | A mapping from each virtual member function to its set of final overriders |
| CCXXFoldExpr | Represents a folding of a pack over an operator |
| CCXXForRangeStmt | CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (range-declarator : range-expression)' or 'for (init-statement range-declarator : range-expression)' |
| CCXXFunctionalCastExpr | Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]) |
| CCXXIndirectPrimaryBaseSet | A set of all the primary bases for a class |
| CCXXInheritedCtorInitExpr | Represents a call to an inherited base class constructor from an inheriting constructor |
| CCXXMemberCallExpr | Represents a call to a member function that may be written either with member call syntax (e.g., "obj.func()" or "objptr->func()") or with normal function-call syntax ("func()") within a member function that ends up calling a member function |
| CCXXMethodDecl | Represents a static or instance method of a struct/union/class |
| CCXXNamedCastExpr | Abstract class common to all of the C++ "named"/"keyword" casts |
| CCXXNewExpr | Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)" |
| CCXXNoexceptExpr | Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]) |
| CCXXNullPtrLiteralExpr | The null pointer literal (C++11 [lex.nullptr]) |
| CCXXOperatorCallExpr | A call to an overloaded operator written using operator syntax |
| CCXXParenListInitExpr | Represents a list-initialization with parenthesis |
| CCXXPseudoDestructorExpr | Represents a C++ pseudo-destructor (C++ [expr.pseudo]) |
| CCXXRecordDecl | Represents a C++ struct/union/class |
| Cfriend_iterator | An iterator over the friend declarations of a class |
| CLambdaNumbering | Information about how a lambda is numbered within its context |
| CCXXReinterpretCastExpr | A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]) |
| CCXXRewrittenBinaryOperator | A rewritten comparison expression that was originally written using operator syntax |
| CDecomposedForm | |
| CCXXScalarValueInitExpr | An expression "T()" which creates an rvalue of a non-class type T |
| CCXXScopeSpec | Represents a C++ nested-name-specifier or a global scope specifier |
| CCXXStandardLibraryVersionInfo | |
| CCXXStaticCastExpr | A C++ static_cast expression (C++ [expr.static.cast]) |
| CCXXStdInitializerListExpr | Implicit construction of a std::initializer_list<T> object from an array temporary within list-initialization (C++11 [dcl.init.list]p5) |
| CCXXTemporary | Represents a C++ temporary |
| CCXXTemporaryObjectExpr | Represents a C++ functional cast expression that builds a temporary object |
| CCXXThisExpr | Represents the this expression in C++ |
| CCXXThrowExpr | A C++ throw-expression (C++ [except.throw]) |
| CCXXTryStmt | CXXTryStmt - A C++ try block, including all handlers |
| CCXXTypeidExpr | A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplied type, or the (possibly dynamic) type of the supplied expression |
| CCXXUnresolvedConstructExpr | Describes an explicit type conversion that uses functional notion but could not be resolved because one or more arguments are type-dependent |
| CCXXUuidofExpr | A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or expression |
| CDarwinSDKInfo | The information about the darwin SDK that was used during this compilation |
| COSEnvPair | A value that describes two os-environment pairs that can be used as a key to the version map in the SDK |
| CRelatedTargetVersionMapping | Represents a version mapping that maps from a version of one target to a version of a related target |
| CSDKPlatformInfo | Information about the supported platforms, derived from the target triple definitions, in the SDK |
| CDataflowValues | DataflowValues. Container class to store dataflow values for a CFG |
| CDataflowWorklistBase | A worklist implementation where the enqueued blocks will be dequeued based on the order defined by 'Comp' |
| CDecayedType | Represents a pointer type decayed from an array or function type |
| CDecayedTypeLoc | Wrapper for source info for pointers decayed from arrays and functions |
| CDecl | Decl - This represents one declaration (or definition), e.g |
| CEmptyShell | A placeholder type used to construct an empty shell of a decl-derived type that will be filled in later (e.g., by some deserialization method) |
| Credecl_iterator | Iterates through all the redeclarations of the same decl |
| CDeclAccessPair | A POD class for pairing a NamedDecl* with an access specifier |
| CDeclarationName | The name of a declaration |
| CDeclarationNameInfo | DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the corresponding source/type location info |
| CDeclarationNameLoc | DeclarationNameLoc - Additional source/type location info for a declaration name |
| CDeclarationNameTable | DeclarationNameTable is used to store and retrieve DeclarationName instances for the various kinds of declaration names, e.g., normal identifiers, C++ constructor names, etc |
| CDeclarator | Information about one declarator, including the parsed type information and the identifier |
| CDeclaratorChunk | One instance of this struct is used for each type in a declarator that is parsed |
| CArrayTypeInfo | |
| CBlockPointerTypeInfo | |
| CFunctionTypeInfo | |
| CMemberPointerTypeInfo | |
| CParamInfo | ParamInfo - An array of paraminfo objects is allocated whenever a function declarator is parsed |
| CPipeTypeInfo | |
| CPointerTypeInfo | |
| CReferenceTypeInfo | |
| CTypeAndRange | |
| CDeclaratorDecl | Represents a ValueDecl that came out of a declarator |
| CDeclBindingInfo | |
| CDeclContext | DeclContext - This is used only as base class of specific decl types that can act as declaration contexts |
| Call_lookups_iterator | All_lookups_iterator - An iterator that provides a view over the results of looking up every possible name |
| CBlockDeclBitfields | Stores the bits used by BlockDecl |
| CCXXConstructorDeclBitfields | Stores the bits used by CXXConstructorDecl |
| Cddiag_iterator | An iterator over the dependent diagnostics in a dependent context |
| Cdecl_iterator | Decl_iterator - Iterates through the declarations stored within this context |
| CDeclContextBitfields | Stores the bits used by DeclContext |
| CEnumDeclBitfields | Stores the bits used by EnumDecl |
| Cfiltered_decl_iterator | Iterates over a filtered subrange of declarations stored in a DeclContext |
| CFunctionDeclBitfields | Stores the bits used by FunctionDecl |
| CLinkageSpecDeclBitfields | Stores the bits used by LinkageSpecDecl |
| CNamespaceDeclBitfields | Stores the bits used by NamespaceDecl |
| CObjCContainerDeclBitfields | Stores the bits used by ObjCContainerDecl |
| CObjCMethodDeclBitfields | Stores the bits used by ObjCMethodDecl |
| COMPDeclareReductionDeclBitfields | Stores the bits used by OMPDeclareReductionDecl |
| CRecordDeclBitfields | Stores the bits used by RecordDecl |
| Cspecific_decl_iterator | Specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it) |
| CTagDeclBitfields | Stores the bits used by TagDecl |
| Cudir_iterator | |
| CDeclContextLookupResult | The results of name lookup within a DeclContext |
| CDeclFilterCCC | Simple template class for restricting typo correction candidates to ones having a single Decl* of the given type |
| CDeclGroup | |
| CDeclGroupRef | |
| CDeclIDBase | GlobalDeclID means DeclID in the current ASTContext and LocalDeclID means DeclID specific to a certain ModuleFile |
| CDeclIDIterator | A helper iterator adaptor to convert the iterators to SmallVector<SomeDeclID> to the iterators to SmallVector<OtherDeclID> |
| CDeclListNode | A list storing NamedDecls in the lookup tables |
| Citerator | |
| CDeclOrStmtAttr | |
| CDeclRefExpr | A reference to a declared variable, function, enum, etc |
| CDeclSpec | Captures information about "declaration specifiers" |
| CDeclStmt | DeclStmt - Adaptor class for mixing declarations with statements and expressions |
| CDecltypeTypeLoc | |
| CDecltypeTypeLocInfo | |
| CDeclVisitor | A simple visitor class that helps create declaration visitors |
| CDecompositionDecl | A decomposition declaration |
| CDecompositionDeclarator | A parsed C++17 decomposition declarator of the form '[' identifier-list ']' |
| CBinding | |
| CDeducedPack | A pack that we're currently deducing |
| CDeducedTemplateArgument | Captures a template argument whose value has been deduced via c++ template argument deduction |
| CDeducedTemplateSpecializationLocInfo | |
| CDeducedTemplateSpecializationTypeLoc | |
| CDeducedTemplateStorage | |
| CDeducedTypeLoc | |
| CDeductionFailureInfo | A structure used to record information about a failed template argument deduction, for diagnosis |
| CDefaultArgStorage | Storage for a default argument |
| CDefaultArguments | |
| CDefaultFilterCCC | |
| CDefaultInitializedTypeVisitor | |
| CDefaultStmt | |
| CDeferredConversionTemplateOverloadCandidate | |
| CDeferredFunctionTemplateOverloadCandidate | |
| CDeferredMethodTemplateOverloadCandidate | |
| CDeferredTemplateOverloadCandidate | |
| CDeferStmt | DeferStmt - This represents a deferred statement |
| CDefMacroDirective | A directive for a defined macro or a macro imported from a module |
| CDelegatingDeserializationListener | |
| CDependence | |
| CDependencyCollector | An interface for collecting the dependencies of a compilation |
| CDependencyDirectivesGetter | Functor that returns the dependency directives for a given file |
| CDependencyFileGenerator | Builds a dependency file when attached to a Preprocessor (for includes) and ASTReader (for module imports), and writes it out at the end of processing a source file |
| CDependencyOutputOptions | DependencyOutputOptions - Options for controlling the compiler dependency file generation |
| CDependentAddressSpaceLocInfo | |
| CDependentAddressSpaceType | Represents an extended address space qualifier where the input address space value is dependent |
| CDependentAddressSpaceTypeLoc | |
| CDependentBitIntType | |
| CDependentBitIntTypeLoc | |
| CDependentCoawaitExpr | Represents a 'co_await' expression while the type of the promise is dependent |
| CDependentDiagnostic | A dependently-generated diagnostic |
| CDependentFunctionTemplateSpecializationInfo | Provides information about a dependent function-template specialization declaration |
| CDependentNameLocInfo | |
| CDependentNameTypeLoc | |
| CDependentScopeDeclRefExpr | A qualified reference to a name whose declaration cannot yet be resolved |
| CDependentSizedArrayType | Represents an array type in C++ whose size is a value-dependent expression |
| CDependentSizedArrayTypeLoc | |
| CDependentSizedExtVectorType | Represents an extended vector type where either the type or size is dependent |
| CDependentSizedExtVectorTypeLoc | |
| CDependentSizedMatrixType | Represents a matrix type where the type and the number of rows and columns is dependent on a template |
| CDependentSizedMatrixTypeLoc | |
| CDependentStoredDeclsMap | |
| CDependentTemplateName | |
| CDependentTemplateStorage | Represents a dependent template name that cannot be resolved prior to template instantiation |
| CDependentTypeOfExprType | Internal representation of canonical, dependent typeof(expr) types |
| CDependentVectorType | Represents a vector type where either the type or size is dependent |
| CDependentVectorTypeLoc | |
| CDesignatedInitExpr | Represents a C99 designated initializer expression |
| CDesignator | Represents a single C99 designator |
| CDesignatedInitUpdateExpr | |
| CDesignation | Designation - Represent a full designation, which is a sequence of designators |
| CDesignator | Designator - A designator in a C99 designated initializer |
| CDestructedTypeVisitor | |
| CDiagnostic | A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine and DiagnosticStorage) that allows clients to enquire about the diagnostic |
| CDiagnosticBuilder | A little helper class used to produce diagnostics |
| CDiagnosticConsumer | Abstract interface, implemented by clients of the front-end, which formats and prints fully processed diagnostics |
| CDiagnosticError | Carries a Clang diagnostic in an llvm::Error |
| CDiagnosticErrorTrap | RAII class that determines when any errors have occurred between the time the instance was created and the time it was queried |
| CDiagnosticIDs | Used for handling and querying diagnostic IDs |
| CCustomDiagDesc | |
| CGroupInfo | |
| CDiagnosticMapping | |
| CDiagnosticNoteRenderer | Subclass of DiagnosticRender that turns all subdiagostics into explicit notes |
| CDiagnosticOptions | Options for controlling the compiler diagnostics engine |
| CDiagnosticRenderer | Class to encapsulate the logic for formatting a diagnostic message |
| CDiagnosticsEngine | Concrete class used by the front-end to report problems and issues |
| CDiagnosticStorage | |
| CDiagStorageAllocator | An allocator for DiagnosticStorage objects, which uses a small cache to objects, used to reduce malloc()/free() traffic for partial diagnostics |
| CDirectoryEntry | Cached information about one directory (either on disk or in the virtual file system) |
| CDirectoryEntryRef | A reference to a DirectoryEntry that includes the name of the directory as it was accessed by the FileManager's client |
| CDirectoryLookup | DirectoryLookup - This class represents one entry in the search list that specifies the search order for directories in #include directives |
| CDirectoryWatcher | Provides notifications for file changes in a directory |
| CEvent | |
| CDoStmt | DoStmt - This represents a 'do/while' stmt |
| CDotMemberAccessHandler | |
| CDumpCompilerOptionsAction | |
| CDumpModuleInfoAction | Dump information about the given module file, to be used for basic debugging and discovery |
| CDumpRawTokensAction | |
| CDumpTokensAction | |
| CDynamicAllocLValue | Symbolic representation of a dynamic allocation |
| CDynamicRecursiveASTVisitorBase | Recursive AST visitor that supports extension via dynamic dispatch |
| CDynTypedNode | A dynamically typed AST node container |
| CBaseConverter< ConceptReference, void > | |
| CBaseConverter< CXXBaseSpecifier, void > | |
| CBaseConverter< CXXCtorInitializer, void > | |
| CBaseConverter< LambdaCapture, void > | |
| CBaseConverter< NestedNameSpecifier, void > | |
| CBaseConverter< NestedNameSpecifierLoc, void > | |
| CBaseConverter< ObjCProtocolLoc, void > | |
| CBaseConverter< QualType, void > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< Attr, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< Decl, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< OMPClause, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< Stmt, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< Type, T >::value > > | |
| CBaseConverter< T, std::enable_if_t< std::is_base_of< TypeLoc, T >::value > > | |
| CBaseConverter< TemplateArgument, void > | |
| CBaseConverter< TemplateArgumentLoc, void > | |
| CBaseConverter< TemplateName, void > | |
| CDenseMapInfo | Hooks for using DynTypedNode as a key in a DenseMap |
| CDynTypedNodeList | Container for either a single DynTypedNode or for an ArrayRef to DynTypedNode |
| CEffectConditionExpr | Wrap a function effect's condition expression in another struct so that FunctionProtoType's TrailingObjects can treat it separately |
| CElaboratedLocInfo | |
| CElaboratedNameLocInfo | |
| CElaboratedNameTypeLoc | |
| CElidedTemporaryObjectConstructionContext | Represents a temporary object that is constructed for the sole purpose of being immediately copied by an elidable copy/move constructor |
| CEmbedAnnotationData | Helper class to shuttle information about #embed directives from the preprocessor to the parser through an annotation token |
| CEmbedDataStorage | Stores data related to a single #embed directive |
| CEmbedExpr | Represents a reference to #emded data |
| CChildElementIter | |
| CEmitAssemblyAction | |
| CEmitBCAction | |
| CEmitCodeGenOnlyAction | |
| CEmitLLVMAction | |
| CEmitLLVMOnlyAction | |
| CEmitObjAction | |
| CEmptyDecl | Represents an empty-declaration |
| CEmptylineHandler | Abstract base class that describes a handler that will receive source ranges for empty lines encountered in the source file |
| CEmptyPragmaHandler | EmptyPragmaHandler - A pragma handler which takes no action, which can be used to ignore particular pragmas |
| CEnsureFunctionAnalysis | |
| CEnsureFunctionVisitor | |
| CEnterExpressionEvaluationContext | RAII object that enters a new expression evaluation context |
| CEnterExpressionEvaluationContextForFunction | RAII object that enters a new function expression evaluation context |
| CEnumConstantDecl | An instance of this object exists for each enum constant that is defined |
| CEnumDecl | Represents an enum |
| CEnumTypeLoc | Wrapper for source info for enum types |
| CEpsilonPoint | This is a meta program point, which should be skipped by all the diagnostic reasoning etc |
| CEvaluatedExprVisitor | EvaluatedExprVisitor - This class visits 'Expr *'s |
| CEvaluatedExprVisitorBase | Given a potentially-evaluated expression, this visitor visits all of its potentially-evaluated subexpressions, recursively |
| CEvaluatedStmt | Structure used to store a statement, the constant value to which it was evaluated (if any), and whether or not the statement is an integral constant expression (if known) |
| CExpected | |
| CExplicitCastExpr | ExplicitCastExpr - An explicit cast written in the source code |
| CExplicitInstantiationInfo | Provides information about an explicit instantiation of a variable or class template |
| CExplicitSpecifier | Store information needed for an explicit specifier |
| CExportContextualKeywordInfo | Record the previous 'export' keyword info |
| CExportDecl | Represents a standard C++ module export declaration |
| CExpr | This represents one expression |
| CClassification | The return type of classify() |
| CEvalResult | EvalResult is a struct with detailed info about an evaluated expression |
| CEvalStatus | EvalStatus is a struct with detailed info about an evaluation in progress |
| CExprDependenceScope | |
| CExpressionTraitExpr | An expression trait intrinsic |
| CExprMutationAnalyzer | Analyzes whether any mutative operations are applied to an expression within a given statement |
| CAnalyzer | |
| CMemoized | |
| CExprWithCleanups | Represents an expression – generally a full-expression – that introduces cleanups to be run at the end of the sub-expression's evaluation |
| CExtensionRAIIObject | ExtensionRAIIObject - This saves the state of extension warnings when constructed and disables them |
| CExternalASTMerger | ExternalASTSource implementation that merges information from several ASTContexts |
| CDCOrigin | A single origin for a DeclContext |
| CImporterSource | A source for an ExternalASTMerger |
| CImporterTarget | The target for an ExternalASTMerger |
| CExternalASTSource | Abstract interface for external sources of AST nodes |
| CDeserializing | RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing |
| CMemoryBufferSizes | |
| CExternalHeaderFileInfoSource | An external source of header file information, which may supply information about header files already included |
| CExternalPreprocessingRecordSource | An abstract class that should be subclassed by any external source of preprocessing record entries |
| CExternalPreprocessorSource | Abstract interface for external sources of preprocessor information |
| CExternalSemaSource | An abstract interface that should be implemented by external AST sources that also provide information for semantic analysis |
| CExternalSLocEntrySource | External source of source location entries |
| CExternalSource | |
| CExternalVTableUse | A simple structure that captures a vtable use for the purposes of the ExternalSemaSource |
| CExternCContextDecl | Declaration context for names declared as extern "C" in C++ |
| CExtQuals | We can encode up to four bits in the low bits of a type pointer, but there are many more type qualifiers that we want to be able to apply to an arbitrary type |
| CExtQualsTypeCommonBase | Base class that is common to both the ExtQuals and Type classes, which allows QualType to access the common fields between the two |
| CExtractAPIAction | ExtractAPIAction sets up the output file and creates the ExtractAPIVisitor |
| CExtractAPIActionBase | Base class to be used by front end actions to generate ExtarctAPI info |
| CExtVectorElementExpr | ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the left hand side or right hand side |
| CExtVectorType | ExtVectorType - Extended vector type |
| CExtVectorTypeLoc | |
| CFieldDecl | Represents a member of a struct/union/class |
| CFieldDeclarator | This little struct is used to capture information about structure field declarators, which is basically just a bitfield size |
| CFileEntry | Cached information about one file (either on disk or in the virtual file system) |
| CFileEntryRef | A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's client |
| CMapValue | Type stored in the StringMap |
| CFileID | An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with its #include path and #line data |
| CFileManager | Implements support for file system lookup, file system caching, and directory search management |
| CFilenamePatternConstraint | |
| CFileNullability | Describes whether we've seen any nullability information for the given file |
| CFileNullabilityMap | A mapping from file IDs to a record of whether we've seen nullability information in that file |
| CFileScopeAsmDecl | |
| CFileSystemOptions | Keeps track of options that affect how file operations are performed |
| CFileSystemStatCache | Abstract interface for introducing a FileManager cache for 'stat' system calls, which is used by precompiled and pretokenized headers to improve performance |
| CFilterAndStoreDiagnosticConsumer | Diagnostic consumer that saves each diagnostic it is given |
| CFixedPointLiteral | |
| CFixedSizeTemplateParameterListStorage | Stores a list of template parameters and the associated requires-clause (if any) for a TemplateDecl and its derived classes |
| CFixItAction | |
| CFixItHint | Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the problem |
| CFixItOptions | |
| CFixItRecompile | Emits changes to temporary files and uses them for the original frontend action |
| CFixItRewriter | |
| CFixitStrategy | |
| CFloatingLiteral | |
| CFoldExpandedConstraint | |
| CFoldingSetPlaceholder | |
| CFormatStyleSet | |
| CForStmt | ForStmt - This represents a 'for (init;cond;inc)' stmt |
| CForwardDataflowWorklist | A worklist implementation for forward dataflow analysis |
| CForwardingDiagnosticConsumer | Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic consumer |
| CFPOptions | |
| CFPOptionsOverride | Represents difference between two FPOptions values |
| CFrameworkCacheEntry | This structure is used to record entries in our framework cache |
| CFriendDecl | FriendDecl - Represents the declaration of a friend entity, which can be a function, a type, or a templated function or type |
| CFriendTemplateDecl | Declaration of a friend template |
| CFrontendAction | Abstract base class for actions which can be performed by the frontend |
| CFrontendInputFile | An input file for the front end |
| CFrontendOptions | FrontendOptions - Options for controlling the behavior of the frontend |
| CFullExpr | FullExpr - Represents a "full-expression" node |
| CFullSourceLoc | A SourceLocation and its associated SourceManager |
| CBeforeThanCompare | Comparison function class, useful for sorting FullSourceLocs |
| CFunctionCallFilterCCC | |
| CFunctionDecl | Represents a function declaration or definition |
| CDefaultedOrDeletedFunctionInfo | Stashed information about a defaulted/deleted function body |
| CFunctionEffect | Represents an abstract function effect, using just an enumeration describing its kind |
| CFunctionEffectIterator | Support iteration in parallel through a pair of FunctionEffect and EffectConditionExpr containers |
| CFunctionEffectKindSet | A mutable set of FunctionEffect::Kind |
| CFunctionEffectSet | A mutable set of FunctionEffects and possibly conditions attached to them |
| CConflict | |
| CFunctionEffectsRef | An immutable set of FunctionEffects and possibly conditions attached to them |
| CFunctionEffectWithCondition | A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e.g |
| CFunctionExitPoint | |
| CFunctionLocInfo | |
| CFunctionNoProtoType | Represents a K&R-style 'int foo()' function, which has no information available about its arguments |
| CFunctionNoProtoTypeLoc | |
| CFunctionParmMutationAnalyzer | |
| CFunctionParmPackExpr | Represents a reference to a function parameter pack, init-capture pack, or binding pack that has been substituted but not yet expanded |
| CFunctionProtoType | Represents a prototype with parameter type info, e.g |
| CExceptionSpecInfo | Holds information about the various types of exception specification |
| CExtProtoInfo | Extra information about a function prototype |
| CFunctionProtoTypeLoc | |
| CFunctionTemplateDecl | Declaration of a template function |
| CCommon | Data that is common to all of the declarations of a given function template |
| CFunctionTemplateSpecializationInfo | Provides information about a function template specialization, which is a FunctionDecl that has been explicitly specialization or instantiated from a function template |
| CFunctionType | FunctionType - C99 6.7.5.3 - Function Declarators |
| CExceptionType | A simple holder for a QualType representing a type in an exception specification |
| CExtInfo | A class which abstracts out some details necessary for making a call |
| CExtParameterInfo | Interesting information about a specific parameter that can't simply be reflected in parameter's type |
| CFunctionTypeArmAttributes | A holder for Arm type attributes as described in the Arm C/C++ Language extensions which are not particularly common to all types and therefore accounted separately from FunctionTypeBitfields |
| CFunctionTypeExtraAttributeInfo | A holder for extra information from attributes which aren't part of an AttributedType |
| CFunctionTypeExtraBitfields | A simple holder for various uncommon bits which do not fit in FunctionTypeBitfields |
| CFunctionTypeLoc | Wrapper for source info for functions |
| CGCCAsmStmt | This represents a GCC inline-assembly statement extension |
| CAsmStringPiece | AsmStringPiece - this is part of a decomposed asm string specification (for use with the AnalyzeAsmString function below) |
| CGenerateHeaderUnitAction | |
| CGenerateInterfaceStubsAction | |
| CGenerateModuleAction | |
| CGenerateModuleFromModuleMapAction | |
| CGenerateModuleInterfaceAction | Generates full BMI (which contains full information to generate the object files) for C++20 Named Modules |
| CGeneratePCHAction | |
| CGenerateReducedModuleInterfaceAction | Only generates the reduced BMI. This action is mainly used by tests |
| CGenericSelectionExpr | Represents a C11 generic selection |
| CGlobalCodeCompletionAllocator | Allocator for a cached set of global code completions |
| CGlobalDecl | GlobalDecl - represents a global declaration |
| CGlobalDeclID | |
| CGlobalModuleIndex | A global index for a set of module files, providing information about the identifiers within those module files |
| CGNUNullExpr | GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that has integral type (e.g., int or long) and is the same size and alignment as a pointer |
| CGotoStmt | GotoStmt - This represents a direct goto |
| CGreaterThanIsOperatorScope | RAII object that makes '>' behave either as an operator or as the closing angle bracket for a template argument list |
| CHeaderDesc | |
| CHeaderFileInfo | The preprocessor keeps track of this information for each file that is #included |
| CHeaderMap | This class represents an Apple concept known as a 'header map' |
| CHeaderMapImpl | Implementation for HeaderMap that doesn't depend on FileManager |
| CHeaderSearch | Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc |
| CHeaderSearchOptions | HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSearch object |
| CEntry | |
| CSystemHeaderPrefix | |
| CHeuristicResolver | |
| CHLSLAnnotationAttr | |
| CHLSLAttributedResourceLocInfo | |
| CHLSLAttributedResourceTypeLoc | Type source information for HLSL attributed resource type |
| CHLSLBufferDecl | HLSLBufferDecl - Represent a cbuffer or tbuffer declaration |
| CHLSLExternalSemaSource | |
| CHLSLFrontendAction | |
| CHLSLInlineSpirvTypeLoc | |
| CHLSLInlineSpirvTypeLocInfo | |
| CHLSLOutArgExpr | This class represents temporary values used to represent inout and out arguments in HLSL |
| CHLSLRootSignatureDecl | |
| CHLSLSemanticBaseAttr | |
| CHMapBucket | |
| CHMapHeader | |
| CHTMLPrintAction | |
| CIdentifierInfo | One of these records is kept for each identifier that is lexed |
| CIdentifierInfoLookup | Provides lookups to, and iteration over, IdentiferInfo objects |
| CIdentifierIterator | An iterator that walks over all of the known identifiers in the lookup table |
| CIdentifierLoc | A simple pair of identifier info and location |
| CIdentifierOrOverloadedOperator | |
| CIdentifierResolver | IdentifierResolver - Keeps track of shadowed decls on enclosing scopes |
| CIdDeclInfoMap | IdDeclInfoMap - Associates IdDeclInfos with declaration names |
| Citerator | Iterator - Iterate over the decls of a specified declaration name |
| CIdentifierTable | Implements an efficient mapping from strings to IdentifierInfo nodes |
| CIfStmt | IfStmt - This represents an if/then/else |
| CIgnoringDiagConsumer | A diagnostic client that ignores all diagnostics |
| CImaginaryLiteral | ImaginaryLiteral - We support imaginary integer and floating point literals, like "1.0i" |
| CImplicitAllocationParameters | |
| CImplicitCallPoint | Represents an implicit call event |
| CImplicitCastExpr | ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct representation in the original source code |
| CImplicitConceptSpecializationDecl | |
| CImplicitConversionSequence | ImplicitConversionSequence - Represents an implicit conversion sequence, which may be a standard conversion sequence (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2), or an ellipsis conversion sequence (C++ 13.3.3.1.3) |
| CImplicitDeallocationParameters | |
| CImplicitParamDecl | |
| CImplicitValueInitExpr | Represents an implicitly-generated value initialization of an object of a given type |
| CImportDecl | Describes a module import declaration, which makes the contents of the named module visible in the current translation unit |
| CInBeforeInTUCacheEntry | Holds the cache used by isBeforeInTranslationUnit |
| CInclusionDirective | Record the location of an inclusion directive, such as an #include or #import statement |
| CIncompleteArrayType | Represents a C array with an unspecified size |
| CIncompleteArrayTypeLoc | |
| CIncrementalAction | A custom action enabling the incremental processing functionality |
| CIncrementalCompilerBuilder | Create a pre-configured CompilerInstance for incremental processing |
| CIncrementalCUDADeviceParser | |
| CIncrementalExecutor | |
| CIncrementalExecutorBuilder | |
| CIncrementalParser | Provides support for incremental compilation |
| CIncrementalSyntaxOnlyAction | |
| CIndirectFieldDecl | Represents a field injected from an anonymous union/struct into the parent scope |
| CIndirectGotoStmt | IndirectGotoStmt - This represents an indirect goto |
| CInheritableAttr | |
| CInheritableParamAttr | |
| CInheritableParamOrStmtAttr | |
| CInheritedConstructor | Description of a constructor that was inherited from a base class |
| CInheritingConcreteTypeLoc | A metaprogramming class designed for concrete subtypes of abstract types where all subtypes share equivalently-structured source information |
| CInitializationKind | Describes the kind of initialization being performed, along with location information for tokens related to the initialization (equal sign, parentheses) |
| CInitializationSequence | Describes the sequence of initializations required to initialize a given object or reference with a set of arguments |
| CStep | A single step in the initialization sequence |
| CF | |
| CInitializedEntity | Describes an entity that is being initialized |
| CInitListExpr | Describes an C or C++ initializer list |
| CInitOnlyAction | |
| CInjectedClassNameTypeLoc | Wrapper for source info for injected class names of class templates |
| CInMemoryModuleCache | In-memory cache for modules |
| CInMessageExpressionRAIIObject | |
| CInProcessPrintingASTConsumer | |
| CInputKind | The kind of a file that we've been handed as an input |
| CIntegerLiteral | |
| CInterfaceKindVisitor | |
| CInterpreter | Provides top-level interfaces for incremental compilation and execution |
| CIntrusiveRefCntPtr | |
| CIntrusiveRefCntPtrInfo | |
| CInventedTemplateParameterInfo | |
| CIsResultPtrLowBitFree | |
| CIsResultPtrLowBitFree< CXXBaseSpecifier * > | |
| CIsResultPtrLowBitFree< CXXCtorInitializer * > | |
| CIsResultPtrLowBitFree< Expr * > | |
| CIsResultPtrLowBitFree< Stmt * > | |
| CItaniumMangleContext | |
| CItaniumVTableContext | |
| CJSONDumper | |
| CJSONNodeDumper | |
| CKeepEmptyLinesStyle | Options regarding which empty lines are kept |
| CKeywordHelpers | Provides a few static helpers for converting and printing elaborated type keyword and tag type kind enumerations |
| CKeywordWrapper | |
| CCannotCastToThisType | |
| CLabelDecl | Represents the declaration of a label |
| CLabelStmt | LabelStmt - Represents a label, which has a substatement |
| CLambdaCapture | Describes the capture of a variable or of this, or of a C++1y init-capture |
| CLambdaCaptureConstructionContext | |
| CLambdaExpr | A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked later |
| CLambdaIntroducer | Represents a complete lambda introducer |
| CLambdaCapture | An individual capture in a lambda introducer |
| CLangOptions | Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that is accepted |
| CLangOptionsBase | Bitfields of LangOptions, split out from LangOptions in order to ensure that this large collection of bitfields is a trivial class type |
| CLangStandard | LangStandard - Information about the properties of a particular language standard |
| CLateParsedTemplate | Contains a late templated function |
| CLayoutOverrideSource | An external AST source that overrides the layout of a specified set of record types |
| CLazyASTUnresolvedSet | An UnresolvedSet-like class that might not have been loaded from the external AST source yet |
| CLazyDetector | Simple wrapper for toolchain detector with costly initialization |
| CLazyGenerationalUpdatePtr | A lazy value (of type T) that is within an AST node of type Owner, where the value might change in later generations of the external AST source |
| CLazyData | A cache of the value of this pointer, in the most recent generation in which we queried it |
| CLazyIdentifierInfoPtr | |
| CLazyOffsetPtr | A lazy pointer to an AST node (of base type T) that resides within an external AST source |
| CLazyVector | Represents a lazily-loaded vector of data |
| Citerator | Iteration over the elements in the vector |
| CLexEmbedParametersResult | |
| CLexer | Lexer - This provides a simple interface that turns a text buffer into a stream of tokens |
| CSizedChar | Represents a char and the number of bytes parsed to produce it |
| CLexicallyOrderedRecursiveASTVisitor | A RecursiveASTVisitor subclass that guarantees that AST traversal is performed in a lexical order (i.e |
| CLifetimeExtendedTemporaryDecl | Implicit declaration of a temporary that was materialized by a MaterializeTemporaryExpr and lifetime-extended by a declaration |
| CLineEntry | |
| CLineTableInfo | Used to hold and unique data used to represent #line information |
| CLinkageComputer | |
| CLinkageInfo | |
| CLinkageSpecDecl | Represents a linkage specification |
| CLiveVariables | |
| CLivenessValues | |
| CObserver | |
| CLocalDeclID | |
| CLocalInstantiationScope | A stack-allocated class that identifies which local variable declaration instantiations are present in this scope |
| CLocationCheck | |
| CLocationContext | It wraps the AnalysisDeclContext to represent both the call stack with the help of StackFrameContext and inside the function calls the BlockInvocationContext |
| CLocationContextManager | |
| CLocInfoType | Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing |
| CLogDiagnosticPrinter | |
| CLookupBlockOffsets | |
| CLookupResult | Represents the results of name lookup |
| CFilter | A class for iterating through a result set and possibly filtering out results |
| CLoopControlStmt | Base class for BreakStmt and ContinueStmt |
| CLoopExit | Represents a point when we exit a loop |
| CLoopHint | Loop optimization hint for loop and unroll pragmas |
| CLValueReferenceType | An lvalue reference type, per C++11 [dcl.ref] |
| CLValueReferenceTypeLoc | |
| CLVComputationKind | Kinds of LV computation |
| CMacroArgs | MacroArgs - An instance of this class captures information about the formal arguments specified to a function-like macro invocation |
| CMacroBuilder | |
| CMacroDefinition | A description of the current definition of a macro |
| CMacroDefinitionRecord | Record the location of a macro definition |
| CMacroDirective | Encapsulates changes to the "macros namespace" (the location where the macro name became active, the location where it was undefined, etc.) |
| CDefInfo | |
| CMacroExpansion | Records the location of a macro expansion |
| CMacroExpansionContext | MacroExpansionContext tracks the macro expansions processed by the Preprocessor |
| CMacroInfo | Encapsulates the data about a macro definition (e.g |
| CMacroPPCallbacks | |
| CMacroQualifiedLocInfo | |
| CMacroQualifiedType | Sugar type that represents a type that was qualified by a qualifier written as a macro invocation |
| CMacroQualifiedTypeLoc | |
| CManagedAnalysis | The base class of a hierarchy of objects representing analyses tied to AnalysisDeclContext |
| CMangleContext | MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangler |
| CMangleNumberingContext | Keeps track of the mangled names of lambda expressions and block literals within a particular context |
| CMatchingVariablePatternConstraint | Ensures that all clones reference variables in the same pattern |
| CMaterializeTemporaryExpr | Represents a prvalue temporary that is written into memory so that a reference can bind to it |
| CMatrixSingleSubscriptExpr | MatrixSingleSubscriptExpr - Matrix single subscript expression for the MatrixType extension when you want to get\set a vector from a Matrix |
| CMatrixSubscriptExpr | MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension |
| CMatrixType | Represents a matrix type, as defined in the Matrix Types clang extensions |
| CMatrixTypeLoc | |
| CMatrixTypeLocInfo | |
| CMemberExpr | MemberExpr - [C99 6.5.2.3] Structure and Union Members |
| CMemberPointerLocInfo | |
| CMemberPointerType | A pointer to member type per C++ 8.3.3 - Pointers to members |
| CMemberPointerTypeLoc | Wrapper for source info for member pointers |
| CMemberSpecializationInfo | Provides information a specialization of a member of a class template, which may be a member function, static data member, member class or member enumeration |
| CMemorizeStatCalls | A stat "cache" that can be used by FileManager to keep track of the results of stat() calls that occur throughout the execution of the front end |
| CMergeable | Provides common interface for the Decls that cannot be redeclared, but can be merged if the same declaration is brought in from multiple modules |
| CMethodVFTableLocation | |
| CMicrosoftMangleContext | |
| CMicrosoftVTableContext | |
| CMigratorOptions | |
| CMinComplexityConstraint | Ensures that every clone has at least the given complexity |
| CMinGroupSizeConstraint | Ensures that all clone groups contain at least the given amount of clones |
| CModule | Describes a module or submodule |
| CConflict | A conflict between two modules |
| CDirectoryName | Information about a directory name as found in the module map file |
| CHeader | Information about a header directive as found in the module map file |
| CLinkLibrary | A library or framework to link against when an entity from this module is used |
| CRequirement | |
| CUnresolvedConflict | An unresolved conflict with another module |
| CUnresolvedExportDecl | Describes an exported module that has not yet been resolved (perhaps because the module it refers to has not yet been loaded) |
| CUnresolvedHeaderDirective | Stored information about a header directive that was found in the module map file but has not been resolved to a file |
| CModuleAttributes | The set of attributes that can be attached to a module |
| CModuleCache | The module cache used for compiling modules implicitly |
| CModuleConstructorTag | Required to construct a Module |
| CModuleDependencyCollector | Collects the dependencies for imported modules into a directory |
| CModuleFileExtension | An abstract superclass that describes a custom extension to the module/precompiled header file format |
| CModuleFileExtensionMetadata | Metadata for a module file extension |
| CModuleFileExtensionReader | Abstract base class that reads a module file extension block from a module file |
| CModuleFileExtensionWriter | Abstract base class that writes a module file extension block into a module file |
| CModuleLoader | Abstract interface for a module loader |
| CModuleLoadResult | Describes the result of attempting to load a module |
| CModuleMacro | Represents a macro directive exported by a module |
| CModuleMap | |
| CKnownHeader | A header that is known to reside within a given module, whether it was included or excluded |
| CModuleMapCallbacks | A mechanism to observe the actions of the module map loader as it reads module map files |
| CModuleMapLoader | |
| CModuleNameLoc | |
| CMSAsmStmt | This represents a Microsoft inline-assembly statement extension |
| CMSDependentExistsStmt | Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name |
| CMSGuidDecl | A global _GUID constant |
| CMSGuidDeclParts | Parts of a decomposed MSGuidDecl |
| CMSPropertyDecl | An instance of this class represents the declaration of a property member |
| CMSPropertyRefExpr | A member reference to an MSPropertyDecl |
| CMSPropertySubscriptExpr | MS property subscript expression |
| CMultiKeywordSelector | One of these variable length records is kept for each selector containing more than one keyword |
| CMultiLevelTemplateArgumentList | Data structure that captures multiple levels of template argument lists for use in template instantiation |
| CMultipleIncludeOpt | Implements the simple state machine that the Lexer class uses to detect files subject to the 'multiple-include' optimization |
| CMultiplexASTDeserializationListener | |
| CMultiplexASTMutationListener | |
| CMultiplexConsumer | |
| CMultiplexExternalSemaSource | An abstract interface that should be implemented by external AST sources that also provide information for semantic analysis |
| CMutableArrayRef | |
| CNamedDecl | This represents a decl that may have a name |
| CNamespaceAliasDecl | Represents a C++ namespace alias |
| CNamespaceAndPrefix | |
| CNamespaceAndPrefixLoc | |
| CNamespaceAndPrefixStorage | |
| CNamespaceBaseDecl | Represents C++ namespaces and their aliases |
| CNamespaceDecl | Represent a C++ namespace |
| CNeonTypeFlags | Flags to identify the types for overloaded Neon builtins |
| CNestedNameSpecifier | Represents a C++ nested name specifier, such as "\::std::vector<int>::" |
| CNestedNameSpecifierLoc | A C++ nested-name-specifier augmented with source location information |
| CNestedNameSpecifierLocBuilder | Class that aids in the construction of nested-name-specifiers along with source-location information for all of the components of the nested-name-specifier |
| CNewAllocatedObjectConstructionContext | Represents immediate initialization of memory allocated by operator new, eg |
| CNodeStreamer | |
| CNoInitExpr | Represents a place-holder for an object not to be initialized by anything |
| CNonTypeTemplateParmDecl | NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in |
| CNormalizedConstraint | A normalized constraint, as defined in C++ [temp.constr.normal], is either an atomic constraint, a conjunction of normalized constraints or a disjunction of normalized constraints |
| CAtomicConstraintBits | |
| CCompoundConstraintBits | |
| CConceptIdBits | |
| CFoldExpandedConstraintBits | |
| CNormalizedConstraintWithParamMapping | |
| CNoSanitizeList | |
| CNoTrivialPPDirectiveTracer | Consider the following code: |
| CNoTypoCorrectionCCC | |
| CNSAPI | |
| CNullStmt | NullStmt - This is the null statement ";": C99 6.8.3p3 |
| CNumericLiteralCaseStyle | Separate control for each numeric literal component |
| CNumericLiteralParser | NumericLiteralParser - This performs strict semantic analysis of the content of a ppnumber, classifying it as either integer, floating, or erroneous, determines the radix of the value and can convert it to a useful value |
| CObjCArrayLiteral | ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]]; |
| CObjCAtCatchStmt | Represents Objective-C's @catch statement |
| CObjCAtDefsFieldDecl | Represents a field declaration created by an @defs(...) |
| CObjCAtFinallyStmt | Represents Objective-C's @finally statement |
| CObjCAtSynchronizedStmt | Represents Objective-C's @synchronized statement |
| CObjCAtThrowStmt | Represents Objective-C's @throw statement |
| CObjCAtTryStmt | Represents Objective-C's @try ... @catch ... @finally statement |
| CObjCAutoreleasePoolStmt | Represents Objective-C's @autoreleasepool Statement |
| CObjCAvailabilityCheckExpr | A runtime availability query |
| CObjCBoolLiteralExpr | ObjCBoolLiteralExpr - Objective-C Boolean Literal |
| CObjCBoxedExpr | ObjCBoxedExpr - used for generalized expression boxing |
| CObjCBridgedCastExpr | An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers, transferring ownership in the process |
| CObjCCategoryDecl | ObjCCategoryDecl - Represents a category declaration |
| CObjCCategoryImplDecl | ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration |
| CObjCCompatibleAliasDecl | ObjCCompatibleAliasDecl - Represents alias of a class |
| CObjCContainerDecl | ObjCContainerDecl - Represents a container for method declarations |
| CObjCDeclSpec | Captures information about "declaration specifiers" specific to Objective-C |
| CObjCDictionaryElement | An element in an Objective-C dictionary literal |
| CObjCDictionaryLiteral | ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserName(), @"date" : [NSDate date] }; |
| CObjCDictionaryLiteral_ExpansionData | Internal struct to describes an element that is a pack expansion, used if any of the elements in the dictionary literal are pack expansions |
| CObjCDictionaryLiteral_KeyValuePair | Internal struct for storing Key/value pair |
| CObjCEncodeExpr | ObjCEncodeExpr, used for @encode in Objective-C |
| CObjCForCollectionStmt | Represents Objective-C's collection statement |
| CObjCImplDecl | |
| CObjCImplementationDecl | ObjCImplementationDecl - Represents a class definition - this is where method definitions are specified |
| CObjCIndirectCopyRestoreExpr | ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore in ARC |
| CObjCInterfaceDecl | Represents an ObjC class declaration |
| Cfiltered_category_iterator | Iterator that walks over the list of categories, filtering out those that do not meet specific criteria |
| CObjCInterfaceLocInfo | |
| CObjCInterfaceType | Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type), a C23 feature |
| CObjCInterfaceTypeLoc | Wrapper for source info for ObjC interfaces |
| CObjCIsaExpr | ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type |
| CObjCIvarDecl | ObjCIvarDecl - Represents an ObjC instance variable |
| CObjCIvarRefExpr | ObjCIvarRefExpr - A reference to an ObjC instance variable |
| CObjCList | ObjCList - This is a simple template class used to hold various lists of decls etc, which is heavily used by the ObjC front-end |
| CObjCListBase | |
| CObjCMessageExpr | An expression that sends a message to the given Objective-C object or class |
| CObjCMethodDecl | ObjCMethodDecl - Represents an instance or class method declaration |
| CGetTypeFn | |
| CObjCMethodList | Linked list of methods with the same selector name but different signatures |
| CObjCNoReturn | |
| CObjCObjectPointerType | Represents a pointer to an Objective C object |
| CObjCObjectPointerTypeLoc | Wraps an ObjCPointerType with source location information |
| CObjCObjectTypeLoc | |
| CObjCObjectTypeLocInfo | |
| CObjCPropertyDecl | Represents one property declaration in an Objective-C interface |
| CObjCPropertyImplDecl | ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category implementation block |
| CObjCPropertyRefExpr | ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property |
| CObjCProtocolDecl | Represents an Objective-C protocol declaration |
| CObjCProtocolExpr | ObjCProtocolExpr used for protocol expression in Objective-C |
| CObjCProtocolList | A list of Objective-C protocols, along with the source locations at which they were referenced |
| CObjCProtocolLoc | |
| CObjCRuntime | The basic abstraction for the target Objective-C runtime |
| CObjCSelectorExpr | ObjCSelectorExpr used for @selector in Objective-C |
| CObjCStringLiteral | ObjCStringLiteral, used for Objective-C string literals i.e |
| CObjCSubscriptRefExpr | ObjCSubscriptRefExpr - used for array and dictionary subscripting |
| CObjCTypeParamDecl | Represents the declaration of an Objective-C type parameter |
| CObjCTypeParamList | Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereof |
| CObjCTypeParamTypeLoc | ProtocolLAngleLoc, ProtocolRAngleLoc, and the source locations for protocol qualifiers are stored after Info |
| CObjCTypeParamTypeLocInfo | |
| CObjectFilePCHContainerReader | A PCHContainerReader implementation that uses LLVM to wraps Clang modules inside a COFF, ELF, or Mach-O container |
| CObjectFilePCHContainerWriter | A PCHContainerWriter implementation that uses LLVM to wraps Clang modules inside a COFF, ELF, or Mach-O container |
| CODRDiagsEmitter | |
| CODRHash | |
| COffloadBundler | |
| COffloadBundlerConfig | |
| COffloadTargetInfo | Obtain the offload kind, real machine triple, and an optional TargetID out of the target information specified by the user |
| COffsetOfExpr | OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator) |
| COffsetOfNode | Helper class for OffsetOfExpr |
| COffsetOfStateRAIIObject | |
| COMPAlignClause | This represents the 'align' clause in the '#pragma omp allocate' directive |
| COMPAllocateClause | This represents clause 'allocate' in the '#pragma omp ...' directives |
| COMPAllocateDecl | This represents '#pragma omp allocate ...' directive |
| COMPAllocatorClause | This represents 'allocator' clause in the '#pragma omp ...' directive |
| COMPArrayShapingExpr | An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]...[sn])expr |
| COMPCapturedExprDecl | Pseudo declaration for capturing expressions |
| COMPClause | This is a basic class for representing single OpenMP clause |
| COMPClauseReader | |
| COMPClauseWithPostUpdate | Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc |
| COMPClauseWithPreInit | Class that handles pre-initialization statement for some clauses, like 'schedule', 'firstprivate' etc |
| COMPCollapseClause | This represents 'collapse' clause in the '#pragma omp ...' directive |
| COMPDeclarativeDirective | This is a basic class for representing single OpenMP declarative directive |
| COMPDeclareMapperDecl | This represents '#pragma omp declare mapper ...' directive |
| COMPDeclareReductionDecl | This represents '#pragma omp declare reduction ...' directive |
| COMPDefaultClause | This represents 'default' clause in the '#pragma omp ...' directive |
| COMPDirectiveListClause | Class that represents a list of directive kinds (parallel, target, etc.) as used in absent, contains clauses |
| COMPFinalClause | This represents 'final' clause in the '#pragma omp ...' directive |
| COMPFullClause | Representation of the 'full' clause of the '#pragma omp unroll' directive |
| COMPGroupPrivateDecl | This represents '#pragma omp groupprivate ...' directive |
| COMPIfClause | This represents 'if' clause in the '#pragma omp ...' directive |
| COMPInteropInfo | |
| COMPIteratorExpr | OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause on which they appear |
| CIteratorDefinition | Iterator definition representation |
| CIteratorRange | Iterator range representation begin:end[:step] |
| COMPIteratorHelperData | Helper expressions and declaration for OMPIteratorExpr class for each iteration space |
| COMPLoopRangeClause | This class represents the 'looprange' clause in the '#pragma omp fuse' directive |
| COMPNoChildClause | |
| COMPNumThreadsClause | This represents 'num_threads' clause in the '#pragma omp ...' directive |
| COMPOneStmtClause | |
| COMPPartialClause | Representation of the 'partial' clause of the '#pragma omp unroll' directive |
| COMPPermutationClause | This class represents the 'permutation' clause in the '#pragma omp interchange' directive |
| COMPRequiresDecl | This represents '#pragma omp requires...' directive |
| COMPSafelenClause | This represents 'safelen' clause in the '#pragma omp ...' directive |
| COMPSimdlenClause | This represents 'simdlen' clause in the '#pragma omp ...' directive |
| COMPSizesClause | This represents the 'sizes' clause in the '#pragma omp tile' directive |
| COMPThreadPrivateDecl | This represents '#pragma omp threadprivate ...' directive |
| COMPThreadsetClause | This represents 'threadset' clause in the '#pragma omp task ...' directive |
| COMPVarListClause | This represents clauses with the list of variables like 'private', 'firstprivate', 'copyin', 'shared', or 'reduction' clauses in the '#pragma omp ...' directives |
| COMPVarListLocTy | This structure contains most locations needed for by an OMPVarListClause |
| COnlyLargestCloneConstraint | Ensures that no clone group fully contains another clone group |
| COpaquePtr | Wrapper for void* pointer |
| COpaqueValueExpr | OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class |
| COpenACCAssociatedStmtConstruct | This is a base class for any OpenACC statement-level constructs that have an associated statement |
| COpenACCAsteriskSizeExpr | This expression type represents an asterisk in an OpenACC Size-Expr, used in the 'tile' and 'gang' clauses |
| COpenACCAsyncClause | |
| COpenACCAttachClause | |
| COpenACCAutoClause | |
| COpenACCBindClause | |
| COpenACCClause | This is the base type for all OpenACC Clauses |
| COpenACCClausePrinter | |
| COpenACCClauseVisitor | |
| COpenACCClauseWithCondition | Represents one of the handful of classes that has an optional/required 'condition' expression as an argument |
| COpenACCClauseWithExprs | Represents a clause that has one or more expressions associated with it |
| COpenACCClauseWithParams | Represents a clause that has a list of parameters |
| COpenACCClauseWithSingleIntExpr | Represents one of a handful of clauses that have a single integer expression |
| COpenACCClauseWithVarList | Represents a clause with one or more 'var' objects, represented as an expr, as its arguments |
| COpenACCCollapseClause | Represents a 'collapse' clause on a 'loop' construct |
| COpenACCConstructDecl | |
| COpenACCConstructStmt | This is the base class for an OpenACC statement-level construct, other construct types are expected to inherit from this |
| COpenACCCopyClause | |
| COpenACCCopyInClause | |
| COpenACCCopyOutClause | |
| COpenACCCreateClause | |
| COpenACCDeclareDecl | |
| COpenACCDefaultAsyncClause | |
| COpenACCDefaultClause | A 'default' clause, has the optional 'none' or 'present' argument |
| COpenACCDeleteClause | |
| COpenACCDetachClause | |
| COpenACCDeviceClause | |
| COpenACCDeviceNumClause | |
| COpenACCDevicePtrClause | |
| COpenACCDeviceResidentClause | |
| COpenACCDeviceTypeClause | A 'device_type' or 'dtype' clause, takes a list of either an 'asterisk' or an identifier |
| COpenACCFinalizeClause | |
| COpenACCFirstPrivateClause | |
| COpenACCFirstPrivateRecipe | |
| COpenACCGangClause | |
| COpenACCHostClause | |
| COpenACCIfClause | An 'if' clause, which has a required condition expression |
| COpenACCIfPresentClause | |
| COpenACCIndependentClause | |
| COpenACCLinkClause | |
| COpenACCNoCreateClause | |
| COpenACCNoHostClause | |
| COpenACCNumGangsClause | |
| COpenACCNumWorkersClause | |
| COpenACCPresentClause | |
| COpenACCPrivateClause | |
| COpenACCPrivateRecipe | |
| COpenACCReductionClause | |
| COpenACCReductionRecipe | |
| CCombinerRecipe | |
| COpenACCReductionRecipeWithStorage | |
| COpenACCRoutineDecl | |
| COpenACCSelfClause | A 'self' clause, which has an optional condition expression, or, in the event of an 'update' directive, contains a 'VarList' |
| COpenACCSeqClause | |
| COpenACCTileClause | |
| COpenACCUseDeviceClause | |
| COpenACCVectorClause | |
| COpenACCVectorLengthClause | |
| COpenACCWaitClause | |
| COpenACCWorkerClause | |
| COpenCLOptions | OpenCL supported extensions and optional core features |
| COpenCLOptionInfo | |
| COpenMPScheduleTy | Scheduling data for loop-based OpenMP directives |
| COptionalDiagnostic | A partial diagnostic which we might know in advance that we are not going to emit |
| COrcIncrementalExecutor | |
| COutlinedFunctionDecl | Represents a partial function definition |
| COverloadCandidate | OverloadCandidate - A single candidate in an overload set (C++ 13.3) |
| COverloadCandidateSet | OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13.3) |
| COperatorRewriteInfo | Information about operator rewrites to consider when adding operator functions to a candidate set |
| COverloadedTemplateStorage | A structure for storing the information associated with an overloaded template name |
| COverloadExpr | A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr |
| CFindResult | |
| COverridingMethods | The set of methods that override a given virtual method in each subobject where it occurs |
| CPackExpansionExpr | Represents a C++11 pack expansion that produces a sequence of expressions |
| CPackExpansionTypeLoc | |
| CPackExpansionTypeLocInfo | |
| CPackIndexingExpr | |
| CPackIndexingTypeLoc | |
| CPackIndexingTypeLocInfo | |
| CParameterABIAttr | A parameter attribute which changes the argument-passing ABI rule for the parameter |
| CParamIdx | A single parameter index whose accessors require each use to make explicit the parameter index encoding needed |
| CParenBraceBracketBalancer | RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing, even when there's a parsing error |
| CParenExpr | ParenExpr - This represents a parenthesized expression, e.g |
| CParenListExpr | |
| CParenLocInfo | |
| CParentMap | |
| CParentMapContext | |
| CParentMap | |
| CASTVisitor | A RecursiveASTVisitor that builds a map from nodes to their parents as defined by the RecursiveASTVisitor |
| CParenType | Sugar for parentheses used when specifying types |
| CParenTypeLoc | |
| CParmVarDecl | Represents a parameter to a function |
| CParsedAttr | ParsedAttr - Represents a syntactic attribute |
| CParsedAttributeArgumentsProperties | |
| CParsedAttributes | ParsedAttributes - A collection of parsed attributes |
| CParsedAttributesView | |
| Cconst_iterator | |
| Citerator | |
| CParsedAttrInfo | |
| CSpelling | The syntaxes supported by this attribute and how they're spelled |
| CParsedSourceLocation | A source location that has been parsed on the command line |
| CParsedSourceRange | A source range that has been parsed on the command line |
| CParsedTargetAttr | Contains information gathered from parsing the contents of TargetAttr |
| CParsedTemplateArgument | Represents the parsed form of a C++ template argument |
| CParser | Parser - This implements a parser for the C family of languages |
| CConditionDeclarationOrInitStatementState | |
| CMultiParseScope | Introduces zero or more scopes for parsing |
| CObjCTypeParamListScope | |
| CParseScope | ParseScope - Introduces a new scope for parsing |
| CReenterClassScopeRAII | |
| CReenterTemplateScopeRAII | |
| CParsingDeclarator | A class for parsing a declarator |
| CParsingDeclRAIIObject | RAII object used to inform the actions that we're currently parsing a declaration |
| CParsingDeclSpec | A class for parsing a DeclSpec |
| CParsingFieldDeclarator | A class for parsing a field declarator |
| CParsingOpenACCDirectiveRAII | Activates OpenACC parsing mode to preseve OpenACC specific annotation tokens |
| CParsingOpenMPDirectiveRAII | Activates OpenMP parsing mode to preseve OpenMP specific annotation tokens |
| CPartialDiagnostic | |
| CNullDiagnostic | |
| CPartialTranslationUnit | The class keeps track of various objects created as part of processing incremental inputs |
| CPCHBuffer | |
| CPCHContainerOperations | A registry of PCHContainerWriter and -Reader objects for different formats |
| CPCHContainerReader | This abstract interface provides operations for unwrapping containers for serialized ASTs (precompiled headers and clang modules) |
| CPCHContainerWriter | This abstract interface provides operations for creating containers for serialized ASTs (precompiled headers and clang modules) |
| CPCHGenerator | AST and semantic-analysis consumer that generates a precompiled header from the parsed source code |
| CPCHValidator | ASTReaderListener implementation to validate the information of the PCH file against an initialized Preprocessor |
| CPipeType | PipeType - OpenCL20 |
| CPipeTypeLoc | |
| CPipeTypeLocInfo | |
| CPluginASTAction | |
| CPointerAuthOptions | |
| CPointerAuthQualifier | Pointer-authentication qualifiers |
| CPointerAuthSchema | |
| CPointerLikeLocInfo | |
| CPointerLikeTypeLoc | A base class for |
| CPointerType | PointerType - C99 6.7.5.1 - Pointer Declarators |
| CPointerTypeLoc | Wrapper for source info for pointers |
| CPoisonIdentifierRAIIObject | An RAII object for [un]poisoning an identifier within a scope |
| CPoisonSEHIdentifiersRAIIObject | |
| CPositiveAnalyzerOption | |
| CPostAllocatorCall | |
| CPostCondition | |
| CPostImplicitCall | Represents a program point just after an implicit call event |
| CPostInitializer | |
| CPostLoad | |
| CPostLValue | |
| CPostOrderCFGView | |
| CBlockOrderCompare | |
| CCFGBlockSet | Implements a set of CFGBlocks using a BitVector |
| Citerator | |
| CPostStmt | |
| CPostStmtPurgeDeadSymbols | Represents a point after we ran remove dead bindings AFTER processing the given statement |
| CPostStore | Represents a program point after a store evaluation |
| CPPCallbacks | This interface provides a way to observe the actions of the preprocessor as it does its thing |
| CPPChainedCallbacks | Simple wrapper class for chaining callbacks |
| CPPConditionalDirectiveRecord | Records preprocessor conditional directive regions and allows querying in which region source locations belong to |
| CPPConditionalInfo | Information about the conditional stack (#if directives) currently active |
| CPPDirectiveParameter | Captures basic information about a preprocessor directive parameter |
| CPPEmbedParameterIfEmpty | Preprocessor standard embed parameter "if_empty" if_empty( balanced-token-seq ) |
| CPPEmbedParameterLimit | Preprocessor standard embed parameter "limit" limit( constant-expression ) |
| CPPEmbedParameterOffset | Preprocessor extension embed parameter "clang::offset" clang::offset( constant-expression ) |
| CPPEmbedParameterPrefix | Preprocessor standard embed parameter "prefix" prefix( balanced-token-seq ) |
| CPPEmbedParameterSuffix | Preprocessor standard embed parameter "suffix" suffix( balanced-token-seq ) |
| CPragmaCommentDecl | Represents a #pragma comment line |
| CPragmaDetectMismatchDecl | Represents a #pragma detect_mismatch line |
| CPragmaHandler | PragmaHandler - Instances of this interface defined to handle the various pragmas that the language front-end uses |
| CPragmaIntroducer | Describes how and where the pragma was introduced |
| CPragmaLoopHintInfo | |
| CPragmaNamespace | PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas, allowing hierarchical pragmas to be defined |
| CPreambleBounds | Describes the bounds (start, size) of the preamble and a flag required by PreprocessorOptions::PrecompiledPreambleBytes |
| CPreambleCallbacks | A set of callbacks to gather useful information while building a preamble |
| CPrecompiledPreamble | A class holding a PCH and all information to check whether it is valid to reuse the PCH for the subsequent runs |
| CPCHStorage | |
| CPredefinedExpr | [C99 6.4.2.2] - A predefined identifier such as func |
| CPredefinedSugarType | |
| CPredefinedSugarTypeLoc | |
| CPredefinedSugarTypeLocInfo | |
| CPreferredTypeBuilder | Tracks expected type during expression parsing, for use in code completion |
| CPreImplicitCall | Represents a program point just before an implicit call event |
| CPreLoad | |
| CPreprocessedEntity | Base class that describes a preprocessed entity, which may be a preprocessor directive or macro expansion |
| CPreprocessingDirective | Records the presence of a preprocessor directive |
| CPreprocessingRecord | A record of the steps taken while preprocessing a source file, including the various preprocessing directives processed, macros expanded, etc |
| Citerator | Iteration over the preprocessed entities |
| CPreprocessOnlyAction | |
| CPreprocessor | Engages in a tight little dance with the lexer to efficiently preprocess tokens |
| CPreambleSkipInfo | |
| CResetMacroExpansionHelper | |
| CPreprocessorFrontendAction | Abstract base class to use for preprocessor-based frontend actions |
| CPreprocessorLexer | |
| CPreprocessorOptions | PreprocessorOptions - This class is used for passing the various options used in preprocessor initialization to InitializePreprocessor() |
| CPreprocessorOutputOptions | PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g., -E) |
| CPreStmt | |
| CPreStmtPurgeDeadSymbols | Represents a point after we ran remove dead bindings BEFORE processing the given statement |
| CPreStore | |
| CPresumedLoc | Represents an unpacked "presumed" location which can be presented to the user |
| CPrettyDeclStackTraceEntry | PrettyDeclStackTraceEntry - If a crash occurs in the parser while parsing something related to a declaration, include that declaration in the stack trace |
| CPrettyStackTraceDecl | PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specific decl |
| CPrettyStackTraceLoc | If a crash happens while one of these objects are live, the message is printed out along with the specified source location |
| CPrintDependencyDirectivesSourceMinimizerAction | |
| CPrinterHelper | |
| CPrintingCallbacks | Callbacks to use to customize the behavior of the pretty-printer |
| CPrintingCodeCompleteConsumer | A simple code-completion consumer that prints the results it receives in a simple format |
| CPrintingPolicy | Describes how types, statements, expressions, and declarations should be printed |
| CPrintPreambleAction | |
| CPrintPreprocessedAction | |
| CProfileList | |
| CProfileSpecialCaseList | |
| CProgramPoint | |
| CProgramPointTag | ProgramPoints can be "tagged" as representing points specific to a given analysis entity |
| CPseudoDestructorTypeStorage | Stores the type being destroyed by a pseudo-destructor expression |
| CPseudoObjectExpr | PseudoObjectExpr - An expression which accesses a pseudo-object l-value |
| CQualifiedTemplateName | Represents a template name as written in source code |
| CQualifiedTypeLoc | Wrapper of type source information for a type with non-trivial direct qualifiers |
| CQualifierCollector | A qualifier set is used to build a set of qualifiers |
| CQualifierInfo | A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line declarations |
| CQualifiers | The collection of all-type qualifiers we support |
| CQualifiersAndAtomic | |
| CQualType | A (possibly-)qualified type |
| CStreamedQualTypeHelper | |
| CQualTypeOrdering | Function object that provides a total ordering on QualType values |
| CRawComment | |
| CCommentLine | |
| CRawCommentList | This class represents all comments included in the translation unit, sorted in order of appearance in the translation unit |
| CRawPCHContainerReader | Implements read operations for a raw pass-through PCH container |
| CRawPCHContainerWriter | Implements write operations for a raw pass-through PCH container |
| CRawStringFormat | See documentation of RawStringFormats |
| CReadPCHAndPreprocessAction | Preprocessor-based frontend action that also loads PCH files |
| CRecordDecl | Represents a struct/union/class |
| CRecordTypeLoc | Wrapper for source info for record types |
| CRecoveryExpr | Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expressions |
| CRecursiveASTVisitor | A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each node |
| CRecursiveCloneTypeIIHashConstraint | This constraint moves clones into clone groups of type II via hashing |
| CRecursiveCloneTypeIIVerifyConstraint | This constraint moves clones into clone groups of type II by comparing them |
| CRedeclarable | Provides common interface for the Decls that can be redeclared |
| CDeclLink | |
| Credecl_iterator | Iterates through all the redeclarations of the same decl |
| CRedeclarableTemplateDecl | Declaration of a redeclarable template |
| CCommonBase | |
| CSpecEntryTraits | |
| CSpecEntryTraits< FunctionTemplateSpecializationInfo > | |
| CSpecIterator | |
| CReducedBMIGenerator | |
| CRefCountedBase | |
| CReferenceType | Base for LValueReferenceType and RValueReferenceType |
| CReferenceTypeLoc | |
| CRelaxedLiveVariables | |
| CReplCodeCompleter | |
| CReplCompletionConsumer | |
| CRequiresExpr | C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on template arguments |
| CRequiresExprBodyDecl | Represents the body of a requires-expression |
| CResourceBindings | |
| CRetainTypeChecker | An inter-procedural analysis facility that detects CF types with the underlying pointer type |
| CReturnAdjustment | A return adjustment |
| CVirtualAdjustment | Holds the ABI-specific information about the virtual return adjustment, if needed |
| CReturnedValueConstructionContext | |
| CReturnStmt | ReturnStmt - This represents a return, optionally of an expression: return; return 4; |
| CReversePostOrderCompare | |
| CRewriteIncludesAction | |
| CRewriteImportsListener | |
| CRewriteMacrosAction | |
| CRewriteObjCAction | |
| CRewriter | Rewriter - This is the main interface to the rewrite buffers |
| CRewriteOptions | |
| CRewriteTestAction | |
| CRValueReferenceType | An rvalue reference type, per C++11 [dcl.ref] |
| CRValueReferenceTypeLoc | |
| CSanitizerKind | |
| CSanitizerMask | |
| CSanitizerMaskCutoffs | |
| CSanitizerSet | |
| CSanitizerSpecialCaseList | |
| CSanitizerSection | |
| CSARIFDiagnostic | |
| CSARIFDiagnosticPrinter | |
| CSarifDocumentWriter | This class handles creating a valid SARIF document given various input attributes |
| CSarifReportingConfiguration | A SARIF Reporting Configuration (reportingConfiguration) object contains properties for a SarifRule that can be configured at runtime before analysis begins |
| CSarifResult | A SARIF result (also called a "reporting item") is a unit of output produced when one of the tool's reportingDescriptor encounters a match on the file being analysed by the tool |
| CSarifRule | A SARIF rule (reportingDescriptor object) contains information that describes a reporting item generated by a tool |
| CSaveAndRestore | |
| CSavedStreamPosition | Helper class that saves the current stream position and then restores it when destroyed |
| CScope | Scope - A scope is a transient data structure that is used while parsing the program |
| CScratchBuffer | ScratchBuffer - This class exposes a simple interface for the dynamic construction of tokens |
| CSEHExceptStmt | |
| CSEHFinallyStmt | |
| CSEHLeaveStmt | Represents a __leave statement |
| CSEHTryStmt | |
| CSelector | Smart pointer class that efficiently represents Objective-C method names |
| CSelectorTable | This table allows us to fully hide how we implement multi-keyword caching |
| CSema | Sema - This implements semantic analysis and AST building for C |
| CActOnMemberAccessExtraArgs | |
| CAlignPackIncludeState | |
| CAlignPackInfo | |
| CArgPackSubstIndexRAII | RAII object used to change the argument pack substitution index within a Sema object |
| CBoundTypeDiagnoser | |
| CCheckNonDependentConversionsFlag | |
| CCheckTemplateArgumentInfo | |
| CCodeSynthesisContext | A context in which code is being synthesized (where a source location alone is not sufficient to identify the context) |
| CCompoundScopeRAII | A RAII object to enter scope of a compound statement |
| CConditionResult | |
| CConstraintEvalRAII | |
| CContextRAII | A RAII object to temporarily push a declaration context |
| CContextualImplicitConverter | Abstract base class used to perform a contextual implicit conversion from an expression to any type passing a filter |
| CCXXThisScopeRAII | RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers on the current class type |
| CDefaultedFunctionKind | For a defaulted function, the kind of defaulted function that it is |
| CDeferDiagsRAII | RAII class to control scope of DeferDiags |
| CDelayedDiagnostics | A class which encapsulates the logic for delaying diagnostics during parsing and other processing |
| CDelayedDiagnosticsState | |
| CExpressionEvaluationContextRecord | Data structure used to record current or nested expression evaluation contexts |
| CInitializationContext | |
| CExtParameterInfoBuilder | A helper class for building up ExtParameterInfos |
| CFormatStringInfo | |
| CFPFeaturesStateRAII | Records and restores the CurFPFeatures state on entry/exit of compound statements |
| CFpPragmaStackSaveRAII | |
| CFullExprArg | |
| CFunctionEffectDiff | |
| CFunctionEffectDiffVector | |
| CFunctionScopeRAII | An RAII helper that pops function a function scope on exit |
| CGlobalEagerInstantiationScope | |
| CICEConvertDiagnoser | |
| CImplicitExceptionSpecification | Helper class that collects exception specifications for implicitly-declared special member functions |
| CInheritedConstructorInfo | |
| CInstantiatingTemplate | A stack object to be created when performing template instantiation |
| CBuildingDeductionGuidesTag | |
| CConstraintNormalization | |
| CConstraintsCheck | |
| CConstraintSubstitution | |
| CExceptionSpecification | |
| CParameterMappingSubstitution | |
| CPartialOrderingTTP | |
| CLambdaScopeForCallOperatorInstantiationRAII | |
| CLateInstantiatedAttribute | |
| CLocalEagerInstantiationScope | |
| CNameClassification | |
| CNamedReturnInfo | |
| CNestedNameSpecInfo | Keeps information about an identifier in a nested-name-spec |
| CNonSFINAEContext | |
| COffsetOfComponent | |
| COriginalCallArg | Brief A function argument from which we performed template argument |
| CPendingPragmaInfo | Information from a C++ #pragma export, for a symbol that we haven't seen the declaration for yet |
| CPoppedFunctionScopeDeleter | Custom deleter to allow FunctionScopeInfos to be kept alive for a short time after they've been popped |
| CPragmaAttributeEntry | This an attribute introduced by #pragma clang attribute |
| CPragmaAttributeGroup | A push'd group of PragmaAttributeEntries |
| CPragmaClangSection | |
| CPragmaPackInfo | |
| CPragmaStack | |
| CSlot | |
| CPragmaStackSentinelRAII | |
| CProcessDeclAttributeOptions | |
| CRecursiveInstGuard | |
| CReferenceConversionsScope | |
| CRequiredTemplateKind | Whether and why a template name is required in this lookup |
| CSatisfactionStackResetRAII | |
| CSFINAEContextBase | |
| CSFINAETrap | RAII class used to determine whether SFINAE has trapped any errors that occur during template argument deduction |
| CSizelessTypeDiagnoser | A derivative of BoundTypeDiagnoser for which the diagnostic's type parameter is preceded by a 0/1 enum that is 1 if the type is sizeless |
| CSpecialMemberOverloadResult | SpecialMemberOverloadResult - The overloading result for a special member function |
| CSpecialMemberOverloadResultEntry | |
| CSynthesizedFunctionScope | RAII object to handle the state changes required to synthesize a function body |
| CTemplateCompareNewDeclInfo | |
| CTentativeAnalysisScope | RAII class used to indicate that we are performing provisional semantic analysis to determine the validity of a construct, so typo-correction and diagnostics in the immediate context (not within implicitly-instantiated templates) should be suppressed |
| CTypeDiagnoser | Abstract class used to diagnose incomplete types |
| CTypeTagData | |
| CVerifyICEDiagnoser | Abstract base class used for diagnosing integer constant expression violations |
| CSemaAMDGPU | |
| CSemaARM | |
| CSemaAVR | |
| CSemaBase | |
| CImmediateDiagBuilder | Helper class that creates diagnostics with optional template instantiation stacks |
| CSemaDiagnosticBuilder | A generic diagnostic builder for errors which may or may not be deferred |
| CSemaBPF | |
| CSemaCodeCompletion | |
| CCodeCompleteExpressionData | |
| CSemaConsumer | An abstract interface that should be implemented by clients that read ASTs and then require further semantic analysis of the entities in those ASTs |
| CSemaCUDA | |
| CCUDATargetContext | Define the current global CUDA host/device context where a function may be called |
| CCUDATargetContextRAII | |
| CFunctionDeclAndLoc | A pair of a canonical FunctionDecl and a SourceLocation |
| CSemaDirectX | |
| CSemaHexagon | |
| CSemaHLSL | |
| CSemaLoongArch | |
| CSemaM68k | |
| CSemaMIPS | |
| CSemaMSP430 | |
| CSemaNVPTX | |
| CSemaObjC | |
| CObjCArgInfo | |
| CSemaOpenACC | |
| CAssociatedStmtRAII | Helper type for the registration/assignment of constructs that need to 'know' about their parent constructs and hold a reference to them, such as Loop needing its parent construct |
| CLoopGangOnKernelTy | If there is a current 'active' loop construct with a 'gang' clause on a 'kernel' construct, this will have the source location for it, and the 'kernel kind' |
| CLoopInConstructRAII | Helper type to restore the state of various 'loop' constructs when we run into a loop (for, etc) inside the construct |
| CLoopWithoutSeqCheckingInfo | If there is a current 'active' loop construct that does NOT have a 'seq' clause on it, this has that source location and loop Directive 'kind' |
| COpenACCParsedClause | A type to represent all the data for an OpenACC Clause that has been parsed, but not yet created/semantically analyzed |
| CSemaOpenCL | |
| CSemaOpenMP | |
| CDeclareTargetContextInfo | |
| CMapInfo | |
| COMPIteratorData | Data structure for iterator expression |
| COpenMPVarListDataTy | Data used for processing a list of variables in OpenMP clauses |
| COpenMPReductionClauseModifiers | |
| CUsesAllocatorsData | Data for list of allocators |
| CSemaPPC | |
| CSemaPseudoObject | |
| CSemaRISCV | |
| CSemaSPIRV | |
| CSemaSwift | |
| CSemaSYCL | |
| CSemaSystemZ | |
| CSemaWasm | |
| CSemaX86 | |
| CShuffleVectorExpr | ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector |
| CSimpleASTReaderListener | ASTReaderListenter implementation to set SuggestedPredefines of ASTReader which is required to use a pch file |
| CSimpleConstructorInitializerConstructionContext | Represents construction into a field or a base class within a bigger object via a constructor initializer, eg |
| CSimpleProgramPointTag | |
| CSimpleReturnedValueConstructionContext | Represents a temporary object that is being immediately returned from a function by value, eg |
| CSimpleTemporaryObjectConstructionContext | Represents a temporary object that is not constructed for the purpose of being immediately copied/moved by an elidable copy/move-constructor |
| CSimpleTypoCorrection | |
| CSimpleVariableConstructionContext | Represents construction into a simple local variable, eg |
| CSizeOfPackExpr | Represents an expression that computes the length of a parameter pack |
| CSkipBodyInfo | |
| CSkippedRange | |
| CSmallString | |
| CSmallVector | |
| CSmallVectorImpl | |
| CSortIncludesOptions | Includes sorting options |
| CSourceLocation | Encodes a location in the source |
| CSourceLocationEncoding | Serialized encoding of SourceLocations without context |
| CSourceLocExpr | Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(), __builtin_FUNCSIG(), __builtin_FILE(), __builtin_FILE_NAME() or __builtin_source_location() |
| CSourceManager | This class handles loading and caching of source files into memory |
| CMemoryBufferSizes | |
| CSourceManagerForFile | SourceManager and necessary dependencies (e.g |
| CSourceMgrAdapter | An adapter that can be used to translate diagnostics from one or more llvm::SourceMgr instances to a , |
| CSourceRange | A trivial tuple used to represent a source range |
| CSpaceBeforeParensCustom | Precise control over the spacing before parentheses |
| CSpacesInLineComment | If true, spaces may be inserted into C style casts. This option is deprecated. See InCStyleCasts of SpacesInParensOptions |
| CSpacesInParensCustom | Precise control over the spacing in parentheses |
| Cspecific_attr_iterator | Specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are of a specific type |
| CSplitQualType | A std::pair-like structure for storing a qualified type split into its local qualifiers and its locally-unqualified type |
| CStackExhaustionHandler | |
| CStackFrameContext | It represents a stack frame of the call stack (based on CallEvent) |
| CStandaloneDiagnostic | Represents a StoredDiagnostic in a form that can be retained until after its SourceManager has been destroyed |
| CSourceOffsetRange | Represents a CharSourceRange within a StandaloneDiagnostic |
| CStandaloneFixIt | Represents a FixItHint within a StandaloneDiagnostic |
| CStandardConversionSequence | StandardConversionSequence - represents a standard conversion sequence (C++ 13.3.3.1.1) |
| CStaticAssertDecl | Represents a C++11 static_assert declaration |
| CStmt | Stmt - This represents one statement |
| CArrayOrMatrixSubscriptExprBitfields | |
| CArrayTypeTraitExprBitfields | |
| CAttributedStmtBitfields | |
| CBinaryOperatorBitfields | |
| CCallExprBitfields | |
| CCastExprBitfields | |
| CCastIterator | Iterator for iterating over Stmt * arrays that contain only T * |
| CCharacterLiteralBitfields | |
| CChooseExprBitfields | |
| CCoawaitExprBitfields | |
| CCompoundStmtBitfields | |
| CConstantExprBitfields | |
| CConvertVectorExprBitfields | |
| CCXXBoolLiteralExprBitfields | |
| CCXXConstructExprBitfields | |
| CCXXDefaultArgExprBitfields | |
| CCXXDefaultInitExprBitfields | |
| CCXXDeleteExprBitfields | |
| CCXXDependentScopeMemberExprBitfields | |
| CCXXFoldExprBitfields | |
| CCXXNewExprBitfields | |
| CCXXNoexceptExprBitfields | |
| CCXXNullPtrLiteralExprBitfields | |
| CCXXOperatorCallExprBitfields | |
| CCXXRewrittenBinaryOperatorBitfields | |
| CCXXScalarValueInitExprBitfields | |
| CCXXThisExprBitfields | |
| CCXXThrowExprBitfields | |
| CCXXUnresolvedConstructExprBitfields | |
| CDeclRefExprBitfields | |
| CDeferStmtBitfields | |
| CDependentScopeDeclRefExprBitfields | |
| CDoStmtBitfields | |
| CEmptyShell | A placeholder type used to construct an empty shell of a type, that will be filled in later (e.g., by some de-serialization) |
| CExprBitfields | |
| CExpressionTraitExprBitfields | |
| CExprWithCleanupsBitfields | |
| CFloatingLiteralBitfields | |
| CForStmtBitfields | |
| CGenericSelectionExprBitfields | |
| CGotoStmtBitfields | |
| CIfStmtBitfields | |
| CInitListExprBitfields | |
| CLabelStmtBitfields | |
| CLambdaExprBitfields | |
| CLoopControlStmtBitfields | |
| CMemberExprBitfields | |
| CNullStmtBitfields | |
| CObjCIndirectCopyRestoreExprBitfields | |
| COpaqueValueExprBitfields | |
| COverloadExprBitfields | |
| CPackIndexingExprBitfields | |
| CParenExprBitfields | |
| CParenListExprBitfields | |
| CPredefinedExprBitfields | |
| CPseudoObjectExprBitfields | |
| CRequiresExprBitfields | |
| CReturnStmtBitfields | |
| CShuffleVectorExprBitfields | |
| CSourceLocExprBitfields | |
| CStmtBitfields | |
| CStmtExprBitfields | |
| CStringLiteralBitfields | |
| CSubstNonTypeTemplateParmExprBitfields | |
| CSwitchCaseBitfields | |
| CSwitchStmtBitfields | |
| CTypeTraitExprBitfields | |
| CUnaryExprOrTypeTraitExprBitfields | |
| CUnaryOperatorBitfields | |
| CUnresolvedLookupExprBitfields | |
| CUnresolvedMemberExprBitfields | |
| CWhileStmtBitfields | |
| CStmtAttr | |
| CStmtExpr | StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}) |
| CStmtIterator | |
| CStmtIteratorBase | |
| CStmtIteratorImpl | |
| CStmtPoint | |
| CStmtSequence | Identifies a list of statements |
| CStmtVisitor | StmtVisitor - This class implements a simple visitor for Stmt subclasses |
| CStmtVisitorBase | StmtVisitorBase - This class implements a simple visitor for Stmt subclasses |
| CStoredDeclsList | An array of decls optimized for the common case of only containing one entry |
| CStoredDeclsMap | |
| CStoredDiagnostic | Represents a diagnostic in a form that can be retained until its corresponding source manager is destroyed |
| CStreamingDiagnostic | The streaming interface shared between DiagnosticBuilder and PartialDiagnostic |
| CStringLiteral | StringLiteral - This represents a string literal expression, e.g |
| CStringLiteralParser | StringLiteralParser - This decodes string escape characters and performs wide string analysis and Translation Phase #6 (concatenation of string literals) (C99 5.1.1.2p1) |
| CStringSizerHelper | |
| CStructuralEquivalenceContext | |
| CAttrScopedAttrEquivalenceContext | RAII helper that is used to suppress diagnostics during attribute equivalence checking |
| CSubobjectAdjustment | An adjustment to be made to the temporary created when emitting a reference binding, which accesses a particular subobject of that temporary |
| CDTB | |
| CP | |
| CSubstBuiltinTemplatePackTypeLoc | Wrapper for substituted template type parameters |
| CSubstNonTypeTemplateParmExpr | Represents a reference to a non-type template parameter that has been substituted with a template argument |
| CSubstNonTypeTemplateParmPackExpr | Represents a reference to a non-type template parameter pack that has been substituted with a non-template argument pack |
| CSubstPackTypeLoc | Abstract type representing delayed type pack expansions |
| CSubstTemplateTemplateParmPackStorage | A structure for storing an already-substituted template template parameter pack |
| CSubstTemplateTemplateParmStorage | A structure for storing the information associated with a substituted template template parameter |
| CSubstTemplateTypeParmPackTypeLoc | Wrapper for substituted template type parameters |
| CSubstTemplateTypeParmTypeLoc | Wrapper for substituted template type parameters |
| CSubsumptionChecker | SubsumptionChecker establishes subsumption between two set of constraints |
| CSuppressAccessChecks | A RAII object used to temporarily suppress access-like checking |
| CSVETypeFlags | Flags to identify the types for overloaded SVE builtins |
| CSwitchCase | |
| CSwitchStmt | SwitchStmt - This represents a 'switch' stmt |
| CSYCLKernelCallStmt | SYCLKernelCallStmt represents the transformation that is applied to the body of a function declared with the sycl_kernel_entry_point attribute |
| CSYCLKernelInfo | |
| CSYCLUniqueStableNameExpr | |
| CSyntaxOnlyAction | |
| CTagDecl | Represents the declaration of a struct/union/class/enum |
| CTagTypeLoc | |
| CTagTypeLocInfo | |
| CTargetCXXABI | The basic abstraction for the target C++ ABI |
| CTargetInfo | Exposes information about the current target |
| CAddlRegName | |
| CBranchProtectionInfo | |
| CConstraintInfo | |
| CGCCRegAlias | |
| CTargetOptions | Options for controlling the target |
| CTemplateArgument | Represents a template argument |
| CTemplateArgumentList | A template argument list |
| CTemplateArgumentListInfo | A convenient class for passing around template argument information |
| CTemplateArgumentLoc | Location wrapper for a TemplateArgument |
| CTemplateArgumentLocContainerIterator | Simple iterator that traverses the template arguments in a container that provides a getArgLoc() member function |
| Cpointer | |
| CTemplateArgumentLocInfo | Location information for a TemplateArgument |
| CTemplateTemplateArgLocInfo | |
| CTemplateArgumentLocInventIterator | Iterator adaptor that invents template argument location information for each of the template arguments in its underlying iterator |
| Cpointer | |
| CTemplateArgumentVisitor | A simple visitor class that helps create template argument visitors |
| CTemplateDecl | The base class of all kinds of template declarations (e.g., class, function, etc.) |
| CTemplateDeclInstantiator | |
| CTemplateDiffTypes | |
| CTemplateIdAnnotation | Information about a template-id annotation token |
| CTemplateInstantiationCallback | This is a base class for callbacks that will be notified at every template instantiation |
| CTemplateName | Represents a C++ template name within the type system |
| CTemplateNameLocInfo | |
| CTemplateParameterList | Stores a list of template parameters for a TemplateDecl and its derived classes |
| CTemplateParamObjectDecl | A template parameter object |
| CTemplateParmPosition | Defines the position of a template parameter within a template parameter list |
| CTemplatePartialOrderingContext | |
| CTemplateSpecCandidate | TemplateSpecCandidate - This is a generalization of OverloadCandidate which keeps track of template argument deduction failure info, when handling explicit specializations (and instantiations) of templates beyond function overloading |
| CTemplateSpecCandidateSet | TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations |
| CTemplateSpecializationLocInfo | |
| CTemplateSpecializationTypeLoc | |
| CTemplateTemplateParmDecl | TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in |
| CTemplateTypeParmDecl | Declaration of a template type parameter |
| CTemplateTypeParmTypeLoc | Wrapper for template type parameters |
| CTemplightDumpAction | |
| CTemporaryObjectConstructionContext | Represents a temporary object, eg |
| CTerminalColor | |
| CTestAST | The result of parsing a file specified by TestInputs |
| CTestClangConfig | A Clang configuration for end-to-end tests that can be converted to command line arguments for the driver |
| CTestInputs | Specifies a virtual source file to be parsed as part of a test |
| CTestModuleFileExtension | A module file extension used for testing purposes |
| CTextDiagnostic | Class to encapsulate the logic for formatting and printing a textual diagnostic message |
| CStyleRange | |
| CTextDiagnosticBuffer | |
| CTextDiagnosticPrinter | |
| CTextNodeDumper | |
| CTextTreeStructure | |
| CThisAdjustment | A this pointer adjustment |
| CVirtualAdjustment | Holds the ABI-specific information about the virtual this adjustment, if needed |
| CThreadFlow | A thread flow is a sequence of code locations that specify a possible path through a single thread of execution |
| CThunkInfo | The this pointer adjustment as well as an optional return adjustment for a thunk |
| CToken | Token - This structure provides full information about a lexed token |
| CTokenConcatenation | TokenConcatenation class, which answers the question of "Is it safe to emit two tokens without a whitespace between them, or would that cause implicit concatenation of the tokens? |
| CTokenLexer | TokenLexer - This implements a lexer that returns tokens from a macro body or token stream instead of lexing from a character buffer |
| CTokenRewriter | |
| CTokenRole | |
| CTokenValue | Stores token information for comparing actual tokens with predefined values |
| CTopLevelStmtDecl | A declaration that models statements at global scope |
| CTransferrableTargetInfo | Fields controlling how types are laid out in memory; these may need to be copied for targets like AMDGPU that base their ABIs on an auxiliary CPU target |
| CTranslationUnitDecl | The top declaration context |
| CTraversalKindScope | |
| CTreeTransform | A semantic tree transformation that allows one to transform one abstract syntax tree into another |
| CTemporaryBase | RAII object that temporarily sets the base location and entity used for reporting diagnostics in types |
| CTrivialFunctionAnalysis | An inter-procedural analysis facility that detects functions with "trivial" behavior with respect to reference counting, such as simple field getters |
| CTrivialFunctionAnalysisVisitor | |
| CTrivialModuleLoader | A module loader that doesn't know how to create or load modules |
| CType | The base class of the type hierarchy |
| CArrayTypeBitfields | |
| CAttributedTypeBitfields | |
| CAutoTypeBitfields | |
| CBuiltinTypeBitfields | |
| CConstantArrayTypeBitfields | |
| CCountAttributedTypeBitfields | |
| CFunctionTypeBitfields | FunctionTypeBitfields store various bits belonging to FunctionProtoType |
| CKeywordWrapperBitfields | |
| CObjCObjectTypeBitfields | |
| CPackExpansionTypeBitfields | |
| CPredefinedSugarTypeBitfields | |
| CReferenceTypeBitfields | |
| CSubstPackTypeBitfields | |
| CSubstTemplateTypeParmTypeBitfields | |
| CTagTypeBitfields | |
| CTemplateSpecializationTypeBitfields | |
| CTemplateTypeParmTypeBitfields | |
| CTypedefBitfields | |
| CTypeOfBitfields | |
| CUnresolvedUsingBitfields | |
| CUsingBitfields | |
| CVectorTypeBitfields | |
| CTypeAliasDecl | Represents the declaration of a typedef-name via a C++11 alias-declaration |
| CTypeAliasTemplateDecl | Declaration of an alias template |
| CTypeAttr | |
| CTypeConstraint | Models the abbreviated syntax to constrain a template type parameter: template <convertible_to<string> T> void print(T object); ~~~~~~~~~~~~~~~~~~~~~~ Semantically, this adds an "immediately-declared constraint" with extra arg: requires convertible_to<T, string> |
| CTypeCoupledDeclRefInfo | [BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by attribute and the likes |
| CTypeDecl | Represents a declaration of a type |
| CTypedefDecl | Represents the declaration of a typedef-name via the 'typedef' type specifier |
| CTypedefNameDecl | Base class for declarations which introduce a typedef-name |
| CTypedefType | |
| CTypedefTypeLoc | Wrapper for source info for typedefs |
| CTypeDependenceScope | |
| CTypeInfo | |
| CTypeInfoChars | |
| CTypeInfoLValue | Symbolic representation of typeid(T) for some type T |
| CTypeLoc | Base wrapper for a particular "section" of type source info |
| CTypeLocBuilder | |
| CTypeLocReader | |
| CTypeLocVisitor | |
| CTypeOfExprType | Represents a typeof (or typeof) expression (a C23 feature and GCC extension) or a typeof_unqual expression (a C23 feature) |
| CTypeOfExprTypeLoc | |
| CTypeOfExprTypeLocInfo | |
| CTypeofLikeTypeLoc | |
| CTypeofLocInfo | |
| CTypeOfTypeLoc | |
| CTypeOfTypeLocInfo | |
| CTypePropertyCache | The type-property cache |
| CTypeSourceInfo | A container of type source information |
| CTypeSpecLocInfo | |
| CTypeSpecTypeLoc | A reasonable base class for TypeLocs that correspond to types that are written as a type-specifier |
| CTypeTraitExpr | A type trait used in the implementation of various C++11 and Library TR1 trait templates |
| CTypeVisitor | An operation on a type |
| CTypeWithKeyword | A helper class for Type nodes having an ElaboratedTypeKeyword |
| CTypoCorrection | Simple class containing the result of Sema::CorrectTypo |
| CTypoCorrectionConsumer | |
| CUnaryExprOrTypeTraitExpr | UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand |
| CUnaryOperator | UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions |
| CUnaryTransformTypeLoc | |
| CUnaryTransformTypeLocInfo | |
| CUncommonTemplateNameStorage | Implementation class used to describe either a set of overloaded template names or an already-substituted template template parameter pack |
| CBitsTag | |
| CUndefMacroDirective | A directive for an undefined macro |
| CUnexpandedInfo | |
| CUninitUse | A use of a variable, which might be uninitialized |
| CBranch | |
| CUninitVariablesAnalysisStats | |
| CUninitVariablesHandler | |
| CUnionOpaquePtr | UnionOpaquePtr - A version of OpaquePtr suitable for membership in a union |
| CUniqueVirtualMethod | Uniquely identifies a virtual method within a class hierarchy by the method itself and a class subobject number |
| CUnnamedGlobalConstantDecl | An artificial decl, representing a global anonymous constant value which is uniquified by value within a translation unit |
| CUnqualifiedId | Represents a C++ unqualified-id that has been parsed |
| COFI | |
| CUnqualTypeLoc | Wrapper of type source information for a type with no direct qualifiers |
| CUnresolvedLookupExpr | A reference to a name which we were able to look up during parsing but could not resolve to a specific declaration |
| CUnresolvedMemberExpr | Represents a C++ member access expression for which lookup produced a set of overloaded functions |
| CUnresolvedSet | A set of unresolved declarations |
| CUnresolvedSetImpl | A set of unresolved declarations |
| CUnresolvedSetIterator | The iterator over UnresolvedSets |
| CUnresolvedUsingIfExistsDecl | This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) failed to resolve to a known declaration |
| CUnresolvedUsingType | Represents the dependent type named by a dependently-scoped typename using declaration, e.g |
| CUnresolvedUsingTypeLoc | Wrapper for source info for unresolved typename using decls |
| CUnresolvedUsingTypenameDecl | Represents a dependent using declaration which was marked with typename |
| CUnresolvedUsingValueDecl | Represents a dependent using declaration which was not marked with typename |
| CUnsafeBufferUsageHandler | The interface that lets the caller handle unsafe buffer usage analysis results by overriding this class's handle... methods |
| CUnsignedOrNone | |
| CUnsubstitutedConstraintSatisfactionCacheResult | |
| CUpdateOnReturn | |
| CUsedDeclVisitor | |
| CUserDefinedConversionSequence | UserDefinedConversionSequence - Represents a user-defined conversion sequence (C++ 13.3.3.1.2) |
| CUserDefinedLiteral | A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit.ext]) |
| CUsingDecl | Represents a C++ using-declaration |
| CUsingDirectiveDecl | Represents C++ using-directive |
| CUsingEnumDecl | Represents a C++ using-enum-declaration |
| CUsingPackDecl | Represents a pack of using declarations that a single using-declarator pack-expanded into |
| CUsingShadowDecl | Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration or using-enum-declaration to achieve the desired lookup semantics |
| CUsingType | |
| CUsingTypeLoc | Wrapper for source info for types used via transparent aliases |
| CUsualDeleteParams | The parameters to pass to a usual operator delete |
| CVAArgExpr | Represents a call to the builtin function __builtin_va_arg |
| CValue | |
| CconvertFwd | |
| CconvertFwd< T * > | |
| CValueDecl | Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it is a function designator) or an enum constant |
| CValueRef | |
| CValueStmt | Represents a statement that could possibly have a value and type |
| CVAOptDefinitionContext | A class for tracking whether we're inside a VA_OPT during a traversal of the tokens of a variadic macro definition |
| CVAOptExpansionContext | A class for tracking whether we're inside a VA_OPT during a traversal of the tokens of a macro during macro expansion |
| CVarDecl | Represents a variable declaration or definition |
| CNonParmVarDeclBitfields | |
| CParmVarDeclBitfields | |
| CVariableArrayType | Represents a C array with a specified size that is not an integer-constant-expression |
| CVariableArrayTypeLoc | |
| CVariableConstructionContext | An abstract base class for local variable constructors |
| CVariableGroupsManager | |
| CVariablePattern | Analyzes the pattern of the referenced variables in a statement |
| CSuspiciousClonePair | Describes two clones that reference their variables in a different pattern which could indicate a programming error |
| CSuspiciousCloneInfo | Utility class holding the relevant information about a single clone in this pair |
| CVariadicMacroScopeGuard | An RAII class that tracks when the Preprocessor starts and stops lexing the definition of a (ISO C/C++) variadic macro |
| CVarTemplateDecl | Declaration of a variable template |
| CCommon | Data that is common to all of the declarations of a given variable template |
| CVarTemplatePartialSpecializationDecl | |
| CVarTemplateSpecializationDecl | Represents a variable template specialization, which refers to a variable template with a given set of template arguments |
| CVectorType | Represents a GCC generic vector type |
| CVectorTypeLoc | |
| CVectorTypeLocInfo | |
| CVerifyDiagnosticConsumer | VerifyDiagnosticConsumer - Create a diagnostic client which will use markers in the input source to check that all the emitted diagnostics match those expected |
| CDirective | Directive - Abstract class representing a parsed verify directive |
| CExpectedData | ExpectedData - owns directive objects and deletes on destructor |
| CMarkerTracker | |
| CParsingState | |
| CVerifyPCHAction | |
| CVirtSpecifiers | Represents a C++11 virt-specifier-seq |
| CVirtualBaseInfo | All virtual base related information about a given record decl |
| CVisibilityMacroDirective | A directive for setting the module visibility of a macro |
| CVisibleDeclConsumer | Consumes visible declarations found when searching for all visible names within a given scope or context |
| CVisibleLookupBlockOffsets | |
| CVisibleModuleSet | A set of visible modules |
| CVPtrInfo | Holds information about the inheritance path to a virtual base or function table pointer |
| CVTableComponent | Represents a single component in a vtable |
| CVTableContextBase | |
| CVTableLayout | |
| CAddressPointLocation | |
| CVTTBuilder | Class for building VTT layout information |
| CVTTComponent | |
| CVTTVTable | |
| CWasmIncrementalExecutor | |
| CWeakInfo | Captures information about a #pragma weak directive |
| CDenseMapInfoByAliasOnly | |
| CWhileStmt | WhileStmt - This represents a 'while' stmt |
| CWrapperFrontendAction | A frontend action which simply wraps some other runtime-specified frontend action |
| CWrappingExtractAPIAction | Wrap ExtractAPIAction on top of a pre-existing action |
| CWrittenBuiltinSpecs | Structure that packs information about the type specifiers that were written in a particular type specifier sequence |
| CWTOCompare | |
| CWTODataflowWorklist | A worklist implementation for forward dataflow analysis based on a weak topological ordering of the nodes |
| CXRayFunctionFilter | |
| CXRayInstrSet | |
| Nhlsl | |
| N__detail | |
| Cenable_if | |
| Cenable_if< true, T > | |
| Cis_arithmetic | |
| Cis_same | |
| Cis_same< T, T > | |
| Nvk | |
| Cintegral_constant | |
| CLiteral | |
| Nlibc_func_matchers | |
| CLibcFunNamePrefixSuffixParser | |
| Nlld | |
| CDriverDef | |
| CResult | |
| Nllvm | Diagnostic wrappers for TextAPI types for error reporting |
| Ncl | |
| Cparser< clang::ParsedSourceLocation > | Command-line option parser that parses source locations |
| NIDFCalculatorDetail | |
| CChildrenGetterTy< clang::CFGBlock, IsPostDom > | Specialize ChildrenGetterTy to skip nullpointer successors |
| Nyaml | |
| CDocumentListTraits< std::vector< FormatStyle > > | |
| CMappingContextTraits< custom_flag::Declaration, llvm::SmallSet< std::string, 32 > > | |
| CMappingContextTraits< custom_flag::ValueDetail, llvm::SmallSet< std::string, 32 > > | |
| CMappingTraits< clang::tooling::AtomicChange > | Specialized MappingTraits to describe how an AtomicChange is (de)serialized |
| CMappingTraits< clang::tooling::Diagnostic > | |
| CNormalizedDiagnostic | Helper to (de)serialize a Diagnostic since we don't have direct access to its data members |
| CMappingTraits< clang::tooling::DiagnosticMessage > | |
| CMappingTraits< clang::tooling::FileByteRange > | |
| CMappingTraits< clang::tooling::IncludeStyle::IncludeCategory > | |
| CMappingTraits< clang::tooling::Replacement > | Specialized MappingTraits to describe how a Replacement is (de)serialized |
| CNormalizedReplacement | Helper to (de)serialize a Replacement since we don't have direct access to its data members |
| CMappingTraits< clang::tooling::TranslationUnitDiagnostics > | Specialized MappingTraits to describe how a TranslationUnitDiagnostics is (de)serialized |
| CMappingTraits< clang::tooling::TranslationUnitReplacements > | Specialized MappingTraits to describe how a TranslationUnitReplacements is (de)serialized |
| CMappingTraits< Class > | |
| CMappingTraits< EnumConstant > | |
| CMappingTraits< Field > | |
| CMappingTraits< FormatStyle > | |
| CMappingTraits< FormatStyle::AlignConsecutiveStyle > | |
| CMappingTraits< FormatStyle::BraceWrappingFlags > | |
| CMappingTraits< FormatStyle::IntegerLiteralSeparatorStyle > | |
| CMappingTraits< FormatStyle::KeepEmptyLinesStyle > | |
| CMappingTraits< FormatStyle::NumericLiteralCaseStyle > | |
| CMappingTraits< FormatStyle::RawStringFormat > | |
| CMappingTraits< FormatStyle::ShortCaseStatementsAlignmentStyle > | |
| CMappingTraits< FormatStyle::SortIncludesOptions > | |
| CMappingTraits< FormatStyle::SpaceBeforeParensCustom > | |
| CMappingTraits< FormatStyle::SpacesInLineComment > | |
| CMappingTraits< FormatStyle::SpacesInParensCustom > | |
| CMappingTraits< FormatStyle::TrailingCommentsAlignmentStyle > | |
| CMappingTraits< Function > | |
| CMappingTraits< GlobalVariable > | |
| CMappingTraits< Method > | |
| CMappingTraits< Module > | |
| CMappingTraits< MultilibGroupSerialization > | |
| CMappingTraits< MultilibSerialization > | |
| CMappingTraits< MultilibSet::FlagMatcher > | |
| CMappingTraits< MultilibSetSerialization > | |
| CMappingTraits< Namespace > | |
| CMappingTraits< NormalizedAtomicChange > | Specialized MappingTraits to describe how an AtomicChange is (de)serialized |
| CMappingTraits< Param > | |
| CMappingTraits< Property > | |
| CMappingTraits< Tag > | |
| CMappingTraits< TaintConfiguration > | |
| CMappingTraits< TaintConfiguration::Filter > | |
| CMappingTraits< TaintConfiguration::Propagation > | |
| CMappingTraits< TaintConfiguration::Sink > | |
| CMappingTraits< TemplightEntry > | |
| CMappingTraits< Typedef > | |
| CMappingTraits< Versioned > | |
| CScalarEnumerationTraits< APIAvailability > | |
| CScalarEnumerationTraits< BracketAlignmentStyle > | |
| CScalarEnumerationTraits< clang::tooling::Diagnostic::Level > | |
| CScalarEnumerationTraits< clang::tooling::IncludeStyle::IncludeBlocksStyle > | |
| CScalarEnumerationTraits< clang::tooling::IncludeStyle::MainIncludeCharDiscriminator > | |
| CScalarEnumerationTraits< EnumConvenienceAliasKind > | |
| CScalarEnumerationTraits< EnumExtensibilityKind > | |
| CScalarEnumerationTraits< FactoryAsInitKind > | |
| CScalarEnumerationTraits< FormatStyle::ArrayInitializerAlignmentStyle > | |
| CScalarEnumerationTraits< FormatStyle::AttributeBreakingStyle > | |
| CScalarEnumerationTraits< FormatStyle::BinaryOperatorStyle > | |
| CScalarEnumerationTraits< FormatStyle::BinPackParametersStyle > | |
| CScalarEnumerationTraits< FormatStyle::BinPackStyle > | |
| CScalarEnumerationTraits< FormatStyle::BitFieldColonSpacingStyle > | |
| CScalarEnumerationTraits< FormatStyle::BraceBreakingStyle > | |
| CScalarEnumerationTraits< FormatStyle::BracedListStyle > | |
| CScalarEnumerationTraits< FormatStyle::BraceWrappingAfterControlStatementStyle > | |
| CScalarEnumerationTraits< FormatStyle::BreakBeforeConceptDeclarationsStyle > | |
| CScalarEnumerationTraits< FormatStyle::BreakBeforeInlineASMColonStyle > | |
| CScalarEnumerationTraits< FormatStyle::BreakBeforeNoexceptSpecifierStyle > | |
| CScalarEnumerationTraits< FormatStyle::BreakBinaryOperationsStyle > | |
| CScalarEnumerationTraits< FormatStyle::BreakConstructorInitializersStyle > | |
| CScalarEnumerationTraits< FormatStyle::BreakInheritanceListStyle > | |
| CScalarEnumerationTraits< FormatStyle::BreakTemplateDeclarationsStyle > | |
| CScalarEnumerationTraits< FormatStyle::DAGArgStyle > | |
| CScalarEnumerationTraits< FormatStyle::DefinitionReturnTypeBreakingStyle > | |
| CScalarEnumerationTraits< FormatStyle::EmptyLineAfterAccessModifierStyle > | |
| CScalarEnumerationTraits< FormatStyle::EmptyLineBeforeAccessModifierStyle > | |
| CScalarEnumerationTraits< FormatStyle::EnumTrailingCommaStyle > | |
| CScalarEnumerationTraits< FormatStyle::EscapedNewlineAlignmentStyle > | |
| CScalarEnumerationTraits< FormatStyle::IndentExternBlockStyle > | |
| CScalarEnumerationTraits< FormatStyle::JavaScriptQuoteStyle > | |
| CScalarEnumerationTraits< FormatStyle::LambdaBodyIndentationKind > | |
| CScalarEnumerationTraits< FormatStyle::LanguageKind > | |
| CScalarEnumerationTraits< FormatStyle::LanguageStandard > | |
| CScalarEnumerationTraits< FormatStyle::LineEndingStyle > | |
| CScalarEnumerationTraits< FormatStyle::NamespaceIndentationKind > | |
| CScalarEnumerationTraits< FormatStyle::NumericLiteralComponentStyle > | |
| CScalarEnumerationTraits< FormatStyle::OperandAlignmentStyle > | |
| CScalarEnumerationTraits< FormatStyle::PackConstructorInitializersStyle > | |
| CScalarEnumerationTraits< FormatStyle::PointerAlignmentStyle > | |
| CScalarEnumerationTraits< FormatStyle::PPDirectiveIndentStyle > | |
| CScalarEnumerationTraits< FormatStyle::QualifierAlignmentStyle > | |
| CScalarEnumerationTraits< FormatStyle::ReferenceAlignmentStyle > | |
| CScalarEnumerationTraits< FormatStyle::ReflowCommentsStyle > | |
| CScalarEnumerationTraits< FormatStyle::RemoveParenthesesStyle > | |
| CScalarEnumerationTraits< FormatStyle::RequiresClausePositionStyle > | |
| CScalarEnumerationTraits< FormatStyle::RequiresExpressionIndentationKind > | |
| CScalarEnumerationTraits< FormatStyle::ReturnTypeBreakingStyle > | |
| CScalarEnumerationTraits< FormatStyle::SeparateDefinitionStyle > | |
| CScalarEnumerationTraits< FormatStyle::ShortBlockStyle > | |
| CScalarEnumerationTraits< FormatStyle::ShortFunctionStyle > | |
| CScalarEnumerationTraits< FormatStyle::ShortIfStyle > | |
| CScalarEnumerationTraits< FormatStyle::ShortLambdaStyle > | |
| CScalarEnumerationTraits< FormatStyle::SortJavaStaticImportOptions > | |
| CScalarEnumerationTraits< FormatStyle::SortUsingDeclarationsOptions > | |
| CScalarEnumerationTraits< FormatStyle::SpaceAroundPointerQualifiersStyle > | |
| CScalarEnumerationTraits< FormatStyle::SpaceBeforeParensStyle > | |
| CScalarEnumerationTraits< FormatStyle::SpaceInEmptyBracesStyle > | |
| CScalarEnumerationTraits< FormatStyle::SpacesInAnglesStyle > | |
| CScalarEnumerationTraits< FormatStyle::SpacesInParensStyle > | |
| CScalarEnumerationTraits< FormatStyle::TrailingCommaStyle > | |
| CScalarEnumerationTraits< FormatStyle::TrailingCommentsAlignmentKinds > | |
| CScalarEnumerationTraits< FormatStyle::UseTabStyle > | |
| CScalarEnumerationTraits< FormatStyle::WrapNamespaceBodyWithEmptyLinesStyle > | |
| CScalarEnumerationTraits< MethodKind > | |
| CScalarEnumerationTraits< MultilibGroupType > | |
| CScalarEnumerationTraits< NullabilityKind > | |
| CScalarEnumerationTraits< RetainCountConventionKind > | |
| CScalarEnumerationTraits< SwiftNewTypeKind > | |
| CScalarEnumerationTraits< SwiftSafetyKind > | |
| CScalarEnumerationTraits< TaintConfiguration::VariadicType > | |
| CArrayRef | |
| Ccast_convert_val< ::clang::DeclContext, FromTy *, FromTy * > | |
| Ccast_convert_val< ::clang::DeclContext, FromTy, FromTy > | Implement cast_convert_val for Decl -> DeclContext conversions |
| Ccast_convert_val< const ::clang::DeclContext, FromTy *, FromTy * > | |
| Ccast_convert_val< const ::clang::DeclContext, FromTy, FromTy > | |
| Ccast_convert_val< ToTy, ::clang::DeclContext *, ::clang::DeclContext * > | |
| Ccast_convert_val< ToTy, ::clang::DeclContext, ::clang::DeclContext > | |
| Ccast_convert_val< ToTy, const ::clang::DeclContext *, const ::clang::DeclContext * > | |
| Ccast_convert_val< ToTy, const ::clang::DeclContext, const ::clang::DeclContext > | Cast<T>(DeclContext*) |
| CCastInfo< clang::OMPLoopTransformationDirective, clang::Stmt * > | |
| CCastInfo< clang::OMPLoopTransformationDirective, const clang::Stmt * > | |
| CCastInfo< To, From, std::enable_if_t< std::is_base_of<::clang::ento::SVal, From >::value > > | |
| CCastInfo< ToTy, ::clang::extractapi::RecordContext * > | |
| CCastInfo< ToTy, const ::clang::extractapi::RecordContext * > | |
| CCastInfo<::clang::extractapi::RecordContext, const FromTy * > | |
| CCastInfo<::clang::extractapi::RecordContext, FromTy * > | |
| CDenseMapInfo< CatchHandlerType > | |
| CDenseMapInfo< clang::api_notes::ContextTableKey > | |
| CDenseMapInfo< clang::api_notes::SingleDeclTableKey > | |
| CDenseMapInfo< clang::api_notes::StoredObjCSelector > | |
| CDenseMapInfo< clang::APValue::LValueBase > | |
| CDenseMapInfo< clang::ASTNodeKind > | |
| CDenseMapInfo< clang::BaseSubobject > | |
| CDenseMapInfo< clang::CallGraphNode::CallRecord > | |
| CDenseMapInfo< clang::CanonicalDeclPtr< decl_type > > | |
| CDenseMapInfo< clang::CanQualType > | |
| CDenseMapInfo< clang::CharUnits > | |
| CDenseMapInfo< clang::CodeGen::TBAAAccessInfo > | |
| CDenseMapInfo< clang::dataflow::Atom > | |
| CDenseMapInfo< clang::DeclarationName > | Define DenseMapInfo so that DeclarationNames can be used as keys in DenseMap and DenseSets |
| CDenseMapInfo< clang::dependencies::ModuleID > | |
| CDenseMapInfo< clang::DirectoryEntryRef > | Specialisation of DenseMapInfo for DirectoryEntryRef |
| CDenseMapInfo< clang::DynTypedNode > | |
| CDenseMapInfo< clang::FileEntryRef > | Specialisation of DenseMapInfo for FileEntryRef |
| CDenseMapInfo< clang::FileID, void > | Define DenseMapInfo so that FileID's can be used as keys in DenseMap and DenseSets |
| CDenseMapInfo< clang::GlobalDecl > | |
| CDenseMapInfo< clang::GlobalDeclID > | |
| CDenseMapInfo< clang::lifetimes::internal::utils::ID< Tag > > | |
| CDenseMapInfo< clang::LocalDeclID > | |
| CDenseMapInfo< clang::NestedNameSpecifier > | |
| CDenseMapInfo< clang::NestedNameSpecifierLoc > | |
| CDenseMapInfo< clang::ProgramPoint > | |
| CDenseMapInfo< clang::QualType > | |
| CDenseMapInfo< clang::Selector > | Define DenseMapInfo so that Selectors can be used as keys in DenseMap and DenseSets |
| CDenseMapInfo< clang::SemaCUDA::FunctionDeclAndLoc > | |
| CDenseMapInfo< clang::serialization::DeclarationNameKey > | |
| CDenseMapInfo< clang::SourceLocation, void > | Define DenseMapInfo so that SourceLocation's can be used as keys in DenseMap and DenseSet |
| CDenseMapInfo< clang::SourceRange > | |
| CDenseMapInfo< clang::tok::PPKeywordKind > | |
| CDenseMapInfo< clang::tooling::stdlib::Header > | |
| CDenseMapInfo< clang::tooling::stdlib::Symbol > | |
| CDenseMapInfo< DecompositionDeclName > | |
| CDenseMapInfo< llvm::FoldingSetNodeID > | |
| CDenseMapInfo< ObjCSummaryKey > | |
| CDenseMapInfo< ObjectUnderConstruction > | |
| CDenseMapInfo< PrivateMethodKey > | |
| CDenseMapInfo< ScalableVecTyKey > | |
| CDOTGraphTraits< const CallGraph * > | |
| CDOTGraphTraits< const CFG * > | |
| CDOTGraphTraits< const Stmt * > | |
| CDOTGraphTraits< ExplodedGraph * > | |
| CDOTGraphTraits< ModuleManager > | |
| Cenum_iteration_traits< clang::OpenMPDefaultmapClauseKind > | |
| CExpected | |
| CFoldingSetTrait | |
| CFoldingSetTrait< AllocKind > | |
| CFoldingSetTrait< ArgEffect > | |
| CFoldingSetTrait< clang::SourceLocation, void > | |
| CFoldingSetTrait< ObjectState > | |
| CFoldingSetTrait< RetEffect > | |
| CFoldingSetTrait< SValData > | |
| CFoldingSetTrait< SValPair > | |
| Cformat_provider< FindUninitializedField::FieldChainTy > | |
| Cformat_provider< ValueDescStr > | |
| CGraphTraits< ::clang::CFG * > | |
| CGraphTraits< ::clang::CFGBlock * > | |
| CGraphTraits< clang::CallGraph * > | |
| CGraphTraits< clang::CallGraphNode * > | |
| CGraphTraits< clang::CFGDomTree * > | |
| CGraphTraits< clang::DomTreeNode * > | DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterators |
| CGraphTraits< clang::ento::ExplodedGraph * > | |
| CGraphTraits< clang::Stmt * > | |
| CGraphTraits< const ::clang::CFG * > | |
| CGraphTraits< const ::clang::CFGBlock * > | |
| CGraphTraits< const clang::CallGraph * > | |
| CGraphTraits< const clang::CallGraphNode * > | |
| CGraphTraits< const clang::Stmt * > | |
| CGraphTraits< Inverse< ::clang::CFG * > > | |
| CGraphTraits< Inverse< ::clang::CFGBlock * > > | |
| CGraphTraits< Inverse< const ::clang::CFG * > > | |
| CGraphTraits< Inverse< const ::clang::CFGBlock * > > | |
| CGraphTraits< ModuleManager > | |
| CImutContainerInfo< clang::ento::SymbolRef > | |
| CIntrusiveRefCntPtr | |
| CIntrusiveRefCntPtrInfo | |
| CIntrusiveRefCntPtrInfo< const clang::ento::ProgramState > | |
| Cisa_impl< To, ::clang::DeclContext > | Isa<T>(DeclContext*) |
| CLinkInModulesPass | Create and return a pass that links in Moduels from a provided BackendConsumer to a given primary Module |
| CMutableArrayRef | |
| CPointerLikeTypeTraits | |
| CPointerLikeTypeTraits< ::clang::CodeGen::ConstantInitBuilderBase * > | |
| CPointerLikeTypeTraits< ::clang::CodeGen::ConstantInitFuture > | |
| CPointerLikeTypeTraits< ::clang::ExtQuals * > | |
| CPointerLikeTypeTraits< ::clang::Type * > | |
| CPointerLikeTypeTraits< clang::CanonicalDeclPtr< decl_type > > | |
| CPointerLikeTypeTraits< clang::CanQual< T > > | |
| CPointerLikeTypeTraits< clang::DeclarationName > | |
| CPointerLikeTypeTraits< clang::DeclGroupRef > | |
| CPointerLikeTypeTraits< clang::DirectoryEntryRef > | |
| CPointerLikeTypeTraits< clang::DynamicAllocLValue > | |
| CPointerLikeTypeTraits< clang::Expr * > | |
| CPointerLikeTypeTraits< clang::LazyGenerationalUpdatePtr< Owner, T, Update > > | Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be placed into a PointerUnion |
| CPointerLikeTypeTraits< clang::NestedNameSpecifier > | |
| CPointerLikeTypeTraits< clang::OpaquePtr< T > > | |
| CPointerLikeTypeTraits< clang::QualType > | |
| CPointerLikeTypeTraits< clang::Selector > | |
| CPointerLikeTypeTraits< clang::TemplateName > | The clang::TemplateName class is effectively a pointer |
| CPointerLikeTypeTraits< clang::TypeInfoLValue > | |
| CPointerLikeTypeTraits<::clang::NamedDecl * > | |
| CRefCountedBase | |
| CSaveAndRestore | |
| CScalableVecTyKey | |
| Csimplify_type< ::clang::CanQual< T > > | Implement simplify_type for CanQual<T>, so that we can dyn_cast from CanQual<T> to a specific Type class |
| Csimplify_type< ::clang::CFGTerminator > | Implement simplify_type for CFGTerminator, so that we can dyn_cast from CFGTerminator to a specific Stmt class |
| Csimplify_type< ::clang::QualType > | Implement simplify_type for QualType, so that we can dyn_cast from QualType to a specific Type class |
| Csimplify_type< clang::ento::CallEventRef< T > > | |
| CSmallPtrSet | |
| CSmallSetVector | |
| CSmallString | |
| CSmallVector | |
| CSmallVectorImpl | |
| Nstd | |
| Cis_error_code_enum< clang::BuildPreambleError > | |
| Cis_error_code_enum< clang::format::ParseError > | |
| Cis_error_code_enum< clang::serialized_diags::SDError > | |
| Citerator_traits< llvm::ImmutableList< CritSectionMarker >::iterator > | |
| C__clang_cuda_enable_if | |
| C__clang_cuda_enable_if< true, __T > | |
| C__clang_Interpreter_NewTag | |
| C__cuda_builtin_blockDim_t | |
| C__cuda_builtin_blockIdx_t | |
| C__cuda_builtin_gridDim_t | |
| C__cuda_builtin_threadIdx_t | |
| C_Unwind_Exception | |
| CArgType | |
| CArrayRef | |
| CASTContext | Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic analysis of a file |
| CBuiltinVectorTypeInfo | |
| CCUDAConstantEvalContext | |
| CCUDAConstantEvalContextRAII | |
| CCXXRecordDeclRelocationInfo | |
| CSectionInfo | |
| Catomic_flag | |
| CBase | |
| Cbasic_parser | |
| CBitwiseShiftChecker | |
| CBuiltinTypeDeclBuilder | |
| CCallableVisitor | |
| CCastIsPossible | |
| CCGBuilderBaseTy | |
| CCompareNode | |
| CConstOMPClauseVisitor | |
| CConstStrippingForwardingCast | |
| CConversionSpecifier | |
| CCPUSuffix | |
| CCXCodeCompleteResults | Contains the results of code-completion |
| CCXComment | A parsed comment |
| CCXCompletionResult | A single result of code completion |
| CCXCursor | A cursor representing some element in the abstract syntax tree for a translation unit |
| CCXCursorAndRangeVisitor | |
| CCXFileUniqueID | Uniquely identifies a CXFile, that refers to the same underlying file, across an indexing session |
| CCXIdxAttrInfo | |
| CCXIdxBaseClassInfo | |
| CCXIdxContainerInfo | |
| CCXIdxCXXClassDeclInfo | |
| CCXIdxDeclInfo | |
| CCXIdxEntityInfo | |
| CCXIdxEntityRefInfo | Data for IndexerCallbacks::indexEntityReference |
| CCXIdxIBOutletCollectionAttrInfo | |
| CCXIdxImportedASTFileInfo | Data for IndexerCallbacks::importedASTFile |
| CCXIdxIncludedFileInfo | Data for ppIncludedFile callback |
| CCXIdxLoc | Source location passed to index callbacks |
| CCXIdxObjCCategoryDeclInfo | |
| CCXIdxObjCContainerDeclInfo | |
| CCXIdxObjCInterfaceDeclInfo | |
| CCXIdxObjCPropertyDeclInfo | |
| CCXIdxObjCProtocolRefInfo | |
| CCXIdxObjCProtocolRefListInfo | |
| CCXIndexOptions | Index initialization options |
| CCXPlatformAvailability | Describes the availability of a given entity on a particular platform, e.g., a particular class might only be available on Mac OS 10.7 or newer |
| CCXSourceLocation | Identifies a specific source location within a translation unit |
| CCXSourceRange | Identifies a half-open character range in the source code |
| CCXSourceRangeList | Identifies an array of ranges |
| CCXString | A character string |
| CCXStringSet | |
| CCXToken | Describes a single preprocessing token |
| CCXTUResourceUsage | The memory usage of a CXTranslationUnit, broken into categories |
| CCXTUResourceUsageEntry | |
| CCXType | The type of an element in the abstract syntax tree |
| CCXUnsavedFile | Provides the contents of a file that has not yet been saved to disk |
| CCXVersion | Describes a version number of the form major.minor.subminor |
| CDefaultDoCastIfPossible | |
| CDefaultDOTGraphTraits | |
| CDefinedTracker | DefinedTracker - This struct is used while parsing expressions to keep track of whether !defined(X) has been seen |
| CDereferenceInfo | |
| CDerefSimplePtrArithFixableGadget | |
| CDiagnosticBuilder | Class to make it convenient to initialize TrapReason objects which can be used to attach the "trap reason" to trap instructions |
| CDiagnosticHandler | |
| Cdim3 | |
| CDynamicType | |
| CEmitter | |
| CEnsureImmediateInvocationInDefaultArgs | |
| CExitFunctionBodyRAII | RAII object that pops an ExpressionEvaluationContext when exiting a function body |
| CExpected | |
| CExpression | |
| CFieldConsumer | Helper struct for collecting smart owning pointer field regions |
| CFieldDecl | Represents a member of a struct/union/class |
| CFindStackRegionsSymbolVisitor | A visitor made for use with a ScanReachableSymbols scanner, used for finding stack regions within an SVal that live on the current stack frame of the given checker context |
| CFixableGadgetMatcher | |
| CFixableGadgetSets | |
| CFormatAttrCommon | |
| CFormatSpecifier | |
| CFormatStringHandler | |
| CFormattingAttemptStatus | Represents the status of a formatting attempt |
| CForVarDeclFinder | Look for variables declared in the body parts of a for-loop nest |
| Cforward | Code completion in a |
| CFriendCountAndPosition | Used as return type of getFriendCountAndPosition |
| CGEPOffsetAndOverflow | |
| CGlobalDeclRefChecker | This class visits every VarDecl that the initializer references and adds OMPDeclareTargetDeclAttr to each of them |
| Chexagon_udma_descriptor_type0_s | |
| Chexagon_udma_descriptor_type1_s | |
| CHIPUndefinedFatBinSymbols | |
| CImmediateCallVisitor | |
| CImutProfileInfo | |
| CIncludeStyle | Style for sorting and grouping C++ #include directives |
| CIncludeCategory | See documentation of IncludeCategories |
| CIndexerCallbacks | A group of callbacks used by clang_indexSourceFile and clang_indexTranslationUnit |
| CInjectRootSignatureCallback | |
| CISANameRevision | |
| CIsPartialSpecialization | |
| CIsPartialSpecialization< ClassTemplatePartialSpecializationDecl > | |
| CIsPartialSpecialization< VarTemplatePartialSpecializationDecl > | |
| CKind2Unsigned | |
| CLengthModifier | Represents the length modifier in a format string in scanf/printf |
| CLimitedRegionBindingsRef | This class represents the same as RegionBindingsRef, but with a limit on the number of bindings that can be added |
| CLineRange | |
| CLValueBaseString | |
| CMatchDescendantVisitor | |
| CMatchParents | |
| CMatchParents< T > | |
| Cmax_align_t | |
| CNestedLoopCounterVisitor | Counts the total number of OpenMP canonical nested loops, including the outermost loop (the original loop) |
| CNonTypeOrVarTemplateParmDecl | |
| CNullableValueCastFailed | |
| CObjCObjectType | |
| COMPAffinityClause | This represents clause 'affinity' in the '#pragma omp task'-based directives |
| COMPAlignedClause | This represents clause 'aligned' in the '#pragma omp ...' directives |
| COMPAssumeDirective | |
| COMPBindClause | This represents 'bind' clause in the '#pragma omp ...' directives |
| COMPCancelDirective | This represents '#pragma omp cancel' directive |
| COMPCancellationPointDirective | This represents '#pragma omp cancellation point' directive |
| COMPCanonicalLoopNestTransformationDirective | |
| COMPCanonicalLoopSequenceTransformationDirective | The base class for all transformation directives of canonical loop sequences (currently only 'fuse') |
| COMPChildren | Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) and associated statement, if any |
| COMPClause | |
| COMPClauseMappableExprCommon | Struct that defines common infrastructure to handle mappable expressions used in OpenMP clauses |
| CMappableComponent | Class that represents a component of a mappable expression. E.g. for an expression S.a, the first component is a declaration reference expression associated with 'S' and the second is a member expression associated with the field declaration 'a'. If the expression is an array subscript it may not have any associated declaration. In that case the associated declaration is set to nullptr |
| COMPClausePrinter | |
| COMPClauseVisitor | |
| COMPClauseVisitorBase | This class implements a simple visitor for OMPClause subclasses |
| COMPClauseWithPreInit | |
| COMPCopyinClause | This represents clause 'copyin' in the '#pragma omp ...' directives |
| COMPCopyprivateClause | This represents clause 'copyprivate' in the '#pragma omp ...' directives |
| COMPDefaultmapClause | This represents 'defaultmap' clause in the '#pragma omp ...' directive |
| COMPDependClause | This represents implicit clause 'depend' for the '#pragma omp task' directive |
| CDependDataTy | |
| COMPDepobjClause | This represents implicit clause 'depobj' for the '#pragma omp depobj' directive. This clause does not exist by itself, it can be only as a part of 'omp depobj' directive. This clause is introduced to keep the original structure of OMPExecutableDirective class and its derivatives and to use the existing infrastructure of clauses with the list of variables |
| COMPDestroyClause | This represents 'destroy' clause in the '#pragma omp depobj' directive or the '#pragma omp interop' directive. |
| COMPDetachClause | This represents 'detach' clause in the '#pragma omp task' directive |
| COMPDeviceClause | This represents 'device' clause in the '#pragma omp ...' directive |
| COMPDispatchDirective | This represents '#pragma omp dispatch' directive |
| COMPDistributeDirective | This represents '#pragma omp distribute' directive |
| COMPDistributeParallelForDirective | This represents '#pragma omp distribute parallel for' composite directive |
| COMPDistributeParallelForSimdDirective | This represents '#pragma omp distribute parallel for simd' composite directive |
| COMPDistributeSimdDirective | This represents '#pragma omp distribute simd' composite directive |
| COMPDistScheduleClause | This represents 'dist_schedule' clause in the '#pragma omp ...' directive |
| COMPDoacrossClause | This represents the 'doacross' clause for the '#pragma omp ordered' directive |
| COMPDynGroupprivateClause | This represents 'dyn_groupprivate' clause in '#pragma omp target ...' and '#pragma omp teams ...' directives |
| COMPErrorDirective | This represents '#pragma omp error' directive |
| COMPExclusiveClause | This represents clause 'exclusive' in the '#pragma omp scan' directive |
| COMPExecutableDirective | |
| COMPFilterClause | This represents 'filter' clause in the '#pragma omp ...' directive |
| COMPFlushClause | This represents implicit clause 'flush' for the '#pragma omp flush' directive. This clause does not exist by itself, it can be only as a part of 'omp flush' directive. This clause is introduced to keep the original structure of OMPExecutableDirective class and its derivatives and to use the existing infrastructure of clauses with the list of variables |
| COMPFromClause | This represents clause 'from' in the '#pragma omp ...' directives |
| COMPFuseDirective | Represents the '#pragma omp fuse' loop transformation directive |
| COMPGenericLoopDirective | This represents '#pragma omp loop' directive |
| COMPGrainsizeClause | This represents 'grainsize' clause in the '#pragma omp ...' directive |
| COMPHasDeviceAddrClause | This represents clause 'has_device_ptr' in the '#pragma omp ...' directives |
| COMPHintClause | This represents 'hint' clause in the '#pragma omp ...' directive |
| COMPInclusiveClause | This represents clause 'inclusive' in the '#pragma omp scan' directive |
| COMPInitClause | This represents the 'init' clause in '#pragma omp ...' directives |
| COMPInterchangeDirective | Represents the '#pragma omp interchange' loop transformation directive |
| COMPInteropDirective | This represents '#pragma omp interop' directive |
| COMPIsDevicePtrClause | This represents clause 'is_device_ptr' in the '#pragma omp ...' directives |
| COMPLoopDirective | |
| COMPLoopTransformationDirective | |
| COMPMapClause | This represents clause 'map' in the '#pragma omp ...' directives |
| COMPMappableExprListClause | This represents clauses with a list of expressions that are mappable. Examples of these clauses are 'map' in '#pragma omp target [enter|exit] [data]...' directives, and 'to' and 'from in '#pragma omp target update...' directives |
| Cconst_component_lists_iterator | Iterator that browse the components by lists. It also allows browsing components of a single declaration |
| COMPMappableExprListSizeTy | This structure contains all sizes needed for by an OMPMappableExprListClause |
| COMPMaskedDirective | This represents '#pragma omp masked' directive |
| COMPMaskedTaskLoopDirective | This represents '#pragma omp masked taskloop' directive |
| COMPMaskedTaskLoopSimdDirective | This represents '#pragma omp masked taskloop simd' directive |
| COMPMasterTaskLoopDirective | This represents '#pragma omp master taskloop' directive |
| COMPMasterTaskLoopSimdDirective | This represents '#pragma omp master taskloop simd' directive |
| COMPMetaDirective | This represents '#pragma omp metadirective' directive |
| COMPNoChildClause | |
| COMPNocontextClause | This represents 'nocontext' clause in the '#pragma omp ...' directive |
| COMPNogroupClause | This represents 'nogroup' clause in the '#pragma omp ...' directive |
| COMPNontemporalClause | This represents clause 'nontemporal' in the '#pragma omp ...' directives |
| COMPNovariantsClause | This represents 'novariants' clause in the '#pragma omp ...' directive |
| COMPNumTasksClause | This represents 'num_tasks' clause in the '#pragma omp ...' directive |
| COMPNumTeamsClause | This represents 'num_teams' clause in the '#pragma omp ...' directive |
| COMPOneStmtClause | |
| COMPOrderClause | This represents 'order' clause in the '#pragma omp ...' directive |
| COMPParallelGenericLoopDirective | This represents '#pragma omp parallel loop' directive |
| COMPParallelMaskedTaskLoopDirective | This represents '#pragma omp parallel masked taskloop' directive |
| COMPParallelMaskedTaskLoopSimdDirective | This represents '#pragma omp parallel masked taskloop simd' directive |
| COMPParallelMasterTaskLoopDirective | This represents '#pragma omp parallel master taskloop' directive |
| COMPParallelMasterTaskLoopSimdDirective | This represents '#pragma omp parallel master taskloop simd' directive |
| COMPPriorityClause | This represents 'priority' clause in the '#pragma omp ...' directive |
| COMPReverseDirective | Represents the '#pragma omp reverse' loop transformation directive |
| COMPScanDirective | This represents '#pragma omp scan' directive |
| COMPSIMDClause | This represents 'simd' clause in the '#pragma omp ...' directive |
| COMPStripeDirective | This represents the '#pragma omp stripe' loop transformation directive |
| COMPTargetDataDirective | This represents '#pragma omp target data' directive |
| COMPTargetDirective | This represents '#pragma omp target' directive |
| COMPTargetEnterDataDirective | This represents '#pragma omp target enter data' directive |
| COMPTargetExitDataDirective | This represents '#pragma omp target exit data' directive |
| COMPTargetParallelDirective | This represents '#pragma omp target parallel' directive |
| COMPTargetParallelForDirective | This represents '#pragma omp target parallel for' directive |
| COMPTargetParallelForSimdDirective | This represents '#pragma omp target parallel for simd' directive |
| COMPTargetParallelGenericLoopDirective | This represents '#pragma omp target parallel loop' directive |
| COMPTargetSimdDirective | This represents '#pragma omp target simd' directive |
| COMPTargetTeamsDirective | This represents '#pragma omp target teams' directive |
| COMPTargetTeamsDistributeDirective | This represents '#pragma omp target teams distribute' combined directive |
| COMPTargetTeamsDistributeParallelForDirective | This represents '#pragma omp target teams distribute parallel for' combined directive |
| COMPTargetTeamsDistributeParallelForSimdDirective | This represents '#pragma omp target teams distribute parallel for simd' combined directive |
| COMPTargetTeamsDistributeSimdDirective | This represents '#pragma omp target teams distribute simd' combined directive |
| COMPTargetTeamsGenericLoopDirective | This represents '#pragma omp target teams loop' directive |
| COMPTargetUpdateDirective | This represents '#pragma omp target update' directive |
| COMPTaskLoopDirective | This represents '#pragma omp taskloop' directive |
| COMPTaskLoopSimdDirective | This represents '#pragma omp taskloop simd' directive |
| COMPTeamsDirective | This represents '#pragma omp teams' directive |
| COMPTeamsDistributeDirective | This represents '#pragma omp teams distribute' directive |
| COMPTeamsDistributeParallelForDirective | This represents '#pragma omp teams distribute parallel for' composite directive |
| COMPTeamsDistributeParallelForSimdDirective | This represents '#pragma omp teams distribute parallel for simd' composite directive |
| COMPTeamsDistributeSimdDirective | This represents '#pragma omp teams distribute simd' combined directive |
| COMPTeamsGenericLoopDirective | This represents '#pragma omp teams loop' directive |
| COMPThreadLimitClause | This represents 'thread_limit' clause in the '#pragma omp ...' directive |
| COMPThreadsClause | This represents 'threads' clause in the '#pragma omp ...' directive |
| COMPTileDirective | This represents the '#pragma omp tile' loop transformation directive |
| COMPToClause | This represents clause 'to' in the '#pragma omp ...' directives |
| COMPTraitInfo | |
| COMPTraitProperty | |
| COMPTraitSelector | |
| COMPTraitSet | |
| COMPUnrollDirective | This represents the '#pragma omp unroll' loop transformation directive |
| COMPUseClause | This represents the 'use' clause in '#pragma omp ...' directives |
| COMPUseDeviceAddrClause | This represents clause 'use_device_addr' in the '#pragma omp ...' directives |
| COMPUseDevicePtrClause | This represents clause 'use_device_ptr' in the '#pragma omp ...' directives |
| COMPUsesAllocatorsClause | This represents clause 'uses_allocators' in the '#pragma omp target'-based directives |
| CData | Data for list of allocators |
| COMPXAttributeClause | This represents 'ompx_attribute' clause in a directive that might generate an outlined function |
| COMPXBareClause | This represents 'ompx_bare' clause in the '#pragma omp target teams ...' directive |
| COMPXDynCGroupMemClause | This represents 'ompx_dyn_cgroup_mem' clause in the '#pragma omp target ...' directive |
| COpaqueValueVisitor | |
| COpenACCAssociatedStmtConstruct | |
| COpenACCAtomicConstruct | |
| CSingleStmtInfo | |
| CStmtInfo | |
| COpenACCCacheConstruct | |
| COpenACCCombinedConstruct | |
| COpenACCConstructStmt | |
| COpenACCDataConstruct | |
| COpenACCEnterDataConstruct | |
| COpenACCExitDataConstruct | |
| COpenACCHostDataConstruct | |
| COpenACCInitConstruct | |
| COpenACCLoopConstruct | This class represents a 'loop' construct. The 'loop' construct applies to a 'for' loop (or range-for loop), and is optionally associated with a Compute Construct |
| COpenACCSetConstruct | |
| COpenACCShutdownConstruct | |
| COpenACCUpdateConstruct | |
| COpenACCWaitConstruct | |
| COperatorRelationsTable | |
| COptionalAmount | |
| COSLogBufferItem | An OSLogBufferItem represents a single item in the data written by a call to os_log() or os_trace() |
| COSLogBufferLayout | |
| CPassInfoMixin | |
| CPrintfSpecifier | |
| CPrivateMethodKey | |
| CRawCompressedBundleHeader | |
| CCommonFields | |
| CV1Header | |
| CV2Header | |
| CV3Header | |
| Crdtime | |
| CReadySuspendResumeResult | |
| CRotateIntegerConverter | |
| CSarifArtifact | Since every clang artifact MUST have a location (there being no nested artifacts), the creation method SarifArtifact::create requires a SarifArtifactLocation object |
| CSarifArtifactLocation | |
| CScanfConversionSpecifier | |
| CScanfSpecifier | |
| CSmallVector | |
| CSparcCPUInfo | |
| CStdVariantChecker | |
| CStmtClassNameTable | |
| CTargetOMPContext | Clang specific specialization of the OMPContext to lookup target features |
| CTgtInfo | |
| CThis | Trap message and trap category |
| CTypeInfo | |
| CPhasesBitSet | |
| CU | |
| Cudir_iterator_base | |
| CUPCPreIncrementGadget | |
| CUpdateOnReturn | |
| CUUCAddAssignGadget | |
| CVariableGroupsManagerImpl | |
| CWarningGadgetMatcher | |
| CWarningGadgetSets | |
| CWebAssemblyABIInfo | |
| CWebAssemblyTargetCodeGenInfo |
Generated on for clang by
1.14.0