►Nclang | Dataflow Directional Tag Classes |
►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 |
CPrintfConversionSpecifier | |
CPrintfSpecifier | |
►Nanalyze_scanf | Pieces specific to fscanf format strings |
CScanfConversionSpecifier | |
CScanfSpecifier | |
►Narcmt | |
►Ntrans | |
CASTTraverser | |
CBlockObjCVariableTraverser | |
CBodyContext | |
CBodyTransform | |
CGCAttrsTraverser | |
CGCCollectableCallsTraverser | |
►CMigrationContext | |
CGCAttrOccurrence | |
CObjCImplementationContext | |
CPropertyRewriteTraverser | |
CProtectedScopeTraverser | |
CCapturedDiagList | |
CCheckAction | |
CFileRemapper | |
CMigrateAction | |
CMigrateSourceAction | |
CMigrationPass | |
►CMigrationProcess | |
CRewriteListener | |
CModifyAction | |
CObjCMigrateAction | Migrates to modern ObjC syntax |
CTransaction | |
►CTransformActions | |
CRewriteReceiver | |
►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< std::string > | |
CArgTypeTraits< StringRef > | |
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 |
CMatcherDescriptor | Matcher descriptor interface |
COverloadedMatcherDescriptor | MatcherDescriptor that wraps multiple "overloads" of the same matcher |
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 | |
►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 |
►Nast_type_traits | |
►CASTNodeKind | Kind identifier |
CDenseMapInfo | Hooks for using ASTNodeKind as a key in a DenseMap |
►CDynTypedNode | A dynamically typed AST node container |
CBaseConverter< CXXCtorInitializer, void > | |
CBaseConverter< NestedNameSpecifier, void > | |
CBaseConverter< NestedNameSpecifierLoc, void > | |
CBaseConverter< QualType, void > | |
CBaseConverter< T, typename std::enable_if< std::is_base_of< Decl, T >::value >::type > | |
CBaseConverter< T, typename std::enable_if< std::is_base_of< Stmt, T >::value >::type > | |
CBaseConverter< T, typename std::enable_if< std::is_base_of< Type, T >::value >::type > | |
CBaseConverter< TemplateArgument, void > | |
CBaseConverter< TemplateName, void > | |
CBaseConverter< TypeLoc, void > | |
CDenseMapInfo | Hooks for using DynTypedNode as a key in a DenseMap |
►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 | |
►NCodeGen | |
►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 | An aligned address |
CAggValueSlot | An aggregate value slot |
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 | |
►CCGCXXABI | Implements C++ ABI-specific code generation functions |
CAddedStructorArgs | Notes how many arguments were added to the beginning (Prefix) and ending (Suffix) of an arg list |
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 | |
►CCGObjCRuntime | Implements runtime-specific code generation functions |
CMessageSendInfo | |
►CCGOpenCLRuntime | |
CEnqueuedBlockInfo | Structure for enqueued block information |
►CCGOpenMPRuntime | |
CDisableAutoDeclareTargetRAII | Allows to disable automatic handling of functions used in target regions as those marked as omp declare target |
CCGOpenMPRuntimeNVPTX | |
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 |
CArrayInitLoopExprScope | The scope of an ArrayInitLoopExpr |
CAutoVarEmission | |
CCallLifetimeEnd | |
CCGCapturedStmtInfo | API for captured statement code generation |
CCGCapturedStmtRAII | RAII for correct setting/restoring of CapturedStmtInfo |
CCGCoroInfo | |
CConditionalEvaluation | An object to manage conditionally-evaluated expressions |
CConstantEmission | |
CCXXDefaultInitExprScope | The scope of a CXXDefaultInitExpr |
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 |
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 |
►CMultiVersionResolverOption | |
CConds | |
COMPCancelStackRAII | Controls insertion of cancellation exit blocks in worksharing constructs |
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 | |
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 |
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 | |
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 |
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 |
CDispatchRTInput | Struct with the values to be passed to the dispatch runtime function |
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 |
CEHPadEndScope | |
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 |
►CCleanup | Information for lazily generating a cleanup |
CFlags | Generation flags |
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 |
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 | |
►COffloadEntriesInfoManagerTy | Entity that registers the offloading constants that were emitted so far |
COffloadEntryInfo | Base class of the entries info |
COffloadEntryInfoDeviceGlobalVar | Device global variable entries info |
COffloadEntryInfoTargetRegion | Target region entries info |
COMPTaskDataTy | |
COrderGlobalInits | |
CPrePostActionTy | A basic class for pre|post-action for advanced codegen sequence for OpenMP region |
CReductionCodeGen | Class intended to support codegen of all kind of the reduction clauses |
CReductionOptionsTy | |
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 |
CSanitizerMetadata | |
CStaticRTInput | Struct with the values to be passed to the static runtime function |
CSwiftABIInfo | A refining implementation of ABIInfo for targets that support swiftcall |
►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 |
CTargetDataInfo | Struct that keeps all the relevant information that should be kept throughout a 'target data' region |
CTaskResultTy | |
CTBAAAccessInfo | |
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 |
CArgument | |
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 |
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 |
CArgument | |
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 |
►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 | |
Cbackward_analysis_tag | |
Cforward_analysis_tag | |
►Ndeclvisitor | |
CBase | A simple visitor class that helps create declaration visitors |
►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 |
CPropertyData | |
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 | |
►Ntoolchains | |
CAMDGPUToolChain | |
CAnanas | |
CAVRToolChain | |
CBareMetal | |
CCloudABI | |
CContiki | |
CCrossWindowsToolChain | |
CCudaToolChain | |
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 |
CGCCVersion | Struct to store and manipulate GCC versions |
CHaiku | |
CHexagonToolChain | |
CHIPToolChain | |
CHurd | |
CLanaiToolChain | |
CLinux | |
CMachO | |
CMinGW | |
CMinix | |
CMipsLLVMToolChain | |
CMSP430ToolChain | |
CMSVCToolChain | |
CMyriadToolChain | MyriadToolChain - A tool chain using either clang or the external compiler installed by the Movidius SDK to perform all subcommands |
CNaClToolChain | |
CNetBSD | |
COpenBSD | |
CPS4CPU | |
CRISCVToolChain | |
CSolaris | |
CTCELEToolChain | Toolchain for little endian TCE cores |
CTCEToolChain | TCEToolChain - A tool chain using the llvm bitcode tools to perform all subcommands |
CWebAssembly | |
CXCoreToolChain | |
►Ntools | |
►NAMDGCN | |
CLinker | |
►Namdgpu | |
CLinker | |
►Nananas | Ananas – Directly call GNU Binutils assembler and linker |
CAssembler | |
CLinker | |
►NAVR | |
CLinker | |
►Nbaremetal | |
CLinker | |
►Ncloudabi | Cloudabi – Directly call GNU Binutils linker |
CLinker | |
►NCrossWindows | |
CAssembler | |
CLinker | |
►Ndarwin | |
CAssembler | |
CDsymutil | |
CLinker | |
CLipo | |
CMachOTool | |
CVerifyDebug | |
►Ndragonfly | Dragonfly – Directly call GNU Binutils assembler and linker |
CAssembler | |
CLinker | |
►Nfreebsd | Freebsd – Directly call GNU Binutils assembler and linker |
CAssembler | |
CLinker | |
►Nfuchsia | |
CLinker | |
►Ngcc | Gcc - Generic GCC tool implementations |
CCommon | |
CCompiler | |
CLinker | |
CPreprocessor | |
►Ngnutools | Directly call GNU Binutils' assembler and linker |
CAssembler | |
CLinker | |
►Nhexagon | |
CAssembler | |
CLinker | |
►NMinGW | MinGW – Directly call GNU Binutils assembler and linker |
CAssembler | |
CLinker | |
►Nminix | Minix – Directly call GNU Binutils assembler and linker |
CAssembler | |
CLinker | |
►Nmsp430 | |
CLinker | |
►NMyriad | The Myriad toolchain uses tools that are in two different namespaces |
CLinker | |
►Nnacltools | |
CAssemblerARM | |
CLinker | |
►Nnetbsd | Netbsd – Directly call GNU Binutils assembler and linker |
CAssembler | |
CLinker | |
►NNVPTX | |
CAssembler | |
CLinker | |
COpenMPLinker | |
►Nopenbsd | Openbsd – Directly call GNU Binutils assembler and linker |
CAssembler | |
CLinker | |
►NPS4cpu | |
CAssemble | |
CLink | |
►NRISCV | |
CLinker | |
►NSHAVE | SHAVE tools – Directly call moviCompile and moviAsm |
CAssembler | |
CCompiler | |
►Nsolaris | Solaris – Directly call Solaris assembler and linker |
CAssembler | |
CLinker | |
►Nvisualstudio | Visual studio tools |
CCompiler | |
CLinker | |
►Nwasm | |
CLinker | |
►NXCore | |
CAssembler | |
CLinker | |
CClang | Clang compiler tool |
CClangAs | Clang integrated assembler tool |
CGnuTool | Base class for all GNU tools that provide the same behavior when it comes to response files support |
COffloadBundler | Offload bundler tool |
CAction | Action - Represent an abstract compilation step to perform |
CAnalyzeJobAction | |
CAssembleJobAction | |
CBackendJobAction | |
CBindArchAction | |
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 |
CDarwinSDKInfo | The information about the darwin SDK that was used during this compilation |
CDetectedMultilibs | |
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 | |
CFallbackCommand | Like Command, but with a fallback which is executed in case the primary command crashes |
CForceSuccessCommand | Like Command, but always pretends that the wrapped command succeeded |
CHeaderModulePrecompileJobAction | |
CInputAction | |
CInputInfo | InputInfo - Wrapper for information about an input source |
CJobAction | |
CJobList | JobList - A sequence of jobs to perform |
CLinkJobAction | |
CLipoJobAction | |
CMigrateJobAction | |
CMultilib | This corresponds to a single GCC Multilib, or a segment of one controlled by a command line flag |
CMultilibSet | |
►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 | |
►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 |
CSanitizerArgs | |
CTool | Tool - Information on a specific compilation tool |
CToolChain | ToolChain - Access to tools for a single platform |
CVerifyDebugInfoJobAction | |
CVerifyJobAction | |
CVerifyPCHJobAction | |
CXRayArgs | |
►Nedit | |
►CCommit | |
CEdit | |
CEditedSource | |
CEditsReceiver | |
CFileOffset | |
►Nento | |
►Ncheck | |
CASTCodeBody | |
CASTDecl | |
CBeginFunction | |
CBind | |
CBranchCondition | |
CConstPointerEscape | |
CDeadSymbols | |
CEndAnalysis | |
CEndFunction | |
CEndOfTranslationUnit | |
CEvent | |
CLiveSymbols | |
CLocation | |
CNewAllocator | |
CObjCMessageNil | |
CPointerEscape | |
CPostCall | |
CPostObjCMessage | |
CPostStmt | |
CPreCall | |
CPreObjCMessage | |
CPreStmt | |
CRegionChanges | |
►Neval | |
CAssume | |
CCall | |
►Nloc | |
CConcreteInt | |
CGotoLabel | |
CMemRegionVal | |
►Nmpi | |
CMPIBugReporter | |
CMPIChecker | |
CMPIFunctionClassifier | |
CRequest | |
CRequestMap | |
►Nnonloc | |
CCompoundVal | |
CConcreteInt | Value representing integer constant |
CLazyCompoundVal | |
CLocAsInteger | |
CPointerToMember | Value representing pointer-to-member |
CSymbolVal | Represents symbolic expression that isn't a location |
►Nretaincountchecker | |
CBadRelease | |
CDeallocNotOwned | |
CLeak | |
COverAutorelease | |
CRefCountBug | |
CRefCountReport | |
CRefLeakReport | |
CRefVal | Metadata on reference |
CRetainCountChecker | |
CReturnedNotOwnedForOwned | |
CUseAfterRelease | |
►NsummMgr | |
CSummaryKey | |
CAllocaRegion | AllocaRegion - A region that represents an untyped blob of bytes created by a call to 'alloca' |
CAnalysisAction | |
CAnalysisASTConsumer | |
CAnalysisManager | |
CAnyFunctionCall | Represents a call to any sort of function that might have a FunctionDecl |
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 |
CBasicValueFactory | |
CBinarySymExpr | Represents a symbolic expression involving a binary operator |
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 |
CNodeResolver | |
CBugReportEquivClass | |
CBugReporter | BugReporter is a utility class for generating PathDiagnostics for analysis |
CBugReporterContext | |
CBugReporterData | |
CBugType | |
CBuiltinBug | |
CCallDescription | This class represents a description of a function call using the number of arguments and the name of the function |
CCallEffects | Encapsulates the retain count semantics on the arguments, return value, and receiver (if any) of a function/method call |
CCallEvent | Represents an abstract call to a function or method along a particular path |
CCallEventRef | |
CChecker | |
CChecker< CHECK1 > | |
CCheckerBase | |
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 |
CCheckerFn | |
CCheckerFn< RET(Ps...)> | |
CCheckerManager | |
CCheckerProgramPointTag | Tag that can use a checker name as a message provider (see SimpleProgramPointTag) |
►CCheckerRegistry | Manages a set of available checkers for running a static analysis |
CCheckerInfo | |
CCheckName | |
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 | |
CConditionTruthVal | |
CConstraintManager | |
CConstraintRange | |
CCoreEngine | CoreEngine - Implements the core logic of the graph-reachability analysis |
CCXXBaseObjectRegion | |
CCXXDerivedObjectRegion | |
CCXXTempObjectRegion | |
CCXXThisRegion | CXXThisRegion - Represents the region for the implicit 'this' parameter in a call to a C++ method |
CDeclRegion | |
CDefaultBool | A helper class which wraps a boolean value set to false by default |
CDefinedOrUnknownSVal | |
CDefinedSVal | |
CDerivedSymTaint | The GDM component mapping derived symbols' parent symbols to their underlying regions |
CDynamicTypeInfo | Stores the currently inferred strictest bound on the runtime type of a region in a given state along the analysis path |
CDynamicTypeMap | The GDM component containing the dynamic type info |
CElementRegion | ElementRegion is used to represent both array elements and casts |
CEnvironment | An immutable map from EnvironemntEntries to SVals |
CEnvironmentEntry | An entry in the environment consists of a Stmt and an LocationContext |
CEnvironmentManager | |
CEventDispatcher | |
CExplodedGraph | |
CExplodedNode | |
CExplodedNodeSet | |
►CExprEngine | |
CEvalCallOptions | Hints for figuring out of a call should be inlined during evalCall() |
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 then system calls |
CGlobalsSpaceRegion | |
CGlobalSystemSpaceRegion | The region containing globals which are defined in system/external headers and are considered modifiable by system calls (ex: errno) |
CGRBugReporter | GRBugReporter is used for generating path-sensitive reports |
CHeapSpaceRegion | |
CImplicitNullDerefEvent | We dereferenced a location that may be null |
►CIndirectGotoNodeBuilder | |
Citerator | |
CIntSymExpr | Represents a symbolic expression like 3 - 'x' |
CKnownSVal | Represents an SVal that is guaranteed to not be UnknownVal |
CLazyCompoundValData | |
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 | |
CNodeBuilder | This is the simplest builder which generates nodes in the ExplodedGraph |
CNodeBuilderContext | |
CNodeBuilderWithSinks | This node builder keeps track of the generated sink nodes |
CNodeMapClosure | |
CNonLoc | |
CNonStaticGlobalSpaceRegion | The region for all the non-static global variables |
CObjCIvarRegion | |
CObjCStringRegion | The region associated with an ObjCStringLiteral |
CObjCSummaryKey | A key identifying a summary |
CParseModelFileAction | Frontend action to parse model files |
CPathDiagnostic | PathDiagnostic - PathDiagnostic objects represent a single path-sensitive diagnostic |
CPathDiagnosticCallPiece | |
►CPathDiagnosticConsumer | |
CFilesMade | |
CPDFileEntry | |
CPathDiagnosticControlFlowPiece | |
CPathDiagnosticEventPiece | |
CPathDiagnosticLocation | |
CPathDiagnosticLocationPair | |
CPathDiagnosticMacroPiece | |
CPathDiagnosticNotePiece | |
CPathDiagnosticPiece | |
CPathDiagnosticRange | |
CPathDiagnosticSpotPiece | |
CPathPieces | |
CPointerToMemberData | |
CPrettyStackTraceLocationContext | While alive, includes the current analysis stack in a crash trace |
CProgramState | ProgramState - This class encapsulates: |
CProgramStateManager | |
CProgramStatePartialTrait | |
CProgramStatePartialTrait< bool > | |
CProgramStatePartialTrait< const void * > | |
CProgramStatePartialTrait< llvm::ImmutableList< T > > | |
CProgramStatePartialTrait< llvm::ImmutableMap< Key, Data, Info > > | |
CProgramStatePartialTrait< llvm::ImmutableSet< Key, Info > > | |
CProgramStatePartialTrait< unsigned > | |
CProgramStatePartialTrait< void * > | |
CProgramStateTrait | |
CProgramStateTrait< ConstraintRange > | |
CProgramStateTrait< DerivedSymTaint > | |
CProgramStateTrait< DynamicTypeMap > | |
CProgramStateTrait< mpi::RequestMap > | |
CProgramStateTrait< ReplayWithoutInlining > | |
CProgramStateTrait< TaintMap > | |
CRange | A Range represents the closed range [from, to] |
CRangedConstraintManager | |
CRangeSet | RangeSet contains a set of ranges |
CRangeTrait | |
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 |
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 | |
CSMTExpr | Generic base class for SMT exprs |
CSMTSolver | Generic base class for SMT Solvers |
CSMTSort | Generic base class for SMT sorts |
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 |
CSubEngine | |
CSubRegion | SubRegion - A region that subsets another larger region |
CSummaryManager | |
CSummaryManagerImpl | |
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 |
CSymExprVisitor | SymExprVisitor - this class implements a simple visitor for SymExpr subclasses |
CSymIntExpr | Represents a symbolic expression like 'x' + 3 |
CSymSymExpr | Represents a symbolic expression like 'x' + 'y' |
CTaintManager | |
CTaintMap | The GDM component containing the tainted root symbols |
CTypedRegion | TypedRegion - An abstract class representing regions that are typed |
CTypedValueRegion | TypedValueRegion - An abstract class representing regions having a typed value |
CUndefinedVal | |
CUninitObjCheckerOptions | |
CUnknownSpaceRegion | |
CUnknownVal | |
CVarRegion | |
CWorkList | |
CWorkListUnit | |
►Nformat | |
CAdditionalKeywords | Encapsulates keywords that are context sensitive or for languages not properly supported by Clang's lexer |
CAffectedRangeManager | |
CAnnotatedLine | |
CBreakableBlockComment | |
CBreakableComment | |
CBreakableLineCommentSection | |
CBreakableStringLiteral | |
CCommaSeparatedList | |
CCompoundStatementIndenter | |
CContinuationIndenter | |
CEnvironment | |
►CFormatStyle | The FormatStyle is used to configure the formatting to follow specific guidelines |
CBraceWrappingFlags | Precise control over the wrapping of braces |
CFormatStyleSet | |
CRawStringFormat | See documentation of RawStringFormats |
CFormattingAttemptStatus | Represents the status of a formatting attempt |
CFormatToken | A wrapper around a Token storing information about the whitespace characters preceding it |
CFormatTokenLexer | |
CFormatTokenSource | |
CJavaScriptImportSorter | |
CJsImportedSymbol | |
CJsModuleReference | |
CLineState | The current state when indenting a unwrapped line |
CNamespaceEndCommentsFixer | |
CParenState | |
CParseErrorCategory | |
CRawStringFormatStyleManager | |
CScopedLineState | |
CTokenAnalyzer | |
CTokenAnnotator | Determines extra information about the tokens comprising an UnwrappedLine |
CTokenRole | |
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 | |
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 |
►Nindex | |
►CCodegenNameGenerator | |
CImplementation | |
CCommentToXMLConverter | |
►CIndexDataConsumer | |
CASTNodeInfo | |
CIndexingContext | |
CIndexingOptions | |
CSimpleFormatContext | A small class to be used by libclang clients to format a declaration string in memory |
CSymbolInfo | |
CSymbolRelation | Represents a relation to another symbol for a symbol occurrence |
►Nreachable_code | |
CCallback | |
►Nsema | |
CAccessedEntity | A declaration being accessed, together with information about how it was accessed |
►CAnalysisBasedWarnings | |
CPolicy | |
CBlockScopeInfo | Retains information about a block that is currently being parsed |
CCapture | |
CCapturedRegionScopeInfo | Retains information about a captured region |
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 | |
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 |
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 | |
CDeclarationNameKey | A key used when looking up entities by DeclarationName |
CDeclOffset | Source range/offset of a preprocessed entity |
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 |
CLocalRedeclarationsInfo | Describes the redeclarations of a declaration |
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 |
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 |
CSLocEntry | This is a discriminated union of FileInfo and ExpansionInfo |
►Ntargets | |
CAArch64beTargetInfo | |
CAArch64leTargetInfo | |
CAArch64TargetInfo | |
CAMDGPUTargetInfo | |
CAnanasTargetInfo | |
CAndroidX86_32TargetInfo | |
CAndroidX86_64TargetInfo | |
CARCTargetInfo | |
CARMbeTargetInfo | |
CARMleTargetInfo | |
CARMTargetInfo | |
CAVRTargetInfo | |
CBPFTargetInfo | |
CCloudABITargetInfo | |
CCygwinARMTargetInfo | |
CCygwinX86_32TargetInfo | |
CCygwinX86_64TargetInfo | |
CDarwinAArch64TargetInfo | |
CDarwinARMTargetInfo | |
CDarwinI386TargetInfo | |
CDarwinPPC32TargetInfo | |
CDarwinPPC64TargetInfo | |
CDarwinTargetInfo | |
CDarwinX86_64TargetInfo | |
CDragonFlyBSDTargetInfo | |
CFreeBSDTargetInfo | |
CFuchsiaTargetInfo | |
CHaikuTargetInfo | |
CHaikuX86_32TargetInfo | |
CHexagonTargetInfo | |
CHurdTargetInfo | |
CItaniumWindowsARMleTargetInfo | |
CKFreeBSDTargetInfo | |
CLanaiTargetInfo | |
CLe64TargetInfo | |
CLinuxTargetInfo | |
CMCUInfo | Information about a specific microcontroller |
CMCUX86_32TargetInfo | |
CMicrosoftARM64TargetInfo | |
CMicrosoftARMleTargetInfo | |
CMicrosoftX86_32TargetInfo | |
CMicrosoftX86_64TargetInfo | |
CMinGWARM64TargetInfo | |
CMinGWARMTargetInfo | |
CMinGWX86_32TargetInfo | |
CMinGWX86_64TargetInfo | |
CMinixTargetInfo | |
CMipsTargetInfo | |
CMSP430TargetInfo | |
CNaClMips32TargetInfo | |
CNaClTargetInfo | |
CNetBSDI386TargetInfo | |
CNetBSDTargetInfo | |
CNVPTXTargetInfo | |
COpenBSDI386TargetInfo | |
COpenBSDTargetInfo | |
COpenBSDX86_64TargetInfo | |
COSTargetInfo | |
CPNaClTargetInfo | |
CPPC32TargetInfo | |
CPPC64TargetInfo | |
CPPCTargetInfo | |
CPS3PPUTargetInfo | |
CPS4OSTargetInfo | |
CPSPTargetInfo | |
CRenderScript32TargetInfo | |
CRenderScript64TargetInfo | |
CRISCV32TargetInfo | |
CRISCV64TargetInfo | |
CRISCVTargetInfo | |
CRTEMSTargetInfo | |
CRTEMSX86_32TargetInfo | |
CSolarisTargetInfo | |
CSparcTargetInfo | |
CSparcV8elTargetInfo | |
CSparcV8TargetInfo | |
CSparcV9TargetInfo | |
CSPIR32TargetInfo | |
CSPIR64TargetInfo | |
CSPIRTargetInfo | |
CSystemZTargetInfo | |
CTCELETargetInfo | |
CTCETargetInfo | |
CWebAssembly32TargetInfo | |
CWebAssembly64TargetInfo | |
CWebAssemblyOSTargetInfo | |
CWebAssemblyTargetInfo | |
CWindowsARM64TargetInfo | |
CWindowsARMTargetInfo | |
CWindowsTargetInfo | |
CWindowsX86_32TargetInfo | |
CWindowsX86_64TargetInfo | |
CX86_32TargetInfo | |
CX86_64TargetInfo | |
CX86TargetInfo | |
CXCoreTargetInfo | |
►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 | |
►Nfixit | |
►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 > | |
►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 |
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 | |
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 |
CTranslationUnitDiagnostics | Collection of Diagnostics generated from a single translation unit |
CTranslationUnitReplacements | Collection of Replacements generated from a single translation unit |
CUSRFindingAction | |
CUSRSymbolRenamer | |
CAbstractConditionalOperator | AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOperator |
CAccessSpecDecl | Represents an access specifier followed by colon ':' |
CActionResult | ActionResult - This structure is used while parsing/acting on expressions, stmts, etc |
CActionResult< PtrTy, true > | |
CAddFlagValue | |
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 or method under analysis |
CAnalysisDeclContextManager | |
CAnalyzerOptions | Stores options for the analyzer from the command line |
CAnyFunctionDecl | Represents any kind of function declaration, whether it is a concrete function or a function template |
CAPFixedPoint | Works similarly to APInt/APSInt in that it is a functional replacement for a scaled integer |
CAPFloatStorage | |
CAPIntStorage | |
CAPNumericStorage | Used by IntegerLiteral/FloatingLiteral 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] |
CLV | |
CLValueBase | |
CLValuePathEntry | |
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 | |
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 |
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 |
CBlockVarCopyInit | Copy initialization expr of a __block variable and a boolean flag that indicates whether the expression can throw |
CDynTypedNodeList | Container for either a single DynTypedNode or for an ArrayRef to DynTypedNode |
►CParentMap | |
CASTVisitor | A RecursiveASTVisitor that builds a map from nodes to their parents as defined by the RecursiveASTVisitor |
CRawCommentAndCacheFlags | |
CSectionInfo | |
CASTDeclListAction | |
CASTDeclReader | |
CASTDeclWriter | |
CASTDeserializationListener | |
CASTDumpAction | |
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 |
CASTImporterLookupTable | |
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 |
CASTNodeImporter | |
CASTPrintAction | |
►CASTReader | Reads an AST files chain containing the contents of a translation unit |
CImportedSubmodule | |
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 |
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>" |
CASTTypeWriter | |
►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 |
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 |
CAtomicScopeModel | Defines the interface for synch scope model |
CAtomicScopeOpenCLModel | Defines the synch scope model for OpenCL |
CAtomicType | |
CAtomicTypeLoc | |
CAtomicTypeLocInfo | |
CAttr | Attr - This represents one attribute |
CAttributedLocInfo | |
CAttributedStmt | Represents an attribute applied to a statement |
CAttributedType | An attributed type is a type to which a type attribute has been applied |
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 | |
CAttrVisitor | A simple visitor class that helps create attribute visitors |
CAutoType | Represents a C++11 auto or C++14 decltype(auto) type |
CAutoTypeLoc | |
CAvailabilityChange | Represents information about a change in availability for an entity, which is part of the encoding of the 'availability' attribute |
CAvailabilitySpec | One specifier in an expression |
CBackendConsumer | |
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 { .. |
CBaseSubobject | |
CBeforeThanCompare | Comparison function object |
CBeforeThanCompare< RawComment > | Compare comments' source locations |
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 |
CBlockCall | |
►CBlockDecl | Pepresents 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 | |
CBlockPointerType | Pointer to a block type |
CBlockPointerTypeLoc | Wrapper for source info for block pointers |
CBodyFarm | |
CBreakStmt | BreakStmt - This represents a break |
CBuildPreambleErrorCategory | |
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 | |
CCallEnter | Represents a point when we begin processing an inlined call |
CCallEventManager | Manages the lifetime of CallEvent objects |
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 | |
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 |
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 |
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 |
CCGOpenMPSIMDRuntime | Class supports emissionof SIMD-only code |
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 |
CChooseExpr | ChooseExpr - GNU builtin-in function __builtin_choose_expr |
CClangDiagnosticHandler | |
CClassScopeFunctionSpecializationDecl | Declaration of a function specialization at template class scope |
►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 | |
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 | |
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 |
CCompilerInvocation | Helper class for holding the data necessary to invoke the compiler |
CCompilerInvocationBase | |
CComplexType | Complex values, per C99 6.2.5p11 |
CComplexTypeLoc | |
CCompoundAssignOperator | CompoundAssignOperator - For compound assignments (e.g |
CCompoundLiteralExpr | CompoundLiteralExpr - [C99 6.5.2.5] |
CCompoundStmt | CompoundStmt - This represents a group of statements like { stmt stmt } |
►CConcreteTypeLoc | A metaprogramming base class for TypeLoc classes which correspond to a particular Type subclass |
CHasNoInnerType | |
CConditionalOperator | ConditionalOperator - The ?: ternary operator |
CConstantArrayType | Represents the canonical version of C arrays with a specified constant size |
CConstantArrayTypeLoc | |
CConstantExpr | ConstantExpr - An expression that occurs in a constant context |
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 |
CConstrainedTemplateDeclInfo | Stores the template parameter list and associated constraints for TemplateDecl objects that track associated constraints |
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 |
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 |
CCoverageSourceInfo | Stores additional source code information like skipped ranges which is required by the coverage mapping generator and is obtained from the preprocessor |
CCoyieldExpr | Represents a 'co_yield' expression |
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 |
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 |
►CCXXABI | Implements C++ ABI-specific semantic analysis functions |
CMemberPointerInfo | |
CCXXAllocatorCall | Represents the memory allocation call in a C++ new-expression |
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 |
CCXXConstructorCall | 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 |
CCXXDestructorCall | Represents an implicit call to a C++ destructor |
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 |
CCXXInstanceCall | Represents a non-static C++ member function call, no matter how it is written |
CCXXMemberCall | Represents a non-static C++ member function call |
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 |
CCXXMemberOperatorCall | Represents a C++ overloaded operator call where the operator is implemented as a non-static 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 |
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 |
CCXXReinterpretCastExpr | A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]) |
CCXXScalarValueInitExpr | An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type |
CCXXScopeSpec | Represents a C++ nested-name-specifier or a global scope specifier |
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 |
CDataflowValues | DataflowValues. Container class to store dataflow values for a CFG |
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 correspnding source/type location info |
►CDeclarationNameLoc | DeclarationNameLoc - Additional source/type location info for a declaration name |
CCXXLitOpName | |
CCXXOpName | |
CNT | |
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 |
►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 |
Cddiag_iterator | An iterator over the dependent diagnostics in a dependent context |
Cdecl_iterator | Decl_iterator - Iterates through the declarations stored within this context |
Cfiltered_decl_iterator | Iterates over a filtered subrange of declarations stored in a DeclContext |
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) |
Cudir_iterator | |
►CDeclContextLookupResult | The results of name lookup within a DeclContext |
Citerator | |
CDeclContextPrintAction | |
CDeclFilterCCC | Simple template class for restricting typo correction candidates to ones having a single Decl* of the given type |
CDeclGroup | |
CDeclGroupRef | |
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 |
CDecltypeType | Represents the type decltype(expr) (C++11) |
CDecltypeTypeLoc | |
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 |
CDeducedTemplateSpecializationType | Represents a C++17 deduced template specialization type |
CDeducedTemplateSpecializationTypeLoc | |
CDeducedType | Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced class template types, and (eventually) constrained type names from the C++ Concepts TS |
CDeducedTypeLoc | |
CDeductionFailureInfo | A structure used to record information about a failed template argument deduction, for diagnosis |
CDefaultArgStorage | Storage for a default argument |
CDefaultInitializedTypeVisitor | |
CDefaultStmt | |
CDefMacroDirective | A directive for a defined macro or a macro imported from a module |
CDeltaTree | DeltaTree - a multiway search tree (BTree) structure with some fancy features |
CDependencyCollector | An interface for collecting the dependencies of a compilation |
CDependencyFileGenerator | Builds a depdenency 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 | |
CDependentCoawaitExpr | Represents a 'co_await' expression while the type of the promise is dependent |
CDependentDecltypeType | Internal representation of canonical, dependent decltype(expr) types |
CDependentDiagnostic | A dependently-generated diagnostic |
CDependentFunctionTemplateSpecializationInfo | Provides information about a dependent function-template specialization declaration |
CDependentNameLocInfo | |
CDependentNameType | Represents a qualified type name for which the type name is dependent |
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 | |
CDependentStoredDeclsMap | |
CDependentTemplateName | Represents a dependent template name that cannot be resolved prior to template instantiation |
CDependentTemplateSpecializationLocInfo | |
CDependentTemplateSpecializationType | Represents a template specialization type whose template cannot be resolved, e.g |
CDependentTemplateSpecializationTypeLoc | |
CDependentTypeOfExprType | Internal representation of canonical, dependent typeof(expr) types |
CDependentUnaryTransformType | Internal representation of canonical, dependent __underlying_type(type) types |
CDependentVectorType | Represents a vector type where either the type or size is dependent |
CDependentVectorTypeLoc | |
►CDesignatedInitExpr | Represents a C99 designated initializer expression |
CArrayOrRangeDesignator | An array or GNU array-range designator, e.g., "[9]" or "[10..15]" |
CDesignator | Represents a single C99 designator |
CFieldDesignator | A field designator, e.g., ".x" |
CDesignatedInitUpdateExpr | |
CDesignation | Designation - Represent a full designation, which is a sequence of designators |
CDesignator | Designator - A designator in a C99 designated initializer |
CDestroyTemplateIdAnnotationsRAIIObj | RAIIObject to destroy the contents of a SmallVector of TemplateIdAnnotation pointers and clear the vector |
CDestructedTypeVisitor | |
CDiagnostic | A little helper class (which is basically a smart pointer that forwards info from DiagnosticsEngine) that allows clients to enquire about the currently in-flight 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 |
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 |
CDirectoryEntry | Cached information about one directory (either on disk or in the virtual file system) |
CDirectoryLookup | DirectoryLookup - This class represents one entry in the search list that specifies the search order for directories in #include directives |
CDominatorTree | Concrete subclass of DominatorTreeBase for Clang This class implements the dominators tree functionality given a Clang CFG |
CDoStmt | DoStmt - This represents a 'do/while' stmt |
CDumpCompilerOptionsAction | |
CDumpModuleInfoAction | Dump information about the given module file, to be used for basic debugging and discovery |
CDumpRawTokensAction | |
CDumpTokensAction | |
CElaboratedLocInfo | |
CElaboratedType | Represents a type that was referred to using an elaborated type keyword, e.g., struct S, or via a qualified name, e.g., N::M::type, or both |
CElaboratedTypeLoc | |
CElidedTemporaryObjectConstructionContext | Represents a temporary object that is constructed for the sole purpose of being immediately copied by an elidable copy/move constructor |
CEmitAssemblyAction | |
CEmitBCAction | |
CEmitCodeGenOnlyAction | |
CEmitLLVMAction | |
CEmitLLVMOnlyAction | |
CEmitObjAction | |
CEmptyDecl | Represents an empty-declaration |
CEmptyPragmaHandler | EmptyPragmaHandler - A pragma handler which takes no action, which can be used to ignore particular pragmas |
CEnterExpressionEvaluationContext | RAII object that enters a new expression evaluation context |
CEnumConstantDecl | An instance of this object exists for each enum constant that is defined |
CEnumDecl | Represents an enum |
CEnumType | A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums |
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) |
CExplicitCastExpr | ExplicitCastExpr - An explicit cast written in the source code |
CExportDecl | Represents a C++ Modules TS 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 |
CExpressionTraitExpr | An expression trait intrinsic |
CExprMutationAnalyzer | Analyzes whether any mutative operations are applied to an expression within a given statement |
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 |
CASTSourceDescriptor | Abstracts clang modules and precompiled header files and holds everything needed to generate debug info for an imported module or PCH |
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 |
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 |
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 |
CFileData | |
CFileEntry | Cached information about one file (either on disk or in the virtual file system) |
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 | |
CFixedPointSemantics | The fixed point semantics work similarly to llvm::fltSemantics |
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 | |
CFloatingLiteral | |
CForStmt | ForStmt - This represents a 'for (init;cond;inc)' stmt |
CForwardingDiagnosticConsumer | Diagnostic consumer that forwards diagnostics along to an existing, already-initialized diagnostic consumer |
CFPOptions | Floating point control options |
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 |
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 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 |
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) |
CGenerateHeaderModuleAction | |
CGenerateModuleAction | |
CGenerateModuleFromModuleMapAction | |
CGenerateModuleInterfaceAction | |
CGeneratePCHAction | |
CGenericSelectionExpr | Represents a C11 generic selection |
CGlobalCodeCompletionAllocator | Allocator for a cached set of global code completions |
CGlobalDecl | GlobalDecl - represents a global declaration |
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 |
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 | |
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 | Wraps an identifier and optional source location for the identifier |
►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" |
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 |
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) |
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 |
CImportError | |
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 | |
CIndirectFieldDecl | Represents a field injected from an anonymous union/struct into the parent scope |
CIndirectGotoStmt | IndirectGotoStmt - This represents an indirect goto |
CInheritableAttr | |
CInheritableParamAttr | |
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 | |
CInjectedClassNameType | The injected class name of a C++ class template or class template partial specialization |
CInjectedClassNameTypeLoc | Wrapper for source info for injected class names of class templates |
CInMessageExpressionRAIIObject | |
CInputKind | The kind of a file that we've been handed as an input |
CIntegerLiteral | |
CIsResultPtrLowBitFree | |
CIsResultPtrLowBitFree< CXXBaseSpecifier * > | |
CIsResultPtrLowBitFree< CXXCtorInitializer * > | |
CIsResultPtrLowBitFree< Expr * > | |
CIsResultPtrLowBitFree< Stmt * > | |
CItaniumMangleContext | |
CItaniumVTableContext | |
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 |
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 |
►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 |
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 |
CLexer | Lexer - This provides a simple interface that turns a text buffer into a stream of tokens |
CLexicallyOrderedRecursiveASTVisitor | A RecursiveASTVisitor subclass that guarantees that AST traversal is performed in a lexical order (i.e |
CLineEntry | |
CLineTableInfo | Used to hold and unique data used to represent #line information |
CLinkageComputer | |
CLinkageInfo | |
CLinkageSpecDecl | Represents a linkage specification |
►CLiveVariables | |
CLivenessValues | |
CObserver | |
CLocalInstantiationScope | A stack-allocated class that identifies which local variable declaration instantiations are present in this scope |
CLocationCheck | |
CLocationContext | |
CLocationContextManager | |
CLocInfoType | Holds a QualType and a TypeSourceInfo* that came out of a declarator parsing |
CLogDiagnosticPrinter | |
►CLookupResult | Represents the results of name lookup |
CFilter | A class for iterating through a result set and possibly filtering out results |
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 |
CMacroInfo | Encapsulates the data about a macro definition (e.g |
CMacroPPCallbacks | |
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 |
CMemberExpr | MemberExpr - [C99 6.5.2.3] Structure and Union Members |
CMemberExprNameQualifier | Extra data stored in some MemberExpr objects |
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 |
CMemoryBufferCache | Manage memory buffers across multiple users |
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 |
CMMToken | A token in a module map file |
►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 |
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 |
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 parser as it reads module map files |
CModuleMapParser | |
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 |
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 |
CNamedDecl | This represents a decl that may have a name |
CNamespaceAliasDecl | Represents a C++ namespace alias |
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 |
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 |
CNoTypoCorrectionCCC | |
CNSAPI | |
CNullStmt | NullStmt - This is the null statement ";": C99 6.8.3p3 |
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 | Interfaces are the core concept in Objective-C for object oriented design |
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 |
CObjCMethodCall | Represents any expression that calls an Objective-C method |
►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 |
CObjCObjectType | Represents a class type in Objective C |
CObjCObjectTypeImpl | A class providing a concrete implementation of ObjCObjectType, so as to not increase the footprint of ObjCInterfaceType |
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 |
CObjCProtocolQualifiers | This class wraps the list of protocol qualifiers |
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 |
CObjCTypeParamType | Represents a type parameter type in Objective C |
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 |
CODRHash | |
COffsetOfExpr | OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator) |
COffsetOfNode | Helper class for OffsetOfExpr |
COMPArraySectionExpr | OpenMP 4.0 [2.4, Array Sections] |
COMPAtomicDefaultMemOrderClause | This represents 'atomic_default_mem_order' clause in the '#pragma omp requires' directive |
COMPAtomicDirective | This represents '#pragma omp atomic' directive |
COMPBarrierDirective | This represents '#pragma omp barrier' directive |
COMPCancelDirective | This represents '#pragma omp cancel' directive |
COMPCancellationPointDirective | This represents '#pragma omp cancellation point' directive |
COMPCaptureClause | This represents 'capture' clause in the '#pragma omp atomic' directive |
COMPCapturedExprDecl | Pseudo declaration for capturing expressions |
COMPClause | This is a basic class for representing single OpenMP clause |
COMPClauseReader | |
COMPClauseWithPostUpdate | Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc |
COMPClauseWithPreInit | Class that handles pre-initialization statement for some clauses, like 'shedule', 'firstprivate' etc |
COMPClauseWriter | |
COMPCollapseClause | This represents 'collapse' clause in the '#pragma omp ...' directive |
COMPCriticalDirective | This represents '#pragma omp critical' directive |
COMPDeclareReductionDecl | This represents '#pragma omp declare reduction ...' directive |
COMPDefaultClause | This represents 'default' clause in the '#pragma omp ...' 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 |
COMPDynamicAllocatorsClause | This represents 'dynamic_allocators' clause in the '#pragma omp requires' directive |
►COMPExecutableDirective | This is a basic class for representing single OpenMP executable directive |
Cspecific_clause_iterator | Iterates over a filtered subrange of clauses applied to a directive |
COMPFinalClause | This represents 'final' clause in the '#pragma omp ...' directive |
COMPFirstprivateClause | This represents clause 'firstprivate' in the '#pragma omp ...' directives |
COMPFlushDirective | This represents '#pragma omp flush' directive |
COMPForDirective | This represents '#pragma omp for' directive |
COMPForSimdDirective | This represents '#pragma omp for simd' directive |
COMPIfClause | This represents 'if' clause in the '#pragma omp ...' directive |
COMPInReductionClause | This represents clause 'in_reduction' in the '#pragma omp task' directives |
COMPLastprivateClause | This represents clause 'lastprivate' in the '#pragma omp ...' directives |
COMPLinearClause | This represents clause 'linear' in the '#pragma omp ...' directives |
►COMPLoopDirective | This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc.) |
CDistCombinedHelperExprs | The expressions built to support OpenMP loops in combined/composite pragmas (e.g |
CHelperExprs | The expressions built for the OpenMP loop CodeGen for the whole collapsed loop nest |
COMPMasterDirective | This represents '#pragma omp master' directive |
COMPMergeableClause | This represents 'mergeable' clause in the '#pragma omp ...' directive |
COMPNowaitClause | This represents 'nowait' clause in the '#pragma omp ...' directive |
COMPNumThreadsClause | This represents 'num_threads' clause in the '#pragma omp ...' directive |
COMPOrderedClause | This represents 'ordered' clause in the '#pragma omp ...' directive |
COMPOrderedDirective | This represents '#pragma omp ordered' directive |
COMPParallelDirective | This represents '#pragma omp parallel' directive |
COMPParallelForDirective | This represents '#pragma omp parallel for' directive |
COMPParallelForSimdDirective | This represents '#pragma omp parallel for simd' directive |
COMPParallelSectionsDirective | This represents '#pragma omp parallel sections' 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 |
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 |
COMPSectionDirective | This represents '#pragma omp section' directive |
COMPSectionsDirective | This represents '#pragma omp sections' directive |
COMPSeqCstClause | This represents 'seq_cst' clause in the '#pragma omp atomic' directive |
COMPSharedClause | This represents clause 'shared' in the '#pragma omp ...' directives |
COMPSimdDirective | This represents '#pragma omp simd' directive |
COMPSimdlenClause | This represents 'simdlen' clause in the '#pragma omp ...' directive |
COMPSingleDirective | This represents '#pragma omp single' 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 |
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 |
COMPTargetUpdateDirective | This represents '#pragma omp target update' directive |
COMPTaskDirective | This represents '#pragma omp task' directive |
COMPTaskgroupDirective | This represents '#pragma omp taskgroup' directive |
COMPTaskLoopDirective | This represents '#pragma omp taskloop' directive |
COMPTaskLoopSimdDirective | This represents '#pragma omp taskloop simd' directive |
COMPTaskReductionClause | This represents clause 'task_reduction' in the '#pragma omp taskgroup' directives |
COMPTaskwaitDirective | This represents '#pragma omp taskwait' directive |
COMPTaskyieldDirective | This represents '#pragma omp taskyield' 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 |
COMPThreadPrivateDecl | This represents '#pragma omp threadprivate ...' directive |
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 |
COMPVarListClause | This represents clauses with the list of variables like 'private', 'firstprivate', 'copyin', 'shared', or 'reduction' clauses in the '#pragma omp ...' directives |
COMPWriteClause | This represents 'write' clause in the '#pragma omp atomic' 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 |
COpenCLOptions | OpenCL supported extensions and optional core features |
COpenMPScheduleTy | Scheduling data for loop-based OpenMP directives |
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) |
COverloadedTemplateStorage | A structure for storing the information associated with an overloaded template name |
►COverloadExpr | A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr |
CFindResult | |
COverridingMethods | The set of methods that override a given virtual method in each subobject where it occurs |
CPackExpansionExpr | Represents a C++11 pack expansion that produces a sequence of expressions |
CPackExpansionType | Represents a pack expansion of types |
CPackExpansionTypeLoc | |
CPackExpansionTypeLocInfo | |
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 parethesized expression, e.g |
CParenListExpr | |
CParenLocInfo | |
CParentMap | |
CParenType | Sugar for parentheses used when specifying types |
CParenTypeLoc | |
CParmVarDecl | Represents a parameter to a function |
CParsedAttr | ParsedAttr - Represents a syntactic attribute |
CParsedAttributes | ParsedAttributes - A collection of parsed attributes |
►CParsedAttributesView | |
Cconst_iterator | |
Citerator | |
CParsedSourceLocation | A source location that has been parsed on the command line |
CParsedSourceRange | A source range that has been parsed on the command line |
CParsedTemplateArgument | Represents the parsed form of a C++ template argument |
►CParser | Parser - This implements a parser for the C family of languages |
CConditionDeclarationOrInitStatementState | |
CObjCTypeParamListScope | Class to handle popping type parameters when leaving the scope |
COpenMPVarListDataTy | Data used for parsing list of variables in OpenMP clauses |
CParseScope | ParseScope - Introduces a new scope for parsing |
CUnannotatedTentativeParsingAction | A tentative parsing action that can also revert token annotations |
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 |
►CPartialDiagnostic | |
CNullDiagnostic | |
CStorage | |
CStorageAllocator | An allocator for Storage objects, which uses a small cache to objects, used to reduce malloc()/free() traffic for partial diagnostics |
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 | |
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 | |
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 |
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 |
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 |
CPredefinedExpr | [C99 6.4.2.2] - A predefined identifier such as func |
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 |
CCachedTokensRange | |
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() |
CFailedModulesSet | Records the set of modules |
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 |
CPrinterHelper | |
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 | |
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 that was expressed as a qualified name |
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 |
►CQualType | A (possibly-)qualified type |
CStreamedQualTypeHelper | |
CQualTypeOrdering | Function object that provides a total ordering on QualType values |
CRawComment | |
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 |
CRecordDecl | Represents a struct/union/class |
CRecordType | A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/classes |
CRecordTypeLoc | Wrapper for source info for record types |
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 | |
CReferenceType | Base for LValueReferenceType and RValueReferenceType |
CReferenceTypeLoc | |
CRelaxedLiveVariables | |
►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; |
CRewriteBuffer | RewriteBuffer - As code is rewritten, SourceBuffer's from the original input with modifications get a new RewriteBuffer associated with them |
►CRewriteIncludesAction | |
CRewriteImportsListener | |
CRewriteMacrosAction | |
CRewriteObjCAction | |
►CRewriter | Rewriter - This is the main interface to the rewrite buffers |
CRewriteOptions | |
CRewriteRope | RewriteRope - A powerful string class |
CRewriteTestAction | |
CRopePiece | RopePiece - This class represents a view into a RopeRefCountString object |
CRopePieceBTree | |
CRopePieceBTreeIterator | RopePieceBTreeIterator - This class provides read-only forward iteration over bytes that are in a RopePieceBTree |
CRopeRefCountString | RopeRefCountString - This struct is allocated with 'new char[]' from the heap, and represents a reference counted chunk of string data |
CRValueReferenceType | An rvalue reference type, per C++11 [dcl.ref] |
CRValueReferenceTypeLoc | |
CSanitizerBlacklist | |
CSanitizerSet | |
►CSanitizerSpecialCaseList | |
CSanitizerSection | |
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 |
CScopeContext | |
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 | |
CArgumentPackSubstitutionIndexRAII | RAII object used to change the argument pack substitution index within a Sema object |
CBoundTypeDiagnoser | |
CCodeCompleteExpressionData | |
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 | |
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 |
CCUDADiagBuilder | Diagnostic builder for CUDA errors which may or may not be deferred |
CCXXThisScopeRAII | RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers on the current class type |
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 |
CExtParameterInfoBuilder | A helper class for building up ExtParameterInfos |
CFPContractStateRAII | Records and restores the FP_CONTRACT state on entry/exit of compound statements |
CFullExprArg | |
CFunctionDeclAndLoc | A pair of a canonical FunctionDecl and a SourceLocation |
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 |
CExceptionSpecification | |
CLateInstantiatedAttribute | |
CLocalEagerInstantiationScope | |
CNameClassification | |
CNestedNameSpecInfo | Keeps information about an identifier in a nested-name-spec |
CObjCArgInfo | |
COffsetOfComponent | |
COriginalCallArg | Brief A function argument from which we performed template argument |
CPackIncludeState | |
CPragmaAttributeEntry | This an attribute introduced by #pragma clang attribute |
CPragmaAttributeGroup | A push'd group of PragmaAttributeEntries |
CPragmaClangSection | |
►CPragmaStack | |
CSlot | |
CPragmaStackSentinelRAII | |
CSemaDiagnosticBuilder | Helper class that creates diagnostics with optional template instantiation stacks |
CSFINAETrap | RAII class used to determine whether SFINAE has trapped any errors that occur during template argument deduction |
CSkipBodyInfo | |
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 |
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 |
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 |
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 |
CSimpleVariableConstructionContext | Represents construction into a simple local variable, eg |
CSizeOfPackExpr | Represents an expression that computes the length of a parameter pack |
CSourceLocation | Encodes a location in the source |
►CSourceManager | This class handles loading and caching of source files into memory |
CMemoryBufferSizes | |
CSourceManagerForFile | SourceManager and necessary depdencies (e.g |
CSourceRange | A trivial tuple used to represent a source range |
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 |
CStackFrameContext | |
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 |
CArraySubscriptExprBitfields | |
CAttributedStmtBitfields | |
CBinaryOperatorBitfields | |
CBreakStmtBitfields | |
CCallExprBitfields | |
CCastExprBitfields | |
CCharacterLiteralBitfields | |
CCoawaitExprBitfields | |
CCompoundStmtBitfields | |
CConstExprIterator | Const iterator for iterating over Stmt * arrays that contain only Expr * |
CContinueStmtBitfields | |
CCXXBoolLiteralExprBitfields | |
CCXXConstructExprBitfields | |
CCXXDefaultArgExprBitfields | |
CCXXDefaultInitExprBitfields | |
CCXXDeleteExprBitfields | |
CCXXDependentScopeMemberExprBitfields | |
CCXXNewExprBitfields | |
CCXXNoexceptExprBitfields | |
CCXXNullPtrLiteralExprBitfields | |
CCXXOperatorCallExprBitfields | |
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 | |
CExprIterator | Iterator for iterating over Stmt * arrays that contain only Expr * |
CExprWithCleanupsBitfields | |
CFloatingLiteralBitfields | |
CForStmtBitfields | |
CGotoStmtBitfields | |
CIfStmtBitfields | |
CInitListExprBitfields | |
CLabelStmtBitfields | |
CMemberExprBitfields | |
CNullStmtBitfields | |
CObjCIndirectCopyRestoreExprBitfields | |
COpaqueValueExprBitfields | |
COverloadExprBitfields | |
CParenListExprBitfields | |
CPredefinedExprBitfields | |
CPseudoObjectExprBitfields | |
CReturnStmtBitfields | |
CStmtBitfields | |
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 |
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 | |
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 |
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 |
CSubstTemplateTypeParmPackType | Represents the result of substituting a set of types for a template type parameter pack |
CSubstTemplateTypeParmPackTypeLoc | Wrapper for substituted template type parameters |
CSubstTemplateTypeParmType | Represents the result of substituting a type for a template type parameter |
CSubstTemplateTypeParmTypeLoc | Wrapper for substituted template type parameters |
CSuppressAccessChecks | A RAII object used to temporarily suppress access-like checking |
CSwitchCase | |
CSwitchStmt | SwitchStmt - This represents a 'switch' stmt |
CSyntaxOnlyAction | |
CTagDecl | Represents the declaration of a struct/union/class/enum |
CTagType | |
CTagTypeLoc | Wrapper for source info for tag types |
CTargetCXXABI | The basic abstraction for the target C++ ABI |
►CTargetInfo | Exposes information about the current target |
CAddlRegName | |
CConstraintInfo | |
CGCCRegAlias | |
CTargetOptions | Options for controlling the target |
CTemplateArgument | Represents a template argument |
CTemplateArgumentList | A template argument list |
CTemplateArgumentListInfo | A convenient class for passing around template argument information |
CTemplateArgumentLoc | Location wrapper for a TemplateArgument |
►CTemplateArgumentLocContainerIterator | Simple iterator that traverses the template arguments in a container that provides a getArgLoc() member function |
Cpointer | |
CTemplateArgumentLocInfo | Location information for a TemplateArgument |
►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 |
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 | |
CTemplateSpecializationType | Represents a type template specialization; the template must be a class template, a type alias template, or a template template parameter |
CTemplateSpecializationTypeLoc | |
CTemplateTemplateParmDecl | TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in |
CTemplateTypeParmDecl | Declaration of a template type parameter |
CTemplateTypeParmType | |
CTemplateTypeParmTypeLoc | Wrapper for template type parameters |
CTemplightDumpAction | |
CTemporaryObjectConstructionContext | Represents a temporary object, eg |
CTerminalColor | |
CTestModuleFileExtension | A module file extension used for testing purposes |
CTextDiagnostic | Class to encapsulate the logic for formatting and printing a textual diagnostic message |
CTextDiagnosticBuffer | |
CTextDiagnosticPrinter | |
CTextNodeDumper | |
CTextTreeStructure | |
►CThisAdjustment | A this pointer adjustment |
CVirtualAdjustment | Holds the ABI-specific information about the virtual this adjustment, if needed |
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 | |
CTokenValue | Stores token information for comparing actual tokens with predefined values |
CTranslationUnitDecl | The top declaration context |
►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 |
CTrivialModuleLoader | A module loader that doesn't know how to load modules |
►CType | The base class of the type hierarchy |
CArrayTypeBitfields | |
CAttributedTypeBitfields | |
CAutoTypeBitfields | |
CBuiltinTypeBitfields | |
CDependentTemplateSpecializationTypeBitfields | |
CElaboratedTypeBitfields | |
CFunctionTypeBitfields | FunctionTypeBitfields store various bits belonging to FunctionProtoType |
CObjCObjectTypeBitfields | |
CPackExpansionTypeBitfields | |
CReferenceTypeBitfields | |
CSubstTemplateTypeParmPackTypeBitfields | |
CTemplateSpecializationTypeBitfields | |
CTypeWithKeywordBitfields | |
CVectorTypeBitfields | |
CTypeAliasDecl | Represents the declaration of a typedef-name via a C++11 alias-declaration |
CTypeAliasTemplateDecl | Declaration of an alias template |
CTypeAttr | |
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 |
CTypeInfo | |
CTypeLoc | Base wrapper for a particular "section" of type source info |
CTypeLocBuilder | |
CTypeLocReader | |
CTypeLocVisitor | |
CTypeOfExprType | Represents a typeof (or typeof) expression (a GCC extension) |
CTypeOfExprTypeLoc | |
CTypeOfExprTypeLocInfo | |
CTypeofLikeTypeLoc | |
CTypeofLocInfo | |
CTypeOfType | Represents typeof(type) , a GCC extension |
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 |
CCannotCastToThisType | |
CTypoCorrection | Simple class containing the result of Sema::CorrectTypo |
CTypoCorrectionConsumer | |
CTypoExpr | TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and/or an error diagnostic emitted |
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 |
CUnaryTransformType | A unary type transform, which is a type constructed from another |
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 |
►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 |
►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 |
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 |
CUpdateOnReturn | |
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 |
Cshadow_iterator | Iterates through the using shadow declarations associated with this using declaration |
CUsingDirectiveDecl | Represents C++ using-directive |
CUsingPackDecl | Represents a pack of using declarations that a single using-declarator pack-expanded into |
CUsingShadowDecl | Represents a shadow declaration introduced into a scope by a (resolved) using declaration |
CVAArgExpr | Represents a call to the builtin function __builtin_va_arg |
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 |
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 |
►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 | |
►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 |
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 |
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 | |
CWeakInfo | Captures information about a #pragma weak directive |
CWhileStmt | WhileStmt - This represents a 'while' stmt |
CWrapperFrontendAction | A frontend action which simply wraps some other runtime-specified frontend action |
CWrittenBuiltinSpecs | Structure that packs information about the type specifiers that were written in a particular type specifier sequence |
CXRayFunctionFilter | |
CXRayInstrSet | |
►Nllvm | DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterators |
►Ncl | |
Cparser< clang::ParsedSourceLocation > | Command-line option parser that parses source locations |
►Nyaml | |
CDocumentListTraits< std::vector< FormatStyle > > | |
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::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< FormatStyle > | |
CMappingTraits< FormatStyle::BraceWrappingFlags > | |
CMappingTraits< FormatStyle::RawStringFormat > | |
CMappingTraits< NormalizedAtomicChange > | Specialized MappingTraits to describe how an AtomicChange is (de)serialized |
CMappingTraits< TemplightEntry > | |
CScalarEnumerationTraits< clang::tooling::IncludeStyle::IncludeBlocksStyle > | |
CScalarEnumerationTraits< FormatStyle::BinaryOperatorStyle > | |
CScalarEnumerationTraits< FormatStyle::BinPackStyle > | |
CScalarEnumerationTraits< FormatStyle::BraceBreakingStyle > | |
CScalarEnumerationTraits< FormatStyle::BracketAlignmentStyle > | |
CScalarEnumerationTraits< FormatStyle::BreakConstructorInitializersStyle > | |
CScalarEnumerationTraits< FormatStyle::BreakInheritanceListStyle > | |
CScalarEnumerationTraits< FormatStyle::BreakTemplateDeclarationsStyle > | |
CScalarEnumerationTraits< FormatStyle::DefinitionReturnTypeBreakingStyle > | |
CScalarEnumerationTraits< FormatStyle::EscapedNewlineAlignmentStyle > | |
CScalarEnumerationTraits< FormatStyle::JavaScriptQuoteStyle > | |
CScalarEnumerationTraits< FormatStyle::LanguageKind > | |
CScalarEnumerationTraits< FormatStyle::LanguageStandard > | |
CScalarEnumerationTraits< FormatStyle::NamespaceIndentationKind > | |
CScalarEnumerationTraits< FormatStyle::PointerAlignmentStyle > | |
CScalarEnumerationTraits< FormatStyle::PPDirectiveIndentStyle > | |
CScalarEnumerationTraits< FormatStyle::ReturnTypeBreakingStyle > | |
CScalarEnumerationTraits< FormatStyle::ShortFunctionStyle > | |
CScalarEnumerationTraits< FormatStyle::SpaceBeforeParensOptions > | |
CScalarEnumerationTraits< FormatStyle::UseTabStyle > | |
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*) |
CDenseMapInfo | |
CDenseMapInfo< CatchHandlerType > | |
CDenseMapInfo< clang::APValue::LValueBase > | |
CDenseMapInfo< clang::ast_type_traits::ASTNodeKind > | |
CDenseMapInfo< clang::ast_type_traits::DynTypedNode > | |
CDenseMapInfo< clang::BaseSubobject > | |
CDenseMapInfo< clang::CanonicalDeclPtr< decl_type > > | |
CDenseMapInfo< clang::CanQualType > | |
CDenseMapInfo< clang::CharUnits > | |
CDenseMapInfo< clang::CodeGen::TBAAAccessInfo > | |
CDenseMapInfo< clang::DeclarationName > | Define DenseMapInfo so that DeclarationNames can be used as keys in DenseMap and DenseSets |
CDenseMapInfo< clang::FileID > | Define DenseMapInfo so that FileID's can be used as keys in DenseMap and DenseSets |
CDenseMapInfo< clang::GlobalDecl > | |
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::Sema::FunctionDeclAndLoc > | |
CDenseMapInfo< clang::serialization::DeclarationNameKey > | |
CDenseMapInfo< DecompositionDeclName > | |
CDenseMapInfo< EditEntry > | |
CDenseMapInfo< ObjCSummaryKey > | |
CDenseSet | |
CDOTGraphTraits< const CallGraph * > | |
CDOTGraphTraits< const CFG * > | |
CDOTGraphTraits< const Stmt * > | |
CDOTGraphTraits< ExplodedGraph * > | |
CDOTGraphTraits< ModuleManager > | |
CExpected | |
CFoldingSetTrait< AllocKind > | |
CFoldingSetTrait< ArgEffect > | |
CFoldingSetTrait< ObjectState > | |
CFoldingSetTrait< RetEffect > | |
CFoldingSetTrait< SValData > | |
CFoldingSetTrait< SValPair > | |
CGraphTraits< ::clang::CFG *> | |
CGraphTraits< ::clang::CFGBlock * > | |
CGraphTraits< ::clang::DominatorTree *> | |
CGraphTraits< ::clang::DomTreeNode *> | |
CGraphTraits< clang::CallGraph * > | |
CGraphTraits< clang::CallGraphNode * > | |
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 > | |
CIntrusiveRefCntPtr | |
CIntrusiveRefCntPtrInfo | |
CIntrusiveRefCntPtrInfo< const clang::ento::ProgramState > | |
Cisa_impl< To, ::clang::DeclContext > | Isa<T>(DeclContext*) |
CisPodLike | |
CisPodLike< BindingKey > | |
CisPodLike< clang::BaseSubobject > | |
CisPodLike< clang::CharUnits > | |
CisPodLike< clang::CodeCompletionString::Chunk > | |
CisPodLike< clang::DeclAccessPair > | |
CisPodLike< clang::DeclarationName > | |
CisPodLike< clang::ento::SVal > | |
CisPodLike< clang::FileID > | |
CisPodLike< clang::GlobalDecl > | |
CisPodLike< clang::ObjCDictionaryElement > | |
CisPodLike< clang::OpaquePtr< T > > | |
CisPodLike< clang::ProgramPoint > | |
CisPodLike< clang::QualType > | |
CisPodLike< clang::Selector > | |
CisPodLike< clang::SourceLocation > | |
CisPodLike< clang::Token > | |
CMutableArrayRef | |
COptional | |
COwningArrayRef | |
CPointerLikeTypeTraits | |
CPointerLikeTypeTraits< ::clang::AnyFunctionDecl > | |
CPointerLikeTypeTraits< ::clang::CodeGen::ConstantInitBuilderBase * > | |
CPointerLikeTypeTraits< ::clang::CodeGen::ConstantInitFuture > | |
CPointerLikeTypeTraits< ::clang::ExtQuals * > | |
CPointerLikeTypeTraits< ::clang::Type * > | |
CPointerLikeTypeTraits< clang::CanQual< T > > | |
CPointerLikeTypeTraits< clang::DeclGroupRef > | |
CPointerLikeTypeTraits< clang::IdentifierInfo * > | |
CPointerLikeTypeTraits< clang::LazyGenerationalUpdatePtr< Owner, T, Update > > | |
CPointerLikeTypeTraits< clang::OpaquePtr< T > > | |
CPointerLikeTypeTraits< clang::QualType > | |
CPointerLikeTypeTraits< clang::Selector > | |
CPointerLikeTypeTraits< clang::SourceLocation > | |
CPointerLikeTypeTraits< clang::TemplateName > | The clang::TemplateName class is effectively a pointer |
CPointerLikeTypeTraits< const clang::IdentifierInfo * > | |
CRefCountedBase | |
CSaveAndRestore | |
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 > > | |
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 > | |
C__clang_cuda_enable_if | |
C__clang_cuda_enable_if< true, __T > | |
C__cuda_builtin_blockDim_t | |
C__cuda_builtin_blockIdx_t | |
C__cuda_builtin_gridDim_t | |
C__cuda_builtin_threadIdx_t | |
C_Unwind_Exception | |
CAnyFunctionCall | |
Catomic_flag | |
Cbasic_parser | |
CBugReporterVisitor | |
CCallEvent | |
CCGBuilderBaseTy | |
CCGOpenMPRuntime | |
CCHECK1 | |
CCleanupTy | A basic class for pre|post-action for advanced codegen sequence for OpenMP region |
CCommonBase | |
CConstOMPClauseVisitor | |
CCopyOptionsTy | |
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 | |
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 |
CDefaultDOTGraphTraits | |
CDefinedTracker | DefinedTracker - This struct is used while parsing expressions to keep track of whether !defined(X) has been seen |
CDereferenceInfo | |
CDiagnosticHandler | |
CExitFunctionBodyRAII | RAII object that pops an ExpressionEvaluationContext when exiting a function body |
CGraphTraits | |
CIndexerCallbacks | A group of callbacks used by clang_indexSourceFile and clang_indexTranslationUnit |
CISANameRevision | |
CIsPartialSpecialization | |
CIsPartialSpecialization< ClassTemplatePartialSpecializationDecl > | |
CIsPartialSpecialization< VarTemplatePartialSpecializationDecl > | |
CIteratorBase | |
CLoopState | |
Cmax_align_t | |
Cndrange_t | |
COMPAlignedClause | This represents clause 'aligned' in the '#pragma omp ...' directives |
COMPClause | |
►COMPClauseMappableExprCommon | Struct that defines common infrastructure to handle mappable expressions used in OpenMP clauses |
CMappableComponent | Class that represents a component of a mappable expression |
COMPClausePrinter | |
COMPClauseVisitor | |
COMPClauseVisitorBase | This class implements a simple visitor for OMPClause subclasses |
COMPClauseWithPreInit | |
COMPCopyinClause | This represents clause 'copyin' in the '#pragma omp ...' directives |
COMPCopyprivateClause | This represents clause 'copyprivate' in the '#pragma omp ...' directives |
COMPDefaultmapClause | This represents 'defaultmap' clause in the '#pragma omp ...' directive |
COMPDependClause | This represents implicit clause 'depend' for the '#pragma omp task' directive |
COMPDeviceClause | This represents 'device' clause in the '#pragma omp ...' directive |
COMPDistScheduleClause | This represents 'dist_schedule' clause in the '#pragma omp ...' directive |
COMPFlushClause | This represents implicit clause 'flush' for the '#pragma omp flush' directive |
COMPFromClause | This represents clause 'from' in the '#pragma omp ...' directives |
COMPGrainsizeClause | This represents 'grainsize' clause in the '#pragma omp ...' directive |
COMPHintClause | This represents 'hint' clause in the '#pragma omp ...' directive |
COMPIsDevicePtrClause | This represents clause 'is_device_ptr' in the '#pragma omp ...' directives |
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 |
COMPNogroupClause | This represents 'nogroup' 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 |
COMPPriorityClause | This represents 'priority' clause in the '#pragma omp ...' directive |
COMPSIMDClause | This represents 'simd' clause in the '#pragma omp ...' directive |
COMPThreadLimitClause | This represents 'thread_limit' clause in the '#pragma omp ...' directive |
COMPThreadsClause | This represents 'threads' clause in the '#pragma omp ...' directive |
COMPToClause | This represents clause 'to' in the '#pragma omp ...' directives |
COMPUseDevicePtrClause | This represents clause 'use_device_ptr' in the '#pragma omp ...' directives |
CParsedAttrInfo | |
CReadySuspendResumeResult | |
CSparcCPUInfo | |
CStmtClassNameTable | |
Ctype | |
CTypeInfo | |
Cudir_iterator_base | |