Thanks to visit codestin.com
Credit goes to clang.llvm.org

clang 22.0.0git
TypeBase.h
Go to the documentation of this file.
1//===- TypeBase.h - C Language Family Type Representation -------*- 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/// C Language Family Type Representation
11///
12/// This file defines the clang::Type interface and subclasses, used to
13/// represent types for languages in the C family.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef LLVM_CLANG_AST_TYPE_BASE_H
18#define LLVM_CLANG_AST_TYPE_BASE_H
19
27#include "clang/Basic/LLVM.h"
29#include "clang/Basic/Linkage.h"
35#include "llvm/ADT/APInt.h"
36#include "llvm/ADT/APSInt.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/FoldingSet.h"
39#include "llvm/ADT/PointerIntPair.h"
40#include "llvm/ADT/PointerUnion.h"
41#include "llvm/ADT/STLForwardCompat.h"
42#include "llvm/ADT/StringRef.h"
43#include "llvm/ADT/Twine.h"
44#include "llvm/ADT/iterator_range.h"
45#include "llvm/Support/Casting.h"
46#include "llvm/Support/Compiler.h"
47#include "llvm/Support/DXILABI.h"
48#include "llvm/Support/ErrorHandling.h"
49#include "llvm/Support/PointerLikeTypeTraits.h"
50#include "llvm/Support/TrailingObjects.h"
51#include "llvm/Support/type_traits.h"
52#include <bitset>
53#include <cassert>
54#include <cstddef>
55#include <cstdint>
56#include <cstring>
57#include <optional>
58#include <string>
59#include <type_traits>
60#include <utility>
61
62namespace clang {
63
64class BTFTypeTagAttr;
65class ExtQuals;
66class QualType;
67class ConceptDecl;
68class ValueDecl;
69class TagDecl;
71class Type;
72class Attr;
73
74enum {
77};
78
79namespace serialization {
80 template <class T> class AbstractTypeReader;
81 template <class T> class AbstractTypeWriter;
82}
83
84} // namespace clang
85
86namespace llvm {
87
88 template <typename T>
90 template<>
92 static inline void *getAsVoidPointer(::clang::Type *P) { return P; }
93
94 static inline ::clang::Type *getFromVoidPointer(void *P) {
95 return static_cast< ::clang::Type*>(P);
96 }
97
99 };
100
101 template<>
103 static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }
104
105 static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
106 return static_cast< ::clang::ExtQuals*>(P);
107 }
108
110 };
111
112} // namespace llvm
113
114namespace clang {
115
116class ASTContext;
117template <typename> class CanQual;
118class CXXRecordDecl;
119class DeclContext;
120class EnumDecl;
121class Expr;
122class ExtQualsTypeCommonBase;
123class FunctionDecl;
124class FunctionEffectsRef;
125class FunctionEffectKindSet;
126class FunctionEffectSet;
127class IdentifierInfo;
128class NamedDecl;
129class ObjCInterfaceDecl;
130class ObjCProtocolDecl;
131class ObjCTypeParamDecl;
132struct PrintingPolicy;
133class RecordDecl;
134class Stmt;
135class TagDecl;
136class ClassTemplateDecl;
137class TemplateArgument;
138class TemplateArgumentListInfo;
139class TemplateArgumentLoc;
140class TemplateTypeParmDecl;
141class TypedefNameDecl;
142class UnresolvedUsingTypenameDecl;
143class UsingShadowDecl;
144
145using CanQualType = CanQual<Type>;
146
147// Provide forward declarations for all of the *Type classes.
148#define TYPE(Class, Base) class Class##Type;
149#include "clang/AST/TypeNodes.inc"
150
151/// Pointer-authentication qualifiers.
152class PointerAuthQualifier {
153 enum : uint32_t {
154 EnabledShift = 0,
155 EnabledBits = 1,
156 EnabledMask = 1 << EnabledShift,
157 AddressDiscriminatedShift = EnabledShift + EnabledBits,
158 AddressDiscriminatedBits = 1,
159 AddressDiscriminatedMask = 1 << AddressDiscriminatedShift,
160 AuthenticationModeShift =
161 AddressDiscriminatedShift + AddressDiscriminatedBits,
162 AuthenticationModeBits = 2,
163 AuthenticationModeMask = ((1 << AuthenticationModeBits) - 1)
164 << AuthenticationModeShift,
165 IsaPointerShift = AuthenticationModeShift + AuthenticationModeBits,
166 IsaPointerBits = 1,
167 IsaPointerMask = ((1 << IsaPointerBits) - 1) << IsaPointerShift,
168 AuthenticatesNullValuesShift = IsaPointerShift + IsaPointerBits,
169 AuthenticatesNullValuesBits = 1,
170 AuthenticatesNullValuesMask = ((1 << AuthenticatesNullValuesBits) - 1)
171 << AuthenticatesNullValuesShift,
172 KeyShift = AuthenticatesNullValuesShift + AuthenticatesNullValuesBits,
173 KeyBits = 10,
174 KeyMask = ((1 << KeyBits) - 1) << KeyShift,
175 DiscriminatorShift = KeyShift + KeyBits,
176 DiscriminatorBits = 16,
177 DiscriminatorMask = ((1u << DiscriminatorBits) - 1) << DiscriminatorShift,
178 };
179
180 // bits: |0 |1 |2..3 |4 |
181 // |Enabled|Address|AuthenticationMode|ISA pointer|
182 // bits: |5 |6..15| 16...31 |
183 // |AuthenticatesNull|Key |Discriminator|
184 uint32_t Data = 0;
185
186 // The following static assertions check that each of the 32 bits is present
187 // exactly in one of the constants.
188 static_assert((EnabledBits + AddressDiscriminatedBits +
189 AuthenticationModeBits + IsaPointerBits +
190 AuthenticatesNullValuesBits + KeyBits + DiscriminatorBits) ==
191 32,
192 "PointerAuthQualifier should be exactly 32 bits");
193 static_assert((EnabledMask + AddressDiscriminatedMask +
194 AuthenticationModeMask + IsaPointerMask +
195 AuthenticatesNullValuesMask + KeyMask + DiscriminatorMask) ==
196 0xFFFFFFFF,
197 "All masks should cover the entire bits");
198 static_assert((EnabledMask ^ AddressDiscriminatedMask ^
199 AuthenticationModeMask ^ IsaPointerMask ^
200 AuthenticatesNullValuesMask ^ KeyMask ^ DiscriminatorMask) ==
201 0xFFFFFFFF,
202 "All masks should cover the entire bits");
203
204 PointerAuthQualifier(unsigned Key, bool IsAddressDiscriminated,
205 unsigned ExtraDiscriminator,
206 PointerAuthenticationMode AuthenticationMode,
207 bool IsIsaPointer, bool AuthenticatesNullValues)
208 : Data(EnabledMask |
209 (IsAddressDiscriminated
210 ? llvm::to_underlying(AddressDiscriminatedMask)
211 : 0) |
212 (Key << KeyShift) |
213 (llvm::to_underlying(AuthenticationMode)
214 << AuthenticationModeShift) |
215 (ExtraDiscriminator << DiscriminatorShift) |
216 (IsIsaPointer << IsaPointerShift) |
217 (AuthenticatesNullValues << AuthenticatesNullValuesShift)) {
218 assert(Key <= KeyNoneInternal);
219 assert(ExtraDiscriminator <= MaxDiscriminator);
220 assert((Data == 0) ==
222 }
223
224public:
225 enum {
226 KeyNoneInternal = (1u << KeyBits) - 1,
227
228 /// The maximum supported pointer-authentication key.
230
231 /// The maximum supported pointer-authentication discriminator.
232 MaxDiscriminator = (1u << DiscriminatorBits) - 1
233 };
234
235public:
237
238 static PointerAuthQualifier
239 Create(unsigned Key, bool IsAddressDiscriminated, unsigned ExtraDiscriminator,
240 PointerAuthenticationMode AuthenticationMode, bool IsIsaPointer,
241 bool AuthenticatesNullValues) {
242 if (Key == PointerAuthKeyNone)
243 Key = KeyNoneInternal;
244 assert(Key <= KeyNoneInternal && "out-of-range key value");
245 return PointerAuthQualifier(Key, IsAddressDiscriminated, ExtraDiscriminator,
246 AuthenticationMode, IsIsaPointer,
247 AuthenticatesNullValues);
248 }
249
250 bool isPresent() const {
251 assert((Data == 0) ==
253 return Data != 0;
254 }
255
256 explicit operator bool() const { return isPresent(); }
257
258 unsigned getKey() const {
259 assert(isPresent());
260 return (Data & KeyMask) >> KeyShift;
261 }
262
263 bool hasKeyNone() const { return isPresent() && getKey() == KeyNoneInternal; }
264
266 assert(isPresent());
267 return (Data & AddressDiscriminatedMask) >> AddressDiscriminatedShift;
268 }
269
270 unsigned getExtraDiscriminator() const {
271 assert(isPresent());
272 return (Data >> DiscriminatorShift);
273 }
274
276 return PointerAuthenticationMode((Data & AuthenticationModeMask) >>
277 AuthenticationModeShift);
278 }
279
280 bool isIsaPointer() const {
281 assert(isPresent());
282 return (Data & IsaPointerMask) >> IsaPointerShift;
283 }
284
286 assert(isPresent());
287 return (Data & AuthenticatesNullValuesMask) >> AuthenticatesNullValuesShift;
288 }
289
290 PointerAuthQualifier withoutKeyNone() const {
291 return hasKeyNone() ? PointerAuthQualifier() : *this;
292 }
293
294 friend bool operator==(PointerAuthQualifier Lhs, PointerAuthQualifier Rhs) {
295 return Lhs.Data == Rhs.Data;
296 }
297 friend bool operator!=(PointerAuthQualifier Lhs, PointerAuthQualifier Rhs) {
298 return Lhs.Data != Rhs.Data;
299 }
300
301 bool isEquivalent(PointerAuthQualifier Other) const {
302 return withoutKeyNone() == Other.withoutKeyNone();
303 }
304
305 uint32_t getAsOpaqueValue() const { return Data; }
306
307 // Deserialize pointer-auth qualifiers from an opaque representation.
308 static PointerAuthQualifier fromOpaqueValue(uint32_t Opaque) {
309 PointerAuthQualifier Result;
310 Result.Data = Opaque;
311 assert((Result.Data == 0) ==
312 (Result.getAuthenticationMode() == PointerAuthenticationMode::None));
313 return Result;
314 }
315
316 std::string getAsString() const;
317 std::string getAsString(const PrintingPolicy &Policy) const;
318
319 bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
320 void print(raw_ostream &OS, const PrintingPolicy &Policy) const;
321
322 void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger(Data); }
323};
324
325/// The collection of all-type qualifiers we support.
326/// Clang supports five independent qualifiers:
327/// * C99: const, volatile, and restrict
328/// * MS: __unaligned
329/// * Embedded C (TR18037): address spaces
330/// * Objective C: the GC attributes (none, weak, or strong)
332public:
333 Qualifiers() = default;
334 enum TQ : uint64_t {
335 // NOTE: These flags must be kept in sync with DeclSpec::TQ.
336 Const = 0x1,
337 Restrict = 0x2,
338 Volatile = 0x4,
340 };
341
342 enum GC {
346 };
347
349 /// There is no lifetime qualification on this type.
351
352 /// This object can be modified without requiring retains or
353 /// releases.
355
356 /// Assigning into this object requires the old value to be
357 /// released and the new value to be retained. The timing of the
358 /// release of the old value is inexact: it may be moved to
359 /// immediately after the last known point where the value is
360 /// live.
362
363 /// Reading or writing from this object requires a barrier call.
365
366 /// Assigning into this object requires a lifetime extension.
368 };
369
370 enum : uint64_t {
371 /// The maximum supported address space number.
372 /// 23 bits should be enough for anyone.
373 MaxAddressSpace = 0x7fffffu,
374
375 /// The width of the "fast" qualifier mask.
377
378 /// The fast qualifier mask.
379 FastMask = (1 << FastWidth) - 1
380 };
381
382 /// Returns the common set of qualifiers while removing them from
383 /// the given sets.
385 Qualifiers Q;
387 if (LPtrAuth.isPresent() &&
389 LPtrAuth == R.getPointerAuth()) {
390 Q.setPointerAuth(LPtrAuth);
394 }
395
396 // If both are only CVR-qualified, bit operations are sufficient.
397 if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) {
398 Q.Mask = L.Mask & R.Mask;
399 L.Mask &= ~Q.Mask;
400 R.Mask &= ~Q.Mask;
401 return Q;
402 }
403
404 unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
405 Q.addCVRQualifiers(CommonCRV);
406 L.removeCVRQualifiers(CommonCRV);
407 R.removeCVRQualifiers(CommonCRV);
408
409 if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
413 }
414
415 if (L.getObjCLifetime() == R.getObjCLifetime()) {
419 }
420
421 if (L.getAddressSpace() == R.getAddressSpace()) {
425 }
426 return Q;
427 }
428
429 static Qualifiers fromFastMask(unsigned Mask) {
430 Qualifiers Qs;
431 Qs.addFastQualifiers(Mask);
432 return Qs;
433 }
434
435 static Qualifiers fromCVRMask(unsigned CVR) {
436 Qualifiers Qs;
437 Qs.addCVRQualifiers(CVR);
438 return Qs;
439 }
440
441 static Qualifiers fromCVRUMask(unsigned CVRU) {
442 Qualifiers Qs;
443 Qs.addCVRUQualifiers(CVRU);
444 return Qs;
445 }
446
447 // Deserialize qualifiers from an opaque representation.
448 static Qualifiers fromOpaqueValue(uint64_t opaque) {
449 Qualifiers Qs;
450 Qs.Mask = opaque;
451 return Qs;
452 }
453
454 // Serialize these qualifiers into an opaque representation.
455 uint64_t getAsOpaqueValue() const { return Mask; }
456
457 bool hasConst() const { return Mask & Const; }
458 bool hasOnlyConst() const { return Mask == Const; }
459 void removeConst() { Mask &= ~Const; }
460 void addConst() { Mask |= Const; }
462 Qualifiers Qs = *this;
463 Qs.addConst();
464 return Qs;
465 }
466
467 bool hasVolatile() const { return Mask & Volatile; }
468 bool hasOnlyVolatile() const { return Mask == Volatile; }
469 void removeVolatile() { Mask &= ~Volatile; }
470 void addVolatile() { Mask |= Volatile; }
472 Qualifiers Qs = *this;
473 Qs.addVolatile();
474 return Qs;
475 }
476
477 bool hasRestrict() const { return Mask & Restrict; }
478 bool hasOnlyRestrict() const { return Mask == Restrict; }
479 void removeRestrict() { Mask &= ~Restrict; }
480 void addRestrict() { Mask |= Restrict; }
482 Qualifiers Qs = *this;
483 Qs.addRestrict();
484 return Qs;
485 }
486
487 bool hasCVRQualifiers() const { return getCVRQualifiers(); }
488 unsigned getCVRQualifiers() const { return Mask & CVRMask; }
489 unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }
490
491 void setCVRQualifiers(unsigned mask) {
492 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits");
493 Mask = (Mask & ~CVRMask) | mask;
494 }
495 void removeCVRQualifiers(unsigned mask) {
496 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits");
497 Mask &= ~static_cast<uint64_t>(mask);
498 }
502 void addCVRQualifiers(unsigned mask) {
503 assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits");
504 Mask |= mask;
505 }
506 void addCVRUQualifiers(unsigned mask) {
507 assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits");
508 Mask |= mask;
509 }
510
511 bool hasUnaligned() const { return Mask & UMask; }
512 void setUnaligned(bool flag) {
513 Mask = (Mask & ~UMask) | (flag ? UMask : 0);
514 }
515 void removeUnaligned() { Mask &= ~UMask; }
516 void addUnaligned() { Mask |= UMask; }
517
518 bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
519 GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
521 Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
522 }
525 assert(type);
527 }
529 Qualifiers qs = *this;
530 qs.removeObjCGCAttr();
531 return qs;
532 }
534 Qualifiers qs = *this;
536 return qs;
537 }
539 Qualifiers qs = *this;
541 return qs;
542 }
543
544 bool hasObjCLifetime() const { return Mask & LifetimeMask; }
546 return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
547 }
549 Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
550 }
553 assert(type);
554 assert(!hasObjCLifetime());
555 Mask |= (type << LifetimeShift);
556 }
557
558 /// True if the lifetime is neither None or ExplicitNone.
560 ObjCLifetime lifetime = getObjCLifetime();
561 return (lifetime > OCL_ExplicitNone);
562 }
563
564 /// True if the lifetime is either strong or weak.
566 ObjCLifetime lifetime = getObjCLifetime();
567 return (lifetime == OCL_Strong || lifetime == OCL_Weak);
568 }
569
570 bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
572 return static_cast<LangAS>((Mask & AddressSpaceMask) >> AddressSpaceShift);
573 }
577 /// Get the address space attribute value to be printed by diagnostics.
579 auto Addr = getAddressSpace();
580 // This function is not supposed to be used with language specific
581 // address spaces. If that happens, the diagnostic message should consider
582 // printing the QualType instead of the address space value.
584 if (Addr != LangAS::Default)
586 // TODO: The diagnostic messages where Addr may be 0 should be fixed
587 // since it cannot differentiate the situation where 0 denotes the default
588 // address space or user specified __attribute__((address_space(0))).
589 return 0;
590 }
592 assert((unsigned)space <= MaxAddressSpace);
593 Mask = (Mask & ~AddressSpaceMask)
594 | (((uint32_t) space) << AddressSpaceShift);
595 }
598 assert(space != LangAS::Default);
599 setAddressSpace(space);
600 }
601
602 bool hasPointerAuth() const { return Mask & PtrAuthMask; }
604 return PointerAuthQualifier::fromOpaqueValue(Mask >> PtrAuthShift);
605 }
607 Mask = (Mask & ~PtrAuthMask) |
608 (uint64_t(Q.getAsOpaqueValue()) << PtrAuthShift);
609 }
610 void removePointerAuth() { Mask &= ~PtrAuthMask; }
612 assert(Q.isPresent());
614 }
615
616 // Fast qualifiers are those that can be allocated directly
617 // on a QualType object.
618 bool hasFastQualifiers() const { return getFastQualifiers(); }
619 unsigned getFastQualifiers() const { return Mask & FastMask; }
620 void setFastQualifiers(unsigned mask) {
621 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits");
622 Mask = (Mask & ~FastMask) | mask;
623 }
624 void removeFastQualifiers(unsigned mask) {
625 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits");
626 Mask &= ~static_cast<uint64_t>(mask);
627 }
631 void addFastQualifiers(unsigned mask) {
632 assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits");
633 Mask |= mask;
634 }
635
636 /// Return true if the set contains any qualifiers which require an ExtQuals
637 /// node to be allocated.
638 bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
640 Qualifiers Quals = *this;
641 Quals.setFastQualifiers(0);
642 return Quals;
643 }
644
645 /// Return true if the set contains any qualifiers.
646 bool hasQualifiers() const { return Mask; }
647 bool empty() const { return !Mask; }
648
649 /// Add the qualifiers from the given set to this set.
651 // If the other set doesn't have any non-boolean qualifiers, just
652 // bit-or it in.
653 if (!(Q.Mask & ~CVRMask))
654 Mask |= Q.Mask;
655 else {
656 Mask |= (Q.Mask & CVRMask);
657 if (Q.hasAddressSpace())
659 if (Q.hasObjCGCAttr())
661 if (Q.hasObjCLifetime())
663 if (Q.hasPointerAuth())
665 }
666 }
667
668 /// Remove the qualifiers from the given set from this set.
670 // If the other set doesn't have any non-boolean qualifiers, just
671 // bit-and the inverse in.
672 if (!(Q.Mask & ~CVRMask))
673 Mask &= ~Q.Mask;
674 else {
675 Mask &= ~(Q.Mask & CVRMask);
676 if (getObjCGCAttr() == Q.getObjCGCAttr())
678 if (getObjCLifetime() == Q.getObjCLifetime())
680 if (getAddressSpace() == Q.getAddressSpace())
682 if (getPointerAuth() == Q.getPointerAuth())
684 }
685 }
686
687 /// Add the qualifiers from the given set to this set, given that
688 /// they don't conflict.
690 assert(getAddressSpace() == qs.getAddressSpace() ||
691 !hasAddressSpace() || !qs.hasAddressSpace());
692 assert(getObjCGCAttr() == qs.getObjCGCAttr() ||
693 !hasObjCGCAttr() || !qs.hasObjCGCAttr());
694 assert(getObjCLifetime() == qs.getObjCLifetime() ||
695 !hasObjCLifetime() || !qs.hasObjCLifetime());
696 assert(!hasPointerAuth() || !qs.hasPointerAuth() ||
698 Mask |= qs.Mask;
699 }
700
701 /// Returns true if address space A is equal to or a superset of B.
702 /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
703 /// overlapping address spaces.
704 /// CL1.1 or CL1.2:
705 /// every address space is a superset of itself.
706 /// CL2.0 adds:
707 /// __generic is a superset of any address space except for __constant.
709 const ASTContext &Ctx) {
710 // Address spaces must match exactly.
711 return A == B || isTargetAddressSpaceSupersetOf(A, B, Ctx);
712 }
713
715 const ASTContext &Ctx);
716
717 /// Returns true if the address space in these qualifiers is equal to or
718 /// a superset of the address space in the argument qualifiers.
719 bool isAddressSpaceSupersetOf(Qualifiers other, const ASTContext &Ctx) const {
721 Ctx);
722 }
723
724 /// Determines if these qualifiers compatibly include another set.
725 /// Generally this answers the question of whether an object with the other
726 /// qualifiers can be safely used as an object with these qualifiers.
727 bool compatiblyIncludes(Qualifiers other, const ASTContext &Ctx) const {
728 return isAddressSpaceSupersetOf(other, Ctx) &&
729 // ObjC GC qualifiers can match, be added, or be removed, but can't
730 // be changed.
731 (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() ||
732 !other.hasObjCGCAttr()) &&
733 // Pointer-auth qualifiers must match exactly.
734 getPointerAuth() == other.getPointerAuth() &&
735 // ObjC lifetime qualifiers must match exactly.
736 getObjCLifetime() == other.getObjCLifetime() &&
737 // CVR qualifiers may subset.
738 (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) &&
739 // U qualifier may superset.
740 (!other.hasUnaligned() || hasUnaligned());
741 }
742
743 /// Determines if these qualifiers compatibly include another set of
744 /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
745 ///
746 /// One set of Objective-C lifetime qualifiers compatibly includes the other
747 /// if the lifetime qualifiers match, or if both are non-__weak and the
748 /// including set also contains the 'const' qualifier, or both are non-__weak
749 /// and one is None (which can only happen in non-ARC modes).
751 if (getObjCLifetime() == other.getObjCLifetime())
752 return true;
753
754 if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak)
755 return false;
756
757 if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None)
758 return true;
759
760 return hasConst();
761 }
762
763 /// Determine whether this set of qualifiers is a strict superset of
764 /// another set of qualifiers, not considering qualifier compatibility.
766
767 bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
768 bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }
769
770 explicit operator bool() const { return hasQualifiers(); }
771
773 addQualifiers(R);
774 return *this;
775 }
776
777 // Union two qualifier sets. If an enumerated qualifier appears
778 // in both sets, use the one from the right.
780 L += R;
781 return L;
782 }
783
786 return *this;
787 }
788
789 /// Compute the difference between two qualifier sets.
791 L -= R;
792 return L;
793 }
794
795 std::string getAsString() const;
796 std::string getAsString(const PrintingPolicy &Policy) const;
797
798 static std::string getAddrSpaceAsString(LangAS AS);
799
800 bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
801 void print(raw_ostream &OS, const PrintingPolicy &Policy,
802 bool appendSpaceIfNonEmpty = false) const;
803
804 void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger(Mask); }
805
806private:
807 // bits: |0 1 2|3|4 .. 5|6 .. 8|9 ... 31|32 ... 63|
808 // |C R V|U|GCAttr|Lifetime|AddressSpace| PtrAuth |
809 uint64_t Mask = 0;
810 static_assert(sizeof(PointerAuthQualifier) == sizeof(uint32_t),
811 "PointerAuthQualifier must be 32 bits");
812
813 static constexpr uint64_t PtrAuthShift = 32;
814 static constexpr uint64_t PtrAuthMask = UINT64_C(0xffffffff) << PtrAuthShift;
815
816 static constexpr uint64_t UMask = 0x8;
817 static constexpr uint64_t UShift = 3;
818 static constexpr uint64_t GCAttrMask = 0x30;
819 static constexpr uint64_t GCAttrShift = 4;
820 static constexpr uint64_t LifetimeMask = 0x1C0;
821 static constexpr uint64_t LifetimeShift = 6;
822 static constexpr uint64_t AddressSpaceMask =
823 ~(CVRMask | UMask | GCAttrMask | LifetimeMask | PtrAuthMask);
824 static constexpr uint64_t AddressSpaceShift = 9;
825};
826
828 Qualifiers Quals;
829 bool HasAtomic;
830
831public:
832 QualifiersAndAtomic() : HasAtomic(false) {}
833 QualifiersAndAtomic(Qualifiers Quals, bool HasAtomic)
834 : Quals(Quals), HasAtomic(HasAtomic) {}
835
836 operator Qualifiers() const { return Quals; }
837
838 bool hasVolatile() const { return Quals.hasVolatile(); }
839 bool hasConst() const { return Quals.hasConst(); }
840 bool hasRestrict() const { return Quals.hasRestrict(); }
841 bool hasAtomic() const { return HasAtomic; }
842
843 void addVolatile() { Quals.addVolatile(); }
844 void addConst() { Quals.addConst(); }
845 void addRestrict() { Quals.addRestrict(); }
846 void addAtomic() { HasAtomic = true; }
847
848 void removeVolatile() { Quals.removeVolatile(); }
849 void removeConst() { Quals.removeConst(); }
850 void removeRestrict() { Quals.removeRestrict(); }
851 void removeAtomic() { HasAtomic = false; }
852
854 return {Quals.withVolatile(), HasAtomic};
855 }
856 QualifiersAndAtomic withConst() { return {Quals.withConst(), HasAtomic}; }
858 return {Quals.withRestrict(), HasAtomic};
859 }
860 QualifiersAndAtomic withAtomic() { return {Quals, true}; }
861
863 Quals += RHS;
864 return *this;
865 }
866};
867
868/// A std::pair-like structure for storing a qualified type split
869/// into its local qualifiers and its locally-unqualified type.
871 /// The locally-unqualified type.
872 const Type *Ty = nullptr;
873
874 /// The local qualifiers.
876
877 SplitQualType() = default;
878 SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}
879
880 SplitQualType getSingleStepDesugaredType() const; // end of this file
881
882 // Make std::tie work.
883 std::pair<const Type *,Qualifiers> asPair() const {
884 return std::pair<const Type *, Qualifiers>(Ty, Quals);
885 }
886
888 return a.Ty == b.Ty && a.Quals == b.Quals;
889 }
891 return a.Ty != b.Ty || a.Quals != b.Quals;
892 }
893};
894
895/// The kind of type we are substituting Objective-C type arguments into.
896///
897/// The kind of substitution affects the replacement of type parameters when
898/// no concrete type information is provided, e.g., when dealing with an
899/// unspecialized type.
901 /// An ordinary type.
903
904 /// The result type of a method or function.
906
907 /// The parameter type of a method or function.
909
910 /// The type of a property.
912
913 /// The superclass of a type.
915};
916
917/// The kind of 'typeof' expression we're after.
918enum class TypeOfKind : uint8_t {
921};
922
923/// A (possibly-)qualified type.
924///
925/// For efficiency, we don't store CV-qualified types as nodes on their
926/// own: instead each reference to a type stores the qualifiers. This
927/// greatly reduces the number of nodes we need to allocate for types (for
928/// example we only need one for 'int', 'const int', 'volatile int',
929/// 'const volatile int', etc).
930///
931/// As an added efficiency bonus, instead of making this a pair, we
932/// just store the two bits we care about in the low bits of the
933/// pointer. To handle the packing/unpacking, we make QualType be a
934/// simple wrapper class that acts like a smart pointer. A third bit
935/// indicates whether there are extended qualifiers present, in which
936/// case the pointer points to a special structure.
937class QualType {
938 friend class QualifierCollector;
939
940 // Thankfully, these are efficiently composable.
941 llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
943
944 const ExtQuals *getExtQualsUnsafe() const {
945 return cast<const ExtQuals *>(Value.getPointer());
946 }
947
948 const Type *getTypePtrUnsafe() const {
949 return cast<const Type *>(Value.getPointer());
950 }
951
952 const ExtQualsTypeCommonBase *getCommonPtr() const {
953 assert(!isNull() && "Cannot retrieve a NULL type pointer");
954 auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
955 CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
956 return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
957 }
958
959public:
960 QualType() = default;
961 QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
962 QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
963
964 unsigned getLocalFastQualifiers() const { return Value.getInt(); }
965 void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }
966
967 bool UseExcessPrecision(const ASTContext &Ctx);
968
969 /// Retrieves a pointer to the underlying (unqualified) type.
970 ///
971 /// This function requires that the type not be NULL. If the type might be
972 /// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
973 const Type *getTypePtr() const;
974
975 const Type *getTypePtrOrNull() const;
976
977 /// Retrieves a pointer to the name of the base type.
979
980 /// Divides a QualType into its unqualified type and a set of local
981 /// qualifiers.
982 SplitQualType split() const;
983
984 void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
985
986 static QualType getFromOpaquePtr(const void *Ptr) {
987 QualType T;
988 T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
989 return T;
990 }
991
992 const Type &operator*() const {
993 return *getTypePtr();
994 }
995
996 const Type *operator->() const {
997 return getTypePtr();
998 }
999
1000 bool isCanonical() const;
1001 bool isCanonicalAsParam() const;
1002
1003 /// Return true if this QualType doesn't point to a type yet.
1004 bool isNull() const {
1005 return Value.getPointer().isNull();
1006 }
1007
1008 // Determines if a type can form `T&`.
1009 bool isReferenceable() const;
1010
1011 /// Determine whether this particular QualType instance has the
1012 /// "const" qualifier set, without looking through typedefs that may have
1013 /// added "const" at a different level.
1016 }
1017
1018 /// Determine whether this type is const-qualified.
1019 bool isConstQualified() const;
1020
1027 /// Determine whether instances of this type can be placed in immutable
1028 /// storage.
1029 /// If ExcludeCtor is true, the duration when the object's constructor runs
1030 /// will not be considered. The caller will need to verify that the object is
1031 /// not written to during its construction. ExcludeDtor works similarly.
1032 std::optional<NonConstantStorageReason>
1033 isNonConstantStorage(const ASTContext &Ctx, bool ExcludeCtor,
1034 bool ExcludeDtor);
1035
1036 bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor,
1037 bool ExcludeDtor) {
1038 return !isNonConstantStorage(Ctx, ExcludeCtor, ExcludeDtor);
1039 }
1040
1041 /// Determine whether this particular QualType instance has the
1042 /// "restrict" qualifier set, without looking through typedefs that may have
1043 /// added "restrict" at a different level.
1047
1048 /// Determine whether this type is restrict-qualified.
1049 bool isRestrictQualified() const;
1050
1051 /// Determine whether this particular QualType instance has the
1052 /// "volatile" qualifier set, without looking through typedefs that may have
1053 /// added "volatile" at a different level.
1057
1058 /// Determine whether this type is volatile-qualified.
1059 bool isVolatileQualified() const;
1060
1061 /// Determine whether this particular QualType instance has any
1062 /// qualifiers, without looking through any typedefs that might add
1063 /// qualifiers at a different level.
1067
1068 /// Determine whether this type has any qualifiers.
1069 bool hasQualifiers() const;
1070
1071 /// Determine whether this particular QualType instance has any
1072 /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
1073 /// instance.
1075 return isa<const ExtQuals *>(Value.getPointer());
1076 }
1077
1078 /// Retrieve the set of qualifiers local to this particular QualType
1079 /// instance, not including any qualifiers acquired through typedefs or
1080 /// other sugar.
1082
1083 /// Retrieve the set of qualifiers applied to this type.
1084 Qualifiers getQualifiers() const;
1085
1086 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
1087 /// local to this particular QualType instance, not including any qualifiers
1088 /// acquired through typedefs or other sugar.
1089 unsigned getLocalCVRQualifiers() const {
1090 return getLocalFastQualifiers();
1091 }
1092
1093 /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
1094 /// applied to this type.
1095 unsigned getCVRQualifiers() const;
1096
1097 bool isConstant(const ASTContext& Ctx) const {
1098 return QualType::isConstant(*this, Ctx);
1099 }
1100
1101 /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
1102 bool isPODType(const ASTContext &Context) const;
1103
1104 /// Return true if this is a POD type according to the rules of the C++98
1105 /// standard, regardless of the current compilation's language.
1106 bool isCXX98PODType(const ASTContext &Context) const;
1107
1108 /// Return true if this is a POD type according to the more relaxed rules
1109 /// of the C++11 standard, regardless of the current compilation's language.
1110 /// (C++0x [basic.types]p9). Note that, unlike
1111 /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
1112 bool isCXX11PODType(const ASTContext &Context) const;
1113
1114 /// Return true if this is a trivial type per (C++0x [basic.types]p9)
1115 bool isTrivialType(const ASTContext &Context) const;
1116
1117 /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
1118 bool isTriviallyCopyableType(const ASTContext &Context) const;
1119
1120 /// Return true if the type is safe to bitwise copy using memcpy/memmove.
1121 ///
1122 /// This is an extension in clang: bitwise cloneable types act as trivially
1123 /// copyable types, meaning their underlying bytes can be safely copied by
1124 /// memcpy or memmove. After the copy, the destination object has the same
1125 /// object representation.
1126 ///
1127 /// However, there are cases where it is not safe to copy:
1128 /// - When sanitizers, such as AddressSanitizer, add padding with poison,
1129 /// which can cause issues if those poisoned padding bits are accessed.
1130 /// - Types with Objective-C lifetimes, where specific runtime
1131 /// semantics may not be preserved during a bitwise copy.
1132 bool isBitwiseCloneableType(const ASTContext &Context) const;
1133
1134 /// Return true if this is a trivially copyable type
1135 bool isTriviallyCopyConstructibleType(const ASTContext &Context) const;
1136
1137 /// Returns true if it is a class and it might be dynamic.
1138 bool mayBeDynamicClass() const;
1139
1140 /// Returns true if it is not a class or if the class might not be dynamic.
1141 bool mayBeNotDynamicClass() const;
1142
1143 /// Returns true if it is a WebAssembly Reference Type.
1144 bool isWebAssemblyReferenceType() const;
1145
1146 /// Returns true if it is a WebAssembly Externref Type.
1147 bool isWebAssemblyExternrefType() const;
1148
1149 /// Returns true if it is a WebAssembly Funcref Type.
1150 bool isWebAssemblyFuncrefType() const;
1151
1152 // Don't promise in the API that anything besides 'const' can be
1153 // easily added.
1154
1155 /// Add the `const` type qualifier to this QualType.
1162
1163 /// Add the `volatile` type qualifier to this QualType.
1170
1171 /// Add the `restrict` qualifier to this QualType.
1178
1179 QualType withCVRQualifiers(unsigned CVR) const {
1180 return withFastQualifiers(CVR);
1181 }
1182
1183 void addFastQualifiers(unsigned TQs) {
1184 assert(!(TQs & ~Qualifiers::FastMask)
1185 && "non-fast qualifier bits set in mask!");
1186 Value.setInt(Value.getInt() | TQs);
1187 }
1188
1189 void removeLocalConst();
1190 void removeLocalVolatile();
1191 void removeLocalRestrict();
1192
1193 void removeLocalFastQualifiers() { Value.setInt(0); }
1194 void removeLocalFastQualifiers(unsigned Mask) {
1195 assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers");
1196 Value.setInt(Value.getInt() & ~Mask);
1197 }
1198
1199 // Creates a type with the given qualifiers in addition to any
1200 // qualifiers already on this type.
1201 QualType withFastQualifiers(unsigned TQs) const {
1202 QualType T = *this;
1203 T.addFastQualifiers(TQs);
1204 return T;
1205 }
1206
1207 // Creates a type with exactly the given fast qualifiers, removing
1208 // any existing fast qualifiers.
1212
1213 // Removes fast qualifiers, but leaves any extended qualifiers in place.
1215 QualType T = *this;
1216 T.removeLocalFastQualifiers();
1217 return T;
1218 }
1219
1220 QualType getCanonicalType() const;
1221
1222 /// Return this type with all of the instance-specific qualifiers
1223 /// removed, but without removing any qualifiers that may have been applied
1224 /// through typedefs.
1226
1227 /// Retrieve the unqualified variant of the given type,
1228 /// removing as little sugar as possible.
1229 ///
1230 /// This routine looks through various kinds of sugar to find the
1231 /// least-desugared type that is unqualified. For example, given:
1232 ///
1233 /// \code
1234 /// typedef int Integer;
1235 /// typedef const Integer CInteger;
1236 /// typedef CInteger DifferenceType;
1237 /// \endcode
1238 ///
1239 /// Executing \c getUnqualifiedType() on the type \c DifferenceType will
1240 /// desugar until we hit the type \c Integer, which has no qualifiers on it.
1241 ///
1242 /// The resulting type might still be qualified if it's sugar for an array
1243 /// type. To strip qualifiers even from within a sugared array type, use
1244 /// ASTContext::getUnqualifiedArrayType.
1245 ///
1246 /// Note: In C, the _Atomic qualifier is special (see C23 6.2.5p32 for
1247 /// details), and it is not stripped by this function. Use
1248 /// getAtomicUnqualifiedType() to strip qualifiers including _Atomic.
1249 inline QualType getUnqualifiedType() const;
1250
1251 /// Retrieve the unqualified variant of the given type, removing as little
1252 /// sugar as possible.
1253 ///
1254 /// Like getUnqualifiedType(), but also returns the set of
1255 /// qualifiers that were built up.
1256 ///
1257 /// The resulting type might still be qualified if it's sugar for an array
1258 /// type. To strip qualifiers even from within a sugared array type, use
1259 /// ASTContext::getUnqualifiedArrayType.
1261
1262 /// Determine whether this type is more qualified than the other
1263 /// given type, requiring exact equality for non-CVR qualifiers.
1264 bool isMoreQualifiedThan(QualType Other, const ASTContext &Ctx) const;
1265
1266 /// Determine whether this type is at least as qualified as the other
1267 /// given type, requiring exact equality for non-CVR qualifiers.
1268 bool isAtLeastAsQualifiedAs(QualType Other, const ASTContext &Ctx) const;
1269
1271
1272 /// Determine the type of a (typically non-lvalue) expression with the
1273 /// specified result type.
1274 ///
1275 /// This routine should be used for expressions for which the return type is
1276 /// explicitly specified (e.g., in a cast or call) and isn't necessarily
1277 /// an lvalue. It removes a top-level reference (since there are no
1278 /// expressions of reference type) and deletes top-level cvr-qualifiers
1279 /// from non-class types (in C++) or all types (in C).
1280 QualType getNonLValueExprType(const ASTContext &Context) const;
1281
1282 /// Remove an outer pack expansion type (if any) from this type. Used as part
1283 /// of converting the type of a declaration to the type of an expression that
1284 /// references that expression. It's meaningless for an expression to have a
1285 /// pack expansion type.
1287
1288 /// Return the specified type with any "sugar" removed from
1289 /// the type. This takes off typedefs, typeof's etc. If the outer level of
1290 /// the type is already concrete, it returns it unmodified. This is similar
1291 /// to getting the canonical type, but it doesn't remove *all* typedefs. For
1292 /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
1293 /// concrete.
1294 ///
1295 /// Qualifiers are left in place.
1296 QualType getDesugaredType(const ASTContext &Context) const {
1297 return getDesugaredType(*this, Context);
1298 }
1299
1301 return getSplitDesugaredType(*this);
1302 }
1303
1304 /// Return the specified type with one level of "sugar" removed from
1305 /// the type.
1306 ///
1307 /// This routine takes off the first typedef, typeof, etc. If the outer level
1308 /// of the type is already concrete, it returns it unmodified.
1310 return getSingleStepDesugaredTypeImpl(*this, Context);
1311 }
1312
1313 /// Returns the specified type after dropping any
1314 /// outer-level parentheses.
1316 if (isa<ParenType>(*this))
1317 return QualType::IgnoreParens(*this);
1318 return *this;
1319 }
1320
1321 /// Indicate whether the specified types and qualifiers are identical.
1322 friend bool operator==(const QualType &LHS, const QualType &RHS) {
1323 return LHS.Value == RHS.Value;
1324 }
1325 friend bool operator!=(const QualType &LHS, const QualType &RHS) {
1326 return LHS.Value != RHS.Value;
1327 }
1328 friend bool operator<(const QualType &LHS, const QualType &RHS) {
1329 return LHS.Value < RHS.Value;
1330 }
1331
1332 static std::string getAsString(SplitQualType split,
1333 const PrintingPolicy &Policy) {
1334 return getAsString(split.Ty, split.Quals, Policy);
1335 }
1336 static std::string getAsString(const Type *ty, Qualifiers qs,
1337 const PrintingPolicy &Policy);
1338
1339 std::string getAsString() const;
1340 std::string getAsString(const PrintingPolicy &Policy) const;
1341
1342 void print(raw_ostream &OS, const PrintingPolicy &Policy,
1343 const Twine &PlaceHolder = Twine(),
1344 unsigned Indentation = 0) const;
1345
1346 static void print(SplitQualType split, raw_ostream &OS,
1347 const PrintingPolicy &policy, const Twine &PlaceHolder,
1348 unsigned Indentation = 0) {
1349 return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
1350 }
1351
1352 static void print(const Type *ty, Qualifiers qs,
1353 raw_ostream &OS, const PrintingPolicy &policy,
1354 const Twine &PlaceHolder,
1355 unsigned Indentation = 0);
1356
1357 void getAsStringInternal(std::string &Str,
1358 const PrintingPolicy &Policy) const;
1359
1360 static void getAsStringInternal(SplitQualType split, std::string &out,
1361 const PrintingPolicy &policy) {
1362 return getAsStringInternal(split.Ty, split.Quals, out, policy);
1363 }
1364
1365 static void getAsStringInternal(const Type *ty, Qualifiers qs,
1366 std::string &out,
1367 const PrintingPolicy &policy);
1368
1370 const QualType &T;
1371 const PrintingPolicy &Policy;
1372 const Twine &PlaceHolder;
1373 unsigned Indentation;
1374
1375 public:
1377 const Twine &PlaceHolder, unsigned Indentation)
1378 : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
1379 Indentation(Indentation) {}
1380
1381 friend raw_ostream &operator<<(raw_ostream &OS,
1382 const StreamedQualTypeHelper &SQT) {
1383 SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1384 return OS;
1385 }
1386 };
1387
1389 const Twine &PlaceHolder = Twine(),
1390 unsigned Indentation = 0) const {
1391 return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
1392 }
1393
1394 void dump(const char *s) const;
1395 void dump() const;
1396 void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
1397
1398 void Profile(llvm::FoldingSetNodeID &ID) const {
1399 ID.AddPointer(getAsOpaquePtr());
1400 }
1401
1402 /// Check if this type has any address space qualifier.
1403 inline bool hasAddressSpace() const;
1404
1405 /// Return the address space of this type.
1406 inline LangAS getAddressSpace() const;
1407
1408 /// Returns true if address space qualifiers overlap with T address space
1409 /// qualifiers.
1410 /// OpenCL C defines conversion rules for pointers to different address spaces
1411 /// and notion of overlapping address spaces.
1412 /// CL1.1 or CL1.2:
1413 /// address spaces overlap iff they are they same.
1414 /// OpenCL C v2.0 s6.5.5 adds:
1415 /// __generic overlaps with any address space except for __constant.
1418 Qualifiers TQ = T.getQualifiers();
1419 // Address spaces overlap if at least one of them is a superset of another
1420 return Q.isAddressSpaceSupersetOf(TQ, Ctx) ||
1421 TQ.isAddressSpaceSupersetOf(Q, Ctx);
1422 }
1423
1424 /// Returns gc attribute of this type.
1425 inline Qualifiers::GC getObjCGCAttr() const;
1426
1427 /// true when Type is objc's weak.
1428 bool isObjCGCWeak() const {
1429 return getObjCGCAttr() == Qualifiers::Weak;
1430 }
1431
1432 /// true when Type is objc's strong.
1433 bool isObjCGCStrong() const {
1435 }
1436
1437 /// Returns lifetime attribute of this type.
1441
1445
1449
1450 // true when Type is objc's weak and weak is enabled but ARC isn't.
1451 bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;
1452
1456
1458 if (PointerAuthQualifier PtrAuth = getPointerAuth())
1459 return PtrAuth.isAddressDiscriminated();
1460 return false;
1461 }
1462
1464 /// The type does not fall into any of the following categories. Note that
1465 /// this case is zero-valued so that values of this enum can be used as a
1466 /// boolean condition for non-triviality.
1468
1469 /// The type is an Objective-C retainable pointer type that is qualified
1470 /// with the ARC __strong qualifier.
1472
1473 /// The type is an Objective-C retainable pointer type that is qualified
1474 /// with the ARC __weak qualifier.
1476
1477 /// The type is a struct containing a field whose type is not PCK_Trivial.
1479 };
1480
1481 /// Functions to query basic properties of non-trivial C struct types.
1482
1483 /// Check if this is a non-trivial type that would cause a C struct
1484 /// transitively containing this type to be non-trivial to default initialize
1485 /// and return the kind.
1488
1490 /// The type does not fall into any of the following categories. Note that
1491 /// this case is zero-valued so that values of this enum can be used as a
1492 /// boolean condition for non-triviality.
1494
1495 /// The type would be trivial except that it is volatile-qualified. Types
1496 /// that fall into one of the other non-trivial cases may additionally be
1497 /// volatile-qualified.
1499
1500 /// The type is an Objective-C retainable pointer type that is qualified
1501 /// with the ARC __strong qualifier.
1503
1504 /// The type is an Objective-C retainable pointer type that is qualified
1505 /// with the ARC __weak qualifier.
1507
1508 /// The type is an address-discriminated signed pointer type.
1510
1511 /// The type is a struct containing a field whose type is neither
1512 /// PCK_Trivial nor PCK_VolatileTrivial.
1513 /// Note that a C++ struct type does not necessarily match this; C++ copying
1514 /// semantics are too complex to express here, in part because they depend
1515 /// on the exact constructor or assignment operator that is chosen by
1516 /// overload resolution to do the copy.
1518 };
1519
1520 /// Check if this is a non-trivial type that would cause a C struct
1521 /// transitively containing this type to be non-trivial to copy and return the
1522 /// kind.
1524
1525 /// Check if this is a non-trivial type that would cause a C struct
1526 /// transitively containing this type to be non-trivial to destructively
1527 /// move and return the kind. Destructive move in this context is a C++-style
1528 /// move in which the source object is placed in a valid but unspecified state
1529 /// after it is moved, as opposed to a truly destructive move in which the
1530 /// source object is placed in an uninitialized state.
1532
1540
1541 /// Returns a nonzero value if objects of this type require
1542 /// non-trivial work to clean up after. Non-zero because it's
1543 /// conceivable that qualifiers (objc_gc(weak)?) could make
1544 /// something require destruction.
1546 return isDestructedTypeImpl(*this);
1547 }
1548
1549 /// Check if this is or contains a C union that is non-trivial to
1550 /// default-initialize, which is a union that has a member that is non-trivial
1551 /// to default-initialize. If this returns true,
1552 /// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
1554
1555 /// Check if this is or contains a C union that is non-trivial to destruct,
1556 /// which is a union that has a member that is non-trivial to destruct. If
1557 /// this returns true, isDestructedType returns DK_nontrivial_c_struct.
1559
1560 /// Check if this is or contains a C union that is non-trivial to copy, which
1561 /// is a union that has a member that is non-trivial to copy. If this returns
1562 /// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
1564
1565 /// Determine whether expressions of the given type are forbidden
1566 /// from being lvalues in C.
1567 ///
1568 /// The expression types that are forbidden to be lvalues are:
1569 /// - 'void', but not qualified void
1570 /// - function types
1571 ///
1572 /// The exact rule here is C99 6.3.2.1:
1573 /// An lvalue is an expression with an object type or an incomplete
1574 /// type other than void.
1575 bool isCForbiddenLValueType() const;
1576
1577 /// Substitute type arguments for the Objective-C type parameters used in the
1578 /// subject type.
1579 ///
1580 /// \param ctx ASTContext in which the type exists.
1581 ///
1582 /// \param typeArgs The type arguments that will be substituted for the
1583 /// Objective-C type parameters in the subject type, which are generally
1584 /// computed via \c Type::getObjCSubstitutions. If empty, the type
1585 /// parameters will be replaced with their bounds or id/Class, as appropriate
1586 /// for the context.
1587 ///
1588 /// \param context The context in which the subject type was written.
1589 ///
1590 /// \returns the resulting type.
1592 ArrayRef<QualType> typeArgs,
1593 ObjCSubstitutionContext context) const;
1594
1595 /// Substitute type arguments from an object type for the Objective-C type
1596 /// parameters used in the subject type.
1597 ///
1598 /// This operation combines the computation of type arguments for
1599 /// substitution (\c Type::getObjCSubstitutions) with the actual process of
1600 /// substitution (\c QualType::substObjCTypeArgs) for the convenience of
1601 /// callers that need to perform a single substitution in isolation.
1602 ///
1603 /// \param objectType The type of the object whose member type we're
1604 /// substituting into. For example, this might be the receiver of a message
1605 /// or the base of a property access.
1606 ///
1607 /// \param dc The declaration context from which the subject type was
1608 /// retrieved, which indicates (for example) which type parameters should
1609 /// be substituted.
1610 ///
1611 /// \param context The context in which the subject type was written.
1612 ///
1613 /// \returns the subject type after replacing all of the Objective-C type
1614 /// parameters with their corresponding arguments.
1616 const DeclContext *dc,
1617 ObjCSubstitutionContext context) const;
1618
1619 /// Strip Objective-C "__kindof" types from the given type.
1620 QualType stripObjCKindOfType(const ASTContext &ctx) const;
1621
1622 /// Remove all qualifiers including _Atomic.
1623 ///
1624 /// Like getUnqualifiedType(), the type may still be qualified if it is a
1625 /// sugared array type. To strip qualifiers even from within a sugared array
1626 /// type, use in conjunction with ASTContext::getUnqualifiedArrayType.
1628
1629private:
1630 // These methods are implemented in a separate translation unit;
1631 // "static"-ize them to avoid creating temporary QualTypes in the
1632 // caller.
1633 static bool isConstant(QualType T, const ASTContext& Ctx);
1634 static QualType getDesugaredType(QualType T, const ASTContext &Context);
1636 static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
1637 static QualType getSingleStepDesugaredTypeImpl(QualType type,
1638 const ASTContext &C);
1640 static DestructionKind isDestructedTypeImpl(QualType type);
1641
1642 /// Check if \param RD is or contains a non-trivial C union.
1645 static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1646};
1647
1648raw_ostream &operator<<(raw_ostream &OS, QualType QT);
1649
1650} // namespace clang
1651
1652namespace llvm {
1653
1654/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1655/// to a specific Type class.
1656template<> struct simplify_type< ::clang::QualType> {
1657 using SimpleType = const ::clang::Type *;
1658
1660 return Val.getTypePtr();
1661 }
1662};
1663
1664// Teach SmallPtrSet that QualType is "basically a pointer".
1665template<>
1666struct PointerLikeTypeTraits<clang::QualType> {
1667 static inline void *getAsVoidPointer(clang::QualType P) {
1668 return P.getAsOpaquePtr();
1669 }
1670
1671 static inline clang::QualType getFromVoidPointer(void *P) {
1673 }
1674
1675 // Various qualifiers go in low bits.
1676 static constexpr int NumLowBitsAvailable = 0;
1677};
1678
1679} // namespace llvm
1680
1681namespace clang {
1682
1683/// Base class that is common to both the \c ExtQuals and \c Type
1684/// classes, which allows \c QualType to access the common fields between the
1685/// two.
1686class ExtQualsTypeCommonBase {
1687 friend class ExtQuals;
1688 friend class QualType;
1689 friend class Type;
1690 friend class ASTReader;
1691
1692 /// The "base" type of an extended qualifiers type (\c ExtQuals) or
1693 /// a self-referential pointer (for \c Type).
1694 ///
1695 /// This pointer allows an efficient mapping from a QualType to its
1696 /// underlying type pointer.
1697 const Type *const BaseType;
1698
1699 /// The canonical type of this type. A QualType.
1700 QualType CanonicalType;
1701
1702 ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
1703 : BaseType(baseType), CanonicalType(canon) {}
1704};
1705
1706/// We can encode up to four bits in the low bits of a
1707/// type pointer, but there are many more type qualifiers that we want
1708/// to be able to apply to an arbitrary type. Therefore we have this
1709/// struct, intended to be heap-allocated and used by QualType to
1710/// store qualifiers.
1711///
1712/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1713/// in three low bits on the QualType pointer; a fourth bit records whether
1714/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1715/// Objective-C GC attributes) are much more rare.
1716class alignas(TypeAlignment) ExtQuals : public ExtQualsTypeCommonBase,
1717 public llvm::FoldingSetNode {
1718 // NOTE: changing the fast qualifiers should be straightforward as
1719 // long as you don't make 'const' non-fast.
1720 // 1. Qualifiers:
1721 // a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
1722 // Fast qualifiers must occupy the low-order bits.
1723 // b) Update Qualifiers::FastWidth and FastMask.
1724 // 2. QualType:
1725 // a) Update is{Volatile,Restrict}Qualified(), defined inline.
1726 // b) Update remove{Volatile,Restrict}, defined near the end of
1727 // this header.
1728 // 3. ASTContext:
1729 // a) Update get{Volatile,Restrict}Type.
1730
1731 /// The immutable set of qualifiers applied by this node. Always contains
1732 /// extended qualifiers.
1733 Qualifiers Quals;
1734
1735 ExtQuals *this_() { return this; }
1736
1737public:
1738 ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
1739 : ExtQualsTypeCommonBase(baseType,
1740 canon.isNull() ? QualType(this_(), 0) : canon),
1741 Quals(quals) {
1742 assert(Quals.hasNonFastQualifiers()
1743 && "ExtQuals created with no fast qualifiers");
1744 assert(!Quals.hasFastQualifiers()
1745 && "ExtQuals created with fast qualifiers");
1746 }
1747
1748 Qualifiers getQualifiers() const { return Quals; }
1749
1750 bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
1751 Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }
1752
1753 bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
1755 return Quals.getObjCLifetime();
1756 }
1757
1758 bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
1759 LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
1760
1761 const Type *getBaseType() const { return BaseType; }
1762
1763public:
1764 void Profile(llvm::FoldingSetNodeID &ID) const {
1765 Profile(ID, getBaseType(), Quals);
1766 }
1767
1768 static void Profile(llvm::FoldingSetNodeID &ID,
1769 const Type *BaseType,
1770 Qualifiers Quals) {
1771 assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!");
1772 ID.AddPointer(BaseType);
1773 Quals.Profile(ID);
1774 }
1775};
1776
1777/// The kind of C++11 ref-qualifier associated with a function type.
1778/// This determines whether a member function's "this" object can be an
1779/// lvalue, rvalue, or neither.
1781 /// No ref-qualifier was provided.
1783
1784 /// An lvalue ref-qualifier was provided (\c &).
1786
1787 /// An rvalue ref-qualifier was provided (\c &&).
1789};
1790
1791/// Which keyword(s) were used to create an AutoType.
1793 /// auto
1795
1796 /// decltype(auto)
1798
1799 /// __auto_type (GNU extension)
1801};
1802
1803enum class ArraySizeModifier;
1804enum class ElaboratedTypeKeyword;
1805enum class VectorKind;
1806
1807/// The base class of the type hierarchy.
1808///
1809/// A central concept with types is that each type always has a canonical
1810/// type. A canonical type is the type with any typedef names stripped out
1811/// of it or the types it references. For example, consider:
1812///
1813/// typedef int foo;
1814/// typedef foo* bar;
1815/// 'int *' 'foo *' 'bar'
1816///
1817/// There will be a Type object created for 'int'. Since int is canonical, its
1818/// CanonicalType pointer points to itself. There is also a Type for 'foo' (a
1819/// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next
1820/// there is a PointerType that represents 'int*', which, like 'int', is
1821/// canonical. Finally, there is a PointerType type for 'foo*' whose canonical
1822/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1823/// is also 'int*'.
1824///
1825/// Non-canonical types are useful for emitting diagnostics, without losing
1826/// information about typedefs being used. Canonical types are useful for type
1827/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1828/// about whether something has a particular form (e.g. is a function type),
1829/// because they implicitly, recursively, strip all typedefs out of a type.
1830///
1831/// Types, once created, are immutable.
1832///
1833class alignas(TypeAlignment) Type : public ExtQualsTypeCommonBase {
1834public:
1836#define TYPE(Class, Base) Class,
1837#define LAST_TYPE(Class) TypeLast = Class
1838#define ABSTRACT_TYPE(Class, Base)
1839#include "clang/AST/TypeNodes.inc"
1840 };
1841
1842private:
1843 /// Bitfields required by the Type class.
1844 class TypeBitfields {
1845 friend class Type;
1846 template <class T> friend class TypePropertyCache;
1847
1848 /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
1849 LLVM_PREFERRED_TYPE(TypeClass)
1850 unsigned TC : 8;
1851
1852 /// Store information on the type dependency.
1853 LLVM_PREFERRED_TYPE(TypeDependence)
1854 unsigned Dependence : llvm::BitWidth<TypeDependence>;
1855
1856 /// True if the cache (i.e. the bitfields here starting with
1857 /// 'Cache') is valid.
1858 LLVM_PREFERRED_TYPE(bool)
1859 mutable unsigned CacheValid : 1;
1860
1861 /// Linkage of this type.
1862 LLVM_PREFERRED_TYPE(Linkage)
1863 mutable unsigned CachedLinkage : 3;
1864
1865 /// Whether this type involves and local or unnamed types.
1866 LLVM_PREFERRED_TYPE(bool)
1867 mutable unsigned CachedLocalOrUnnamed : 1;
1868
1869 /// Whether this type comes from an AST file.
1870 LLVM_PREFERRED_TYPE(bool)
1871 mutable unsigned FromAST : 1;
1872
1873 bool isCacheValid() const {
1874 return CacheValid;
1875 }
1876
1877 Linkage getLinkage() const {
1878 assert(isCacheValid() && "getting linkage from invalid cache");
1879 return static_cast<Linkage>(CachedLinkage);
1880 }
1881
1882 bool hasLocalOrUnnamedType() const {
1883 assert(isCacheValid() && "getting linkage from invalid cache");
1884 return CachedLocalOrUnnamed;
1885 }
1886 };
1887 enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1888
1889protected:
1890 // These classes allow subclasses to somewhat cleanly pack bitfields
1891 // into Type.
1892
1894 friend class ArrayType;
1895
1896 LLVM_PREFERRED_TYPE(TypeBitfields)
1897 unsigned : NumTypeBits;
1898
1899 /// CVR qualifiers from declarations like
1900 /// 'int X[static restrict 4]'. For function parameters only.
1901 LLVM_PREFERRED_TYPE(Qualifiers)
1902 unsigned IndexTypeQuals : 3;
1903
1904 /// Storage class qualifiers from declarations like
1905 /// 'int X[static restrict 4]'. For function parameters only.
1906 LLVM_PREFERRED_TYPE(ArraySizeModifier)
1907 unsigned SizeModifier : 3;
1908 };
1909 enum { NumArrayTypeBits = NumTypeBits + 6 };
1910
1912 friend class ConstantArrayType;
1913
1914 LLVM_PREFERRED_TYPE(ArrayTypeBitfields)
1916
1917 /// Whether we have a stored size expression.
1918 LLVM_PREFERRED_TYPE(bool)
1919 unsigned HasExternalSize : 1;
1920
1921 LLVM_PREFERRED_TYPE(unsigned)
1922 unsigned SizeWidth : 5;
1923 };
1924
1926 friend class BuiltinType;
1927
1928 LLVM_PREFERRED_TYPE(TypeBitfields)
1929 unsigned : NumTypeBits;
1930
1931 /// The kind (BuiltinType::Kind) of builtin type this is.
1932 static constexpr unsigned NumOfBuiltinTypeBits = 9;
1933 unsigned Kind : NumOfBuiltinTypeBits;
1934 };
1935
1936public:
1937 static constexpr int FunctionTypeNumParamsWidth = 16;
1938 static constexpr int FunctionTypeNumParamsLimit = (1 << 16) - 1;
1939
1940protected:
1941 /// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
1942 /// Only common bits are stored here. Additional uncommon bits are stored
1943 /// in a trailing object after FunctionProtoType.
1945 friend class FunctionProtoType;
1946 friend class FunctionType;
1947
1948 LLVM_PREFERRED_TYPE(TypeBitfields)
1949 unsigned : NumTypeBits;
1950
1951 /// The ref-qualifier associated with a \c FunctionProtoType.
1952 ///
1953 /// This is a value of type \c RefQualifierKind.
1954 LLVM_PREFERRED_TYPE(RefQualifierKind)
1955 unsigned RefQualifier : 2;
1956
1957 /// Used only by FunctionProtoType, put here to pack with the
1958 /// other bitfields.
1959 /// The qualifiers are part of FunctionProtoType because...
1960 ///
1961 /// C++ 8.3.5p4: The return type, the parameter type list and the
1962 /// cv-qualifier-seq, [...], are part of the function type.
1963 LLVM_PREFERRED_TYPE(Qualifiers)
1964 unsigned FastTypeQuals : Qualifiers::FastWidth;
1965 /// Whether this function has extended Qualifiers.
1966 LLVM_PREFERRED_TYPE(bool)
1967 unsigned HasExtQuals : 1;
1968
1969 /// The type of exception specification this function has.
1970 LLVM_PREFERRED_TYPE(ExceptionSpecificationType)
1971 unsigned ExceptionSpecType : 4;
1972
1973 /// Whether this function has extended parameter information.
1974 LLVM_PREFERRED_TYPE(bool)
1975 unsigned HasExtParameterInfos : 1;
1976
1977 /// Whether this function has extra bitfields for the prototype.
1978 LLVM_PREFERRED_TYPE(bool)
1979 unsigned HasExtraBitfields : 1;
1980
1981 /// Whether the function is variadic.
1982 LLVM_PREFERRED_TYPE(bool)
1983 unsigned Variadic : 1;
1984
1985 /// Whether this function has a trailing return type.
1986 LLVM_PREFERRED_TYPE(bool)
1987 unsigned HasTrailingReturn : 1;
1988
1989 /// Whether this function has is a cfi unchecked callee.
1990 LLVM_PREFERRED_TYPE(bool)
1991 unsigned CFIUncheckedCallee : 1;
1992
1993 /// Extra information which affects how the function is called, like
1994 /// regparm and the calling convention.
1995 LLVM_PREFERRED_TYPE(CallingConv)
1996 unsigned ExtInfo : 14;
1997
1998 /// The number of parameters this function has, not counting '...'.
1999 /// According to [implimits] 8 bits should be enough here but this is
2000 /// somewhat easy to exceed with metaprogramming and so we would like to
2001 /// keep NumParams as wide as reasonably possible.
2002 unsigned NumParams : FunctionTypeNumParamsWidth;
2003 };
2004
2006 friend class ObjCObjectType;
2007
2008 LLVM_PREFERRED_TYPE(TypeBitfields)
2009 unsigned : NumTypeBits;
2010
2011 /// The number of type arguments stored directly on this object type.
2012 unsigned NumTypeArgs : 7;
2013
2014 /// The number of protocols stored directly on this object type.
2015 unsigned NumProtocols : 6;
2016
2017 /// Whether this is a "kindof" type.
2018 LLVM_PREFERRED_TYPE(bool)
2019 unsigned IsKindOf : 1;
2020 };
2021
2023 friend class ReferenceType;
2024
2025 LLVM_PREFERRED_TYPE(TypeBitfields)
2026 unsigned : NumTypeBits;
2027
2028 /// True if the type was originally spelled with an lvalue sigil.
2029 /// This is never true of rvalue references but can also be false
2030 /// on lvalue references because of C++0x [dcl.typedef]p9,
2031 /// as follows:
2032 ///
2033 /// typedef int &ref; // lvalue, spelled lvalue
2034 /// typedef int &&rvref; // rvalue
2035 /// ref &a; // lvalue, inner ref, spelled lvalue
2036 /// ref &&a; // lvalue, inner ref
2037 /// rvref &a; // lvalue, inner ref, spelled lvalue
2038 /// rvref &&a; // rvalue, inner ref
2039 LLVM_PREFERRED_TYPE(bool)
2040 unsigned SpelledAsLValue : 1;
2041
2042 /// True if the inner type is a reference type. This only happens
2043 /// in non-canonical forms.
2044 LLVM_PREFERRED_TYPE(bool)
2045 unsigned InnerRef : 1;
2046 };
2047
2049 template <class> friend class KeywordWrapper;
2050
2051 LLVM_PREFERRED_TYPE(TypeBitfields)
2052 unsigned : NumTypeBits;
2053
2054 /// An ElaboratedTypeKeyword. 8 bits for efficient access.
2055 LLVM_PREFERRED_TYPE(ElaboratedTypeKeyword)
2056 unsigned Keyword : 8;
2057 };
2058
2059 enum { NumTypeWithKeywordBits = NumTypeBits + 8 };
2060
2062 friend class TagType;
2063
2064 LLVM_PREFERRED_TYPE(KeywordWrapperBitfields)
2066
2067 /// Whether the TagType has a trailing Qualifier.
2068 LLVM_PREFERRED_TYPE(bool)
2069 unsigned HasQualifier : 1;
2070
2071 /// Whether the TagType owns the Tag.
2072 LLVM_PREFERRED_TYPE(bool)
2073 unsigned OwnsTag : 1;
2074
2075 /// Whether the TagType was created from an injected name.
2076 LLVM_PREFERRED_TYPE(bool)
2077 unsigned IsInjected : 1;
2078 };
2079
2081 friend class VectorType;
2083
2084 LLVM_PREFERRED_TYPE(TypeBitfields)
2085 unsigned : NumTypeBits;
2086
2087 /// The kind of vector, either a generic vector type or some
2088 /// target-specific vector type such as for AltiVec or Neon.
2089 LLVM_PREFERRED_TYPE(VectorKind)
2090 unsigned VecKind : 4;
2091 /// The number of elements in the vector.
2092 uint32_t NumElements;
2093 };
2094
2096 friend class AttributedType;
2097
2098 LLVM_PREFERRED_TYPE(TypeBitfields)
2099 unsigned : NumTypeBits;
2100
2101 LLVM_PREFERRED_TYPE(attr::Kind)
2102 unsigned AttrKind : 32 - NumTypeBits;
2103 };
2104
2106 friend class AutoType;
2107
2108 LLVM_PREFERRED_TYPE(TypeBitfields)
2109 unsigned : NumTypeBits;
2110
2111 /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
2112 /// or '__auto_type'? AutoTypeKeyword value.
2113 LLVM_PREFERRED_TYPE(AutoTypeKeyword)
2114 unsigned Keyword : 2;
2115
2116 /// The number of template arguments in the type-constraints, which is
2117 /// expected to be able to hold at least 1024 according to [implimits].
2118 /// However as this limit is somewhat easy to hit with template
2119 /// metaprogramming we'd prefer to keep it as large as possible.
2120 /// At the moment it has been left as a non-bitfield since this type
2121 /// safely fits in 64 bits as an unsigned, so there is no reason to
2122 /// introduce the performance impact of a bitfield.
2123 unsigned NumArgs;
2124 };
2125
2127 friend class TypeOfType;
2128 friend class TypeOfExprType;
2129
2130 LLVM_PREFERRED_TYPE(TypeBitfields)
2131 unsigned : NumTypeBits;
2132 LLVM_PREFERRED_TYPE(TypeOfKind)
2133 unsigned Kind : 1;
2134 };
2135
2138
2139 LLVM_PREFERRED_TYPE(KeywordWrapperBitfields)
2141
2142 /// True if there is a non-null qualifier.
2143 LLVM_PREFERRED_TYPE(bool)
2144 unsigned hasQualifier : 1;
2145 };
2146
2148 friend class UsingType;
2149
2150 LLVM_PREFERRED_TYPE(KeywordWrapperBitfields)
2152
2153 /// True if there is a non-null qualifier.
2154 LLVM_PREFERRED_TYPE(bool)
2155 unsigned hasQualifier : 1;
2156 };
2157
2159 friend class TypedefType;
2160
2161 LLVM_PREFERRED_TYPE(KeywordWrapperBitfields)
2163
2164 /// True if there is a non-null qualifier.
2165 LLVM_PREFERRED_TYPE(bool)
2166 unsigned hasQualifier : 1;
2167
2168 /// True if the underlying type is different from the declared one.
2169 LLVM_PREFERRED_TYPE(bool)
2170 unsigned hasTypeDifferentFromDecl : 1;
2171 };
2172
2175
2176 LLVM_PREFERRED_TYPE(TypeBitfields)
2177 unsigned : NumTypeBits;
2178
2179 /// The depth of the template parameter.
2180 unsigned Depth : 15;
2181
2182 /// Whether this is a template parameter pack.
2183 LLVM_PREFERRED_TYPE(bool)
2184 unsigned ParameterPack : 1;
2185
2186 /// The index of the template parameter.
2187 unsigned Index : 16;
2188 };
2189
2192
2193 LLVM_PREFERRED_TYPE(TypeBitfields)
2194 unsigned : NumTypeBits;
2195
2196 LLVM_PREFERRED_TYPE(bool)
2197 unsigned HasNonCanonicalUnderlyingType : 1;
2198
2199 // The index of the template parameter this substitution represents.
2200 unsigned Index : 15;
2201
2202 LLVM_PREFERRED_TYPE(bool)
2203 unsigned Final : 1;
2204
2205 /// Represents the index within a pack if this represents a substitution
2206 /// from a pack expansion. This index starts at the end of the pack and
2207 /// increments towards the beginning.
2208 /// Positive non-zero number represents the index + 1.
2209 /// Zero means this is not substituted from an expansion.
2210 unsigned PackIndex : 15;
2211 };
2212
2214 friend class SubstPackType;
2216
2217 LLVM_PREFERRED_TYPE(TypeBitfields)
2218 unsigned : NumTypeBits;
2219
2220 /// The number of template arguments in \c Arguments, which is
2221 /// expected to be able to hold at least 1024 according to [implimits].
2222 /// However as this limit is somewhat easy to hit with template
2223 /// metaprogramming we'd prefer to keep it as large as possible.
2224 unsigned NumArgs : 16;
2225
2226 // The index of the template parameter this substitution represents.
2227 // Only used by SubstTemplateTypeParmPackType. We keep it in the same
2228 // class to avoid dealing with complexities of bitfields that go over
2229 // the size of `unsigned`.
2230 unsigned SubstTemplTypeParmPackIndex : 16;
2231 };
2232
2235
2236 LLVM_PREFERRED_TYPE(KeywordWrapperBitfields)
2238
2239 /// Whether this template specialization type is a substituted type alias.
2240 LLVM_PREFERRED_TYPE(bool)
2241 unsigned TypeAlias : 1;
2242
2243 /// The number of template arguments named in this class template
2244 /// specialization, which is expected to be able to hold at least 1024
2245 /// according to [implimits]. However, as this limit is somewhat easy to
2246 /// hit with template metaprogramming we'd prefer to keep it as large
2247 /// as possible. At the moment it has been left as a non-bitfield since
2248 /// this type safely fits in 64 bits as an unsigned, so there is no reason
2249 /// to introduce the performance impact of a bitfield.
2250 unsigned NumArgs;
2251 };
2252
2254 friend class PackExpansionType;
2255
2256 LLVM_PREFERRED_TYPE(TypeBitfields)
2257 unsigned : NumTypeBits;
2258
2259 /// The number of expansions that this pack expansion will
2260 /// generate when substituted (+1), which is expected to be able to
2261 /// hold at least 1024 according to [implimits]. However, as this limit
2262 /// is somewhat easy to hit with template metaprogramming we'd prefer to
2263 /// keep it as large as possible. At the moment it has been left as a
2264 /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
2265 /// there is no reason to introduce the performance impact of a bitfield.
2266 ///
2267 /// This field will only have a non-zero value when some of the parameter
2268 /// packs that occur within the pattern have been substituted but others
2269 /// have not.
2270 unsigned NumExpansions;
2271 };
2272
2274 /// The "size_t" type.
2276
2277 /// The signed integer type corresponding to "size_t".
2279
2280 /// The "ptrdiff_t" type.
2282
2283 // Indicates how many items the enum has.
2285 };
2286
2289
2290 LLVM_PREFERRED_TYPE(TypeBitfields)
2291 unsigned : NumTypeBits;
2292
2293 LLVM_PREFERRED_TYPE(PredefinedSugarKind)
2294 unsigned Kind : 8;
2295 };
2296
2299
2300 LLVM_PREFERRED_TYPE(TypeBitfields)
2301 unsigned : NumTypeBits;
2302
2303 static constexpr unsigned NumCoupledDeclsBits = 4;
2304 unsigned NumCoupledDecls : NumCoupledDeclsBits;
2305 LLVM_PREFERRED_TYPE(bool)
2306 unsigned CountInBytes : 1;
2307 LLVM_PREFERRED_TYPE(bool)
2308 unsigned OrNull : 1;
2309 };
2310 static_assert(sizeof(CountAttributedTypeBitfields) <= sizeof(unsigned));
2311
2312 union {
2313 TypeBitfields TypeBits;
2336 };
2337
2338private:
2339 template <class T> friend class TypePropertyCache;
2340
2341 /// Set whether this type comes from an AST file.
2342 void setFromAST(bool V = true) const {
2343 TypeBits.FromAST = V;
2344 }
2345
2346protected:
2347 friend class ASTContext;
2348
2350 : ExtQualsTypeCommonBase(this,
2351 canon.isNull() ? QualType(this_(), 0) : canon) {
2352 static_assert(sizeof(*this) <=
2353 alignof(decltype(*this)) + sizeof(ExtQualsTypeCommonBase),
2354 "changing bitfields changed sizeof(Type)!");
2355 static_assert(alignof(decltype(*this)) % TypeAlignment == 0,
2356 "Insufficient alignment!");
2357 TypeBits.TC = tc;
2358 TypeBits.Dependence = static_cast<unsigned>(Dependence);
2359 TypeBits.CacheValid = false;
2360 TypeBits.CachedLocalOrUnnamed = false;
2361 TypeBits.CachedLinkage = llvm::to_underlying(Linkage::Invalid);
2362 TypeBits.FromAST = false;
2363 }
2364
2365 // silence VC++ warning C4355: 'this' : used in base member initializer list
2366 Type *this_() { return this; }
2367
2369 TypeBits.Dependence = static_cast<unsigned>(D);
2370 }
2371
2373
2374public:
2375 friend class ASTReader;
2376 friend class ASTWriter;
2377 template <class T> friend class serialization::AbstractTypeReader;
2378 template <class T> friend class serialization::AbstractTypeWriter;
2379
2380 Type(const Type &) = delete;
2381 Type(Type &&) = delete;
2382 Type &operator=(const Type &) = delete;
2383 Type &operator=(Type &&) = delete;
2384
2385 TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
2386
2387 /// Whether this type comes from an AST file.
2388 bool isFromAST() const { return TypeBits.FromAST; }
2389
2390 /// Whether this type is or contains an unexpanded parameter
2391 /// pack, used to support C++0x variadic templates.
2392 ///
2393 /// A type that contains a parameter pack shall be expanded by the
2394 /// ellipsis operator at some point. For example, the typedef in the
2395 /// following example contains an unexpanded parameter pack 'T':
2396 ///
2397 /// \code
2398 /// template<typename ...T>
2399 /// struct X {
2400 /// typedef T* pointer_types; // ill-formed; T is a parameter pack.
2401 /// };
2402 /// \endcode
2403 ///
2404 /// Note that this routine does not specify which
2406 return getDependence() & TypeDependence::UnexpandedPack;
2407 }
2408
2409 /// Determines if this type would be canonical if it had no further
2410 /// qualification.
2412 return CanonicalType == QualType(this, 0);
2413 }
2414
2415 /// Pull a single level of sugar off of this locally-unqualified type.
2416 /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
2417 /// or QualType::getSingleStepDesugaredType(const ASTContext&).
2418 QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
2419
2420 /// As an extension, we classify types as one of "sized" or "sizeless";
2421 /// every type is one or the other. Standard types are all sized;
2422 /// sizeless types are purely an extension.
2423 ///
2424 /// Sizeless types contain data with no specified size, alignment,
2425 /// or layout.
2426 bool isSizelessType() const;
2427 bool isSizelessBuiltinType() const;
2428
2429 /// Returns true for all scalable vector types.
2430 bool isSizelessVectorType() const;
2431
2432 /// Returns true for SVE scalable vector types.
2433 bool isSVESizelessBuiltinType() const;
2434
2435 /// Returns true for RVV scalable vector types.
2436 bool isRVVSizelessBuiltinType() const;
2437
2438 /// Check if this is a WebAssembly Externref Type.
2439 bool isWebAssemblyExternrefType() const;
2440
2441 /// Returns true if this is a WebAssembly table type: either an array of
2442 /// reference types, or a pointer to a reference type (which can only be
2443 /// created by array to pointer decay).
2444 bool isWebAssemblyTableType() const;
2445
2446 /// Determines if this is a sizeless type supported by the
2447 /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
2448 /// SVE vector or predicate, excluding tuple types such as svint32x4_t.
2449 bool isSveVLSBuiltinType() const;
2450
2451 /// Returns the representative type for the element of an SVE builtin type.
2452 /// This is used to represent fixed-length SVE vectors created with the
2453 /// 'arm_sve_vector_bits' type attribute as VectorType.
2454 QualType getSveEltType(const ASTContext &Ctx) const;
2455
2456 /// Determines if this is a sizeless type supported by the
2457 /// 'riscv_rvv_vector_bits' type attribute, which can be applied to a single
2458 /// RVV vector or mask.
2459 bool isRVVVLSBuiltinType() const;
2460
2461 /// Returns the representative type for the element of an RVV builtin type.
2462 /// This is used to represent fixed-length RVV vectors created with the
2463 /// 'riscv_rvv_vector_bits' type attribute as VectorType.
2464 QualType getRVVEltType(const ASTContext &Ctx) const;
2465
2466 /// Returns the representative type for the element of a sizeless vector
2467 /// builtin type.
2468 QualType getSizelessVectorEltType(const ASTContext &Ctx) const;
2469
2470 /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
2471 /// object types, function types, and incomplete types.
2472
2473 /// Return true if this is an incomplete type.
2474 /// A type that can describe objects, but which lacks information needed to
2475 /// determine its size (e.g. void, or a fwd declared struct). Clients of this
2476 /// routine will need to determine if the size is actually required.
2477 ///
2478 /// Def If non-null, and the type refers to some kind of declaration
2479 /// that can be completed (such as a C struct, C++ class, or Objective-C
2480 /// class), will be set to the declaration.
2481 bool isIncompleteType(NamedDecl **Def = nullptr) const;
2482
2483 /// Return true if this is an incomplete or object
2484 /// type, in other words, not a function type.
2486 return !isFunctionType();
2487 }
2488
2489 /// \returns True if the type is incomplete and it is also a type that
2490 /// cannot be completed by a later type definition.
2491 ///
2492 /// E.g. For `void` this is true but for `struct ForwardDecl;` this is false
2493 /// because a definition for `ForwardDecl` could be provided later on in the
2494 /// translation unit.
2495 ///
2496 /// Note even for types that this function returns true for it is still
2497 /// possible for the declarations that contain this type to later have a
2498 /// complete type in a translation unit. E.g.:
2499 ///
2500 /// \code{.c}
2501 /// // This decl has type 'char[]' which is incomplete and cannot be later
2502 /// // completed by another by another type declaration.
2503 /// extern char foo[];
2504 /// // This decl now has complete type 'char[5]'.
2505 /// char foo[5]; // foo has a complete type
2506 /// \endcode
2507 bool isAlwaysIncompleteType() const;
2508
2509 /// Determine whether this type is an object type.
2510 bool isObjectType() const {
2511 // C++ [basic.types]p8:
2512 // An object type is a (possibly cv-qualified) type that is not a
2513 // function type, not a reference type, and not a void type.
2514 return !isReferenceType() && !isFunctionType() && !isVoidType();
2515 }
2516
2517 /// Return true if this is a literal type
2518 /// (C++11 [basic.types]p10)
2519 bool isLiteralType(const ASTContext &Ctx) const;
2520
2521 /// Determine if this type is a structural type, per C++20 [temp.param]p7.
2522 bool isStructuralType() const;
2523
2524 /// Test if this type is a standard-layout type.
2525 /// (C++0x [basic.type]p9)
2526 bool isStandardLayoutType() const;
2527
2528 /// Helper methods to distinguish type categories. All type predicates
2529 /// operate on the canonical type, ignoring typedefs and qualifiers.
2530
2531 /// Returns true if the type is a builtin type.
2532 bool isBuiltinType() const;
2533
2534 /// Test for a particular builtin type.
2535 bool isSpecificBuiltinType(unsigned K) const;
2536
2537 /// Test for a type which does not represent an actual type-system type but
2538 /// is instead used as a placeholder for various convenient purposes within
2539 /// Clang. All such types are BuiltinTypes.
2540 bool isPlaceholderType() const;
2541 const BuiltinType *getAsPlaceholderType() const;
2542
2543 /// Test for a specific placeholder type.
2544 bool isSpecificPlaceholderType(unsigned K) const;
2545
2546 /// Test for a placeholder type other than Overload; see
2547 /// BuiltinType::isNonOverloadPlaceholderType.
2548 bool isNonOverloadPlaceholderType() const;
2549
2550 /// isIntegerType() does *not* include complex integers (a GCC extension).
2551 /// isComplexIntegerType() can be used to test for complex integers.
2552 bool isIntegerType() const; // C99 6.2.5p17 (int, char, bool, enum)
2553 bool isEnumeralType() const;
2554
2555 /// Determine whether this type is a scoped enumeration type.
2556 bool isScopedEnumeralType() const;
2557 bool isBooleanType() const;
2558 bool isCharType() const;
2559 bool isWideCharType() const;
2560 bool isChar8Type() const;
2561 bool isChar16Type() const;
2562 bool isChar32Type() const;
2563 bool isAnyCharacterType() const;
2564 bool isUnicodeCharacterType() const;
2565 bool isIntegralType(const ASTContext &Ctx) const;
2566
2567 /// Determine whether this type is an integral or enumeration type.
2568 bool isIntegralOrEnumerationType() const;
2569
2570 /// Determine whether this type is an integral or unscoped enumeration type.
2571 bool isIntegralOrUnscopedEnumerationType() const;
2572 bool isUnscopedEnumerationType() const;
2573
2574 /// Floating point categories.
2575 bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
2576 /// isComplexType() does *not* include complex integers (a GCC extension).
2577 /// isComplexIntegerType() can be used to test for complex integers.
2578 bool isComplexType() const; // C99 6.2.5p11 (complex)
2579 bool isAnyComplexType() const; // C99 6.2.5p11 (complex) + Complex Int.
2580 bool isFloatingType() const; // C99 6.2.5p11 (real floating + complex)
2581 bool isHalfType() const; // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
2582 bool isFloat16Type() const; // C11 extension ISO/IEC TS 18661
2583 bool isFloat32Type() const;
2584 bool isDoubleType() const;
2585 bool isBFloat16Type() const;
2586 bool isMFloat8Type() const;
2587 bool isFloat128Type() const;
2588 bool isIbm128Type() const;
2589 bool isRealType() const; // C99 6.2.5p17 (real floating + integer)
2590 bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating)
2591 bool isVoidType() const; // C99 6.2.5p19
2592 bool isScalarType() const; // C99 6.2.5p21 (arithmetic + pointers)
2593 bool isAggregateType() const;
2594 bool isFundamentalType() const;
2595 bool isCompoundType() const;
2596
2597 // Type Predicates: Check to see if this type is structurally the specified
2598 // type, ignoring typedefs and qualifiers.
2599 bool isFunctionType() const;
2602 bool isPointerType() const;
2603 bool isPointerOrReferenceType() const;
2604 bool isSignableType(const ASTContext &Ctx) const;
2605 bool isSignablePointerType() const;
2606 bool isSignableIntegerType(const ASTContext &Ctx) const;
2607 bool isAnyPointerType() const; // Any C pointer or ObjC object pointer
2608 bool isCountAttributedType() const;
2609 bool isCFIUncheckedCalleeFunctionType() const;
2610 bool hasPointeeToToCFIUncheckedCalleeFunctionType() const;
2611 bool isBlockPointerType() const;
2612 bool isVoidPointerType() const;
2613 bool isReferenceType() const;
2614 bool isLValueReferenceType() const;
2615 bool isRValueReferenceType() const;
2616 bool isObjectPointerType() const;
2617 bool isFunctionPointerType() const;
2618 bool isFunctionReferenceType() const;
2619 bool isMemberPointerType() const;
2620 bool isMemberFunctionPointerType() const;
2621 bool isMemberDataPointerType() const;
2622 bool isArrayType() const;
2623 bool isConstantArrayType() const;
2624 bool isIncompleteArrayType() const;
2625 bool isVariableArrayType() const;
2626 bool isArrayParameterType() const;
2627 bool isDependentSizedArrayType() const;
2628 bool isRecordType() const;
2629 bool isClassType() const;
2630 bool isStructureType() const;
2631 bool isStructureTypeWithFlexibleArrayMember() const;
2632 bool isObjCBoxableRecordType() const;
2633 bool isInterfaceType() const;
2634 bool isStructureOrClassType() const;
2635 bool isUnionType() const;
2636 bool isComplexIntegerType() const; // GCC _Complex integer type.
2637 bool isVectorType() const; // GCC vector type.
2638 bool isExtVectorType() const; // Extended vector type.
2639 bool isExtVectorBoolType() const; // Extended vector type with bool element.
2640 // Extended vector type with bool element that is packed. HLSL doesn't pack
2641 // its bool vectors.
2642 bool isPackedVectorBoolType(const ASTContext &ctx) const;
2643 bool isSubscriptableVectorType() const;
2644 bool isMatrixType() const; // Matrix type.
2645 bool isConstantMatrixType() const; // Constant matrix type.
2646 bool isDependentAddressSpaceType() const; // value-dependent address space qualifier
2647 bool isObjCObjectPointerType() const; // pointer to ObjC object
2648 bool isObjCRetainableType() const; // ObjC object or block pointer
2649 bool isObjCLifetimeType() const; // (array of)* retainable type
2650 bool isObjCIndirectLifetimeType() const; // (pointer to)* lifetime type
2651 bool isObjCNSObjectType() const; // __attribute__((NSObject))
2652 bool isObjCIndependentClassType() const; // __attribute__((objc_independent_class))
2653 // FIXME: change this to 'raw' interface type, so we can used 'interface' type
2654 // for the common case.
2655 bool isObjCObjectType() const; // NSString or typeof(*(id)0)
2656 bool isObjCQualifiedInterfaceType() const; // NSString<foo>
2657 bool isObjCQualifiedIdType() const; // id<foo>
2658 bool isObjCQualifiedClassType() const; // Class<foo>
2659 bool isObjCObjectOrInterfaceType() const;
2660 bool isObjCIdType() const; // id
2661 bool isDecltypeType() const;
2662 /// Was this type written with the special inert-in-ARC __unsafe_unretained
2663 /// qualifier?
2664 ///
2665 /// This approximates the answer to the following question: if this
2666 /// translation unit were compiled in ARC, would this type be qualified
2667 /// with __unsafe_unretained?
2669 return hasAttr(attr::ObjCInertUnsafeUnretained);
2670 }
2671
2672 /// Whether the type is Objective-C 'id' or a __kindof type of an
2673 /// object type, e.g., __kindof NSView * or __kindof id
2674 /// <NSCopying>.
2675 ///
2676 /// \param bound Will be set to the bound on non-id subtype types,
2677 /// which will be (possibly specialized) Objective-C class type, or
2678 /// null for 'id.
2679 bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
2680 const ObjCObjectType *&bound) const;
2681
2682 bool isObjCClassType() const; // Class
2683
2684 /// Whether the type is Objective-C 'Class' or a __kindof type of an
2685 /// Class type, e.g., __kindof Class <NSCopying>.
2686 ///
2687 /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
2688 /// here because Objective-C's type system cannot express "a class
2689 /// object for a subclass of NSFoo".
2690 bool isObjCClassOrClassKindOfType() const;
2691
2692 bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
2693 bool isObjCSelType() const; // Class
2694 bool isObjCBuiltinType() const; // 'id' or 'Class'
2695 bool isObjCARCBridgableType() const;
2696 bool isCARCBridgableType() const;
2697 bool isTemplateTypeParmType() const; // C++ template type parameter
2698 bool isNullPtrType() const; // C++11 std::nullptr_t or
2699 // C23 nullptr_t
2700 bool isNothrowT() const; // C++ std::nothrow_t
2701 bool isAlignValT() const; // C++17 std::align_val_t
2702 bool isStdByteType() const; // C++17 std::byte
2703 bool isAtomicType() const; // C11 _Atomic()
2704 bool isUndeducedAutoType() const; // C++11 auto or
2705 // C++14 decltype(auto)
2706 bool isTypedefNameType() const; // typedef or alias template
2707
2708#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2709 bool is##Id##Type() const;
2710#include "clang/Basic/OpenCLImageTypes.def"
2711
2712 bool isImageType() const; // Any OpenCL image type
2713
2714 bool isSamplerT() const; // OpenCL sampler_t
2715 bool isEventT() const; // OpenCL event_t
2716 bool isClkEventT() const; // OpenCL clk_event_t
2717 bool isQueueT() const; // OpenCL queue_t
2718 bool isReserveIDT() const; // OpenCL reserve_id_t
2719
2720#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2721 bool is##Id##Type() const;
2722#include "clang/Basic/OpenCLExtensionTypes.def"
2723 // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
2724 bool isOCLIntelSubgroupAVCType() const;
2725 bool isOCLExtOpaqueType() const; // Any OpenCL extension type
2726
2727 bool isPipeType() const; // OpenCL pipe type
2728 bool isBitIntType() const; // Bit-precise integer type
2729 bool isOpenCLSpecificType() const; // Any OpenCL specific type
2730
2731#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) bool is##Id##Type() const;
2732#include "clang/Basic/HLSLIntangibleTypes.def"
2733 bool isHLSLSpecificType() const; // Any HLSL specific type
2734 bool isHLSLBuiltinIntangibleType() const; // Any HLSL builtin intangible type
2735 bool isHLSLAttributedResourceType() const;
2736 bool isHLSLInlineSpirvType() const;
2737 bool isHLSLResourceRecord() const;
2738 bool isHLSLResourceRecordArray() const;
2739 bool isHLSLIntangibleType()
2740 const; // Any HLSL intangible type (builtin, array, class)
2741
2742 /// Determines if this type, which must satisfy
2743 /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
2744 /// than implicitly __strong.
2745 bool isObjCARCImplicitlyUnretainedType() const;
2746
2747 /// Check if the type is the CUDA device builtin surface type.
2748 bool isCUDADeviceBuiltinSurfaceType() const;
2749 /// Check if the type is the CUDA device builtin texture type.
2750 bool isCUDADeviceBuiltinTextureType() const;
2751
2752 /// Return the implicit lifetime for this type, which must not be dependent.
2753 Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;
2754
2767
2768 /// Given that this is a scalar type, classify it.
2769 ScalarTypeKind getScalarTypeKind() const;
2770
2772 return static_cast<TypeDependence>(TypeBits.Dependence);
2773 }
2774
2775 /// Whether this type is an error type.
2776 bool containsErrors() const {
2777 return getDependence() & TypeDependence::Error;
2778 }
2779
2780 /// Whether this type is a dependent type, meaning that its definition
2781 /// somehow depends on a template parameter (C++ [temp.dep.type]).
2782 bool isDependentType() const {
2783 return getDependence() & TypeDependence::Dependent;
2784 }
2785
2786 /// Determine whether this type is an instantiation-dependent type,
2787 /// meaning that the type involves a template parameter (even if the
2788 /// definition does not actually depend on the type substituted for that
2789 /// template parameter).
2791 return getDependence() & TypeDependence::Instantiation;
2792 }
2793
2794 /// Determine whether this type is an undeduced type, meaning that
2795 /// it somehow involves a C++11 'auto' type or similar which has not yet been
2796 /// deduced.
2797 bool isUndeducedType() const;
2798
2799 /// Whether this type is a variably-modified type (C99 6.7.5).
2801 return getDependence() & TypeDependence::VariablyModified;
2802 }
2803
2804 /// Whether this type involves a variable-length array type
2805 /// with a definite size.
2806 bool hasSizedVLAType() const;
2807
2808 /// Whether this type is or contains a local or unnamed type.
2809 bool hasUnnamedOrLocalType() const;
2810
2811 bool isOverloadableType() const;
2812
2813 /// Determine wither this type is a C++ elaborated-type-specifier.
2814 bool isElaboratedTypeSpecifier() const;
2815
2816 bool canDecayToPointerType() const;
2817
2818 /// Whether this type is represented natively as a pointer. This includes
2819 /// pointers, references, block pointers, and Objective-C interface,
2820 /// qualified id, and qualified interface types, as well as nullptr_t.
2821 bool hasPointerRepresentation() const;
2822
2823 /// Whether this type can represent an objective pointer type for the
2824 /// purpose of GC'ability
2825 bool hasObjCPointerRepresentation() const;
2826
2827 /// Determine whether this type has an integer representation
2828 /// of some sort, e.g., it is an integer type or a vector.
2829 bool hasIntegerRepresentation() const;
2830
2831 /// Determine whether this type has an signed integer representation
2832 /// of some sort, e.g., it is an signed integer type or a vector.
2833 bool hasSignedIntegerRepresentation() const;
2834
2835 /// Determine whether this type has an unsigned integer representation
2836 /// of some sort, e.g., it is an unsigned integer type or a vector.
2837 bool hasUnsignedIntegerRepresentation() const;
2838
2839 /// Determine whether this type has a floating-point representation
2840 /// of some sort, e.g., it is a floating-point type or a vector thereof.
2841 bool hasFloatingRepresentation() const;
2842
2843 /// Determine whether this type has a boolean representation -- i.e., it is a
2844 /// boolean type, an enum type whose underlying type is a boolean type, or a
2845 /// vector of booleans.
2846 bool hasBooleanRepresentation() const;
2847
2848 // Type Checking Functions: Check to see if this type is structurally the
2849 // specified type, ignoring typedefs and qualifiers, and return a pointer to
2850 // the best type we can.
2851 const RecordType *getAsStructureType() const;
2852 /// NOTE: getAs*ArrayType are methods on ASTContext.
2853 const RecordType *getAsUnionType() const;
2854 const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
2855 const ObjCObjectType *getAsObjCInterfaceType() const;
2856
2857 // The following is a convenience method that returns an ObjCObjectPointerType
2858 // for object declared using an interface.
2859 const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
2860 const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
2861 const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
2862 const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
2863
2864 /// Retrieves the CXXRecordDecl that this type refers to, either
2865 /// because the type is a RecordType or because it is the injected-class-name
2866 /// type of a class template or class template partial specialization.
2867 inline CXXRecordDecl *getAsCXXRecordDecl() const;
2868 inline CXXRecordDecl *castAsCXXRecordDecl() const;
2869
2870 /// Retrieves the RecordDecl this type refers to.
2871 inline RecordDecl *getAsRecordDecl() const;
2872 inline RecordDecl *castAsRecordDecl() const;
2873
2874 /// Retrieves the EnumDecl this type refers to.
2875 inline EnumDecl *getAsEnumDecl() const;
2876 inline EnumDecl *castAsEnumDecl() const;
2877
2878 /// Retrieves the TagDecl that this type refers to, either
2879 /// because the type is a TagType or because it is the injected-class-name
2880 /// type of a class template or class template partial specialization.
2881 inline TagDecl *getAsTagDecl() const;
2882 inline TagDecl *castAsTagDecl() const;
2883
2884 /// If this is a pointer or reference to a RecordType, return the
2885 /// CXXRecordDecl that the type refers to.
2886 ///
2887 /// If this is not a pointer or reference, or the type being pointed to does
2888 /// not refer to a CXXRecordDecl, returns NULL.
2889 const CXXRecordDecl *getPointeeCXXRecordDecl() const;
2890
2891 /// Get the DeducedType whose type will be deduced for a variable with
2892 /// an initializer of this type. This looks through declarators like pointer
2893 /// types, but not through decltype or typedefs.
2894 DeducedType *getContainedDeducedType() const;
2895
2896 /// Get the AutoType whose type will be deduced for a variable with
2897 /// an initializer of this type. This looks through declarators like pointer
2898 /// types, but not through decltype or typedefs.
2899 AutoType *getContainedAutoType() const {
2900 return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2901 }
2902
2903 /// Determine whether this type was written with a leading 'auto'
2904 /// corresponding to a trailing return type (possibly for a nested
2905 /// function type within a pointer to function type or similar).
2906 bool hasAutoForTrailingReturnType() const;
2907
2908 /// Member-template getAs<specific type>'. Look through sugar for
2909 /// an instance of <specific type>. This scheme will eventually
2910 /// replace the specific getAsXXXX methods above.
2911 ///
2912 /// There are some specializations of this member template listed
2913 /// immediately following this class.
2914 ///
2915 /// If you are interested only in the canonical properties of this type,
2916 /// consider using getAsCanonical instead, as that is much faster.
2917 template <typename T> const T *getAs() const;
2918
2919 /// If this type is canonically the specified type, return its canonical type
2920 /// cast to that specified type, otherwise returns null.
2921 template <typename T> const T *getAsCanonical() const {
2922 return dyn_cast<T>(CanonicalType);
2923 }
2924
2925 /// Return this type's canonical type cast to the specified type.
2926 /// If the type is not canonically that specified type, the behaviour is
2927 /// undefined.
2928 template <typename T> const T *castAsCanonical() const {
2929 return cast<T>(CanonicalType);
2930 }
2931
2932// It is not helpful to use these on types which are never canonical
2933#define TYPE(Class, Base)
2934#define NEVER_CANONICAL_TYPE(Class) \
2935 template <> inline const Class##Type *Type::getAsCanonical() const = delete; \
2936 template <> inline const Class##Type *Type::castAsCanonical() const = delete;
2937#include "clang/AST/TypeNodes.inc"
2938
2939 /// Look through sugar for an instance of TemplateSpecializationType which
2940 /// is not a type alias, or null if there is no such type.
2941 /// This is used when you want as-written template arguments or the template
2942 /// name for a class template specialization.
2943 const TemplateSpecializationType *
2944 getAsNonAliasTemplateSpecializationType() const;
2945
2946 const TemplateSpecializationType *
2948 const auto *TST = getAsNonAliasTemplateSpecializationType();
2949 assert(TST && "not a TemplateSpecializationType");
2950 return TST;
2951 }
2952
2953 /// Member-template getAsAdjusted<specific type>. Look through specific kinds
2954 /// of sugar (parens, attributes, etc) for an instance of <specific type>.
2955 /// This is used when you need to walk over sugar nodes that represent some
2956 /// kind of type adjustment from a type that was written as a <specific type>
2957 /// to another type that is still canonically a <specific type>.
2958 template <typename T> const T *getAsAdjusted() const;
2959
2960 /// A variant of getAs<> for array types which silently discards
2961 /// qualifiers from the outermost type.
2962 const ArrayType *getAsArrayTypeUnsafe() const;
2963
2964 /// Member-template castAs<specific type>. Look through sugar for
2965 /// the underlying instance of <specific type>.
2966 ///
2967 /// This method has the same relationship to getAs<T> as cast<T> has
2968 /// to dyn_cast<T>; which is to say, the underlying type *must*
2969 /// have the intended type, and this method will never return null.
2970 template <typename T> const T *castAs() const;
2971
2972 /// A variant of castAs<> for array type which silently discards
2973 /// qualifiers from the outermost type.
2974 const ArrayType *castAsArrayTypeUnsafe() const;
2975
2976 /// If this type represents a qualified-id, this returns its nested name
2977 /// specifier. For example, for the qualified-id "foo::bar::baz", this returns
2978 /// "foo::bar". Returns null if this type represents an unqualified-id.
2979 NestedNameSpecifier getPrefix() const;
2980
2981 /// Determine whether this type had the specified attribute applied to it
2982 /// (looking through top-level type sugar).
2983 bool hasAttr(attr::Kind AK) const;
2984
2985 /// Get the base element type of this type, potentially discarding type
2986 /// qualifiers. This should never be used when type qualifiers
2987 /// are meaningful.
2988 const Type *getBaseElementTypeUnsafe() const;
2989
2990 /// If this is an array type, return the element type of the array,
2991 /// potentially with type qualifiers missing.
2992 /// This should never be used when type qualifiers are meaningful.
2993 const Type *getArrayElementTypeNoTypeQual() const;
2994
2995 /// If this is a pointer type, return the pointee type.
2996 /// If this is an array type, return the array element type.
2997 /// This should never be used when type qualifiers are meaningful.
2998 const Type *getPointeeOrArrayElementType() const;
2999
3000 /// If this is a pointer, ObjC object pointer, or block
3001 /// pointer, this returns the respective pointee.
3002 QualType getPointeeType() const;
3003
3004 /// Return the specified type with any "sugar" removed from the type,
3005 /// removing any typedefs, typeofs, etc., as well as any qualifiers.
3006 const Type *getUnqualifiedDesugaredType() const;
3007
3008 /// Return true if this is an integer type that is
3009 /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
3010 /// or an enum decl which has a signed representation.
3011 bool isSignedIntegerType() const;
3012
3013 /// Return true if this is an integer type that is
3014 /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
3015 /// or an enum decl which has an unsigned representation.
3016 bool isUnsignedIntegerType() const;
3017
3018 /// Determines whether this is an integer type that is signed or an
3019 /// enumeration types whose underlying type is a signed integer type.
3020 bool isSignedIntegerOrEnumerationType() const;
3021
3022 /// Determines whether this is an integer type that is unsigned or an
3023 /// enumeration types whose underlying type is a unsigned integer type.
3024 bool isUnsignedIntegerOrEnumerationType() const;
3025
3026 /// Return true if this is a fixed point type according to
3027 /// ISO/IEC JTC1 SC22 WG14 N1169.
3028 bool isFixedPointType() const;
3029
3030 /// Return true if this is a fixed point or integer type.
3031 bool isFixedPointOrIntegerType() const;
3032
3033 /// Return true if this can be converted to (or from) a fixed point type.
3034 bool isConvertibleToFixedPointType() const;
3035
3036 /// Return true if this is a saturated fixed point type according to
3037 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
3038 bool isSaturatedFixedPointType() const;
3039
3040 /// Return true if this is a saturated fixed point type according to
3041 /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
3042 bool isUnsaturatedFixedPointType() const;
3043
3044 /// Return true if this is a fixed point type that is signed according
3045 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
3046 bool isSignedFixedPointType() const;
3047
3048 /// Return true if this is a fixed point type that is unsigned according
3049 /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
3050 bool isUnsignedFixedPointType() const;
3051
3052 /// Return true if this is not a variable sized type,
3053 /// according to the rules of C99 6.7.5p3. It is not legal to call this on
3054 /// incomplete types.
3055 bool isConstantSizeType() const;
3056
3057 /// Returns true if this type can be represented by some
3058 /// set of type specifiers.
3059 bool isSpecifierType() const;
3060
3061 /// Determine the linkage of this type.
3062 Linkage getLinkage() const;
3063
3064 /// Determine the visibility of this type.
3066 return getLinkageAndVisibility().getVisibility();
3067 }
3068
3069 /// Return true if the visibility was explicitly set is the code.
3071 return getLinkageAndVisibility().isVisibilityExplicit();
3072 }
3073
3074 /// Determine the linkage and visibility of this type.
3075 LinkageInfo getLinkageAndVisibility() const;
3076
3077 /// True if the computed linkage is valid. Used for consistency
3078 /// checking. Should always return true.
3079 bool isLinkageValid() const;
3080
3081 /// Determine the nullability of the given type.
3082 ///
3083 /// Note that nullability is only captured as sugar within the type
3084 /// system, not as part of the canonical type, so nullability will
3085 /// be lost by canonicalization and desugaring.
3086 std::optional<NullabilityKind> getNullability() const;
3087
3088 /// Determine whether the given type can have a nullability
3089 /// specifier applied to it, i.e., if it is any kind of pointer type.
3090 ///
3091 /// \param ResultIfUnknown The value to return if we don't yet know whether
3092 /// this type can have nullability because it is dependent.
3093 bool canHaveNullability(bool ResultIfUnknown = true) const;
3094
3095 /// Retrieve the set of substitutions required when accessing a member
3096 /// of the Objective-C receiver type that is declared in the given context.
3097 ///
3098 /// \c *this is the type of the object we're operating on, e.g., the
3099 /// receiver for a message send or the base of a property access, and is
3100 /// expected to be of some object or object pointer type.
3101 ///
3102 /// \param dc The declaration context for which we are building up a
3103 /// substitution mapping, which should be an Objective-C class, extension,
3104 /// category, or method within.
3105 ///
3106 /// \returns an array of type arguments that can be substituted for
3107 /// the type parameters of the given declaration context in any type described
3108 /// within that context, or an empty optional to indicate that no
3109 /// substitution is required.
3110 std::optional<ArrayRef<QualType>>
3111 getObjCSubstitutions(const DeclContext *dc) const;
3112
3113 /// Determines if this is an ObjC interface type that may accept type
3114 /// parameters.
3115 bool acceptsObjCTypeParams() const;
3116
3117 const char *getTypeClassName() const;
3118
3120 return CanonicalType;
3121 }
3122
3123 CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
3124 void dump() const;
3125 void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
3126};
3127
3128/// This will check for a TypedefType by removing any existing sugar
3129/// until it reaches a TypedefType or a non-sugared type.
3130template <> const TypedefType *Type::getAs() const;
3131template <> const UsingType *Type::getAs() const;
3132
3133/// This will check for a TemplateSpecializationType by removing any
3134/// existing sugar until it reaches a TemplateSpecializationType or a
3135/// non-sugared type.
3136template <> const TemplateSpecializationType *Type::getAs() const;
3137
3138/// This will check for an AttributedType by removing any existing sugar
3139/// until it reaches an AttributedType or a non-sugared type.
3140template <> const AttributedType *Type::getAs() const;
3141
3142/// This will check for a BoundsAttributedType by removing any existing
3143/// sugar until it reaches an BoundsAttributedType or a non-sugared type.
3144template <> const BoundsAttributedType *Type::getAs() const;
3145
3146/// This will check for a CountAttributedType by removing any existing
3147/// sugar until it reaches an CountAttributedType or a non-sugared type.
3148template <> const CountAttributedType *Type::getAs() const;
3149
3150// We can do always canonical types faster, because we don't have to
3151// worry about preserving decoration.
3152#define TYPE(Class, Base)
3153#define ALWAYS_CANONICAL_TYPE(Class) \
3154 template <> inline const Class##Type *Type::getAs() const { \
3155 return dyn_cast<Class##Type>(CanonicalType); \
3156 } \
3157 template <> inline const Class##Type *Type::castAs() const { \
3158 return cast<Class##Type>(CanonicalType); \
3159 }
3160#include "clang/AST/TypeNodes.inc"
3161
3162/// This class is used for builtin types like 'int'. Builtin
3163/// types are always canonical and have a literal name field.
3164class BuiltinType : public Type {
3165public:
3166 enum Kind {
3167// OpenCL image types
3168#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
3169#include "clang/Basic/OpenCLImageTypes.def"
3170// OpenCL extension types
3171#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
3172#include "clang/Basic/OpenCLExtensionTypes.def"
3173// SVE Types
3174#define SVE_TYPE(Name, Id, SingletonId) Id,
3175#include "clang/Basic/AArch64ACLETypes.def"
3176// PPC MMA Types
3177#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
3178#include "clang/Basic/PPCTypes.def"
3179// RVV Types
3180#define RVV_TYPE(Name, Id, SingletonId) Id,
3181#include "clang/Basic/RISCVVTypes.def"
3182// WebAssembly reference types
3183#define WASM_TYPE(Name, Id, SingletonId) Id,
3184#include "clang/Basic/WebAssemblyReferenceTypes.def"
3185// AMDGPU types
3186#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) Id,
3187#include "clang/Basic/AMDGPUTypes.def"
3188// HLSL intangible Types
3189#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) Id,
3190#include "clang/Basic/HLSLIntangibleTypes.def"
3191// All other builtin types
3192#define BUILTIN_TYPE(Id, SingletonId) Id,
3193#define LAST_BUILTIN_TYPE(Id) LastKind = Id
3194#include "clang/AST/BuiltinTypes.def"
3195 };
3196
3197private:
3198 friend class ASTContext; // ASTContext creates these.
3199
3200 BuiltinType(Kind K)
3201 : Type(Builtin, QualType(),
3202 K == Dependent ? TypeDependence::DependentInstantiation
3203 : TypeDependence::None) {
3204 static_assert(Kind::LastKind <
3205 (1 << BuiltinTypeBitfields::NumOfBuiltinTypeBits) &&
3206 "Defined builtin type exceeds the allocated space for serial "
3207 "numbering");
3208 BuiltinTypeBits.Kind = K;
3209 }
3210
3211public:
3212 Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
3213 StringRef getName(const PrintingPolicy &Policy) const;
3214
3215 const char *getNameAsCString(const PrintingPolicy &Policy) const {
3216 // The StringRef is null-terminated.
3217 StringRef str = getName(Policy);
3218 assert(!str.empty() && str.data()[str.size()] == '\0');
3219 return str.data();
3220 }
3221
3222 bool isSugared() const { return false; }
3223 QualType desugar() const { return QualType(this, 0); }
3224
3225 bool isInteger() const {
3226 return getKind() >= Bool && getKind() <= Int128;
3227 }
3228
3229 bool isSignedInteger() const {
3230 return getKind() >= Char_S && getKind() <= Int128;
3231 }
3232
3233 bool isUnsignedInteger() const {
3234 return getKind() >= Bool && getKind() <= UInt128;
3235 }
3236
3237 bool isFloatingPoint() const {
3238 return getKind() >= Half && getKind() <= Ibm128;
3239 }
3240
3241 bool isSVEBool() const { return getKind() == Kind::SveBool; }
3242
3243 bool isSVECount() const { return getKind() == Kind::SveCount; }
3244
3245 /// Determines whether the given kind corresponds to a placeholder type.
3247 return K >= Overload;
3248 }
3249
3250 /// Determines whether this type is a placeholder type, i.e. a type
3251 /// which cannot appear in arbitrary positions in a fully-formed
3252 /// expression.
3253 bool isPlaceholderType() const {
3255 }
3256
3257 /// Determines whether this type is a placeholder type other than
3258 /// Overload. Most placeholder types require only syntactic
3259 /// information about their context in order to be resolved (e.g.
3260 /// whether it is a call expression), which means they can (and
3261 /// should) be resolved in an earlier "phase" of analysis.
3262 /// Overload expressions sometimes pick up further information
3263 /// from their context, like whether the context expects a
3264 /// specific function-pointer type, and so frequently need
3265 /// special treatment.
3267 return getKind() > Overload;
3268 }
3269
3270 static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
3271};
3272
3273/// Complex values, per C99 6.2.5p11. This supports the C99 complex
3274/// types (_Complex float etc) as well as the GCC integer complex extensions.
3275class ComplexType : public Type, public llvm::FoldingSetNode {
3276 friend class ASTContext; // ASTContext creates these.
3277
3278 QualType ElementType;
3279
3280 ComplexType(QualType Element, QualType CanonicalPtr)
3281 : Type(Complex, CanonicalPtr, Element->getDependence()),
3282 ElementType(Element) {}
3283
3284public:
3285 QualType getElementType() const { return ElementType; }
3286
3287 bool isSugared() const { return false; }
3288 QualType desugar() const { return QualType(this, 0); }
3289
3290 void Profile(llvm::FoldingSetNodeID &ID) {
3291 Profile(ID, getElementType());
3292 }
3293
3294 static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
3295 ID.AddPointer(Element.getAsOpaquePtr());
3296 }
3297
3298 static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
3299};
3300
3301/// Sugar for parentheses used when specifying types.
3302class ParenType : public Type, public llvm::FoldingSetNode {
3303 friend class ASTContext; // ASTContext creates these.
3304
3305 QualType Inner;
3306
3307 ParenType(QualType InnerType, QualType CanonType)
3308 : Type(Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}
3309
3310public:
3311 QualType getInnerType() const { return Inner; }
3312
3313 bool isSugared() const { return true; }
3314 QualType desugar() const { return getInnerType(); }
3315
3316 void Profile(llvm::FoldingSetNodeID &ID) {
3317 Profile(ID, getInnerType());
3318 }
3319
3320 static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
3321 Inner.Profile(ID);
3322 }
3323
3324 static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
3325};
3326
3327/// PointerType - C99 6.7.5.1 - Pointer Declarators.
3328class PointerType : public Type, public llvm::FoldingSetNode {
3329 friend class ASTContext; // ASTContext creates these.
3330
3331 QualType PointeeType;
3332
3333 PointerType(QualType Pointee, QualType CanonicalPtr)
3334 : Type(Pointer, CanonicalPtr, Pointee->getDependence()),
3335 PointeeType(Pointee) {}
3336
3337public:
3338 QualType getPointeeType() const { return PointeeType; }
3339
3340 bool isSugared() const { return false; }
3341 QualType desugar() const { return QualType(this, 0); }
3342
3343 void Profile(llvm::FoldingSetNodeID &ID) {
3344 Profile(ID, getPointeeType());
3345 }
3346
3347 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
3348 ID.AddPointer(Pointee.getAsOpaquePtr());
3349 }
3350
3351 static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
3352};
3353
3354/// [BoundsSafety] Represents information of declarations referenced by the
3355/// arguments of the `counted_by` attribute and the likes.
3357public:
3358 using BaseTy = llvm::PointerIntPair<ValueDecl *, 1, unsigned>;
3359
3360private:
3361 enum {
3362 DerefShift = 0,
3363 DerefMask = 1,
3364 };
3365 BaseTy Data;
3366
3367public:
3368 /// \p D is to a declaration referenced by the argument of attribute. \p Deref
3369 /// indicates whether \p D is referenced as a dereferenced form, e.g., \p
3370 /// Deref is true for `*n` in `int *__counted_by(*n)`.
3371 TypeCoupledDeclRefInfo(ValueDecl *D = nullptr, bool Deref = false);
3372
3373 bool isDeref() const;
3374 ValueDecl *getDecl() const;
3375 unsigned getInt() const;
3376 void *getOpaqueValue() const;
3377 bool operator==(const TypeCoupledDeclRefInfo &Other) const;
3378 void setFromOpaqueValue(void *V);
3379};
3380
3381/// [BoundsSafety] Represents a parent type class for CountAttributedType and
3382/// similar sugar types that will be introduced to represent a type with a
3383/// bounds attribute.
3384///
3385/// Provides a common interface to navigate declarations referred to by the
3386/// bounds expression.
3387
3388class BoundsAttributedType : public Type, public llvm::FoldingSetNode {
3389 QualType WrappedTy;
3390
3391protected:
3392 ArrayRef<TypeCoupledDeclRefInfo> Decls; // stored in trailing objects
3393
3394 BoundsAttributedType(TypeClass TC, QualType Wrapped, QualType Canon);
3395
3396public:
3397 bool isSugared() const { return true; }
3398 QualType desugar() const { return WrappedTy; }
3399
3401 using decl_range = llvm::iterator_range<decl_iterator>;
3402
3403 decl_iterator dependent_decl_begin() const { return Decls.begin(); }
3404 decl_iterator dependent_decl_end() const { return Decls.end(); }
3405
3406 unsigned getNumCoupledDecls() const { return Decls.size(); }
3407
3411
3415
3416 bool referencesFieldDecls() const;
3417
3418 static bool classof(const Type *T) {
3419 // Currently, only `class CountAttributedType` inherits
3420 // `BoundsAttributedType` but the subclass will grow as we add more bounds
3421 // annotations.
3422 switch (T->getTypeClass()) {
3423 case CountAttributed:
3424 return true;
3425 default:
3426 return false;
3427 }
3428 }
3429};
3430
3431/// Represents a sugar type with `__counted_by` or `__sized_by` annotations,
3432/// including their `_or_null` variants.
3433class CountAttributedType final
3434 : public BoundsAttributedType,
3435 public llvm::TrailingObjects<CountAttributedType,
3436 TypeCoupledDeclRefInfo> {
3437 friend class ASTContext;
3438
3439 Expr *CountExpr;
3440 /// \p CountExpr represents the argument of __counted_by or the likes. \p
3441 /// CountInBytes indicates that \p CountExpr is a byte count (i.e.,
3442 /// __sized_by(_or_null)) \p OrNull means it's an or_null variant (i.e.,
3443 /// __counted_by_or_null or __sized_by_or_null) \p CoupledDecls contains the
3444 /// list of declarations referenced by \p CountExpr, which the type depends on
3445 /// for the bounds information.
3446 CountAttributedType(QualType Wrapped, QualType Canon, Expr *CountExpr,
3447 bool CountInBytes, bool OrNull,
3449
3450 unsigned numTrailingObjects(OverloadToken<TypeCoupledDeclRefInfo>) const {
3451 return CountAttributedTypeBits.NumCoupledDecls;
3452 }
3453
3454public:
3461
3462 Expr *getCountExpr() const { return CountExpr; }
3463 bool isCountInBytes() const { return CountAttributedTypeBits.CountInBytes; }
3464 bool isOrNull() const { return CountAttributedTypeBits.OrNull; }
3465
3467 if (isOrNull())
3469 return isCountInBytes() ? SizedBy : CountedBy;
3470 }
3471
3472 void Profile(llvm::FoldingSetNodeID &ID) {
3473 Profile(ID, desugar(), CountExpr, isCountInBytes(), isOrNull());
3474 }
3475
3476 static void Profile(llvm::FoldingSetNodeID &ID, QualType WrappedTy,
3477 Expr *CountExpr, bool CountInBytes, bool Nullable);
3478
3479 static bool classof(const Type *T) {
3480 return T->getTypeClass() == CountAttributed;
3481 }
3482
3483 StringRef getAttributeName(bool WithMacroPrefix) const;
3484};
3485
3486/// Represents a type which was implicitly adjusted by the semantic
3487/// engine for arbitrary reasons. For example, array and function types can
3488/// decay, and function types can have their calling conventions adjusted.
3489class AdjustedType : public Type, public llvm::FoldingSetNode {
3490 QualType OriginalTy;
3491 QualType AdjustedTy;
3492
3493protected:
3494 friend class ASTContext; // ASTContext creates these.
3495
3496 AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
3497 QualType CanonicalPtr)
3498 : Type(TC, CanonicalPtr,
3499 AdjustedTy->getDependence() |
3500 (OriginalTy->getDependence() & ~TypeDependence::Dependent)),
3501 OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
3502
3503public:
3504 QualType getOriginalType() const { return OriginalTy; }
3505 QualType getAdjustedType() const { return AdjustedTy; }
3506
3507 bool isSugared() const { return true; }
3508 QualType desugar() const { return AdjustedTy; }
3509
3510 void Profile(llvm::FoldingSetNodeID &ID) {
3511 Profile(ID, OriginalTy, AdjustedTy);
3512 }
3513
3514 static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
3515 ID.AddPointer(Orig.getAsOpaquePtr());
3516 ID.AddPointer(New.getAsOpaquePtr());
3517 }
3518
3519 static bool classof(const Type *T) {
3520 return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed;
3521 }
3522};
3523
3524/// Represents a pointer type decayed from an array or function type.
3525class DecayedType : public AdjustedType {
3526 friend class ASTContext; // ASTContext creates these.
3527
3528 inline
3529 DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);
3530
3531public:
3533
3534 inline QualType getPointeeType() const;
3535
3536 static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
3537};
3538
3539/// Pointer to a block type.
3540/// This type is to represent types syntactically represented as
3541/// "void (^)(int)", etc. Pointee is required to always be a function type.
3542class BlockPointerType : public Type, public llvm::FoldingSetNode {
3543 friend class ASTContext; // ASTContext creates these.
3544
3545 // Block is some kind of pointer type
3546 QualType PointeeType;
3547
3548 BlockPointerType(QualType Pointee, QualType CanonicalCls)
3549 : Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
3550 PointeeType(Pointee) {}
3551
3552public:
3553 // Get the pointee type. Pointee is required to always be a function type.
3554 QualType getPointeeType() const { return PointeeType; }
3555
3556 bool isSugared() const { return false; }
3557 QualType desugar() const { return QualType(this, 0); }
3558
3559 void Profile(llvm::FoldingSetNodeID &ID) {
3560 Profile(ID, getPointeeType());
3561 }
3562
3563 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
3564 ID.AddPointer(Pointee.getAsOpaquePtr());
3565 }
3566
3567 static bool classof(const Type *T) {
3568 return T->getTypeClass() == BlockPointer;
3569 }
3570};
3571
3572/// Base for LValueReferenceType and RValueReferenceType
3573class ReferenceType : public Type, public llvm::FoldingSetNode {
3574 QualType PointeeType;
3575
3576protected:
3577 ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
3578 bool SpelledAsLValue)
3579 : Type(tc, CanonicalRef, Referencee->getDependence()),
3580 PointeeType(Referencee) {
3581 ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
3582 ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
3583 }
3584
3585public:
3586 bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
3587 bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }
3588
3589 QualType getPointeeTypeAsWritten() const { return PointeeType; }
3590
3592 // FIXME: this might strip inner qualifiers; okay?
3593 const ReferenceType *T = this;
3594 while (T->isInnerRef())
3595 T = T->PointeeType->castAs<ReferenceType>();
3596 return T->PointeeType;
3597 }
3598
3599 void Profile(llvm::FoldingSetNodeID &ID) {
3600 Profile(ID, PointeeType, isSpelledAsLValue());
3601 }
3602
3603 static void Profile(llvm::FoldingSetNodeID &ID,
3604 QualType Referencee,
3605 bool SpelledAsLValue) {
3606 ID.AddPointer(Referencee.getAsOpaquePtr());
3607 ID.AddBoolean(SpelledAsLValue);
3608 }
3609
3610 static bool classof(const Type *T) {
3611 return T->getTypeClass() == LValueReference ||
3612 T->getTypeClass() == RValueReference;
3613 }
3614};
3615
3616/// An lvalue reference type, per C++11 [dcl.ref].
3617class LValueReferenceType : public ReferenceType {
3618 friend class ASTContext; // ASTContext creates these
3619
3620 LValueReferenceType(QualType Referencee, QualType CanonicalRef,
3621 bool SpelledAsLValue)
3622 : ReferenceType(LValueReference, Referencee, CanonicalRef,
3623 SpelledAsLValue) {}
3624
3625public:
3626 bool isSugared() const { return false; }
3627 QualType desugar() const { return QualType(this, 0); }
3628
3629 static bool classof(const Type *T) {
3630 return T->getTypeClass() == LValueReference;
3631 }
3632};
3633
3634/// An rvalue reference type, per C++11 [dcl.ref].
3635class RValueReferenceType : public ReferenceType {
3636 friend class ASTContext; // ASTContext creates these
3637
3638 RValueReferenceType(QualType Referencee, QualType CanonicalRef)
3639 : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}
3640
3641public:
3642 bool isSugared() const { return false; }
3643 QualType desugar() const { return QualType(this, 0); }
3644
3645 static bool classof(const Type *T) {
3646 return T->getTypeClass() == RValueReference;
3647 }
3648};
3649
3650/// A pointer to member type per C++ 8.3.3 - Pointers to members.
3651///
3652/// This includes both pointers to data members and pointer to member functions.
3653class MemberPointerType : public Type, public llvm::FoldingSetNode {
3654 friend class ASTContext; // ASTContext creates these.
3655
3656 QualType PointeeType;
3657
3658 /// The class of which the pointee is a member. Must ultimately be a
3659 /// CXXRecordType, but could be a typedef or a template parameter too.
3660 NestedNameSpecifier Qualifier;
3661
3662 MemberPointerType(QualType Pointee, NestedNameSpecifier Qualifier,
3663 QualType CanonicalPtr)
3664 : Type(MemberPointer, CanonicalPtr,
3665 (toTypeDependence(Qualifier.getDependence()) &
3666 ~TypeDependence::VariablyModified) |
3667 Pointee->getDependence()),
3668 PointeeType(Pointee), Qualifier(Qualifier) {}
3669
3670public:
3671 QualType getPointeeType() const { return PointeeType; }
3672
3673 /// Returns true if the member type (i.e. the pointee type) is a
3674 /// function type rather than a data-member type.
3676 return PointeeType->isFunctionProtoType();
3677 }
3678
3679 /// Returns true if the member type (i.e. the pointee type) is a
3680 /// data type rather than a function type.
3681 bool isMemberDataPointer() const {
3682 return !PointeeType->isFunctionProtoType();
3683 }
3684
3685 NestedNameSpecifier getQualifier() const { return Qualifier; }
3686 /// Note: this can trigger extra deserialization when external AST sources are
3687 /// used. Prefer `getCXXRecordDecl()` unless you really need the most recent
3688 /// decl.
3689 CXXRecordDecl *getMostRecentCXXRecordDecl() const;
3690
3691 bool isSugared() const;
3693 return isSugared() ? getCanonicalTypeInternal() : QualType(this, 0);
3694 }
3695
3696 void Profile(llvm::FoldingSetNodeID &ID) {
3697 // FIXME: `getMostRecentCXXRecordDecl()` should be possible to use here,
3698 // however when external AST sources are used it causes nondeterminism
3699 // issues (see https://github.com/llvm/llvm-project/pull/137910).
3700 Profile(ID, getPointeeType(), getQualifier(), getCXXRecordDecl());
3701 }
3702
3703 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
3704 const NestedNameSpecifier Qualifier,
3705 const CXXRecordDecl *Cls);
3706
3707 static bool classof(const Type *T) {
3708 return T->getTypeClass() == MemberPointer;
3709 }
3710
3711private:
3712 CXXRecordDecl *getCXXRecordDecl() const;
3713};
3714
3715/// Capture whether this is a normal array (e.g. int X[4])
3716/// an array with a static size (e.g. int X[static 4]), or an array
3717/// with a star size (e.g. int X[*]).
3718/// 'static' is only allowed on function parameters.
3720
3721/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
3722class ArrayType : public Type, public llvm::FoldingSetNode {
3723private:
3724 /// The element type of the array.
3725 QualType ElementType;
3726
3727protected:
3728 friend class ASTContext; // ASTContext creates these.
3729
3731 unsigned tq, const Expr *sz = nullptr);
3732
3733public:
3734 QualType getElementType() const { return ElementType; }
3735
3737 return ArraySizeModifier(ArrayTypeBits.SizeModifier);
3738 }
3739
3743
3744 unsigned getIndexTypeCVRQualifiers() const {
3745 return ArrayTypeBits.IndexTypeQuals;
3746 }
3747
3748 static bool classof(const Type *T) {
3749 return T->getTypeClass() == ConstantArray ||
3750 T->getTypeClass() == VariableArray ||
3751 T->getTypeClass() == IncompleteArray ||
3752 T->getTypeClass() == DependentSizedArray ||
3753 T->getTypeClass() == ArrayParameter;
3754 }
3755};
3756
3757/// Represents the canonical version of C arrays with a specified constant size.
3758/// For example, the canonical type for 'int A[4 + 4*100]' is a
3759/// ConstantArrayType where the element type is 'int' and the size is 404.
3760class ConstantArrayType : public ArrayType {
3761 friend class ASTContext; // ASTContext creates these.
3762
3763 struct ExternalSize {
3764 ExternalSize(const llvm::APInt &Sz, const Expr *SE)
3765 : Size(Sz), SizeExpr(SE) {}
3766 llvm::APInt Size; // Allows us to unique the type.
3767 const Expr *SizeExpr;
3768 };
3769
3770 union {
3771 uint64_t Size;
3772 ExternalSize *SizePtr;
3773 };
3774
3775 ConstantArrayType(QualType Et, QualType Can, uint64_t Width, uint64_t Sz,
3776 ArraySizeModifier SM, unsigned TQ)
3777 : ArrayType(ConstantArray, Et, Can, SM, TQ, nullptr), Size(Sz) {
3778 ConstantArrayTypeBits.HasExternalSize = false;
3779 ConstantArrayTypeBits.SizeWidth = Width / 8;
3780 // The in-structure size stores the size in bytes rather than bits so we
3781 // drop the three least significant bits since they're always zero anyways.
3782 assert(Width < 0xFF && "Type width in bits must be less than 8 bits");
3783 }
3784
3785 ConstantArrayType(QualType Et, QualType Can, ExternalSize *SzPtr,
3786 ArraySizeModifier SM, unsigned TQ)
3787 : ArrayType(ConstantArray, Et, Can, SM, TQ, SzPtr->SizeExpr),
3788 SizePtr(SzPtr) {
3789 ConstantArrayTypeBits.HasExternalSize = true;
3790 ConstantArrayTypeBits.SizeWidth = 0;
3791
3792 assert((SzPtr->SizeExpr == nullptr || !Can.isNull()) &&
3793 "canonical constant array should not have size expression");
3794 }
3795
3796 static ConstantArrayType *Create(const ASTContext &Ctx, QualType ET,
3797 QualType Can, const llvm::APInt &Sz,
3798 const Expr *SzExpr, ArraySizeModifier SzMod,
3799 unsigned Qual);
3800
3801protected:
3802 ConstantArrayType(TypeClass Tc, const ConstantArrayType *ATy, QualType Can)
3803 : ArrayType(Tc, ATy->getElementType(), Can, ATy->getSizeModifier(),
3804 ATy->getIndexTypeQualifiers().getAsOpaqueValue(), nullptr) {
3805 ConstantArrayTypeBits.HasExternalSize =
3806 ATy->ConstantArrayTypeBits.HasExternalSize;
3807 if (!ConstantArrayTypeBits.HasExternalSize) {
3808 ConstantArrayTypeBits.SizeWidth = ATy->ConstantArrayTypeBits.SizeWidth;
3809 Size = ATy->Size;
3810 } else
3811 SizePtr = ATy->SizePtr;
3812 }
3813
3814public:
3815 /// Return the constant array size as an APInt.
3816 llvm::APInt getSize() const {
3817 return ConstantArrayTypeBits.HasExternalSize
3818 ? SizePtr->Size
3819 : llvm::APInt(ConstantArrayTypeBits.SizeWidth * 8, Size);
3820 }
3821
3822 /// Return the bit width of the size type.
3823 unsigned getSizeBitWidth() const {
3824 return ConstantArrayTypeBits.HasExternalSize
3825 ? SizePtr->Size.getBitWidth()
3826 : static_cast<unsigned>(ConstantArrayTypeBits.SizeWidth * 8);
3827 }
3828
3829 /// Return true if the size is zero.
3830 bool isZeroSize() const {
3831 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.isZero()
3832 : 0 == Size;
3833 }
3834
3835 /// Return the size zero-extended as a uint64_t.
3836 uint64_t getZExtSize() const {
3837 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getZExtValue()
3838 : Size;
3839 }
3840
3841 /// Return the size sign-extended as a uint64_t.
3842 int64_t getSExtSize() const {
3843 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->Size.getSExtValue()
3844 : static_cast<int64_t>(Size);
3845 }
3846
3847 /// Return the size zero-extended to uint64_t or UINT64_MAX if the value is
3848 /// larger than UINT64_MAX.
3849 uint64_t getLimitedSize() const {
3850 return ConstantArrayTypeBits.HasExternalSize
3851 ? SizePtr->Size.getLimitedValue()
3852 : Size;
3853 }
3854
3855 /// Return a pointer to the size expression.
3856 const Expr *getSizeExpr() const {
3857 return ConstantArrayTypeBits.HasExternalSize ? SizePtr->SizeExpr : nullptr;
3858 }
3859
3860 bool isSugared() const { return false; }
3861 QualType desugar() const { return QualType(this, 0); }
3862
3863 /// Determine the number of bits required to address a member of
3864 // an array with the given element type and number of elements.
3865 static unsigned getNumAddressingBits(const ASTContext &Context,
3866 QualType ElementType,
3867 const llvm::APInt &NumElements);
3868
3869 unsigned getNumAddressingBits(const ASTContext &Context) const;
3870
3871 /// Determine the maximum number of active bits that an array's size
3872 /// can require, which limits the maximum size of the array.
3873 static unsigned getMaxSizeBits(const ASTContext &Context);
3874
3875 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
3878 }
3879
3880 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
3881 QualType ET, uint64_t ArraySize, const Expr *SizeExpr,
3882 ArraySizeModifier SizeMod, unsigned TypeQuals);
3883
3884 static bool classof(const Type *T) {
3885 return T->getTypeClass() == ConstantArray ||
3886 T->getTypeClass() == ArrayParameter;
3887 }
3888};
3889
3890/// Represents a constant array type that does not decay to a pointer when used
3891/// as a function parameter.
3892class ArrayParameterType : public ConstantArrayType {
3893 friend class ASTContext; // ASTContext creates these.
3894
3895 ArrayParameterType(const ConstantArrayType *ATy, QualType CanTy)
3896 : ConstantArrayType(ArrayParameter, ATy, CanTy) {}
3897
3898public:
3899 static bool classof(const Type *T) {
3900 return T->getTypeClass() == ArrayParameter;
3901 }
3902
3903 QualType getConstantArrayType(const ASTContext &Ctx) const;
3904};
3905
3906/// Represents a C array with an unspecified size. For example 'int A[]' has
3907/// an IncompleteArrayType where the element type is 'int' and the size is
3908/// unspecified.
3909class IncompleteArrayType : public ArrayType {
3910 friend class ASTContext; // ASTContext creates these.
3911
3912 IncompleteArrayType(QualType et, QualType can,
3913 ArraySizeModifier sm, unsigned tq)
3914 : ArrayType(IncompleteArray, et, can, sm, tq) {}
3915
3916public:
3917 friend class StmtIteratorBase;
3918
3919 bool isSugared() const { return false; }
3920 QualType desugar() const { return QualType(this, 0); }
3921
3922 static bool classof(const Type *T) {
3923 return T->getTypeClass() == IncompleteArray;
3924 }
3925
3926 void Profile(llvm::FoldingSetNodeID &ID) {
3929 }
3930
3931 static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
3932 ArraySizeModifier SizeMod, unsigned TypeQuals) {
3933 ID.AddPointer(ET.getAsOpaquePtr());
3934 ID.AddInteger(llvm::to_underlying(SizeMod));
3935 ID.AddInteger(TypeQuals);
3936 }
3937};
3938
3939/// Represents a C array with a specified size that is not an
3940/// integer-constant-expression. For example, 'int s[x+foo()]'.
3941/// Since the size expression is an arbitrary expression, we store it as such.
3942///
3943/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3944/// should not be: two lexically equivalent variable array types could mean
3945/// different things, for example, these variables do not have the same type
3946/// dynamically:
3947///
3948/// void foo(int x) {
3949/// int Y[x];
3950/// ++x;
3951/// int Z[x];
3952/// }
3953///
3954/// FIXME: Even constant array types might be represented by a
3955/// VariableArrayType, as in:
3956///
3957/// void func(int n) {
3958/// int array[7][n];
3959/// }
3960///
3961/// Even though 'array' is a constant-size array of seven elements of type
3962/// variable-length array of size 'n', it will be represented as a
3963/// VariableArrayType whose 'SizeExpr' is an IntegerLiteral whose value is 7.
3964/// Instead, this should be a ConstantArrayType whose element is a
3965/// VariableArrayType, which models the type better.
3966class VariableArrayType : public ArrayType {
3967 friend class ASTContext; // ASTContext creates these.
3968
3969 /// An assignment-expression. VLA's are only permitted within
3970 /// a function block.
3971 Stmt *SizeExpr;
3972
3973 VariableArrayType(QualType et, QualType can, Expr *e, ArraySizeModifier sm,
3974 unsigned tq)
3975 : ArrayType(VariableArray, et, can, sm, tq, e), SizeExpr((Stmt *)e) {}
3976
3977public:
3978 friend class StmtIteratorBase;
3979
3981 // We use C-style casts instead of cast<> here because we do not wish
3982 // to have a dependency of Type.h on Stmt.h/Expr.h.
3983 return (Expr*) SizeExpr;
3984 }
3985
3986 bool isSugared() const { return false; }
3987 QualType desugar() const { return QualType(this, 0); }
3988
3989 static bool classof(const Type *T) {
3990 return T->getTypeClass() == VariableArray;
3991 }
3992
3993 void Profile(llvm::FoldingSetNodeID &ID) {
3994 llvm_unreachable("Cannot unique VariableArrayTypes.");
3995 }
3996};
3997
3998/// Represents an array type in C++ whose size is a value-dependent expression.
3999///
4000/// For example:
4001/// \code
4002/// template<typename T, int Size>
4003/// class array {
4004/// T data[Size];
4005/// };
4006/// \endcode
4007///
4008/// For these types, we won't actually know what the array bound is
4009/// until template instantiation occurs, at which point this will
4010/// become either a ConstantArrayType or a VariableArrayType.
4011class DependentSizedArrayType : public ArrayType {
4012 friend class ASTContext; // ASTContext creates these.
4013
4014 /// An assignment expression that will instantiate to the
4015 /// size of the array.
4016 ///
4017 /// The expression itself might be null, in which case the array
4018 /// type will have its size deduced from an initializer.
4019 Stmt *SizeExpr;
4020
4021 DependentSizedArrayType(QualType et, QualType can, Expr *e,
4022 ArraySizeModifier sm, unsigned tq);
4023
4024public:
4025 friend class StmtIteratorBase;
4026
4028 // We use C-style casts instead of cast<> here because we do not wish
4029 // to have a dependency of Type.h on Stmt.h/Expr.h.
4030 return (Expr*) SizeExpr;
4031 }
4032
4033 bool isSugared() const { return false; }
4034 QualType desugar() const { return QualType(this, 0); }
4035
4036 static bool classof(const Type *T) {
4037 return T->getTypeClass() == DependentSizedArray;
4038 }
4039
4040 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
4041 Profile(ID, Context, getElementType(),
4043 }
4044
4045 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4046 QualType ET, ArraySizeModifier SizeMod,
4047 unsigned TypeQuals, Expr *E);
4048};
4049
4050/// Represents an extended address space qualifier where the input address space
4051/// value is dependent. Non-dependent address spaces are not represented with a
4052/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
4053///
4054/// For example:
4055/// \code
4056/// template<typename T, int AddrSpace>
4057/// class AddressSpace {
4058/// typedef T __attribute__((address_space(AddrSpace))) type;
4059/// }
4060/// \endcode
4061class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
4062 friend class ASTContext;
4063
4064 Expr *AddrSpaceExpr;
4065 QualType PointeeType;
4066 SourceLocation loc;
4067
4068 DependentAddressSpaceType(QualType PointeeType, QualType can,
4069 Expr *AddrSpaceExpr, SourceLocation loc);
4070
4071public:
4072 Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
4073 QualType getPointeeType() const { return PointeeType; }
4074 SourceLocation getAttributeLoc() const { return loc; }
4075
4076 bool isSugared() const { return false; }
4077 QualType desugar() const { return QualType(this, 0); }
4078
4079 static bool classof(const Type *T) {
4080 return T->getTypeClass() == DependentAddressSpace;
4081 }
4082
4083 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
4084 Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
4085 }
4086
4087 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4088 QualType PointeeType, Expr *AddrSpaceExpr);
4089};
4090
4091/// Represents an extended vector type where either the type or size is
4092/// dependent.
4093///
4094/// For example:
4095/// \code
4096/// template<typename T, int Size>
4097/// class vector {
4098/// typedef T __attribute__((ext_vector_type(Size))) type;
4099/// }
4100/// \endcode
4101class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
4102 friend class ASTContext;
4103
4104 Expr *SizeExpr;
4105
4106 /// The element type of the array.
4107 QualType ElementType;
4108
4109 SourceLocation loc;
4110
4111 DependentSizedExtVectorType(QualType ElementType, QualType can,
4112 Expr *SizeExpr, SourceLocation loc);
4113
4114public:
4115 Expr *getSizeExpr() const { return SizeExpr; }
4116 QualType getElementType() const { return ElementType; }
4117 SourceLocation getAttributeLoc() const { return loc; }
4118
4119 bool isSugared() const { return false; }
4120 QualType desugar() const { return QualType(this, 0); }
4121
4122 static bool classof(const Type *T) {
4123 return T->getTypeClass() == DependentSizedExtVector;
4124 }
4125
4126 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
4127 Profile(ID, Context, getElementType(), getSizeExpr());
4128 }
4129
4130 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4131 QualType ElementType, Expr *SizeExpr);
4132};
4133
4134enum class VectorKind {
4135 /// not a target-specific vector type
4137
4138 /// is AltiVec vector
4140
4141 /// is AltiVec 'vector Pixel'
4143
4144 /// is AltiVec 'vector bool ...'
4146
4147 /// is ARM Neon vector
4149
4150 /// is ARM Neon polynomial vector
4152
4153 /// is AArch64 SVE fixed-length data vector
4155
4156 /// is AArch64 SVE fixed-length predicate vector
4158
4159 /// is RISC-V RVV fixed-length data vector
4161
4162 /// is RISC-V RVV fixed-length mask vector
4164
4168};
4169
4170/// Represents a GCC generic vector type. This type is created using
4171/// __attribute__((vector_size(n)), where "n" specifies the vector size in
4172/// bytes; or from an Altivec __vector or vector declaration.
4173/// Since the constructor takes the number of vector elements, the
4174/// client is responsible for converting the size into the number of elements.
4175class VectorType : public Type, public llvm::FoldingSetNode {
4176protected:
4177 friend class ASTContext; // ASTContext creates these.
4178
4179 /// The element type of the vector.
4181
4182 VectorType(QualType vecType, unsigned nElements, QualType canonType,
4183 VectorKind vecKind);
4184
4185 VectorType(TypeClass tc, QualType vecType, unsigned nElements,
4186 QualType canonType, VectorKind vecKind);
4187
4188public:
4190 unsigned getNumElements() const { return VectorTypeBits.NumElements; }
4191
4192 bool isSugared() const { return false; }
4193 QualType desugar() const { return QualType(this, 0); }
4194
4196 return VectorKind(VectorTypeBits.VecKind);
4197 }
4198
4199 void Profile(llvm::FoldingSetNodeID &ID) {
4202 }
4203
4204 static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
4205 unsigned NumElements, TypeClass TypeClass,
4206 VectorKind VecKind) {
4207 ID.AddPointer(ElementType.getAsOpaquePtr());
4208 ID.AddInteger(NumElements);
4209 ID.AddInteger(TypeClass);
4210 ID.AddInteger(llvm::to_underlying(VecKind));
4211 }
4212
4213 static bool classof(const Type *T) {
4214 return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector;
4215 }
4216};
4217
4218/// Represents a vector type where either the type or size is dependent.
4219////
4220/// For example:
4221/// \code
4222/// template<typename T, int Size>
4223/// class vector {
4224/// typedef T __attribute__((vector_size(Size))) type;
4225/// }
4226/// \endcode
4227class DependentVectorType : public Type, public llvm::FoldingSetNode {
4228 friend class ASTContext;
4229
4230 QualType ElementType;
4231 Expr *SizeExpr;
4232 SourceLocation Loc;
4233
4234 DependentVectorType(QualType ElementType, QualType CanonType, Expr *SizeExpr,
4235 SourceLocation Loc, VectorKind vecKind);
4236
4237public:
4238 Expr *getSizeExpr() const { return SizeExpr; }
4239 QualType getElementType() const { return ElementType; }
4240 SourceLocation getAttributeLoc() const { return Loc; }
4242 return VectorKind(VectorTypeBits.VecKind);
4243 }
4244
4245 bool isSugared() const { return false; }
4246 QualType desugar() const { return QualType(this, 0); }
4247
4248 static bool classof(const Type *T) {
4249 return T->getTypeClass() == DependentVector;
4250 }
4251
4252 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
4253 Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
4254 }
4255
4256 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4257 QualType ElementType, const Expr *SizeExpr,
4258 VectorKind VecKind);
4259};
4260
4261/// ExtVectorType - Extended vector type. This type is created using
4262/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
4263/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
4264/// class enables syntactic extensions, like Vector Components for accessing
4265/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
4266/// Shading Language).
4267class ExtVectorType : public VectorType {
4268 friend class ASTContext; // ASTContext creates these.
4269
4270 ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
4271 : VectorType(ExtVector, vecType, nElements, canonType,
4272 VectorKind::Generic) {}
4273
4274public:
4275 static int getPointAccessorIdx(char c) {
4276 switch (c) {
4277 default: return -1;
4278 case 'x': case 'r': return 0;
4279 case 'y': case 'g': return 1;
4280 case 'z': case 'b': return 2;
4281 case 'w': case 'a': return 3;
4282 }
4283 }
4284
4285 static int getNumericAccessorIdx(char c) {
4286 switch (c) {
4287 default: return -1;
4288 case '0': return 0;
4289 case '1': return 1;
4290 case '2': return 2;
4291 case '3': return 3;
4292 case '4': return 4;
4293 case '5': return 5;
4294 case '6': return 6;
4295 case '7': return 7;
4296 case '8': return 8;
4297 case '9': return 9;
4298 case 'A':
4299 case 'a': return 10;
4300 case 'B':
4301 case 'b': return 11;
4302 case 'C':
4303 case 'c': return 12;
4304 case 'D':
4305 case 'd': return 13;
4306 case 'E':
4307 case 'e': return 14;
4308 case 'F':
4309 case 'f': return 15;
4310 }
4311 }
4312
4313 static int getAccessorIdx(char c, bool isNumericAccessor) {
4314 if (isNumericAccessor)
4315 return getNumericAccessorIdx(c);
4316 else
4317 return getPointAccessorIdx(c);
4318 }
4319
4320 bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
4321 if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
4322 return unsigned(idx-1) < getNumElements();
4323 return false;
4324 }
4325
4326 bool isSugared() const { return false; }
4327 QualType desugar() const { return QualType(this, 0); }
4328
4329 static bool classof(const Type *T) {
4330 return T->getTypeClass() == ExtVector;
4331 }
4332};
4333
4334/// Represents a matrix type, as defined in the Matrix Types clang extensions.
4335/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
4336/// number of rows and "columns" specifies the number of columns.
4337class MatrixType : public Type, public llvm::FoldingSetNode {
4338protected:
4339 friend class ASTContext;
4340
4341 /// The element type of the matrix.
4343
4344 MatrixType(QualType ElementTy, QualType CanonElementTy);
4345
4346 MatrixType(TypeClass TypeClass, QualType ElementTy, QualType CanonElementTy,
4347 const Expr *RowExpr = nullptr, const Expr *ColumnExpr = nullptr);
4348
4349public:
4350 /// Returns type of the elements being stored in the matrix
4352
4353 /// Valid elements types are the following:
4354 /// * an integer type (as in C23 6.2.5p22), but excluding enumerated types
4355 /// and _Bool
4356 /// * the standard floating types float or double
4357 /// * a half-precision floating point type, if one is supported on the target
4359 return T->isDependentType() ||
4360 (T->isRealType() && !T->isBooleanType() && !T->isEnumeralType());
4361 }
4362
4363 bool isSugared() const { return false; }
4364 QualType desugar() const { return QualType(this, 0); }
4365
4366 static bool classof(const Type *T) {
4367 return T->getTypeClass() == ConstantMatrix ||
4368 T->getTypeClass() == DependentSizedMatrix;
4369 }
4370};
4371
4372/// Represents a concrete matrix type with constant number of rows and columns
4373class ConstantMatrixType final : public MatrixType {
4374protected:
4375 friend class ASTContext;
4376
4377 /// Number of rows and columns.
4378 unsigned NumRows;
4379 unsigned NumColumns;
4380
4381 static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;
4382
4383 ConstantMatrixType(QualType MatrixElementType, unsigned NRows,
4384 unsigned NColumns, QualType CanonElementType);
4385
4386 ConstantMatrixType(TypeClass typeClass, QualType MatrixType, unsigned NRows,
4387 unsigned NColumns, QualType CanonElementType);
4388
4389public:
4390 /// Returns the number of rows in the matrix.
4391 unsigned getNumRows() const { return NumRows; }
4392
4393 /// Returns the number of columns in the matrix.
4394 unsigned getNumColumns() const { return NumColumns; }
4395
4396 /// Returns the number of elements required to embed the matrix into a vector.
4397 unsigned getNumElementsFlattened() const {
4398 return getNumRows() * getNumColumns();
4399 }
4400
4401 /// Returns true if \p NumElements is a valid matrix dimension.
4402 static constexpr bool isDimensionValid(size_t NumElements) {
4403 return NumElements > 0 && NumElements <= MaxElementsPerDimension;
4404 }
4405
4406 /// Returns the maximum number of elements per dimension.
4407 static constexpr unsigned getMaxElementsPerDimension() {
4409 }
4410
4411 void Profile(llvm::FoldingSetNodeID &ID) {
4413 getTypeClass());
4414 }
4415
4416 static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
4417 unsigned NumRows, unsigned NumColumns,
4419 ID.AddPointer(ElementType.getAsOpaquePtr());
4420 ID.AddInteger(NumRows);
4421 ID.AddInteger(NumColumns);
4422 ID.AddInteger(TypeClass);
4423 }
4424
4425 static bool classof(const Type *T) {
4426 return T->getTypeClass() == ConstantMatrix;
4427 }
4428};
4429
4430/// Represents a matrix type where the type and the number of rows and columns
4431/// is dependent on a template.
4432class DependentSizedMatrixType final : public MatrixType {
4433 friend class ASTContext;
4434
4435 Expr *RowExpr;
4436 Expr *ColumnExpr;
4437
4438 SourceLocation loc;
4439
4440 DependentSizedMatrixType(QualType ElementType, QualType CanonicalType,
4441 Expr *RowExpr, Expr *ColumnExpr, SourceLocation loc);
4442
4443public:
4444 Expr *getRowExpr() const { return RowExpr; }
4445 Expr *getColumnExpr() const { return ColumnExpr; }
4446 SourceLocation getAttributeLoc() const { return loc; }
4447
4448 static bool classof(const Type *T) {
4449 return T->getTypeClass() == DependentSizedMatrix;
4450 }
4451
4452 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
4453 Profile(ID, Context, getElementType(), getRowExpr(), getColumnExpr());
4454 }
4455
4456 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4457 QualType ElementType, Expr *RowExpr, Expr *ColumnExpr);
4458};
4459
4460/// FunctionType - C99 6.7.5.3 - Function Declarators. This is the common base
4461/// class of FunctionNoProtoType and FunctionProtoType.
4462class FunctionType : public Type {
4463 // The type returned by the function.
4464 QualType ResultType;
4465
4466public:
4467 /// Interesting information about a specific parameter that can't simply
4468 /// be reflected in parameter's type. This is only used by FunctionProtoType
4469 /// but is in FunctionType to make this class available during the
4470 /// specification of the bases of FunctionProtoType.
4471 ///
4472 /// It makes sense to model language features this way when there's some
4473 /// sort of parameter-specific override (such as an attribute) that
4474 /// affects how the function is called. For example, the ARC ns_consumed
4475 /// attribute changes whether a parameter is passed at +0 (the default)
4476 /// or +1 (ns_consumed). This must be reflected in the function type,
4477 /// but isn't really a change to the parameter type.
4478 ///
4479 /// One serious disadvantage of modelling language features this way is
4480 /// that they generally do not work with language features that attempt
4481 /// to destructure types. For example, template argument deduction will
4482 /// not be able to match a parameter declared as
4483 /// T (*)(U)
4484 /// against an argument of type
4485 /// void (*)(__attribute__((ns_consumed)) id)
4486 /// because the substitution of T=void, U=id into the former will
4487 /// not produce the latter.
4489 enum {
4490 ABIMask = 0x0F,
4491 IsConsumed = 0x10,
4492 HasPassObjSize = 0x20,
4493 IsNoEscape = 0x40,
4494 };
4495 unsigned char Data = 0;
4496
4497 public:
4498 ExtParameterInfo() = default;
4499
4500 /// Return the ABI treatment of this parameter.
4501 ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
4503 ExtParameterInfo copy = *this;
4504 copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
4505 return copy;
4506 }
4507
4508 /// Is this parameter considered "consumed" by Objective-C ARC?
4509 /// Consumed parameters must have retainable object type.
4510 bool isConsumed() const { return (Data & IsConsumed); }
4512 ExtParameterInfo copy = *this;
4513 if (consumed)
4514 copy.Data |= IsConsumed;
4515 else
4516 copy.Data &= ~IsConsumed;
4517 return copy;
4518 }
4519
4520 bool hasPassObjectSize() const { return Data & HasPassObjSize; }
4522 ExtParameterInfo Copy = *this;
4523 Copy.Data |= HasPassObjSize;
4524 return Copy;
4525 }
4526
4527 bool isNoEscape() const { return Data & IsNoEscape; }
4528 ExtParameterInfo withIsNoEscape(bool NoEscape) const {
4529 ExtParameterInfo Copy = *this;
4530 if (NoEscape)
4531 Copy.Data |= IsNoEscape;
4532 else
4533 Copy.Data &= ~IsNoEscape;
4534 return Copy;
4535 }
4536
4537 unsigned char getOpaqueValue() const { return Data; }
4538 static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
4539 ExtParameterInfo result;
4540 result.Data = data;
4541 return result;
4542 }
4543
4545 return lhs.Data == rhs.Data;
4546 }
4547
4549 return lhs.Data != rhs.Data;
4550 }
4551 };
4552
4553 /// A class which abstracts out some details necessary for
4554 /// making a call.
4555 ///
4556 /// It is not actually used directly for storing this information in
4557 /// a FunctionType, although FunctionType does currently use the
4558 /// same bit-pattern.
4559 ///
4560 // If you add a field (say Foo), other than the obvious places (both,
4561 // constructors, compile failures), what you need to update is
4562 // * Operator==
4563 // * getFoo
4564 // * withFoo
4565 // * functionType. Add Foo, getFoo.
4566 // * ASTContext::getFooType
4567 // * ASTContext::mergeFunctionTypes
4568 // * FunctionNoProtoType::Profile
4569 // * FunctionProtoType::Profile
4570 // * TypePrinter::PrintFunctionProto
4571 // * AST read and write
4572 // * Codegen
4573 class ExtInfo {
4574 friend class FunctionType;
4575
4576 // Feel free to rearrange or add bits, but if you go over 16, you'll need to
4577 // adjust the Bits field below, and if you add bits, you'll need to adjust
4578 // Type::FunctionTypeBitfields::ExtInfo as well.
4579
4580 // | CC |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
4581 // |0 .. 5| 6 | 7 | 8 |9 .. 11| 12 | 13 |
4582 //
4583 // regparm is either 0 (no regparm attribute) or the regparm value+1.
4584 enum { CallConvMask = 0x3F };
4585 enum { NoReturnMask = 0x40 };
4586 enum { ProducesResultMask = 0x80 };
4587 enum { NoCallerSavedRegsMask = 0x100 };
4588 enum { RegParmMask = 0xe00, RegParmOffset = 9 };
4589 enum { NoCfCheckMask = 0x1000 };
4590 enum { CmseNSCallMask = 0x2000 };
4591 uint16_t Bits = CC_C;
4592
4593 ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
4594
4595 public:
4596 // Constructor with no defaults. Use this when you know that you
4597 // have all the elements (when reading an AST file for example).
4598 ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
4599 bool producesResult, bool noCallerSavedRegs, bool NoCfCheck,
4600 bool cmseNSCall) {
4601 assert((!hasRegParm || regParm < 7) && "Invalid regparm value");
4602 Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) |
4603 (producesResult ? ProducesResultMask : 0) |
4604 (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) |
4605 (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) |
4606 (NoCfCheck ? NoCfCheckMask : 0) |
4607 (cmseNSCall ? CmseNSCallMask : 0);
4608 }
4609
4610 // Constructor with all defaults. Use when for example creating a
4611 // function known to use defaults.
4612 ExtInfo() = default;
4613
4614 // Constructor with just the calling convention, which is an important part
4615 // of the canonical type.
4616 ExtInfo(CallingConv CC) : Bits(CC) {}
4617
4618 bool getNoReturn() const { return Bits & NoReturnMask; }
4619 bool getProducesResult() const { return Bits & ProducesResultMask; }
4620 bool getCmseNSCall() const { return Bits & CmseNSCallMask; }
4621 bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
4622 bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
4623 bool getHasRegParm() const { return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
4624
4625 unsigned getRegParm() const {
4626 unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
4627 if (RegParm > 0)
4628 --RegParm;
4629 return RegParm;
4630 }
4631
4632 CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }
4633
4634 bool operator==(ExtInfo Other) const {
4635 return Bits == Other.Bits;
4636 }
4637 bool operator!=(ExtInfo Other) const {
4638 return Bits != Other.Bits;
4639 }
4640
4641 // Note that we don't have setters. That is by design, use
4642 // the following with methods instead of mutating these objects.
4643
4644 ExtInfo withNoReturn(bool noReturn) const {
4645 if (noReturn)
4646 return ExtInfo(Bits | NoReturnMask);
4647 else
4648 return ExtInfo(Bits & ~NoReturnMask);
4649 }
4650
4651 ExtInfo withProducesResult(bool producesResult) const {
4652 if (producesResult)
4653 return ExtInfo(Bits | ProducesResultMask);
4654 else
4655 return ExtInfo(Bits & ~ProducesResultMask);
4656 }
4657
4658 ExtInfo withCmseNSCall(bool cmseNSCall) const {
4659 if (cmseNSCall)
4660 return ExtInfo(Bits | CmseNSCallMask);
4661 else
4662 return ExtInfo(Bits & ~CmseNSCallMask);
4663 }
4664
4665 ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
4666 if (noCallerSavedRegs)
4667 return ExtInfo(Bits | NoCallerSavedRegsMask);
4668 else
4669 return ExtInfo(Bits & ~NoCallerSavedRegsMask);
4670 }
4671
4672 ExtInfo withNoCfCheck(bool noCfCheck) const {
4673 if (noCfCheck)
4674 return ExtInfo(Bits | NoCfCheckMask);
4675 else
4676 return ExtInfo(Bits & ~NoCfCheckMask);
4677 }
4678
4679 ExtInfo withRegParm(unsigned RegParm) const {
4680 assert(RegParm < 7 && "Invalid regparm value");
4681 return ExtInfo((Bits & ~RegParmMask) |
4682 ((RegParm + 1) << RegParmOffset));
4683 }
4684
4685 ExtInfo withCallingConv(CallingConv cc) const {
4686 return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
4687 }
4688
4689 void Profile(llvm::FoldingSetNodeID &ID) const {
4690 ID.AddInteger(Bits);
4691 }
4692 };
4693
4694 /// A simple holder for a QualType representing a type in an
4695 /// exception specification. Unfortunately needed by FunctionProtoType
4696 /// because TrailingObjects cannot handle repeated types.
4698
4699 /// A simple holder for various uncommon bits which do not fit in
4700 /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
4701 /// alignment of subsequent objects in TrailingObjects.
4702 struct alignas(void *) FunctionTypeExtraBitfields {
4703 /// The number of types in the exception specification.
4704 /// A whole unsigned is not needed here and according to
4705 /// [implimits] 8 bits would be enough here.
4706 unsigned NumExceptionType : 10;
4707
4708 LLVM_PREFERRED_TYPE(bool)
4710
4711 LLVM_PREFERRED_TYPE(bool)
4713
4714 LLVM_PREFERRED_TYPE(bool)
4717
4722 };
4723
4724 /// A holder for extra information from attributes which aren't part of an
4725 /// \p AttributedType.
4726 struct alignas(void *) FunctionTypeExtraAttributeInfo {
4727 /// A CFI "salt" that differentiates functions with the same prototype.
4728 StringRef CFISalt;
4729
4730 operator bool() const { return !CFISalt.empty(); }
4731
4732 void Profile(llvm::FoldingSetNodeID &ID) const { ID.AddString(CFISalt); }
4733 };
4734
4735 /// The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number
4736 /// of function type attributes that can be set on function types, including
4737 /// function pointers.
4742
4743 // Describes the value of the state using ArmStateValue.
4748
4749 // A bit to tell whether a function is agnostic about sme ZA state.
4752
4754 0b1'111'111'11 // We can't support more than 9 bits because of
4755 // the bitmask in FunctionTypeArmAttributes
4756 // and ExtProtoInfo.
4757 };
4758
4759 enum ArmStateValue : unsigned {
4765 };
4766
4767 static ArmStateValue getArmZAState(unsigned AttrBits) {
4768 return static_cast<ArmStateValue>((AttrBits & SME_ZAMask) >> SME_ZAShift);
4769 }
4770
4771 static ArmStateValue getArmZT0State(unsigned AttrBits) {
4772 return static_cast<ArmStateValue>((AttrBits & SME_ZT0Mask) >> SME_ZT0Shift);
4773 }
4774
4775 /// A holder for Arm type attributes as described in the Arm C/C++
4776 /// Language extensions which are not particularly common to all
4777 /// types and therefore accounted separately from FunctionTypeBitfields.
4778 struct alignas(void *) FunctionTypeArmAttributes {
4779 /// Any AArch64 SME ACLE type attributes that need to be propagated
4780 /// on declarations and function pointers.
4781 LLVM_PREFERRED_TYPE(AArch64SMETypeAttributes)
4783
4785 };
4786
4787protected:
4790 : Type(tc, Canonical, Dependence), ResultType(res) {
4791 FunctionTypeBits.ExtInfo = Info.Bits;
4792 }
4793
4795 if (isFunctionProtoType())
4796 return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
4797
4798 return Qualifiers();
4799 }
4800
4801public:
4802 QualType getReturnType() const { return ResultType; }
4803
4804 bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
4805 unsigned getRegParmType() const { return getExtInfo().getRegParm(); }
4806
4807 /// Determine whether this function type includes the GNU noreturn
4808 /// attribute. The C++11 [[noreturn]] attribute does not affect the function
4809 /// type.
4810 bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }
4811
4812 /// Determine whether this is a function prototype that includes the
4813 /// cfi_unchecked_callee attribute.
4814 bool getCFIUncheckedCalleeAttr() const;
4815
4816 bool getCmseNSCallAttr() const { return getExtInfo().getCmseNSCall(); }
4817 CallingConv getCallConv() const { return getExtInfo().getCC(); }
4818 ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }
4819
4820 static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
4821 "Const, volatile and restrict are assumed to be a subset of "
4822 "the fast qualifiers.");
4823
4824 bool isConst() const { return getFastTypeQuals().hasConst(); }
4825 bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
4826 bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }
4827
4828 /// Determine the type of an expression that calls a function of
4829 /// this type.
4830 QualType getCallResultType(const ASTContext &Context) const {
4831 return getReturnType().getNonLValueExprType(Context);
4832 }
4833
4834 static StringRef getNameForCallConv(CallingConv CC);
4835
4836 static bool classof(const Type *T) {
4837 return T->getTypeClass() == FunctionNoProto ||
4838 T->getTypeClass() == FunctionProto;
4839 }
4840};
4841
4842/// Represents a K&R-style 'int foo()' function, which has
4843/// no information available about its arguments.
4844class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
4845 friend class ASTContext; // ASTContext creates these.
4846
4847 FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
4848 : FunctionType(FunctionNoProto, Result, Canonical,
4850 ~(TypeDependence::DependentInstantiation |
4851 TypeDependence::UnexpandedPack),
4852 Info) {}
4853
4854public:
4855 // No additional state past what FunctionType provides.
4856
4857 bool isSugared() const { return false; }
4858 QualType desugar() const { return QualType(this, 0); }
4859
4860 void Profile(llvm::FoldingSetNodeID &ID) {
4862 }
4863
4864 static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
4865 ExtInfo Info) {
4866 Info.Profile(ID);
4867 ID.AddPointer(ResultType.getAsOpaquePtr());
4868 }
4869
4870 static bool classof(const Type *T) {
4871 return T->getTypeClass() == FunctionNoProto;
4872 }
4873};
4874
4875// ------------------------------------------------------------------------------
4876
4877/// Represents an abstract function effect, using just an enumeration describing
4878/// its kind.
4880public:
4881 /// Identifies the particular effect.
4889 constexpr static size_t KindCount = static_cast<size_t>(Kind::Last) + 1;
4890
4891 /// Flags describing some behaviors of the effect.
4894 // Can verification inspect callees' implementations? (e.g. nonblocking:
4895 // yes, tcb+types: no). This also implies the need for 2nd-pass
4896 // verification.
4898
4899 // Language constructs which effects can diagnose as disallowed.
4905 };
4906
4907private:
4908 Kind FKind;
4909
4910 // Expansion: for hypothetical TCB+types, there could be one Kind for TCB,
4911 // then ~16(?) bits "SubKind" to map to a specific named TCB. SubKind would
4912 // be considered for uniqueness.
4913
4914public:
4915 explicit FunctionEffect(Kind K) : FKind(K) {}
4916
4917 /// The kind of the effect.
4918 Kind kind() const { return FKind; }
4919
4920 /// Return the opposite kind, for effects which have opposites.
4921 Kind oppositeKind() const;
4922
4923 /// For serialization.
4924 uint32_t toOpaqueInt32() const { return uint32_t(FKind); }
4926 return FunctionEffect(Kind(Value));
4927 }
4928
4929 /// Flags describing some behaviors of the effect.
4930 Flags flags() const {
4931 switch (kind()) {
4932 case Kind::NonBlocking:
4937 // Same as NonBlocking, except without FE_ExcludeStaticLocalVars.
4940 case Kind::Blocking:
4941 case Kind::Allocating:
4942 return 0;
4943 }
4944 llvm_unreachable("unknown effect kind");
4945 }
4946
4947 /// The description printed in diagnostics, e.g. 'nonblocking'.
4948 StringRef name() const;
4949
4950 friend raw_ostream &operator<<(raw_ostream &OS,
4951 const FunctionEffect &Effect) {
4952 OS << Effect.name();
4953 return OS;
4954 }
4955
4956 /// Determine whether the effect is allowed to be inferred on the callee,
4957 /// which is either a FunctionDecl or BlockDecl. If the returned optional
4958 /// is empty, inference is permitted; otherwise it holds the effect which
4959 /// blocked inference.
4960 /// Example: This allows nonblocking(false) to prevent inference for the
4961 /// function.
4962 std::optional<FunctionEffect>
4963 effectProhibitingInference(const Decl &Callee,
4964 FunctionEffectKindSet CalleeFX) const;
4965
4966 // Return false for success. When true is returned for a direct call, then the
4967 // FE_InferrableOnCallees flag may trigger inference rather than an immediate
4968 // diagnostic. Caller should be assumed to have the effect (it may not have it
4969 // explicitly when inferring).
4970 bool shouldDiagnoseFunctionCall(bool Direct,
4971 FunctionEffectKindSet CalleeFX) const;
4972
4974 return LHS.FKind == RHS.FKind;
4975 }
4977 return !(LHS == RHS);
4978 }
4980 return LHS.FKind < RHS.FKind;
4981 }
4982};
4983
4984/// Wrap a function effect's condition expression in another struct so
4985/// that FunctionProtoType's TrailingObjects can treat it separately.
4987 Expr *Cond = nullptr; // if null, unconditional.
4988
4989public:
4991 EffectConditionExpr(Expr *E) : Cond(E) {}
4992
4993 Expr *getCondition() const { return Cond; }
4994
4995 bool operator==(const EffectConditionExpr &RHS) const {
4996 return Cond == RHS.Cond;
4997 }
4998};
4999
5000/// A FunctionEffect plus a potential boolean expression determining whether
5001/// the effect is declared (e.g. nonblocking(expr)). Generally the condition
5002/// expression when present, is dependent.
5006
5009
5010 /// Return a textual description of the effect, and its condition, if any.
5011 std::string description() const;
5012
5013 friend raw_ostream &operator<<(raw_ostream &OS,
5014 const FunctionEffectWithCondition &CFE);
5015};
5016
5017/// Support iteration in parallel through a pair of FunctionEffect and
5018/// EffectConditionExpr containers.
5019template <typename Container> class FunctionEffectIterator {
5020 friend Container;
5021
5022 const Container *Outer = nullptr;
5023 size_t Idx = 0;
5024
5025public:
5027 FunctionEffectIterator(const Container &O, size_t I) : Outer(&O), Idx(I) {}
5029 return Idx == Other.Idx;
5030 }
5032 return Idx != Other.Idx;
5033 }
5034
5036 ++Idx;
5037 return *this;
5038 }
5039
5041 assert(Outer != nullptr && "invalid FunctionEffectIterator");
5042 bool HasConds = !Outer->Conditions.empty();
5043 return FunctionEffectWithCondition{Outer->Effects[Idx],
5044 HasConds ? Outer->Conditions[Idx]
5046 }
5047};
5048
5049/// An immutable set of FunctionEffects and possibly conditions attached to
5050/// them. The effects and conditions reside in memory not managed by this object
5051/// (typically, trailing objects in FunctionProtoType, or borrowed references
5052/// from a FunctionEffectSet).
5053///
5054/// Invariants:
5055/// - there is never more than one instance of any given effect.
5056/// - the array of conditions is either empty or has the same size as the
5057/// array of effects.
5058/// - some conditions may be null expressions; each condition pertains to
5059/// the effect at the same array index.
5060///
5061/// Also, if there are any conditions, at least one of those expressions will be
5062/// dependent, but this is only asserted in the constructor of
5063/// FunctionProtoType.
5064///
5065/// See also FunctionEffectSet, in Sema, which provides a mutable set.
5066class FunctionEffectsRef {
5067 // Restrict classes which can call the private constructor -- these friends
5068 // all maintain the required invariants. FunctionEffectSet is generally the
5069 // only way in which the arrays are created; FunctionProtoType will not
5070 // reorder them.
5071 friend FunctionProtoType;
5072 friend FunctionEffectSet;
5073
5076
5077 // The arrays are expected to have been sorted by the caller, with the
5078 // effects in order. The conditions array must be empty or the same size
5079 // as the effects array, since the conditions are associated with the effects
5080 // at the same array indices.
5081 FunctionEffectsRef(ArrayRef<FunctionEffect> FX,
5083 : Effects(FX), Conditions(Conds) {}
5084
5085public:
5086 /// Extract the effects from a Type if it is a function, block, or member
5087 /// function pointer, or a reference or pointer to one.
5088 static FunctionEffectsRef get(QualType QT);
5089
5090 /// Asserts invariants.
5091 static FunctionEffectsRef create(ArrayRef<FunctionEffect> FX,
5093
5095
5096 bool empty() const { return Effects.empty(); }
5097 size_t size() const { return Effects.size(); }
5098
5099 ArrayRef<FunctionEffect> effects() const { return Effects; }
5100 ArrayRef<EffectConditionExpr> conditions() const { return Conditions; }
5101
5103 friend iterator;
5104 iterator begin() const { return iterator(*this, 0); }
5105 iterator end() const { return iterator(*this, size()); }
5106
5107 friend bool operator==(const FunctionEffectsRef &LHS,
5108 const FunctionEffectsRef &RHS) {
5109 return LHS.Effects == RHS.Effects && LHS.Conditions == RHS.Conditions;
5110 }
5111 friend bool operator!=(const FunctionEffectsRef &LHS,
5112 const FunctionEffectsRef &RHS) {
5113 return !(LHS == RHS);
5114 }
5115
5116 void dump(llvm::raw_ostream &OS) const;
5117};
5118
5119/// A mutable set of FunctionEffect::Kind.
5120class FunctionEffectKindSet {
5121 // For now this only needs to be a bitmap.
5122 constexpr static size_t EndBitPos = FunctionEffect::KindCount;
5123 using KindBitsT = std::bitset<EndBitPos>;
5124
5125 KindBitsT KindBits{};
5126
5127 explicit FunctionEffectKindSet(KindBitsT KB) : KindBits(KB) {}
5128
5129 // Functions to translate between an effect kind, starting at 1, and a
5130 // position in the bitset.
5131
5132 constexpr static size_t kindToPos(FunctionEffect::Kind K) {
5133 return static_cast<size_t>(K);
5134 }
5135
5136 constexpr static FunctionEffect::Kind posToKind(size_t Pos) {
5137 return static_cast<FunctionEffect::Kind>(Pos);
5138 }
5139
5140 // Iterates through the bits which are set.
5141 class iterator {
5142 const FunctionEffectKindSet *Outer = nullptr;
5143 size_t Idx = 0;
5144
5145 // If Idx does not reference a set bit, advance it until it does,
5146 // or until it reaches EndBitPos.
5147 void advanceToNextSetBit() {
5148 while (Idx < EndBitPos && !Outer->KindBits.test(Idx))
5149 ++Idx;
5150 }
5151
5152 public:
5153 iterator();
5154 iterator(const FunctionEffectKindSet &O, size_t I) : Outer(&O), Idx(I) {
5155 advanceToNextSetBit();
5156 }
5157 bool operator==(const iterator &Other) const { return Idx == Other.Idx; }
5158 bool operator!=(const iterator &Other) const { return Idx != Other.Idx; }
5159
5160 iterator operator++() {
5161 ++Idx;
5162 advanceToNextSetBit();
5163 return *this;
5164 }
5165
5166 FunctionEffect operator*() const {
5167 assert(Idx < EndBitPos && "Dereference of end iterator");
5168 return FunctionEffect(posToKind(Idx));
5169 }
5170 };
5171
5172public:
5175
5176 iterator begin() const { return iterator(*this, 0); }
5177 iterator end() const { return iterator(*this, EndBitPos); }
5178
5179 void insert(FunctionEffect Effect) { KindBits.set(kindToPos(Effect.kind())); }
5181 for (FunctionEffect Item : FX.effects())
5182 insert(Item);
5183 }
5184 void insert(FunctionEffectKindSet Set) { KindBits |= Set.KindBits; }
5185
5186 bool empty() const { return KindBits.none(); }
5187 bool contains(const FunctionEffect::Kind EK) const {
5188 return KindBits.test(kindToPos(EK));
5189 }
5190 void dump(llvm::raw_ostream &OS) const;
5191
5192 static FunctionEffectKindSet difference(FunctionEffectKindSet LHS,
5193 FunctionEffectKindSet RHS) {
5194 return FunctionEffectKindSet(LHS.KindBits & ~RHS.KindBits);
5195 }
5196};
5197
5198/// A mutable set of FunctionEffects and possibly conditions attached to them.
5199/// Used to compare and merge effects on declarations.
5200///
5201/// Has the same invariants as FunctionEffectsRef.
5205
5206public:
5208
5210 : Effects(FX.effects()), Conditions(FX.conditions()) {}
5211
5212 bool empty() const { return Effects.empty(); }
5213 size_t size() const { return Effects.size(); }
5214
5216 friend iterator;
5217 iterator begin() const { return iterator(*this, 0); }
5218 iterator end() const { return iterator(*this, size()); }
5219
5220 operator FunctionEffectsRef() const { return {Effects, Conditions}; }
5221
5222 void dump(llvm::raw_ostream &OS) const;
5223
5224 // Mutators
5225
5226 // On insertion, a conflict occurs when attempting to insert an
5227 // effect which is opposite an effect already in the set, or attempting
5228 // to insert an effect which is already in the set but with a condition
5229 // which is not identical.
5235
5236 // Returns true for success (obviating a check of Errs.empty()).
5237 bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs);
5238
5239 // Returns true for success (obviating a check of Errs.empty()).
5240 bool insert(const FunctionEffectsRef &Set, Conflicts &Errs);
5241
5242 // Set operations
5243
5245 FunctionEffectsRef RHS, Conflicts &Errs);
5247 FunctionEffectsRef RHS);
5248};
5249
5250/// Represents a prototype with parameter type info, e.g.
5251/// 'int foo(int)' or 'int foo(void)'. 'void' is represented as having no
5252/// parameters, not as having a single void parameter. Such a type can have
5253/// an exception specification, but this specification is not part of the
5254/// canonical type. FunctionProtoType has several trailing objects, some of
5255/// which optional. For more information about the trailing objects see
5256/// the first comment inside FunctionProtoType.
5257class FunctionProtoType final
5258 : public FunctionType,
5259 public llvm::FoldingSetNode,
5260 private llvm::TrailingObjects<
5261 FunctionProtoType, QualType, SourceLocation,
5262 FunctionType::FunctionTypeExtraBitfields,
5263 FunctionType::FunctionTypeExtraAttributeInfo,
5264 FunctionType::FunctionTypeArmAttributes, FunctionType::ExceptionType,
5265 Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers,
5266 FunctionEffect, EffectConditionExpr> {
5267 friend class ASTContext; // ASTContext creates these.
5268 friend TrailingObjects;
5269
5270 // FunctionProtoType is followed by several trailing objects, some of
5271 // which optional. They are in order:
5272 //
5273 // * An array of getNumParams() QualType holding the parameter types.
5274 // Always present. Note that for the vast majority of FunctionProtoType,
5275 // these will be the only trailing objects.
5276 //
5277 // * Optionally if the function is variadic, the SourceLocation of the
5278 // ellipsis.
5279 //
5280 // * Optionally if some extra data is stored in FunctionTypeExtraBitfields
5281 // (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
5282 // a single FunctionTypeExtraBitfields. Present if and only if
5283 // hasExtraBitfields() is true.
5284 //
5285 // * Optionally exactly one of:
5286 // * an array of getNumExceptions() ExceptionType,
5287 // * a single Expr *,
5288 // * a pair of FunctionDecl *,
5289 // * a single FunctionDecl *
5290 // used to store information about the various types of exception
5291 // specification. See getExceptionSpecSize for the details.
5292 //
5293 // * Optionally an array of getNumParams() ExtParameterInfo holding
5294 // an ExtParameterInfo for each of the parameters. Present if and
5295 // only if hasExtParameterInfos() is true.
5296 //
5297 // * Optionally a Qualifiers object to represent extra qualifiers that can't
5298 // be represented by FunctionTypeBitfields.FastTypeQuals. Present if and
5299 // only if hasExtQualifiers() is true.
5300 //
5301 // * Optionally, an array of getNumFunctionEffects() FunctionEffect.
5302 // Present only when getNumFunctionEffects() > 0
5303 //
5304 // * Optionally, an array of getNumFunctionEffects() EffectConditionExpr.
5305 // Present only when getNumFunctionEffectConditions() > 0.
5306 //
5307 // The optional FunctionTypeExtraBitfields has to be before the data
5308 // related to the exception specification since it contains the number
5309 // of exception types.
5310 //
5311 // We put the ExtParameterInfos later. If all were equal, it would make
5312 // more sense to put these before the exception specification, because
5313 // it's much easier to skip past them compared to the elaborate switch
5314 // required to skip the exception specification. However, all is not
5315 // equal; ExtParameterInfos are used to model very uncommon features,
5316 // and it's better not to burden the more common paths.
5317
5318public:
5319 /// Holds information about the various types of exception specification.
5320 /// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
5321 /// used to group together the various bits of information about the
5322 /// exception specification.
5324 /// The kind of exception specification this is.
5326
5327 /// Explicitly-specified list of exception types.
5329
5330 /// Noexcept expression, if this is a computed noexcept specification.
5331 Expr *NoexceptExpr = nullptr;
5332
5333 /// The function whose exception specification this is, for
5334 /// EST_Unevaluated and EST_Uninstantiated.
5336
5337 /// The function template whose exception specification this is instantiated
5338 /// from, for EST_Uninstantiated.
5340
5342
5344
5345 void instantiate();
5346 };
5347
5348 /// Extra information about a function prototype. ExtProtoInfo is not
5349 /// stored as such in FunctionProtoType but is used to group together
5350 /// the various bits of extra information about a function prototype.
5360
5361 LLVM_PREFERRED_TYPE(bool)
5363 LLVM_PREFERRED_TYPE(bool)
5364 unsigned HasTrailingReturn : 1;
5365 LLVM_PREFERRED_TYPE(bool)
5367 LLVM_PREFERRED_TYPE(AArch64SMETypeAttributes)
5369
5373
5377
5379 ExtProtoInfo Result(*this);
5380 Result.ExceptionSpec = ESI;
5381 return Result;
5382 }
5383
5385 ExtProtoInfo Result(*this);
5386 Result.CFIUncheckedCallee = CFIUncheckedCallee;
5387 return Result;
5388 }
5389
5396
5400
5402 return static_cast<bool>(ExtraAttributeInfo);
5403 }
5404
5405 void setArmSMEAttribute(AArch64SMETypeAttributes Kind, bool Enable = true) {
5406 if (Enable)
5407 AArch64SMEAttributes |= Kind;
5408 else
5409 AArch64SMEAttributes &= ~Kind;
5410 }
5411 };
5412
5413private:
5414 unsigned numTrailingObjects(OverloadToken<QualType>) const {
5415 return getNumParams();
5416 }
5417
5418 unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
5419 return isVariadic();
5420 }
5421
5422 unsigned numTrailingObjects(OverloadToken<FunctionTypeArmAttributes>) const {
5423 return hasArmTypeAttributes();
5424 }
5425
5426 unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
5427 return hasExtraBitfields();
5428 }
5429
5430 unsigned
5431 numTrailingObjects(OverloadToken<FunctionTypeExtraAttributeInfo>) const {
5432 return hasExtraAttributeInfo();
5433 }
5434
5435 unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
5436 return getExceptionSpecSize().NumExceptionType;
5437 }
5438
5439 unsigned numTrailingObjects(OverloadToken<Expr *>) const {
5440 return getExceptionSpecSize().NumExprPtr;
5441 }
5442
5443 unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
5444 return getExceptionSpecSize().NumFunctionDeclPtr;
5445 }
5446
5447 unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
5448 return hasExtParameterInfos() ? getNumParams() : 0;
5449 }
5450
5451 unsigned numTrailingObjects(OverloadToken<Qualifiers>) const {
5452 return hasExtQualifiers() ? 1 : 0;
5453 }
5454
5455 unsigned numTrailingObjects(OverloadToken<FunctionEffect>) const {
5456 return getNumFunctionEffects();
5457 }
5458
5459 /// Determine whether there are any argument types that
5460 /// contain an unexpanded parameter pack.
5461 static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
5462 unsigned numArgs) {
5463 for (unsigned Idx = 0; Idx < numArgs; ++Idx)
5464 if (ArgArray[Idx]->containsUnexpandedParameterPack())
5465 return true;
5466
5467 return false;
5468 }
5469
5470 FunctionProtoType(QualType result, ArrayRef<QualType> params,
5471 QualType canonical, const ExtProtoInfo &epi);
5472
5473 /// This struct is returned by getExceptionSpecSize and is used to
5474 /// translate an ExceptionSpecificationType to the number and kind
5475 /// of trailing objects related to the exception specification.
5476 struct ExceptionSpecSizeHolder {
5477 unsigned NumExceptionType;
5478 unsigned NumExprPtr;
5479 unsigned NumFunctionDeclPtr;
5480 };
5481
5482 /// Return the number and kind of trailing objects
5483 /// related to the exception specification.
5484 static ExceptionSpecSizeHolder
5485 getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
5486 switch (EST) {
5487 case EST_None:
5488 case EST_DynamicNone:
5489 case EST_MSAny:
5490 case EST_BasicNoexcept:
5491 case EST_Unparsed:
5492 case EST_NoThrow:
5493 return {0, 0, 0};
5494
5495 case EST_Dynamic:
5496 return {NumExceptions, 0, 0};
5497
5499 case EST_NoexceptFalse:
5500 case EST_NoexceptTrue:
5501 return {0, 1, 0};
5502
5503 case EST_Uninstantiated:
5504 return {0, 0, 2};
5505
5506 case EST_Unevaluated:
5507 return {0, 0, 1};
5508 }
5509 llvm_unreachable("bad exception specification kind");
5510 }
5511
5512 /// Return the number and kind of trailing objects
5513 /// related to the exception specification.
5514 ExceptionSpecSizeHolder getExceptionSpecSize() const {
5515 return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
5516 }
5517
5518 /// Whether the trailing FunctionTypeExtraBitfields is present.
5519 bool hasExtraBitfields() const {
5520 assert((getExceptionSpecType() != EST_Dynamic ||
5521 FunctionTypeBits.HasExtraBitfields) &&
5522 "ExtraBitfields are required for given ExceptionSpecType");
5523 return FunctionTypeBits.HasExtraBitfields;
5524
5525 }
5526
5527 bool hasExtraAttributeInfo() const {
5528 return FunctionTypeBits.HasExtraBitfields &&
5529 getTrailingObjects<FunctionTypeExtraBitfields>()
5530 ->HasExtraAttributeInfo;
5531 }
5532
5533 bool hasArmTypeAttributes() const {
5534 return FunctionTypeBits.HasExtraBitfields &&
5535 getTrailingObjects<FunctionTypeExtraBitfields>()
5536 ->HasArmTypeAttributes;
5537 }
5538
5539 bool hasExtQualifiers() const {
5540 return FunctionTypeBits.HasExtQuals;
5541 }
5542
5543public:
5544 unsigned getNumParams() const { return FunctionTypeBits.NumParams; }
5545
5546 QualType getParamType(unsigned i) const {
5547 assert(i < getNumParams() && "invalid parameter index");
5548 return param_type_begin()[i];
5549 }
5550
5554
5571
5572 /// Get the kind of exception specification on this function.
5574 return static_cast<ExceptionSpecificationType>(
5575 FunctionTypeBits.ExceptionSpecType);
5576 }
5577
5578 /// Return whether this function has any kind of exception spec.
5579 bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }
5580
5581 /// Return whether this function has a dynamic (throw) exception spec.
5585
5586 /// Return whether this function has a noexcept exception spec.
5590
5591 /// Return whether this function has a dependent exception spec.
5592 bool hasDependentExceptionSpec() const;
5593
5594 /// Return whether this function has an instantiation-dependent exception
5595 /// spec.
5596 bool hasInstantiationDependentExceptionSpec() const;
5597
5598 /// Return all the available information about this type's exception spec.
5602 if (Result.Type == EST_Dynamic) {
5603 Result.Exceptions = exceptions();
5604 } else if (isComputedNoexcept(Result.Type)) {
5605 Result.NoexceptExpr = getNoexceptExpr();
5606 } else if (Result.Type == EST_Uninstantiated) {
5607 Result.SourceDecl = getExceptionSpecDecl();
5608 Result.SourceTemplate = getExceptionSpecTemplate();
5609 } else if (Result.Type == EST_Unevaluated) {
5610 Result.SourceDecl = getExceptionSpecDecl();
5611 }
5612 return Result;
5613 }
5614
5615 /// Return the number of types in the exception specification.
5616 unsigned getNumExceptions() const {
5618 ? getTrailingObjects<FunctionTypeExtraBitfields>()
5619 ->NumExceptionType
5620 : 0;
5621 }
5622
5623 /// Return the ith exception type, where 0 <= i < getNumExceptions().
5624 QualType getExceptionType(unsigned i) const {
5625 assert(i < getNumExceptions() && "Invalid exception number!");
5626 return exception_begin()[i];
5627 }
5628
5629 /// Return the expression inside noexcept(expression), or a null pointer
5630 /// if there is none (because the exception spec is not of this form).
5633 return nullptr;
5634 return *getTrailingObjects<Expr *>();
5635 }
5636
5637 /// If this function type has an exception specification which hasn't
5638 /// been determined yet (either because it has not been evaluated or because
5639 /// it has not been instantiated), this is the function whose exception
5640 /// specification is represented by this type.
5644 return nullptr;
5645 return getTrailingObjects<FunctionDecl *>()[0];
5646 }
5647
5648 /// If this function type has an uninstantiated exception
5649 /// specification, this is the function whose exception specification
5650 /// should be instantiated to find the exception specification for
5651 /// this type.
5654 return nullptr;
5655 return getTrailingObjects<FunctionDecl *>()[1];
5656 }
5657
5658 /// Determine whether this function type has a non-throwing exception
5659 /// specification.
5660 CanThrowResult canThrow() const;
5661
5662 /// Determine whether this function type has a non-throwing exception
5663 /// specification. If this depends on template arguments, returns
5664 /// \c ResultIfDependent.
5665 bool isNothrow(bool ResultIfDependent = false) const {
5666 return ResultIfDependent ? canThrow() != CT_Can : canThrow() == CT_Cannot;
5667 }
5668
5669 /// Whether this function prototype is variadic.
5670 bool isVariadic() const { return FunctionTypeBits.Variadic; }
5671
5673 return isVariadic() ? *getTrailingObjects<SourceLocation>()
5674 : SourceLocation();
5675 }
5676
5677 /// Determines whether this function prototype contains a
5678 /// parameter pack at the end.
5679 ///
5680 /// A function template whose last parameter is a parameter pack can be
5681 /// called with an arbitrary number of arguments, much like a variadic
5682 /// function.
5683 bool isTemplateVariadic() const;
5684
5685 /// Whether this function prototype has a trailing return type.
5686 bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }
5687
5689 return FunctionTypeBits.CFIUncheckedCallee;
5690 }
5691
5693 if (hasExtQualifiers())
5694 return *getTrailingObjects<Qualifiers>();
5695 else
5696 return getFastTypeQuals();
5697 }
5698
5699 /// Retrieve the ref-qualifier associated with this function type.
5701 return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
5702 }
5703
5705
5709
5711 return getTrailingObjects<QualType>();
5712 }
5713
5717
5719
5721 return {exception_begin(), exception_end()};
5722 }
5723
5725 return reinterpret_cast<exception_iterator>(
5726 getTrailingObjects<ExceptionType>());
5727 }
5728
5732
5733 /// Is there any interesting extra information for any of the parameters
5734 /// of this function type?
5736 return FunctionTypeBits.HasExtParameterInfos;
5737 }
5738
5740 assert(hasExtParameterInfos());
5741 return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
5742 getNumParams());
5743 }
5744
5745 /// Return a pointer to the beginning of the array of extra parameter
5746 /// information, if present, or else null if none of the parameters
5747 /// carry it. This is equivalent to getExtProtoInfo().ExtParameterInfos.
5749 if (!hasExtParameterInfos())
5750 return nullptr;
5751 return getTrailingObjects<ExtParameterInfo>();
5752 }
5753
5754 /// Return the extra attribute information.
5756 if (hasExtraAttributeInfo())
5757 return *getTrailingObjects<FunctionTypeExtraAttributeInfo>();
5759 }
5760
5761 /// Return a bitmask describing the SME attributes on the function type, see
5762 /// AArch64SMETypeAttributes for their values.
5763 unsigned getAArch64SMEAttributes() const {
5764 if (!hasArmTypeAttributes())
5765 return SME_NormalFunction;
5766 return getTrailingObjects<FunctionTypeArmAttributes>()
5767 ->AArch64SMEAttributes;
5768 }
5769
5771 assert(I < getNumParams() && "parameter index out of range");
5773 return getTrailingObjects<ExtParameterInfo>()[I];
5774 return ExtParameterInfo();
5775 }
5776
5777 ParameterABI getParameterABI(unsigned I) const {
5778 assert(I < getNumParams() && "parameter index out of range");
5780 return getTrailingObjects<ExtParameterInfo>()[I].getABI();
5782 }
5783
5784 bool isParamConsumed(unsigned I) const {
5785 assert(I < getNumParams() && "parameter index out of range");
5787 return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
5788 return false;
5789 }
5790
5791 unsigned getNumFunctionEffects() const {
5792 return hasExtraBitfields()
5793 ? getTrailingObjects<FunctionTypeExtraBitfields>()
5794 ->NumFunctionEffects
5795 : 0;
5796 }
5797
5798 // For serialization.
5800 if (hasExtraBitfields()) {
5801 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5802 if (Bitfields->NumFunctionEffects > 0)
5803 return getTrailingObjects<FunctionEffect>(
5804 Bitfields->NumFunctionEffects);
5805 }
5806 return {};
5807 }
5808
5810 if (hasExtraBitfields()) {
5811 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5812 if (Bitfields->EffectsHaveConditions)
5813 return Bitfields->NumFunctionEffects;
5814 }
5815 return 0;
5816 }
5817
5818 // For serialization.
5820 if (hasExtraBitfields()) {
5821 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5822 if (Bitfields->EffectsHaveConditions)
5823 return getTrailingObjects<EffectConditionExpr>(
5824 Bitfields->NumFunctionEffects);
5825 }
5826 return {};
5827 }
5828
5829 // Combines effects with their conditions.
5831 if (hasExtraBitfields()) {
5832 const auto *Bitfields = getTrailingObjects<FunctionTypeExtraBitfields>();
5833 if (Bitfields->NumFunctionEffects > 0) {
5834 const size_t NumConds = Bitfields->EffectsHaveConditions
5835 ? Bitfields->NumFunctionEffects
5836 : 0;
5837 return FunctionEffectsRef(
5838 getTrailingObjects<FunctionEffect>(Bitfields->NumFunctionEffects),
5839 {NumConds ? getTrailingObjects<EffectConditionExpr>() : nullptr,
5840 NumConds});
5841 }
5842 }
5843 return {};
5844 }
5845
5846 bool isSugared() const { return false; }
5847 QualType desugar() const { return QualType(this, 0); }
5848
5849 void printExceptionSpecification(raw_ostream &OS,
5850 const PrintingPolicy &Policy) const;
5851
5852 static bool classof(const Type *T) {
5853 return T->getTypeClass() == FunctionProto;
5854 }
5855
5856 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
5857 static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
5858 param_type_iterator ArgTys, unsigned NumArgs,
5859 const ExtProtoInfo &EPI, const ASTContext &Context,
5860 bool Canonical);
5861};
5862
5863/// The elaboration keyword that precedes a qualified type name or
5864/// introduces an elaborated-type-specifier.
5866 /// The "struct" keyword introduces the elaborated-type-specifier.
5868
5869 /// The "__interface" keyword introduces the elaborated-type-specifier.
5871
5872 /// The "union" keyword introduces the elaborated-type-specifier.
5874
5875 /// The "class" keyword introduces the elaborated-type-specifier.
5877
5878 /// The "enum" keyword introduces the elaborated-type-specifier.
5880
5881 /// The "typename" keyword precedes the qualified type name, e.g.,
5882 /// \c typename T::type.
5884
5885 /// No keyword precedes the qualified type name.
5887};
5888
5889/// The kind of a tag type.
5890enum class TagTypeKind {
5891 /// The "struct" keyword.
5893
5894 /// The "__interface" keyword.
5896
5897 /// The "union" keyword.
5899
5900 /// The "class" keyword.
5902
5903 /// The "enum" keyword.
5905};
5906
5907/// Provides a few static helpers for converting and printing
5908/// elaborated type keyword and tag type kind enumerations.
5910 /// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
5911 static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);
5912
5913 /// Converts a type specifier (DeclSpec::TST) into a tag type kind.
5914 /// It is an error to provide a type specifier which *isn't* a tag kind here.
5915 static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);
5916
5917 /// Converts a TagTypeKind into an elaborated type keyword.
5919
5920 /// Converts an elaborated type keyword into a TagTypeKind.
5921 /// It is an error to provide an elaborated type keyword
5922 /// which *isn't* a tag kind here.
5924
5926
5928
5929 static StringRef getTagTypeKindName(TagTypeKind Kind) {
5931 }
5932};
5933
5934template <class T> class KeywordWrapper : public T, public KeywordHelpers {
5935protected:
5936 template <class... As>
5938 : T(std::forward<As>(as)...) {
5939 this->KeywordWrapperBits.Keyword = llvm::to_underlying(Keyword);
5940 }
5941
5942public:
5944 return static_cast<ElaboratedTypeKeyword>(this->KeywordWrapperBits.Keyword);
5945 }
5946
5949};
5950
5951/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5952/// The keyword in stored in the free bits of the base class.
5953class TypeWithKeyword : public KeywordWrapper<Type> {
5954protected:
5958};
5959
5960template <class T> struct FoldingSetPlaceholder : llvm::FoldingSetNode {
5961 void Profile(llvm::FoldingSetNodeID &ID) { getType()->Profile(ID); }
5962
5963 inline const T *getType() const {
5964 constexpr unsigned long Offset =
5965 llvm::alignTo(sizeof(T), alignof(FoldingSetPlaceholder));
5966 const auto *Addr = reinterpret_cast<const T *>(
5967 reinterpret_cast<const char *>(this) - Offset);
5968 assert(llvm::isAddrAligned(llvm::Align(alignof(T)), Addr));
5969 return Addr;
5970 }
5971};
5972
5973/// Represents the dependent type named by a dependently-scoped
5974/// typename using declaration, e.g.
5975/// using typename Base<T>::foo;
5976///
5977/// Template instantiation turns these into the underlying type.
5978class UnresolvedUsingType final
5979 : public TypeWithKeyword,
5980 private llvm::TrailingObjects<UnresolvedUsingType,
5981 FoldingSetPlaceholder<UnresolvedUsingType>,
5982 NestedNameSpecifier> {
5983 friend class ASTContext; // ASTContext creates these.
5984 friend TrailingObjects;
5985
5987
5988 unsigned numTrailingObjects(
5989 OverloadToken<FoldingSetPlaceholder<UnresolvedUsingType>>) const {
5990 assert(UnresolvedUsingBits.hasQualifier ||
5992 return 1;
5993 }
5994
5995 FoldingSetPlaceholder<UnresolvedUsingType> *getFoldingSetPlaceholder() {
5996 assert(numTrailingObjects(
5998 1);
5999 return getTrailingObjects<FoldingSetPlaceholder<UnresolvedUsingType>>();
6000 }
6001
6002 UnresolvedUsingType(ElaboratedTypeKeyword Keyword,
6003 NestedNameSpecifier Qualifier,
6004 const UnresolvedUsingTypenameDecl *D,
6005 const Type *CanonicalType);
6006
6007public:
6009 return UnresolvedUsingBits.hasQualifier
6010 ? *getTrailingObjects<NestedNameSpecifier>()
6011 : std::nullopt;
6012 }
6013
6014 UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }
6015
6016 bool isSugared() const { return false; }
6017 QualType desugar() const { return QualType(this, 0); }
6018
6019 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
6020 NestedNameSpecifier Qualifier,
6021 const UnresolvedUsingTypenameDecl *D) {
6022 static_assert(llvm::to_underlying(ElaboratedTypeKeyword::None) <= 7);
6023 ID.AddInteger(uintptr_t(D) | llvm::to_underlying(Keyword));
6024 if (Qualifier)
6025 Qualifier.Profile(ID);
6026 }
6027
6028 void Profile(llvm::FoldingSetNodeID &ID) const {
6030 }
6031
6032 static bool classof(const Type *T) {
6033 return T->getTypeClass() == UnresolvedUsing;
6034 }
6035};
6036
6037class UsingType final : public TypeWithKeyword,
6038 public llvm::FoldingSetNode,
6039 llvm::TrailingObjects<UsingType, NestedNameSpecifier> {
6040 UsingShadowDecl *D;
6041 QualType UnderlyingType;
6042
6043 friend class ASTContext; // ASTContext creates these.
6044 friend TrailingObjects;
6045
6047 const UsingShadowDecl *D, QualType UnderlyingType);
6048
6049public:
6051 return UsingBits.hasQualifier ? *getTrailingObjects() : std::nullopt;
6052 }
6053
6054 UsingShadowDecl *getDecl() const { return D; }
6055
6056 QualType desugar() const { return UnderlyingType; }
6057 bool isSugared() const { return true; }
6058
6059 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
6060 NestedNameSpecifier Qualifier, const UsingShadowDecl *D,
6061 QualType UnderlyingType) {
6062 static_assert(llvm::to_underlying(ElaboratedTypeKeyword::None) <= 7);
6063 ID.AddInteger(uintptr_t(D) | llvm::to_underlying(Keyword));
6064 UnderlyingType.Profile(ID);
6065 if (Qualifier)
6066 Qualifier.Profile(ID);
6067 }
6068
6069 void Profile(llvm::FoldingSetNodeID &ID) const {
6070 Profile(ID, getKeyword(), getQualifier(), D, desugar());
6071 }
6072 static bool classof(const Type *T) { return T->getTypeClass() == Using; }
6073};
6074
6075class TypedefType final
6076 : public TypeWithKeyword,
6077 private llvm::TrailingObjects<TypedefType,
6078 FoldingSetPlaceholder<TypedefType>,
6079 NestedNameSpecifier, QualType> {
6080 TypedefNameDecl *Decl;
6081 friend class ASTContext; // ASTContext creates these.
6082 friend TrailingObjects;
6083
6084 unsigned
6085 numTrailingObjects(OverloadToken<FoldingSetPlaceholder<TypedefType>>) const {
6086 assert(TypedefBits.hasQualifier || TypedefBits.hasTypeDifferentFromDecl ||
6088 return 1;
6089 }
6090
6091 unsigned numTrailingObjects(OverloadToken<NestedNameSpecifier>) const {
6092 return TypedefBits.hasQualifier;
6093 }
6094
6095 TypedefType(TypeClass TC, ElaboratedTypeKeyword Keyword,
6096 NestedNameSpecifier Qualifier, const TypedefNameDecl *D,
6097 QualType UnderlyingType, bool HasTypeDifferentFromDecl);
6098
6099 FoldingSetPlaceholder<TypedefType> *getFoldingSetPlaceholder() {
6100 assert(numTrailingObjects(
6101 OverloadToken<FoldingSetPlaceholder<TypedefType>>{}) == 1);
6102 return getTrailingObjects<FoldingSetPlaceholder<TypedefType>>();
6103 }
6104
6105public:
6107 return TypedefBits.hasQualifier ? *getTrailingObjects<NestedNameSpecifier>()
6108 : std::nullopt;
6109 }
6110
6111 TypedefNameDecl *getDecl() const { return Decl; }
6112
6113 bool isSugared() const { return true; }
6114
6115 // This always has the 'same' type as declared, but not necessarily identical.
6116 QualType desugar() const;
6117
6118 // Internal helper, for debugging purposes.
6119 bool typeMatchesDecl() const { return !TypedefBits.hasTypeDifferentFromDecl; }
6120
6121 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
6122 NestedNameSpecifier Qualifier,
6123 const TypedefNameDecl *Decl, QualType Underlying) {
6124
6125 ID.AddInteger(uintptr_t(Decl) | (Keyword != ElaboratedTypeKeyword::None) |
6126 (!Qualifier << 1));
6128 ID.AddInteger(llvm::to_underlying(Keyword));
6129 if (Qualifier)
6130 Qualifier.Profile(ID);
6131 if (!Underlying.isNull())
6132 Underlying.Profile(ID);
6133 }
6134
6135 void Profile(llvm::FoldingSetNodeID &ID) const {
6137 typeMatchesDecl() ? QualType() : desugar());
6138 }
6139
6140 static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
6141};
6142
6143/// Sugar type that represents a type that was qualified by a qualifier written
6144/// as a macro invocation.
6145class MacroQualifiedType : public Type {
6146 friend class ASTContext; // ASTContext creates these.
6147
6148 QualType UnderlyingTy;
6149 const IdentifierInfo *MacroII;
6150
6151 MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
6152 const IdentifierInfo *MacroII)
6153 : Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
6154 UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
6155 assert(isa<AttributedType>(UnderlyingTy) &&
6156 "Expected a macro qualified type to only wrap attributed types.");
6157 }
6158
6159public:
6160 const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
6161 QualType getUnderlyingType() const { return UnderlyingTy; }
6162
6163 /// Return this attributed type's modified type with no qualifiers attached to
6164 /// it.
6165 QualType getModifiedType() const;
6166
6167 bool isSugared() const { return true; }
6168 QualType desugar() const;
6169
6170 static bool classof(const Type *T) {
6171 return T->getTypeClass() == MacroQualified;
6172 }
6173};
6174
6175/// Represents a `typeof` (or __typeof__) expression (a C23 feature and GCC
6176/// extension) or a `typeof_unqual` expression (a C23 feature).
6177class TypeOfExprType : public Type {
6178 Expr *TOExpr;
6179 const ASTContext &Context;
6180
6181protected:
6182 friend class ASTContext; // ASTContext creates these.
6183
6184 TypeOfExprType(const ASTContext &Context, Expr *E, TypeOfKind Kind,
6185 QualType Can = QualType());
6186
6187public:
6188 Expr *getUnderlyingExpr() const { return TOExpr; }
6189
6190 /// Returns the kind of 'typeof' type this is.
6192 return static_cast<TypeOfKind>(TypeOfBits.Kind);
6193 }
6194
6195 /// Remove a single level of sugar.
6196 QualType desugar() const;
6197
6198 /// Returns whether this type directly provides sugar.
6199 bool isSugared() const;
6200
6201 static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
6202};
6203
6204/// Internal representation of canonical, dependent
6205/// `typeof(expr)` types.
6206///
6207/// This class is used internally by the ASTContext to manage
6208/// canonical, dependent types, only. Clients will only see instances
6209/// of this class via TypeOfExprType nodes.
6211 public llvm::FoldingSetNode {
6212public:
6214 : TypeOfExprType(Context, E, Kind) {}
6215
6216 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
6217 Profile(ID, Context, getUnderlyingExpr(),
6219 }
6220
6221 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
6222 Expr *E, bool IsUnqual);
6223};
6224
6225/// Represents `typeof(type)`, a C23 feature and GCC extension, or
6226/// `typeof_unqual(type), a C23 feature.
6227class TypeOfType : public Type {
6228 friend class ASTContext; // ASTContext creates these.
6229
6230 QualType TOType;
6231 const ASTContext &Context;
6232
6233 TypeOfType(const ASTContext &Context, QualType T, QualType Can,
6234 TypeOfKind Kind);
6235
6236public:
6237 QualType getUnmodifiedType() const { return TOType; }
6238
6239 /// Remove a single level of sugar.
6240 QualType desugar() const;
6241
6242 /// Returns whether this type directly provides sugar.
6243 bool isSugared() const { return true; }
6244
6245 /// Returns the kind of 'typeof' type this is.
6246 TypeOfKind getKind() const {
6247 return static_cast<TypeOfKind>(TypeOfBits.Kind);
6248 }
6249
6250 static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
6251};
6252
6253/// Represents the type `decltype(expr)` (C++11).
6254class DecltypeType : public Type {
6255 Expr *E;
6256 QualType UnderlyingType;
6257
6258protected:
6259 friend class ASTContext; // ASTContext creates these.
6260
6261 DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
6262
6263public:
6264 Expr *getUnderlyingExpr() const { return E; }
6265 QualType getUnderlyingType() const { return UnderlyingType; }
6266
6267 /// Remove a single level of sugar.
6268 QualType desugar() const;
6269
6270 /// Returns whether this type directly provides sugar.
6271 bool isSugared() const;
6272
6273 static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
6274};
6275
6276/// Internal representation of canonical, dependent
6277/// decltype(expr) types.
6278///
6279/// This class is used internally by the ASTContext to manage
6280/// canonical, dependent types, only. Clients will only see instances
6281/// of this class via DecltypeType nodes.
6282class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
6283public:
6284 DependentDecltypeType(Expr *E);
6285
6286 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
6287 Profile(ID, Context, getUnderlyingExpr());
6288 }
6289
6290 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
6291 Expr *E);
6292};
6293
6294class PackIndexingType final
6295 : public Type,
6296 public llvm::FoldingSetNode,
6297 private llvm::TrailingObjects<PackIndexingType, QualType> {
6298 friend TrailingObjects;
6299
6300 QualType Pattern;
6301 Expr *IndexExpr;
6302
6303 unsigned Size : 31;
6304
6305 LLVM_PREFERRED_TYPE(bool)
6306 unsigned FullySubstituted : 1;
6307
6308protected:
6309 friend class ASTContext; // ASTContext creates these.
6310 PackIndexingType(QualType Canonical, QualType Pattern, Expr *IndexExpr,
6311 bool FullySubstituted, ArrayRef<QualType> Expansions = {});
6312
6313public:
6314 Expr *getIndexExpr() const { return IndexExpr; }
6315 QualType getPattern() const { return Pattern; }
6316
6317 bool isSugared() const { return hasSelectedType(); }
6318
6319 QualType desugar() const {
6320 if (hasSelectedType())
6321 return getSelectedType();
6322 return QualType(this, 0);
6323 }
6324
6325 QualType getSelectedType() const {
6326 assert(hasSelectedType() && "Type is dependant");
6327 return *(getExpansionsPtr() + *getSelectedIndex());
6328 }
6329
6330 UnsignedOrNone getSelectedIndex() const;
6331
6332 bool hasSelectedType() const { return getSelectedIndex() != std::nullopt; }
6333
6334 bool isFullySubstituted() const { return FullySubstituted; }
6335
6336 bool expandsToEmptyPack() const { return isFullySubstituted() && Size == 0; }
6337
6338 ArrayRef<QualType> getExpansions() const {
6339 return {getExpansionsPtr(), Size};
6340 }
6341
6342 static bool classof(const Type *T) {
6343 return T->getTypeClass() == PackIndexing;
6344 }
6345
6346 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context);
6347 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
6348 QualType Pattern, Expr *E, bool FullySubstituted,
6349 ArrayRef<QualType> Expansions);
6350
6351private:
6352 const QualType *getExpansionsPtr() const { return getTrailingObjects(); }
6353
6354 static TypeDependence computeDependence(QualType Pattern, Expr *IndexExpr,
6355 ArrayRef<QualType> Expansions = {});
6356};
6357
6358/// A unary type transform, which is a type constructed from another.
6359class UnaryTransformType : public Type, public llvm::FoldingSetNode {
6360public:
6361 enum UTTKind {
6362#define TRANSFORM_TYPE_TRAIT_DEF(Enum, _) Enum,
6363#include "clang/Basic/TransformTypeTraits.def"
6364 };
6365
6366private:
6367 /// The untransformed type.
6368 QualType BaseType;
6369
6370 /// The transformed type if not dependent, otherwise the same as BaseType.
6371 QualType UnderlyingType;
6372
6373 UTTKind UKind;
6374
6375protected:
6376 friend class ASTContext;
6377
6378 UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
6379 QualType CanonicalTy);
6380
6381public:
6382 bool isSugared() const { return !isDependentType(); }
6383 QualType desugar() const { return UnderlyingType; }
6384
6385 QualType getUnderlyingType() const { return UnderlyingType; }
6386 QualType getBaseType() const { return BaseType; }
6387
6388 UTTKind getUTTKind() const { return UKind; }
6389
6390 static bool classof(const Type *T) {
6391 return T->getTypeClass() == UnaryTransform;
6392 }
6393
6394 void Profile(llvm::FoldingSetNodeID &ID) {
6395 Profile(ID, getBaseType(), getUnderlyingType(), getUTTKind());
6396 }
6397
6398 static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
6399 QualType UnderlyingType, UTTKind UKind) {
6400 BaseType.Profile(ID);
6401 UnderlyingType.Profile(ID);
6402 ID.AddInteger(UKind);
6403 }
6404};
6405
6406class TagType : public TypeWithKeyword {
6407 friend class ASTContext; // ASTContext creates these.
6408
6409 /// Stores the TagDecl associated with this type. The decl may point to any
6410 /// TagDecl that declares the entity.
6411 TagDecl *decl;
6412
6413 void *getTrailingPointer() const;
6414 NestedNameSpecifier &getTrailingQualifier() const;
6415
6416protected:
6417 TagType(TypeClass TC, ElaboratedTypeKeyword Keyword,
6418 NestedNameSpecifier Qualifier, const TagDecl *TD, bool OwnsTag,
6419 bool IsInjected, const Type *CanonicalType);
6420
6421public:
6422 // FIXME: Temporarily renamed from `getDecl` in order to facilitate
6423 // rebasing, due to change in behaviour. This should be renamed back
6424 // to `getDecl` once the change is settled.
6425 TagDecl *getOriginalDecl() const { return decl; }
6426
6427 NestedNameSpecifier getQualifier() const;
6428
6429 /// Does the TagType own this declaration of the Tag?
6430 bool isTagOwned() const { return TagTypeBits.OwnsTag; }
6431
6432 bool isInjected() const { return TagTypeBits.IsInjected; }
6433
6434 ClassTemplateDecl *getTemplateDecl() const;
6435 TemplateName getTemplateName(const ASTContext &Ctx) const;
6436 ArrayRef<TemplateArgument> getTemplateArgs(const ASTContext &Ctx) const;
6437
6438 bool isSugared() const { return false; }
6439 QualType desugar() const { return getCanonicalTypeInternal(); }
6440
6441 static bool classof(const Type *T) {
6442 return T->getTypeClass() == Enum || T->getTypeClass() == Record ||
6443 T->getTypeClass() == InjectedClassName;
6444 }
6445};
6446
6447struct TagTypeFoldingSetPlaceholder : public llvm::FoldingSetNode {
6448 static constexpr size_t getOffset() {
6449 return alignof(TagType) -
6450 (sizeof(TagTypeFoldingSetPlaceholder) % alignof(TagType));
6451 }
6452
6453 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
6454 NestedNameSpecifier Qualifier, const TagDecl *Tag,
6455 bool OwnsTag, bool IsInjected) {
6456 ID.AddInteger(uintptr_t(Tag) | OwnsTag | (IsInjected << 1) |
6457 ((Keyword != ElaboratedTypeKeyword::None) << 2));
6458 if (Keyword != ElaboratedTypeKeyword::None)
6459 ID.AddInteger(llvm::to_underlying(Keyword));
6460 if (Qualifier)
6461 Qualifier.Profile(ID);
6462 }
6463
6464 void Profile(llvm::FoldingSetNodeID &ID) const {
6465 const TagType *T = getTagType();
6466 Profile(ID, T->getKeyword(), T->getQualifier(), T->getOriginalDecl(),
6467 T->isTagOwned(), T->isInjected());
6468 }
6469
6470 TagType *getTagType() {
6471 return reinterpret_cast<TagType *>(reinterpret_cast<char *>(this + 1) +
6472 getOffset());
6473 }
6474 const TagType *getTagType() const {
6475 return const_cast<TagTypeFoldingSetPlaceholder *>(this)->getTagType();
6476 }
6477 static TagTypeFoldingSetPlaceholder *fromTagType(TagType *T) {
6478 return reinterpret_cast<TagTypeFoldingSetPlaceholder *>(
6479 reinterpret_cast<char *>(T) - getOffset()) -
6480 1;
6481 }
6482};
6483
6484/// A helper class that allows the use of isa/cast/dyncast
6485/// to detect TagType objects of structs/unions/classes.
6486class RecordType final : public TagType {
6487 using TagType::TagType;
6488
6489public:
6490 // FIXME: Temporarily renamed from `getDecl` in order to facilitate
6491 // rebasing, due to change in behaviour. This should be renamed back
6492 // to `getDecl` once the change is settled.
6493 RecordDecl *getOriginalDecl() const {
6494 return reinterpret_cast<RecordDecl *>(TagType::getOriginalDecl());
6495 }
6496
6497 /// Recursively check all fields in the record for const-ness. If any field
6498 /// is declared const, return true. Otherwise, return false.
6499 bool hasConstFields() const;
6500
6501 static bool classof(const Type *T) { return T->getTypeClass() == Record; }
6502};
6503
6504/// A helper class that allows the use of isa/cast/dyncast
6505/// to detect TagType objects of enums.
6506class EnumType final : public TagType {
6507 using TagType::TagType;
6508
6509public:
6510 // FIXME: Temporarily renamed from `getDecl` in order to facilitate
6511 // rebasing, due to change in behaviour. This should be renamed back
6512 // to `getDecl` once the change is settled.
6513 EnumDecl *getOriginalDecl() const {
6514 return reinterpret_cast<EnumDecl *>(TagType::getOriginalDecl());
6515 }
6516
6517 static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
6518};
6519
6520/// The injected class name of a C++ class template or class
6521/// template partial specialization. Used to record that a type was
6522/// spelled with a bare identifier rather than as a template-id; the
6523/// equivalent for non-templated classes is just RecordType.
6524///
6525/// Injected class name types are always dependent. Template
6526/// instantiation turns these into RecordTypes.
6527///
6528/// Injected class name types are always canonical. This works
6529/// because it is impossible to compare an injected class name type
6530/// with the corresponding non-injected template type, for the same
6531/// reason that it is impossible to directly compare template
6532/// parameters from different dependent contexts: injected class name
6533/// types can only occur within the scope of a particular templated
6534/// declaration, and within that scope every template specialization
6535/// will canonicalize to the injected class name (when appropriate
6536/// according to the rules of the language).
6537class InjectedClassNameType final : public TagType {
6538 friend class ASTContext; // ASTContext creates these.
6539
6540 InjectedClassNameType(ElaboratedTypeKeyword Keyword,
6541 NestedNameSpecifier Qualifier, const TagDecl *TD,
6542 bool IsInjected, const Type *CanonicalType);
6543
6544public:
6545 // FIXME: Temporarily renamed from `getDecl` in order to facilitate
6546 // rebasing, due to change in behaviour. This should be renamed back
6547 // to `getDecl` once the change is settled.
6548 CXXRecordDecl *getOriginalDecl() const {
6549 return reinterpret_cast<CXXRecordDecl *>(TagType::getOriginalDecl());
6550 }
6551
6552 static bool classof(const Type *T) {
6553 return T->getTypeClass() == InjectedClassName;
6554 }
6555};
6556
6557/// An attributed type is a type to which a type attribute has been applied.
6558///
6559/// The "modified type" is the fully-sugared type to which the attributed
6560/// type was applied; generally it is not canonically equivalent to the
6561/// attributed type. The "equivalent type" is the minimally-desugared type
6562/// which the type is canonically equivalent to.
6563///
6564/// For example, in the following attributed type:
6565/// int32_t __attribute__((vector_size(16)))
6566/// - the modified type is the TypedefType for int32_t
6567/// - the equivalent type is VectorType(16, int32_t)
6568/// - the canonical type is VectorType(16, int)
6569class AttributedType : public Type, public llvm::FoldingSetNode {
6570public:
6571 using Kind = attr::Kind;
6572
6573private:
6574 friend class ASTContext; // ASTContext creates these
6575
6576 const Attr *Attribute;
6577
6578 QualType ModifiedType;
6579 QualType EquivalentType;
6580
6581 AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
6582 QualType equivalent)
6583 : AttributedType(canon, attrKind, nullptr, modified, equivalent) {}
6584
6585 AttributedType(QualType canon, const Attr *attr, QualType modified,
6586 QualType equivalent);
6587
6588private:
6589 AttributedType(QualType canon, attr::Kind attrKind, const Attr *attr,
6590 QualType modified, QualType equivalent);
6591
6592public:
6593 Kind getAttrKind() const {
6594 return static_cast<Kind>(AttributedTypeBits.AttrKind);
6595 }
6596
6597 const Attr *getAttr() const { return Attribute; }
6598
6599 QualType getModifiedType() const { return ModifiedType; }
6600 QualType getEquivalentType() const { return EquivalentType; }
6601
6602 bool isSugared() const { return true; }
6603 QualType desugar() const { return getEquivalentType(); }
6604
6605 /// Does this attribute behave like a type qualifier?
6606 ///
6607 /// A type qualifier adjusts a type to provide specialized rules for
6608 /// a specific object, like the standard const and volatile qualifiers.
6609 /// This includes attributes controlling things like nullability,
6610 /// address spaces, and ARC ownership. The value of the object is still
6611 /// largely described by the modified type.
6612 ///
6613 /// In contrast, many type attributes "rewrite" their modified type to
6614 /// produce a fundamentally different type, not necessarily related in any
6615 /// formalizable way to the original type. For example, calling convention
6616 /// and vector attributes are not simple type qualifiers.
6617 ///
6618 /// Type qualifiers are often, but not always, reflected in the canonical
6619 /// type.
6620 bool isQualifier() const;
6621
6622 bool isMSTypeSpec() const;
6623
6624 bool isWebAssemblyFuncrefSpec() const;
6625
6626 bool isCallingConv() const;
6627
6628 std::optional<NullabilityKind> getImmediateNullability() const;
6629
6630 /// Strip off the top-level nullability annotation on the given
6631 /// type, if it's there.
6632 ///
6633 /// \param T The type to strip. If the type is exactly an
6634 /// AttributedType specifying nullability (without looking through
6635 /// type sugar), the nullability is returned and this type changed
6636 /// to the underlying modified type.
6637 ///
6638 /// \returns the top-level nullability, if present.
6639 static std::optional<NullabilityKind> stripOuterNullability(QualType &T);
6640
6641 void Profile(llvm::FoldingSetNodeID &ID) {
6642 Profile(ID, getAttrKind(), ModifiedType, EquivalentType, Attribute);
6643 }
6644
6645 static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
6646 QualType modified, QualType equivalent,
6647 const Attr *attr) {
6648 ID.AddInteger(attrKind);
6649 ID.AddPointer(modified.getAsOpaquePtr());
6650 ID.AddPointer(equivalent.getAsOpaquePtr());
6651 ID.AddPointer(attr);
6652 }
6653
6654 static bool classof(const Type *T) {
6655 return T->getTypeClass() == Attributed;
6656 }
6657};
6658
6659class BTFTagAttributedType : public Type, public llvm::FoldingSetNode {
6660private:
6661 friend class ASTContext; // ASTContext creates these
6662
6663 QualType WrappedType;
6664 const BTFTypeTagAttr *BTFAttr;
6665
6666 BTFTagAttributedType(QualType Canon, QualType Wrapped,
6667 const BTFTypeTagAttr *BTFAttr)
6668 : Type(BTFTagAttributed, Canon, Wrapped->getDependence()),
6669 WrappedType(Wrapped), BTFAttr(BTFAttr) {}
6670
6671public:
6672 QualType getWrappedType() const { return WrappedType; }
6673 const BTFTypeTagAttr *getAttr() const { return BTFAttr; }
6674
6675 bool isSugared() const { return true; }
6676 QualType desugar() const { return getWrappedType(); }
6677
6678 void Profile(llvm::FoldingSetNodeID &ID) {
6679 Profile(ID, WrappedType, BTFAttr);
6680 }
6681
6682 static void Profile(llvm::FoldingSetNodeID &ID, QualType Wrapped,
6683 const BTFTypeTagAttr *BTFAttr) {
6684 ID.AddPointer(Wrapped.getAsOpaquePtr());
6685 ID.AddPointer(BTFAttr);
6686 }
6687
6688 static bool classof(const Type *T) {
6689 return T->getTypeClass() == BTFTagAttributed;
6690 }
6691};
6692
6693class HLSLAttributedResourceType : public Type, public llvm::FoldingSetNode {
6694public:
6695 struct Attributes {
6696 // Data gathered from HLSL resource attributes
6697 llvm::dxil::ResourceClass ResourceClass;
6698
6699 LLVM_PREFERRED_TYPE(bool)
6700 uint8_t IsROV : 1;
6701
6702 LLVM_PREFERRED_TYPE(bool)
6703 uint8_t RawBuffer : 1;
6704
6705 LLVM_PREFERRED_TYPE(bool)
6706 uint8_t IsCounter : 1;
6707
6708 Attributes(llvm::dxil::ResourceClass ResourceClass, bool IsROV = false,
6709 bool RawBuffer = false, bool IsCounter = false)
6710 : ResourceClass(ResourceClass), IsROV(IsROV), RawBuffer(RawBuffer),
6711 IsCounter(IsCounter) {}
6712
6713 Attributes()
6714 : Attributes(llvm::dxil::ResourceClass::UAV, false, false, false) {}
6715
6716 friend bool operator==(const Attributes &LHS, const Attributes &RHS) {
6717 return std::tie(LHS.ResourceClass, LHS.IsROV, LHS.RawBuffer,
6718 LHS.IsCounter) == std::tie(RHS.ResourceClass, RHS.IsROV,
6719 RHS.RawBuffer, RHS.IsCounter);
6720 }
6721 friend bool operator!=(const Attributes &LHS, const Attributes &RHS) {
6722 return !(LHS == RHS);
6723 }
6724 };
6725
6726private:
6727 friend class ASTContext; // ASTContext creates these
6728
6729 QualType WrappedType;
6730 QualType ContainedType;
6731 const Attributes Attrs;
6732
6733 HLSLAttributedResourceType(QualType Wrapped, QualType Contained,
6734 const Attributes &Attrs)
6735 : Type(HLSLAttributedResource, QualType(),
6736 Contained.isNull() ? TypeDependence::None
6737 : Contained->getDependence()),
6738 WrappedType(Wrapped), ContainedType(Contained), Attrs(Attrs) {}
6739
6740public:
6741 QualType getWrappedType() const { return WrappedType; }
6742 QualType getContainedType() const { return ContainedType; }
6743 bool hasContainedType() const { return !ContainedType.isNull(); }
6744 const Attributes &getAttrs() const { return Attrs; }
6745
6746 bool isSugared() const { return false; }
6747 QualType desugar() const { return QualType(this, 0); }
6748
6749 void Profile(llvm::FoldingSetNodeID &ID) {
6750 Profile(ID, WrappedType, ContainedType, Attrs);
6751 }
6752
6753 static void Profile(llvm::FoldingSetNodeID &ID, QualType Wrapped,
6754 QualType Contained, const Attributes &Attrs) {
6755 ID.AddPointer(Wrapped.getAsOpaquePtr());
6756 ID.AddPointer(Contained.getAsOpaquePtr());
6757 ID.AddInteger(static_cast<uint32_t>(Attrs.ResourceClass));
6758 ID.AddBoolean(Attrs.IsROV);
6759 ID.AddBoolean(Attrs.RawBuffer);
6760 ID.AddBoolean(Attrs.IsCounter);
6761 }
6762
6763 static bool classof(const Type *T) {
6764 return T->getTypeClass() == HLSLAttributedResource;
6765 }
6766
6767 // Returns handle type from HLSL resource, if the type is a resource
6768 static const HLSLAttributedResourceType *
6769 findHandleTypeOnResource(const Type *RT);
6770};
6771
6772/// Instances of this class represent operands to a SPIR-V type instruction.
6773class SpirvOperand {
6774public:
6775 enum SpirvOperandKind : unsigned char {
6776 Invalid, ///< Uninitialized.
6777 ConstantId, ///< Integral value to represent as a SPIR-V OpConstant
6778 ///< instruction ID.
6779 Literal, ///< Integral value to represent as an immediate literal.
6780 TypeId, ///< Type to represent as a SPIR-V type ID.
6781
6782 Max,
6783 };
6784
6785private:
6786 SpirvOperandKind Kind = Invalid;
6787
6788 QualType ResultType;
6789 llvm::APInt Value; // Signedness of constants is represented by ResultType.
6790
6791public:
6792 SpirvOperand() : Kind(Invalid), ResultType(), Value() {}
6793
6794 SpirvOperand(SpirvOperandKind Kind, QualType ResultType, llvm::APInt Value)
6795 : Kind(Kind), ResultType(ResultType), Value(std::move(Value)) {}
6796
6797 SpirvOperand(const SpirvOperand &Other) { *this = Other; }
6798 ~SpirvOperand() {}
6799
6800 SpirvOperand &operator=(const SpirvOperand &Other) = default;
6801
6802 bool operator==(const SpirvOperand &Other) const {
6803 return Kind == Other.Kind && ResultType == Other.ResultType &&
6804 Value == Other.Value;
6805 }
6806
6807 bool operator!=(const SpirvOperand &Other) const { return !(*this == Other); }
6808
6809 SpirvOperandKind getKind() const { return Kind; }
6810
6811 bool isValid() const { return Kind != Invalid && Kind < Max; }
6812 bool isConstant() const { return Kind == ConstantId; }
6813 bool isLiteral() const { return Kind == Literal; }
6814 bool isType() const { return Kind == TypeId; }
6815
6816 llvm::APInt getValue() const {
6817 assert((isConstant() || isLiteral()) &&
6818 "This is not an operand with a value!");
6819 return Value;
6820 }
6821
6822 QualType getResultType() const {
6823 assert((isConstant() || isType()) &&
6824 "This is not an operand with a result type!");
6825 return ResultType;
6826 }
6827
6828 static SpirvOperand createConstant(QualType ResultType, llvm::APInt Val) {
6829 return SpirvOperand(ConstantId, ResultType, std::move(Val));
6830 }
6831
6832 static SpirvOperand createLiteral(llvm::APInt Val) {
6833 return SpirvOperand(Literal, QualType(), std::move(Val));
6834 }
6835
6836 static SpirvOperand createType(QualType T) {
6837 return SpirvOperand(TypeId, T, llvm::APSInt());
6838 }
6839
6840 void Profile(llvm::FoldingSetNodeID &ID) const {
6841 ID.AddInteger(Kind);
6842 ID.AddPointer(ResultType.getAsOpaquePtr());
6843 Value.Profile(ID);
6844 }
6845};
6846
6847/// Represents an arbitrary, user-specified SPIR-V type instruction.
6848class HLSLInlineSpirvType final
6849 : public Type,
6850 public llvm::FoldingSetNode,
6851 private llvm::TrailingObjects<HLSLInlineSpirvType, SpirvOperand> {
6852 friend class ASTContext; // ASTContext creates these
6853 friend TrailingObjects;
6854
6855private:
6857 uint32_t Size;
6858 uint32_t Alignment;
6859 size_t NumOperands;
6860
6861 HLSLInlineSpirvType(uint32_t Opcode, uint32_t Size, uint32_t Alignment,
6862 ArrayRef<SpirvOperand> Operands)
6863 : Type(HLSLInlineSpirv, QualType(), TypeDependence::None), Opcode(Opcode),
6864 Size(Size), Alignment(Alignment), NumOperands(Operands.size()) {
6865 for (size_t I = 0; I < NumOperands; I++) {
6866 // Since Operands are stored as a trailing object, they have not been
6867 // initialized yet. Call the constructor manually.
6868 auto *Operand = new (&getTrailingObjects()[I]) SpirvOperand();
6869 *Operand = Operands[I];
6870 }
6871 }
6872
6873public:
6874 uint32_t getOpcode() const { return Opcode; }
6875 uint32_t getSize() const { return Size; }
6876 uint32_t getAlignment() const { return Alignment; }
6877 ArrayRef<SpirvOperand> getOperands() const {
6878 return getTrailingObjects(NumOperands);
6879 }
6880
6881 bool isSugared() const { return false; }
6882 QualType desugar() const { return QualType(this, 0); }
6883
6884 void Profile(llvm::FoldingSetNodeID &ID) {
6885 Profile(ID, Opcode, Size, Alignment, getOperands());
6886 }
6887
6888 static void Profile(llvm::FoldingSetNodeID &ID, uint32_t Opcode,
6889 uint32_t Size, uint32_t Alignment,
6890 ArrayRef<SpirvOperand> Operands) {
6891 ID.AddInteger(Opcode);
6892 ID.AddInteger(Size);
6893 ID.AddInteger(Alignment);
6894 for (auto &Operand : Operands)
6895 Operand.Profile(ID);
6896 }
6897
6898 static bool classof(const Type *T) {
6899 return T->getTypeClass() == HLSLInlineSpirv;
6900 }
6901};
6902
6903class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
6904 friend class ASTContext; // ASTContext creates these
6905
6906 // The associated TemplateTypeParmDecl for the non-canonical type.
6907 TemplateTypeParmDecl *TTPDecl;
6908
6909 TemplateTypeParmType(unsigned D, unsigned I, bool PP,
6910 TemplateTypeParmDecl *TTPDecl, QualType Canon)
6911 : Type(TemplateTypeParm, Canon,
6912 TypeDependence::DependentInstantiation |
6913 (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)),
6914 TTPDecl(TTPDecl) {
6915 assert(!TTPDecl == Canon.isNull());
6916 TemplateTypeParmTypeBits.Depth = D;
6917 TemplateTypeParmTypeBits.Index = I;
6918 TemplateTypeParmTypeBits.ParameterPack = PP;
6919 }
6920
6921public:
6922 unsigned getDepth() const { return TemplateTypeParmTypeBits.Depth; }
6923 unsigned getIndex() const { return TemplateTypeParmTypeBits.Index; }
6924 bool isParameterPack() const {
6925 return TemplateTypeParmTypeBits.ParameterPack;
6926 }
6927
6928 TemplateTypeParmDecl *getDecl() const { return TTPDecl; }
6929
6930 IdentifierInfo *getIdentifier() const;
6931
6932 bool isSugared() const { return false; }
6933 QualType desugar() const { return QualType(this, 0); }
6934
6935 void Profile(llvm::FoldingSetNodeID &ID) {
6936 Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
6937 }
6938
6939 static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
6940 unsigned Index, bool ParameterPack,
6941 TemplateTypeParmDecl *TTPDecl) {
6942 ID.AddInteger(Depth);
6943 ID.AddInteger(Index);
6944 ID.AddBoolean(ParameterPack);
6945 ID.AddPointer(TTPDecl);
6946 }
6947
6948 static bool classof(const Type *T) {
6949 return T->getTypeClass() == TemplateTypeParm;
6950 }
6951};
6952
6953/// Represents the result of substituting a type for a template
6954/// type parameter.
6955///
6956/// Within an instantiated template, all template type parameters have
6957/// been replaced with these. They are used solely to record that a
6958/// type was originally written as a template type parameter;
6959/// therefore they are never canonical.
6960class SubstTemplateTypeParmType final
6961 : public Type,
6962 public llvm::FoldingSetNode,
6963 private llvm::TrailingObjects<SubstTemplateTypeParmType, QualType> {
6964 friend class ASTContext;
6965 friend class llvm::TrailingObjects<SubstTemplateTypeParmType, QualType>;
6966
6967 Decl *AssociatedDecl;
6968
6969 SubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
6970 unsigned Index, UnsignedOrNone PackIndex,
6971 bool Final);
6972
6973public:
6974 /// Gets the type that was substituted for the template
6975 /// parameter.
6976 QualType getReplacementType() const {
6977 return SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType
6978 ? *getTrailingObjects()
6979 : getCanonicalTypeInternal();
6980 }
6981
6982 /// A template-like entity which owns the whole pattern being substituted.
6983 /// This will usually own a set of template parameters, or in some
6984 /// cases might even be a template parameter itself.
6985 Decl *getAssociatedDecl() const { return AssociatedDecl; }
6986
6987 /// Gets the template parameter declaration that was substituted for.
6988 const TemplateTypeParmDecl *getReplacedParameter() const;
6989
6990 /// Returns the index of the replaced parameter in the associated declaration.
6991 /// This should match the result of `getReplacedParameter()->getIndex()`.
6992 unsigned getIndex() const { return SubstTemplateTypeParmTypeBits.Index; }
6993
6994 // This substitution is Final, which means the substitution is fully
6995 // sugared: it doesn't need to be resugared later.
6996 unsigned getFinal() const { return SubstTemplateTypeParmTypeBits.Final; }
6997
6998 UnsignedOrNone getPackIndex() const {
6999 return UnsignedOrNone::fromInternalRepresentation(
7000 SubstTemplateTypeParmTypeBits.PackIndex);
7001 }
7002
7003 bool isSugared() const { return true; }
7004 QualType desugar() const { return getReplacementType(); }
7005
7006 void Profile(llvm::FoldingSetNodeID &ID) {
7007 Profile(ID, getReplacementType(), getAssociatedDecl(), getIndex(),
7008 getPackIndex(), getFinal());
7009 }
7010
7011 static void Profile(llvm::FoldingSetNodeID &ID, QualType Replacement,
7012 const Decl *AssociatedDecl, unsigned Index,
7013 UnsignedOrNone PackIndex, bool Final);
7014
7015 static bool classof(const Type *T) {
7016 return T->getTypeClass() == SubstTemplateTypeParm;
7017 }
7018};
7019
7020/// Represents the result of substituting a set of types as a template argument
7021/// that needs to be expanded later.
7022///
7023/// These types are always dependent and produced depending on the situations:
7024/// - SubstTemplateTypeParmPack is an expansion that had to be delayed,
7025/// - SubstBuiltinTemplatePackType is an expansion from a builtin.
7026class SubstPackType : public Type, public llvm::FoldingSetNode {
7027 friend class ASTContext;
7028
7029 /// A pointer to the set of template arguments that this
7030 /// parameter pack is instantiated with.
7031 const TemplateArgument *Arguments;
7032
7033protected:
7034 SubstPackType(TypeClass Derived, QualType Canon,
7035 const TemplateArgument &ArgPack);
7036
7037public:
7038 unsigned getNumArgs() const { return SubstPackTypeBits.NumArgs; }
7039
7040 TemplateArgument getArgumentPack() const;
7041
7042 void Profile(llvm::FoldingSetNodeID &ID);
7043 static void Profile(llvm::FoldingSetNodeID &ID,
7044 const TemplateArgument &ArgPack);
7045
7046 static bool classof(const Type *T) {
7047 return T->getTypeClass() == SubstTemplateTypeParmPack ||
7048 T->getTypeClass() == SubstBuiltinTemplatePack;
7049 }
7050};
7051
7052/// Represents the result of substituting a builtin template as a pack.
7053class SubstBuiltinTemplatePackType : public SubstPackType {
7054 friend class ASTContext;
7055
7056 SubstBuiltinTemplatePackType(QualType Canon, const TemplateArgument &ArgPack);
7057
7058public:
7059 bool isSugared() const { return false; }
7060 QualType desugar() const { return QualType(this, 0); }
7061
7062 /// Mark that we reuse the Profile. We do not introduce new fields.
7063 using SubstPackType::Profile;
7064
7065 static bool classof(const Type *T) {
7066 return T->getTypeClass() == SubstBuiltinTemplatePack;
7067 }
7068};
7069
7070/// Represents the result of substituting a set of types for a template
7071/// type parameter pack.
7072///
7073/// When a pack expansion in the source code contains multiple parameter packs
7074/// and those parameter packs correspond to different levels of template
7075/// parameter lists, this type node is used to represent a template type
7076/// parameter pack from an outer level, which has already had its argument pack
7077/// substituted but that still lives within a pack expansion that itself
7078/// could not be instantiated. When actually performing a substitution into
7079/// that pack expansion (e.g., when all template parameters have corresponding
7080/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
7081/// at the current pack substitution index.
7082class SubstTemplateTypeParmPackType : public SubstPackType {
7083 friend class ASTContext;
7084
7085 /// A pointer to the set of template arguments that this
7086 /// parameter pack is instantiated with.
7087 const TemplateArgument *Arguments;
7088
7089 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
7090
7091 SubstTemplateTypeParmPackType(QualType Canon, Decl *AssociatedDecl,
7092 unsigned Index, bool Final,
7093 const TemplateArgument &ArgPack);
7094
7095public:
7096 IdentifierInfo *getIdentifier() const;
7097
7098 /// A template-like entity which owns the whole pattern being substituted.
7099 /// This will usually own a set of template parameters, or in some
7100 /// cases might even be a template parameter itself.
7101 Decl *getAssociatedDecl() const;
7102
7103 /// Gets the template parameter declaration that was substituted for.
7104 const TemplateTypeParmDecl *getReplacedParameter() const;
7105
7106 /// Returns the index of the replaced parameter in the associated declaration.
7107 /// This should match the result of `getReplacedParameter()->getIndex()`.
7108 unsigned getIndex() const {
7109 return SubstPackTypeBits.SubstTemplTypeParmPackIndex;
7110 }
7111
7112 // This substitution will be Final, which means the substitution will be fully
7113 // sugared: it doesn't need to be resugared later.
7114 bool getFinal() const;
7115
7116 bool isSugared() const { return false; }
7117 QualType desugar() const { return QualType(this, 0); }
7118
7119 void Profile(llvm::FoldingSetNodeID &ID);
7120 static void Profile(llvm::FoldingSetNodeID &ID, const Decl *AssociatedDecl,
7121 unsigned Index, bool Final,
7122 const TemplateArgument &ArgPack);
7123
7124 static bool classof(const Type *T) {
7125 return T->getTypeClass() == SubstTemplateTypeParmPack;
7126 }
7127};
7128
7129/// Common base class for placeholders for types that get replaced by
7130/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
7131/// class template types, and constrained type names.
7132///
7133/// These types are usually a placeholder for a deduced type. However, before
7134/// the initializer is attached, or (usually) if the initializer is
7135/// type-dependent, there is no deduced type and the type is canonical. In
7136/// the latter case, it is also a dependent type.
7137class DeducedType : public Type {
7138 QualType DeducedAsType;
7139
7140protected:
7141 DeducedType(TypeClass TC, QualType DeducedAsType,
7142 TypeDependence ExtraDependence, QualType Canon)
7143 : Type(TC, Canon,
7144 ExtraDependence | (DeducedAsType.isNull()
7146 : DeducedAsType->getDependence() &
7147 ~TypeDependence::VariablyModified)),
7148 DeducedAsType(DeducedAsType) {}
7149
7150public:
7151 bool isSugared() const { return !DeducedAsType.isNull(); }
7152 QualType desugar() const {
7153 return isSugared() ? DeducedAsType : QualType(this, 0);
7154 }
7155
7156 /// Get the type deduced for this placeholder type, or null if it
7157 /// has not been deduced.
7158 QualType getDeducedType() const { return DeducedAsType; }
7159 bool isDeduced() const {
7160 return !DeducedAsType.isNull() || isDependentType();
7161 }
7162
7163 static bool classof(const Type *T) {
7164 return T->getTypeClass() == Auto ||
7165 T->getTypeClass() == DeducedTemplateSpecialization;
7166 }
7167};
7168
7169/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
7170/// by a type-constraint.
7171class AutoType : public DeducedType {
7172 friend class ASTContext; // ASTContext creates these
7173
7174 TemplateDecl *TypeConstraintConcept;
7175
7176 AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
7177 TypeDependence ExtraDependence, QualType Canon, TemplateDecl *CD,
7178 ArrayRef<TemplateArgument> TypeConstraintArgs);
7179
7180public:
7181 ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
7182 return {reinterpret_cast<const TemplateArgument *>(this + 1),
7183 AutoTypeBits.NumArgs};
7184 }
7185
7186 TemplateDecl *getTypeConstraintConcept() const {
7187 return TypeConstraintConcept;
7188 }
7189
7190 bool isConstrained() const {
7191 return TypeConstraintConcept != nullptr;
7192 }
7193
7194 bool isDecltypeAuto() const {
7195 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
7196 }
7197
7198 bool isGNUAutoType() const {
7199 return getKeyword() == AutoTypeKeyword::GNUAutoType;
7200 }
7201
7202 AutoTypeKeyword getKeyword() const {
7203 return (AutoTypeKeyword)AutoTypeBits.Keyword;
7204 }
7205
7206 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context);
7207 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
7208 QualType Deduced, AutoTypeKeyword Keyword,
7209 bool IsDependent, TemplateDecl *CD,
7210 ArrayRef<TemplateArgument> Arguments);
7211
7212 static bool classof(const Type *T) {
7213 return T->getTypeClass() == Auto;
7214 }
7215};
7216
7217/// Represents a C++17 deduced template specialization type.
7218class DeducedTemplateSpecializationType : public KeywordWrapper<DeducedType>,
7219 public llvm::FoldingSetNode {
7220 friend class ASTContext; // ASTContext creates these
7221
7222 /// The name of the template whose arguments will be deduced.
7224
7225 DeducedTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
7226 TemplateName Template,
7227 QualType DeducedAsType,
7228 bool IsDeducedAsDependent, QualType Canon)
7229 : KeywordWrapper(Keyword, DeducedTemplateSpecialization, DeducedAsType,
7230 toTypeDependence(Template.getDependence()) |
7231 (IsDeducedAsDependent
7232 ? TypeDependence::DependentInstantiation
7233 : TypeDependence::None),
7234 Canon),
7235 Template(Template) {}
7236
7237public:
7238 /// Retrieve the name of the template that we are deducing.
7239 TemplateName getTemplateName() const { return Template; }
7240
7241 void Profile(llvm::FoldingSetNodeID &ID) const {
7242 Profile(ID, getKeyword(), getTemplateName(), getDeducedType(),
7243 isDependentType());
7244 }
7245
7246 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
7247 TemplateName Template, QualType Deduced,
7248 bool IsDependent) {
7249 ID.AddInteger(llvm::to_underlying(Keyword));
7250 Template.Profile(ID);
7251 Deduced.Profile(ID);
7252 ID.AddBoolean(IsDependent || Template.isDependent());
7253 }
7254
7255 static bool classof(const Type *T) {
7256 return T->getTypeClass() == DeducedTemplateSpecialization;
7257 }
7258};
7259
7260/// Represents a type template specialization; the template
7261/// must be a class template, a type alias template, or a template
7262/// template parameter. A template which cannot be resolved to one of
7263/// these, e.g. because it is written with a dependent scope
7264/// specifier, is instead represented as a
7265/// @c DependentTemplateSpecializationType.
7266///
7267/// A non-dependent template specialization type is always "sugar",
7268/// typically for a \c RecordType. For example, a class template
7269/// specialization type of \c vector<int> will refer to a tag type for
7270/// the instantiation \c std::vector<int, std::allocator<int>>
7271///
7272/// Template specializations are dependent if either the template or
7273/// any of the template arguments are dependent, in which case the
7274/// type may also be canonical.
7275///
7276/// Instances of this type are allocated with a trailing array of
7277/// TemplateArguments, followed by a QualType representing the
7278/// non-canonical aliased type when the template is a type alias
7279/// template.
7280class TemplateSpecializationType : public TypeWithKeyword,
7281 public llvm::FoldingSetNode {
7282 friend class ASTContext; // ASTContext creates these
7283
7284 /// The name of the template being specialized. This is
7285 /// either a TemplateName::Template (in which case it is a
7286 /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
7287 /// TypeAliasTemplateDecl*), a
7288 /// TemplateName::SubstTemplateTemplateParmPack, or a
7289 /// TemplateName::SubstTemplateTemplateParm (in which case the
7290 /// replacement must, recursively, be one of these).
7292
7293 TemplateSpecializationType(ElaboratedTypeKeyword Keyword, TemplateName T,
7294 bool IsAlias, ArrayRef<TemplateArgument> Args,
7295 QualType Underlying);
7296
7297public:
7298 /// Determine whether any of the given template arguments are dependent.
7299 ///
7300 /// The converted arguments should be supplied when known; whether an
7301 /// argument is dependent can depend on the conversions performed on it
7302 /// (for example, a 'const int' passed as a template argument might be
7303 /// dependent if the parameter is a reference but non-dependent if the
7304 /// parameter is an int).
7305 ///
7306 /// Note that the \p Args parameter is unused: this is intentional, to remind
7307 /// the caller that they need to pass in the converted arguments, not the
7308 /// specified arguments.
7309 static bool
7310 anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
7311 ArrayRef<TemplateArgument> Converted);
7312 static bool
7313 anyDependentTemplateArguments(const TemplateArgumentListInfo &,
7314 ArrayRef<TemplateArgument> Converted);
7315 static bool anyInstantiationDependentTemplateArguments(
7316 ArrayRef<TemplateArgumentLoc> Args);
7317
7318 /// True if this template specialization type matches a current
7319 /// instantiation in the context in which it is found.
7320 bool isCurrentInstantiation() const {
7321 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
7322 }
7323
7324 /// Determine if this template specialization type is for a type alias
7325 /// template that has been substituted.
7326 ///
7327 /// Nearly every template specialization type whose template is an alias
7328 /// template will be substituted. However, this is not the case when
7329 /// the specialization contains a pack expansion but the template alias
7330 /// does not have a corresponding parameter pack, e.g.,
7331 ///
7332 /// \code
7333 /// template<typename T, typename U, typename V> struct S;
7334 /// template<typename T, typename U> using A = S<T, int, U>;
7335 /// template<typename... Ts> struct X {
7336 /// typedef A<Ts...> type; // not a type alias
7337 /// };
7338 /// \endcode
7339 bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }
7340
7341 /// Get the aliased type, if this is a specialization of a type alias
7342 /// template.
7343 QualType getAliasedType() const;
7344
7345 /// Retrieve the name of the template that we are specializing.
7346 TemplateName getTemplateName() const { return Template; }
7347
7348 ArrayRef<TemplateArgument> template_arguments() const {
7349 return {reinterpret_cast<const TemplateArgument *>(this + 1),
7350 TemplateSpecializationTypeBits.NumArgs};
7351 }
7352
7353 bool isSugared() const;
7354
7355 QualType desugar() const {
7356 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
7357 }
7358
7359 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
7360 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
7361 TemplateName T, ArrayRef<TemplateArgument> Args,
7362 QualType Underlying, const ASTContext &Context);
7363
7364 static bool classof(const Type *T) {
7366 }
7367};
7368
7369/// Print a template argument list, including the '<' and '>'
7370/// enclosing the template arguments.
7371void printTemplateArgumentList(raw_ostream &OS,
7372 ArrayRef<TemplateArgument> Args,
7373 const PrintingPolicy &Policy,
7374 const TemplateParameterList *TPL = nullptr);
7375
7376void printTemplateArgumentList(raw_ostream &OS,
7377 ArrayRef<TemplateArgumentLoc> Args,
7378 const PrintingPolicy &Policy,
7379 const TemplateParameterList *TPL = nullptr);
7380
7381void printTemplateArgumentList(raw_ostream &OS,
7382 const TemplateArgumentListInfo &Args,
7383 const PrintingPolicy &Policy,
7384 const TemplateParameterList *TPL = nullptr);
7385
7386/// Make a best-effort determination of whether the type T can be produced by
7387/// substituting Args into the default argument of Param.
7388bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
7389 const NamedDecl *Param,
7390 ArrayRef<TemplateArgument> Args,
7391 unsigned Depth);
7392
7393/// Represents a qualified type name for which the type name is
7394/// dependent.
7395///
7396/// DependentNameType represents a class of dependent types that involve a
7397/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
7398/// name of a type. The DependentNameType may start with a "typename" (for a
7399/// typename-specifier), "class", "struct", "union", or "enum" (for a
7400/// dependent elaborated-type-specifier), or nothing (in contexts where we
7401/// know that we must be referring to a type, e.g., in a base class specifier).
7402/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
7403/// mode, this type is used with non-dependent names to delay name lookup until
7404/// instantiation.
7405class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
7406 friend class ASTContext; // ASTContext creates these
7407
7408 /// The nested name specifier containing the qualifier.
7409 NestedNameSpecifier NNS;
7410
7411 /// The type that this typename specifier refers to.
7412 const IdentifierInfo *Name;
7413
7414 DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier NNS,
7415 const IdentifierInfo *Name, QualType CanonType)
7416 : TypeWithKeyword(Keyword, DependentName, CanonType,
7417 TypeDependence::DependentInstantiation |
7418 (NNS ? toTypeDependence(NNS.getDependence())
7420 NNS(NNS), Name(Name) {
7421 assert(Name);
7422 }
7423
7424public:
7425 /// Retrieve the qualification on this type.
7426 NestedNameSpecifier getQualifier() const { return NNS; }
7427
7428 /// Retrieve the identifier that terminates this type name.
7429 /// For example, "type" in "typename T::type".
7430 const IdentifierInfo *getIdentifier() const {
7431 return Name;
7432 }
7433
7434 bool isSugared() const { return false; }
7435 QualType desugar() const { return QualType(this, 0); }
7436
7437 void Profile(llvm::FoldingSetNodeID &ID) {
7438 Profile(ID, getKeyword(), NNS, Name);
7439 }
7440
7441 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
7442 NestedNameSpecifier NNS, const IdentifierInfo *Name) {
7443 ID.AddInteger(llvm::to_underlying(Keyword));
7444 NNS.Profile(ID);
7445 ID.AddPointer(Name);
7446 }
7447
7448 static bool classof(const Type *T) {
7449 return T->getTypeClass() == DependentName;
7450 }
7451};
7452
7453/// Represents a pack expansion of types.
7454///
7455/// Pack expansions are part of C++11 variadic templates. A pack
7456/// expansion contains a pattern, which itself contains one or more
7457/// "unexpanded" parameter packs. When instantiated, a pack expansion
7458/// produces a series of types, each instantiated from the pattern of
7459/// the expansion, where the Ith instantiation of the pattern uses the
7460/// Ith arguments bound to each of the unexpanded parameter packs. The
7461/// pack expansion is considered to "expand" these unexpanded
7462/// parameter packs.
7463///
7464/// \code
7465/// template<typename ...Types> struct tuple;
7466///
7467/// template<typename ...Types>
7468/// struct tuple_of_references {
7469/// typedef tuple<Types&...> type;
7470/// };
7471/// \endcode
7472///
7473/// Here, the pack expansion \c Types&... is represented via a
7474/// PackExpansionType whose pattern is Types&.
7475class PackExpansionType : public Type, public llvm::FoldingSetNode {
7476 friend class ASTContext; // ASTContext creates these
7477
7478 /// The pattern of the pack expansion.
7479 QualType Pattern;
7480
7481 PackExpansionType(QualType Pattern, QualType Canon,
7482 UnsignedOrNone NumExpansions)
7483 : Type(PackExpansion, Canon,
7484 (Pattern->getDependence() | TypeDependence::Dependent |
7485 TypeDependence::Instantiation) &
7486 ~TypeDependence::UnexpandedPack),
7487 Pattern(Pattern) {
7488 PackExpansionTypeBits.NumExpansions =
7489 NumExpansions ? *NumExpansions + 1 : 0;
7490 }
7491
7492public:
7493 /// Retrieve the pattern of this pack expansion, which is the
7494 /// type that will be repeatedly instantiated when instantiating the
7495 /// pack expansion itself.
7496 QualType getPattern() const { return Pattern; }
7497
7498 /// Retrieve the number of expansions that this pack expansion will
7499 /// generate, if known.
7500 UnsignedOrNone getNumExpansions() const {
7501 if (PackExpansionTypeBits.NumExpansions)
7502 return PackExpansionTypeBits.NumExpansions - 1;
7503 return std::nullopt;
7504 }
7505
7506 bool isSugared() const { return false; }
7507 QualType desugar() const { return QualType(this, 0); }
7508
7509 void Profile(llvm::FoldingSetNodeID &ID) {
7510 Profile(ID, getPattern(), getNumExpansions());
7511 }
7512
7513 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
7514 UnsignedOrNone NumExpansions) {
7515 ID.AddPointer(Pattern.getAsOpaquePtr());
7516 ID.AddInteger(NumExpansions.toInternalRepresentation());
7517 }
7518
7519 static bool classof(const Type *T) {
7520 return T->getTypeClass() == PackExpansion;
7521 }
7522};
7523
7524/// This class wraps the list of protocol qualifiers. For types that can
7525/// take ObjC protocol qualifers, they can subclass this class.
7526template <class T>
7527class ObjCProtocolQualifiers {
7528protected:
7529 ObjCProtocolQualifiers() = default;
7530
7531 ObjCProtocolDecl * const *getProtocolStorage() const {
7532 return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
7533 }
7534
7535 ObjCProtocolDecl **getProtocolStorage() {
7536 return static_cast<T*>(this)->getProtocolStorageImpl();
7537 }
7538
7539 void setNumProtocols(unsigned N) {
7540 static_cast<T*>(this)->setNumProtocolsImpl(N);
7541 }
7542
7543 void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
7544 setNumProtocols(protocols.size());
7545 assert(getNumProtocols() == protocols.size() &&
7546 "bitfield overflow in protocol count");
7547 if (!protocols.empty())
7548 memcpy(getProtocolStorage(), protocols.data(),
7549 protocols.size() * sizeof(ObjCProtocolDecl*));
7550 }
7551
7552public:
7553 using qual_iterator = ObjCProtocolDecl * const *;
7554 using qual_range = llvm::iterator_range<qual_iterator>;
7555
7556 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
7557 qual_iterator qual_begin() const { return getProtocolStorage(); }
7558 qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }
7559
7560 bool qual_empty() const { return getNumProtocols() == 0; }
7561
7562 /// Return the number of qualifying protocols in this type, or 0 if
7563 /// there are none.
7564 unsigned getNumProtocols() const {
7565 return static_cast<const T*>(this)->getNumProtocolsImpl();
7566 }
7567
7568 /// Fetch a protocol by index.
7569 ObjCProtocolDecl *getProtocol(unsigned I) const {
7570 assert(I < getNumProtocols() && "Out-of-range protocol access");
7571 return qual_begin()[I];
7572 }
7573
7574 /// Retrieve all of the protocol qualifiers.
7575 ArrayRef<ObjCProtocolDecl *> getProtocols() const {
7576 return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
7577 }
7578};
7579
7580/// Represents a type parameter type in Objective C. It can take
7581/// a list of protocols.
7582class ObjCTypeParamType : public Type,
7583 public ObjCProtocolQualifiers<ObjCTypeParamType>,
7584 public llvm::FoldingSetNode {
7585 friend class ASTContext;
7586 friend class ObjCProtocolQualifiers<ObjCTypeParamType>;
7587
7588 /// The number of protocols stored on this type.
7589 unsigned NumProtocols : 6;
7590
7591 ObjCTypeParamDecl *OTPDecl;
7592
7593 /// The protocols are stored after the ObjCTypeParamType node. In the
7594 /// canonical type, the list of protocols are sorted alphabetically
7595 /// and uniqued.
7596 ObjCProtocolDecl **getProtocolStorageImpl();
7597
7598 /// Return the number of qualifying protocols in this interface type,
7599 /// or 0 if there are none.
7600 unsigned getNumProtocolsImpl() const {
7601 return NumProtocols;
7602 }
7603
7604 void setNumProtocolsImpl(unsigned N) {
7605 NumProtocols = N;
7606 }
7607
7608 ObjCTypeParamType(const ObjCTypeParamDecl *D,
7609 QualType can,
7610 ArrayRef<ObjCProtocolDecl *> protocols);
7611
7612public:
7613 bool isSugared() const { return true; }
7614 QualType desugar() const { return getCanonicalTypeInternal(); }
7615
7616 static bool classof(const Type *T) {
7617 return T->getTypeClass() == ObjCTypeParam;
7618 }
7619
7620 void Profile(llvm::FoldingSetNodeID &ID);
7621 static void Profile(llvm::FoldingSetNodeID &ID,
7622 const ObjCTypeParamDecl *OTPDecl,
7623 QualType CanonicalType,
7624 ArrayRef<ObjCProtocolDecl *> protocols);
7625
7626 ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
7627};
7628
7629/// Represents a class type in Objective C.
7630///
7631/// Every Objective C type is a combination of a base type, a set of
7632/// type arguments (optional, for parameterized classes) and a list of
7633/// protocols.
7634///
7635/// Given the following declarations:
7636/// \code
7637/// \@class C<T>;
7638/// \@protocol P;
7639/// \endcode
7640///
7641/// 'C' is an ObjCInterfaceType C. It is sugar for an ObjCObjectType
7642/// with base C and no protocols.
7643///
7644/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
7645/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
7646/// protocol list.
7647/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
7648/// and protocol list [P].
7649///
7650/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
7651/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
7652/// and no protocols.
7653///
7654/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
7655/// with base BuiltinType::ObjCIdType and protocol list [P]. Eventually
7656/// this should get its own sugar class to better represent the source.
7657class ObjCObjectType : public Type,
7658 public ObjCProtocolQualifiers<ObjCObjectType> {
7659 friend class ObjCProtocolQualifiers<ObjCObjectType>;
7660
7661 // ObjCObjectType.NumTypeArgs - the number of type arguments stored
7662 // after the ObjCObjectPointerType node.
7663 // ObjCObjectType.NumProtocols - the number of protocols stored
7664 // after the type arguments of ObjCObjectPointerType node.
7665 //
7666 // These protocols are those written directly on the type. If
7667 // protocol qualifiers ever become additive, the iterators will need
7668 // to get kindof complicated.
7669 //
7670 // In the canonical object type, these are sorted alphabetically
7671 // and uniqued.
7672
7673 /// Either a BuiltinType or an InterfaceType or sugar for either.
7674 QualType BaseType;
7675
7676 /// Cached superclass type.
7677 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
7678 CachedSuperClassType;
7679
7680 QualType *getTypeArgStorage();
7681 const QualType *getTypeArgStorage() const {
7682 return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
7683 }
7684
7685 ObjCProtocolDecl **getProtocolStorageImpl();
7686 /// Return the number of qualifying protocols in this interface type,
7687 /// or 0 if there are none.
7688 unsigned getNumProtocolsImpl() const {
7689 return ObjCObjectTypeBits.NumProtocols;
7690 }
7691 void setNumProtocolsImpl(unsigned N) {
7692 ObjCObjectTypeBits.NumProtocols = N;
7693 }
7694
7695protected:
7696 enum Nonce_ObjCInterface { Nonce_ObjCInterface };
7697
7698 ObjCObjectType(QualType Canonical, QualType Base,
7699 ArrayRef<QualType> typeArgs,
7700 ArrayRef<ObjCProtocolDecl *> protocols,
7701 bool isKindOf);
7702
7703 ObjCObjectType(enum Nonce_ObjCInterface)
7704 : Type(ObjCInterface, QualType(), TypeDependence::None),
7705 BaseType(QualType(this_(), 0)) {
7706 ObjCObjectTypeBits.NumProtocols = 0;
7707 ObjCObjectTypeBits.NumTypeArgs = 0;
7708 ObjCObjectTypeBits.IsKindOf = 0;
7709 }
7710
7711 void computeSuperClassTypeSlow() const;
7712
7713public:
7714 /// Gets the base type of this object type. This is always (possibly
7715 /// sugar for) one of:
7716 /// - the 'id' builtin type (as opposed to the 'id' type visible to the
7717 /// user, which is a typedef for an ObjCObjectPointerType)
7718 /// - the 'Class' builtin type (same caveat)
7719 /// - an ObjCObjectType (currently always an ObjCInterfaceType)
7720 QualType getBaseType() const { return BaseType; }
7721
7722 bool isObjCId() const {
7723 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
7724 }
7725
7726 bool isObjCClass() const {
7727 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
7728 }
7729
7730 bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
7731 bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
7732 bool isObjCUnqualifiedIdOrClass() const {
7733 if (!qual_empty()) return false;
7734 if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
7735 return T->getKind() == BuiltinType::ObjCId ||
7736 T->getKind() == BuiltinType::ObjCClass;
7737 return false;
7738 }
7739 bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
7740 bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }
7741
7742 /// Gets the interface declaration for this object type, if the base type
7743 /// really is an interface.
7744 ObjCInterfaceDecl *getInterface() const;
7745
7746 /// Determine whether this object type is "specialized", meaning
7747 /// that it has type arguments.
7748 bool isSpecialized() const;
7749
7750 /// Determine whether this object type was written with type arguments.
7751 bool isSpecializedAsWritten() const {
7752 return ObjCObjectTypeBits.NumTypeArgs > 0;
7753 }
7754
7755 /// Determine whether this object type is "unspecialized", meaning
7756 /// that it has no type arguments.
7757 bool isUnspecialized() const { return !isSpecialized(); }
7758
7759 /// Determine whether this object type is "unspecialized" as
7760 /// written, meaning that it has no type arguments.
7761 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
7762
7763 /// Retrieve the type arguments of this object type (semantically).
7764 ArrayRef<QualType> getTypeArgs() const;
7765
7766 /// Retrieve the type arguments of this object type as they were
7767 /// written.
7768 ArrayRef<QualType> getTypeArgsAsWritten() const {
7769 return {getTypeArgStorage(), ObjCObjectTypeBits.NumTypeArgs};
7770 }
7771
7772 /// Whether this is a "__kindof" type as written.
7773 bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }
7774
7775 /// Whether this ia a "__kindof" type (semantically).
7776 bool isKindOfType() const;
7777
7778 /// Retrieve the type of the superclass of this object type.
7779 ///
7780 /// This operation substitutes any type arguments into the
7781 /// superclass of the current class type, potentially producing a
7782 /// specialization of the superclass type. Produces a null type if
7783 /// there is no superclass.
7784 QualType getSuperClassType() const {
7785 if (!CachedSuperClassType.getInt())
7786 computeSuperClassTypeSlow();
7787
7788 assert(CachedSuperClassType.getInt() && "Superclass not set?");
7789 return QualType(CachedSuperClassType.getPointer(), 0);
7790 }
7791
7792 /// Strip off the Objective-C "kindof" type and (with it) any
7793 /// protocol qualifiers.
7794 QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;
7795
7796 bool isSugared() const { return false; }
7797 QualType desugar() const { return QualType(this, 0); }
7798
7799 static bool classof(const Type *T) {
7800 return T->getTypeClass() == ObjCObject ||
7801 T->getTypeClass() == ObjCInterface;
7802 }
7803};
7804
7805/// A class providing a concrete implementation
7806/// of ObjCObjectType, so as to not increase the footprint of
7807/// ObjCInterfaceType. Code outside of ASTContext and the core type
7808/// system should not reference this type.
7809class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
7810 friend class ASTContext;
7811
7812 // If anyone adds fields here, ObjCObjectType::getProtocolStorage()
7813 // will need to be modified.
7814
7815 ObjCObjectTypeImpl(QualType Canonical, QualType Base,
7816 ArrayRef<QualType> typeArgs,
7817 ArrayRef<ObjCProtocolDecl *> protocols,
7818 bool isKindOf)
7819 : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}
7820
7821public:
7822 void Profile(llvm::FoldingSetNodeID &ID);
7823 static void Profile(llvm::FoldingSetNodeID &ID,
7824 QualType Base,
7825 ArrayRef<QualType> typeArgs,
7826 ArrayRef<ObjCProtocolDecl *> protocols,
7827 bool isKindOf);
7828};
7829
7830inline QualType *ObjCObjectType::getTypeArgStorage() {
7831 return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
7832}
7833
7834inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
7835 return reinterpret_cast<ObjCProtocolDecl**>(
7836 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
7837}
7838
7839inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
7840 return reinterpret_cast<ObjCProtocolDecl**>(
7841 static_cast<ObjCTypeParamType*>(this)+1);
7842}
7843
7844/// Interfaces are the core concept in Objective-C for object oriented design.
7845/// They basically correspond to C++ classes. There are two kinds of interface
7846/// types: normal interfaces like `NSString`, and qualified interfaces, which
7847/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
7848///
7849/// ObjCInterfaceType guarantees the following properties when considered
7850/// as a subtype of its superclass, ObjCObjectType:
7851/// - There are no protocol qualifiers. To reinforce this, code which
7852/// tries to invoke the protocol methods via an ObjCInterfaceType will
7853/// fail to compile.
7854/// - It is its own base type. That is, if T is an ObjCInterfaceType*,
7855/// T->getBaseType() == QualType(T, 0).
7856class ObjCInterfaceType : public ObjCObjectType {
7857 friend class ASTContext; // ASTContext creates these.
7858 friend class ASTReader;
7859 template <class T> friend class serialization::AbstractTypeReader;
7860
7861 ObjCInterfaceDecl *Decl;
7862
7863 ObjCInterfaceType(const ObjCInterfaceDecl *D)
7864 : ObjCObjectType(Nonce_ObjCInterface),
7865 Decl(const_cast<ObjCInterfaceDecl*>(D)) {}
7866
7867public:
7868 /// Get the declaration of this interface.
7869 ObjCInterfaceDecl *getDecl() const;
7870
7871 bool isSugared() const { return false; }
7872 QualType desugar() const { return QualType(this, 0); }
7873
7874 static bool classof(const Type *T) {
7875 return T->getTypeClass() == ObjCInterface;
7876 }
7877
7878 // Nonsense to "hide" certain members of ObjCObjectType within this
7879 // class. People asking for protocols on an ObjCInterfaceType are
7880 // not going to get what they want: ObjCInterfaceTypes are
7881 // guaranteed to have no protocols.
7882 enum {
7888 };
7889};
7890
7891inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
7892 QualType baseType = getBaseType();
7893 while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
7894 if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
7895 return T->getDecl();
7896
7897 baseType = ObjT->getBaseType();
7898 }
7899
7900 return nullptr;
7901}
7902
7903/// Represents a pointer to an Objective C object.
7904///
7905/// These are constructed from pointer declarators when the pointee type is
7906/// an ObjCObjectType (or sugar for one). In addition, the 'id' and 'Class'
7907/// types are typedefs for these, and the protocol-qualified types 'id<P>'
7908/// and 'Class<P>' are translated into these.
7909///
7910/// Pointers to pointers to Objective C objects are still PointerTypes;
7911/// only the first level of pointer gets it own type implementation.
7912class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
7913 friend class ASTContext; // ASTContext creates these.
7914
7915 QualType PointeeType;
7916
7917 ObjCObjectPointerType(QualType Canonical, QualType Pointee)
7918 : Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
7919 PointeeType(Pointee) {}
7920
7921public:
7922 /// Gets the type pointed to by this ObjC pointer.
7923 /// The result will always be an ObjCObjectType or sugar thereof.
7924 QualType getPointeeType() const { return PointeeType; }
7925
7926 /// Gets the type pointed to by this ObjC pointer. Always returns non-null.
7927 ///
7928 /// This method is equivalent to getPointeeType() except that
7929 /// it discards any typedefs (or other sugar) between this
7930 /// type and the "outermost" object type. So for:
7931 /// \code
7932 /// \@class A; \@protocol P; \@protocol Q;
7933 /// typedef A<P> AP;
7934 /// typedef A A1;
7935 /// typedef A1<P> A1P;
7936 /// typedef A1P<Q> A1PQ;
7937 /// \endcode
7938 /// For 'A*', getObjectType() will return 'A'.
7939 /// For 'A<P>*', getObjectType() will return 'A<P>'.
7940 /// For 'AP*', getObjectType() will return 'A<P>'.
7941 /// For 'A1*', getObjectType() will return 'A'.
7942 /// For 'A1<P>*', getObjectType() will return 'A1<P>'.
7943 /// For 'A1P*', getObjectType() will return 'A1<P>'.
7944 /// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
7945 /// adding protocols to a protocol-qualified base discards the
7946 /// old qualifiers (for now). But if it didn't, getObjectType()
7947 /// would return 'A1P<Q>' (and we'd have to make iterating over
7948 /// qualifiers more complicated).
7950 return PointeeType->castAs<ObjCObjectType>();
7951 }
7952
7953 /// If this pointer points to an Objective C
7954 /// \@interface type, gets the type for that interface. Any protocol
7955 /// qualifiers on the interface are ignored.
7956 ///
7957 /// \return null if the base type for this pointer is 'id' or 'Class'
7958 const ObjCInterfaceType *getInterfaceType() const;
7959
7960 /// If this pointer points to an Objective \@interface
7961 /// type, gets the declaration for that interface.
7962 ///
7963 /// \return null if the base type for this pointer is 'id' or 'Class'
7965 return getObjectType()->getInterface();
7966 }
7967
7968 /// True if this is equivalent to the 'id' type, i.e. if
7969 /// its object type is the primitive 'id' type with no protocols.
7970 bool isObjCIdType() const {
7971 return getObjectType()->isObjCUnqualifiedId();
7972 }
7973
7974 /// True if this is equivalent to the 'Class' type,
7975 /// i.e. if its object tive is the primitive 'Class' type with no protocols.
7976 bool isObjCClassType() const {
7977 return getObjectType()->isObjCUnqualifiedClass();
7978 }
7979
7980 /// True if this is equivalent to the 'id' or 'Class' type,
7981 bool isObjCIdOrClassType() const {
7982 return getObjectType()->isObjCUnqualifiedIdOrClass();
7983 }
7984
7985 /// True if this is equivalent to 'id<P>' for some non-empty set of
7986 /// protocols.
7988 return getObjectType()->isObjCQualifiedId();
7989 }
7990
7991 /// True if this is equivalent to 'Class<P>' for some non-empty set of
7992 /// protocols.
7994 return getObjectType()->isObjCQualifiedClass();
7995 }
7996
7997 /// Whether this is a "__kindof" type.
7998 bool isKindOfType() const { return getObjectType()->isKindOfType(); }
7999
8000 /// Whether this type is specialized, meaning that it has type arguments.
8001 bool isSpecialized() const { return getObjectType()->isSpecialized(); }
8002
8003 /// Whether this type is specialized, meaning that it has type arguments.
8005 return getObjectType()->isSpecializedAsWritten();
8006 }
8007
8008 /// Whether this type is unspecialized, meaning that is has no type arguments.
8009 bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }
8010
8011 /// Determine whether this object type is "unspecialized" as
8012 /// written, meaning that it has no type arguments.
8014
8015 /// Retrieve the type arguments for this type.
8017 return getObjectType()->getTypeArgs();
8018 }
8019
8020 /// Retrieve the type arguments for this type.
8022 return getObjectType()->getTypeArgsAsWritten();
8023 }
8024
8025 /// An iterator over the qualifiers on the object type. Provided
8026 /// for convenience. This will always iterate over the full set of
8027 /// protocols on a type, not just those provided directly.
8028 using qual_iterator = ObjCObjectType::qual_iterator;
8029 using qual_range = llvm::iterator_range<qual_iterator>;
8030
8032
8034 return getObjectType()->qual_begin();
8035 }
8036
8038 return getObjectType()->qual_end();
8039 }
8040
8041 bool qual_empty() const { return getObjectType()->qual_empty(); }
8042
8043 /// Return the number of qualifying protocols on the object type.
8044 unsigned getNumProtocols() const {
8045 return getObjectType()->getNumProtocols();
8046 }
8047
8048 /// Retrieve a qualifying protocol by index on the object type.
8049 ObjCProtocolDecl *getProtocol(unsigned I) const {
8050 return getObjectType()->getProtocol(I);
8051 }
8052
8053 bool isSugared() const { return false; }
8054 QualType desugar() const { return QualType(this, 0); }
8055
8056 /// Retrieve the type of the superclass of this object pointer type.
8057 ///
8058 /// This operation substitutes any type arguments into the
8059 /// superclass of the current class type, potentially producing a
8060 /// pointer to a specialization of the superclass type. Produces a
8061 /// null type if there is no superclass.
8062 QualType getSuperClassType() const;
8063
8064 /// Strip off the Objective-C "kindof" type and (with it) any
8065 /// protocol qualifiers.
8066 const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
8067 const ASTContext &ctx) const;
8068
8069 void Profile(llvm::FoldingSetNodeID &ID) {
8070 Profile(ID, getPointeeType());
8071 }
8072
8073 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
8074 ID.AddPointer(T.getAsOpaquePtr());
8075 }
8076
8077 static bool classof(const Type *T) {
8078 return T->getTypeClass() == ObjCObjectPointer;
8079 }
8080};
8081
8082class AtomicType : public Type, public llvm::FoldingSetNode {
8083 friend class ASTContext; // ASTContext creates these.
8084
8085 QualType ValueType;
8086
8087 AtomicType(QualType ValTy, QualType Canonical)
8088 : Type(Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}
8089
8090public:
8091 /// Gets the type contained by this atomic type, i.e.
8092 /// the type returned by performing an atomic load of this atomic type.
8093 QualType getValueType() const { return ValueType; }
8094
8095 bool isSugared() const { return false; }
8096 QualType desugar() const { return QualType(this, 0); }
8097
8098 void Profile(llvm::FoldingSetNodeID &ID) {
8099 Profile(ID, getValueType());
8100 }
8101
8102 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
8103 ID.AddPointer(T.getAsOpaquePtr());
8104 }
8105
8106 static bool classof(const Type *T) {
8107 return T->getTypeClass() == Atomic;
8108 }
8109};
8110
8111/// PipeType - OpenCL20.
8112class PipeType : public Type, public llvm::FoldingSetNode {
8113 friend class ASTContext; // ASTContext creates these.
8114
8115 QualType ElementType;
8116 bool isRead;
8117
8118 PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
8119 : Type(Pipe, CanonicalPtr, elemType->getDependence()),
8120 ElementType(elemType), isRead(isRead) {}
8121
8122public:
8123 QualType getElementType() const { return ElementType; }
8124
8125 bool isSugared() const { return false; }
8126
8127 QualType desugar() const { return QualType(this, 0); }
8128
8129 void Profile(llvm::FoldingSetNodeID &ID) {
8131 }
8132
8133 static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
8134 ID.AddPointer(T.getAsOpaquePtr());
8135 ID.AddBoolean(isRead);
8136 }
8137
8138 static bool classof(const Type *T) {
8139 return T->getTypeClass() == Pipe;
8140 }
8141
8142 bool isReadOnly() const { return isRead; }
8143};
8144
8145/// A fixed int type of a specified bitwidth.
8146class BitIntType final : public Type, public llvm::FoldingSetNode {
8147 friend class ASTContext;
8148 LLVM_PREFERRED_TYPE(bool)
8149 unsigned IsUnsigned : 1;
8150 unsigned NumBits : 24;
8151
8152protected:
8153 BitIntType(bool isUnsigned, unsigned NumBits);
8154
8155public:
8156 bool isUnsigned() const { return IsUnsigned; }
8157 bool isSigned() const { return !IsUnsigned; }
8158 unsigned getNumBits() const { return NumBits; }
8159
8160 bool isSugared() const { return false; }
8161 QualType desugar() const { return QualType(this, 0); }
8162
8163 void Profile(llvm::FoldingSetNodeID &ID) const {
8164 Profile(ID, isUnsigned(), getNumBits());
8165 }
8166
8167 static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned,
8168 unsigned NumBits) {
8169 ID.AddBoolean(IsUnsigned);
8170 ID.AddInteger(NumBits);
8171 }
8172
8173 static bool classof(const Type *T) { return T->getTypeClass() == BitInt; }
8174};
8175
8176class DependentBitIntType final : public Type, public llvm::FoldingSetNode {
8177 friend class ASTContext;
8178 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
8179
8180protected:
8181 DependentBitIntType(bool IsUnsigned, Expr *NumBits);
8182
8183public:
8184 bool isUnsigned() const;
8185 bool isSigned() const { return !isUnsigned(); }
8186 Expr *getNumBitsExpr() const;
8187
8188 bool isSugared() const { return false; }
8189 QualType desugar() const { return QualType(this, 0); }
8190
8191 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
8192 Profile(ID, Context, isUnsigned(), getNumBitsExpr());
8193 }
8194 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
8195 bool IsUnsigned, Expr *NumBitsExpr);
8196
8197 static bool classof(const Type *T) {
8198 return T->getTypeClass() == DependentBitInt;
8199 }
8200};
8201
8202class PredefinedSugarType final : public Type {
8203public:
8204 friend class ASTContext;
8206
8207private:
8208 PredefinedSugarType(Kind KD, const IdentifierInfo *IdentName,
8209 QualType CanonicalType)
8210 : Type(PredefinedSugar, CanonicalType, TypeDependence::None),
8211 Name(IdentName) {
8212 PredefinedSugarTypeBits.Kind = llvm::to_underlying(KD);
8213 }
8214
8215 static StringRef getName(Kind KD);
8216
8217 const IdentifierInfo *Name;
8218
8219public:
8220 bool isSugared() const { return true; }
8221
8223
8224 Kind getKind() const { return Kind(PredefinedSugarTypeBits.Kind); }
8225
8226 const IdentifierInfo *getIdentifier() const { return Name; }
8227
8228 static bool classof(const Type *T) {
8229 return T->getTypeClass() == PredefinedSugar;
8230 }
8231};
8232
8233/// A qualifier set is used to build a set of qualifiers.
8235public:
8237
8238 /// Collect any qualifiers on the given type and return an
8239 /// unqualified type. The qualifiers are assumed to be consistent
8240 /// with those already in the type.
8242 addFastQualifiers(type.getLocalFastQualifiers());
8243 if (!type.hasLocalNonFastQualifiers())
8244 return type.getTypePtrUnsafe();
8245
8246 const ExtQuals *extQuals = type.getExtQualsUnsafe();
8248 return extQuals->getBaseType();
8249 }
8250
8251 /// Apply the collected qualifiers to the given type.
8252 QualType apply(const ASTContext &Context, QualType QT) const;
8253
8254 /// Apply the collected qualifiers to the given type.
8255 QualType apply(const ASTContext &Context, const Type* T) const;
8256};
8257
8258/// A container of type source information.
8259///
8260/// A client can read the relevant info using TypeLoc wrappers, e.g:
8261/// @code
8262/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
8263/// TL.getBeginLoc().print(OS, SrcMgr);
8264/// @endcode
8265class alignas(8) TypeSourceInfo {
8266 // Contains a memory block after the class, used for type source information,
8267 // allocated by ASTContext.
8268 friend class ASTContext;
8269
8270 QualType Ty;
8271
8272 TypeSourceInfo(QualType ty, size_t DataSize); // implemented in TypeLoc.h
8273
8274public:
8275 /// Return the type wrapped by this type source info.
8276 QualType getType() const { return Ty; }
8277
8278 /// Return the TypeLoc wrapper for the type source info.
8279 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
8280
8281 /// Override the type stored in this TypeSourceInfo. Use with caution!
8282 void overrideType(QualType T) { Ty = T; }
8283};
8284
8285// Inline function definitions.
8286
8288 SplitQualType desugar =
8289 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
8291 return desugar;
8292}
8293
8294inline const Type *QualType::getTypePtr() const {
8295 return getCommonPtr()->BaseType;
8296}
8297
8298inline const Type *QualType::getTypePtrOrNull() const {
8299 return (isNull() ? nullptr : getCommonPtr()->BaseType);
8300}
8301
8302inline bool QualType::isReferenceable() const {
8303 // C++ [defns.referenceable]
8304 // type that is either an object type, a function type that does not have
8305 // cv-qualifiers or a ref-qualifier, or a reference type.
8306 const Type &Self = **this;
8307 if (Self.isObjectType() || Self.isReferenceType())
8308 return true;
8309 if (const auto *F = Self.getAs<FunctionProtoType>())
8310 return F->getMethodQuals().empty() && F->getRefQualifier() == RQ_None;
8311
8312 return false;
8313}
8314
8317 return SplitQualType(getTypePtrUnsafe(),
8319
8320 const ExtQuals *eq = getExtQualsUnsafe();
8321 Qualifiers qs = eq->getQualifiers();
8323 return SplitQualType(eq->getBaseType(), qs);
8324}
8325
8327 Qualifiers Quals;
8329 Quals = getExtQualsUnsafe()->getQualifiers();
8331 return Quals;
8332}
8333
8335 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
8337 return quals;
8338}
8339
8340inline unsigned QualType::getCVRQualifiers() const {
8341 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
8342 cvr |= getLocalCVRQualifiers();
8343 return cvr;
8344}
8345
8347 QualType canon = getCommonPtr()->CanonicalType;
8349}
8350
8351inline bool QualType::isCanonical() const {
8352 return getTypePtr()->isCanonicalUnqualified();
8353}
8354
8355inline bool QualType::isCanonicalAsParam() const {
8356 if (!isCanonical()) return false;
8357 if (hasLocalQualifiers()) return false;
8358
8359 const Type *T = getTypePtr();
8360 if (T->isVariablyModifiedType() && T->hasSizedVLAType())
8361 return false;
8362
8363 return !isa<FunctionType>(T) &&
8365}
8366
8367inline bool QualType::isConstQualified() const {
8368 return isLocalConstQualified() ||
8369 getCommonPtr()->CanonicalType.isLocalConstQualified();
8370}
8371
8373 return isLocalRestrictQualified() ||
8374 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
8375}
8376
8377
8379 return isLocalVolatileQualified() ||
8380 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
8381}
8382
8383inline bool QualType::hasQualifiers() const {
8384 return hasLocalQualifiers() ||
8385 getCommonPtr()->CanonicalType.hasLocalQualifiers();
8386}
8387
8389 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
8390 return QualType(getTypePtr(), 0);
8391
8392 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
8393}
8394
8396 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
8397 return split();
8398
8399 return getSplitUnqualifiedTypeImpl(*this);
8400}
8401
8405
8409
8413
8414/// Check if this type has any address space qualifier.
8415inline bool QualType::hasAddressSpace() const {
8416 return getQualifiers().hasAddressSpace();
8417}
8418
8419/// Return the address space of this type.
8421 return getQualifiers().getAddressSpace();
8422}
8423
8424/// Return the gc attribute of this type.
8426 return getQualifiers().getObjCGCAttr();
8427}
8428
8430 if (const auto *PT = t.getAs<PointerType>()) {
8431 if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
8432 return FT->getExtInfo();
8433 } else if (const auto *FT = t.getAs<FunctionType>())
8434 return FT->getExtInfo();
8435
8436 return FunctionType::ExtInfo();
8437}
8438
8442
8443/// Determine whether this type is more
8444/// qualified than the Other type. For example, "const volatile int"
8445/// is more qualified than "const int", "volatile int", and
8446/// "int". However, it is not more qualified than "const volatile
8447/// int".
8449 const ASTContext &Ctx) const {
8450 Qualifiers MyQuals = getQualifiers();
8451 Qualifiers OtherQuals = other.getQualifiers();
8452 return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals, Ctx));
8453}
8454
8455/// Determine whether this type is at last
8456/// as qualified as the Other type. For example, "const volatile
8457/// int" is at least as qualified as "const int", "volatile int",
8458/// "int", and "const volatile int".
8460 const ASTContext &Ctx) const {
8461 Qualifiers OtherQuals = other.getQualifiers();
8462
8463 // Ignore __unaligned qualifier if this type is a void.
8464 if (getUnqualifiedType()->isVoidType())
8465 OtherQuals.removeUnaligned();
8466
8467 return getQualifiers().compatiblyIncludes(OtherQuals, Ctx);
8468}
8469
8470/// If Type is a reference type (e.g., const
8471/// int&), returns the type that the reference refers to ("const
8472/// int"). Otherwise, returns the type itself. This routine is used
8473/// throughout Sema to implement C++ 5p6:
8474///
8475/// If an expression initially has the type "reference to T" (8.3.2,
8476/// 8.5.3), the type is adjusted to "T" prior to any further
8477/// analysis, the expression designates the object or function
8478/// denoted by the reference, and the expression is an lvalue.
8480 if (const auto *RefType = (*this)->getAs<ReferenceType>())
8481 return RefType->getPointeeType();
8482 else
8483 return *this;
8484}
8485
8487 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
8488 getTypePtr()->isFunctionType());
8489}
8490
8491/// Tests whether the type is categorized as a fundamental type.
8492///
8493/// \returns True for types specified in C++0x [basic.fundamental].
8494inline bool Type::isFundamentalType() const {
8495 return isVoidType() ||
8496 isNullPtrType() ||
8497 // FIXME: It's really annoying that we don't have an
8498 // 'isArithmeticType()' which agrees with the standard definition.
8500}
8501
8502/// Tests whether the type is categorized as a compound type.
8503///
8504/// \returns True for types specified in C++0x [basic.compound].
8505inline bool Type::isCompoundType() const {
8506 // C++0x [basic.compound]p1:
8507 // Compound types can be constructed in the following ways:
8508 // -- arrays of objects of a given type [...];
8509 return isArrayType() ||
8510 // -- functions, which have parameters of given types [...];
8511 isFunctionType() ||
8512 // -- pointers to void or objects or functions [...];
8513 isPointerType() ||
8514 // -- references to objects or functions of a given type. [...]
8515 isReferenceType() ||
8516 // -- classes containing a sequence of objects of various types, [...];
8517 isRecordType() ||
8518 // -- unions, which are classes capable of containing objects of different
8519 // types at different times;
8520 isUnionType() ||
8521 // -- enumerations, which comprise a set of named constant values. [...];
8522 isEnumeralType() ||
8523 // -- pointers to non-static class members, [...].
8525}
8526
8527inline bool Type::isFunctionType() const {
8528 return isa<FunctionType>(CanonicalType);
8529}
8530
8531inline bool Type::isPointerType() const {
8532 return isa<PointerType>(CanonicalType);
8533}
8534
8536 return isPointerType() || isReferenceType();
8537}
8538
8539inline bool Type::isAnyPointerType() const {
8541}
8542
8543inline bool Type::isSignableType(const ASTContext &Ctx) const {
8545}
8546
8547inline bool Type::isSignablePointerType() const {
8549}
8550
8551inline bool Type::isBlockPointerType() const {
8552 return isa<BlockPointerType>(CanonicalType);
8553}
8554
8555inline bool Type::isReferenceType() const {
8556 return isa<ReferenceType>(CanonicalType);
8557}
8558
8559inline bool Type::isLValueReferenceType() const {
8560 return isa<LValueReferenceType>(CanonicalType);
8561}
8562
8563inline bool Type::isRValueReferenceType() const {
8564 return isa<RValueReferenceType>(CanonicalType);
8565}
8566
8567inline bool Type::isObjectPointerType() const {
8568 // Note: an "object pointer type" is not the same thing as a pointer to an
8569 // object type; rather, it is a pointer to an object type or a pointer to cv
8570 // void.
8571 if (const auto *T = getAs<PointerType>())
8572 return !T->getPointeeType()->isFunctionType();
8573 else
8574 return false;
8575}
8576
8578 if (const auto *Fn = getAs<FunctionProtoType>())
8579 return Fn->hasCFIUncheckedCallee();
8580 return false;
8581}
8582
8584 QualType Pointee;
8585 if (const auto *PT = getAs<PointerType>())
8586 Pointee = PT->getPointeeType();
8587 else if (const auto *RT = getAs<ReferenceType>())
8588 Pointee = RT->getPointeeType();
8589 else if (const auto *MPT = getAs<MemberPointerType>())
8590 Pointee = MPT->getPointeeType();
8591 else if (const auto *DT = getAs<DecayedType>())
8592 Pointee = DT->getPointeeType();
8593 else
8594 return false;
8595 return Pointee->isCFIUncheckedCalleeFunctionType();
8596}
8597
8598inline bool Type::isFunctionPointerType() const {
8599 if (const auto *T = getAs<PointerType>())
8600 return T->getPointeeType()->isFunctionType();
8601 else
8602 return false;
8603}
8604
8606 if (const auto *T = getAs<ReferenceType>())
8607 return T->getPointeeType()->isFunctionType();
8608 else
8609 return false;
8610}
8611
8612inline bool Type::isMemberPointerType() const {
8613 return isa<MemberPointerType>(CanonicalType);
8614}
8615
8617 if (const auto *T = getAs<MemberPointerType>())
8618 return T->isMemberFunctionPointer();
8619 else
8620 return false;
8621}
8622
8624 if (const auto *T = getAs<MemberPointerType>())
8625 return T->isMemberDataPointer();
8626 else
8627 return false;
8628}
8629
8630inline bool Type::isArrayType() const {
8631 return isa<ArrayType>(CanonicalType);
8632}
8633
8634inline bool Type::isConstantArrayType() const {
8635 return isa<ConstantArrayType>(CanonicalType);
8636}
8637
8638inline bool Type::isIncompleteArrayType() const {
8639 return isa<IncompleteArrayType>(CanonicalType);
8640}
8641
8642inline bool Type::isVariableArrayType() const {
8643 return isa<VariableArrayType>(CanonicalType);
8644}
8645
8646inline bool Type::isArrayParameterType() const {
8647 return isa<ArrayParameterType>(CanonicalType);
8648}
8649
8651 return isa<DependentSizedArrayType>(CanonicalType);
8652}
8653
8654inline bool Type::isBuiltinType() const {
8655 return isa<BuiltinType>(CanonicalType);
8656}
8657
8658inline bool Type::isRecordType() const {
8659 return isa<RecordType>(CanonicalType);
8660}
8661
8662inline bool Type::isEnumeralType() const {
8663 return isa<EnumType>(CanonicalType);
8664}
8665
8666inline bool Type::isAnyComplexType() const {
8667 return isa<ComplexType>(CanonicalType);
8668}
8669
8670inline bool Type::isVectorType() const {
8671 return isa<VectorType>(CanonicalType);
8672}
8673
8674inline bool Type::isExtVectorType() const {
8675 return isa<ExtVectorType>(CanonicalType);
8676}
8677
8678inline bool Type::isExtVectorBoolType() const {
8679 if (!isExtVectorType())
8680 return false;
8681 return cast<ExtVectorType>(CanonicalType)->getElementType()->isBooleanType();
8682}
8683
8685 return isVectorType() || isSveVLSBuiltinType();
8686}
8687
8688inline bool Type::isMatrixType() const {
8689 return isa<MatrixType>(CanonicalType);
8690}
8691
8692inline bool Type::isConstantMatrixType() const {
8693 return isa<ConstantMatrixType>(CanonicalType);
8694}
8695
8697 return isa<DependentAddressSpaceType>(CanonicalType);
8698}
8699
8701 return isa<ObjCObjectPointerType>(CanonicalType);
8702}
8703
8704inline bool Type::isObjCObjectType() const {
8705 return isa<ObjCObjectType>(CanonicalType);
8706}
8707
8709 return isa<ObjCInterfaceType>(CanonicalType) ||
8710 isa<ObjCObjectType>(CanonicalType);
8711}
8712
8713inline bool Type::isAtomicType() const {
8714 return isa<AtomicType>(CanonicalType);
8715}
8716
8717inline bool Type::isUndeducedAutoType() const {
8718 return isa<AutoType>(CanonicalType);
8719}
8720
8721inline bool Type::isObjCQualifiedIdType() const {
8722 if (const auto *OPT = getAs<ObjCObjectPointerType>())
8723 return OPT->isObjCQualifiedIdType();
8724 return false;
8725}
8726
8728 if (const auto *OPT = getAs<ObjCObjectPointerType>())
8729 return OPT->isObjCQualifiedClassType();
8730 return false;
8731}
8732
8733inline bool Type::isObjCIdType() const {
8734 if (const auto *OPT = getAs<ObjCObjectPointerType>())
8735 return OPT->isObjCIdType();
8736 return false;
8737}
8738
8739inline bool Type::isObjCClassType() const {
8740 if (const auto *OPT = getAs<ObjCObjectPointerType>())
8741 return OPT->isObjCClassType();
8742 return false;
8743}
8744
8745inline bool Type::isObjCSelType() const {
8746 if (const auto *OPT = getAs<PointerType>())
8747 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
8748 return false;
8749}
8750
8751inline bool Type::isObjCBuiltinType() const {
8752 return isObjCIdType() || isObjCClassType() || isObjCSelType();
8753}
8754
8755inline bool Type::isDecltypeType() const {
8756 return isa<DecltypeType>(this);
8757}
8758
8759#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8760 inline bool Type::is##Id##Type() const { \
8761 return isSpecificBuiltinType(BuiltinType::Id); \
8762 }
8763#include "clang/Basic/OpenCLImageTypes.def"
8764
8765inline bool Type::isSamplerT() const {
8766 return isSpecificBuiltinType(BuiltinType::OCLSampler);
8767}
8768
8769inline bool Type::isEventT() const {
8770 return isSpecificBuiltinType(BuiltinType::OCLEvent);
8771}
8772
8773inline bool Type::isClkEventT() const {
8774 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
8775}
8776
8777inline bool Type::isQueueT() const {
8778 return isSpecificBuiltinType(BuiltinType::OCLQueue);
8779}
8780
8781inline bool Type::isReserveIDT() const {
8782 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
8783}
8784
8785inline bool Type::isImageType() const {
8786#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
8787 return
8788#include "clang/Basic/OpenCLImageTypes.def"
8789 false; // end boolean or operation
8790}
8791
8792inline bool Type::isPipeType() const {
8793 return isa<PipeType>(CanonicalType);
8794}
8795
8796inline bool Type::isBitIntType() const {
8797 return isa<BitIntType>(CanonicalType);
8798}
8799
8800#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
8801 inline bool Type::is##Id##Type() const { \
8802 return isSpecificBuiltinType(BuiltinType::Id); \
8803 }
8804#include "clang/Basic/OpenCLExtensionTypes.def"
8805
8807#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
8808 isOCLIntelSubgroupAVC##Id##Type() ||
8809 return
8810#include "clang/Basic/OpenCLExtensionTypes.def"
8811 false; // end of boolean or operation
8812}
8813
8814inline bool Type::isOCLExtOpaqueType() const {
8815#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
8816 return
8817#include "clang/Basic/OpenCLExtensionTypes.def"
8818 false; // end of boolean or operation
8819}
8820
8821inline bool Type::isOpenCLSpecificType() const {
8822 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
8824}
8825
8826#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
8827 inline bool Type::is##Id##Type() const { \
8828 return isSpecificBuiltinType(BuiltinType::Id); \
8829 }
8830#include "clang/Basic/HLSLIntangibleTypes.def"
8831
8833#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) is##Id##Type() ||
8834 return
8835#include "clang/Basic/HLSLIntangibleTypes.def"
8836 false;
8837}
8838
8843
8846}
8847
8848inline bool Type::isHLSLInlineSpirvType() const {
8849 return isa<HLSLInlineSpirvType>(this);
8850}
8851
8852inline bool Type::isTemplateTypeParmType() const {
8853 return isa<TemplateTypeParmType>(CanonicalType);
8854}
8855
8856inline bool Type::isSpecificBuiltinType(unsigned K) const {
8857 if (const BuiltinType *BT = getAs<BuiltinType>()) {
8858 return BT->getKind() == static_cast<BuiltinType::Kind>(K);
8859 }
8860 return false;
8861}
8862
8863inline bool Type::isPlaceholderType() const {
8864 if (const auto *BT = dyn_cast<BuiltinType>(this))
8865 return BT->isPlaceholderType();
8866 return false;
8867}
8868
8870 if (const auto *BT = dyn_cast<BuiltinType>(this))
8871 if (BT->isPlaceholderType())
8872 return BT;
8873 return nullptr;
8874}
8875
8876inline bool Type::isSpecificPlaceholderType(unsigned K) const {
8878 return isSpecificBuiltinType(K);
8879}
8880
8882 if (const auto *BT = dyn_cast<BuiltinType>(this))
8883 return BT->isNonOverloadPlaceholderType();
8884 return false;
8885}
8886
8887inline bool Type::isVoidType() const {
8888 return isSpecificBuiltinType(BuiltinType::Void);
8889}
8890
8891inline bool Type::isHalfType() const {
8892 // FIXME: Should we allow complex __fp16? Probably not.
8893 return isSpecificBuiltinType(BuiltinType::Half);
8894}
8895
8896inline bool Type::isFloat16Type() const {
8897 return isSpecificBuiltinType(BuiltinType::Float16);
8898}
8899
8900inline bool Type::isFloat32Type() const {
8901 return isSpecificBuiltinType(BuiltinType::Float);
8902}
8903
8904inline bool Type::isDoubleType() const {
8905 return isSpecificBuiltinType(BuiltinType::Double);
8906}
8907
8908inline bool Type::isBFloat16Type() const {
8909 return isSpecificBuiltinType(BuiltinType::BFloat16);
8910}
8911
8912inline bool Type::isMFloat8Type() const {
8913 return isSpecificBuiltinType(BuiltinType::MFloat8);
8914}
8915
8916inline bool Type::isFloat128Type() const {
8917 return isSpecificBuiltinType(BuiltinType::Float128);
8918}
8919
8920inline bool Type::isIbm128Type() const {
8921 return isSpecificBuiltinType(BuiltinType::Ibm128);
8922}
8923
8924inline bool Type::isNullPtrType() const {
8925 return isSpecificBuiltinType(BuiltinType::NullPtr);
8926}
8927
8930
8931inline bool Type::isIntegerType() const {
8932 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8933 return BT->isInteger();
8934 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
8935 // Incomplete enum types are not treated as integer types.
8936 // FIXME: In C++, enum types are never integer types.
8937 return IsEnumDeclComplete(ET->getOriginalDecl()) &&
8938 !IsEnumDeclScoped(ET->getOriginalDecl());
8939 }
8940 return isBitIntType();
8941}
8942
8943inline bool Type::isFixedPointType() const {
8944 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8945 return BT->getKind() >= BuiltinType::ShortAccum &&
8946 BT->getKind() <= BuiltinType::SatULongFract;
8947 }
8948 return false;
8949}
8950
8952 return isFixedPointType() || isIntegerType();
8953}
8954
8958
8960 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8961 return BT->getKind() >= BuiltinType::SatShortAccum &&
8962 BT->getKind() <= BuiltinType::SatULongFract;
8963 }
8964 return false;
8965}
8966
8970
8971inline bool Type::isSignedFixedPointType() const {
8972 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8973 return ((BT->getKind() >= BuiltinType::ShortAccum &&
8974 BT->getKind() <= BuiltinType::LongAccum) ||
8975 (BT->getKind() >= BuiltinType::ShortFract &&
8976 BT->getKind() <= BuiltinType::LongFract) ||
8977 (BT->getKind() >= BuiltinType::SatShortAccum &&
8978 BT->getKind() <= BuiltinType::SatLongAccum) ||
8979 (BT->getKind() >= BuiltinType::SatShortFract &&
8980 BT->getKind() <= BuiltinType::SatLongFract));
8981 }
8982 return false;
8983}
8984
8987}
8988
8989inline bool Type::isScalarType() const {
8990 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8991 return BT->getKind() > BuiltinType::Void &&
8992 BT->getKind() <= BuiltinType::NullPtr;
8993 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
8994 // Enums are scalar types, but only if they are defined. Incomplete enums
8995 // are not treated as scalar types.
8996 return IsEnumDeclComplete(ET->getOriginalDecl());
8997 return isa<PointerType>(CanonicalType) ||
8998 isa<BlockPointerType>(CanonicalType) ||
8999 isa<MemberPointerType>(CanonicalType) ||
9000 isa<ComplexType>(CanonicalType) ||
9001 isa<ObjCObjectPointerType>(CanonicalType) ||
9002 isBitIntType();
9003}
9004
9006 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
9007 return BT->isInteger();
9008
9009 // Check for a complete enum type; incomplete enum types are not properly an
9010 // enumeration type in the sense required here.
9011 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
9012 return IsEnumDeclComplete(ET->getOriginalDecl());
9013
9014 return isBitIntType();
9015}
9016
9017inline bool Type::isBooleanType() const {
9018 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
9019 return BT->getKind() == BuiltinType::Bool;
9020 return false;
9021}
9022
9023inline bool Type::isUndeducedType() const {
9024 auto *DT = getContainedDeducedType();
9025 return DT && !DT->isDeduced();
9026}
9027
9028/// Determines whether this is a type for which one can define
9029/// an overloaded operator.
9030inline bool Type::isOverloadableType() const {
9031 if (!isDependentType())
9032 return isRecordType() || isEnumeralType();
9033 return !isArrayType() && !isFunctionType() && !isAnyPointerType() &&
9035}
9036
9037/// Determines whether this type is written as a typedef-name.
9038inline bool Type::isTypedefNameType() const {
9039 if (getAs<TypedefType>())
9040 return true;
9041 if (auto *TST = getAs<TemplateSpecializationType>())
9042 return TST->isTypeAlias();
9043 return false;
9044}
9045
9046/// Determines whether this type can decay to a pointer type.
9047inline bool Type::canDecayToPointerType() const {
9048 return isFunctionType() || (isArrayType() && !isArrayParameterType());
9049}
9050
9055
9057 return isObjCObjectPointerType();
9058}
9059
9061 const Type *type = this;
9062 while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
9063 type = arrayType->getElementType().getTypePtr();
9064 return type;
9065}
9066
9068 const Type *type = this;
9069 if (type->isAnyPointerType())
9070 return type->getPointeeType().getTypePtr();
9071 else if (type->isArrayType())
9072 return type->getBaseElementTypeUnsafe();
9073 return type;
9074}
9075/// Insertion operator for partial diagnostics. This allows sending adress
9076/// spaces into a diagnostic with <<.
9078 LangAS AS) {
9079 PD.AddTaggedVal(llvm::to_underlying(AS),
9081 return PD;
9082}
9083
9084/// Insertion operator for partial diagnostics. This allows sending Qualifiers
9085/// into a diagnostic with <<.
9092
9093/// Insertion operator for partial diagnostics. This allows sending QualType's
9094/// into a diagnostic with <<.
9096 QualType T) {
9097 PD.AddTaggedVal(reinterpret_cast<uint64_t>(T.getAsOpaquePtr()),
9099 return PD;
9100}
9101
9102// Helper class template that is used by Type::getAs to ensure that one does
9103// not try to look through a qualified type to get to an array type.
9104template <typename T> using TypeIsArrayType = std::is_base_of<ArrayType, T>;
9105
9106// Member-template getAs<specific type>'.
9107template <typename T> const T *Type::getAs() const {
9108 static_assert(!TypeIsArrayType<T>::value,
9109 "ArrayType cannot be used with getAs!");
9110
9111 // If this is directly a T type, return it.
9112 if (const auto *Ty = dyn_cast<T>(this))
9113 return Ty;
9114
9115 // If the canonical form of this type isn't the right kind, reject it.
9116 if (!isa<T>(CanonicalType))
9117 return nullptr;
9118
9119 // If this is a typedef for the type, strip the typedef off without
9120 // losing all typedef information.
9122}
9123
9124template <typename T> const T *Type::getAsAdjusted() const {
9125 static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");
9126
9127 // If this is directly a T type, return it.
9128 if (const auto *Ty = dyn_cast<T>(this))
9129 return Ty;
9130
9131 // If the canonical form of this type isn't the right kind, reject it.
9132 if (!isa<T>(CanonicalType))
9133 return nullptr;
9134
9135 // Strip off type adjustments that do not modify the underlying nature of the
9136 // type.
9137 const Type *Ty = this;
9138 while (Ty) {
9139 if (const auto *A = dyn_cast<AttributedType>(Ty))
9140 Ty = A->getModifiedType().getTypePtr();
9141 else if (const auto *A = dyn_cast<BTFTagAttributedType>(Ty))
9142 Ty = A->getWrappedType().getTypePtr();
9143 else if (const auto *A = dyn_cast<HLSLAttributedResourceType>(Ty))
9144 Ty = A->getWrappedType().getTypePtr();
9145 else if (const auto *P = dyn_cast<ParenType>(Ty))
9146 Ty = P->desugar().getTypePtr();
9147 else if (const auto *A = dyn_cast<AdjustedType>(Ty))
9148 Ty = A->desugar().getTypePtr();
9149 else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
9150 Ty = M->desugar().getTypePtr();
9151 else
9152 break;
9153 }
9154
9155 // Just because the canonical type is correct does not mean we can use cast<>,
9156 // since we may not have stripped off all the sugar down to the base type.
9157 return dyn_cast<T>(Ty);
9158}
9159
9161 // If this is directly an array type, return it.
9162 if (const auto *arr = dyn_cast<ArrayType>(this))
9163 return arr;
9164
9165 // If the canonical form of this type isn't the right kind, reject it.
9166 if (!isa<ArrayType>(CanonicalType))
9167 return nullptr;
9168
9169 // If this is a typedef for the type, strip the typedef off without
9170 // losing all typedef information.
9172}
9173
9174template <typename T> const T *Type::castAs() const {
9175 static_assert(!TypeIsArrayType<T>::value,
9176 "ArrayType cannot be used with castAs!");
9177
9178 if (const auto *ty = dyn_cast<T>(this)) return ty;
9179 assert(isa<T>(CanonicalType));
9181}
9182
9184 assert(isa<ArrayType>(CanonicalType));
9185 if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
9187}
9188
9189DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
9190 QualType CanonicalPtr)
9191 : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
9192#ifndef NDEBUG
9193 QualType Adjusted = getAdjustedType();
9194 (void)AttributedType::stripOuterNullability(Adjusted);
9195 assert(isa<PointerType>(Adjusted));
9196#endif
9197}
9198
9200 QualType Decayed = getDecayedType();
9201 (void)AttributedType::stripOuterNullability(Decayed);
9202 return cast<PointerType>(Decayed)->getPointeeType();
9203}
9204
9205// Get the decimal string representation of a fixed point type, represented
9206// as a scaled integer.
9207// TODO: At some point, we should change the arguments to instead just accept an
9208// APFixedPoint instead of APSInt and scale.
9209void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
9210 unsigned Scale);
9211
9212inline FunctionEffectsRef FunctionEffectsRef::get(QualType QT) {
9213 const Type *TypePtr = QT.getTypePtr();
9214 while (true) {
9215 if (QualType Pointee = TypePtr->getPointeeType(); !Pointee.isNull())
9216 TypePtr = Pointee.getTypePtr();
9217 else if (TypePtr->isArrayType())
9218 TypePtr = TypePtr->getBaseElementTypeUnsafe();
9219 else
9220 break;
9221 }
9222 if (const auto *FPT = TypePtr->getAs<FunctionProtoType>())
9223 return FPT->getFunctionEffects();
9224 return {};
9225}
9226
9227} // namespace clang
9228
9229#endif // LLVM_CLANG_AST_TYPE_BASE_H
#define V(N, I)
Provides definitions for the various language-specific address spaces.
static bool isUnsigned(SValBuilder &SVB, NonLoc Value)
Defines the clang::attr::Kind enum.
Defines the Diagnostic-related interfaces.
static bool isBooleanType(QualType Ty)
llvm::dxil::ResourceClass ResourceClass
static std::optional< NonLoc > getIndex(ProgramStateRef State, const ElementRegion *ER, CharKind CK)
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
Definition CharUnits.h:225
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
static Decl::Kind getKind(const Decl *D)
Defines the ExceptionSpecificationType enumeration and various utility functions.
static QualType getObjectType(APValue::LValueBase B)
Retrieves the "underlying object type" of the given expression, as used by __builtin_object_size.
TokenType getType() const
Returns the token's type, e.g.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
Definition MachO.h:31
#define SM(sm)
static StringRef getIdentifier(const Token &Tok)
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
static QualType getUnderlyingType(const SubRegion *R)
static bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)
Definition SemaCUDA.cpp:109
static RecordDecl * getAsRecordDecl(QualType BaseType, HeuristicResolver &Resolver)
static bool isRecordType(QualType T)
static bool isParameterPack(Expr *PackExpression)
Defines the clang::SourceLocation class and associated facilities.
Defines various enumerations that describe declaration and type specifiers.
static OMPAtomicDirective * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, ArrayRef< OMPClause * > Clauses, Stmt *AssociatedStmt, Expressions Exprs)
Creates directive with a list of Clauses and 'x', 'v' and 'expr' parts of the atomic construct (see S...
static bool classof(const Stmt *T)
static QualType getPointeeType(const MemRegion *R)
static const TemplateTypeParmDecl * getReplacedParameter(Decl *D, unsigned Index)
Definition Type.cpp:4439
Defines the clang::Visibility enumeration and various utility functions.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
__device__ __2f16 b
__device__ __2f16 float __ockl_bool s
__device__ __2f16 float c
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:220
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:220
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons.
Definition TypeBase.h:3489
static bool classof(const Type *T)
Definition TypeBase.h:3519
static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New)
Definition TypeBase.h:3514
AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy, QualType CanonicalPtr)
Definition TypeBase.h:3496
QualType desugar() const
Definition TypeBase.h:3508
QualType getAdjustedType() const
Definition TypeBase.h:3505
friend class ASTContext
Definition TypeBase.h:3494
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3510
bool isSugared() const
Definition TypeBase.h:3507
QualType getOriginalType() const
Definition TypeBase.h:3504
static bool classof(const Type *T)
Definition TypeBase.h:3899
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition TypeBase.h:3722
ArraySizeModifier getSizeModifier() const
Definition TypeBase.h:3736
Qualifiers getIndexTypeQualifiers() const
Definition TypeBase.h:3740
static bool classof(const Type *T)
Definition TypeBase.h:3748
QualType getElementType() const
Definition TypeBase.h:3734
friend class ASTContext
Definition TypeBase.h:3728
ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm, unsigned tq, const Expr *sz=nullptr)
Definition Type.cpp:174
unsigned getIndexTypeCVRQualifiers() const
Definition TypeBase.h:3744
static void Profile(llvm::FoldingSetNodeID &ID, QualType T)
Definition TypeBase.h:8102
bool isSugared() const
Definition TypeBase.h:8095
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition TypeBase.h:8093
QualType desugar() const
Definition TypeBase.h:8096
friend class ASTContext
Definition TypeBase.h:8083
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:8098
static bool classof(const Type *T)
Definition TypeBase.h:8106
Attr - This represents one attribute.
Definition Attr.h:44
bool isSigned() const
Definition TypeBase.h:8157
static bool classof(const Type *T)
Definition TypeBase.h:8173
BitIntType(bool isUnsigned, unsigned NumBits)
Definition Type.cpp:424
static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned, unsigned NumBits)
Definition TypeBase.h:8167
bool isSugared() const
Definition TypeBase.h:8160
friend class ASTContext
Definition TypeBase.h:8147
bool isUnsigned() const
Definition TypeBase.h:8156
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:8163
unsigned getNumBits() const
Definition TypeBase.h:8158
QualType desugar() const
Definition TypeBase.h:8161
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3559
QualType getPointeeType() const
Definition TypeBase.h:3554
friend class ASTContext
Definition TypeBase.h:3543
static bool classof(const Type *T)
Definition TypeBase.h:3567
static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee)
Definition TypeBase.h:3563
QualType desugar() const
Definition TypeBase.h:3557
bool isSugared() const
Definition TypeBase.h:3556
[BoundsSafety] Represents a parent type class for CountAttributedType and similar sugar types that wi...
Definition TypeBase.h:3388
decl_iterator dependent_decl_begin() const
Definition TypeBase.h:3403
decl_iterator dependent_decl_end() const
Definition TypeBase.h:3404
unsigned getNumCoupledDecls() const
Definition TypeBase.h:3406
BoundsAttributedType(TypeClass TC, QualType Wrapped, QualType Canon)
Definition Type.cpp:3981
const TypeCoupledDeclRefInfo * decl_iterator
Definition TypeBase.h:3400
decl_range dependent_decls() const
Definition TypeBase.h:3408
QualType desugar() const
Definition TypeBase.h:3398
ArrayRef< TypeCoupledDeclRefInfo > getCoupledDecls() const
Definition TypeBase.h:3412
llvm::iterator_range< decl_iterator > decl_range
Definition TypeBase.h:3401
static bool classof(const Type *T)
Definition TypeBase.h:3418
ArrayRef< TypeCoupledDeclRefInfo > Decls
Definition TypeBase.h:3392
This class is used for builtin types like 'int'.
Definition TypeBase.h:3164
bool isPlaceholderType() const
Determines whether this type is a placeholder type, i.e.
Definition TypeBase.h:3253
bool isSugared() const
Definition TypeBase.h:3222
bool isNonOverloadPlaceholderType() const
Determines whether this type is a placeholder type other than Overload.
Definition TypeBase.h:3266
bool isSVECount() const
Definition TypeBase.h:3243
bool isSVEBool() const
Definition TypeBase.h:3241
QualType desugar() const
Definition TypeBase.h:3223
bool isInteger() const
Definition TypeBase.h:3225
friend class ASTContext
Definition TypeBase.h:3198
bool isFloatingPoint() const
Definition TypeBase.h:3237
static bool classof(const Type *T)
Definition TypeBase.h:3270
bool isSignedInteger() const
Definition TypeBase.h:3229
bool isUnsignedInteger() const
Definition TypeBase.h:3233
Kind getKind() const
Definition TypeBase.h:3212
static bool isPlaceholderTypeKind(Kind K)
Determines whether the given kind corresponds to a placeholder type.
Definition TypeBase.h:3246
StringRef getName(const PrintingPolicy &Policy) const
Definition Type.cpp:3363
const char * getNameAsCString(const PrintingPolicy &Policy) const
Definition TypeBase.h:3215
Represents a C++ struct/union/class.
Definition DeclCXX.h:258
Complex values, per C99 6.2.5p11.
Definition TypeBase.h:3275
bool isSugared() const
Definition TypeBase.h:3287
QualType getElementType() const
Definition TypeBase.h:3285
static void Profile(llvm::FoldingSetNodeID &ID, QualType Element)
Definition TypeBase.h:3294
static bool classof(const Type *T)
Definition TypeBase.h:3298
friend class ASTContext
Definition TypeBase.h:3276
QualType desugar() const
Definition TypeBase.h:3288
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3290
Declaration of a C++20 concept.
Represents the canonical version of C arrays with a specified constant size.
Definition TypeBase.h:3760
unsigned getSizeBitWidth() const
Return the bit width of the size type.
Definition TypeBase.h:3823
ConstantArrayType(TypeClass Tc, const ConstantArrayType *ATy, QualType Can)
Definition TypeBase.h:3802
ExternalSize * SizePtr
Definition TypeBase.h:3772
QualType desugar() const
Definition TypeBase.h:3861
uint64_t getLimitedSize() const
Return the size zero-extended to uint64_t or UINT64_MAX if the value is larger than UINT64_MAX.
Definition TypeBase.h:3849
bool isZeroSize() const
Return true if the size is zero.
Definition TypeBase.h:3830
int64_t getSExtSize() const
Return the size sign-extended as a uint64_t.
Definition TypeBase.h:3842
friend class ASTContext
Definition TypeBase.h:3761
const Expr * getSizeExpr() const
Return a pointer to the size expression.
Definition TypeBase.h:3856
static bool classof(const Type *T)
Definition TypeBase.h:3884
llvm::APInt getSize() const
Return the constant array size as an APInt.
Definition TypeBase.h:3816
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition TypeBase.h:3875
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Definition TypeBase.h:3836
unsigned getNumColumns() const
Returns the number of columns in the matrix.
Definition TypeBase.h:4394
static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType, unsigned NumRows, unsigned NumColumns, TypeClass TypeClass)
Definition TypeBase.h:4416
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:4411
static constexpr unsigned getMaxElementsPerDimension()
Returns the maximum number of elements per dimension.
Definition TypeBase.h:4407
unsigned getNumRows() const
Returns the number of rows in the matrix.
Definition TypeBase.h:4391
unsigned getNumElementsFlattened() const
Returns the number of elements required to embed the matrix into a vector.
Definition TypeBase.h:4397
static constexpr unsigned MaxElementsPerDimension
Definition TypeBase.h:4381
ConstantMatrixType(QualType MatrixElementType, unsigned NRows, unsigned NColumns, QualType CanonElementType)
Definition Type.cpp:378
static constexpr bool isDimensionValid(size_t NumElements)
Returns true if NumElements is a valid matrix dimension.
Definition TypeBase.h:4402
unsigned NumRows
Number of rows and columns.
Definition TypeBase.h:4378
static bool classof(const Type *T)
Definition TypeBase.h:4425
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
Definition TypeBase.h:3436
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3472
static bool classof(const Type *T)
Definition TypeBase.h:3479
bool isCountInBytes() const
Definition TypeBase.h:3463
Expr * getCountExpr() const
Definition TypeBase.h:3462
DynamicCountPointerKind getKind() const
Definition TypeBase.h:3466
QualType getPointeeType() const
Definition TypeBase.h:9199
static bool classof(const Type *T)
Definition TypeBase.h:3536
friend class ASTContext
Definition TypeBase.h:3526
QualType getDecayedType() const
Definition TypeBase.h:3532
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition DeclBase.h:1449
Decl - This represents one declaration (or definition), e.g.
Definition DeclBase.h:86
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4083
QualType getPointeeType() const
Definition TypeBase.h:4073
static bool classof(const Type *T)
Definition TypeBase.h:4079
SourceLocation getAttributeLoc() const
Definition TypeBase.h:4074
Expr * getNumBitsExpr() const
Definition Type.cpp:437
QualType desugar() const
Definition TypeBase.h:8189
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:8191
DependentBitIntType(bool IsUnsigned, Expr *NumBits)
Definition Type.cpp:428
static bool classof(const Type *T)
Definition TypeBase.h:8197
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4040
static bool classof(const Type *T)
Definition TypeBase.h:4036
static bool classof(const Type *T)
Definition TypeBase.h:4122
SourceLocation getAttributeLoc() const
Definition TypeBase.h:4117
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4126
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4452
SourceLocation getAttributeLoc() const
Definition TypeBase.h:4446
static bool classof(const Type *T)
Definition TypeBase.h:4448
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:6216
DependentTypeOfExprType(const ASTContext &Context, Expr *E, TypeOfKind Kind)
Definition TypeBase.h:6213
Expr * getSizeExpr() const
Definition TypeBase.h:4238
VectorKind getVectorKind() const
Definition TypeBase.h:4241
SourceLocation getAttributeLoc() const
Definition TypeBase.h:4240
QualType getElementType() const
Definition TypeBase.h:4239
QualType desugar() const
Definition TypeBase.h:4246
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:4252
static bool classof(const Type *T)
Definition TypeBase.h:4248
@ ak_addrspace
address space
Definition Diagnostic.h:266
Wrap a function effect's condition expression in another struct so that FunctionProtoType's TrailingO...
Definition TypeBase.h:4986
Expr * getCondition() const
Definition TypeBase.h:4993
bool operator==(const EffectConditionExpr &RHS) const
Definition TypeBase.h:4995
Represents an enum.
Definition Decl.h:4007
This represents one expression.
Definition Expr.h:112
We can encode up to four bits in the low bits of a type pointer, but there are many more type qualifi...
Definition TypeBase.h:1717
Qualifiers::ObjCLifetime getObjCLifetime() const
Definition TypeBase.h:1754
static void Profile(llvm::FoldingSetNodeID &ID, const Type *BaseType, Qualifiers Quals)
Definition TypeBase.h:1768
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:1764
ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
Definition TypeBase.h:1738
bool hasObjCGCAttr() const
Definition TypeBase.h:1750
Qualifiers::GC getObjCGCAttr() const
Definition TypeBase.h:1751
bool hasAddressSpace() const
Definition TypeBase.h:1758
const Type * getBaseType() const
Definition TypeBase.h:1761
Qualifiers getQualifiers() const
Definition TypeBase.h:1748
LangAS getAddressSpace() const
Definition TypeBase.h:1759
bool hasObjCLifetime() const
Definition TypeBase.h:1753
bool isSugared() const
Definition TypeBase.h:4326
bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const
Definition TypeBase.h:4320
friend class ASTContext
Definition TypeBase.h:4268
static int getNumericAccessorIdx(char c)
Definition TypeBase.h:4285
static bool classof(const Type *T)
Definition TypeBase.h:4329
static int getPointAccessorIdx(char c)
Definition TypeBase.h:4275
QualType desugar() const
Definition TypeBase.h:4327
static int getAccessorIdx(char c, bool isNumericAccessor)
Definition TypeBase.h:4313
Represents a function declaration or definition.
Definition Decl.h:2000
Support iteration in parallel through a pair of FunctionEffect and EffectConditionExpr containers.
Definition TypeBase.h:5019
bool operator==(const FunctionEffectIterator &Other) const
Definition TypeBase.h:5028
bool operator!=(const FunctionEffectIterator &Other) const
Definition TypeBase.h:5031
FunctionEffectIterator operator++()
Definition TypeBase.h:5035
FunctionEffectIterator(const Container &O, size_t I)
Definition TypeBase.h:5027
FunctionEffectWithCondition operator*() const
Definition TypeBase.h:5040
A mutable set of FunctionEffect::Kind.
Definition TypeBase.h:5120
static FunctionEffectKindSet difference(FunctionEffectKindSet LHS, FunctionEffectKindSet RHS)
Definition TypeBase.h:5192
bool contains(const FunctionEffect::Kind EK) const
Definition TypeBase.h:5187
FunctionEffectKindSet(FunctionEffectsRef FX)
Definition TypeBase.h:5174
void insert(FunctionEffectKindSet Set)
Definition TypeBase.h:5184
void insert(FunctionEffectsRef FX)
Definition TypeBase.h:5180
void insert(FunctionEffect Effect)
Definition TypeBase.h:5179
FunctionEffectSet(const FunctionEffectsRef &FX)
Definition TypeBase.h:5209
iterator end() const
Definition TypeBase.h:5218
size_t size() const
Definition TypeBase.h:5213
FunctionEffectIterator< FunctionEffectSet > iterator
Definition TypeBase.h:5215
bool insert(const FunctionEffectWithCondition &NewEC, Conflicts &Errs)
Definition Type.cpp:5592
SmallVector< Conflict > Conflicts
Definition TypeBase.h:5234
static FunctionEffectSet getIntersection(FunctionEffectsRef LHS, FunctionEffectsRef RHS)
Definition Type.cpp:5641
static FunctionEffectSet getUnion(FunctionEffectsRef LHS, FunctionEffectsRef RHS, Conflicts &Errs)
Definition Type.cpp:5679
iterator begin() const
Definition TypeBase.h:5217
Represents an abstract function effect, using just an enumeration describing its kind.
Definition TypeBase.h:4879
Kind kind() const
The kind of the effect.
Definition TypeBase.h:4918
unsigned Flags
Flags describing some behaviors of the effect.
Definition TypeBase.h:4892
static constexpr size_t KindCount
Definition TypeBase.h:4889
friend bool operator<(FunctionEffect LHS, FunctionEffect RHS)
Definition TypeBase.h:4979
friend bool operator==(FunctionEffect LHS, FunctionEffect RHS)
Definition TypeBase.h:4973
uint32_t toOpaqueInt32() const
For serialization.
Definition TypeBase.h:4924
friend bool operator!=(FunctionEffect LHS, FunctionEffect RHS)
Definition TypeBase.h:4976
Kind
Identifies the particular effect.
Definition TypeBase.h:4882
Flags flags() const
Flags describing some behaviors of the effect.
Definition TypeBase.h:4930
StringRef name() const
The description printed in diagnostics, e.g. 'nonblocking'.
Definition Type.cpp:5529
static FunctionEffect fromOpaqueInt32(uint32_t Value)
Definition TypeBase.h:4925
friend raw_ostream & operator<<(raw_ostream &OS, const FunctionEffect &Effect)
Definition TypeBase.h:4950
An immutable set of FunctionEffects and possibly conditions attached to them.
Definition TypeBase.h:5066
ArrayRef< FunctionEffect > effects() const
Definition TypeBase.h:5099
iterator begin() const
Definition TypeBase.h:5104
ArrayRef< EffectConditionExpr > conditions() const
Definition TypeBase.h:5100
static FunctionEffectsRef create(ArrayRef< FunctionEffect > FX, ArrayRef< EffectConditionExpr > Conds)
Asserts invariants.
Definition Type.cpp:5723
iterator end() const
Definition TypeBase.h:5105
FunctionEffectIterator< FunctionEffectsRef > iterator
Definition TypeBase.h:5102
friend bool operator==(const FunctionEffectsRef &LHS, const FunctionEffectsRef &RHS)
Definition TypeBase.h:5107
static FunctionEffectsRef get(QualType QT)
Extract the effects from a Type if it is a function, block, or member function pointer,...
Definition TypeBase.h:9212
friend bool operator!=(const FunctionEffectsRef &LHS, const FunctionEffectsRef &RHS)
Definition TypeBase.h:5111
static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType, ExtInfo Info)
Definition TypeBase.h:4864
QualType desugar() const
Definition TypeBase.h:4858
static bool classof(const Type *T)
Definition TypeBase.h:4870
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:4860
Represents a prototype with parameter type info, e.g.
Definition TypeBase.h:5266
QualType desugar() const
Definition TypeBase.h:5847
param_type_iterator param_type_begin() const
Definition TypeBase.h:5710
unsigned getNumFunctionEffectConditions() const
Definition TypeBase.h:5809
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition TypeBase.h:5770
ArrayRef< EffectConditionExpr > getFunctionEffectConditions() const
Definition TypeBase.h:5819
ExceptionSpecificationType getExceptionSpecType() const
Get the kind of exception specification on this function.
Definition TypeBase.h:5573
ArrayRef< FunctionEffect > getFunctionEffectsWithoutConditions() const
Definition TypeBase.h:5799
bool isParamConsumed(unsigned I) const
Definition TypeBase.h:5784
exception_iterator exception_end() const
Definition TypeBase.h:5729
const ExtParameterInfo * getExtParameterInfosOrNull() const
Return a pointer to the beginning of the array of extra parameter information, if present,...
Definition TypeBase.h:5748
unsigned getNumParams() const
Definition TypeBase.h:5544
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition TypeBase.h:5686
ExceptionSpecInfo getExceptionSpecInfo() const
Return all the available information about this type's exception spec.
Definition TypeBase.h:5599
const QualType * param_type_iterator
Definition TypeBase.h:5704
Qualifiers getMethodQuals() const
Definition TypeBase.h:5692
const QualType * exception_iterator
Definition TypeBase.h:5718
static bool classof(const Type *T)
Definition TypeBase.h:5852
QualType getParamType(unsigned i) const
Definition TypeBase.h:5546
FunctionEffectsRef getFunctionEffects() const
Definition TypeBase.h:5830
unsigned getAArch64SMEAttributes() const
Return a bitmask describing the SME attributes on the function type, see AArch64SMETypeAttributes for...
Definition TypeBase.h:5763
QualType getExceptionType(unsigned i) const
Return the ith exception type, where 0 <= i < getNumExceptions().
Definition TypeBase.h:5624
static void Profile(llvm::FoldingSetNodeID &ID, QualType Result, param_type_iterator ArgTys, unsigned NumArgs, const ExtProtoInfo &EPI, const ASTContext &Context, bool Canonical)
SourceLocation getEllipsisLoc() const
Definition TypeBase.h:5672
friend class ASTContext
Definition TypeBase.h:5267
unsigned getNumFunctionEffects() const
Definition TypeBase.h:5791
bool hasCFIUncheckedCallee() const
Definition TypeBase.h:5688
unsigned getNumExceptions() const
Return the number of types in the exception specification.
Definition TypeBase.h:5616
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition TypeBase.h:5579
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
Definition Type.cpp:3846
bool hasDynamicExceptionSpec() const
Return whether this function has a dynamic (throw) exception spec.
Definition TypeBase.h:5582
bool hasNoexceptExceptionSpec() const
Return whether this function has a noexcept exception spec.
Definition TypeBase.h:5587
bool isVariadic() const
Whether this function prototype is variadic.
Definition TypeBase.h:5670
ExtProtoInfo getExtProtoInfo() const
Definition TypeBase.h:5555
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
Definition TypeBase.h:5631
param_type_iterator param_type_end() const
Definition TypeBase.h:5714
FunctionDecl * getExceptionSpecTemplate() const
If this function type has an uninstantiated exception specification, this is the function whose excep...
Definition TypeBase.h:5652
FunctionTypeExtraAttributeInfo getExtraAttributeInfo() const
Return the extra attribute information.
Definition TypeBase.h:5755
bool isNothrow(bool ResultIfDependent=false) const
Determine whether this function type has a non-throwing exception specification.
Definition TypeBase.h:5665
ArrayRef< QualType > getParamTypes() const
Definition TypeBase.h:5551
ArrayRef< QualType > exceptions() const
Definition TypeBase.h:5720
ParameterABI getParameterABI(unsigned I) const
Definition TypeBase.h:5777
ArrayRef< QualType > param_types() const
Definition TypeBase.h:5706
exception_iterator exception_begin() const
Definition TypeBase.h:5724
ArrayRef< ExtParameterInfo > getExtParameterInfos() const
Definition TypeBase.h:5739
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type?
Definition TypeBase.h:5735
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition TypeBase.h:5700
FunctionDecl * getExceptionSpecDecl() const
If this function type has an exception specification which hasn't been determined yet (either because...
Definition TypeBase.h:5641
A class which abstracts out some details necessary for making a call.
Definition TypeBase.h:4573
ExtInfo withNoCfCheck(bool noCfCheck) const
Definition TypeBase.h:4672
ExtInfo withCallingConv(CallingConv cc) const
Definition TypeBase.h:4685
CallingConv getCC() const
Definition TypeBase.h:4632
ExtInfo withProducesResult(bool producesResult) const
Definition TypeBase.h:4651
ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc, bool producesResult, bool noCallerSavedRegs, bool NoCfCheck, bool cmseNSCall)
Definition TypeBase.h:4598
unsigned getRegParm() const
Definition TypeBase.h:4625
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:4689
bool getNoCallerSavedRegs() const
Definition TypeBase.h:4621
ExtInfo withNoReturn(bool noReturn) const
Definition TypeBase.h:4644
bool operator==(ExtInfo Other) const
Definition TypeBase.h:4634
ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const
Definition TypeBase.h:4665
ExtInfo withCmseNSCall(bool cmseNSCall) const
Definition TypeBase.h:4658
ExtInfo withRegParm(unsigned RegParm) const
Definition TypeBase.h:4679
bool operator!=(ExtInfo Other) const
Definition TypeBase.h:4637
Interesting information about a specific parameter that can't simply be reflected in parameter's type...
Definition TypeBase.h:4488
friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs)
Definition TypeBase.h:4544
friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs)
Definition TypeBase.h:4548
ExtParameterInfo withHasPassObjectSize() const
Definition TypeBase.h:4521
unsigned char getOpaqueValue() const
Definition TypeBase.h:4537
bool isConsumed() const
Is this parameter considered "consumed" by Objective-C ARC?
Definition TypeBase.h:4510
ParameterABI getABI() const
Return the ABI treatment of this parameter.
Definition TypeBase.h:4501
ExtParameterInfo withIsConsumed(bool consumed) const
Definition TypeBase.h:4511
ExtParameterInfo withIsNoEscape(bool NoEscape) const
Definition TypeBase.h:4528
ExtParameterInfo withABI(ParameterABI kind) const
Definition TypeBase.h:4502
static ExtParameterInfo getFromOpaqueValue(unsigned char data)
Definition TypeBase.h:4538
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition TypeBase.h:4462
ExtInfo getExtInfo() const
Definition TypeBase.h:4818
AArch64SMETypeAttributes
The AArch64 SME ACLE (Arm C/C++ Language Extensions) define a number of function type attributes that...
Definition TypeBase.h:4738
static ArmStateValue getArmZT0State(unsigned AttrBits)
Definition TypeBase.h:4771
bool getNoReturnAttr() const
Determine whether this function type includes the GNU noreturn attribute.
Definition TypeBase.h:4810
bool isConst() const
Definition TypeBase.h:4824
static ArmStateValue getArmZAState(unsigned AttrBits)
Definition TypeBase.h:4767
unsigned getRegParmType() const
Definition TypeBase.h:4805
CallingConv getCallConv() const
Definition TypeBase.h:4817
bool isRestrict() const
Definition TypeBase.h:4826
QualType getReturnType() const
Definition TypeBase.h:4802
FunctionType(TypeClass tc, QualType res, QualType Canonical, TypeDependence Dependence, ExtInfo Info)
Definition TypeBase.h:4788
static bool classof(const Type *T)
Definition TypeBase.h:4836
bool getCmseNSCallAttr() const
Definition TypeBase.h:4816
bool getHasRegParm() const
Definition TypeBase.h:4804
Qualifiers getFastTypeQuals() const
Definition TypeBase.h:4794
QualType getCallResultType(const ASTContext &Context) const
Determine the type of an expression that calls a function of this type.
Definition TypeBase.h:4830
bool isVolatile() const
Definition TypeBase.h:4825
One of these records is kept for each identifier that is lexed.
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3926
static void Profile(llvm::FoldingSetNodeID &ID, QualType ET, ArraySizeModifier SizeMod, unsigned TypeQuals)
Definition TypeBase.h:3931
friend class StmtIteratorBase
Definition TypeBase.h:3917
QualType desugar() const
Definition TypeBase.h:3920
static bool classof(const Type *T)
Definition TypeBase.h:3922
KeywordWrapper(ElaboratedTypeKeyword Keyword, As &&...as)
Definition TypeBase.h:5937
ElaboratedTypeKeyword getKeyword() const
Definition TypeBase.h:5943
static CannotCastToThisType classof(const T *)
static bool classof(const Type *T)
Definition TypeBase.h:3629
QualType desugar() const
Definition TypeBase.h:3627
static bool classof(const Type *T)
Definition TypeBase.h:6170
QualType getUnderlyingType() const
Definition TypeBase.h:6161
const IdentifierInfo * getMacroIdentifier() const
Definition TypeBase.h:6160
QualType getElementType() const
Returns type of the elements being stored in the matrix.
Definition TypeBase.h:4351
friend class ASTContext
Definition TypeBase.h:4339
QualType desugar() const
Definition TypeBase.h:4364
MatrixType(QualType ElementTy, QualType CanonElementTy)
static bool isValidElementType(QualType T)
Valid elements types are the following:
Definition TypeBase.h:4358
QualType ElementType
The element type of the matrix.
Definition TypeBase.h:4342
bool isSugared() const
Definition TypeBase.h:4363
static bool classof(const Type *T)
Definition TypeBase.h:4366
NestedNameSpecifier getQualifier() const
Definition TypeBase.h:3685
bool isSugared() const
Definition Type.cpp:5435
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3696
QualType getPointeeType() const
Definition TypeBase.h:3671
bool isMemberFunctionPointer() const
Returns true if the member type (i.e.
Definition TypeBase.h:3675
friend class ASTContext
Definition TypeBase.h:3654
bool isMemberDataPointer() const
Returns true if the member type (i.e.
Definition TypeBase.h:3681
QualType desugar() const
Definition TypeBase.h:3692
static bool classof(const Type *T)
Definition TypeBase.h:3707
This represents a decl that may have a name.
Definition Decl.h:274
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Represents an ObjC class declaration.
Definition DeclObjC.h:1154
Represents typeof(type), a C23 feature and GCC extension, or `typeof_unqual(type),...
Definition TypeBase.h:7856
QualType desugar() const
Definition TypeBase.h:7872
friend class ASTContext
Definition TypeBase.h:7857
static bool classof(const Type *T)
Definition TypeBase.h:7874
Represents a pointer to an Objective C object.
Definition TypeBase.h:7912
unsigned getNumProtocols() const
Return the number of qualifying protocols on the object type.
Definition TypeBase.h:8044
bool isSpecialized() const
Whether this type is specialized, meaning that it has type arguments.
Definition TypeBase.h:8001
qual_iterator qual_end() const
Definition TypeBase.h:8037
bool isObjCQualifiedClassType() const
True if this is equivalent to 'Class.
Definition TypeBase.h:7993
static void Profile(llvm::FoldingSetNodeID &ID, QualType T)
Definition TypeBase.h:8073
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
Definition TypeBase.h:7987
bool isSpecializedAsWritten() const
Whether this type is specialized, meaning that it has type arguments.
Definition TypeBase.h:8004
bool isUnspecializedAsWritten() const
Determine whether this object type is "unspecialized" as written, meaning that it has no type argumen...
Definition TypeBase.h:8013
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments for this type.
Definition TypeBase.h:8021
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:8069
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition TypeBase.h:7949
ObjCObjectType::qual_iterator qual_iterator
An iterator over the qualifiers on the object type.
Definition TypeBase.h:8028
llvm::iterator_range< qual_iterator > qual_range
Definition TypeBase.h:8029
static bool classof(const Type *T)
Definition TypeBase.h:8077
bool isUnspecialized() const
Whether this type is unspecialized, meaning that is has no type arguments.
Definition TypeBase.h:8009
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
Definition TypeBase.h:7970
ObjCProtocolDecl * getProtocol(unsigned I) const
Retrieve a qualifying protocol by index on the object type.
Definition TypeBase.h:8049
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition TypeBase.h:7924
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
Definition TypeBase.h:7964
QualType desugar() const
Definition TypeBase.h:8054
qual_range quals() const
Definition TypeBase.h:8031
bool isObjCClassType() const
True if this is equivalent to the 'Class' type, i.e.
Definition TypeBase.h:7976
bool isObjCIdOrClassType() const
True if this is equivalent to the 'id' or 'Class' type,.
Definition TypeBase.h:7981
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments for this type.
Definition TypeBase.h:8016
qual_iterator qual_begin() const
Definition TypeBase.h:8033
bool isKindOfType() const
Whether this is a "__kindof" type.
Definition TypeBase.h:7998
Represents an Objective-C protocol declaration.
Definition DeclObjC.h:2084
QualType desugar() const
Definition TypeBase.h:3314
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3316
friend class ASTContext
Definition TypeBase.h:3303
static bool classof(const Type *T)
Definition TypeBase.h:3324
static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner)
Definition TypeBase.h:3320
bool isSugared() const
Definition TypeBase.h:3313
QualType getInnerType() const
Definition TypeBase.h:3311
QualType desugar() const
Definition TypeBase.h:8127
bool isSugared() const
Definition TypeBase.h:8125
static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead)
Definition TypeBase.h:8133
QualType getElementType() const
Definition TypeBase.h:8123
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:8129
static bool classof(const Type *T)
Definition TypeBase.h:8138
friend class ASTContext
Definition TypeBase.h:8113
bool isReadOnly() const
Definition TypeBase.h:8142
Pointer-authentication qualifiers.
Definition TypeBase.h:152
static PointerAuthQualifier fromOpaqueValue(uint32_t Opaque)
Definition TypeBase.h:308
friend bool operator==(PointerAuthQualifier Lhs, PointerAuthQualifier Rhs)
Definition TypeBase.h:294
static PointerAuthQualifier Create(unsigned Key, bool IsAddressDiscriminated, unsigned ExtraDiscriminator, PointerAuthenticationMode AuthenticationMode, bool IsIsaPointer, bool AuthenticatesNullValues)
Definition TypeBase.h:239
friend bool operator!=(PointerAuthQualifier Lhs, PointerAuthQualifier Rhs)
Definition TypeBase.h:297
bool authenticatesNullValues() const
Definition TypeBase.h:285
bool isEquivalent(PointerAuthQualifier Other) const
Definition TypeBase.h:301
@ MaxDiscriminator
The maximum supported pointer-authentication discriminator.
Definition TypeBase.h:232
@ MaxKey
The maximum supported pointer-authentication key.
Definition TypeBase.h:229
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:322
bool isAddressDiscriminated() const
Definition TypeBase.h:265
PointerAuthQualifier withoutKeyNone() const
Definition TypeBase.h:290
unsigned getExtraDiscriminator() const
Definition TypeBase.h:270
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
PointerAuthenticationMode getAuthenticationMode() const
Definition TypeBase.h:275
bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const
std::string getAsString() const
uint32_t getAsOpaqueValue() const
Definition TypeBase.h:305
unsigned getKey() const
Definition TypeBase.h:258
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition TypeBase.h:3328
QualType getPointeeType() const
Definition TypeBase.h:3338
friend class ASTContext
Definition TypeBase.h:3329
static bool classof(const Type *T)
Definition TypeBase.h:3351
QualType desugar() const
Definition TypeBase.h:3341
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3343
bool isSugared() const
Definition TypeBase.h:3340
static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee)
Definition TypeBase.h:3347
PredefinedSugarKind Kind
Definition TypeBase.h:8205
static bool classof(const Type *T)
Definition TypeBase.h:8228
QualType desugar() const
Definition TypeBase.h:8222
const IdentifierInfo * getIdentifier() const
Definition TypeBase.h:8226
StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy, const Twine &PlaceHolder, unsigned Indentation)
Definition TypeBase.h:1376
friend raw_ostream & operator<<(raw_ostream &OS, const StreamedQualTypeHelper &SQT)
Definition TypeBase.h:1381
A (possibly-)qualified type.
Definition TypeBase.h:937
void addRestrict()
Add the restrict qualifier to this QualType.
Definition TypeBase.h:1172
QualType(const ExtQuals *Ptr, unsigned Quals)
Definition TypeBase.h:962
bool hasAddressDiscriminatedPointerAuth() const
Definition TypeBase.h:1457
bool isLocalConstQualified() const
Determine whether this particular QualType instance has the "const" qualifier set,...
Definition TypeBase.h:1014
bool isLocalRestrictQualified() const
Determine whether this particular QualType instance has the "restrict" qualifier set,...
Definition TypeBase.h:1044
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition TypeBase.h:8378
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition TypeBase.h:8372
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition Type.cpp:2867
QualType IgnoreParens() const
Returns the specified type after dropping any outer-level parentheses.
Definition TypeBase.h:1315
Qualifiers::GC getObjCGCAttr() const
Returns gc attribute of this type.
Definition TypeBase.h:8425
friend bool operator==(const QualType &LHS, const QualType &RHS)
Indicate whether the specified types and qualifiers are identical.
Definition TypeBase.h:1322
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition TypeBase.h:8383
QualType withFastQualifiers(unsigned TQs) const
Definition TypeBase.h:1201
QualType withRestrict() const
Definition TypeBase.h:1175
bool hasNonTrivialToPrimitiveCopyCUnion() const
Check if this is or contains a C union that is non-trivial to copy, which is a union that has a membe...
Definition Type.h:87
PointerAuthQualifier getPointerAuth() const
Definition TypeBase.h:1453
void addFastQualifiers(unsigned TQs)
Definition TypeBase.h:1183
bool isWebAssemblyFuncrefType() const
Returns true if it is a WebAssembly Funcref Type.
Definition Type.cpp:2948
QualType getNonLValueExprType(const ASTContext &Context) const
Determine the type of a (typically non-lvalue) expression with the specified result type.
Definition Type.cpp:3556
@ PDIK_ARCWeak
The type is an Objective-C retainable pointer type that is qualified with the ARC __weak qualifier.
Definition TypeBase.h:1475
@ PDIK_Trivial
The type does not fall into any of the following categories.
Definition TypeBase.h:1467
@ PDIK_ARCStrong
The type is an Objective-C retainable pointer type that is qualified with the ARC __strong qualifier.
Definition TypeBase.h:1471
@ PDIK_Struct
The type is a struct containing a field whose type is not PCK_Trivial.
Definition TypeBase.h:1478
bool mayBeDynamicClass() const
Returns true if it is a class and it might be dynamic.
Definition Type.cpp:130
bool hasLocalNonFastQualifiers() const
Determine whether this particular QualType instance has any "non-fast" qualifiers,...
Definition TypeBase.h:1074
bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const
Definition Type.cpp:2921
const IdentifierInfo * getBaseTypeIdentifier() const
Retrieves a pointer to the name of the base type.
Definition Type.cpp:109
bool isBitwiseCloneableType(const ASTContext &Context) const
Return true if the type is safe to bitwise copy using memcpy/memmove.
Definition Type.cpp:2873
QualType withoutLocalFastQualifiers() const
Definition TypeBase.h:1214
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:1398
bool isAddressSpaceOverlapping(QualType T, const ASTContext &Ctx) const
Returns true if address space qualifiers overlap with T address space qualifiers.
Definition TypeBase.h:1416
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition TypeBase.h:1296
void removeLocalFastQualifiers(unsigned Mask)
Definition TypeBase.h:1194
QualType withConst() const
Definition TypeBase.h:1159
QualType getLocalUnqualifiedType() const
Return this type with all of the instance-specific qualifiers removed, but without removing any quali...
Definition TypeBase.h:1225
void addConst()
Add the const type qualifier to this QualType.
Definition TypeBase.h:1156
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
Definition TypeBase.h:1064
bool isTriviallyCopyConstructibleType(const ASTContext &Context) const
Return true if this is a trivially copyable type.
Definition Type.cpp:2915
bool isTrivialType(const ASTContext &Context) const
Return true if this is a trivial type per (C++0x [basic.types]p9)
Definition Type.cpp:2758
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition TypeBase.h:1004
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition Type.cpp:2970
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition TypeBase.h:8294
LangAS getAddressSpace() const
Return the address space of this type.
Definition TypeBase.h:8420
bool isConstant(const ASTContext &Ctx) const
Definition TypeBase.h:1097
static QualType getFromOpaquePtr(const void *Ptr)
Definition TypeBase.h:986
QualType withVolatile() const
Definition TypeBase.h:1167
bool hasNonTrivialToPrimitiveDestructCUnion() const
Check if this is or contains a C union that is non-trivial to destruct, which is a union that has a m...
Definition Type.h:81
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition TypeBase.h:8334
const Type * operator->() const
Definition TypeBase.h:996
void setLocalFastQualifiers(unsigned Quals)
Definition TypeBase.h:965
bool isCXX98PODType(const ASTContext &Context) const
Return true if this is a POD type according to the rules of the C++98 standard, regardless of the cur...
Definition Type.cpp:2703
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition TypeBase.h:1438
QualType stripObjCKindOfType(const ASTContext &ctx) const
Strip Objective-C "__kindof" types from the given type.
Definition Type.cpp:1663
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
bool isReferenceable() const
Definition TypeBase.h:8302
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition TypeBase.h:8479
QualType getCanonicalType() const
Definition TypeBase.h:8346
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition TypeBase.h:8388
void removeLocalVolatile()
Definition TypeBase.h:8410
QualType substObjCMemberType(QualType objectType, const DeclContext *dc, ObjCSubstitutionContext context) const
Substitute type arguments from an object type for the Objective-C type parameters used in the subject...
Definition Type.cpp:1654
bool isWebAssemblyReferenceType() const
Returns true if it is a WebAssembly Reference Type.
Definition Type.cpp:2940
SplitQualType getSplitDesugaredType() const
Definition TypeBase.h:1300
std::optional< NonConstantStorageReason > isNonConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
Determine whether instances of this type can be placed in immutable storage.
Definition Type.cpp:151
QualType withCVRQualifiers(unsigned CVR) const
Definition TypeBase.h:1179
QualType()=default
unsigned getLocalCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers local to this particular QualType instan...
Definition TypeBase.h:1089
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition TypeBase.h:8315
bool UseExcessPrecision(const ASTContext &Ctx)
Definition Type.cpp:1612
void addVolatile()
Add the volatile type qualifier to this QualType.
Definition TypeBase.h:1164
bool isCForbiddenLValueType() const
Determine whether expressions of the given type are forbidden from being lvalues in C.
Definition TypeBase.h:8486
PrimitiveDefaultInitializeKind isNonTrivialToPrimitiveDefaultInitialize() const
Functions to query basic properties of non-trivial C struct types.
Definition Type.cpp:2954
bool isObjCGCStrong() const
true when Type is objc's strong.
Definition TypeBase.h:1433
std::string getAsString() const
void dump() const
void * getAsOpaquePtr() const
Definition TypeBase.h:984
static void print(SplitQualType split, raw_ostream &OS, const PrintingPolicy &policy, const Twine &PlaceHolder, unsigned Indentation=0)
Definition TypeBase.h:1346
bool isMoreQualifiedThan(QualType Other, const ASTContext &Ctx) const
Determine whether this type is more qualified than the other given type, requiring exact equality for...
Definition TypeBase.h:8448
bool isCanonicalAsParam() const
Definition TypeBase.h:8355
void removeLocalConst()
Definition TypeBase.h:8402
void removeLocalRestrict()
Definition TypeBase.h:8406
bool isWebAssemblyExternrefType() const
Returns true if it is a WebAssembly Externref Type.
Definition Type.cpp:2944
QualType(const Type *Ptr, unsigned Quals)
Definition TypeBase.h:961
QualType getNonPackExpansionType() const
Remove an outer pack expansion type (if any) from this type.
Definition Type.cpp:3549
SplitQualType getSplitUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition TypeBase.h:8395
bool isCXX11PODType(const ASTContext &Context) const
Return true if this is a POD type according to the more relaxed rules of the C++11 standard,...
Definition Type.cpp:3112
bool mayBeNotDynamicClass() const
Returns true if it is not a class or if the class might not be dynamic.
Definition Type.cpp:135
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition TypeBase.h:8367
bool hasAddressSpace() const
Check if this type has any address space qualifier.
Definition TypeBase.h:8415
bool isObjCGCWeak() const
true when Type is objc's weak.
Definition TypeBase.h:1428
QualType substObjCTypeArgs(ASTContext &ctx, ArrayRef< QualType > typeArgs, ObjCSubstitutionContext context) const
Substitute type arguments for the Objective-C type parameters used in the subject type.
Definition Type.cpp:1647
unsigned getLocalFastQualifiers() const
Definition TypeBase.h:964
void removeLocalFastQualifiers()
Definition TypeBase.h:1193
QualType getAtomicUnqualifiedType() const
Remove all qualifiers including _Atomic.
Definition Type.cpp:1670
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
Definition TypeBase.h:1545
friend bool operator<(const QualType &LHS, const QualType &RHS)
Definition TypeBase.h:1328
friend bool operator!=(const QualType &LHS, const QualType &RHS)
Definition TypeBase.h:1325
bool isCanonical() const
Definition TypeBase.h:8351
StreamedQualTypeHelper stream(const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
Definition TypeBase.h:1388
bool isLocalVolatileQualified() const
Determine whether this particular QualType instance has the "volatile" qualifier set,...
Definition TypeBase.h:1054
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
Definition TypeBase.h:1036
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition TypeBase.h:8340
static void getAsStringInternal(SplitQualType split, std::string &out, const PrintingPolicy &policy)
Definition TypeBase.h:1360
QualType getSingleStepDesugaredType(const ASTContext &Context) const
Return the specified type with one level of "sugar" removed from the type.
Definition TypeBase.h:1309
const Type * getTypePtrOrNull() const
Definition TypeBase.h:8298
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition TypeBase.h:1332
bool hasNonTrivialObjCLifetime() const
Definition TypeBase.h:1442
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition Type.cpp:2695
bool isAtLeastAsQualifiedAs(QualType Other, const ASTContext &Ctx) const
Determine whether this type is at least as qualified as the other given type, requiring exact equalit...
Definition TypeBase.h:8459
friend class QualifierCollector
Definition TypeBase.h:938
bool hasStrongOrWeakObjCLifetime() const
Definition TypeBase.h:1446
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition Type.cpp:2990
QualType withExactLocalFastQualifiers(unsigned TQs) const
Definition TypeBase.h:1209
@ PCK_Struct
The type is a struct containing a field whose type is neither PCK_Trivial nor PCK_VolatileTrivial.
Definition TypeBase.h:1517
@ PCK_Trivial
The type does not fall into any of the following categories.
Definition TypeBase.h:1493
@ PCK_ARCStrong
The type is an Objective-C retainable pointer type that is qualified with the ARC __strong qualifier.
Definition TypeBase.h:1502
@ PCK_VolatileTrivial
The type would be trivial except that it is volatile-qualified.
Definition TypeBase.h:1498
@ PCK_PtrAuth
The type is an address-discriminated signed pointer type.
Definition TypeBase.h:1509
@ PCK_ARCWeak
The type is an Objective-C retainable pointer type that is qualified with the ARC __weak qualifier.
Definition TypeBase.h:1506
const Type & operator*() const
Definition TypeBase.h:992
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition TypeBase.h:8326
bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const
Check if this is or contains a C union that is non-trivial to default-initialize, which is a union th...
Definition Type.h:75
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition TypeBase.h:8241
QualifierCollector(Qualifiers Qs=Qualifiers())
Definition TypeBase.h:8236
QualifiersAndAtomic & operator+=(Qualifiers RHS)
Definition TypeBase.h:862
QualifiersAndAtomic withVolatile()
Definition TypeBase.h:853
QualifiersAndAtomic withAtomic()
Definition TypeBase.h:860
QualifiersAndAtomic withConst()
Definition TypeBase.h:856
QualifiersAndAtomic(Qualifiers Quals, bool HasAtomic)
Definition TypeBase.h:833
QualifiersAndAtomic withRestrict()
Definition TypeBase.h:857
The collection of all-type qualifiers we support.
Definition TypeBase.h:331
unsigned getCVRQualifiers() const
Definition TypeBase.h:488
void removeCVRQualifiers(unsigned mask)
Definition TypeBase.h:495
GC getObjCGCAttr() const
Definition TypeBase.h:519
friend Qualifiers operator-(Qualifiers L, Qualifiers R)
Compute the difference between two qualifier sets.
Definition TypeBase.h:790
static Qualifiers fromFastMask(unsigned Mask)
Definition TypeBase.h:429
void setFastQualifiers(unsigned mask)
Definition TypeBase.h:620
void addAddressSpace(LangAS space)
Definition TypeBase.h:597
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)
Returns the common set of qualifiers while removing them from the given sets.
Definition TypeBase.h:384
bool hasOnlyConst() const
Definition TypeBase.h:458
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
Definition TypeBase.h:361
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
Definition TypeBase.h:354
@ OCL_None
There is no lifetime qualification on this type.
Definition TypeBase.h:350
@ OCL_Weak
Reading or writing from this object requires a barrier call.
Definition TypeBase.h:364
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
Definition TypeBase.h:367
void removeObjCLifetime()
Definition TypeBase.h:551
bool hasTargetSpecificAddressSpace() const
Definition TypeBase.h:574
bool isStrictSupersetOf(Qualifiers Other) const
Determine whether this set of qualifiers is a strict superset of another set of qualifiers,...
Definition Type.cpp:57
bool hasNonFastQualifiers() const
Return true if the set contains any qualifiers which require an ExtQuals node to be allocated.
Definition TypeBase.h:638
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:804
bool operator!=(Qualifiers Other) const
Definition TypeBase.h:768
bool hasConst() const
Definition TypeBase.h:457
bool hasNonTrivialObjCLifetime() const
True if the lifetime is neither None or ExplicitNone.
Definition TypeBase.h:559
void addCVRQualifiers(unsigned mask)
Definition TypeBase.h:502
bool hasCVRQualifiers() const
Definition TypeBase.h:487
void addConsistentQualifiers(Qualifiers qs)
Add the qualifiers from the given set to this set, given that they don't conflict.
Definition TypeBase.h:689
void removeFastQualifiers(unsigned mask)
Definition TypeBase.h:624
static bool isTargetAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Definition Type.cpp:72
Qualifiers & operator+=(Qualifiers R)
Definition TypeBase.h:772
void removeFastQualifiers()
Definition TypeBase.h:628
bool hasQualifiers() const
Return true if the set contains any qualifiers.
Definition TypeBase.h:646
void removeCVRQualifiers()
Definition TypeBase.h:499
Qualifiers withVolatile() const
Definition TypeBase.h:471
void addCVRUQualifiers(unsigned mask)
Definition TypeBase.h:506
Qualifiers & operator-=(Qualifiers R)
Definition TypeBase.h:784
bool compatiblyIncludes(Qualifiers other, const ASTContext &Ctx) const
Determines if these qualifiers compatibly include another set.
Definition TypeBase.h:727
bool hasUnaligned() const
Definition TypeBase.h:511
unsigned getAddressSpaceAttributePrintValue() const
Get the address space attribute value to be printed by diagnostics.
Definition TypeBase.h:578
bool hasAddressSpace() const
Definition TypeBase.h:570
bool hasRestrict() const
Definition TypeBase.h:477
static bool isAddressSpaceSupersetOf(LangAS A, LangAS B, const ASTContext &Ctx)
Returns true if address space A is equal to or a superset of B.
Definition TypeBase.h:708
void removeObjCGCAttr()
Definition TypeBase.h:523
void removeUnaligned()
Definition TypeBase.h:515
Qualifiers withoutAddressSpace() const
Definition TypeBase.h:538
void removeRestrict()
Definition TypeBase.h:479
unsigned getFastQualifiers() const
Definition TypeBase.h:619
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool appendSpaceIfNonEmpty=false) const
void removeAddressSpace()
Definition TypeBase.h:596
void addQualifiers(Qualifiers Q)
Add the qualifiers from the given set to this set.
Definition TypeBase.h:650
static Qualifiers fromCVRMask(unsigned CVR)
Definition TypeBase.h:435
void addUnaligned()
Definition TypeBase.h:516
void removePointerAuth()
Definition TypeBase.h:610
void setAddressSpace(LangAS space)
Definition TypeBase.h:591
unsigned getCVRUQualifiers() const
Definition TypeBase.h:489
bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const
bool hasVolatile() const
Definition TypeBase.h:467
PointerAuthQualifier getPointerAuth() const
Definition TypeBase.h:603
void setObjCGCAttr(GC type)
Definition TypeBase.h:520
Qualifiers withConst() const
Definition TypeBase.h:461
bool hasObjCGCAttr() const
Definition TypeBase.h:518
uint64_t getAsOpaqueValue() const
Definition TypeBase.h:455
void setCVRQualifiers(unsigned mask)
Definition TypeBase.h:491
bool hasObjCLifetime() const
Definition TypeBase.h:544
ObjCLifetime getObjCLifetime() const
Definition TypeBase.h:545
Qualifiers withoutObjCLifetime() const
Definition TypeBase.h:533
Qualifiers withoutObjCGCAttr() const
Definition TypeBase.h:528
static Qualifiers fromCVRUMask(unsigned CVRU)
Definition TypeBase.h:441
friend Qualifiers operator+(Qualifiers L, Qualifiers R)
Definition TypeBase.h:779
bool empty() const
Definition TypeBase.h:647
void setUnaligned(bool flag)
Definition TypeBase.h:512
void addFastQualifiers(unsigned mask)
Definition TypeBase.h:631
void removeVolatile()
Definition TypeBase.h:469
std::string getAsString() const
Qualifiers withRestrict() const
Definition TypeBase.h:481
void addPointerAuth(PointerAuthQualifier Q)
Definition TypeBase.h:611
void addObjCGCAttr(GC type)
Definition TypeBase.h:524
bool hasPointerAuth() const
Definition TypeBase.h:602
bool operator==(Qualifiers Other) const
Definition TypeBase.h:767
void removeQualifiers(Qualifiers Q)
Remove the qualifiers from the given set from this set.
Definition TypeBase.h:669
LangAS getAddressSpace() const
Definition TypeBase.h:571
bool hasOnlyVolatile() const
Definition TypeBase.h:468
void setPointerAuth(PointerAuthQualifier Q)
Definition TypeBase.h:606
Qualifiers()=default
bool compatiblyIncludesObjCLifetime(Qualifiers other) const
Determines if these qualifiers compatibly include another set of qualifiers from the narrow perspecti...
Definition TypeBase.h:750
Qualifiers getNonFastQualifiers() const
Definition TypeBase.h:639
static Qualifiers fromOpaqueValue(uint64_t opaque)
Definition TypeBase.h:448
bool hasStrongOrWeakObjCLifetime() const
True if the lifetime is either strong or weak.
Definition TypeBase.h:565
static std::string getAddrSpaceAsString(LangAS AS)
@ FastWidth
The width of the "fast" qualifier mask.
Definition TypeBase.h:376
@ MaxAddressSpace
The maximum supported address space number.
Definition TypeBase.h:373
@ FastMask
The fast qualifier mask.
Definition TypeBase.h:379
bool hasFastQualifiers() const
Definition TypeBase.h:618
bool hasOnlyRestrict() const
Definition TypeBase.h:478
bool isAddressSpaceSupersetOf(Qualifiers other, const ASTContext &Ctx) const
Returns true if the address space in these qualifiers is equal to or a superset of the address space ...
Definition TypeBase.h:719
void addObjCLifetime(ObjCLifetime type)
Definition TypeBase.h:552
void setObjCLifetime(ObjCLifetime type)
Definition TypeBase.h:548
static bool classof(const Type *T)
Definition TypeBase.h:3645
QualType desugar() const
Definition TypeBase.h:3643
Represents a struct/union/class.
Definition Decl.h:4312
Base for LValueReferenceType and RValueReferenceType.
Definition TypeBase.h:3573
bool isInnerRef() const
Definition TypeBase.h:3587
QualType getPointeeType() const
Definition TypeBase.h:3591
ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef, bool SpelledAsLValue)
Definition TypeBase.h:3577
static bool classof(const Type *T)
Definition TypeBase.h:3610
QualType getPointeeTypeAsWritten() const
Definition TypeBase.h:3589
bool isSpelledAsLValue() const
Definition TypeBase.h:3586
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3599
static void Profile(llvm::FoldingSetNodeID &ID, QualType Referencee, bool SpelledAsLValue)
Definition TypeBase.h:3603
Encodes a location in the source.
Stmt - This represents one statement.
Definition Stmt.h:85
The streaming interface shared between DiagnosticBuilder and PartialDiagnostic.
void AddTaggedVal(uint64_t V, DiagnosticsEngine::ArgumentKind Kind) const
Represents the declaration of a struct/union/class/enum.
Definition Decl.h:3717
Stores a list of template parameters for a TemplateDecl and its derived classes.
[BoundsSafety] Represents information of declarations referenced by the arguments of the counted_by a...
Definition TypeBase.h:3356
TypeCoupledDeclRefInfo(ValueDecl *D=nullptr, bool Deref=false)
D is to a declaration referenced by the argument of attribute.
Definition Type.cpp:3962
llvm::PointerIntPair< ValueDecl *, 1, unsigned > BaseTy
Definition TypeBase.h:3358
Base wrapper for a particular "section" of type source info.
Definition TypeLoc.h:59
static bool classof(const Type *T)
Definition TypeBase.h:6201
TypeOfKind getKind() const
Returns the kind of 'typeof' type this is.
Definition TypeBase.h:6191
TypeOfExprType(const ASTContext &Context, Expr *E, TypeOfKind Kind, QualType Can=QualType())
Definition Type.cpp:4086
friend class ASTContext
Definition TypeBase.h:6182
Expr * getUnderlyingExpr() const
Definition TypeBase.h:6188
friend class ASTContext
Definition TypeBase.h:8268
QualType getType() const
Return the type wrapped by this type source info.
Definition TypeBase.h:8276
void overrideType(QualType T)
Override the type stored in this TypeSourceInfo. Use with caution!
Definition TypeBase.h:8282
TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc, QualType Canonical, TypeDependence Dependence)
Definition TypeBase.h:5955
FunctionTypeBitfields store various bits belonging to FunctionProtoType.
Definition TypeBase.h:1944
The base class of the type hierarchy.
Definition TypeBase.h:1833
bool isIncompleteOrObjectType() const
Return true if this is an incomplete or object type, in other words, not a function type.
Definition TypeBase.h:2485
bool isDecltypeType() const
Definition TypeBase.h:8755
bool isDependentSizedArrayType() const
Definition TypeBase.h:8650
friend class ASTWriter
Definition TypeBase.h:2376
bool isFixedPointOrIntegerType() const
Return true if this is a fixed point or integer type.
Definition TypeBase.h:8951
bool isBlockPointerType() const
Definition TypeBase.h:8551
bool isVoidType() const
Definition TypeBase.h:8887
TypedefBitfields TypedefBits
Definition TypeBase.h:2319
UsingBitfields UsingBits
Definition TypeBase.h:2321
bool hasPointeeToToCFIUncheckedCalleeFunctionType() const
Definition TypeBase.h:8583
bool isBooleanType() const
Definition TypeBase.h:9017
bool isFunctionReferenceType() const
Definition TypeBase.h:8605
bool isSignableType(const ASTContext &Ctx) const
Definition TypeBase.h:8543
Type(const Type &)=delete
bool isObjCBuiltinType() const
Definition TypeBase.h:8751
const TemplateSpecializationType * getAsNonAliasTemplateSpecializationType() const
Look through sugar for an instance of TemplateSpecializationType which is not a type alias,...
Definition Type.cpp:1921
bool isMFloat8Type() const
Definition TypeBase.h:8912
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
Definition TypeBase.h:9067
bool isIncompleteArrayType() const
Definition TypeBase.h:8638
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
Definition TypeBase.h:8863
bool isFloat16Type() const
Definition TypeBase.h:8896
ReferenceTypeBitfields ReferenceTypeBits
Definition TypeBase.h:2325
bool isSignablePointerType() const
Definition TypeBase.h:8547
ArrayTypeBitfields ArrayTypeBits
Definition TypeBase.h:2314
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
Definition TypeBase.h:9183
Type(Type &&)=delete
bool isDependentAddressSpaceType() const
Definition TypeBase.h:8696
bool isUndeducedAutoType() const
Definition TypeBase.h:8717
bool isRValueReferenceType() const
Definition TypeBase.h:8563
bool isFundamentalType() const
Tests whether the type is categorized as a fundamental type.
Definition TypeBase.h:8494
VectorTypeBitfields VectorTypeBits
Definition TypeBase.h:2328
SubstPackTypeBitfields SubstPackTypeBits
Definition TypeBase.h:2331
bool isConstantArrayType() const
Definition TypeBase.h:8634
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
Definition TypeBase.h:9047
bool isArrayType() const
Definition TypeBase.h:8630
bool isFunctionPointerType() const
Definition TypeBase.h:8598
bool isHLSLInlineSpirvType() const
Definition TypeBase.h:8848
bool isConvertibleToFixedPointType() const
Return true if this can be converted to (or from) a fixed point type.
Definition TypeBase.h:8955
bool isArithmeticType() const
Definition Type.cpp:2337
bool isConstantMatrixType() const
Definition TypeBase.h:8692
bool isHLSLBuiltinIntangibleType() const
Definition TypeBase.h:8832
bool isPointerType() const
Definition TypeBase.h:8531
const TemplateSpecializationType * castAsNonAliasTemplateSpecializationType() const
Definition TypeBase.h:2947
bool isArrayParameterType() const
Definition TypeBase.h:8646
TypeOfBitfields TypeOfBits
Definition TypeBase.h:2318
static constexpr int FunctionTypeNumParamsLimit
Definition TypeBase.h:1938
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition TypeBase.h:8931
bool isObjCSelType() const
Definition TypeBase.h:8745
const T * castAs() const
Member-template castAs<specific type>.
Definition TypeBase.h:9174
BuiltinTypeBitfields BuiltinTypeBits
Definition TypeBase.h:2322
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition TypeBase.h:8876
bool isReferenceType() const
Definition TypeBase.h:8555
bool isSignedFixedPointType() const
Return true if this is a fixed point type that is signed according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition TypeBase.h:8971
bool isObjectPointerType() const
Definition TypeBase.h:8567
bool isEnumeralType() const
Definition TypeBase.h:8662
bool isVisibilityExplicit() const
Return true if the visibility was explicitly set is the code.
Definition TypeBase.h:3070
void addDependence(TypeDependence D)
Definition TypeBase.h:2372
ConstantArrayTypeBitfields ConstantArrayTypeBits
Definition TypeBase.h:2315
Type(TypeClass tc, QualType canon, TypeDependence Dependence)
Definition TypeBase.h:2349
bool isScalarType() const
Definition TypeBase.h:8989
bool isVariableArrayType() const
Definition TypeBase.h:8642
bool isFloat128Type() const
Definition TypeBase.h:8916
bool isClkEventT() const
Definition TypeBase.h:8773
bool isSveVLSBuiltinType() const
Determines if this is a sizeless type supported by the 'arm_sve_vector_bits' type attribute,...
Definition Type.cpp:2608
CountAttributedTypeBitfields CountAttributedTypeBits
Definition TypeBase.h:2334
bool isObjCQualifiedIdType() const
Definition TypeBase.h:8721
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition Type.cpp:752
LinkageInfo getLinkageAndVisibility() const
Determine the linkage and visibility of this type.
Definition Type.cpp:5018
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition TypeBase.h:9005
bool isExtVectorType() const
Definition TypeBase.h:8674
friend class ASTReader
Definition TypeBase.h:2375
bool isExtVectorBoolType() const
Definition TypeBase.h:8678
Type & operator=(const Type &)=delete
bool isObjCObjectOrInterfaceType() const
Definition TypeBase.h:8708
bool isImageType() const
Definition TypeBase.h:8785
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
Definition TypeBase.h:8881
bool isOCLIntelSubgroupAVCType() const
Definition TypeBase.h:8806
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type.
Definition TypeBase.h:2899
bool isPipeType() const
Definition TypeBase.h:8792
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition TypeBase.h:2790
bool isMemberDataPointerType() const
Definition TypeBase.h:8623
bool isLValueReferenceType() const
Definition TypeBase.h:8559
bool isBitIntType() const
Definition TypeBase.h:8796
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition TypeBase.h:8856
bool isBuiltinType() const
Helper methods to distinguish type categories.
Definition TypeBase.h:8654
bool isOpenCLSpecificType() const
Definition TypeBase.h:8821
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition TypeBase.h:2782
bool isSignableIntegerType(const ASTContext &Ctx) const
Definition Type.cpp:5215
bool isFloat32Type() const
Definition TypeBase.h:8900
TypeBitfields TypeBits
Definition TypeBase.h:2313
bool isAnyComplexType() const
Definition TypeBase.h:8666
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition TypeBase.h:8943
bool isHalfType() const
Definition TypeBase.h:8891
friend class TypePropertyCache
Definition TypeBase.h:2339
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
Definition Type.cpp:2056
bool isSaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition TypeBase.h:8959
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition TypeBase.h:2405
const BuiltinType * getAsPlaceholderType() const
Definition TypeBase.h:8869
QualType getCanonicalTypeInternal() const
Definition TypeBase.h:3119
friend class ASTContext
Definition TypeBase.h:2347
bool isHLSLSpecificType() const
Definition TypeBase.h:8839
bool isTemplateTypeParmType() const
Definition TypeBase.h:8852
@ PtrdiffT
The "ptrdiff_t" type.
Definition TypeBase.h:2281
@ SizeT
The "size_t" type.
Definition TypeBase.h:2275
@ SignedSizeT
The signed integer type corresponding to "size_t".
Definition TypeBase.h:2278
bool isQueueT() const
Definition TypeBase.h:8777
PresefinedSugarTypeBitfields PredefinedSugarTypeBits
Definition TypeBase.h:2335
bool isCompoundType() const
Tests whether the type is categorized as a compound type.
Definition TypeBase.h:8505
bool containsErrors() const
Whether this type is an error type.
Definition TypeBase.h:2776
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition TypeBase.h:9060
bool isMemberPointerType() const
Definition TypeBase.h:8612
bool isAtomicType() const
Definition TypeBase.h:8713
AttributedTypeBitfields AttributedTypeBits
Definition TypeBase.h:2316
bool isFunctionProtoType() const
Definition TypeBase.h:2601
bool isIbm128Type() const
Definition TypeBase.h:8920
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
Definition TypeBase.h:9030
bool isObjCIdType() const
Definition TypeBase.h:8733
bool isMatrixType() const
Definition TypeBase.h:8688
TagTypeBitfields TagTypeBits
Definition TypeBase.h:2327
PackExpansionTypeBitfields PackExpansionTypeBits
Definition TypeBase.h:2333
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition TypeBase.h:2800
bool isUnsaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition TypeBase.h:8967
UnresolvedUsingBitfields UnresolvedUsingBits
Definition TypeBase.h:2320
bool isObjCObjectType() const
Definition TypeBase.h:8704
bool isFromAST() const
Whether this type comes from an AST file.
Definition TypeBase.h:2388
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
Definition TypeBase.h:9160
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition TypeBase.h:9023
bool isObjectType() const
Determine whether this type is an object type.
Definition TypeBase.h:2510
bool isEventT() const
Definition TypeBase.h:8769
bool isDoubleType() const
Definition TypeBase.h:8904
bool isPointerOrReferenceType() const
Definition TypeBase.h:8535
Type * this_()
Definition TypeBase.h:2366
KeywordWrapperBitfields KeywordWrapperBits
Definition TypeBase.h:2326
FunctionTypeBitfields FunctionTypeBits
Definition TypeBase.h:2323
bool isBFloat16Type() const
Definition TypeBase.h:8908
void setDependence(TypeDependence D)
Definition TypeBase.h:2368
const T * getAsAdjusted() const
Member-template getAsAdjusted<specific type>.
Definition TypeBase.h:9124
bool isFunctionType() const
Definition TypeBase.h:8527
bool isObjCObjectPointerType() const
Definition TypeBase.h:8700
SubstTemplateTypeParmTypeBitfields SubstTemplateTypeParmTypeBits
Definition TypeBase.h:2330
TypeDependence getDependence() const
Definition TypeBase.h:2771
Visibility getVisibility() const
Determine the visibility of this type.
Definition TypeBase.h:3065
bool isMemberFunctionPointerType() const
Definition TypeBase.h:8616
bool isUnsignedFixedPointType() const
Return true if this is a fixed point type that is unsigned according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition TypeBase.h:8985
bool isVectorType() const
Definition TypeBase.h:8670
bool isObjCQualifiedClassType() const
Definition TypeBase.h:8727
bool isObjCClassType() const
Definition TypeBase.h:8739
bool isObjCInertUnsafeUnretainedType() const
Was this type written with the special inert-in-ARC __unsafe_unretained qualifier?
Definition TypeBase.h:2668
bool isRealFloatingType() const
Floating point categories.
Definition Type.cpp:2320
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
Definition TypeBase.h:2921
bool isHLSLAttributedResourceType() const
Definition TypeBase.h:8844
ObjCObjectTypeBitfields ObjCObjectTypeBits
Definition TypeBase.h:2324
TemplateTypeParmTypeBitfields TemplateTypeParmTypeBits
Definition TypeBase.h:2329
@ STK_FloatingComplex
Definition TypeBase.h:2764
@ STK_ObjCObjectPointer
Definition TypeBase.h:2758
@ STK_IntegralComplex
Definition TypeBase.h:2763
@ STK_MemberPointer
Definition TypeBase.h:2759
bool isOCLExtOpaqueType() const
Definition TypeBase.h:8814
const T * castAsCanonical() const
Return this type's canonical type cast to the specified type.
Definition TypeBase.h:2928
bool isAnyPointerType() const
Definition TypeBase.h:8539
TypeClass getTypeClass() const
Definition TypeBase.h:2385
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
Definition TypeBase.h:2411
bool isSubscriptableVectorType() const
Definition TypeBase.h:8684
bool isSamplerT() const
Definition TypeBase.h:8765
const T * getAs() const
Member-template getAs<specific type>'.
Definition TypeBase.h:9107
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs,...
Definition Type.cpp:653
bool isNullPtrType() const
Definition TypeBase.h:8924
bool isRecordType() const
Definition TypeBase.h:8658
TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits
Definition TypeBase.h:2332
bool isTypedefNameType() const
Determines whether this type is written as a typedef-name.
Definition TypeBase.h:9038
static constexpr int FunctionTypeNumParamsWidth
Definition TypeBase.h:1937
@ NumTypeWithKeywordBits
Definition TypeBase.h:2059
bool isUnionType() const
Definition Type.cpp:718
bool isFunctionNoProtoType() const
Definition TypeBase.h:2600
bool isReserveIDT() const
Definition TypeBase.h:8781
bool hasObjCPointerRepresentation() const
Whether this type can represent an objective pointer type for the purpose of GC'ability.
Definition TypeBase.h:9056
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
Definition TypeBase.h:9051
AutoTypeBitfields AutoTypeBits
Definition TypeBase.h:2317
bool isCFIUncheckedCalleeFunctionType() const
Definition TypeBase.h:8577
Type & operator=(Type &&)=delete
Base class for declarations which introduce a typedef-name.
Definition Decl.h:3562
TypedefNameDecl * getDecl() const
Definition TypeBase.h:6111
NestedNameSpecifier getQualifier() const
Definition TypeBase.h:6106
QualType desugar() const
Definition Type.cpp:4041
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const TypedefNameDecl *Decl, QualType Underlying)
Definition TypeBase.h:6121
friend class ASTContext
Definition TypeBase.h:6081
static bool classof(const Type *T)
Definition TypeBase.h:6140
bool typeMatchesDecl() const
Definition TypeBase.h:6119
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:6135
bool isSugared() const
Definition TypeBase.h:6113
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:6028
QualType desugar() const
Definition TypeBase.h:6017
NestedNameSpecifier getQualifier() const
Definition TypeBase.h:6008
UnresolvedUsingTypenameDecl * getDecl() const
Definition TypeBase.h:6014
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const UnresolvedUsingTypenameDecl *D)
Definition TypeBase.h:6019
static bool classof(const Type *T)
Definition TypeBase.h:6032
Represents a dependent using declaration which was marked with typename.
Definition DeclCXX.h:4037
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition DeclCXX.h:3399
UsingShadowDecl * getDecl() const
Definition TypeBase.h:6054
QualType desugar() const
Definition TypeBase.h:6056
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:6069
NestedNameSpecifier getQualifier() const
Definition TypeBase.h:6050
friend class ASTContext
Definition TypeBase.h:6043
static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword, NestedNameSpecifier Qualifier, const UsingShadowDecl *D, QualType UnderlyingType)
Definition TypeBase.h:6059
bool isSugared() const
Definition TypeBase.h:6057
static bool classof(const Type *T)
Definition TypeBase.h:6072
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:712
static bool classof(const Type *T)
Definition TypeBase.h:3989
friend class StmtIteratorBase
Definition TypeBase.h:3978
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:3993
Expr * getSizeExpr() const
Definition TypeBase.h:3980
friend class ASTContext
Definition TypeBase.h:3967
QualType desugar() const
Definition TypeBase.h:3987
unsigned getNumElements() const
Definition TypeBase.h:4190
VectorType(QualType vecType, unsigned nElements, QualType canonType, VectorKind vecKind)
Definition Type.cpp:407
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:4199
bool isSugared() const
Definition TypeBase.h:4192
friend class ASTContext
Definition TypeBase.h:4177
static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType, unsigned NumElements, TypeClass TypeClass, VectorKind VecKind)
Definition TypeBase.h:4204
VectorKind getVectorKind() const
Definition TypeBase.h:4195
QualType ElementType
The element type of the vector.
Definition TypeBase.h:4180
QualType desugar() const
Definition TypeBase.h:4193
QualType getElementType() const
Definition TypeBase.h:4189
static bool classof(const Type *T)
Definition TypeBase.h:4213
Code completion in a.
#define bool
Definition gpuintrin.h:32
Defines the Linkage enumeration and various utility functions.
mlir::Type getBaseType(mlir::Value varPtr)
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
bool operator!=(const CommonEntityInfo &LHS, const CommonEntityInfo &RHS)
Definition Types.h:153
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
uint32_t Literal
Literals are represented as positive integers.
Definition CNFFormula.h:35
std::variant< struct RequiresDecl, struct HeaderDecl, struct UmbrellaDirDecl, struct ModuleDecl, struct ExcludeDecl, struct ExportDecl, struct ExportAsDecl, struct ExternModuleDecl, struct UseDecl, struct LinkDecl, struct ConfigMacrosDecl, struct ConflictDecl > Decl
All declarations that can appear in a module declaration.
bool isLiteral(TokenKind K)
Return true if this is a "literal" kind, like a numeric constant, string, etc.
Definition TokenKinds.h:97
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
@ Overload
This is a legitimate overload: the existing declarations are functions or function templates with dif...
Definition Sema.h:812
bool isa(CodeGen::Address addr)
Definition Address.h:330
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
Definition TypeBase.h:1792
@ GNUAutoType
__auto_type (GNU extension)
Definition TypeBase.h:1800
@ DecltypeAuto
decltype(auto)
Definition TypeBase.h:1797
bool isTargetAddressSpace(LangAS AS)
CanThrowResult
Possible results from evaluation of a noexcept expression.
FunctionType::ExtInfo getFunctionExtInfo(const Type &t)
Definition TypeBase.h:8429
bool isDynamicExceptionSpec(ExceptionSpecificationType ESpecType)
TypeDependenceScope::TypeDependence TypeDependence
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
@ Nullable
Values of this type can be null.
Definition Specifiers.h:352
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
Definition TypeBase.h:1780
@ RQ_None
No ref-qualifier was provided.
Definition TypeBase.h:1782
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
Definition TypeBase.h:1785
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
Definition TypeBase.h:1788
@ TemplateName
The identifier is a template name. FIXME: Add an annotation for that.
Definition Parser.h:61
bool IsEnumDeclComplete(EnumDecl *ED)
Check if the given decl is complete.
Definition Decl.h:5350
ExprDependence computeDependence(FullExpr *E)
@ Vector
'vector' clause, allowed on 'loop', Combined, and 'routine' directives.
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
TypeOfKind
The kind of 'typeof' expression we're after.
Definition TypeBase.h:918
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
Definition CallGraph.h:204
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
TypeDependence toTypeDependence(ExprDependence D)
@ Dependent
Parse the block as a dependent block, which may be used in some template instantiations but not other...
Definition Parser.h:142
unsigned toTargetAddressSpace(LangAS AS)
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition Linkage.h:24
ObjCSubstitutionContext
The kind of type we are substituting Objective-C type arguments into.
Definition TypeBase.h:900
@ Superclass
The superclass of a type.
Definition TypeBase.h:914
@ Property
The type of a property.
Definition TypeBase.h:911
@ Parameter
The parameter type of a method or function.
Definition TypeBase.h:908
@ Result
The result type of a method or function.
Definition TypeBase.h:905
@ TypeAlignment
Definition TypeBase.h:76
@ TypeAlignmentInBits
Definition TypeBase.h:75
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition TypeBase.h:3719
ParameterABI
Kinds of parameter ABI.
Definition Specifiers.h:378
@ Ordinary
This parameter uses ordinary ABI rules for its type.
Definition Specifiers.h:380
const FunctionProtoType * T
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
@ Template
We are parsing a template declaration.
Definition Parser.h:81
bool isNoexceptExceptionSpec(ExceptionSpecificationType ESpecType)
TagTypeKind
The kind of a tag type.
Definition TypeBase.h:5890
constexpr unsigned PointerAuthKeyNone
bool IsEnumDeclScoped(EnumDecl *ED)
Check if the given decl is scoped.
Definition Decl.h:5360
std::is_base_of< ArrayType, T > TypeIsArrayType
Definition TypeBase.h:9104
@ Keyword
The name has been typo-corrected to a keyword.
Definition Sema.h:560
LangAS
Defines the address space values used by the address space qualifier of QualType.
void FixedPointValueToString(SmallVectorImpl< char > &Str, llvm::APSInt Val, unsigned Scale)
Definition Type.cpp:5464
bool operator!=(CanQual< T > x, CanQual< U > y)
PointerAuthenticationMode
Definition LangOptions.h:62
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ConceptReference *C)
Insertion operator for diagnostics.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition Specifiers.h:278
@ AltiVecBool
is AltiVec 'vector bool ...'
Definition TypeBase.h:4145
@ SveFixedLengthData
is AArch64 SVE fixed-length data vector
Definition TypeBase.h:4154
@ AltiVecVector
is AltiVec vector
Definition TypeBase.h:4139
@ AltiVecPixel
is AltiVec 'vector Pixel'
Definition TypeBase.h:4142
@ Neon
is ARM Neon vector
Definition TypeBase.h:4148
@ Generic
not a target-specific vector type
Definition TypeBase.h:4136
@ RVVFixedLengthData
is RISC-V RVV fixed-length data vector
Definition TypeBase.h:4160
@ RVVFixedLengthMask
is RISC-V RVV fixed-length mask vector
Definition TypeBase.h:4163
@ NeonPoly
is ARM Neon polynomial vector
Definition TypeBase.h:4151
@ SveFixedLengthPredicate
is AArch64 SVE fixed-length predicate vector
Definition TypeBase.h:4157
U cast(CodeGen::Address addr)
Definition Address.h:327
@ None
The alignment was not explicit in code.
Definition ASTContext.h:178
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition TypeBase.h:5865
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5870
@ None
No keyword precedes the qualified type name.
Definition TypeBase.h:5886
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5867
@ Class
The "class" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5876
@ Union
The "union" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5873
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5879
@ Typename
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition TypeBase.h:5883
@ Other
Other implicit parameter.
Definition Decl.h:1746
ExceptionSpecificationType
The various types of exception specifications that exist in C++11.
@ EST_DependentNoexcept
noexcept(expression), value-dependent
@ EST_Uninstantiated
not instantiated yet
@ EST_Unparsed
not parsed yet
@ EST_NoThrow
Microsoft __declspec(nothrow) extension.
@ EST_None
no exception specification
@ EST_MSAny
Microsoft throw(...) extension.
@ EST_BasicNoexcept
noexcept
@ EST_NoexceptFalse
noexcept(expression), evals to 'false'
@ EST_Unevaluated
not evaluated yet, for special member function
@ EST_NoexceptTrue
noexcept(expression), evals to 'true'
@ EST_Dynamic
throw(T1, T2)
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition Visibility.h:34
unsigned int uint32_t
Diagnostic wrappers for TextAPI types for error reporting.
Definition Dominators.h:30
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
#define false
Definition stdbool.h:26
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:5961
const T * getType() const
Definition TypeBase.h:5963
FunctionEffectWithCondition Rejected
Definition TypeBase.h:5232
FunctionEffectWithCondition Kept
Definition TypeBase.h:5231
A FunctionEffect plus a potential boolean expression determining whether the effect is declared (e....
Definition TypeBase.h:5003
FunctionEffectWithCondition(FunctionEffect E, const EffectConditionExpr &C)
Definition TypeBase.h:5007
Holds information about the various types of exception specification.
Definition TypeBase.h:5323
FunctionDecl * SourceDecl
The function whose exception specification this is, for EST_Unevaluated and EST_Uninstantiated.
Definition TypeBase.h:5335
ExceptionSpecInfo(ExceptionSpecificationType EST)
Definition TypeBase.h:5343
FunctionDecl * SourceTemplate
The function template whose exception specification this is instantiated from, for EST_Uninstantiated...
Definition TypeBase.h:5339
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition TypeBase.h:5325
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition TypeBase.h:5328
Expr * NoexceptExpr
Noexcept expression, if this is a computed noexcept specification.
Definition TypeBase.h:5331
Extra information about a function prototype.
Definition TypeBase.h:5351
FunctionTypeExtraAttributeInfo ExtraAttributeInfo
Definition TypeBase.h:5359
bool requiresFunctionProtoTypeArmAttributes() const
Definition TypeBase.h:5397
const ExtParameterInfo * ExtParameterInfos
Definition TypeBase.h:5356
bool requiresFunctionProtoTypeExtraAttributeInfo() const
Definition TypeBase.h:5401
ExtProtoInfo withCFIUncheckedCallee(bool CFIUncheckedCallee)
Definition TypeBase.h:5384
bool requiresFunctionProtoTypeExtraBitfields() const
Definition TypeBase.h:5390
void setArmSMEAttribute(AArch64SMETypeAttributes Kind, bool Enable=true)
Definition TypeBase.h:5405
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI)
Definition TypeBase.h:5378
A simple holder for a QualType representing a type in an exception specification.
Definition TypeBase.h:4697
unsigned AArch64SMEAttributes
Any AArch64 SME ACLE type attributes that need to be propagated on declarations and function pointers...
Definition TypeBase.h:4782
A holder for extra information from attributes which aren't part of an AttributedType.
Definition TypeBase.h:4726
StringRef CFISalt
A CFI "salt" that differentiates functions with the same prototype.
Definition TypeBase.h:4728
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:4732
unsigned NumExceptionType
The number of types in the exception specification.
Definition TypeBase.h:4706
Provides a few static helpers for converting and printing elaborated type keyword and tag type kind e...
Definition TypeBase.h:5909
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition TypeBase.h:5929
static StringRef getKeywordName(ElaboratedTypeKeyword Keyword)
Definition Type.cpp:3310
static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag)
Converts a TagTypeKind into an elaborated type keyword.
Definition Type.cpp:3259
static TagTypeKind getTagTypeKindForKeyword(ElaboratedTypeKeyword Keyword)
Converts an elaborated type keyword into a TagTypeKind.
Definition Type.cpp:3276
static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into a tag type kind.
Definition Type.cpp:3241
static bool KeywordIsTagTypeKind(ElaboratedTypeKeyword Keyword)
Definition Type.cpp:3295
static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec)
Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
Definition Type.cpp:3222
Describes how types, statements, expressions, and declarations should be printed.
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition TypeBase.h:870
SplitQualType(const Type *ty, Qualifiers qs)
Definition TypeBase.h:878
SplitQualType getSingleStepDesugaredType() const
Definition TypeBase.h:8287
friend bool operator==(SplitQualType a, SplitQualType b)
Definition TypeBase.h:887
const Type * Ty
The locally-unqualified type.
Definition TypeBase.h:872
friend bool operator!=(SplitQualType a, SplitQualType b)
Definition TypeBase.h:890
std::pair< const Type *, Qualifiers > asPair() const
Definition TypeBase.h:883
Qualifiers Quals
The local qualifiers.
Definition TypeBase.h:875
static inline ::clang::ExtQuals * getFromVoidPointer(void *P)
Definition TypeBase.h:105
static void * getAsVoidPointer(::clang::ExtQuals *P)
Definition TypeBase.h:103
static void * getAsVoidPointer(::clang::Type *P)
Definition TypeBase.h:92
static inline ::clang::Type * getFromVoidPointer(void *P)
Definition TypeBase.h:94
static void * getAsVoidPointer(clang::QualType P)
Definition TypeBase.h:1667
static clang::QualType getFromVoidPointer(void *P)
Definition TypeBase.h:1671
static SimpleType getSimplifiedValue(::clang::QualType Val)
Definition TypeBase.h:1659