clang 19.0.0git
ASTContext.h
Go to the documentation of this file.
1//===- ASTContext.h - Context to hold long-lived AST nodes ------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// Defines the clang::ASTContext interface.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_AST_ASTCONTEXT_H
15#define LLVM_CLANG_AST_ASTCONTEXT_H
16
17#include "clang/AST/ASTFwd.h"
21#include "clang/AST/Decl.h"
27#include "clang/Basic/LLVM.h"
30#include "llvm/ADT/DenseMap.h"
31#include "llvm/ADT/DenseSet.h"
32#include "llvm/ADT/FoldingSet.h"
33#include "llvm/ADT/IntrusiveRefCntPtr.h"
34#include "llvm/ADT/MapVector.h"
35#include "llvm/ADT/PointerIntPair.h"
36#include "llvm/ADT/PointerUnion.h"
37#include "llvm/ADT/SmallVector.h"
38#include "llvm/ADT/StringMap.h"
39#include "llvm/ADT/StringRef.h"
40#include "llvm/ADT/TinyPtrVector.h"
41#include "llvm/Support/TypeSize.h"
42#include <optional>
43
44namespace llvm {
45
46class APFixedPoint;
47class FixedPointSemantics;
48struct fltSemantics;
49template <typename T, unsigned N> class SmallPtrSet;
50
51} // namespace llvm
52
53namespace clang {
54
55class APValue;
56class ASTMutationListener;
57class ASTRecordLayout;
58class AtomicExpr;
59class BlockExpr;
60struct BlockVarCopyInit;
61class BuiltinTemplateDecl;
62class CharUnits;
63class ConceptDecl;
64class CXXABI;
65class CXXConstructorDecl;
66class CXXMethodDecl;
67class CXXRecordDecl;
68class DiagnosticsEngine;
69class DynTypedNodeList;
70class Expr;
71enum class FloatModeKind;
72class GlobalDecl;
73class IdentifierTable;
74class LangOptions;
75class MangleContext;
76class MangleNumberingContext;
77class MemberSpecializationInfo;
78class Module;
79struct MSGuidDeclParts;
80class NestedNameSpecifier;
81class NoSanitizeList;
82class ObjCCategoryDecl;
83class ObjCCategoryImplDecl;
84class ObjCContainerDecl;
85class ObjCImplDecl;
86class ObjCImplementationDecl;
87class ObjCInterfaceDecl;
88class ObjCIvarDecl;
89class ObjCMethodDecl;
90class ObjCPropertyDecl;
91class ObjCPropertyImplDecl;
92class ObjCProtocolDecl;
93class ObjCTypeParamDecl;
94class OMPTraitInfo;
95class ParentMapContext;
96struct ParsedTargetAttr;
97class Preprocessor;
98class ProfileList;
99class StoredDeclsMap;
100class TargetAttr;
101class TargetInfo;
102class TemplateDecl;
103class TemplateParameterList;
104class TemplateTemplateParmDecl;
105class TemplateTypeParmDecl;
106class TypeConstraint;
107class UnresolvedSetIterator;
108class UsingShadowDecl;
109class VarTemplateDecl;
110class VTableContextBase;
111class XRayFunctionFilter;
112
113namespace Builtin {
114
115class Context;
116
117} // namespace Builtin
118
120enum OpenCLTypeKind : uint8_t;
121
122namespace comments {
123
124class FullComment;
125
126} // namespace comments
127
128namespace interp {
129
130class Context;
131
132} // namespace interp
133
134namespace serialization {
135template <class> class AbstractTypeReader;
136} // namespace serialization
137
139 /// The alignment was not explicit in code.
140 None,
141
142 /// The alignment comes from an alignment attribute on a typedef.
144
145 /// The alignment comes from an alignment attribute on a record type.
147
148 /// The alignment comes from an alignment attribute on a enum type.
150};
151
152struct TypeInfo {
153 uint64_t Width = 0;
154 unsigned Align = 0;
156
158 TypeInfo(uint64_t Width, unsigned Align,
163 }
164};
165
170
177 }
178};
179
180/// Holds long-lived AST nodes (such as types and decls) that can be
181/// referred to throughout the semantic analysis of a file.
182class ASTContext : public RefCountedBase<ASTContext> {
184
185 mutable SmallVector<Type *, 0> Types;
186 mutable llvm::FoldingSet<ExtQuals> ExtQualNodes;
187 mutable llvm::FoldingSet<ComplexType> ComplexTypes;
188 mutable llvm::FoldingSet<PointerType> PointerTypes{GeneralTypesLog2InitSize};
189 mutable llvm::FoldingSet<AdjustedType> AdjustedTypes;
190 mutable llvm::FoldingSet<BlockPointerType> BlockPointerTypes;
191 mutable llvm::FoldingSet<LValueReferenceType> LValueReferenceTypes;
192 mutable llvm::FoldingSet<RValueReferenceType> RValueReferenceTypes;
193 mutable llvm::FoldingSet<MemberPointerType> MemberPointerTypes;
194 mutable llvm::ContextualFoldingSet<ConstantArrayType, ASTContext &>
195 ConstantArrayTypes;
196 mutable llvm::FoldingSet<IncompleteArrayType> IncompleteArrayTypes;
197 mutable std::vector<VariableArrayType*> VariableArrayTypes;
198 mutable llvm::ContextualFoldingSet<DependentSizedArrayType, ASTContext &>
199 DependentSizedArrayTypes;
200 mutable llvm::ContextualFoldingSet<DependentSizedExtVectorType, ASTContext &>
201 DependentSizedExtVectorTypes;
202 mutable llvm::ContextualFoldingSet<DependentAddressSpaceType, ASTContext &>
203 DependentAddressSpaceTypes;
204 mutable llvm::FoldingSet<VectorType> VectorTypes;
205 mutable llvm::ContextualFoldingSet<DependentVectorType, ASTContext &>
206 DependentVectorTypes;
207 mutable llvm::FoldingSet<ConstantMatrixType> MatrixTypes;
208 mutable llvm::ContextualFoldingSet<DependentSizedMatrixType, ASTContext &>
209 DependentSizedMatrixTypes;
210 mutable llvm::FoldingSet<FunctionNoProtoType> FunctionNoProtoTypes;
211 mutable llvm::ContextualFoldingSet<FunctionProtoType, ASTContext&>
212 FunctionProtoTypes;
213 mutable llvm::ContextualFoldingSet<DependentTypeOfExprType, ASTContext &>
214 DependentTypeOfExprTypes;
215 mutable llvm::ContextualFoldingSet<DependentDecltypeType, ASTContext &>
216 DependentDecltypeTypes;
217
218 mutable llvm::FoldingSet<PackIndexingType> DependentPackIndexingTypes;
219
220 mutable llvm::FoldingSet<TemplateTypeParmType> TemplateTypeParmTypes;
221 mutable llvm::FoldingSet<ObjCTypeParamType> ObjCTypeParamTypes;
222 mutable llvm::FoldingSet<SubstTemplateTypeParmType>
223 SubstTemplateTypeParmTypes;
224 mutable llvm::FoldingSet<SubstTemplateTypeParmPackType>
225 SubstTemplateTypeParmPackTypes;
226 mutable llvm::ContextualFoldingSet<TemplateSpecializationType, ASTContext&>
227 TemplateSpecializationTypes;
228 mutable llvm::FoldingSet<ParenType> ParenTypes{GeneralTypesLog2InitSize};
229 mutable llvm::FoldingSet<UsingType> UsingTypes;
230 mutable llvm::FoldingSet<TypedefType> TypedefTypes;
231 mutable llvm::FoldingSet<ElaboratedType> ElaboratedTypes{
232 GeneralTypesLog2InitSize};
233 mutable llvm::FoldingSet<DependentNameType> DependentNameTypes;
234 mutable llvm::ContextualFoldingSet<DependentTemplateSpecializationType,
235 ASTContext&>
236 DependentTemplateSpecializationTypes;
237 llvm::FoldingSet<PackExpansionType> PackExpansionTypes;
238 mutable llvm::FoldingSet<ObjCObjectTypeImpl> ObjCObjectTypes;
239 mutable llvm::FoldingSet<ObjCObjectPointerType> ObjCObjectPointerTypes;
240 mutable llvm::FoldingSet<DependentUnaryTransformType>
241 DependentUnaryTransformTypes;
242 mutable llvm::ContextualFoldingSet<AutoType, ASTContext&> AutoTypes;
243 mutable llvm::FoldingSet<DeducedTemplateSpecializationType>
244 DeducedTemplateSpecializationTypes;
245 mutable llvm::FoldingSet<AtomicType> AtomicTypes;
246 mutable llvm::FoldingSet<AttributedType> AttributedTypes;
247 mutable llvm::FoldingSet<PipeType> PipeTypes;
248 mutable llvm::FoldingSet<BitIntType> BitIntTypes;
249 mutable llvm::ContextualFoldingSet<DependentBitIntType, ASTContext &>
250 DependentBitIntTypes;
251 llvm::FoldingSet<BTFTagAttributedType> BTFTagAttributedTypes;
252
253 mutable llvm::FoldingSet<CountAttributedType> CountAttributedTypes;
254
255 mutable llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;
256 mutable llvm::FoldingSet<DependentTemplateName> DependentTemplateNames;
257 mutable llvm::FoldingSet<SubstTemplateTemplateParmStorage>
258 SubstTemplateTemplateParms;
259 mutable llvm::ContextualFoldingSet<SubstTemplateTemplateParmPackStorage,
260 ASTContext&>
261 SubstTemplateTemplateParmPacks;
262
263 mutable llvm::ContextualFoldingSet<ArrayParameterType, ASTContext &>
264 ArrayParameterTypes;
265
266 /// The set of nested name specifiers.
267 ///
268 /// This set is managed by the NestedNameSpecifier class.
269 mutable llvm::FoldingSet<NestedNameSpecifier> NestedNameSpecifiers;
270 mutable NestedNameSpecifier *GlobalNestedNameSpecifier = nullptr;
271
272 /// A cache mapping from RecordDecls to ASTRecordLayouts.
273 ///
274 /// This is lazily created. This is intentionally not serialized.
275 mutable llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>
276 ASTRecordLayouts;
277 mutable llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*>
278 ObjCLayouts;
279
280 /// A cache from types to size and alignment information.
281 using TypeInfoMap = llvm::DenseMap<const Type *, struct TypeInfo>;
282 mutable TypeInfoMap MemoizedTypeInfo;
283
284 /// A cache from types to unadjusted alignment information. Only ARM and
285 /// AArch64 targets need this information, keeping it separate prevents
286 /// imposing overhead on TypeInfo size.
287 using UnadjustedAlignMap = llvm::DenseMap<const Type *, unsigned>;
288 mutable UnadjustedAlignMap MemoizedUnadjustedAlign;
289
290 /// A cache mapping from CXXRecordDecls to key functions.
291 llvm::DenseMap<const CXXRecordDecl*, LazyDeclPtr> KeyFunctions;
292
293 /// Mapping from ObjCContainers to their ObjCImplementations.
294 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*> ObjCImpls;
295
296 /// Mapping from ObjCMethod to its duplicate declaration in the same
297 /// interface.
298 llvm::DenseMap<const ObjCMethodDecl*,const ObjCMethodDecl*> ObjCMethodRedecls;
299
300 /// Mapping from __block VarDecls to BlockVarCopyInit.
301 llvm::DenseMap<const VarDecl *, BlockVarCopyInit> BlockVarCopyInits;
302
303 /// Mapping from GUIDs to the corresponding MSGuidDecl.
304 mutable llvm::FoldingSet<MSGuidDecl> MSGuidDecls;
305
306 /// Mapping from APValues to the corresponding UnnamedGlobalConstantDecl.
307 mutable llvm::FoldingSet<UnnamedGlobalConstantDecl>
308 UnnamedGlobalConstantDecls;
309
310 /// Mapping from APValues to the corresponding TemplateParamObjects.
311 mutable llvm::FoldingSet<TemplateParamObjectDecl> TemplateParamObjectDecls;
312
313 /// A cache mapping a string value to a StringLiteral object with the same
314 /// value.
315 ///
316 /// This is lazily created. This is intentionally not serialized.
317 mutable llvm::StringMap<StringLiteral *> StringLiteralCache;
318
319 /// MD5 hash of CUID. It is calculated when first used and cached by this
320 /// data member.
321 mutable std::string CUIDHash;
322
323 /// Representation of a "canonical" template template parameter that
324 /// is used in canonical template names.
325 class CanonicalTemplateTemplateParm : public llvm::FoldingSetNode {
326 TemplateTemplateParmDecl *Parm;
327
328 public:
329 CanonicalTemplateTemplateParm(TemplateTemplateParmDecl *Parm)
330 : Parm(Parm) {}
331
332 TemplateTemplateParmDecl *getParam() const { return Parm; }
333
334 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &C) {
335 Profile(ID, C, Parm);
336 }
337
338 static void Profile(llvm::FoldingSetNodeID &ID,
339 const ASTContext &C,
340 TemplateTemplateParmDecl *Parm);
341 };
342 mutable llvm::ContextualFoldingSet<CanonicalTemplateTemplateParm,
343 const ASTContext&>
344 CanonTemplateTemplateParms;
345
346 TemplateTemplateParmDecl *
347 getCanonicalTemplateTemplateParmDecl(TemplateTemplateParmDecl *TTP) const;
348
349 /// The typedef for the __int128_t type.
350 mutable TypedefDecl *Int128Decl = nullptr;
351
352 /// The typedef for the __uint128_t type.
353 mutable TypedefDecl *UInt128Decl = nullptr;
354
355 /// The typedef for the target specific predefined
356 /// __builtin_va_list type.
357 mutable TypedefDecl *BuiltinVaListDecl = nullptr;
358
359 /// The typedef for the predefined \c __builtin_ms_va_list type.
360 mutable TypedefDecl *BuiltinMSVaListDecl = nullptr;
361
362 /// The typedef for the predefined \c id type.
363 mutable TypedefDecl *ObjCIdDecl = nullptr;
364
365 /// The typedef for the predefined \c SEL type.
366 mutable TypedefDecl *ObjCSelDecl = nullptr;
367
368 /// The typedef for the predefined \c Class type.
369 mutable TypedefDecl *ObjCClassDecl = nullptr;
370
371 /// The typedef for the predefined \c Protocol class in Objective-C.
372 mutable ObjCInterfaceDecl *ObjCProtocolClassDecl = nullptr;
373
374 /// The typedef for the predefined 'BOOL' type.
375 mutable TypedefDecl *BOOLDecl = nullptr;
376
377 // Typedefs which may be provided defining the structure of Objective-C
378 // pseudo-builtins
379 QualType ObjCIdRedefinitionType;
380 QualType ObjCClassRedefinitionType;
381 QualType ObjCSelRedefinitionType;
382
383 /// The identifier 'bool'.
384 mutable IdentifierInfo *BoolName = nullptr;
385
386 /// The identifier 'NSObject'.
387 mutable IdentifierInfo *NSObjectName = nullptr;
388
389 /// The identifier 'NSCopying'.
390 IdentifierInfo *NSCopyingName = nullptr;
391
392 /// The identifier '__make_integer_seq'.
393 mutable IdentifierInfo *MakeIntegerSeqName = nullptr;
394
395 /// The identifier '__type_pack_element'.
396 mutable IdentifierInfo *TypePackElementName = nullptr;
397
398 QualType ObjCConstantStringType;
399 mutable RecordDecl *CFConstantStringTagDecl = nullptr;
400 mutable TypedefDecl *CFConstantStringTypeDecl = nullptr;
401
402 mutable QualType ObjCSuperType;
403
404 QualType ObjCNSStringType;
405
406 /// The typedef declaration for the Objective-C "instancetype" type.
407 TypedefDecl *ObjCInstanceTypeDecl = nullptr;
408
409 /// The type for the C FILE type.
410 TypeDecl *FILEDecl = nullptr;
411
412 /// The type for the C jmp_buf type.
413 TypeDecl *jmp_bufDecl = nullptr;
414
415 /// The type for the C sigjmp_buf type.
416 TypeDecl *sigjmp_bufDecl = nullptr;
417
418 /// The type for the C ucontext_t type.
419 TypeDecl *ucontext_tDecl = nullptr;
420
421 /// Type for the Block descriptor for Blocks CodeGen.
422 ///
423 /// Since this is only used for generation of debug info, it is not
424 /// serialized.
425 mutable RecordDecl *BlockDescriptorType = nullptr;
426
427 /// Type for the Block descriptor for Blocks CodeGen.
428 ///
429 /// Since this is only used for generation of debug info, it is not
430 /// serialized.
431 mutable RecordDecl *BlockDescriptorExtendedType = nullptr;
432
433 /// Declaration for the CUDA cudaConfigureCall function.
434 FunctionDecl *cudaConfigureCallDecl = nullptr;
435
436 /// Keeps track of all declaration attributes.
437 ///
438 /// Since so few decls have attrs, we keep them in a hash map instead of
439 /// wasting space in the Decl class.
440 llvm::DenseMap<const Decl*, AttrVec*> DeclAttrs;
441
442 /// A mapping from non-redeclarable declarations in modules that were
443 /// merged with other declarations to the canonical declaration that they were
444 /// merged into.
445 llvm::DenseMap<Decl*, Decl*> MergedDecls;
446
447 /// A mapping from a defining declaration to a list of modules (other
448 /// than the owning module of the declaration) that contain merged
449 /// definitions of that entity.
450 llvm::DenseMap<NamedDecl*, llvm::TinyPtrVector<Module*>> MergedDefModules;
451
452 /// Initializers for a module, in order. Each Decl will be either
453 /// something that has a semantic effect on startup (such as a variable with
454 /// a non-constant initializer), or an ImportDecl (which recursively triggers
455 /// initialization of another module).
456 struct PerModuleInitializers {
457 llvm::SmallVector<Decl*, 4> Initializers;
458 llvm::SmallVector<uint32_t, 4> LazyInitializers;
459
460 void resolve(ASTContext &Ctx);
461 };
462 llvm::DenseMap<Module*, PerModuleInitializers*> ModuleInitializers;
463
464 /// This is the top-level (C++20) Named module we are building.
465 Module *CurrentCXXNamedModule = nullptr;
466
467 static constexpr unsigned ConstantArrayTypesLog2InitSize = 8;
468 static constexpr unsigned GeneralTypesLog2InitSize = 9;
469 static constexpr unsigned FunctionProtoTypesLog2InitSize = 12;
470
471 ASTContext &this_() { return *this; }
472
473public:
474 /// A type synonym for the TemplateOrInstantiation mapping.
476 llvm::PointerUnion<VarTemplateDecl *, MemberSpecializationInfo *>;
477
478private:
479 friend class ASTDeclReader;
480 friend class ASTReader;
481 friend class ASTWriter;
482 template <class> friend class serialization::AbstractTypeReader;
483 friend class CXXRecordDecl;
484 friend class IncrementalParser;
485
486 /// A mapping to contain the template or declaration that
487 /// a variable declaration describes or was instantiated from,
488 /// respectively.
489 ///
490 /// For non-templates, this value will be NULL. For variable
491 /// declarations that describe a variable template, this will be a
492 /// pointer to a VarTemplateDecl. For static data members
493 /// of class template specializations, this will be the
494 /// MemberSpecializationInfo referring to the member variable that was
495 /// instantiated or specialized. Thus, the mapping will keep track of
496 /// the static data member templates from which static data members of
497 /// class template specializations were instantiated.
498 ///
499 /// Given the following example:
500 ///
501 /// \code
502 /// template<typename T>
503 /// struct X {
504 /// static T value;
505 /// };
506 ///
507 /// template<typename T>
508 /// T X<T>::value = T(17);
509 ///
510 /// int *x = &X<int>::value;
511 /// \endcode
512 ///
513 /// This mapping will contain an entry that maps from the VarDecl for
514 /// X<int>::value to the corresponding VarDecl for X<T>::value (within the
515 /// class template X) and will be marked TSK_ImplicitInstantiation.
516 llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>
517 TemplateOrInstantiation;
518
519 /// Keeps track of the declaration from which a using declaration was
520 /// created during instantiation.
521 ///
522 /// The source and target declarations are always a UsingDecl, an
523 /// UnresolvedUsingValueDecl, or an UnresolvedUsingTypenameDecl.
524 ///
525 /// For example:
526 /// \code
527 /// template<typename T>
528 /// struct A {
529 /// void f();
530 /// };
531 ///
532 /// template<typename T>
533 /// struct B : A<T> {
534 /// using A<T>::f;
535 /// };
536 ///
537 /// template struct B<int>;
538 /// \endcode
539 ///
540 /// This mapping will contain an entry that maps from the UsingDecl in
541 /// B<int> to the UnresolvedUsingDecl in B<T>.
542 llvm::DenseMap<NamedDecl *, NamedDecl *> InstantiatedFromUsingDecl;
543
544 /// Like InstantiatedFromUsingDecl, but for using-enum-declarations. Maps
545 /// from the instantiated using-enum to the templated decl from whence it
546 /// came.
547 /// Note that using-enum-declarations cannot be dependent and
548 /// thus will never be instantiated from an "unresolved"
549 /// version thereof (as with using-declarations), so each mapping is from
550 /// a (resolved) UsingEnumDecl to a (resolved) UsingEnumDecl.
551 llvm::DenseMap<UsingEnumDecl *, UsingEnumDecl *>
552 InstantiatedFromUsingEnumDecl;
553
554 /// Simlarly maps instantiated UsingShadowDecls to their origin.
555 llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>
556 InstantiatedFromUsingShadowDecl;
557
558 llvm::DenseMap<FieldDecl *, FieldDecl *> InstantiatedFromUnnamedFieldDecl;
559
560 /// Mapping that stores the methods overridden by a given C++
561 /// member function.
562 ///
563 /// Since most C++ member functions aren't virtual and therefore
564 /// don't override anything, we store the overridden functions in
565 /// this map on the side rather than within the CXXMethodDecl structure.
566 using CXXMethodVector = llvm::TinyPtrVector<const CXXMethodDecl *>;
567 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector> OverriddenMethods;
568
569 /// Mapping from each declaration context to its corresponding
570 /// mangling numbering context (used for constructs like lambdas which
571 /// need to be consistently numbered for the mangler).
572 llvm::DenseMap<const DeclContext *, std::unique_ptr<MangleNumberingContext>>
573 MangleNumberingContexts;
574 llvm::DenseMap<const Decl *, std::unique_ptr<MangleNumberingContext>>
575 ExtraMangleNumberingContexts;
576
577 /// Side-table of mangling numbers for declarations which rarely
578 /// need them (like static local vars).
579 llvm::MapVector<const NamedDecl *, unsigned> MangleNumbers;
580 llvm::MapVector<const VarDecl *, unsigned> StaticLocalNumbers;
581 /// Mapping the associated device lambda mangling number if present.
582 mutable llvm::DenseMap<const CXXRecordDecl *, unsigned>
583 DeviceLambdaManglingNumbers;
584
585 /// Mapping that stores parameterIndex values for ParmVarDecls when
586 /// that value exceeds the bitfield size of ParmVarDeclBits.ParameterIndex.
587 using ParameterIndexTable = llvm::DenseMap<const VarDecl *, unsigned>;
588 ParameterIndexTable ParamIndices;
589
590 ImportDecl *FirstLocalImport = nullptr;
591 ImportDecl *LastLocalImport = nullptr;
592
593 TranslationUnitDecl *TUDecl = nullptr;
594 mutable ExternCContextDecl *ExternCContext = nullptr;
595 mutable BuiltinTemplateDecl *MakeIntegerSeqDecl = nullptr;
596 mutable BuiltinTemplateDecl *TypePackElementDecl = nullptr;
597
598 /// The associated SourceManager object.
599 SourceManager &SourceMgr;
600
601 /// The language options used to create the AST associated with
602 /// this ASTContext object.
603 LangOptions &LangOpts;
604
605 /// NoSanitizeList object that is used by sanitizers to decide which
606 /// entities should not be instrumented.
607 std::unique_ptr<NoSanitizeList> NoSanitizeL;
608
609 /// Function filtering mechanism to determine whether a given function
610 /// should be imbued with the XRay "always" or "never" attributes.
611 std::unique_ptr<XRayFunctionFilter> XRayFilter;
612
613 /// ProfileList object that is used by the profile instrumentation
614 /// to decide which entities should be instrumented.
615 std::unique_ptr<ProfileList> ProfList;
616
617 /// The allocator used to create AST objects.
618 ///
619 /// AST objects are never destructed; rather, all memory associated with the
620 /// AST objects will be released when the ASTContext itself is destroyed.
621 mutable llvm::BumpPtrAllocator BumpAlloc;
622
623 /// Allocator for partial diagnostics.
625
626 /// The current C++ ABI.
627 std::unique_ptr<CXXABI> ABI;
629
630 /// Address space map mangling must be used with language specific
631 /// address spaces (e.g. OpenCL/CUDA)
632 bool AddrSpaceMapMangling;
633
634 const TargetInfo *Target = nullptr;
635 const TargetInfo *AuxTarget = nullptr;
637 std::unique_ptr<interp::Context> InterpContext;
638 std::unique_ptr<ParentMapContext> ParentMapCtx;
639
640 /// Keeps track of the deallocated DeclListNodes for future reuse.
641 DeclListNode *ListNodeFreeList = nullptr;
642
643public:
651
652 /// Returns the clang bytecode interpreter context.
654
656 /// Do not allow wrong-sided variables in constant expressions.
657 bool NoWrongSidedVars = false;
662 CUDAConstantEvalContextRAII(ASTContext &Ctx_, bool NoWrongSidedVars)
663 : Ctx(Ctx_), SavedCtx(Ctx_.CUDAConstantEvalCtx) {
664 Ctx_.CUDAConstantEvalCtx.NoWrongSidedVars = NoWrongSidedVars;
665 }
667 };
668
669 /// Returns the dynamic AST node parent map context.
671
672 // A traversal scope limits the parts of the AST visible to certain analyses.
673 // RecursiveASTVisitor only visits specified children of TranslationUnitDecl.
674 // getParents() will only observe reachable parent edges.
675 //
676 // The scope is defined by a set of "top-level" declarations which will be
677 // visible under the TranslationUnitDecl.
678 // Initially, it is the entire TU, represented by {getTranslationUnitDecl()}.
679 //
680 // After setTraversalScope({foo, bar}), the exposed AST looks like:
681 // TranslationUnitDecl
682 // - foo
683 // - ...
684 // - bar
685 // - ...
686 // All other siblings of foo and bar are pruned from the tree.
687 // (However they are still accessible via TranslationUnitDecl->decls())
688 //
689 // Changing the scope clears the parent cache, which is expensive to rebuild.
690 std::vector<Decl *> getTraversalScope() const { return TraversalScope; }
691 void setTraversalScope(const std::vector<Decl *> &);
692
693 /// Forwards to get node parents from the ParentMapContext. New callers should
694 /// use ParentMapContext::getParents() directly.
695 template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node);
696
698 return PrintingPolicy;
699 }
700
702 PrintingPolicy = Policy;
703 }
704
705 SourceManager& getSourceManager() { return SourceMgr; }
706 const SourceManager& getSourceManager() const { return SourceMgr; }
707
708 // Cleans up some of the data structures. This allows us to do cleanup
709 // normally done in the destructor earlier. Renders much of the ASTContext
710 // unusable, mostly the actual AST nodes, so should be called when we no
711 // longer need access to the AST.
712 void cleanup();
713
714 llvm::BumpPtrAllocator &getAllocator() const {
715 return BumpAlloc;
716 }
717
718 void *Allocate(size_t Size, unsigned Align = 8) const {
719 return BumpAlloc.Allocate(Size, Align);
720 }
721 template <typename T> T *Allocate(size_t Num = 1) const {
722 return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
723 }
724 void Deallocate(void *Ptr) const {}
725
726 /// Allocates a \c DeclListNode or returns one from the \c ListNodeFreeList
727 /// pool.
729 if (DeclListNode *Alloc = ListNodeFreeList) {
730 ListNodeFreeList = Alloc->Rest.dyn_cast<DeclListNode*>();
731 Alloc->D = ND;
732 Alloc->Rest = nullptr;
733 return Alloc;
734 }
735 return new (*this) DeclListNode(ND);
736 }
737 /// Deallcates a \c DeclListNode by returning it to the \c ListNodeFreeList
738 /// pool.
740 N->Rest = ListNodeFreeList;
741 ListNodeFreeList = N;
742 }
743
744 /// Return the total amount of physical memory allocated for representing
745 /// AST nodes and type information.
746 size_t getASTAllocatedMemory() const {
747 return BumpAlloc.getTotalMemory();
748 }
749
750 /// Return the total memory used for various side tables.
751 size_t getSideTableAllocatedMemory() const;
752
754 return DiagAllocator;
755 }
756
757 const TargetInfo &getTargetInfo() const { return *Target; }
758 const TargetInfo *getAuxTargetInfo() const { return AuxTarget; }
759
760 /// getIntTypeForBitwidth -
761 /// sets integer QualTy according to specified details:
762 /// bitwidth, signed/unsigned.
763 /// Returns empty type if there is no appropriate target types.
764 QualType getIntTypeForBitwidth(unsigned DestWidth,
765 unsigned Signed) const;
766
767 /// getRealTypeForBitwidth -
768 /// sets floating point QualTy according to specified bitwidth.
769 /// Returns empty type if there is no appropriate target types.
770 QualType getRealTypeForBitwidth(unsigned DestWidth,
771 FloatModeKind ExplicitType) const;
772
773 bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const;
774
775 const LangOptions& getLangOpts() const { return LangOpts; }
776
777 // If this condition is false, typo correction must be performed eagerly
778 // rather than delayed in many places, as it makes use of dependent types.
779 // the condition is false for clang's C-only codepath, as it doesn't support
780 // dependent types yet.
781 bool isDependenceAllowed() const {
782 return LangOpts.CPlusPlus || LangOpts.RecoveryAST;
783 }
784
785 const NoSanitizeList &getNoSanitizeList() const { return *NoSanitizeL; }
786
788 return *XRayFilter;
789 }
790
791 const ProfileList &getProfileList() const { return *ProfList; }
792
794
796 return FullSourceLoc(Loc,SourceMgr);
797 }
798
799 /// Return the C++ ABI kind that should be used. The C++ ABI can be overriden
800 /// at compile time with `-fc++-abi=`. If this is not provided, we instead use
801 /// the default ABI set by the target.
803
804 /// All comments in this translation unit.
806
807 /// True if comments are already loaded from ExternalASTSource.
808 mutable bool CommentsLoaded = false;
809
810 /// Mapping from declaration to directly attached comment.
811 ///
812 /// Raw comments are owned by Comments list. This mapping is populated
813 /// lazily.
814 mutable llvm::DenseMap<const Decl *, const RawComment *> DeclRawComments;
815
816 /// Mapping from canonical declaration to the first redeclaration in chain
817 /// that has a comment attached.
818 ///
819 /// Raw comments are owned by Comments list. This mapping is populated
820 /// lazily.
821 mutable llvm::DenseMap<const Decl *, const Decl *> RedeclChainComments;
822
823 /// Keeps track of redeclaration chains that don't have any comment attached.
824 /// Mapping from canonical declaration to redeclaration chain that has no
825 /// comments attached to any redeclaration. Specifically it's mapping to
826 /// the last redeclaration we've checked.
827 ///
828 /// Shall not contain declarations that have comments attached to any
829 /// redeclaration in their chain.
830 mutable llvm::DenseMap<const Decl *, const Decl *> CommentlessRedeclChains;
831
832 /// Mapping from declarations to parsed comments attached to any
833 /// redeclaration.
834 mutable llvm::DenseMap<const Decl *, comments::FullComment *> ParsedComments;
835
836 /// Attaches \p Comment to \p OriginalD and to its redeclaration chain
837 /// and removes the redeclaration chain from the set of commentless chains.
838 ///
839 /// Don't do anything if a comment has already been attached to \p OriginalD
840 /// or its redeclaration chain.
841 void cacheRawCommentForDecl(const Decl &OriginalD,
842 const RawComment &Comment) const;
843
844 /// \returns searches \p CommentsInFile for doc comment for \p D.
845 ///
846 /// \p RepresentativeLocForDecl is used as a location for searching doc
847 /// comments. \p CommentsInFile is a mapping offset -> comment of files in the
848 /// same file where \p RepresentativeLocForDecl is.
850 const Decl *D, const SourceLocation RepresentativeLocForDecl,
851 const std::map<unsigned, RawComment *> &CommentsInFile) const;
852
853 /// Return the documentation comment attached to a given declaration,
854 /// without looking into cache.
856
857public:
858 void addComment(const RawComment &RC);
859
860 /// Return the documentation comment attached to a given declaration.
861 /// Returns nullptr if no comment is attached.
862 ///
863 /// \param OriginalDecl if not nullptr, is set to declaration AST node that
864 /// had the comment, if the comment we found comes from a redeclaration.
865 const RawComment *
867 const Decl **OriginalDecl = nullptr) const;
868
869 /// Searches existing comments for doc comments that should be attached to \p
870 /// Decls. If any doc comment is found, it is parsed.
871 ///
872 /// Requirement: All \p Decls are in the same file.
873 ///
874 /// If the last comment in the file is already attached we assume
875 /// there are not comments left to be attached to \p Decls.
877 const Preprocessor *PP);
878
879 /// Return parsed documentation comment attached to a given declaration.
880 /// Returns nullptr if no comment is attached.
881 ///
882 /// \param PP the Preprocessor used with this TU. Could be nullptr if
883 /// preprocessor is not available.
885 const Preprocessor *PP) const;
886
887 /// Return parsed documentation comment attached to a given declaration.
888 /// Returns nullptr if no comment is attached. Does not look at any
889 /// redeclarations of the declaration.
891
893 const Decl *D) const;
894
895private:
896 mutable comments::CommandTraits CommentCommandTraits;
897
898 /// Iterator that visits import declarations.
899 class import_iterator {
900 ImportDecl *Import = nullptr;
901
902 public:
903 using value_type = ImportDecl *;
904 using reference = ImportDecl *;
905 using pointer = ImportDecl *;
906 using difference_type = int;
907 using iterator_category = std::forward_iterator_tag;
908
909 import_iterator() = default;
910 explicit import_iterator(ImportDecl *Import) : Import(Import) {}
911
912 reference operator*() const { return Import; }
913 pointer operator->() const { return Import; }
914
915 import_iterator &operator++() {
917 return *this;
918 }
919
920 import_iterator operator++(int) {
921 import_iterator Other(*this);
922 ++(*this);
923 return Other;
924 }
925
926 friend bool operator==(import_iterator X, import_iterator Y) {
927 return X.Import == Y.Import;
928 }
929
930 friend bool operator!=(import_iterator X, import_iterator Y) {
931 return X.Import != Y.Import;
932 }
933 };
934
935public:
937 return CommentCommandTraits;
938 }
939
940 /// Retrieve the attributes for the given declaration.
941 AttrVec& getDeclAttrs(const Decl *D);
942
943 /// Erase the attributes corresponding to the given declaration.
944 void eraseDeclAttrs(const Decl *D);
945
946 /// If this variable is an instantiated static data member of a
947 /// class template specialization, returns the templated static data member
948 /// from which it was instantiated.
949 // FIXME: Remove ?
951 const VarDecl *Var);
952
953 /// Note that the static data member \p Inst is an instantiation of
954 /// the static data member template \p Tmpl of a class template.
957 SourceLocation PointOfInstantiation = SourceLocation());
958
961
964
965 /// If the given using decl \p Inst is an instantiation of
966 /// another (possibly unresolved) using decl, return it.
968
969 /// Remember that the using decl \p Inst is an instantiation
970 /// of the using decl \p Pattern of a class template.
972
973 /// If the given using-enum decl \p Inst is an instantiation of
974 /// another using-enum decl, return it.
976
977 /// Remember that the using enum decl \p Inst is an instantiation
978 /// of the using enum decl \p Pattern of a class template.
980 UsingEnumDecl *Pattern);
981
984 UsingShadowDecl *Pattern);
985
987
989
990 // Access to the set of methods overridden by the given C++ method.
991 using overridden_cxx_method_iterator = CXXMethodVector::const_iterator;
993 overridden_methods_begin(const CXXMethodDecl *Method) const;
994
996 overridden_methods_end(const CXXMethodDecl *Method) const;
997
998 unsigned overridden_methods_size(const CXXMethodDecl *Method) const;
999
1001 llvm::iterator_range<overridden_cxx_method_iterator>;
1002
1004
1005 /// Note that the given C++ \p Method overrides the given \p
1006 /// Overridden method.
1007 void addOverriddenMethod(const CXXMethodDecl *Method,
1008 const CXXMethodDecl *Overridden);
1009
1010 /// Return C++ or ObjC overridden methods for the given \p Method.
1011 ///
1012 /// An ObjC method is considered to override any method in the class's
1013 /// base classes, its protocols, or its categories' protocols, that has
1014 /// the same selector and is of the same kind (class or instance).
1015 /// A method in an implementation is not considered as overriding the same
1016 /// method in the interface or its categories.
1018 const NamedDecl *Method,
1019 SmallVectorImpl<const NamedDecl *> &Overridden) const;
1020
1021 /// Notify the AST context that a new import declaration has been
1022 /// parsed or implicitly created within this translation unit.
1023 void addedLocalImportDecl(ImportDecl *Import);
1024
1026 return Import->getNextLocalImport();
1027 }
1028
1029 using import_range = llvm::iterator_range<import_iterator>;
1030
1032 return import_range(import_iterator(FirstLocalImport), import_iterator());
1033 }
1034
1036 Decl *Result = MergedDecls.lookup(D);
1037 return Result ? Result : D;
1038 }
1039 void setPrimaryMergedDecl(Decl *D, Decl *Primary) {
1040 MergedDecls[D] = Primary;
1041 }
1042
1043 /// Note that the definition \p ND has been merged into module \p M,
1044 /// and should be visible whenever \p M is visible.
1046 bool NotifyListeners = true);
1047
1048 /// Clean up the merged definition list. Call this if you might have
1049 /// added duplicates into the list.
1051
1052 /// Get the additional modules in which the definition \p Def has
1053 /// been merged.
1055
1056 /// Add a declaration to the list of declarations that are initialized
1057 /// for a module. This will typically be a global variable (with internal
1058 /// linkage) that runs module initializers, such as the iostream initializer,
1059 /// or an ImportDecl nominating another module that has initializers.
1061
1063
1064 /// Get the initializations to perform when importing a module, if any.
1066
1067 /// Set the (C++20) module we are building.
1069
1070 /// Get module under construction, nullptr if this is not a C++20 module.
1071 Module *getCurrentNamedModule() const { return CurrentCXXNamedModule; }
1072
1074 return TUDecl->getMostRecentDecl();
1075 }
1077 assert(!TUDecl || TUKind == TU_Incremental);
1079 if (TraversalScope.empty() || TraversalScope.back() == TUDecl)
1080 TraversalScope = {NewTUDecl};
1081 if (TUDecl)
1082 NewTUDecl->setPreviousDecl(TUDecl);
1083 TUDecl = NewTUDecl;
1084 }
1085
1089
1090 // Builtin Types.
1094 CanQualType WCharTy; // [C++ 3.9.1p5].
1095 CanQualType WideCharTy; // Same as WCharTy in C++, integer type in C99.
1096 CanQualType WIntTy; // [C99 7.24.1], integer type unchanged by default promotions.
1097 CanQualType Char8Ty; // [C++20 proposal]
1098 CanQualType Char16Ty; // [C++0x 3.9.1p5], integer type in C99.
1099 CanQualType Char32Ty; // [C++0x 3.9.1p5], integer type in C99.
1105 LongAccumTy; // ISO/IEC JTC1 SC22 WG14 N1169 Extension
1115 CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON
1117 CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3
1124#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1125 CanQualType SingletonId;
1126#include "clang/Basic/OpenCLImageTypes.def"
1131#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1132 CanQualType Id##Ty;
1133#include "clang/Basic/OpenCLExtensionTypes.def"
1134#define SVE_TYPE(Name, Id, SingletonId) \
1135 CanQualType SingletonId;
1136#include "clang/Basic/AArch64SVEACLETypes.def"
1137#define PPC_VECTOR_TYPE(Name, Id, Size) \
1138 CanQualType Id##Ty;
1139#include "clang/Basic/PPCTypes.def"
1140#define RVV_TYPE(Name, Id, SingletonId) \
1141 CanQualType SingletonId;
1142#include "clang/Basic/RISCVVTypes.def"
1143#define WASM_TYPE(Name, Id, SingletonId) CanQualType SingletonId;
1144#include "clang/Basic/WebAssemblyReferenceTypes.def"
1145
1146 // Types for deductions in C++0x [stmt.ranged]'s desugaring. Built on demand.
1147 mutable QualType AutoDeductTy; // Deduction against 'auto'.
1148 mutable QualType AutoRRefDeductTy; // Deduction against 'auto &&'.
1149
1150 // Decl used to help define __builtin_va_list for some targets.
1151 // The decl is built when constructing 'BuiltinVaListDecl'.
1152 mutable Decl *VaListTagDecl = nullptr;
1153
1154 // Implicitly-declared type 'struct _GUID'.
1155 mutable TagDecl *MSGuidTagDecl = nullptr;
1156
1157 /// Keep track of CUDA/HIP device-side variables ODR-used by host code.
1158 /// This does not include extern shared variables used by device host
1159 /// functions as addresses of shared variables are per warp, therefore
1160 /// cannot be accessed by host code.
1162
1163 /// Keep track of CUDA/HIP external kernels or device variables ODR-used by
1164 /// host code.
1166
1167 /// Keep track of CUDA/HIP implicit host device functions used on device side
1168 /// in device compilation.
1170
1172 SelectorTable &sels, Builtin::Context &builtins,
1174 ASTContext(const ASTContext &) = delete;
1175 ASTContext &operator=(const ASTContext &) = delete;
1176 ~ASTContext();
1177
1178 /// Attach an external AST source to the AST context.
1179 ///
1180 /// The external AST source provides the ability to load parts of
1181 /// the abstract syntax tree as needed from some external storage,
1182 /// e.g., a precompiled header.
1184
1185 /// Retrieve a pointer to the external AST source associated
1186 /// with this AST context, if any.
1188 return ExternalSource.get();
1189 }
1190
1191 /// Attach an AST mutation listener to the AST context.
1192 ///
1193 /// The AST mutation listener provides the ability to track modifications to
1194 /// the abstract syntax tree entities committed after they were initially
1195 /// created.
1197 this->Listener = Listener;
1198 }
1199
1200 /// Retrieve a pointer to the AST mutation listener associated
1201 /// with this AST context, if any.
1203
1204 void PrintStats() const;
1205 const SmallVectorImpl<Type *>& getTypes() const { return Types; }
1206
1208 const IdentifierInfo *II) const;
1209
1210 /// Create a new implicit TU-level CXXRecordDecl or RecordDecl
1211 /// declaration.
1213 StringRef Name,
1214 RecordDecl::TagKind TK = RecordDecl::TagKind::Struct) const;
1215
1216 /// Create a new implicit TU-level typedef declaration.
1217 TypedefDecl *buildImplicitTypedef(QualType T, StringRef Name) const;
1218
1219 /// Retrieve the declaration for the 128-bit signed integer type.
1220 TypedefDecl *getInt128Decl() const;
1221
1222 /// Retrieve the declaration for the 128-bit unsigned integer type.
1223 TypedefDecl *getUInt128Decl() const;
1224
1225 //===--------------------------------------------------------------------===//
1226 // Type Constructors
1227 //===--------------------------------------------------------------------===//
1228
1229private:
1230 /// Return a type with extended qualifiers.
1231 QualType getExtQualType(const Type *Base, Qualifiers Quals) const;
1232
1233 QualType getTypeDeclTypeSlow(const TypeDecl *Decl) const;
1234
1235 QualType getPipeType(QualType T, bool ReadOnly) const;
1236
1237public:
1238 /// Return the uniqued reference to the type for an address space
1239 /// qualified type with the specified type and address space.
1240 ///
1241 /// The resulting type has a union of the qualifiers from T and the address
1242 /// space. If T already has an address space specifier, it is silently
1243 /// replaced.
1244 QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const;
1245
1246 /// Remove any existing address space on the type and returns the type
1247 /// with qualifiers intact (or that's the idea anyway)
1248 ///
1249 /// The return type should be T with all prior qualifiers minus the address
1250 /// space.
1252
1253 /// Apply Objective-C protocol qualifiers to the given type.
1254 /// \param allowOnPointerType specifies if we can apply protocol
1255 /// qualifiers on ObjCObjectPointerType. It can be set to true when
1256 /// constructing the canonical type of a Objective-C type parameter.
1258 ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
1259 bool allowOnPointerType = false) const;
1260
1261 /// Return the uniqued reference to the type for an Objective-C
1262 /// gc-qualified type.
1263 ///
1264 /// The resulting type has a union of the qualifiers from T and the gc
1265 /// attribute.
1267
1268 /// Remove the existing address space on the type if it is a pointer size
1269 /// address space and return the type with qualifiers intact.
1271
1272 /// Return the uniqued reference to the type for a \c restrict
1273 /// qualified type.
1274 ///
1275 /// The resulting type has a union of the qualifiers from \p T and
1276 /// \c restrict.
1278 return T.withFastQualifiers(Qualifiers::Restrict);
1279 }
1280
1281 /// Return the uniqued reference to the type for a \c volatile
1282 /// qualified type.
1283 ///
1284 /// The resulting type has a union of the qualifiers from \p T and
1285 /// \c volatile.
1287 return T.withFastQualifiers(Qualifiers::Volatile);
1288 }
1289
1290 /// Return the uniqued reference to the type for a \c const
1291 /// qualified type.
1292 ///
1293 /// The resulting type has a union of the qualifiers from \p T and \c const.
1294 ///
1295 /// It can be reasonably expected that this will always be equivalent to
1296 /// calling T.withConst().
1297 QualType getConstType(QualType T) const { return T.withConst(); }
1298
1299 /// Change the ExtInfo on a function type.
1301 FunctionType::ExtInfo EInfo);
1302
1303 /// Adjust the given function result type.
1305
1306 /// Change the result type of a function type once it is deduced.
1308
1309 /// Get a function type and produce the equivalent function type with the
1310 /// specified exception specification. Type sugar that can be present on a
1311 /// declaration of a function with an exception specification is permitted
1312 /// and preserved. Other type sugar (for instance, typedefs) is not.
1314 QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const;
1315
1316 /// Determine whether two function types are the same, ignoring
1317 /// exception specifications in cases where they're part of the type.
1319
1320 /// Change the exception specification on a function once it is
1321 /// delay-parsed, instantiated, or computed.
1324 bool AsWritten = false);
1325
1326 /// Get a function type and produce the equivalent function type where
1327 /// pointer size address spaces in the return type and parameter tyeps are
1328 /// replaced with the default address space.
1330
1331 /// Determine whether two function types are the same, ignoring pointer sizes
1332 /// in the return type and parameter types.
1334
1335 /// Return the uniqued reference to the type for a complex
1336 /// number with the specified element type.
1340 }
1341
1342 /// Return the uniqued reference to the type for a pointer to
1343 /// the specified type.
1347 }
1348
1349 QualType
1350 getCountAttributedType(QualType T, Expr *CountExpr, bool CountInBytes,
1351 bool OrNull,
1352 ArrayRef<TypeCoupledDeclRefInfo> DependentDecls) const;
1353
1354 /// Return the uniqued reference to a type adjusted from the original
1355 /// type to a new type.
1356 QualType getAdjustedType(QualType Orig, QualType New) const;
1359 getAdjustedType((QualType)Orig, (QualType)New));
1360 }
1361
1362 /// Return the uniqued reference to the decayed version of the given
1363 /// type. Can only be called on array and function types which decay to
1364 /// pointer types.
1368 }
1369 /// Return the uniqued reference to a specified decay from the original
1370 /// type to the decayed type.
1371 QualType getDecayedType(QualType Orig, QualType Decayed) const;
1372
1373 /// Return the uniqued reference to a specified array parameter type from the
1374 /// original array type.
1376
1377 /// Return the uniqued reference to the atomic type for the specified
1378 /// type.
1380
1381 /// Return the uniqued reference to the type for a block of the
1382 /// specified type.
1384
1385 /// Gets the struct used to keep track of the descriptor for pointer to
1386 /// blocks.
1388
1389 /// Return a read_only pipe type for the specified type.
1391
1392 /// Return a write_only pipe type for the specified type.
1394
1395 /// Return a bit-precise integer type with the specified signedness and bit
1396 /// count.
1397 QualType getBitIntType(bool Unsigned, unsigned NumBits) const;
1398
1399 /// Return a dependent bit-precise integer type with the specified signedness
1400 /// and bit count.
1401 QualType getDependentBitIntType(bool Unsigned, Expr *BitsExpr) const;
1402
1403 /// Gets the struct used to keep track of the extended descriptor for
1404 /// pointer to blocks.
1406
1407 /// Map an AST Type to an OpenCLTypeKind enum value.
1408 OpenCLTypeKind getOpenCLTypeKind(const Type *T) const;
1409
1410 /// Get address space for OpenCL type.
1411 LangAS getOpenCLTypeAddrSpace(const Type *T) const;
1412
1413 /// Returns default address space based on OpenCL version and enabled features
1415 return LangOpts.OpenCLGenericAddressSpace ? LangAS::opencl_generic
1417 }
1418
1420 cudaConfigureCallDecl = FD;
1421 }
1422
1424 return cudaConfigureCallDecl;
1425 }
1426
1427 /// Returns true iff we need copy/dispose helpers for the given type.
1428 bool BlockRequiresCopying(QualType Ty, const VarDecl *D);
1429
1430 /// Returns true, if given type has a known lifetime. HasByrefExtendedLayout
1431 /// is set to false in this case. If HasByrefExtendedLayout returns true,
1432 /// byref variable has extended lifetime.
1433 bool getByrefLifetime(QualType Ty,
1434 Qualifiers::ObjCLifetime &Lifetime,
1435 bool &HasByrefExtendedLayout) const;
1436
1437 /// Return the uniqued reference to the type for an lvalue reference
1438 /// to the specified type.
1439 QualType getLValueReferenceType(QualType T, bool SpelledAsLValue = true)
1440 const;
1441
1442 /// Return the uniqued reference to the type for an rvalue reference
1443 /// to the specified type.
1445
1446 /// Return the uniqued reference to the type for a member pointer to
1447 /// the specified type in the specified class.
1448 ///
1449 /// The class \p Cls is a \c Type because it could be a dependent name.
1450 QualType getMemberPointerType(QualType T, const Type *Cls) const;
1451
1452 /// Return a non-unique reference to the type for a variable array of
1453 /// the specified element type.
1455 ArraySizeModifier ASM, unsigned IndexTypeQuals,
1456 SourceRange Brackets) const;
1457
1458 /// Return a non-unique reference to the type for a dependently-sized
1459 /// array of the specified element type.
1460 ///
1461 /// FIXME: We will need these to be uniqued, or at least comparable, at some
1462 /// point.
1465 unsigned IndexTypeQuals,
1466 SourceRange Brackets) const;
1467
1468 /// Return a unique reference to the type for an incomplete array of
1469 /// the specified element type.
1471 unsigned IndexTypeQuals) const;
1472
1473 /// Return the unique reference to the type for a constant array of
1474 /// the specified element type.
1475 QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize,
1476 const Expr *SizeExpr, ArraySizeModifier ASM,
1477 unsigned IndexTypeQuals) const;
1478
1479 /// Return a type for a constant array for a string literal of the
1480 /// specified element type and length.
1481 QualType getStringLiteralArrayType(QualType EltTy, unsigned Length) const;
1482
1483 /// Returns a vla type where known sizes are replaced with [*].
1485
1486 // Convenience struct to return information about a builtin vector type.
1489 llvm::ElementCount EC;
1490 unsigned NumVectors;
1492 unsigned NumVectors)
1494 };
1495
1496 /// Returns the element type, element count and number of vectors
1497 /// (in case of tuple) for a builtin vector type.
1498 BuiltinVectorTypeInfo
1499 getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const;
1500
1501 /// Return the unique reference to a scalable vector type of the specified
1502 /// element type and scalable number of elements.
1503 /// For RISC-V, number of fields is also provided when it fetching for
1504 /// tuple type.
1505 ///
1506 /// \pre \p EltTy must be a built-in type.
1507 QualType getScalableVectorType(QualType EltTy, unsigned NumElts,
1508 unsigned NumFields = 1) const;
1509
1510 /// Return a WebAssembly externref type.
1512
1513 /// Return the unique reference to a vector type of the specified
1514 /// element type and size.
1515 ///
1516 /// \pre \p VectorType must be a built-in type.
1517 QualType getVectorType(QualType VectorType, unsigned NumElts,
1518 VectorKind VecKind) const;
1519 /// Return the unique reference to the type for a dependently sized vector of
1520 /// the specified element type.
1522 SourceLocation AttrLoc,
1523 VectorKind VecKind) const;
1524
1525 /// Return the unique reference to an extended vector type
1526 /// of the specified element type and size.
1527 ///
1528 /// \pre \p VectorType must be a built-in type.
1529 QualType getExtVectorType(QualType VectorType, unsigned NumElts) const;
1530
1531 /// \pre Return a non-unique reference to the type for a dependently-sized
1532 /// vector of the specified element type.
1533 ///
1534 /// FIXME: We will need these to be uniqued, or at least comparable, at some
1535 /// point.
1537 Expr *SizeExpr,
1538 SourceLocation AttrLoc) const;
1539
1540 /// Return the unique reference to the matrix type of the specified element
1541 /// type and size
1542 ///
1543 /// \pre \p ElementType must be a valid matrix element type (see
1544 /// MatrixType::isValidElementType).
1545 QualType getConstantMatrixType(QualType ElementType, unsigned NumRows,
1546 unsigned NumColumns) const;
1547
1548 /// Return the unique reference to the matrix type of the specified element
1549 /// type and size
1550 QualType getDependentSizedMatrixType(QualType ElementType, Expr *RowExpr,
1551 Expr *ColumnExpr,
1552 SourceLocation AttrLoc) const;
1553
1555 Expr *AddrSpaceExpr,
1556 SourceLocation AttrLoc) const;
1557
1558 /// Return a K&R style C function type like 'int()'.
1560 const FunctionType::ExtInfo &Info) const;
1561
1564 }
1565
1566 /// Return a normal function type with a typed argument list.
1568 const FunctionProtoType::ExtProtoInfo &EPI) const {
1569 return getFunctionTypeInternal(ResultTy, Args, EPI, false);
1570 }
1571
1573
1574private:
1575 /// Return a normal function type with a typed argument list.
1576 QualType getFunctionTypeInternal(QualType ResultTy, ArrayRef<QualType> Args,
1578 bool OnlyWantCanonical) const;
1579 QualType
1580 getAutoTypeInternal(QualType DeducedType, AutoTypeKeyword Keyword,
1581 bool IsDependent, bool IsPack = false,
1582 ConceptDecl *TypeConstraintConcept = nullptr,
1583 ArrayRef<TemplateArgument> TypeConstraintArgs = {},
1584 bool IsCanon = false) const;
1585
1586public:
1587 /// Return the unique reference to the type for the specified type
1588 /// declaration.
1590 const TypeDecl *PrevDecl = nullptr) const {
1591 assert(Decl && "Passed null for Decl param");
1592 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
1593
1594 if (PrevDecl) {
1595 assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl");
1596 Decl->TypeForDecl = PrevDecl->TypeForDecl;
1597 return QualType(PrevDecl->TypeForDecl, 0);
1598 }
1599
1600 return getTypeDeclTypeSlow(Decl);
1601 }
1602
1604 QualType Underlying) const;
1605
1606 /// Return the unique reference to the type for the specified
1607 /// typedef-name decl.
1609 QualType Underlying = QualType()) const;
1610
1611 QualType getRecordType(const RecordDecl *Decl) const;
1612
1613 QualType getEnumType(const EnumDecl *Decl) const;
1614
1615 QualType
1617
1619
1620 QualType getAttributedType(attr::Kind attrKind, QualType modifiedType,
1621 QualType equivalentType) const;
1622
1623 QualType getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr,
1624 QualType Wrapped);
1625
1626 QualType
1627 getSubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
1628 unsigned Index,
1629 std::optional<unsigned> PackIndex) const;
1631 unsigned Index, bool Final,
1632 const TemplateArgument &ArgPack);
1633
1634 QualType
1635 getTemplateTypeParmType(unsigned Depth, unsigned Index,
1636 bool ParameterPack,
1637 TemplateTypeParmDecl *ParmDecl = nullptr) const;
1638
1641 QualType Canon = QualType()) const;
1642
1643 QualType
1645 ArrayRef<TemplateArgument> Args) const;
1646
1649 QualType Canon = QualType()) const;
1650
1653 const TemplateArgumentListInfo &Args,
1654 QualType Canon = QualType()) const;
1655
1656 QualType getParenType(QualType NamedType) const;
1657
1659 const IdentifierInfo *MacroII) const;
1660
1662 NestedNameSpecifier *NNS, QualType NamedType,
1663 TagDecl *OwnedTagDecl = nullptr) const;
1666 const IdentifierInfo *Name,
1667 QualType Canon = QualType()) const;
1668
1671 const IdentifierInfo *Name, ArrayRef<TemplateArgumentLoc> Args) const;
1674 const IdentifierInfo *Name, ArrayRef<TemplateArgument> Args) const;
1675
1677
1678 /// Get a template argument list with one argument per template parameter
1679 /// in a template parameter list, such as for the injected class name of
1680 /// a class template.
1683
1684 /// Form a pack expansion type with the given pattern.
1685 /// \param NumExpansions The number of expansions for the pack, if known.
1686 /// \param ExpectPackInType If \c false, we should not expect \p Pattern to
1687 /// contain an unexpanded pack. This only makes sense if the pack
1688 /// expansion is used in a context where the arity is inferred from
1689 /// elsewhere, such as if the pattern contains a placeholder type or
1690 /// if this is the canonical type of another pack expansion type.
1692 std::optional<unsigned> NumExpansions,
1693 bool ExpectPackInType = true);
1694
1696 ObjCInterfaceDecl *PrevDecl = nullptr) const;
1697
1698 /// Legacy interface: cannot provide type arguments or __kindof.
1700 ObjCProtocolDecl * const *Protocols,
1701 unsigned NumProtocols) const;
1702
1704 ArrayRef<QualType> typeArgs,
1706 bool isKindOf) const;
1707
1709 ArrayRef<ObjCProtocolDecl *> protocols) const;
1711 ObjCTypeParamDecl *New) const;
1712
1714
1715 /// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
1716 /// QT's qualified-id protocol list adopt all protocols in IDecl's list
1717 /// of protocols.
1719 ObjCInterfaceDecl *IDecl);
1720
1721 /// Return a ObjCObjectPointerType type for the given ObjCObjectType.
1723
1724 /// C23 feature and GCC extension.
1725 QualType getTypeOfExprType(Expr *E, TypeOfKind Kind) const;
1726 QualType getTypeOfType(QualType QT, TypeOfKind Kind) const;
1727
1728 QualType getReferenceQualifiedType(const Expr *e) const;
1729
1730 /// C++11 decltype.
1731 QualType getDecltypeType(Expr *e, QualType UnderlyingType) const;
1732
1733 QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr,
1734 bool FullySubstituted = false,
1735 ArrayRef<QualType> Expansions = {},
1736 int Index = -1) const;
1737
1738 /// Unary type transforms
1739 QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType,
1740 UnaryTransformType::UTTKind UKind) const;
1741
1742 /// C++11 deduced auto type.
1743 QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
1744 bool IsDependent, bool IsPack = false,
1745 ConceptDecl *TypeConstraintConcept = nullptr,
1746 ArrayRef<TemplateArgument> TypeConstraintArgs ={}) const;
1747
1748 /// C++11 deduction pattern for 'auto' type.
1749 QualType getAutoDeductType() const;
1750
1751 /// C++11 deduction pattern for 'auto &&' type.
1752 QualType getAutoRRefDeductType() const;
1753
1754 /// Remove any type constraints from a template parameter type, for
1755 /// equivalence comparison of template parameters.
1756 QualType getUnconstrainedType(QualType T) const;
1757
1758 /// C++17 deduced class template specialization type.
1759 QualType getDeducedTemplateSpecializationType(TemplateName Template,
1760 QualType DeducedType,
1761 bool IsDependent) const;
1762
1763 /// Return the unique reference to the type for the specified TagDecl
1764 /// (struct/union/class/enum) decl.
1765 QualType getTagDeclType(const TagDecl *Decl) const;
1766
1767 /// Return the unique type for "size_t" (C99 7.17), defined in
1768 /// <stddef.h>.
1769 ///
1770 /// The sizeof operator requires this (C99 6.5.3.4p4).
1771 CanQualType getSizeType() const;
1772
1773 /// Return the unique signed counterpart of
1774 /// the integer type corresponding to size_t.
1776
1777 /// Return the unique type for "intmax_t" (C99 7.18.1.5), defined in
1778 /// <stdint.h>.
1779 CanQualType getIntMaxType() const;
1780
1781 /// Return the unique type for "uintmax_t" (C99 7.18.1.5), defined in
1782 /// <stdint.h>.
1784
1785 /// Return the unique wchar_t type available in C++ (and available as
1786 /// __wchar_t as a Microsoft extension).
1787 QualType getWCharType() const { return WCharTy; }
1788
1789 /// Return the type of wide characters. In C++, this returns the
1790 /// unique wchar_t type. In C99, this returns a type compatible with the type
1791 /// defined in <stddef.h> as defined by the target.
1793
1794 /// Return the type of "signed wchar_t".
1795 ///
1796 /// Used when in C++, as a GCC extension.
1798
1799 /// Return the type of "unsigned wchar_t".
1800 ///
1801 /// Used when in C++, as a GCC extension.
1803
1804 /// In C99, this returns a type compatible with the type
1805 /// defined in <stddef.h> as defined by the target.
1806 QualType getWIntType() const { return WIntTy; }
1807
1808 /// Return a type compatible with "intptr_t" (C99 7.18.1.4),
1809 /// as defined by the target.
1810 QualType getIntPtrType() const;
1811
1812 /// Return a type compatible with "uintptr_t" (C99 7.18.1.4),
1813 /// as defined by the target.
1814 QualType getUIntPtrType() const;
1815
1816 /// Return the unique type for "ptrdiff_t" (C99 7.17) defined in
1817 /// <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
1819
1820 /// Return the unique unsigned counterpart of "ptrdiff_t"
1821 /// integer type. The standard (C11 7.21.6.1p7) refers to this type
1822 /// in the definition of %tu format specifier.
1824
1825 /// Return the unique type for "pid_t" defined in
1826 /// <sys/types.h>. We need this to compute the correct type for vfork().
1827 QualType getProcessIDType() const;
1828
1829 /// Return the C structure type used to represent constant CFStrings.
1831
1832 /// Returns the C struct type for objc_super
1833 QualType getObjCSuperType() const;
1834 void setObjCSuperType(QualType ST) { ObjCSuperType = ST; }
1835
1836 /// Get the structure type used to representation CFStrings, or NULL
1837 /// if it hasn't yet been built.
1839 if (CFConstantStringTypeDecl)
1840 return getTypedefType(CFConstantStringTypeDecl);
1841 return QualType();
1842 }
1846
1847 // This setter/getter represents the ObjC type for an NSConstantString.
1850 return ObjCConstantStringType;
1851 }
1852
1854 return ObjCNSStringType;
1855 }
1856
1858 ObjCNSStringType = T;
1859 }
1860
1861 /// Retrieve the type that \c id has been defined to, which may be
1862 /// different from the built-in \c id if \c id has been typedef'd.
1864 if (ObjCIdRedefinitionType.isNull())
1865 return getObjCIdType();
1866 return ObjCIdRedefinitionType;
1867 }
1868
1869 /// Set the user-written type that redefines \c id.
1871 ObjCIdRedefinitionType = RedefType;
1872 }
1873
1874 /// Retrieve the type that \c Class has been defined to, which may be
1875 /// different from the built-in \c Class if \c Class has been typedef'd.
1877 if (ObjCClassRedefinitionType.isNull())
1878 return getObjCClassType();
1879 return ObjCClassRedefinitionType;
1880 }
1881
1882 /// Set the user-written type that redefines 'SEL'.
1884 ObjCClassRedefinitionType = RedefType;
1885 }
1886
1887 /// Retrieve the type that 'SEL' has been defined to, which may be
1888 /// different from the built-in 'SEL' if 'SEL' has been typedef'd.
1890 if (ObjCSelRedefinitionType.isNull())
1891 return getObjCSelType();
1892 return ObjCSelRedefinitionType;
1893 }
1894
1895 /// Set the user-written type that redefines 'SEL'.
1897 ObjCSelRedefinitionType = RedefType;
1898 }
1899
1900 /// Retrieve the identifier 'NSObject'.
1902 if (!NSObjectName) {
1903 NSObjectName = &Idents.get("NSObject");
1904 }
1905
1906 return NSObjectName;
1907 }
1908
1909 /// Retrieve the identifier 'NSCopying'.
1911 if (!NSCopyingName) {
1912 NSCopyingName = &Idents.get("NSCopying");
1913 }
1914
1915 return NSCopyingName;
1916 }
1917
1919
1921
1922 /// Retrieve the identifier 'bool'.
1924 if (!BoolName)
1925 BoolName = &Idents.get("bool");
1926 return BoolName;
1927 }
1928
1930 if (!MakeIntegerSeqName)
1931 MakeIntegerSeqName = &Idents.get("__make_integer_seq");
1932 return MakeIntegerSeqName;
1933 }
1934
1936 if (!TypePackElementName)
1937 TypePackElementName = &Idents.get("__type_pack_element");
1938 return TypePackElementName;
1939 }
1940
1941 /// Retrieve the Objective-C "instancetype" type, if already known;
1942 /// otherwise, returns a NULL type;
1945 }
1946
1947 /// Retrieve the typedef declaration corresponding to the Objective-C
1948 /// "instancetype" type.
1950
1951 /// Set the type for the C FILE type.
1952 void setFILEDecl(TypeDecl *FILEDecl) { this->FILEDecl = FILEDecl; }
1953
1954 /// Retrieve the C FILE type.
1956 if (FILEDecl)
1957 return getTypeDeclType(FILEDecl);
1958 return QualType();
1959 }
1960
1961 /// Set the type for the C jmp_buf type.
1962 void setjmp_bufDecl(TypeDecl *jmp_bufDecl) {
1963 this->jmp_bufDecl = jmp_bufDecl;
1964 }
1965
1966 /// Retrieve the C jmp_buf type.
1968 if (jmp_bufDecl)
1969 return getTypeDeclType(jmp_bufDecl);
1970 return QualType();
1971 }
1972
1973 /// Set the type for the C sigjmp_buf type.
1974 void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl) {
1975 this->sigjmp_bufDecl = sigjmp_bufDecl;
1976 }
1977
1978 /// Retrieve the C sigjmp_buf type.
1980 if (sigjmp_bufDecl)
1981 return getTypeDeclType(sigjmp_bufDecl);
1982 return QualType();
1983 }
1984
1985 /// Set the type for the C ucontext_t type.
1986 void setucontext_tDecl(TypeDecl *ucontext_tDecl) {
1987 this->ucontext_tDecl = ucontext_tDecl;
1988 }
1989
1990 /// Retrieve the C ucontext_t type.
1992 if (ucontext_tDecl)
1993 return getTypeDeclType(ucontext_tDecl);
1994 return QualType();
1995 }
1996
1997 /// The result type of logical operations, '<', '>', '!=', etc.
1999 return getLangOpts().CPlusPlus ? BoolTy : IntTy;
2000 }
2001
2002 /// Emit the Objective-CC type encoding for the given type \p T into
2003 /// \p S.
2004 ///
2005 /// If \p Field is specified then record field names are also encoded.
2006 void getObjCEncodingForType(QualType T, std::string &S,
2007 const FieldDecl *Field=nullptr,
2008 QualType *NotEncodedT=nullptr) const;
2009
2010 /// Emit the Objective-C property type encoding for the given
2011 /// type \p T into \p S.
2012 void getObjCEncodingForPropertyType(QualType T, std::string &S) const;
2013
2015
2016 /// Put the string version of the type qualifiers \p QT into \p S.
2018 std::string &S) const;
2019
2020 /// Emit the encoded type for the function \p Decl into \p S.
2021 ///
2022 /// This is in the same format as Objective-C method encodings.
2023 ///
2024 /// \returns true if an error occurred (e.g., because one of the parameter
2025 /// types is incomplete), false otherwise.
2026 std::string getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const;
2027
2028 /// Emit the encoded type for the method declaration \p Decl into
2029 /// \p S.
2031 bool Extended = false) const;
2032
2033 /// Return the encoded type for this block declaration.
2034 std::string getObjCEncodingForBlock(const BlockExpr *blockExpr) const;
2035
2036 /// getObjCEncodingForPropertyDecl - Return the encoded type for
2037 /// this method declaration. If non-NULL, Container must be either
2038 /// an ObjCCategoryImplDecl or ObjCImplementationDecl; it should
2039 /// only be NULL when getting encodings for protocol properties.
2041 const Decl *Container) const;
2042
2044 ObjCProtocolDecl *rProto) const;
2045
2047 const ObjCPropertyDecl *PD,
2048 const Decl *Container) const;
2049
2050 /// Return the size of type \p T for Objective-C encoding purpose,
2051 /// in characters.
2053
2054 /// Retrieve the typedef corresponding to the predefined \c id type
2055 /// in Objective-C.
2056 TypedefDecl *getObjCIdDecl() const;
2057
2058 /// Represents the Objective-CC \c id type.
2059 ///
2060 /// This is set up lazily, by Sema. \c id is always a (typedef for a)
2061 /// pointer type, a pointer to a struct.
2064 }
2065
2066 /// Retrieve the typedef corresponding to the predefined 'SEL' type
2067 /// in Objective-C.
2068 TypedefDecl *getObjCSelDecl() const;
2069
2070 /// Retrieve the type that corresponds to the predefined Objective-C
2071 /// 'SEL' type.
2074 }
2075
2076 /// Retrieve the typedef declaration corresponding to the predefined
2077 /// Objective-C 'Class' type.
2079
2080 /// Represents the Objective-C \c Class type.
2081 ///
2082 /// This is set up lazily, by Sema. \c Class is always a (typedef for a)
2083 /// pointer type, a pointer to a struct.
2086 }
2087
2088 /// Retrieve the Objective-C class declaration corresponding to
2089 /// the predefined \c Protocol class.
2091
2092 /// Retrieve declaration of 'BOOL' typedef
2094 return BOOLDecl;
2095 }
2096
2097 /// Save declaration of 'BOOL' typedef
2099 BOOLDecl = TD;
2100 }
2101
2102 /// type of 'BOOL' type.
2104 return getTypeDeclType(getBOOLDecl());
2105 }
2106
2107 /// Retrieve the type of the Objective-C \c Protocol class.
2110 }
2111
2112 /// Retrieve the C type declaration corresponding to the predefined
2113 /// \c __builtin_va_list type.
2115
2116 /// Retrieve the type of the \c __builtin_va_list type.
2119 }
2120
2121 /// Retrieve the C type declaration corresponding to the predefined
2122 /// \c __va_list_tag type used to help define the \c __builtin_va_list type
2123 /// for some targets.
2124 Decl *getVaListTagDecl() const;
2125
2126 /// Retrieve the C type declaration corresponding to the predefined
2127 /// \c __builtin_ms_va_list type.
2129
2130 /// Retrieve the type of the \c __builtin_ms_va_list type.
2133 }
2134
2135 /// Retrieve the implicitly-predeclared 'struct _GUID' declaration.
2137
2138 /// Retrieve the implicitly-predeclared 'struct _GUID' type.
2140 assert(MSGuidTagDecl && "asked for GUID type but MS extensions disabled");
2142 }
2143
2144 /// Return whether a declaration to a builtin is allowed to be
2145 /// overloaded/redeclared.
2146 bool canBuiltinBeRedeclared(const FunctionDecl *) const;
2147
2148 /// Return a type with additional \c const, \c volatile, or
2149 /// \c restrict qualifiers.
2152 }
2153
2154 /// Un-split a SplitQualType.
2156 return getQualifiedType(split.Ty, split.Quals);
2157 }
2158
2159 /// Return a type with additional qualifiers.
2161 if (!Qs.hasNonFastQualifiers())
2162 return T.withFastQualifiers(Qs.getFastQualifiers());
2163 QualifierCollector Qc(Qs);
2164 const Type *Ptr = Qc.strip(T);
2165 return getExtQualType(Ptr, Qc);
2166 }
2167
2168 /// Return a type with additional qualifiers.
2170 if (!Qs.hasNonFastQualifiers())
2171 return QualType(T, Qs.getFastQualifiers());
2172 return getExtQualType(T, Qs);
2173 }
2174
2175 /// Return a type with the given lifetime qualifier.
2176 ///
2177 /// \pre Neither type.ObjCLifetime() nor \p lifetime may be \c OCL_None.
2179 Qualifiers::ObjCLifetime lifetime) {
2180 assert(type.getObjCLifetime() == Qualifiers::OCL_None);
2181 assert(lifetime != Qualifiers::OCL_None);
2182
2183 Qualifiers qs;
2184 qs.addObjCLifetime(lifetime);
2185 return getQualifiedType(type, qs);
2186 }
2187
2188 /// getUnqualifiedObjCPointerType - Returns version of
2189 /// Objective-C pointer type with lifetime qualifier removed.
2191 if (!type.getTypePtr()->isObjCObjectPointerType() ||
2192 !type.getQualifiers().hasObjCLifetime())
2193 return type;
2194 Qualifiers Qs = type.getQualifiers();
2195 Qs.removeObjCLifetime();
2196 return getQualifiedType(type.getUnqualifiedType(), Qs);
2197 }
2198
2199 unsigned char getFixedPointScale(QualType Ty) const;
2200 unsigned char getFixedPointIBits(QualType Ty) const;
2201 llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const;
2202 llvm::APFixedPoint getFixedPointMax(QualType Ty) const;
2203 llvm::APFixedPoint getFixedPointMin(QualType Ty) const;
2204
2206 SourceLocation NameLoc) const;
2207
2209 UnresolvedSetIterator End) const;
2211
2213 bool TemplateKeyword,
2214 TemplateName Template) const;
2215
2217 const IdentifierInfo *Name) const;
2219 OverloadedOperatorKind Operator) const;
2221 getSubstTemplateTemplateParm(TemplateName replacement, Decl *AssociatedDecl,
2222 unsigned Index,
2223 std::optional<unsigned> PackIndex) const;
2225 Decl *AssociatedDecl,
2226 unsigned Index,
2227 bool Final) const;
2228
2230 /// No error
2232
2233 /// Missing a type
2235
2236 /// Missing a type from <stdio.h>
2238
2239 /// Missing a type from <setjmp.h>
2241
2242 /// Missing a type from <ucontext.h>
2245
2246 QualType DecodeTypeStr(const char *&Str, const ASTContext &Context,
2248 bool &RequireICE, bool AllowTypeModifiers) const;
2249
2250 /// Return the type for the specified builtin.
2251 ///
2252 /// If \p IntegerConstantArgs is non-null, it is filled in with a bitmask of
2253 /// arguments to the builtin that are required to be integer constant
2254 /// expressions.
2256 unsigned *IntegerConstantArgs = nullptr) const;
2257
2258 /// Types and expressions required to build C++2a three-way comparisons
2259 /// using operator<=>, including the values return by builtin <=> operators.
2261
2262private:
2263 CanQualType getFromTargetType(unsigned Type) const;
2264 TypeInfo getTypeInfoImpl(const Type *T) const;
2265
2266 //===--------------------------------------------------------------------===//
2267 // Type Predicates.
2268 //===--------------------------------------------------------------------===//
2269
2270public:
2271 /// Return one of the GCNone, Weak or Strong Objective-C garbage
2272 /// collection attributes.
2274
2275 /// Return true if the given vector types are of the same unqualified
2276 /// type or if they are equivalent to the same GCC vector type.
2277 ///
2278 /// \note This ignores whether they are target-specific (AltiVec or Neon)
2279 /// types.
2280 bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec);
2281
2282 /// Return true if the given types are an SVE builtin and a VectorType that
2283 /// is a fixed-length representation of the SVE builtin for a specific
2284 /// vector-length.
2285 bool areCompatibleSveTypes(QualType FirstType, QualType SecondType);
2286
2287 /// Return true if the given vector types are lax-compatible SVE vector types,
2288 /// false otherwise.
2289 bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType);
2290
2291 /// Return true if the given types are an RISC-V vector builtin type and a
2292 /// VectorType that is a fixed-length representation of the RISC-V vector
2293 /// builtin type for a specific vector-length.
2294 bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType);
2295
2296 /// Return true if the given vector types are lax-compatible RISC-V vector
2297 /// types as defined by -flax-vector-conversions=, which permits implicit
2298 /// conversions between vectors with different number of elements and/or
2299 /// incompatible element types, false otherwise.
2300 bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType);
2301
2302 /// Return true if the type has been explicitly qualified with ObjC ownership.
2303 /// A type may be implicitly qualified with ownership under ObjC ARC, and in
2304 /// some cases the compiler treats these differently.
2306
2307 /// Return true if this is an \c NSObject object with its \c NSObject
2308 /// attribute set.
2310 return Ty->isObjCNSObjectType();
2311 }
2312
2313 //===--------------------------------------------------------------------===//
2314 // Type Sizing and Analysis
2315 //===--------------------------------------------------------------------===//
2316
2317 /// Return the APFloat 'semantics' for the specified scalar floating
2318 /// point type.
2319 const llvm::fltSemantics &getFloatTypeSemantics(QualType T) const;
2320
2321 /// Get the size and alignment of the specified complete type in bits.
2322 TypeInfo getTypeInfo(const Type *T) const;
2323 TypeInfo getTypeInfo(QualType T) const { return getTypeInfo(T.getTypePtr()); }
2324
2325 /// Get default simd alignment of the specified complete type in bits.
2326 unsigned getOpenMPDefaultSimdAlign(QualType T) const;
2327
2328 /// Return the size of the specified (complete) type \p T, in bits.
2329 uint64_t getTypeSize(QualType T) const { return getTypeInfo(T).Width; }
2330 uint64_t getTypeSize(const Type *T) const { return getTypeInfo(T).Width; }
2331
2332 /// Return the size of the character type, in bits.
2333 uint64_t getCharWidth() const {
2334 return getTypeSize(CharTy);
2335 }
2336
2337 /// Convert a size in bits to a size in characters.
2338 CharUnits toCharUnitsFromBits(int64_t BitSize) const;
2339
2340 /// Convert a size in characters to a size in bits.
2341 int64_t toBits(CharUnits CharSize) const;
2342
2343 /// Return the size of the specified (complete) type \p T, in
2344 /// characters.
2346 CharUnits getTypeSizeInChars(const Type *T) const;
2347
2348 std::optional<CharUnits> getTypeSizeInCharsIfKnown(QualType Ty) const {
2349 if (Ty->isIncompleteType() || Ty->isDependentType())
2350 return std::nullopt;
2351 return getTypeSizeInChars(Ty);
2352 }
2353
2354 std::optional<CharUnits> getTypeSizeInCharsIfKnown(const Type *Ty) const {
2355 return getTypeSizeInCharsIfKnown(QualType(Ty, 0));
2356 }
2357
2358 /// Return the ABI-specified alignment of a (complete) type \p T, in
2359 /// bits.
2360 unsigned getTypeAlign(QualType T) const { return getTypeInfo(T).Align; }
2361 unsigned getTypeAlign(const Type *T) const { return getTypeInfo(T).Align; }
2362
2363 /// Return the ABI-specified natural alignment of a (complete) type \p T,
2364 /// before alignment adjustments, in bits.
2365 ///
2366 /// This alignment is curently used only by ARM and AArch64 when passing
2367 /// arguments of a composite type.
2369 return getTypeUnadjustedAlign(T.getTypePtr());
2370 }
2371 unsigned getTypeUnadjustedAlign(const Type *T) const;
2372
2373 /// Return the alignment of a type, in bits, or 0 if
2374 /// the type is incomplete and we cannot determine the alignment (for
2375 /// example, from alignment attributes). The returned alignment is the
2376 /// Preferred alignment if NeedsPreferredAlignment is true, otherwise is the
2377 /// ABI alignment.
2379 bool NeedsPreferredAlignment = false) const;
2380
2381 /// Return the ABI-specified alignment of a (complete) type \p T, in
2382 /// characters.
2384 CharUnits getTypeAlignInChars(const Type *T) const;
2385
2386 /// Return the PreferredAlignment of a (complete) type \p T, in
2387 /// characters.
2390 }
2391
2392 /// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a type,
2393 /// in characters, before alignment adjustments. This method does not work on
2394 /// incomplete types.
2397
2398 // getTypeInfoDataSizeInChars - Return the size of a type, in chars. If the
2399 // type is a record, its data size is returned.
2401
2402 TypeInfoChars getTypeInfoInChars(const Type *T) const;
2404
2405 /// Determine if the alignment the type has was required using an
2406 /// alignment attribute.
2407 bool isAlignmentRequired(const Type *T) const;
2408 bool isAlignmentRequired(QualType T) const;
2409
2410 /// More type predicates useful for type checking/promotion
2411 bool isPromotableIntegerType(QualType T) const; // C99 6.3.1.1p2
2412
2413 /// Return the "preferred" alignment of the specified type \p T for
2414 /// the current target, in bits.
2415 ///
2416 /// This can be different than the ABI alignment in cases where it is
2417 /// beneficial for performance or backwards compatibility preserving to
2418 /// overalign a data type. (Note: despite the name, the preferred alignment
2419 /// is ABI-impacting, and not an optimization.)
2421 return getPreferredTypeAlign(T.getTypePtr());
2422 }
2423 unsigned getPreferredTypeAlign(const Type *T) const;
2424
2425 /// Return the default alignment for __attribute__((aligned)) on
2426 /// this target, to be used if no alignment value is specified.
2428
2429 /// Return the alignment in bits that should be given to a
2430 /// global variable with type \p T. If \p VD is non-null it will be
2431 /// considered specifically for the query.
2432 unsigned getAlignOfGlobalVar(QualType T, const VarDecl *VD) const;
2433
2434 /// Return the alignment in characters that should be given to a
2435 /// global variable with type \p T. If \p VD is non-null it will be
2436 /// considered specifically for the query.
2438
2439 /// Return the minimum alignement as specified by the target. If \p VD is
2440 /// non-null it may be used to identify external or weak variables.
2441 unsigned getMinGlobalAlignOfVar(uint64_t Size, const VarDecl *VD) const;
2442
2443 /// Return a conservative estimate of the alignment of the specified
2444 /// decl \p D.
2445 ///
2446 /// \pre \p D must not be a bitfield type, as bitfields do not have a valid
2447 /// alignment.
2448 ///
2449 /// If \p ForAlignof, references are treated like their underlying type
2450 /// and large arrays don't get any special treatment. If not \p ForAlignof
2451 /// it computes the value expected by CodeGen: references are treated like
2452 /// pointers and large arrays get extra alignment.
2453 CharUnits getDeclAlign(const Decl *D, bool ForAlignof = false) const;
2454
2455 /// Return the alignment (in bytes) of the thrown exception object. This is
2456 /// only meaningful for targets that allocate C++ exceptions in a system
2457 /// runtime, such as those using the Itanium C++ ABI.
2459
2460 /// Get or compute information about the layout of the specified
2461 /// record (struct/union/class) \p D, which indicates its size and field
2462 /// position information.
2463 const ASTRecordLayout &getASTRecordLayout(const RecordDecl *D) const;
2464
2465 /// Get or compute information about the layout of the specified
2466 /// Objective-C interface.
2468 const;
2469
2470 void DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS,
2471 bool Simple = false) const;
2472
2473 /// Get or compute information about the layout of the specified
2474 /// Objective-C implementation.
2475 ///
2476 /// This may differ from the interface if synthesized ivars are present.
2477 const ASTRecordLayout &
2479
2480 /// Get our current best idea for the key function of the
2481 /// given record decl, or nullptr if there isn't one.
2482 ///
2483 /// The key function is, according to the Itanium C++ ABI section 5.2.3:
2484 /// ...the first non-pure virtual function that is not inline at the
2485 /// point of class definition.
2486 ///
2487 /// Other ABIs use the same idea. However, the ARM C++ ABI ignores
2488 /// virtual functions that are defined 'inline', which means that
2489 /// the result of this computation can change.
2491
2492 /// Observe that the given method cannot be a key function.
2493 /// Checks the key-function cache for the method's class and clears it
2494 /// if matches the given declaration.
2495 ///
2496 /// This is used in ABIs where out-of-line definitions marked
2497 /// inline are not considered to be key functions.
2498 ///
2499 /// \param method should be the declaration from the class definition
2500 void setNonKeyFunction(const CXXMethodDecl *method);
2501
2502 /// Loading virtual member pointers using the virtual inheritance model
2503 /// always results in an adjustment using the vbtable even if the index is
2504 /// zero.
2505 ///
2506 /// This is usually OK because the first slot in the vbtable points
2507 /// backwards to the top of the MDC. However, the MDC might be reusing a
2508 /// vbptr from an nv-base. In this case, the first slot in the vbtable
2509 /// points to the start of the nv-base which introduced the vbptr and *not*
2510 /// the MDC. Modify the NonVirtualBaseAdjustment to account for this.
2512
2513 /// Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
2514 uint64_t getFieldOffset(const ValueDecl *FD) const;
2515
2516 /// Get the offset of an ObjCIvarDecl in bits.
2517 uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID,
2519 const ObjCIvarDecl *Ivar) const;
2520
2521 /// Find the 'this' offset for the member path in a pointer-to-member
2522 /// APValue.
2524
2525 bool isNearlyEmpty(const CXXRecordDecl *RD) const;
2526
2528
2529 /// If \p T is null pointer, assume the target in ASTContext.
2530 MangleContext *createMangleContext(const TargetInfo *T = nullptr);
2531
2532 /// Creates a device mangle context to correctly mangle lambdas in a mixed
2533 /// architecture compile by setting the lambda mangling number source to the
2534 /// DeviceLambdaManglingNumber. Currently this asserts that the TargetInfo
2535 /// (from the AuxTargetInfo) is a an itanium target.
2537
2538 void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass,
2540
2541 unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const;
2542 void CollectInheritedProtocols(const Decl *CDecl,
2544
2545 /// Return true if the specified type has unique object representations
2546 /// according to (C++17 [meta.unary.prop]p9)
2547 bool
2549 bool CheckIfTriviallyCopyable = true) const;
2550
2551 //===--------------------------------------------------------------------===//
2552 // Type Operators
2553 //===--------------------------------------------------------------------===//
2554
2555 /// Return the canonical (structural) type corresponding to the
2556 /// specified potentially non-canonical type \p T.
2557 ///
2558 /// The non-canonical version of a type may have many "decorated" versions of
2559 /// types. Decorators can include typedefs, 'typeof' operators, etc. The
2560 /// returned type is guaranteed to be free of any of these, allowing two
2561 /// canonical types to be compared for exact equality with a simple pointer
2562 /// comparison.
2564 return CanQualType::CreateUnsafe(T.getCanonicalType());
2565 }
2566
2567 const Type *getCanonicalType(const Type *T) const {
2569 }
2570
2571 /// Return the canonical parameter type corresponding to the specific
2572 /// potentially non-canonical one.
2573 ///
2574 /// Qualifiers are stripped off, functions are turned into function
2575 /// pointers, and arrays decay one level into pointers.
2577
2578 /// Determine whether the given types \p T1 and \p T2 are equivalent.
2579 bool hasSameType(QualType T1, QualType T2) const {
2580 return getCanonicalType(T1) == getCanonicalType(T2);
2581 }
2582 bool hasSameType(const Type *T1, const Type *T2) const {
2583 return getCanonicalType(T1) == getCanonicalType(T2);
2584 }
2585
2586 /// Determine whether the given expressions \p X and \p Y are equivalent.
2587 bool hasSameExpr(const Expr *X, const Expr *Y) const;
2588
2589 /// Return this type as a completely-unqualified array type,
2590 /// capturing the qualifiers in \p Quals.
2591 ///
2592 /// This will remove the minimal amount of sugaring from the types, similar
2593 /// to the behavior of QualType::getUnqualifiedType().
2594 ///
2595 /// \param T is the qualified type, which may be an ArrayType
2596 ///
2597 /// \param Quals will receive the full set of qualifiers that were
2598 /// applied to the array.
2599 ///
2600 /// \returns if this is an array type, the completely unqualified array type
2601 /// that corresponds to it. Otherwise, returns T.getUnqualifiedType().
2603
2604 /// Determine whether the given types are equivalent after
2605 /// cvr-qualifiers have been removed.
2607 return getCanonicalType(T1).getTypePtr() ==
2609 }
2610
2612 bool IsParam) const {
2613 auto SubTnullability = SubT->getNullability();
2614 auto SuperTnullability = SuperT->getNullability();
2615 if (SubTnullability.has_value() == SuperTnullability.has_value()) {
2616 // Neither has nullability; return true
2617 if (!SubTnullability)
2618 return true;
2619 // Both have nullability qualifier.
2620 if (*SubTnullability == *SuperTnullability ||
2621 *SubTnullability == NullabilityKind::Unspecified ||
2622 *SuperTnullability == NullabilityKind::Unspecified)
2623 return true;
2624
2625 if (IsParam) {
2626 // Ok for the superclass method parameter to be "nonnull" and the subclass
2627 // method parameter to be "nullable"
2628 return (*SuperTnullability == NullabilityKind::NonNull &&
2629 *SubTnullability == NullabilityKind::Nullable);
2630 }
2631 // For the return type, it's okay for the superclass method to specify
2632 // "nullable" and the subclass method specify "nonnull"
2633 return (*SuperTnullability == NullabilityKind::Nullable &&
2634 *SubTnullability == NullabilityKind::NonNull);
2635 }
2636 return true;
2637 }
2638
2639 bool ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl,
2640 const ObjCMethodDecl *MethodImp);
2641
2642 bool UnwrapSimilarTypes(QualType &T1, QualType &T2,
2643 bool AllowPiMismatch = true);
2645 bool AllowPiMismatch = true);
2646
2647 /// Determine if two types are similar, according to the C++ rules. That is,
2648 /// determine if they are the same other than qualifiers on the initial
2649 /// sequence of pointer / pointer-to-member / array (and in Clang, object
2650 /// pointer) types and their element types.
2651 ///
2652 /// Clang offers a number of qualifiers in addition to the C++ qualifiers;
2653 /// those qualifiers are also ignored in the 'similarity' check.
2654 bool hasSimilarType(QualType T1, QualType T2);
2655
2656 /// Determine if two types are similar, ignoring only CVR qualifiers.
2657 bool hasCvrSimilarType(QualType T1, QualType T2);
2658
2659 /// Retrieves the "canonical" nested name specifier for a
2660 /// given nested name specifier.
2661 ///
2662 /// The canonical nested name specifier is a nested name specifier
2663 /// that uniquely identifies a type or namespace within the type
2664 /// system. For example, given:
2665 ///
2666 /// \code
2667 /// namespace N {
2668 /// struct S {
2669 /// template<typename T> struct X { typename T* type; };
2670 /// };
2671 /// }
2672 ///
2673 /// template<typename T> struct Y {
2674 /// typename N::S::X<T>::type member;
2675 /// };
2676 /// \endcode
2677 ///
2678 /// Here, the nested-name-specifier for N::S::X<T>:: will be
2679 /// S::X<template-param-0-0>, since 'S' and 'X' are uniquely defined
2680 /// by declarations in the type system and the canonical type for
2681 /// the template type parameter 'T' is template-param-0-0.
2684
2685 /// Retrieves the default calling convention for the current target.
2687 bool IsCXXMethod,
2688 bool IsBuiltin = false) const;
2689
2690 /// Retrieves the "canonical" template name that refers to a
2691 /// given template.
2692 ///
2693 /// The canonical template name is the simplest expression that can
2694 /// be used to refer to a given template. For most templates, this
2695 /// expression is just the template declaration itself. For example,
2696 /// the template std::vector can be referred to via a variety of
2697 /// names---std::vector, \::std::vector, vector (if vector is in
2698 /// scope), etc.---but all of these names map down to the same
2699 /// TemplateDecl, which is used to form the canonical template name.
2700 ///
2701 /// Dependent template names are more interesting. Here, the
2702 /// template name could be something like T::template apply or
2703 /// std::allocator<T>::template rebind, where the nested name
2704 /// specifier itself is dependent. In this case, the canonical
2705 /// template name uses the shortest form of the dependent
2706 /// nested-name-specifier, which itself contains all canonical
2707 /// types, values, and templates.
2709
2710 /// Determine whether the given template names refer to the same
2711 /// template.
2712 bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y) const;
2713
2714 /// Determine whether the two declarations refer to the same entity.
2715 bool isSameEntity(const NamedDecl *X, const NamedDecl *Y) const;
2716
2717 /// Determine whether two template parameter lists are similar enough
2718 /// that they may be used in declarations of the same template.
2720 const TemplateParameterList *Y) const;
2721
2722 /// Determine whether two template parameters are similar enough
2723 /// that they may be used in declarations of the same template.
2724 bool isSameTemplateParameter(const NamedDecl *X, const NamedDecl *Y) const;
2725
2726 /// Determine whether two 'requires' expressions are similar enough that they
2727 /// may be used in re-declarations.
2728 ///
2729 /// Use of 'requires' isn't mandatory, works with constraints expressed in
2730 /// other ways too.
2731 bool isSameConstraintExpr(const Expr *XCE, const Expr *YCE) const;
2732
2733 /// Determine whether two type contraint are similar enough that they could
2734 /// used in declarations of the same template.
2735 bool isSameTypeConstraint(const TypeConstraint *XTC,
2736 const TypeConstraint *YTC) const;
2737
2738 /// Determine whether two default template arguments are similar enough
2739 /// that they may be used in declarations of the same template.
2741 const NamedDecl *Y) const;
2742
2743 /// Retrieve the "canonical" template argument.
2744 ///
2745 /// The canonical template argument is the simplest template argument
2746 /// (which may be a type, value, expression, or declaration) that
2747 /// expresses the value of the argument.
2749 const;
2750
2751 /// Type Query functions. If the type is an instance of the specified class,
2752 /// return the Type pointer for the underlying maximally pretty type. This
2753 /// is a member of ASTContext because this may need to do some amount of
2754 /// canonicalization, e.g. to move type qualifiers into the element type.
2755 const ArrayType *getAsArrayType(QualType T) const;
2757 return dyn_cast_or_null<ConstantArrayType>(getAsArrayType(T));
2758 }
2760 return dyn_cast_or_null<VariableArrayType>(getAsArrayType(T));
2761 }
2763 return dyn_cast_or_null<IncompleteArrayType>(getAsArrayType(T));
2764 }
2766 const {
2767 return dyn_cast_or_null<DependentSizedArrayType>(getAsArrayType(T));
2768 }
2769
2770 /// Return the innermost element type of an array type.
2771 ///
2772 /// For example, will return "int" for int[m][n]
2773 QualType getBaseElementType(const ArrayType *VAT) const;
2774
2775 /// Return the innermost element type of a type (which needn't
2776 /// actually be an array type).
2778
2779 /// Return number of constant array elements.
2780 uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const;
2781
2782 /// Return number of elements initialized in an ArrayInitLoopExpr.
2783 uint64_t
2785
2786 /// Perform adjustment on the parameter type of a function.
2787 ///
2788 /// This routine adjusts the given parameter type @p T to the actual
2789 /// parameter type used by semantic analysis (C99 6.7.5.3p[7,8],
2790 /// C++ [dcl.fct]p3). The adjusted parameter type is returned.
2792
2793 /// Retrieve the parameter type as adjusted for use in the signature
2794 /// of a function, decaying array and function types and removing top-level
2795 /// cv-qualifiers.
2797
2799
2800 /// Return the properly qualified result of decaying the specified
2801 /// array type to a pointer.
2802 ///
2803 /// This operation is non-trivial when handling typedefs etc. The canonical
2804 /// type of \p T must be an array type, this returns a pointer to a properly
2805 /// qualified element of the array.
2806 ///
2807 /// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
2809
2810 /// Return the type that \p PromotableType will promote to: C99
2811 /// 6.3.1.1p2, assuming that \p PromotableType is a promotable integer type.
2812 QualType getPromotedIntegerType(QualType PromotableType) const;
2813
2814 /// Recurses in pointer/array types until it finds an Objective-C
2815 /// retainable type and returns its ownership.
2817
2818 /// Whether this is a promotable bitfield reference according
2819 /// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
2820 ///
2821 /// \returns the type this bit-field will promote to, or NULL if no
2822 /// promotion occurs.
2824
2825 /// Return the highest ranked integer type, see C99 6.3.1.8p1.
2826 ///
2827 /// If \p LHS > \p RHS, returns 1. If \p LHS == \p RHS, returns 0. If
2828 /// \p LHS < \p RHS, return -1.
2829 int getIntegerTypeOrder(QualType LHS, QualType RHS) const;
2830
2831 /// Compare the rank of the two specified floating point types,
2832 /// ignoring the domain of the type (i.e. 'double' == '_Complex double').
2833 ///
2834 /// If \p LHS > \p RHS, returns 1. If \p LHS == \p RHS, returns 0. If
2835 /// \p LHS < \p RHS, return -1.
2836 int getFloatingTypeOrder(QualType LHS, QualType RHS) const;
2837
2838 /// Compare the rank of two floating point types as above, but compare equal
2839 /// if both types have the same floating-point semantics on the target (i.e.
2840 /// long double and double on AArch64 will return 0).
2842
2843 unsigned getTargetAddressSpace(LangAS AS) const;
2844
2845 LangAS getLangASForBuiltinAddressSpace(unsigned AS) const;
2846
2847 /// Get target-dependent integer value for null pointer which is used for
2848 /// constant folding.
2849 uint64_t getTargetNullPointerValue(QualType QT) const;
2850
2852 return AddrSpaceMapMangling || isTargetAddressSpace(AS);
2853 }
2854
2855 // Merges two exception specifications, such that the resulting
2856 // exception spec is the union of both. For example, if either
2857 // of them can throw something, the result can throw it as well.
2861 SmallVectorImpl<QualType> &ExceptionTypeStorage,
2862 bool AcceptDependent);
2863
2864 // For two "same" types, return a type which has
2865 // the common sugar between them. If Unqualified is true,
2866 // both types need only be the same unqualified type.
2867 // The result will drop the qualifiers which do not occur
2868 // in both types.
2870 bool Unqualified = false);
2871
2872private:
2873 // Helper for integer ordering
2874 unsigned getIntegerRank(const Type *T) const;
2875
2876public:
2877 //===--------------------------------------------------------------------===//
2878 // Type Compatibility Predicates
2879 //===--------------------------------------------------------------------===//
2880
2881 /// Compatibility predicates used to check assignment expressions.
2883 bool CompareUnqualified = false); // C99 6.2.7p1
2884
2887
2889 if (const auto *ET = dyn_cast<ElaboratedType>(T))
2890 T = ET->getNamedType();
2891 return T == getObjCIdType();
2892 }
2893
2895 if (const auto *ET = dyn_cast<ElaboratedType>(T))
2896 T = ET->getNamedType();
2897 return T == getObjCClassType();
2898 }
2899
2901 if (const auto *ET = dyn_cast<ElaboratedType>(T))
2902 T = ET->getNamedType();
2903 return T == getObjCSelType();
2904 }
2905
2907 const ObjCObjectPointerType *RHS,
2908 bool ForCompare);
2909
2911 const ObjCObjectPointerType *RHS);
2912
2913 // Check the safety of assignment from LHS to RHS
2915 const ObjCObjectPointerType *RHSOPT);
2917 const ObjCObjectType *RHS);
2919 const ObjCObjectPointerType *LHSOPT,
2920 const ObjCObjectPointerType *RHSOPT,
2921 bool BlockReturnType);
2924 const ObjCObjectPointerType *RHSOPT);
2926
2927 // Functions for calculating composite types
2928 QualType mergeTypes(QualType, QualType, bool OfBlockPointer = false,
2929 bool Unqualified = false, bool BlockReturnType = false,
2930 bool IsConditionalOperator = false);
2931 QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer = false,
2932 bool Unqualified = false, bool AllowCXX = false,
2933 bool IsConditionalOperator = false);
2935 bool OfBlockPointer = false,
2936 bool Unqualified = false);
2938 bool OfBlockPointer=false,
2939 bool Unqualified = false);
2940
2942
2943 /// This function merges the ExtParameterInfo lists of two functions. It
2944 /// returns true if the lists are compatible. The merged list is returned in
2945 /// NewParamInfos.
2946 ///
2947 /// \param FirstFnType The type of the first function.
2948 ///
2949 /// \param SecondFnType The type of the second function.
2950 ///
2951 /// \param CanUseFirst This flag is set to true if the first function's
2952 /// ExtParameterInfo list can be used as the composite list of
2953 /// ExtParameterInfo.
2954 ///
2955 /// \param CanUseSecond This flag is set to true if the second function's
2956 /// ExtParameterInfo list can be used as the composite list of
2957 /// ExtParameterInfo.
2958 ///
2959 /// \param NewParamInfos The composite list of ExtParameterInfo. The list is
2960 /// empty if none of the flags are set.
2961 ///
2963 const FunctionProtoType *FirstFnType,
2964 const FunctionProtoType *SecondFnType,
2965 bool &CanUseFirst, bool &CanUseSecond,
2967
2968 void ResetObjCLayout(const ObjCContainerDecl *CD);
2969
2970 //===--------------------------------------------------------------------===//
2971 // Integer Predicates
2972 //===--------------------------------------------------------------------===//
2973
2974 // The width of an integer, as defined in C99 6.2.6.2. This is the number
2975 // of bits in an integer type excluding any padding bits.
2976 unsigned getIntWidth(QualType T) const;
2977
2978 // Per C99 6.2.5p6, for every signed integer type, there is a corresponding
2979 // unsigned integer type. This method takes a signed type, and returns the
2980 // corresponding unsigned integer type.
2981 // With the introduction of fixed point types in ISO N1169, this method also
2982 // accepts fixed point types and returns the corresponding unsigned type for
2983 // a given fixed point type.
2985
2986 // Per C99 6.2.5p6, for every signed integer type, there is a corresponding
2987 // unsigned integer type. This method takes an unsigned type, and returns the
2988 // corresponding signed integer type.
2989 // With the introduction of fixed point types in ISO N1169, this method also
2990 // accepts fixed point types and returns the corresponding signed type for
2991 // a given fixed point type.
2993
2994 // Per ISO N1169, this method accepts fixed point types and returns the
2995 // corresponding saturated type for a given fixed point type.
2997
2998 // Per ISO N1169, this method accepts fixed point types and returns the
2999 // corresponding non-saturated type for a given fixed point type.
3001
3002 // This method accepts fixed point types and returns the corresponding signed
3003 // type. Unlike getCorrespondingUnsignedType(), this only accepts unsigned
3004 // fixed point types because there are unsigned integer types like bool and
3005 // char8_t that don't have signed equivalents.
3007
3008 //===--------------------------------------------------------------------===//
3009 // Integer Values
3010 //===--------------------------------------------------------------------===//
3011
3012 /// Make an APSInt of the appropriate width and signedness for the
3013 /// given \p Value and integer \p Type.
3014 llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const {
3015 // If Type is a signed integer type larger than 64 bits, we need to be sure
3016 // to sign extend Res appropriately.
3017 llvm::APSInt Res(64, !Type->isSignedIntegerOrEnumerationType());
3018 Res = Value;
3019 unsigned Width = getIntWidth(Type);
3020 if (Width != Res.getBitWidth())
3021 return Res.extOrTrunc(Width);
3022 return Res;
3023 }
3024
3025 bool isSentinelNullExpr(const Expr *E);
3026
3027 /// Get the implementation of the ObjCInterfaceDecl \p D, or nullptr if
3028 /// none exists.
3030
3031 /// Get the implementation of the ObjCCategoryDecl \p D, or nullptr if
3032 /// none exists.
3034
3035 /// Return true if there is at least one \@implementation in the TU.
3037 return !ObjCImpls.empty();
3038 }
3039
3040 /// Set the implementation of ObjCInterfaceDecl.
3042 ObjCImplementationDecl *ImplD);
3043
3044 /// Set the implementation of ObjCCategoryDecl.
3046 ObjCCategoryImplDecl *ImplD);
3047
3048 /// Get the duplicate declaration of a ObjCMethod in the same
3049 /// interface, or null if none exists.
3050 const ObjCMethodDecl *
3052
3054 const ObjCMethodDecl *Redecl);
3055
3056 /// Returns the Objective-C interface that \p ND belongs to if it is
3057 /// an Objective-C method/property/ivar etc. that is part of an interface,
3058 /// otherwise returns null.
3060
3061 /// Set the copy initialization expression of a block var decl. \p CanThrow
3062 /// indicates whether the copy expression can throw or not.
3063 void setBlockVarCopyInit(const VarDecl* VD, Expr *CopyExpr, bool CanThrow);
3064
3065 /// Get the copy initialization expression of the VarDecl \p VD, or
3066 /// nullptr if none exists.
3068
3069 /// Allocate an uninitialized TypeSourceInfo.
3070 ///
3071 /// The caller should initialize the memory held by TypeSourceInfo using
3072 /// the TypeLoc wrappers.
3073 ///
3074 /// \param T the type that will be the basis for type source info. This type
3075 /// should refer to how the declarator was written in source code, not to
3076 /// what type semantic analysis resolved the declarator to.
3077 ///
3078 /// \param Size the size of the type info to create, or 0 if the size
3079 /// should be calculated based on the type.
3080 TypeSourceInfo *CreateTypeSourceInfo(QualType T, unsigned Size = 0) const;
3081
3082 /// Allocate a TypeSourceInfo where all locations have been
3083 /// initialized to a given location, which defaults to the empty
3084 /// location.
3087 SourceLocation Loc = SourceLocation()) const;
3088
3089 /// Add a deallocation callback that will be invoked when the
3090 /// ASTContext is destroyed.
3091 ///
3092 /// \param Callback A callback function that will be invoked on destruction.
3093 ///
3094 /// \param Data Pointer data that will be provided to the callback function
3095 /// when it is called.
3096 void AddDeallocation(void (*Callback)(void *), void *Data) const;
3097
3098 /// If T isn't trivially destructible, calls AddDeallocation to register it
3099 /// for destruction.
3100 template <typename T> void addDestruction(T *Ptr) const {
3101 if (!std::is_trivially_destructible<T>::value) {
3102 auto DestroyPtr = [](void *V) { static_cast<T *>(V)->~T(); };
3103 AddDeallocation(DestroyPtr, Ptr);
3104 }
3105 }
3106
3109
3110 /// Determines if the decl can be CodeGen'ed or deserialized from PCH
3111 /// lazily, only when used; this is only relevant for function or file scoped
3112 /// var definitions.
3113 ///
3114 /// \returns true if the function/var must be CodeGen'ed/deserialized even if
3115 /// it is not used.
3116 bool DeclMustBeEmitted(const Decl *D);
3117
3118 /// Visits all versions of a multiversioned function with the passed
3119 /// predicate.
3121 const FunctionDecl *FD,
3122 llvm::function_ref<void(FunctionDecl *)> Pred) const;
3123
3124 const CXXConstructorDecl *
3126
3128 CXXConstructorDecl *CD);
3129
3131
3133
3135
3137
3138 void setManglingNumber(const NamedDecl *ND, unsigned Number);
3139 unsigned getManglingNumber(const NamedDecl *ND,
3140 bool ForAuxTarget = false) const;
3141
3142 void setStaticLocalNumber(const VarDecl *VD, unsigned Number);
3143 unsigned getStaticLocalNumber(const VarDecl *VD) const;
3144
3145 /// Retrieve the context for computing mangling numbers in the given
3146 /// DeclContext.
3150 const Decl *D);
3151
3152 std::unique_ptr<MangleNumberingContext> createMangleNumberingContext() const;
3153
3154 /// Used by ParmVarDecl to store on the side the
3155 /// index of the parameter when it exceeds the size of the normal bitfield.
3156 void setParameterIndex(const ParmVarDecl *D, unsigned index);
3157
3158 /// Used by ParmVarDecl to retrieve on the side the
3159 /// index of the parameter when it exceeds the size of the normal bitfield.
3160 unsigned getParameterIndex(const ParmVarDecl *D) const;
3161
3162 /// Return a string representing the human readable name for the specified
3163 /// function declaration or file name. Used by SourceLocExpr and
3164 /// PredefinedExpr to cache evaluated results.
3166
3167 /// Return a declaration for the global GUID object representing the given
3168 /// GUID value.
3170
3171 /// Return a declaration for a uniquified anonymous global constant
3172 /// corresponding to a given APValue.
3175
3176 /// Return the template parameter object of the given type with the given
3177 /// value.
3179 const APValue &V) const;
3180
3181 /// Parses the target attributes passed in, and returns only the ones that are
3182 /// valid feature names.
3183 ParsedTargetAttr filterFunctionTargetAttrs(const TargetAttr *TD) const;
3184
3185 std::vector<std::string>
3186 filterFunctionTargetVersionAttrs(const TargetVersionAttr *TV) const;
3187
3188 void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
3189 const FunctionDecl *) const;
3190 void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
3191 GlobalDecl GD) const;
3192
3193 //===--------------------------------------------------------------------===//
3194 // Statistics
3195 //===--------------------------------------------------------------------===//
3196
3197 /// The number of implicitly-declared default constructors.
3199
3200 /// The number of implicitly-declared default constructors for
3201 /// which declarations were built.
3203
3204 /// The number of implicitly-declared copy constructors.
3206
3207 /// The number of implicitly-declared copy constructors for
3208 /// which declarations were built.
3210
3211 /// The number of implicitly-declared move constructors.
3213
3214 /// The number of implicitly-declared move constructors for
3215 /// which declarations were built.
3217
3218 /// The number of implicitly-declared copy assignment operators.
3220
3221 /// The number of implicitly-declared copy assignment operators for
3222 /// which declarations were built.
3224
3225 /// The number of implicitly-declared move assignment operators.
3227
3228 /// The number of implicitly-declared move assignment operators for
3229 /// which declarations were built.
3231
3232 /// The number of implicitly-declared destructors.
3234
3235 /// The number of implicitly-declared destructors for which
3236 /// declarations were built.
3238
3239public:
3240 /// Initialize built-in types.
3241 ///
3242 /// This routine may only be invoked once for a given ASTContext object.
3243 /// It is normally invoked after ASTContext construction.
3244 ///
3245 /// \param Target The target
3247 const TargetInfo *AuxTarget = nullptr);
3248
3249private:
3250 void InitBuiltinType(CanQualType &R, BuiltinType::Kind K);
3251
3252 class ObjCEncOptions {
3253 unsigned Bits;
3254
3255 ObjCEncOptions(unsigned Bits) : Bits(Bits) {}
3256
3257 public:
3258 ObjCEncOptions() : Bits(0) {}
3259
3260#define OPT_LIST(V) \
3261 V(ExpandPointedToStructures, 0) \
3262 V(ExpandStructures, 1) \
3263 V(IsOutermostType, 2) \
3264 V(EncodingProperty, 3) \
3265 V(IsStructField, 4) \
3266 V(EncodeBlockParameters, 5) \
3267 V(EncodeClassNames, 6) \
3268
3269#define V(N,I) ObjCEncOptions& set##N() { Bits |= 1 << I; return *this; }
3270OPT_LIST(V)
3271#undef V
3272
3273#define V(N,I) bool N() const { return Bits & 1 << I; }
3274OPT_LIST(V)
3275#undef V
3276
3277#undef OPT_LIST
3278
3279 [[nodiscard]] ObjCEncOptions keepingOnly(ObjCEncOptions Mask) const {
3280 return Bits & Mask.Bits;
3281 }
3282
3283 [[nodiscard]] ObjCEncOptions forComponentType() const {
3284 ObjCEncOptions Mask = ObjCEncOptions()
3285 .setIsOutermostType()
3286 .setIsStructField();
3287 return Bits & ~Mask.Bits;
3288 }
3289 };
3290
3291 // Return the Objective-C type encoding for a given type.
3292 void getObjCEncodingForTypeImpl(QualType t, std::string &S,
3293 ObjCEncOptions Options,
3294 const FieldDecl *Field,
3295 QualType *NotEncodedT = nullptr) const;
3296
3297 // Adds the encoding of the structure's members.
3298 void getObjCEncodingForStructureImpl(RecordDecl *RD, std::string &S,
3299 const FieldDecl *Field,
3300 bool includeVBases = true,
3301 QualType *NotEncodedT=nullptr) const;
3302
3303public:
3304 // Adds the encoding of a method parameter or return type.
3306 QualType T, std::string& S,
3307 bool Extended) const;
3308
3309 /// Returns true if this is an inline-initialized static data member
3310 /// which is treated as a definition for MSVC compatibility.
3311 bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const;
3312
3314 /// Not an inline variable.
3315 None,
3316
3317 /// Weak definition of inline variable.
3318 Weak,
3319
3320 /// Weak for now, might become strong later in this TU.
3322
3323 /// Strong definition.
3324 Strong
3325 };
3326
3327 /// Determine whether a definition of this inline variable should
3328 /// be treated as a weak or strong definition. For compatibility with
3329 /// C++14 and before, for a constexpr static data member, if there is an
3330 /// out-of-line declaration of the member, we may promote it from weak to
3331 /// strong.
3334
3335private:
3337 friend class DeclContext;
3338
3339 const ASTRecordLayout &
3340 getObjCLayout(const ObjCInterfaceDecl *D,
3341 const ObjCImplementationDecl *Impl) const;
3342
3343 /// A set of deallocations that should be performed when the
3344 /// ASTContext is destroyed.
3345 // FIXME: We really should have a better mechanism in the ASTContext to
3346 // manage running destructors for types which do variable sized allocation
3347 // within the AST. In some places we thread the AST bump pointer allocator
3348 // into the datastructures which avoids this mess during deallocation but is
3349 // wasteful of memory, and here we require a lot of error prone book keeping
3350 // in order to track and run destructors while we're tearing things down.
3352 llvm::SmallVector<std::pair<void (*)(void *), void *>, 16>;
3353 mutable DeallocationFunctionsAndArguments Deallocations;
3354
3355 // FIXME: This currently contains the set of StoredDeclMaps used
3356 // by DeclContext objects. This probably should not be in ASTContext,
3357 // but we include it here so that ASTContext can quickly deallocate them.
3358 llvm::PointerIntPair<StoredDeclsMap *, 1> LastSDM;
3359
3360 std::vector<Decl *> TraversalScope;
3361
3362 std::unique_ptr<VTableContextBase> VTContext;
3363
3364 void ReleaseDeclContextMaps();
3365
3366public:
3367 enum PragmaSectionFlag : unsigned {
3374 PSF_Invalid = 0x80000000U,
3375 };
3376
3381
3382 SectionInfo() = default;
3384 int SectionFlags)
3387 };
3388
3389 llvm::StringMap<SectionInfo> SectionInfos;
3390
3391 /// Return a new OMPTraitInfo object owned by this context.
3393
3394 /// Whether a C++ static variable or CUDA/HIP kernel may be externalized.
3395 bool mayExternalize(const Decl *D) const;
3396
3397 /// Whether a C++ static variable or CUDA/HIP kernel should be externalized.
3398 bool shouldExternalize(const Decl *D) const;
3399
3400 StringRef getCUIDHash() const;
3401
3402private:
3403 /// All OMPTraitInfo objects live in this collection, one per
3404 /// `pragma omp [begin] declare variant` directive.
3405 SmallVector<std::unique_ptr<OMPTraitInfo>, 4> OMPTraitInfoVector;
3406};
3407
3408/// Insertion operator for diagnostics.
3410 const ASTContext::SectionInfo &Section);
3411
3412/// Utility function for constructing a nullary selector.
3413inline Selector GetNullarySelector(StringRef name, ASTContext &Ctx) {
3414 const IdentifierInfo *II = &Ctx.Idents.get(name);
3415 return Ctx.Selectors.getSelector(0, &II);
3416}
3417
3418/// Utility function for constructing an unary selector.
3419inline Selector GetUnarySelector(StringRef name, ASTContext &Ctx) {
3420 const IdentifierInfo *II = &Ctx.Idents.get(name);
3421 return Ctx.Selectors.getSelector(1, &II);
3422}
3423
3424} // namespace clang
3425
3426// operator new and delete aren't allowed inside namespaces.
3427
3428/// Placement new for using the ASTContext's allocator.
3429///
3430/// This placement form of operator new uses the ASTContext's allocator for
3431/// obtaining memory.
3432///
3433/// IMPORTANT: These are also declared in clang/AST/ASTContextAllocate.h!
3434/// Any changes here need to also be made there.
3435///
3436/// We intentionally avoid using a nothrow specification here so that the calls
3437/// to this operator will not perform a null check on the result -- the
3438/// underlying allocator never returns null pointers.
3439///
3440/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
3441/// @code
3442/// // Default alignment (8)
3443/// IntegerLiteral *Ex = new (Context) IntegerLiteral(arguments);
3444/// // Specific alignment
3445/// IntegerLiteral *Ex2 = new (Context, 4) IntegerLiteral(arguments);
3446/// @endcode
3447/// Memory allocated through this placement new operator does not need to be
3448/// explicitly freed, as ASTContext will free all of this memory when it gets
3449/// destroyed. Please note that you cannot use delete on the pointer.
3450///
3451/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
3452/// @param C The ASTContext that provides the allocator.
3453/// @param Alignment The alignment of the allocated memory (if the underlying
3454/// allocator supports it).
3455/// @return The allocated memory. Could be nullptr.
3456inline void *operator new(size_t Bytes, const clang::ASTContext &C,
3457 size_t Alignment /* = 8 */) {
3458 return C.Allocate(Bytes, Alignment);
3459}
3460
3461/// Placement delete companion to the new above.
3462///
3463/// This operator is just a companion to the new above. There is no way of
3464/// invoking it directly; see the new operator for more details. This operator
3465/// is called implicitly by the compiler if a placement new expression using
3466/// the ASTContext throws in the object constructor.
3467inline void operator delete(void *Ptr, const clang::ASTContext &C, size_t) {
3468 C.Deallocate(Ptr);
3469}
3470
3471/// This placement form of operator new[] uses the ASTContext's allocator for
3472/// obtaining memory.
3473///
3474/// We intentionally avoid using a nothrow specification here so that the calls
3475/// to this operator will not perform a null check on the result -- the
3476/// underlying allocator never returns null pointers.
3477///
3478/// Usage looks like this (assuming there's an ASTContext 'Context' in scope):
3479/// @code
3480/// // Default alignment (8)
3481/// char *data = new (Context) char[10];
3482/// // Specific alignment
3483/// char *data = new (Context, 4) char[10];
3484/// @endcode
3485/// Memory allocated through this placement new[] operator does not need to be
3486/// explicitly freed, as ASTContext will free all of this memory when it gets
3487/// destroyed. Please note that you cannot use delete on the pointer.
3488///
3489/// @param Bytes The number of bytes to allocate. Calculated by the compiler.
3490/// @param C The ASTContext that provides the allocator.
3491/// @param Alignment The alignment of the allocated memory (if the underlying
3492/// allocator supports it).
3493/// @return The allocated memory. Could be nullptr.
3494inline void *operator new[](size_t Bytes, const clang::ASTContext& C,
3495 size_t Alignment /* = 8 */) {
3496 return C.Allocate(Bytes, Alignment);
3497}
3498
3499/// Placement delete[] companion to the new[] above.
3500///
3501/// This operator is just a companion to the new[] above. There is no way of
3502/// invoking it directly; see the new[] operator for more details. This operator
3503/// is called implicitly by the compiler if a placement new[] expression using
3504/// the ASTContext throws in the object constructor.
3505inline void operator delete[](void *Ptr, const clang::ASTContext &C, size_t) {
3506 C.Deallocate(Ptr);
3507}
3508
3509/// Create the representation of a LazyGenerationalUpdatePtr.
3510template <typename Owner, typename T,
3511 void (clang::ExternalASTSource::*Update)(Owner)>
3514 const clang::ASTContext &Ctx, T Value) {
3515 // Note, this is implemented here so that ExternalASTSource.h doesn't need to
3516 // include ASTContext.h. We explicitly instantiate it for all relevant types
3517 // in ASTContext.cpp.
3518 if (auto *Source = Ctx.getExternalSource())
3519 return new (Ctx) LazyData(Source, Value);
3520 return Value;
3521}
3522
3523#endif // LLVM_CLANG_AST_ASTCONTEXT_H
#define OPT_LIST(V)
Definition: ASTContext.h:3260
#define V(N, I)
Definition: ASTContext.h:3273
Forward declaration of all AST node types.
DynTypedNode Node
static char ID
Definition: Arena.cpp:183
#define SM(sm)
Definition: Cuda.cpp:82
static bool CanThrow(Expr *E, ASTContext &Ctx)
Definition: CFG.cpp:2679
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
Definition: CharUnits.h:225
static CGCXXABI * createCXXABI(CodeGenModule &CGM)
#define X(type, name)
Definition: Value.h:143
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
llvm::MachO::Target Target
Definition: MachO.h:47
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
Defines the clang::SourceLocation class and associated facilities.
#define CXXABI(Name, Str)
Definition: TargetCXXABI.h:32
SourceLocation Begin
__device__ int
__SIZE_TYPE__ size_t
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
bool getByrefLifetime(QualType Ty, Qualifiers::ObjCLifetime &Lifetime, bool &HasByrefExtendedLayout) const
Returns true, if given type has a known lifetime.
MSGuidDecl * getMSGuidDecl(MSGuidDeclParts Parts) const
Return a declaration for the global GUID object representing the given GUID value.
QualType getUsingType(const UsingShadowDecl *Found, QualType Underlying) const
CanQualType AccumTy
Definition: ASTContext.h:1104
BuiltinVectorTypeInfo getBuiltinVectorTypeInfo(const BuiltinType *VecTy) const
Returns the element type, element count and number of vectors (in case of tuple) for a builtin vector...
bool ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl, const ObjCMethodDecl *MethodImp)
CanQualType ObjCBuiltinSelTy
Definition: ASTContext.h:1122
SourceManager & getSourceManager()
Definition: ASTContext.h:705
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1073
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2756
CanQualType getCanonicalFunctionResultType(QualType ResultType) const
Adjust the given function result type.
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
bool areLaxCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible SVE vector types, false otherwise.
llvm::PointerUnion< VarTemplateDecl *, MemberSpecializationInfo * > TemplateOrSpecializationInfo
A type synonym for the TemplateOrInstantiation mapping.
Definition: ASTContext.h:476
LangAS getOpenCLTypeAddrSpace(const Type *T) const
Get address space for OpenCL type.
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
void InitBuiltinTypes(const TargetInfo &Target, const TargetInfo *AuxTarget=nullptr)
Initialize built-in types.
ParentMapContext & getParentMapContext()
Returns the dynamic AST node parent map context.
Definition: ASTContext.cpp:851
QualType getParenType(QualType NamedType) const
size_t getSideTableAllocatedMemory() const
Return the total memory used for various side tables.
MemberSpecializationInfo * getInstantiatedFromStaticDataMember(const VarDecl *Var)
If this variable is an instantiated static data member of a class template specialization,...
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type.
CanQualType ARCUnbridgedCastTy
Definition: ASTContext.h:1121
uint64_t getTypeSize(const Type *T) const
Definition: ASTContext.h:2330
QualType getDependentSizedMatrixType(QualType ElementType, Expr *RowExpr, Expr *ColumnExpr, SourceLocation AttrLoc) const
Return the unique reference to the matrix type of the specified element type and size.
llvm::DenseMap< const Decl *, comments::FullComment * > ParsedComments
Mapping from declarations to parsed comments attached to any redeclaration.
Definition: ASTContext.h:834
unsigned getManglingNumber(const NamedDecl *ND, bool ForAuxTarget=false) const
CanQualType LongTy
Definition: ASTContext.h:1100
void UnwrapSimilarArrayTypes(QualType &T1, QualType &T2, bool AllowPiMismatch=true)
Attempt to unwrap two types that may both be array types with the same bound (or both be array types ...
const SmallVectorImpl< Type * > & getTypes() const
Definition: ASTContext.h:1205
unsigned getIntWidth(QualType T) const
CanQualType getCanonicalParamType(QualType T) const
Return the canonical parameter type corresponding to the specific potentially non-canonical one.
QualType getBTFTagAttributedType(const BTFTypeTagAttr *BTFAttr, QualType Wrapped)
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
TemplateOrSpecializationInfo getTemplateOrSpecializationInfo(const VarDecl *Var)
CanQualType WIntTy
Definition: ASTContext.h:1096
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType) const
@ Weak
Weak definition of inline variable.
@ WeakUnknown
Weak for now, might become strong later in this TU.
const ProfileList & getProfileList() const
Definition: ASTContext.h:791
void setObjCConstantStringInterface(ObjCInterfaceDecl *Decl)
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C 'Class' type.
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
TypedefDecl * getCFConstantStringDecl() const
CanQualType Int128Ty
Definition: ASTContext.h:1100
CanQualType SatUnsignedFractTy
Definition: ASTContext.h:1113
CanQualType getAdjustedType(CanQualType Orig, CanQualType New) const
Definition: ASTContext.h:1357
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template.
bool areCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an RISC-V vector builtin type and a VectorType that is a fixed-len...
ExternCContextDecl * getExternCContextDecl() const
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat 'semantics' for the specified scalar floating point type.
ParsedTargetAttr filterFunctionTargetAttrs(const TargetAttr *TD) const
Parses the target attributes passed in, and returns only the ones that are valid feature names.
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, ConceptDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined 'SEL' type in Objective-C.
llvm::iterator_range< import_iterator > import_range
Definition: ASTContext.h:1029
bool AnyObjCImplementation()
Return true if there is at least one @implementation in the TU.
Definition: ASTContext.h:3036
CanQualType UnsignedShortAccumTy
Definition: ASTContext.h:1106
TypedefDecl * getObjCInstanceTypeDecl()
Retrieve the typedef declaration corresponding to the Objective-C "instancetype" type.
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
void DeallocateDeclListNode(DeclListNode *N)
Deallcates a DeclListNode by returning it to the ListNodeFreeList pool.
Definition: ASTContext.h:739
DeclListNode * AllocateDeclListNode(clang::NamedDecl *ND)
Allocates a DeclListNode or returns one from the ListNodeFreeList pool.
Definition: ASTContext.h:728
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, ArrayRef< TemplateArgumentLoc > Args) const
void setTemplateOrSpecializationInfo(VarDecl *Inst, TemplateOrSpecializationInfo TSI)
bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, ObjCProtocolDecl *rProto) const
ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the inheritance hierarchy of 'rProto...
bool hasSimilarType(QualType T1, QualType T2)
Determine if two types are similar, according to the C++ rules.
TypedefDecl * buildImplicitTypedef(QualType T, StringRef Name) const
Create a new implicit TU-level typedef declaration.
unsigned getTypeAlign(const Type *T) const
Definition: ASTContext.h:2361
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl.
void adjustObjCTypeParamBoundType(const ObjCTypeParamDecl *Orig, ObjCTypeParamDecl *New) const
llvm::StringMap< SectionInfo > SectionInfos
Definition: ASTContext.h:3389
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
QualType getAutoRRefDeductType() const
C++11 deduction pattern for 'auto &&' type.
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type.
bool ObjCQualifiedIdTypesAreCompatible(const ObjCObjectPointerType *LHS, const ObjCObjectPointerType *RHS, bool ForCompare)
ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an ObjCQualifiedIDType.
void addLazyModuleInitializers(Module *M, ArrayRef< uint32_t > IDs)
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
Definition: ASTContext.h:2117
QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool AllowCXX=false, bool IsConditionalOperator=false)
NamedDecl * getInstantiatedFromUsingDecl(NamedDecl *Inst)
If the given using decl Inst is an instantiation of another (possibly unresolved) using decl,...
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:648
comments::FullComment * cloneFullComment(comments::FullComment *FC, const Decl *D) const
Definition: ASTContext.cpp:558
TemplateName getCanonicalTemplateName(const TemplateName &Name) const
Retrieves the "canonical" template name that refers to a given template.
QualType getUnresolvedUsingType(const UnresolvedUsingTypenameDecl *Decl) const
CharUnits getObjCEncodingTypeSize(QualType T) const
Return the size of type T for Objective-C encoding purpose, in characters.
int getIntegerTypeOrder(QualType LHS, QualType RHS) const
Return the highest ranked integer type, see C99 6.3.1.8p1.
QualType getObjCClassType() const
Represents the Objective-C Class type.
Definition: ASTContext.h:2084
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
void setCurrentNamedModule(Module *M)
Set the (C++20) module we are building.
QualType getRawCFConstantStringType() const
Get the structure type used to representation CFStrings, or NULL if it hasn't yet been built.
Definition: ASTContext.h:1838
QualType getProcessIDType() const
Return the unique type for "pid_t" defined in <sys/types.h>.
CharUnits getMemberPointerPathAdjustment(const APValue &MP) const
Find the 'this' offset for the member path in a pointer-to-member APValue.
bool mayExternalize(const Decl *D) const
Whether a C++ static variable or CUDA/HIP kernel may be externalized.
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
std::unique_ptr< MangleNumberingContext > createMangleNumberingContext() const
CanQualType SatAccumTy
Definition: ASTContext.h:1109
QualType getUnsignedPointerDiffType() const
Return the unique unsigned counterpart of "ptrdiff_t" integer type.
QualType getucontext_tType() const
Retrieve the C ucontext_t type.
Definition: ASTContext.h:1991
QualType getRecordType(const RecordDecl *Decl) const
std::optional< CharUnits > getTypeSizeInCharsIfKnown(const Type *Ty) const
Definition: ASTContext.h:2354
QualType getScalableVectorType(QualType EltTy, unsigned NumElts, unsigned NumFields=1) const
Return the unique reference to a scalable vector type of the specified element type and scalable numb...
bool hasSameExpr(const Expr *X, const Expr *Y) const
Determine whether the given expressions X and Y are equivalent.
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
QualType getBuiltinMSVaListType() const
Retrieve the type of the __builtin_ms_va_list type.
Definition: ASTContext.h:2131
MangleContext * createMangleContext(const TargetInfo *T=nullptr)
If T is null pointer, assume the target in ASTContext.
QualType getRealTypeForBitwidth(unsigned DestWidth, FloatModeKind ExplicitType) const
getRealTypeForBitwidth - sets floating point QualTy according to specified bitwidth.
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
CanQualType ShortAccumTy
Definition: ASTContext.h:1104
ASTMutationListener * getASTMutationListener() const
Retrieve a pointer to the AST mutation listener associated with this AST context, if any.
Definition: ASTContext.h:1202
unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built.
Definition: ASTContext.h:3223
uint64_t getTargetNullPointerValue(QualType QT) const
Get target-dependent integer value for null pointer which is used for constant folding.
unsigned getTypeUnadjustedAlign(QualType T) const
Return the ABI-specified natural alignment of a (complete) type T, before alignment adjustments,...
Definition: ASTContext.h:2368
unsigned char getFixedPointIBits(QualType Ty) const
QualType getCorrespondingSignedFixedPointType(QualType Ty) const
IntrusiveRefCntPtr< ExternalASTSource > ExternalSource
Definition: ASTContext.h:649
CanQualType FloatTy
Definition: ASTContext.h:1103
QualType getArrayParameterType(QualType Ty) const
Return the uniqued reference to a specified array parameter type from the original array type.
QualType getCountAttributedType(QualType T, Expr *CountExpr, bool CountInBytes, bool OrNull, ArrayRef< TypeCoupledDeclRefInfo > DependentDecls) const
void setObjCIdRedefinitionType(QualType RedefType)
Set the user-written type that redefines id.
Definition: ASTContext.h:1870
bool isObjCIdType(QualType T) const
Definition: ASTContext.h:2888
QualType getPackExpansionType(QualType Pattern, std::optional< unsigned > NumExpansions, bool ExpectPackInType=true)
Form a pack expansion type with the given pattern.
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
DynTypedNodeList getParents(const NodeT &Node)
Forwards to get node parents from the ParentMapContext.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2563
unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
Definition: ASTContext.h:3237
bool isObjCClassType(QualType T) const
Definition: ASTContext.h:2894
void setObjCNSStringType(QualType T)
Definition: ASTContext.h:1857
bool mergeExtParameterInfo(const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType, bool &CanUseFirst, bool &CanUseSecond, SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &NewParamInfos)
This function merges the ExtParameterInfo lists of two functions.
bool ObjCQualifiedClassTypesAreCompatible(const ObjCObjectPointerType *LHS, const ObjCObjectPointerType *RHS)
ObjCQualifiedClassTypesAreCompatible - compare Class<pr,...> and Class<pr1, ...>.
bool shouldExternalize(const Decl *D) const
Whether a C++ static variable or CUDA/HIP kernel should be externalized.
FullSourceLoc getFullLoc(SourceLocation Loc) const
Definition: ASTContext.h:795
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2579
bool propertyTypesAreCompatible(QualType, QualType)
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
CanQualType DoubleTy
Definition: ASTContext.h:1103
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateName Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc, VectorKind VecKind) const
Return the unique reference to the type for a dependently sized vector of the specified element type.
comments::CommandTraits & getCommentCommandTraits() const
Definition: ASTContext.h:936
CanQualType SatLongAccumTy
Definition: ASTContext.h:1109
const XRayFunctionFilter & getXRayFilter() const
Definition: ASTContext.h:787
CanQualType getIntMaxType() const
Return the unique type for "intmax_t" (C99 7.18.1.5), defined in <stdint.h>.
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
std::vector< std::string > filterFunctionTargetVersionAttrs(const TargetVersionAttr *TV) const
OpenCLTypeKind getOpenCLTypeKind(const Type *T) const
Map an AST Type to an OpenCLTypeKind enum value.
QualType getFILEType() const
Retrieve the C FILE type.
Definition: ASTContext.h:1955
ArrayRef< Decl * > getModuleInitializers(Module *M)
Get the initializations to perform when importing a module, if any.
void getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, std::string &S) const
Put the string version of the type qualifiers QT into S.
unsigned getPreferredTypeAlign(QualType T) const
Return the "preferred" alignment of the specified type T for the current target, in bits.
Definition: ASTContext.h:2420
void getInjectedTemplateArgs(const TemplateParameterList *Params, SmallVectorImpl< TemplateArgument > &Args)
Get a template argument list with one argument per template parameter in a template parameter list,...
void setsigjmp_bufDecl(TypeDecl *sigjmp_bufDecl)
Set the type for the C sigjmp_buf type.
Definition: ASTContext.h:1974
std::string getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, bool Extended=false) const
Emit the encoded type for the method declaration Decl into S.
void DumpRecordLayout(const RecordDecl *RD, raw_ostream &OS, bool Simple=false) const
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
CanQualType LongDoubleTy
Definition: ASTContext.h:1103
CanQualType OMPArrayShapingTy
Definition: ASTContext.h:1130
ASTContext(LangOptions &LOpts, SourceManager &SM, IdentifierTable &idents, SelectorTable &sels, Builtin::Context &builtins, TranslationUnitKind TUKind)
Definition: ASTContext.cpp:870
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
std::string getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, const Decl *Container) const
getObjCEncodingForPropertyDecl - Return the encoded type for this method declaration.
CanQualType Char16Ty
Definition: ASTContext.h:1098
unsigned getStaticLocalNumber(const VarDecl *VD) const
QualType getObjCSelRedefinitionType() const
Retrieve the type that 'SEL' has been defined to, which may be different from the built-in 'SEL' if '...
Definition: ASTContext.h:1889
void addComment(const RawComment &RC)
Definition: ASTContext.cpp:326
void getLegacyIntegralTypeEncoding(QualType &t) const
getLegacyIntegralTypeEncoding - Another legacy compatibility encoding: 32-bit longs are encoded as 'l...
bool isSameTypeConstraint(const TypeConstraint *XTC, const TypeConstraint *YTC) const
Determine whether two type contraint are similar enough that they could used in declarations of the s...
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod, bool IsBuiltin=false) const
Retrieves the default calling convention for the current target.
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=RecordDecl::TagKind::Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
void setObjCSelRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
Definition: ASTContext.h:1896
void setFILEDecl(TypeDecl *FILEDecl)
Set the type for the C FILE type.
Definition: ASTContext.h:1952
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2762
QualType getMSGuidType() const
Retrieve the implicitly-predeclared 'struct _GUID' type.
Definition: ASTContext.h:2139
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn't on...
const ASTRecordLayout & getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const
Get or compute information about the layout of the specified Objective-C implementation.
CanQualType UnsignedLongFractTy
Definition: ASTContext.h:1108
QualType getEnumType(const EnumDecl *Decl) const
overridden_method_range overridden_methods(const CXXMethodDecl *Method) const
QualType getDependentBitIntType(bool Unsigned, Expr *BitsExpr) const
Return a dependent bit-precise integer type with the specified signedness and bit count.
void setObjCImplementation(ObjCInterfaceDecl *IFaceD, ObjCImplementationDecl *ImplD)
Set the implementation of ObjCInterfaceDecl.
StringRef getCUIDHash() const
bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const
Returns true if this is an inline-initialized static data member which is treated as a definition for...
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
CanQualType VoidPtrTy
Definition: ASTContext.h:1118
QualType getReferenceQualifiedType(const Expr *e) const
getReferenceQualifiedType - Given an expr, will return the type for that expression,...
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U) const
Determine whether two function types are the same, ignoring exception specifications in cases where t...
bool isObjCSelType(QualType T) const
Definition: ASTContext.h:2900
QualType getBlockDescriptorExtendedType() const
Gets the struct used to keep track of the extended descriptor for pointer to blocks.
void Deallocate(void *Ptr) const
Definition: ASTContext.h:724
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type.
CanQualType DependentTy
Definition: ASTContext.h:1119
IdentifierInfo * getMakeIntegerSeqName() const
Definition: ASTContext.h:1929
bool QIdProtocolsAdoptObjCObjectProtocols(QualType QT, ObjCInterfaceDecl *IDecl)
QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in QT's qualified-id protocol list adopt...
bool isSameConstraintExpr(const Expr *XCE, const Expr *YCE) const
Determine whether two 'requires' expressions are similar enough that they may be used in re-declarati...
IdentifierInfo * getTypePackElementName() const
Definition: ASTContext.h:1935
bool BlockRequiresCopying(QualType Ty, const VarDecl *D)
Returns true iff we need copy/dispose helpers for the given type.
CanQualType NullPtrTy
Definition: ASTContext.h:1118
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1589
CanQualType WideCharTy
Definition: ASTContext.h:1095
CanQualType OMPIteratorTy
Definition: ASTContext.h:1130
IdentifierTable & Idents
Definition: ASTContext.h:644
std::vector< Decl * > getTraversalScope() const
Definition: ASTContext.h:690
TemplateName getSubstTemplateTemplateParm(TemplateName replacement, Decl *AssociatedDecl, unsigned Index, std::optional< unsigned > PackIndex) const
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:646
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
const LangOptions & getLangOpts() const
Definition: ASTContext.h:775
QualType getConstType(QualType T) const
Return the uniqued reference to the type for a const qualified type.
Definition: ASTContext.h:1297
TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl)
QualType getFunctionTypeWithoutPtrSizes(QualType T)
Get a function type and produce the equivalent function type where pointer size address spaces in the...
llvm::iterator_range< overridden_cxx_method_iterator > overridden_method_range
Definition: ASTContext.h:1001
SelectorTable & Selectors
Definition: ASTContext.h:645
unsigned getMinGlobalAlignOfVar(uint64_t Size, const VarDecl *VD) const
Return the minimum alignement as specified by the target.
RawCommentList Comments
All comments in this translation unit.
Definition: ASTContext.h:805
bool isSameDefaultTemplateArgument(const NamedDecl *X, const NamedDecl *Y) const
Determine whether two default template arguments are similar enough that they may be used in declarat...
QualType applyObjCProtocolQualifiers(QualType type, ArrayRef< ObjCProtocolDecl * > protocols, bool &hasError, bool allowOnPointerType=false) const
Apply Objective-C protocol qualifiers to the given type.
QualType getMacroQualifiedType(QualType UnderlyingTy, const IdentifierInfo *MacroII) const
QualType removePtrSizeAddrSpace(QualType T) const
Remove the existing address space on the type if it is a pointer size address space and return the ty...
bool areLaxCompatibleRVVTypes(QualType FirstType, QualType SecondType)
Return true if the given vector types are lax-compatible RISC-V vector types as defined by -flax-vect...
void setObjCSuperType(QualType ST)
Definition: ASTContext.h:1834
TypedefDecl * getBOOLDecl() const
Retrieve declaration of 'BOOL' typedef.
Definition: ASTContext.h:2093
CanQualType SatShortFractTy
Definition: ASTContext.h:1112
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
bool canBindObjCObjectType(QualType To, QualType From)
int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const
Compare the rank of two floating point types as above, but compare equal if both types have the same ...
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
void setParameterIndex(const ParmVarDecl *D, unsigned index)
Used by ParmVarDecl to store on the side the index of the parameter when it exceeds the size of the n...
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) const
Get a function type and produce the equivalent function type with the specified exception specificati...
bool hasSameType(const Type *T1, const Type *T2) const
Definition: ASTContext.h:2582
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;.
Definition: ASTContext.h:1943
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const
Return one of the GCNone, Weak or Strong Objective-C garbage collection attributes.
PartialDiagnostic::DiagStorageAllocator & getDiagAllocator()
Definition: ASTContext.h:753
CanQualType Ibm128Ty
Definition: ASTContext.h:1103
void setASTMutationListener(ASTMutationListener *Listener)
Attach an AST mutation listener to the AST context.
Definition: ASTContext.h:1196
bool hasUniqueObjectRepresentations(QualType Ty, bool CheckIfTriviallyCopyable=true) const
Return true if the specified type has unique object representations according to (C++17 [meta....
bool typesAreBlockPointerCompatible(QualType, QualType)
CanQualType SatUnsignedAccumTy
Definition: ASTContext.h:1110
const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const
Get or compute information about the layout of the specified Objective-C interface.
QualType getObjCProtoType() const
Retrieve the type of the Objective-C Protocol class.
Definition: ASTContext.h:2108
void forEachMultiversionedFunctionVersion(const FunctionDecl *FD, llvm::function_ref< void(FunctionDecl *)> Pred) const
Visits all versions of a multiversioned function with the passed predicate.
void setInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst, UsingEnumDecl *Pattern)
Remember that the using enum decl Inst is an instantiation of the using enum decl Pattern of a class ...
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
Decl * getPrimaryMergedDecl(Decl *D)
Definition: ASTContext.h:1035
QualType getSignatureParameterType(QualType T) const
Retrieve the parameter type as adjusted for use in the signature of a function, decaying array and fu...
QualType getCanonicalTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args) const
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:1122
overridden_cxx_method_iterator overridden_methods_end(const CXXMethodDecl *Method) const
VTableContextBase * getVTableContext()
void setBOOLDecl(TypedefDecl *TD)
Save declaration of 'BOOL' typedef.
Definition: ASTContext.h:2098
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>,...
Definition: ASTContext.h:2260
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i....
unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const
ASTContext(const ASTContext &)=delete
ObjCPropertyImplDecl * getObjCPropertyImplDeclForPropertyDecl(const ObjCPropertyDecl *PD, const Decl *Container) const
bool isNearlyEmpty(const CXXRecordDecl *RD) const
QualType AutoDeductTy
Definition: ASTContext.h:1147
CanQualType BoolTy
Definition: ASTContext.h:1092
void cacheRawCommentForDecl(const Decl &OriginalD, const RawComment &Comment) const
Attaches Comment to OriginalD and to its redeclaration chain and removes the redeclaration chain from...
Definition: ASTContext.cpp:470
void attachCommentsToJustParsedDecls(ArrayRef< Decl * > Decls, const Preprocessor *PP)
Searches existing comments for doc comments that should be attached to Decls.
Definition: ASTContext.cpp:496
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth,...
llvm::BumpPtrAllocator & getAllocator() const
Definition: ASTContext.h:714
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
QualType getCFConstantStringType() const
Return the C structure type used to represent constant CFStrings.
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field)
void eraseDeclAttrs(const Decl *D)
Erase the attributes corresponding to the given declaration.
const NoSanitizeList & getNoSanitizeList() const
Definition: ASTContext.h:785
struct clang::ASTContext::CUDAConstantEvalContext CUDAConstantEvalCtx
IdentifierInfo * getNSObjectName() const
Retrieve the identifier 'NSObject'.
Definition: ASTContext.h:1901
UsingEnumDecl * getInstantiatedFromUsingEnumDecl(UsingEnumDecl *Inst)
If the given using-enum decl Inst is an instantiation of another using-enum decl, return it.
RecordDecl * getCFConstantStringTagDecl() const
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
Definition: ASTContext.h:2072
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
std::string getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const
Emit the encoded type for the function Decl into S.
QualType getTemplateTypeParmType(unsigned Depth, unsigned Index, bool ParameterPack, TemplateTypeParmDecl *ParmDecl=nullptr) const
Retrieve the template type parameter type for a template parameter or parameter pack with the given d...
bool addressSpaceMapManglingFor(LangAS AS) const
Definition: ASTContext.h:2851
CanQualType UnsignedFractTy
Definition: ASTContext.h:1108
QualType getjmp_bufType() const
Retrieve the C jmp_buf type.
Definition: ASTContext.h:1967
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
QualType mergeFunctionParameterTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false)
mergeFunctionParameterTypes - merge two types which appear as function parameter types
QualType getsigjmp_bufType() const
Retrieve the C sigjmp_buf type.
Definition: ASTContext.h:1979
void addOverriddenMethod(const CXXMethodDecl *Method, const CXXMethodDecl *Overridden)
Note that the given C++ Method overrides the given Overridden method.
const TargetInfo * getAuxTargetInfo() const
Definition: ASTContext.h:758
CanQualType Float128Ty
Definition: ASTContext.h:1103
CanQualType ObjCBuiltinClassTy
Definition: ASTContext.h:1122
unsigned NumImplicitDefaultConstructorsDeclared
The number of implicitly-declared default constructors for which declarations were built.
Definition: ASTContext.h:3202
void setucontext_tDecl(TypeDecl *ucontext_tDecl)
Set the type for the C ucontext_t type.
Definition: ASTContext.h:1986
OMPTraitInfo & getNewOMPTraitInfo()
Return a new OMPTraitInfo object owned by this context.
CanQualType UnsignedLongTy
Definition: ASTContext.h:1101
bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y) const
Determine whether the given template names refer to the same template.
llvm::DenseSet< const FunctionDecl * > CUDAImplicitHostDeviceFunUsedByDevice
Keep track of CUDA/HIP implicit host device functions used on device side in device compilation.
Definition: ASTContext.h:1169
void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass, SmallVectorImpl< const ObjCIvarDecl * > &Ivars) const
DeepCollectObjCIvars - This routine first collects all declared, but not synthesized,...
llvm::APFixedPoint getFixedPointMin(QualType Ty) const
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location,...
void addedLocalImportDecl(ImportDecl *Import)
Notify the AST context that a new import declaration has been parsed or implicitly created within thi...
const TranslationUnitKind TUKind
Definition: ASTContext.h:647
QualType getQualifiedType(const Type *T, Qualifiers Qs) const
Return a type with additional qualifiers.
Definition: ASTContext.h:2169
CanQualType UnsignedLongAccumTy
Definition: ASTContext.h:1106
QualType AutoRRefDeductTy
Definition: ASTContext.h:1148
QualType getRestrictType(QualType T) const
Return the uniqued reference to the type for a restrict qualified type.
Definition: ASTContext.h:1277
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
CanQualType ShortFractTy
Definition: ASTContext.h:1107
QualType getStringLiteralArrayType(QualType EltTy, unsigned Length) const
Return a type for a constant array for a string literal of the specified element type and length.
QualType getCorrespondingSaturatedType(QualType Ty) const
bool isSameEntity(const NamedDecl *X, const NamedDecl *Y) const
Determine whether the two declarations refer to the same entity.
QualType getBOOLType() const
type of 'BOOL' type.
Definition: ASTContext.h:2103
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
QualType getSubstTemplateTypeParmPackType(Decl *AssociatedDecl, unsigned Index, bool Final, const TemplateArgument &ArgPack)
Retrieve a.
CanQualType BoundMemberTy
Definition: ASTContext.h:1119
CanQualType SatUnsignedShortFractTy
Definition: ASTContext.h:1113
CanQualType CharTy
Definition: ASTContext.h:1093
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
unsigned getOpenMPDefaultSimdAlign(QualType T) const
Get default simd alignment of the specified complete type in bits.
QualType getObjCSuperType() const
Returns the C struct type for objc_super.
QualType getBlockDescriptorType() const
Gets the struct used to keep track of the descriptor for pointer to blocks.
bool CommentsLoaded
True if comments are already loaded from ExternalASTSource.
Definition: ASTContext.h:808
BlockVarCopyInit getBlockVarCopyInit(const VarDecl *VD) const
Get the copy initialization expression of the VarDecl VD, or nullptr if none exists.
unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
Definition: ASTContext.h:3216
unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
Definition: ASTContext.h:3209
CanQualType IntTy
Definition: ASTContext.h:1100
llvm::DenseSet< const VarDecl * > CUDADeviceVarODRUsedByHost
Keep track of CUDA/HIP device-side variables ODR-used by host code.
Definition: ASTContext.h:1161
CanQualType PseudoObjectTy
Definition: ASTContext.h:1121
QualType getWebAssemblyExternrefType() const
Return a WebAssembly externref type.
void setTraversalScope(const std::vector< Decl * > &)
Definition: ASTContext.cpp:937
CharUnits getTypeUnadjustedAlignInChars(QualType T) const
getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a type, in characters,...
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
CanQualType getComplexType(CanQualType T) const
Definition: ASTContext.h:1338
friend class NestedNameSpecifier
Definition: ASTContext.h:183
void PrintStats() const
Definition: ASTContext.cpp:951
unsigned getAlignOfGlobalVar(QualType T, const VarDecl *VD) const
Return the alignment in bits that should be given to a global variable with type T.
TypeInfoChars getTypeInfoDataSizeInChars(QualType T) const
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
comments::FullComment * getLocalCommentForDeclUncached(const Decl *D) const
Return parsed documentation comment attached to a given declaration.
Definition: ASTContext.cpp:573
unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
Definition: ASTContext.h:3233
CanQualType Float16Ty
Definition: ASTContext.h:1117
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:2155
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
bool isAlignmentRequired(const Type *T) const
Determine if the alignment the type has was required using an alignment attribute.
TagDecl * MSGuidTagDecl
Definition: ASTContext.h:1155
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS)
MangleContext * createDeviceMangleContext(const TargetInfo &T)
Creates a device mangle context to correctly mangle lambdas in a mixed architecture compile by settin...
CharUnits getExnObjectAlignment() const
Return the alignment (in bytes) of the thrown exception object.
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals.
CanQualType SignedCharTy
Definition: ASTContext.h:1100
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
ASTMutationListener * Listener
Definition: ASTContext.h:650
void setNonKeyFunction(const CXXMethodDecl *method)
Observe that the given method cannot be a key function.
CanQualType ObjCBuiltinBoolTy
Definition: ASTContext.h:1123
TypeInfoChars getTypeInfoInChars(const Type *T) const
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
LangAS getDefaultOpenCLPointeeAddrSpace()
Returns default address space based on OpenCL version and enabled features.
Definition: ASTContext.h:1414
TemplateParamObjectDecl * getTemplateParamObjectDecl(QualType T, const APValue &V) const
Return the template parameter object of the given type with the given value.
const SourceManager & getSourceManager() const
Definition: ASTContext.h:706
CanQualType OverloadTy
Definition: ASTContext.h:1119
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
CanQualType OCLClkEventTy
Definition: ASTContext.h:1127
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated,...
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
CharUnits getPreferredTypeAlignInChars(QualType T) const
Return the PreferredAlignment of a (complete) type T, in characters.
Definition: ASTContext.h:2388
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:697
ArrayRef< Module * > getModulesWithMergedDefinition(const NamedDecl *Def)
Get the additional modules in which the definition Def has been merged.
static ImportDecl * getNextLocalImport(ImportDecl *Import)
Definition: ASTContext.h:1025
llvm::FixedPointSemantics getFixedPointSemantics(QualType Ty) const
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID, const ObjCImplementationDecl *ID, const ObjCIvarDecl *Ivar) const
Get the offset of an ObjCIvarDecl in bits.
CanQualType SatUnsignedShortAccumTy
Definition: ASTContext.h:1110
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false, bool IsConditionalOperator=false)
const RawComment * getRawCommentForAnyRedecl(const Decl *D, const Decl **OriginalDecl=nullptr) const
Return the documentation comment attached to a given declaration.
Definition: ASTContext.cpp:402
CharUnits getAlignOfGlobalVarInChars(QualType T, const VarDecl *VD) const
Return the alignment in characters that should be given to a global variable with type T.
const ObjCMethodDecl * getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const
Get the duplicate declaration of a ObjCMethod in the same interface, or null if none exists.
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
Definition: ASTContext.h:2309
GVALinkage GetGVALinkageForVariable(const VarDecl *VD) const
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
QualType getWCharType() const
Return the unique wchar_t type available in C++ (and available as __wchar_t as a Microsoft extension)...
Definition: ASTContext.h:1787
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:2062
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
QualType getUnsignedWCharType() const
Return the type of "unsigned wchar_t".
llvm::DenseSet< const ValueDecl * > CUDAExternalDeviceDeclODRUsedByHost
Keep track of CUDA/HIP external kernels or device variables ODR-used by host code.
Definition: ASTContext.h:1165
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2606
QualType getCorrespondingUnsaturatedType(QualType Ty) const
comments::FullComment * getCommentForDecl(const Decl *D, const Preprocessor *PP) const
Return parsed documentation comment attached to a given declaration.
Definition: ASTContext.cpp:578
FunctionProtoType::ExceptionSpecInfo mergeExceptionSpecs(FunctionProtoType::ExceptionSpecInfo ESI1, FunctionProtoType::ExceptionSpecInfo ESI2, SmallVectorImpl< QualType > &ExceptionTypeStorage, bool AcceptDependent)
unsigned getTargetDefaultAlignForAttributeAligned() const
Return the default alignment for attribute((aligned)) on this target, to be used if no alignment valu...
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
bool isSameTemplateParameterList(const TemplateParameterList *X, const TemplateParameterList *Y) const
Determine whether two template parameter lists are similar enough that they may be used in declaratio...
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2329
CanQualType UnsignedInt128Ty
Definition: ASTContext.h:1102
CanQualType BuiltinFnTy
Definition: ASTContext.h:1120
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class.
unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
Definition: ASTContext.h:3198
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built.
Definition: ASTContext.h:3230
void setManglingNumber(const NamedDecl *ND, unsigned Number)
llvm::DenseMap< const Decl *, const RawComment * > DeclRawComments
Mapping from declaration to directly attached comment.
Definition: ASTContext.h:814
CanQualType OCLSamplerTy
Definition: ASTContext.h:1127
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type.
TypeInfo getTypeInfo(QualType T) const
Definition: ASTContext.h:2323
CanQualType VoidTy
Definition: ASTContext.h:1091
CanQualType UnsignedCharTy
Definition: ASTContext.h:1101
CanQualType UnsignedShortFractTy
Definition: ASTContext.h:1108
BuiltinTemplateDecl * buildBuiltinTemplateDecl(BuiltinTemplateKind BTK, const IdentifierInfo *II) const
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:718
bool canBuiltinBeRedeclared(const FunctionDecl *) const
Return whether a declaration to a builtin is allowed to be overloaded/redeclared.
CanQualType UnsignedIntTy
Definition: ASTContext.h:1101
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply.
unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
Definition: ASTContext.h:3212
QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl, ArrayRef< ObjCProtocolDecl * > protocols) const
QualType getVolatileType(QualType T) const
Return the uniqued reference to the type for a volatile qualified type.
Definition: ASTContext.h:1286
void getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, QualType T, std::string &S, bool Extended) const
getObjCEncodingForMethodParameter - Return the encoded type for a single method parameter or return t...
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
unsigned overridden_methods_size(const CXXMethodDecl *Method) const
std::string getObjCEncodingForBlock(const BlockExpr *blockExpr) const
Return the encoded type for this block declaration.
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
QualType getObjCClassRedefinitionType() const
Retrieve the type that Class has been defined to, which may be different from the built-in Class if C...
Definition: ASTContext.h:1876
TagDecl * getMSGuidTagDecl() const
Retrieve the implicitly-predeclared 'struct _GUID' declaration.
Definition: ASTContext.h:2136
QualType getExceptionObjectType(QualType T) const
CanQualType UnknownAnyTy
Definition: ASTContext.h:1119
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Note that the static data member Inst is an instantiation of the static data member template Tmpl of ...
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl)
ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC's protocol list adopt all protocols in Q...
QualType getFunctionNoProtoType(QualType ResultTy) const
Definition: ASTContext.h:1562
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1102
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
QualType getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false)
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1128
bool isSameTemplateParameter(const NamedDecl *X, const NamedDecl *Y) const
Determine whether two template parameters are similar enough that they may be used in declarations of...
size_t getASTAllocatedMemory() const
Return the total amount of physical memory allocated for representing AST nodes and type information.
Definition: ASTContext.h:746
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
overridden_cxx_method_iterator overridden_methods_begin(const CXXMethodDecl *Method) const
CanQualType UnsignedShortTy
Definition: ASTContext.h:1101
unsigned getTypeAlignIfKnown(QualType T, bool NeedsPreferredAlignment=false) const
Return the alignment of a type, in bits, or 0 if the type is incomplete and we cannot determine the a...
QualType getObjCConstantStringInterface() const
Definition: ASTContext.h:1849
bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1567
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
bool canAssignObjCInterfacesInBlockPointer(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT, bool BlockReturnType)
canAssignObjCInterfacesInBlockPointer - This routine is specifically written for providing type-safet...
CanQualType SatUnsignedLongFractTy
Definition: ASTContext.h:1114
void setcudaConfigureCallDecl(FunctionDecl *FD)
Definition: ASTContext.h:1419
CanQualType getDecayedType(CanQualType T) const
Definition: ASTContext.h:1366
QualType getObjCIdRedefinitionType() const
Retrieve the type that id has been defined to, which may be different from the built-in id if id has ...
Definition: ASTContext.h:1863
const CXXConstructorDecl * getCopyConstructorForExceptionObject(CXXRecordDecl *RD)
QualType getDependentAddressSpaceType(QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const
QualType getPackIndexingType(QualType Pattern, Expr *IndexExpr, bool FullySubstituted=false, ArrayRef< QualType > Expansions={}, int Index=-1) const
RawComment * getRawCommentForDeclNoCache(const Decl *D) const
Return the documentation comment attached to a given declaration, without looking into cache.
Definition: ASTContext.cpp:293
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const
Make an APSInt of the appropriate width and signedness for the given Value and integer Type.
Definition: ASTContext.h:3014
const VariableArrayType * getAsVariableArrayType(QualType T) const
Definition: ASTContext.h:2759
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
const Type * getCanonicalType(const Type *T) const
Definition: ASTContext.h:2567
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
Definition: ASTContext.cpp:947
const ObjCInterfaceDecl * getObjContainingInterface(const NamedDecl *ND) const
Returns the Objective-C interface that ND belongs to if it is an Objective-C method/property/ivar etc...
CanQualType ShortTy
Definition: ASTContext.h:1100
StringLiteral * getPredefinedStringLiteralFromCache(StringRef Key) const
Return a string representing the human readable name for the specified function declaration or file n...
bool UnwrapSimilarTypes(QualType &T1, QualType &T2, bool AllowPiMismatch=true)
Attempt to unwrap two types that may be similar (C++ [conv.qual]).
llvm::APFixedPoint getFixedPointMax(QualType Ty) const
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type.
bool areCompatibleSveTypes(QualType FirstType, QualType SecondType)
Return true if the given types are an SVE builtin and a VectorType that is a fixed-length representat...
void setObjCClassRedefinitionType(QualType RedefType)
Set the user-written type that redefines 'SEL'.
Definition: ASTContext.h:1883
bool hasDirectOwnershipQualifier(QualType Ty) const
Return true if the type has been explicitly qualified with ObjC ownership.
CanQualType FractTy
Definition: ASTContext.h:1107
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const
Recurses in pointer/array types until it finds an Objective-C retainable type and returns its ownersh...
void addCopyConstructorForExceptionObject(CXXRecordDecl *RD, CXXConstructorDecl *CD)
FunctionDecl * getcudaConfigureCallDecl()
Definition: ASTContext.h:1423
DiagnosticsEngine & getDiagnostics() const
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
QualType getUnqualifiedObjCPointerType(QualType type) const
getUnqualifiedObjCPointerType - Returns version of Objective-C pointer type with lifetime qualifier r...
Definition: ASTContext.h:2190
void ResetObjCLayout(const ObjCContainerDecl *CD)
CanQualType LongAccumTy
Definition: ASTContext.h:1105
interp::Context & getInterpContext()
Returns the clang bytecode interpreter context.
Definition: ASTContext.cpp:844
CanQualType Char32Ty
Definition: ASTContext.h:1099
QualType getCVRQualifiedType(QualType T, unsigned CVR) const
Return a type with additional const, volatile, or restrict qualifiers.
Definition: ASTContext.h:2150
UnnamedGlobalConstantDecl * getUnnamedGlobalConstantDecl(QualType Ty, const APValue &Value) const
Return a declaration for a uniquified anonymous global constant corresponding to a given APValue.
CanQualType SatFractTy
Definition: ASTContext.h:1112
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size.
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec)
Return true if the given vector types are of the same unqualified type or if they are equivalent to t...
void getOverriddenMethods(const NamedDecl *Method, SmallVectorImpl< const NamedDecl * > &Overridden) const
Return C++ or ObjC overridden methods for the given Method.
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
CanQualType SatLongFractTy
Definition: ASTContext.h:1112
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:757
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
CanQualType OCLQueueTy
Definition: ASTContext.h:1128
CanQualType LongFractTy
Definition: ASTContext.h:1107
CanQualType SatShortAccumTy
Definition: ASTContext.h:1109
QualType getAutoDeductType() const
C++11 deduction pattern for 'auto' type.
CanQualType BFloat16Ty
Definition: ASTContext.h:1116
unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
Definition: ASTContext.h:3205
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
CanQualType IncompleteMatrixIdxTy
Definition: ASTContext.h:1129
std::optional< CharUnits > getTypeSizeInCharsIfKnown(QualType Ty) const
Definition: ASTContext.h:2348
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
CanQualType getNSIntegerType() const
QualType getCorrespondingUnsignedType(QualType T) const
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy initialization expression of a block var decl.
QualType getLifetimeQualifiedType(QualType type, Qualifiers::ObjCLifetime lifetime)
Return a type with the given lifetime qualifier.
Definition: ASTContext.h:2178
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
TemplateName getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack, Decl *AssociatedDecl, unsigned Index, bool Final) const