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 | |
| CABIArgInfo | |
| CCIRBaseBuilderTy | |
| CCIRDataLayout | |
| CCIRGenAction | |
| CCIRGenConsumer | |
| CCIRGenerator | |
| CEmitAssemblyAction | |
| CEmitBCAction | |
| CEmitCIRAction | |
| CEmitLLVMAction | |
| CEmitObjAction | |
| CLoweringPrepareCXXABI | |
| CMissingFeatures | |
| 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 tagert 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 |
| 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 | |
| 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 |
| 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 |
| 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 | |
| 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 | |
| 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 |
| CFunctionPointer | |
| CGlobalInlineDescriptor | Descriptor used for global variables |
| CInitLink | |
| CInitLinkScope | |
| CInitMap | Bitfield tracking the initialisation status of elements of primitive arrays |
| 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 | |
| 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 | Information about a single borrow, or "Loan" |
| 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 |
| COriginFlowFact | |
| COriginManager | Manages the creation, storage, and retrieval of origins for pointer-like variables and expressions |
| CReturnOfOriginFact | |
| CTestPointFact | A dummy-fact used to mark a specific point in the code for testing |
| CUseFact | |
| CLifetimeSafetyReporter | |
| 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 |
| 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 | |
| CWASITargetInfo | |
| 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 | |
| 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 |
| 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 |
| CDependencyScanningTool | The high-level implementation of the dependency discovery tool that runs on an individual worker thread |
| 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 |
| CDignosticsEngineWithDiagOpts | |
| 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 |
| CP1689Rule | |
| 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 |
| 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 |
| 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 |
| 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 |
| 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 |
| CASTWriterData | |
| CCachedCodeCompletionResult | A cached code-completion result, which may be introduced in one of many different contexts |
| CConcurrencyCheck | |
| CStandaloneDiagnostic | |
| CStandaloneFixIt | |
| 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 |
| 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 |
| CConstOMPClauseVisitor | |
| 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 |
| 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 | |
| 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 |
| 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 |
| 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 |
| CGetDependenciesByModuleNameAction | |
| 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 | |
| CHLSLSemanticAttr | |
| 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 | |
| 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 |
| CJITConfig | |
| 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 |
| 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 | |
| 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 | |
| COMPAbsentClause | This represents the 'absent' clause in the '#pragma omp assume' directive |
| COMPAcqRelClause | This represents 'acq_rel' clause in the '#pragma omp atomic|flush' directives |
| COMPAcquireClause | This represents 'acquire' clause in the '#pragma omp atomic|flush' directives |
| COMPAffinityClause | This represents clause 'affinity' in the '#pragma omp task'-based directives |
| COMPAlignClause | This represents the 'align' clause in the '#pragma omp allocate' directive |
| COMPAlignedClause | This represents clause 'aligned' in the '#pragma omp ...' directives |
| 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 |
| COMPAtClause | This represents 'at' clause in the '#pragma omp error' directive |
| COMPAtomicDefaultMemOrderClause | This represents 'atomic_default_mem_order' clause in the '#pragma omp requires' directive |
| COMPBindClause | This represents 'bind' clause in the '#pragma omp ...' directives |
| COMPCaptureClause | This represents 'capture' clause in the '#pragma omp atomic' directive |
| COMPCapturedExprDecl | Pseudo declaration for capturing expressions |
| COMPChildren | Contains data for OpenMP directives: clauses, children expressions/statements (helpers for codegen) and associated statement, if any |
| COMPClause | This is a basic class for representing single OpenMP clause |
| COMPClauseMappableExprCommon | Struct that defines common infrastructure to handle mappable expressions used in OpenMP clauses |
| CMappableComponent | Class that represents a component of a mappable expression |
| COMPClausePrinter | |
| COMPClauseReader | |
| COMPClauseVisitor | |
| COMPClauseVisitorBase | This class implements a simple visitor for OMPClause subclasses |
| 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 |
| COMPCompareClause | This represents 'compare' clause in the '#pragma omp atomic' directive |
| COMPContainsClause | This represents the 'contains' clause in the '#pragma omp assume' directive |
| COMPCopyinClause | This represents clause 'copyin' in the '#pragma omp ...' directives |
| COMPCopyprivateClause | This represents clause 'copyprivate' in the '#pragma omp ...' directives |
| 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 |
| 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 |
| 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 |
| COMPDirectiveListClause | Class that represents a list of directive kinds (parallel, target, etc.) as used in absent, contains clauses |
| COMPDistScheduleClause | This represents 'dist_schedule' clause in the '#pragma omp ...' directive |
| COMPDoacrossClause | This represents the 'doacross' clause for the '#pragma omp ordered' directive |
| COMPDynamicAllocatorsClause | This represents 'dynamic_allocators' clause in the '#pragma omp requires' directive |
| COMPExclusiveClause | This represents clause 'exclusive' in the '#pragma omp scan' directive |
| COMPFailClause | This represents 'fail' clause in the '#pragma omp atomic' directive |
| COMPFilterClause | This represents 'filter' clause in the '#pragma omp ...' directive |
| COMPFinalClause | This represents 'final' clause in the '#pragma omp ...' directive |
| COMPFirstprivateClause | This represents clause 'firstprivate' in the '#pragma omp ...' directives |
| COMPFlushClause | This represents implicit clause 'flush' for the '#pragma omp flush' directive |
| COMPFromClause | This represents clause 'from' in the '#pragma omp ...' directives |
| COMPFullClause | Representation of the 'full' clause of the '#pragma omp unroll' directive |
| COMPGrainsizeClause | This represents 'grainsize' clause in the '#pragma omp ...' directive |
| COMPGroupPrivateDecl | This represents '#pragma omp groupprivate ...' directive |
| COMPHasDeviceAddrClause | This represents clause 'has_device_ptr' in the '#pragma omp ...' directives |
| COMPHintClause | This represents 'hint' clause in the '#pragma omp ...' directive |
| COMPHoldsClause | This represents the 'holds' clause in the '#pragma omp assume' directive |
| COMPIfClause | This represents 'if' 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 |
| COMPInReductionClause | This represents clause 'in_reduction' in the '#pragma omp task' directives |
| COMPInteropInfo | |
| COMPIsDevicePtrClause | This represents clause 'is_device_ptr' in the '#pragma omp ...' directives |
| 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 |
| COMPLastprivateClause | This represents clause 'lastprivate' in the '#pragma omp ...' directives |
| COMPLinearClause | This represents clause 'linear' in the '#pragma omp ...' directives |
| COMPLoopRangeClause | This class represents the 'looprange' clause in the '#pragma omp fuse' directive |
| COMPMapClause | This represents clause 'map' in the '#pragma omp ...' directives |
| COMPMappableExprListClause | This represents clauses with a list of expressions that are mappable |
| Cconst_component_lists_iterator | Iterator that browse the components by lists |
| COMPMappableExprListSizeTy | This structure contains all sizes needed for by an OMPMappableExprListClause |
| COMPMergeableClause | This represents 'mergeable' clause in the '#pragma omp ...' directive |
| COMPMessageClause | This represents the 'message' clause in the '#pragma omp error' and the '#pragma omp parallel' directives |
| 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 |
| COMPNoOpenMPClause | This represents the 'no_openmp' clause in the '#pragma omp assume' directive |
| COMPNoOpenMPConstructsClause | This represents the 'no_openmp_constructs' clause in the |
| COMPNoOpenMPRoutinesClause | This represents the 'no_openmp_routines' clause in the '#pragma omp assume' directive |
| COMPNoParallelismClause | This represents the 'no_parallelism' clause in the '#pragma omp assume' directive |
| COMPNovariantsClause | This represents 'novariants' clause in the '#pragma omp ...' directive |
| COMPNowaitClause | This represents 'nowait' 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 |
| COMPNumThreadsClause | This represents 'num_threads' clause in the '#pragma omp ...' directive |
| COMPOneStmtClause | |
| COMPOrderClause | This represents 'order' clause in the '#pragma omp ...' directive |
| COMPOrderedClause | This represents 'ordered' clause in the '#pragma omp ...' directive |
| 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 |
| COMPPriorityClause | This represents 'priority' clause in the '#pragma omp ...' directive |
| COMPPrivateClause | This represents clause 'private' in the '#pragma omp ...' directives |
| COMPProcBindClause | This represents 'proc_bind' clause in the '#pragma omp ...' directive |
| COMPReadClause | This represents 'read' clause in the '#pragma omp atomic' directive |
| COMPReductionClause | This represents clause 'reduction' in the '#pragma omp ...' directives |
| COMPRelaxedClause | This represents 'relaxed' clause in the '#pragma omp atomic' directives |
| COMPReleaseClause | This represents 'release' clause in the '#pragma omp atomic|flush' directives |
| COMPRequiresDecl | This represents '#pragma omp requires...' directive |
| COMPReverseOffloadClause | This represents 'reverse_offload' clause in the '#pragma omp requires' directive |
| COMPSafelenClause | This represents 'safelen' clause in the '#pragma omp ...' directive |
| COMPScheduleClause | This represents 'schedule' clause in the '#pragma omp ...' directive |
| COMPSelfMapsClause | This represents 'self_maps' clause in the '#pragma omp requires' directive |
| COMPSeqCstClause | This represents 'seq_cst' clause in the '#pragma omp atomic|flush' directives |
| COMPSeverityClause | This represents the 'severity' clause in the '#pragma omp error' and the '#pragma omp parallel' directives |
| COMPSharedClause | This represents clause 'shared' in the '#pragma omp ...' directives |
| COMPSIMDClause | This represents 'simd' 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 |
| COMPTaskReductionClause | This represents clause 'task_reduction' in the '#pragma omp taskgroup' directives |
| COMPThreadLimitClause | This represents 'thread_limit' clause in the '#pragma omp ...' directive |
| COMPThreadPrivateDecl | This represents '#pragma omp threadprivate ...' directive |
| COMPThreadsClause | This represents 'threads' clause in the '#pragma omp ...' directive |
| COMPThreadsetClause | This represents 'threadset' clause in the '#pragma omp task ...' directive |
| COMPToClause | This represents clause 'to' in the '#pragma omp ...' directives |
| COMPTraitInfo | Helper data structure representing the traits in a match clause of an declare variant or metadirective |
| COMPTraitProperty | |
| COMPTraitSelector | |
| COMPTraitSet | |
| COMPUnifiedAddressClause | This represents 'unified_address' clause in the '#pragma omp requires' directive |
| COMPUnifiedSharedMemoryClause | This represents 'unified_shared_memory' clause in the '#pragma omp requires' directive |
| COMPUntiedClause | This represents 'untied' clause in the '#pragma omp ...' directive |
| COMPUpdateClause | This represents 'update' clause in the '#pragma omp atomic' 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 |
| 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 |
| COMPWeakClause | This represents 'weak' clause in the '#pragma omp atomic' directives |
| COMPWriteClause | This represents 'write' clause in the '#pragma omp atomic' directive |
| 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 |
| 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 |
| 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 |
| COwningArrayRef | |
| 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 |
| COffsetOfComponent | |
| COriginalCallArg | Brief A function argument from which we performed template argument |
| 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 | |
| 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) |
| 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 | |
| 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 | |
| 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 | |
| CTargetOMPContext | Clang specific specialization of the OMPContext to lookup target features |
| 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 | |
| CPresefinedSugarTypeBitfields | |
| 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::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::tok::PPKeywordKind > | |
| CDenseMapInfo< clang::tooling::dependencies::ModuleID > | |
| 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< 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 | |
| COwningArrayRef | |
| 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< typename 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 | |
| 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 | |
| CLoweringPrepareItaniumCXXABI | |
| 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 | |
| COMPAssumeDirective | |
| 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') |
| 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 |
| COMPErrorDirective | This represents '#pragma omp error' directive |
| COMPExecutableDirective | |
| COMPFuseDirective | Represents the '#pragma omp fuse' loop transformation directive |
| COMPGenericLoopDirective | This represents '#pragma omp loop' directive |
| COMPInterchangeDirective | Represents the '#pragma omp interchange' loop transformation directive |
| COMPInteropDirective | This represents '#pragma omp interop' directive |
| COMPLoopDirective | |
| COMPLoopTransformationDirective | |
| 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 |
| 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 |
| COMPReverseDirective | Represents the '#pragma omp reverse' loop transformation directive |
| COMPScanDirective | This represents '#pragma omp scan' 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 |
| COMPTileDirective | This represents the '#pragma omp tile' loop transformation directive |
| COMPUnrollDirective | This represents the '#pragma omp unroll' loop transformation directive |
| COpaqueValueVisitor | |
| COpenACCAssociatedStmtConstruct | |
| COpenACCAtomicConstruct | |
| 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 | |
| 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 | |
| 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