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