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 Attributes(llvm::dxil::ResourceClass ResourceClass, bool IsROV = false,
6706 bool RawBuffer = false)
6707 : ResourceClass(ResourceClass), IsROV(IsROV), RawBuffer(RawBuffer) {}
6708
6709 Attributes() : Attributes(llvm::dxil::ResourceClass::UAV, false, false) {}
6710
6711 friend bool operator==(const Attributes &LHS, const Attributes &RHS) {
6712 return std::tie(LHS.ResourceClass, LHS.IsROV, LHS.RawBuffer) ==
6713 std::tie(RHS.ResourceClass, RHS.IsROV, RHS.RawBuffer);
6714 }
6715 friend bool operator!=(const Attributes &LHS, const Attributes &RHS) {
6716 return !(LHS == RHS);
6717 }
6718 };
6719
6720private:
6721 friend class ASTContext; // ASTContext creates these
6722
6723 QualType WrappedType;
6724 QualType ContainedType;
6725 const Attributes Attrs;
6726
6727 HLSLAttributedResourceType(QualType Wrapped, QualType Contained,
6728 const Attributes &Attrs)
6729 : Type(HLSLAttributedResource, QualType(),
6730 Contained.isNull() ? TypeDependence::None
6731 : Contained->getDependence()),
6732 WrappedType(Wrapped), ContainedType(Contained), Attrs(Attrs) {}
6733
6734public:
6735 QualType getWrappedType() const { return WrappedType; }
6736 QualType getContainedType() const { return ContainedType; }
6737 bool hasContainedType() const { return !ContainedType.isNull(); }
6738 const Attributes &getAttrs() const { return Attrs; }
6739
6740 bool isSugared() const { return false; }
6741 QualType desugar() const { return QualType(this, 0); }
6742
6743 void Profile(llvm::FoldingSetNodeID &ID) {
6744 Profile(ID, WrappedType, ContainedType, Attrs);
6745 }
6746
6747 static void Profile(llvm::FoldingSetNodeID &ID, QualType Wrapped,
6748 QualType Contained, const Attributes &Attrs) {
6749 ID.AddPointer(Wrapped.getAsOpaquePtr());
6750 ID.AddPointer(Contained.getAsOpaquePtr());
6751 ID.AddInteger(static_cast<uint32_t>(Attrs.ResourceClass));
6752 ID.AddBoolean(Attrs.IsROV);
6753 ID.AddBoolean(Attrs.RawBuffer);
6754 }
6755
6756 static bool classof(const Type *T) {
6757 return T->getTypeClass() == HLSLAttributedResource;
6758 }
6759
6760 // Returns handle type from HLSL resource, if the type is a resource
6761 static const HLSLAttributedResourceType *
6762 findHandleTypeOnResource(const Type *RT);
6763};
6764
6765/// Instances of this class represent operands to a SPIR-V type instruction.
6766class SpirvOperand {
6767public:
6768 enum SpirvOperandKind : unsigned char {
6769 Invalid, ///< Uninitialized.
6770 ConstantId, ///< Integral value to represent as a SPIR-V OpConstant
6771 ///< instruction ID.
6772 Literal, ///< Integral value to represent as an immediate literal.
6773 TypeId, ///< Type to represent as a SPIR-V type ID.
6774
6775 Max,
6776 };
6777
6778private:
6779 SpirvOperandKind Kind = Invalid;
6780
6781 QualType ResultType;
6782 llvm::APInt Value; // Signedness of constants is represented by ResultType.
6783
6784public:
6785 SpirvOperand() : Kind(Invalid), ResultType(), Value() {}
6786
6787 SpirvOperand(SpirvOperandKind Kind, QualType ResultType, llvm::APInt Value)
6788 : Kind(Kind), ResultType(ResultType), Value(std::move(Value)) {}
6789
6790 SpirvOperand(const SpirvOperand &Other) { *this = Other; }
6791 ~SpirvOperand() {}
6792
6793 SpirvOperand &operator=(const SpirvOperand &Other) = default;
6794
6795 bool operator==(const SpirvOperand &Other) const {
6796 return Kind == Other.Kind && ResultType == Other.ResultType &&
6797 Value == Other.Value;
6798 }
6799
6800 bool operator!=(const SpirvOperand &Other) const { return !(*this == Other); }
6801
6802 SpirvOperandKind getKind() const { return Kind; }
6803
6804 bool isValid() const { return Kind != Invalid && Kind < Max; }
6805 bool isConstant() const { return Kind == ConstantId; }
6806 bool isLiteral() const { return Kind == Literal; }
6807 bool isType() const { return Kind == TypeId; }
6808
6809 llvm::APInt getValue() const {
6810 assert((isConstant() || isLiteral()) &&
6811 "This is not an operand with a value!");
6812 return Value;
6813 }
6814
6815 QualType getResultType() const {
6816 assert((isConstant() || isType()) &&
6817 "This is not an operand with a result type!");
6818 return ResultType;
6819 }
6820
6821 static SpirvOperand createConstant(QualType ResultType, llvm::APInt Val) {
6822 return SpirvOperand(ConstantId, ResultType, std::move(Val));
6823 }
6824
6825 static SpirvOperand createLiteral(llvm::APInt Val) {
6826 return SpirvOperand(Literal, QualType(), std::move(Val));
6827 }
6828
6829 static SpirvOperand createType(QualType T) {
6830 return SpirvOperand(TypeId, T, llvm::APSInt());
6831 }
6832
6833 void Profile(llvm::FoldingSetNodeID &ID) const {
6834 ID.AddInteger(Kind);
6835 ID.AddPointer(ResultType.getAsOpaquePtr());
6836 Value.Profile(ID);
6837 }
6838};
6839
6840/// Represents an arbitrary, user-specified SPIR-V type instruction.
6841class HLSLInlineSpirvType final
6842 : public Type,
6843 public llvm::FoldingSetNode,
6844 private llvm::TrailingObjects<HLSLInlineSpirvType, SpirvOperand> {
6845 friend class ASTContext; // ASTContext creates these
6846 friend TrailingObjects;
6847
6848private:
6850 uint32_t Size;
6851 uint32_t Alignment;
6852 size_t NumOperands;
6853
6854 HLSLInlineSpirvType(uint32_t Opcode, uint32_t Size, uint32_t Alignment,
6855 ArrayRef<SpirvOperand> Operands)
6856 : Type(HLSLInlineSpirv, QualType(), TypeDependence::None), Opcode(Opcode),
6857 Size(Size), Alignment(Alignment), NumOperands(Operands.size()) {
6858 for (size_t I = 0; I < NumOperands; I++) {
6859 // Since Operands are stored as a trailing object, they have not been
6860 // initialized yet. Call the constructor manually.
6861 auto *Operand = new (&getTrailingObjects()[I]) SpirvOperand();
6862 *Operand = Operands[I];
6863 }
6864 }
6865
6866public:
6867 uint32_t getOpcode() const { return Opcode; }
6868 uint32_t getSize() const { return Size; }
6869 uint32_t getAlignment() const { return Alignment; }
6870 ArrayRef<SpirvOperand> getOperands() const {
6871 return getTrailingObjects(NumOperands);
6872 }
6873
6874 bool isSugared() const { return false; }
6875 QualType desugar() const { return QualType(this, 0); }
6876
6877 void Profile(llvm::FoldingSetNodeID &ID) {
6878 Profile(ID, Opcode, Size, Alignment, getOperands());
6879 }
6880
6881 static void Profile(llvm::FoldingSetNodeID &ID, uint32_t Opcode,
6882 uint32_t Size, uint32_t Alignment,
6883 ArrayRef<SpirvOperand> Operands) {
6884 ID.AddInteger(Opcode);
6885 ID.AddInteger(Size);
6886 ID.AddInteger(Alignment);
6887 for (auto &Operand : Operands)
6888 Operand.Profile(ID);
6889 }
6890
6891 static bool classof(const Type *T) {
6892 return T->getTypeClass() == HLSLInlineSpirv;
6893 }
6894};
6895
6896class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
6897 friend class ASTContext; // ASTContext creates these
6898
6899 // The associated TemplateTypeParmDecl for the non-canonical type.
6900 TemplateTypeParmDecl *TTPDecl;
6901
6902 TemplateTypeParmType(unsigned D, unsigned I, bool PP,
6903 TemplateTypeParmDecl *TTPDecl, QualType Canon)
6904 : Type(TemplateTypeParm, Canon,
6905 TypeDependence::DependentInstantiation |
6906 (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)),
6907 TTPDecl(TTPDecl) {
6908 assert(!TTPDecl == Canon.isNull());
6909 TemplateTypeParmTypeBits.Depth = D;
6910 TemplateTypeParmTypeBits.Index = I;
6911 TemplateTypeParmTypeBits.ParameterPack = PP;
6912 }
6913
6914public:
6915 unsigned getDepth() const { return TemplateTypeParmTypeBits.Depth; }
6916 unsigned getIndex() const { return TemplateTypeParmTypeBits.Index; }
6917 bool isParameterPack() const {
6918 return TemplateTypeParmTypeBits.ParameterPack;
6919 }
6920
6921 TemplateTypeParmDecl *getDecl() const { return TTPDecl; }
6922
6923 IdentifierInfo *getIdentifier() const;
6924
6925 bool isSugared() const { return false; }
6926 QualType desugar() const { return QualType(this, 0); }
6927
6928 void Profile(llvm::FoldingSetNodeID &ID) {
6929 Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
6930 }
6931
6932 static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
6933 unsigned Index, bool ParameterPack,
6934 TemplateTypeParmDecl *TTPDecl) {
6935 ID.AddInteger(Depth);
6936 ID.AddInteger(Index);
6937 ID.AddBoolean(ParameterPack);
6938 ID.AddPointer(TTPDecl);
6939 }
6940
6941 static bool classof(const Type *T) {
6942 return T->getTypeClass() == TemplateTypeParm;
6943 }
6944};
6945
6946/// Represents the result of substituting a type for a template
6947/// type parameter.
6948///
6949/// Within an instantiated template, all template type parameters have
6950/// been replaced with these. They are used solely to record that a
6951/// type was originally written as a template type parameter;
6952/// therefore they are never canonical.
6953class SubstTemplateTypeParmType final
6954 : public Type,
6955 public llvm::FoldingSetNode,
6956 private llvm::TrailingObjects<SubstTemplateTypeParmType, QualType> {
6957 friend class ASTContext;
6958 friend class llvm::TrailingObjects<SubstTemplateTypeParmType, QualType>;
6959
6960 Decl *AssociatedDecl;
6961
6962 SubstTemplateTypeParmType(QualType Replacement, Decl *AssociatedDecl,
6963 unsigned Index, UnsignedOrNone PackIndex,
6964 bool Final);
6965
6966public:
6967 /// Gets the type that was substituted for the template
6968 /// parameter.
6969 QualType getReplacementType() const {
6970 return SubstTemplateTypeParmTypeBits.HasNonCanonicalUnderlyingType
6971 ? *getTrailingObjects()
6972 : getCanonicalTypeInternal();
6973 }
6974
6975 /// A template-like entity which owns the whole pattern being substituted.
6976 /// This will usually own a set of template parameters, or in some
6977 /// cases might even be a template parameter itself.
6978 Decl *getAssociatedDecl() const { return AssociatedDecl; }
6979
6980 /// Gets the template parameter declaration that was substituted for.
6981 const TemplateTypeParmDecl *getReplacedParameter() const;
6982
6983 /// Returns the index of the replaced parameter in the associated declaration.
6984 /// This should match the result of `getReplacedParameter()->getIndex()`.
6985 unsigned getIndex() const { return SubstTemplateTypeParmTypeBits.Index; }
6986
6987 // This substitution is Final, which means the substitution is fully
6988 // sugared: it doesn't need to be resugared later.
6989 unsigned getFinal() const { return SubstTemplateTypeParmTypeBits.Final; }
6990
6991 UnsignedOrNone getPackIndex() const {
6992 return UnsignedOrNone::fromInternalRepresentation(
6993 SubstTemplateTypeParmTypeBits.PackIndex);
6994 }
6995
6996 bool isSugared() const { return true; }
6997 QualType desugar() const { return getReplacementType(); }
6998
6999 void Profile(llvm::FoldingSetNodeID &ID) {
7000 Profile(ID, getReplacementType(), getAssociatedDecl(), getIndex(),
7001 getPackIndex(), getFinal());
7002 }
7003
7004 static void Profile(llvm::FoldingSetNodeID &ID, QualType Replacement,
7005 const Decl *AssociatedDecl, unsigned Index,
7006 UnsignedOrNone PackIndex, bool Final);
7007
7008 static bool classof(const Type *T) {
7009 return T->getTypeClass() == SubstTemplateTypeParm;
7010 }
7011};
7012
7013/// Represents the result of substituting a set of types as a template argument
7014/// that needs to be expanded later.
7015///
7016/// These types are always dependent and produced depending on the situations:
7017/// - SubstTemplateTypeParmPack is an expansion that had to be delayed,
7018/// - SubstBuiltinTemplatePackType is an expansion from a builtin.
7019class SubstPackType : public Type, public llvm::FoldingSetNode {
7020 friend class ASTContext;
7021
7022 /// A pointer to the set of template arguments that this
7023 /// parameter pack is instantiated with.
7024 const TemplateArgument *Arguments;
7025
7026protected:
7027 SubstPackType(TypeClass Derived, QualType Canon,
7028 const TemplateArgument &ArgPack);
7029
7030public:
7031 unsigned getNumArgs() const { return SubstPackTypeBits.NumArgs; }
7032
7033 TemplateArgument getArgumentPack() const;
7034
7035 void Profile(llvm::FoldingSetNodeID &ID);
7036 static void Profile(llvm::FoldingSetNodeID &ID,
7037 const TemplateArgument &ArgPack);
7038
7039 static bool classof(const Type *T) {
7040 return T->getTypeClass() == SubstTemplateTypeParmPack ||
7041 T->getTypeClass() == SubstBuiltinTemplatePack;
7042 }
7043};
7044
7045/// Represents the result of substituting a builtin template as a pack.
7046class SubstBuiltinTemplatePackType : public SubstPackType {
7047 friend class ASTContext;
7048
7049 SubstBuiltinTemplatePackType(QualType Canon, const TemplateArgument &ArgPack);
7050
7051public:
7052 bool isSugared() const { return false; }
7053 QualType desugar() const { return QualType(this, 0); }
7054
7055 /// Mark that we reuse the Profile. We do not introduce new fields.
7056 using SubstPackType::Profile;
7057
7058 static bool classof(const Type *T) {
7059 return T->getTypeClass() == SubstBuiltinTemplatePack;
7060 }
7061};
7062
7063/// Represents the result of substituting a set of types for a template
7064/// type parameter pack.
7065///
7066/// When a pack expansion in the source code contains multiple parameter packs
7067/// and those parameter packs correspond to different levels of template
7068/// parameter lists, this type node is used to represent a template type
7069/// parameter pack from an outer level, which has already had its argument pack
7070/// substituted but that still lives within a pack expansion that itself
7071/// could not be instantiated. When actually performing a substitution into
7072/// that pack expansion (e.g., when all template parameters have corresponding
7073/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
7074/// at the current pack substitution index.
7075class SubstTemplateTypeParmPackType : public SubstPackType {
7076 friend class ASTContext;
7077
7078 /// A pointer to the set of template arguments that this
7079 /// parameter pack is instantiated with.
7080 const TemplateArgument *Arguments;
7081
7082 llvm::PointerIntPair<Decl *, 1, bool> AssociatedDeclAndFinal;
7083
7084 SubstTemplateTypeParmPackType(QualType Canon, Decl *AssociatedDecl,
7085 unsigned Index, bool Final,
7086 const TemplateArgument &ArgPack);
7087
7088public:
7089 IdentifierInfo *getIdentifier() const;
7090
7091 /// A template-like entity which owns the whole pattern being substituted.
7092 /// This will usually own a set of template parameters, or in some
7093 /// cases might even be a template parameter itself.
7094 Decl *getAssociatedDecl() const;
7095
7096 /// Gets the template parameter declaration that was substituted for.
7097 const TemplateTypeParmDecl *getReplacedParameter() const;
7098
7099 /// Returns the index of the replaced parameter in the associated declaration.
7100 /// This should match the result of `getReplacedParameter()->getIndex()`.
7101 unsigned getIndex() const {
7102 return SubstPackTypeBits.SubstTemplTypeParmPackIndex;
7103 }
7104
7105 // This substitution will be Final, which means the substitution will be fully
7106 // sugared: it doesn't need to be resugared later.
7107 bool getFinal() const;
7108
7109 bool isSugared() const { return false; }
7110 QualType desugar() const { return QualType(this, 0); }
7111
7112 void Profile(llvm::FoldingSetNodeID &ID);
7113 static void Profile(llvm::FoldingSetNodeID &ID, const Decl *AssociatedDecl,
7114 unsigned Index, bool Final,
7115 const TemplateArgument &ArgPack);
7116
7117 static bool classof(const Type *T) {
7118 return T->getTypeClass() == SubstTemplateTypeParmPack;
7119 }
7120};
7121
7122/// Common base class for placeholders for types that get replaced by
7123/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
7124/// class template types, and constrained type names.
7125///
7126/// These types are usually a placeholder for a deduced type. However, before
7127/// the initializer is attached, or (usually) if the initializer is
7128/// type-dependent, there is no deduced type and the type is canonical. In
7129/// the latter case, it is also a dependent type.
7130class DeducedType : public Type {
7131 QualType DeducedAsType;
7132
7133protected:
7134 DeducedType(TypeClass TC, QualType DeducedAsType,
7135 TypeDependence ExtraDependence, QualType Canon)
7136 : Type(TC, Canon,
7137 ExtraDependence | (DeducedAsType.isNull()
7139 : DeducedAsType->getDependence() &
7140 ~TypeDependence::VariablyModified)),
7141 DeducedAsType(DeducedAsType) {}
7142
7143public:
7144 bool isSugared() const { return !DeducedAsType.isNull(); }
7145 QualType desugar() const {
7146 return isSugared() ? DeducedAsType : QualType(this, 0);
7147 }
7148
7149 /// Get the type deduced for this placeholder type, or null if it
7150 /// has not been deduced.
7151 QualType getDeducedType() const { return DeducedAsType; }
7152 bool isDeduced() const {
7153 return !DeducedAsType.isNull() || isDependentType();
7154 }
7155
7156 static bool classof(const Type *T) {
7157 return T->getTypeClass() == Auto ||
7158 T->getTypeClass() == DeducedTemplateSpecialization;
7159 }
7160};
7161
7162/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
7163/// by a type-constraint.
7164class AutoType : public DeducedType {
7165 friend class ASTContext; // ASTContext creates these
7166
7167 TemplateDecl *TypeConstraintConcept;
7168
7169 AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
7170 TypeDependence ExtraDependence, QualType Canon, TemplateDecl *CD,
7171 ArrayRef<TemplateArgument> TypeConstraintArgs);
7172
7173public:
7174 ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
7175 return {reinterpret_cast<const TemplateArgument *>(this + 1),
7176 AutoTypeBits.NumArgs};
7177 }
7178
7179 TemplateDecl *getTypeConstraintConcept() const {
7180 return TypeConstraintConcept;
7181 }
7182
7183 bool isConstrained() const {
7184 return TypeConstraintConcept != nullptr;
7185 }
7186
7187 bool isDecltypeAuto() const {
7188 return getKeyword() == AutoTypeKeyword::DecltypeAuto;
7189 }
7190
7191 bool isGNUAutoType() const {
7192 return getKeyword() == AutoTypeKeyword::GNUAutoType;
7193 }
7194
7195 AutoTypeKeyword getKeyword() const {
7196 return (AutoTypeKeyword)AutoTypeBits.Keyword;
7197 }
7198
7199 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context);
7200 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
7201 QualType Deduced, AutoTypeKeyword Keyword,
7202 bool IsDependent, TemplateDecl *CD,
7203 ArrayRef<TemplateArgument> Arguments);
7204
7205 static bool classof(const Type *T) {
7206 return T->getTypeClass() == Auto;
7207 }
7208};
7209
7210/// Represents a C++17 deduced template specialization type.
7211class DeducedTemplateSpecializationType : public KeywordWrapper<DeducedType>,
7212 public llvm::FoldingSetNode {
7213 friend class ASTContext; // ASTContext creates these
7214
7215 /// The name of the template whose arguments will be deduced.
7217
7218 DeducedTemplateSpecializationType(ElaboratedTypeKeyword Keyword,
7219 TemplateName Template,
7220 QualType DeducedAsType,
7221 bool IsDeducedAsDependent, QualType Canon)
7222 : KeywordWrapper(Keyword, DeducedTemplateSpecialization, DeducedAsType,
7223 toTypeDependence(Template.getDependence()) |
7224 (IsDeducedAsDependent
7225 ? TypeDependence::DependentInstantiation
7226 : TypeDependence::None),
7227 Canon),
7228 Template(Template) {}
7229
7230public:
7231 /// Retrieve the name of the template that we are deducing.
7232 TemplateName getTemplateName() const { return Template; }
7233
7234 void Profile(llvm::FoldingSetNodeID &ID) const {
7235 Profile(ID, getKeyword(), getTemplateName(), getDeducedType(),
7236 isDependentType());
7237 }
7238
7239 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
7240 TemplateName Template, QualType Deduced,
7241 bool IsDependent) {
7242 ID.AddInteger(llvm::to_underlying(Keyword));
7243 Template.Profile(ID);
7244 Deduced.Profile(ID);
7245 ID.AddBoolean(IsDependent || Template.isDependent());
7246 }
7247
7248 static bool classof(const Type *T) {
7249 return T->getTypeClass() == DeducedTemplateSpecialization;
7250 }
7251};
7252
7253/// Represents a type template specialization; the template
7254/// must be a class template, a type alias template, or a template
7255/// template parameter. A template which cannot be resolved to one of
7256/// these, e.g. because it is written with a dependent scope
7257/// specifier, is instead represented as a
7258/// @c DependentTemplateSpecializationType.
7259///
7260/// A non-dependent template specialization type is always "sugar",
7261/// typically for a \c RecordType. For example, a class template
7262/// specialization type of \c vector<int> will refer to a tag type for
7263/// the instantiation \c std::vector<int, std::allocator<int>>
7264///
7265/// Template specializations are dependent if either the template or
7266/// any of the template arguments are dependent, in which case the
7267/// type may also be canonical.
7268///
7269/// Instances of this type are allocated with a trailing array of
7270/// TemplateArguments, followed by a QualType representing the
7271/// non-canonical aliased type when the template is a type alias
7272/// template.
7273class TemplateSpecializationType : public TypeWithKeyword,
7274 public llvm::FoldingSetNode {
7275 friend class ASTContext; // ASTContext creates these
7276
7277 /// The name of the template being specialized. This is
7278 /// either a TemplateName::Template (in which case it is a
7279 /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
7280 /// TypeAliasTemplateDecl*), a
7281 /// TemplateName::SubstTemplateTemplateParmPack, or a
7282 /// TemplateName::SubstTemplateTemplateParm (in which case the
7283 /// replacement must, recursively, be one of these).
7285
7286 TemplateSpecializationType(ElaboratedTypeKeyword Keyword, TemplateName T,
7287 bool IsAlias, ArrayRef<TemplateArgument> Args,
7288 QualType Underlying);
7289
7290public:
7291 /// Determine whether any of the given template arguments are dependent.
7292 ///
7293 /// The converted arguments should be supplied when known; whether an
7294 /// argument is dependent can depend on the conversions performed on it
7295 /// (for example, a 'const int' passed as a template argument might be
7296 /// dependent if the parameter is a reference but non-dependent if the
7297 /// parameter is an int).
7298 ///
7299 /// Note that the \p Args parameter is unused: this is intentional, to remind
7300 /// the caller that they need to pass in the converted arguments, not the
7301 /// specified arguments.
7302 static bool
7303 anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
7304 ArrayRef<TemplateArgument> Converted);
7305 static bool
7306 anyDependentTemplateArguments(const TemplateArgumentListInfo &,
7307 ArrayRef<TemplateArgument> Converted);
7308 static bool anyInstantiationDependentTemplateArguments(
7309 ArrayRef<TemplateArgumentLoc> Args);
7310
7311 /// True if this template specialization type matches a current
7312 /// instantiation in the context in which it is found.
7313 bool isCurrentInstantiation() const {
7314 return isa<InjectedClassNameType>(getCanonicalTypeInternal());
7315 }
7316
7317 /// Determine if this template specialization type is for a type alias
7318 /// template that has been substituted.
7319 ///
7320 /// Nearly every template specialization type whose template is an alias
7321 /// template will be substituted. However, this is not the case when
7322 /// the specialization contains a pack expansion but the template alias
7323 /// does not have a corresponding parameter pack, e.g.,
7324 ///
7325 /// \code
7326 /// template<typename T, typename U, typename V> struct S;
7327 /// template<typename T, typename U> using A = S<T, int, U>;
7328 /// template<typename... Ts> struct X {
7329 /// typedef A<Ts...> type; // not a type alias
7330 /// };
7331 /// \endcode
7332 bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }
7333
7334 /// Get the aliased type, if this is a specialization of a type alias
7335 /// template.
7336 QualType getAliasedType() const;
7337
7338 /// Retrieve the name of the template that we are specializing.
7339 TemplateName getTemplateName() const { return Template; }
7340
7341 ArrayRef<TemplateArgument> template_arguments() const {
7342 return {reinterpret_cast<const TemplateArgument *>(this + 1),
7343 TemplateSpecializationTypeBits.NumArgs};
7344 }
7345
7346 bool isSugared() const;
7347
7348 QualType desugar() const {
7349 return isTypeAlias() ? getAliasedType() : getCanonicalTypeInternal();
7350 }
7351
7352 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
7353 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
7354 TemplateName T, ArrayRef<TemplateArgument> Args,
7355 QualType Underlying, const ASTContext &Context);
7356
7357 static bool classof(const Type *T) {
7359 }
7360};
7361
7362/// Print a template argument list, including the '<' and '>'
7363/// enclosing the template arguments.
7364void printTemplateArgumentList(raw_ostream &OS,
7365 ArrayRef<TemplateArgument> Args,
7366 const PrintingPolicy &Policy,
7367 const TemplateParameterList *TPL = nullptr);
7368
7369void printTemplateArgumentList(raw_ostream &OS,
7370 ArrayRef<TemplateArgumentLoc> Args,
7371 const PrintingPolicy &Policy,
7372 const TemplateParameterList *TPL = nullptr);
7373
7374void printTemplateArgumentList(raw_ostream &OS,
7375 const TemplateArgumentListInfo &Args,
7376 const PrintingPolicy &Policy,
7377 const TemplateParameterList *TPL = nullptr);
7378
7379/// Make a best-effort determination of whether the type T can be produced by
7380/// substituting Args into the default argument of Param.
7381bool isSubstitutedDefaultArgument(ASTContext &Ctx, TemplateArgument Arg,
7382 const NamedDecl *Param,
7383 ArrayRef<TemplateArgument> Args,
7384 unsigned Depth);
7385
7386/// Represents a qualified type name for which the type name is
7387/// dependent.
7388///
7389/// DependentNameType represents a class of dependent types that involve a
7390/// possibly dependent nested-name-specifier (e.g., "T::") followed by a
7391/// name of a type. The DependentNameType may start with a "typename" (for a
7392/// typename-specifier), "class", "struct", "union", or "enum" (for a
7393/// dependent elaborated-type-specifier), or nothing (in contexts where we
7394/// know that we must be referring to a type, e.g., in a base class specifier).
7395/// Typically the nested-name-specifier is dependent, but in MSVC compatibility
7396/// mode, this type is used with non-dependent names to delay name lookup until
7397/// instantiation.
7398class DependentNameType : public TypeWithKeyword, public llvm::FoldingSetNode {
7399 friend class ASTContext; // ASTContext creates these
7400
7401 /// The nested name specifier containing the qualifier.
7402 NestedNameSpecifier NNS;
7403
7404 /// The type that this typename specifier refers to.
7405 const IdentifierInfo *Name;
7406
7407 DependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier NNS,
7408 const IdentifierInfo *Name, QualType CanonType)
7409 : TypeWithKeyword(Keyword, DependentName, CanonType,
7410 TypeDependence::DependentInstantiation |
7411 (NNS ? toTypeDependence(NNS.getDependence())
7413 NNS(NNS), Name(Name) {
7414 assert(Name);
7415 }
7416
7417public:
7418 /// Retrieve the qualification on this type.
7419 NestedNameSpecifier getQualifier() const { return NNS; }
7420
7421 /// Retrieve the identifier that terminates this type name.
7422 /// For example, "type" in "typename T::type".
7423 const IdentifierInfo *getIdentifier() const {
7424 return Name;
7425 }
7426
7427 bool isSugared() const { return false; }
7428 QualType desugar() const { return QualType(this, 0); }
7429
7430 void Profile(llvm::FoldingSetNodeID &ID) {
7431 Profile(ID, getKeyword(), NNS, Name);
7432 }
7433
7434 static void Profile(llvm::FoldingSetNodeID &ID, ElaboratedTypeKeyword Keyword,
7435 NestedNameSpecifier NNS, const IdentifierInfo *Name) {
7436 ID.AddInteger(llvm::to_underlying(Keyword));
7437 NNS.Profile(ID);
7438 ID.AddPointer(Name);
7439 }
7440
7441 static bool classof(const Type *T) {
7442 return T->getTypeClass() == DependentName;
7443 }
7444};
7445
7446/// Represents a pack expansion of types.
7447///
7448/// Pack expansions are part of C++11 variadic templates. A pack
7449/// expansion contains a pattern, which itself contains one or more
7450/// "unexpanded" parameter packs. When instantiated, a pack expansion
7451/// produces a series of types, each instantiated from the pattern of
7452/// the expansion, where the Ith instantiation of the pattern uses the
7453/// Ith arguments bound to each of the unexpanded parameter packs. The
7454/// pack expansion is considered to "expand" these unexpanded
7455/// parameter packs.
7456///
7457/// \code
7458/// template<typename ...Types> struct tuple;
7459///
7460/// template<typename ...Types>
7461/// struct tuple_of_references {
7462/// typedef tuple<Types&...> type;
7463/// };
7464/// \endcode
7465///
7466/// Here, the pack expansion \c Types&... is represented via a
7467/// PackExpansionType whose pattern is Types&.
7468class PackExpansionType : public Type, public llvm::FoldingSetNode {
7469 friend class ASTContext; // ASTContext creates these
7470
7471 /// The pattern of the pack expansion.
7472 QualType Pattern;
7473
7474 PackExpansionType(QualType Pattern, QualType Canon,
7475 UnsignedOrNone NumExpansions)
7476 : Type(PackExpansion, Canon,
7477 (Pattern->getDependence() | TypeDependence::Dependent |
7478 TypeDependence::Instantiation) &
7479 ~TypeDependence::UnexpandedPack),
7480 Pattern(Pattern) {
7481 PackExpansionTypeBits.NumExpansions =
7482 NumExpansions ? *NumExpansions + 1 : 0;
7483 }
7484
7485public:
7486 /// Retrieve the pattern of this pack expansion, which is the
7487 /// type that will be repeatedly instantiated when instantiating the
7488 /// pack expansion itself.
7489 QualType getPattern() const { return Pattern; }
7490
7491 /// Retrieve the number of expansions that this pack expansion will
7492 /// generate, if known.
7493 UnsignedOrNone getNumExpansions() const {
7494 if (PackExpansionTypeBits.NumExpansions)
7495 return PackExpansionTypeBits.NumExpansions - 1;
7496 return std::nullopt;
7497 }
7498
7499 bool isSugared() const { return false; }
7500 QualType desugar() const { return QualType(this, 0); }
7501
7502 void Profile(llvm::FoldingSetNodeID &ID) {
7503 Profile(ID, getPattern(), getNumExpansions());
7504 }
7505
7506 static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern,
7507 UnsignedOrNone NumExpansions) {
7508 ID.AddPointer(Pattern.getAsOpaquePtr());
7509 ID.AddInteger(NumExpansions.toInternalRepresentation());
7510 }
7511
7512 static bool classof(const Type *T) {
7513 return T->getTypeClass() == PackExpansion;
7514 }
7515};
7516
7517/// This class wraps the list of protocol qualifiers. For types that can
7518/// take ObjC protocol qualifers, they can subclass this class.
7519template <class T>
7520class ObjCProtocolQualifiers {
7521protected:
7522 ObjCProtocolQualifiers() = default;
7523
7524 ObjCProtocolDecl * const *getProtocolStorage() const {
7525 return const_cast<ObjCProtocolQualifiers*>(this)->getProtocolStorage();
7526 }
7527
7528 ObjCProtocolDecl **getProtocolStorage() {
7529 return static_cast<T*>(this)->getProtocolStorageImpl();
7530 }
7531
7532 void setNumProtocols(unsigned N) {
7533 static_cast<T*>(this)->setNumProtocolsImpl(N);
7534 }
7535
7536 void initialize(ArrayRef<ObjCProtocolDecl *> protocols) {
7537 setNumProtocols(protocols.size());
7538 assert(getNumProtocols() == protocols.size() &&
7539 "bitfield overflow in protocol count");
7540 if (!protocols.empty())
7541 memcpy(getProtocolStorage(), protocols.data(),
7542 protocols.size() * sizeof(ObjCProtocolDecl*));
7543 }
7544
7545public:
7546 using qual_iterator = ObjCProtocolDecl * const *;
7547 using qual_range = llvm::iterator_range<qual_iterator>;
7548
7549 qual_range quals() const { return qual_range(qual_begin(), qual_end()); }
7550 qual_iterator qual_begin() const { return getProtocolStorage(); }
7551 qual_iterator qual_end() const { return qual_begin() + getNumProtocols(); }
7552
7553 bool qual_empty() const { return getNumProtocols() == 0; }
7554
7555 /// Return the number of qualifying protocols in this type, or 0 if
7556 /// there are none.
7557 unsigned getNumProtocols() const {
7558 return static_cast<const T*>(this)->getNumProtocolsImpl();
7559 }
7560
7561 /// Fetch a protocol by index.
7562 ObjCProtocolDecl *getProtocol(unsigned I) const {
7563 assert(I < getNumProtocols() && "Out-of-range protocol access");
7564 return qual_begin()[I];
7565 }
7566
7567 /// Retrieve all of the protocol qualifiers.
7568 ArrayRef<ObjCProtocolDecl *> getProtocols() const {
7569 return ArrayRef<ObjCProtocolDecl *>(qual_begin(), getNumProtocols());
7570 }
7571};
7572
7573/// Represents a type parameter type in Objective C. It can take
7574/// a list of protocols.
7575class ObjCTypeParamType : public Type,
7576 public ObjCProtocolQualifiers<ObjCTypeParamType>,
7577 public llvm::FoldingSetNode {
7578 friend class ASTContext;
7579 friend class ObjCProtocolQualifiers<ObjCTypeParamType>;
7580
7581 /// The number of protocols stored on this type.
7582 unsigned NumProtocols : 6;
7583
7584 ObjCTypeParamDecl *OTPDecl;
7585
7586 /// The protocols are stored after the ObjCTypeParamType node. In the
7587 /// canonical type, the list of protocols are sorted alphabetically
7588 /// and uniqued.
7589 ObjCProtocolDecl **getProtocolStorageImpl();
7590
7591 /// Return the number of qualifying protocols in this interface type,
7592 /// or 0 if there are none.
7593 unsigned getNumProtocolsImpl() const {
7594 return NumProtocols;
7595 }
7596
7597 void setNumProtocolsImpl(unsigned N) {
7598 NumProtocols = N;
7599 }
7600
7601 ObjCTypeParamType(const ObjCTypeParamDecl *D,
7602 QualType can,
7603 ArrayRef<ObjCProtocolDecl *> protocols);
7604
7605public:
7606 bool isSugared() const { return true; }
7607 QualType desugar() const { return getCanonicalTypeInternal(); }
7608
7609 static bool classof(const Type *T) {
7610 return T->getTypeClass() == ObjCTypeParam;
7611 }
7612
7613 void Profile(llvm::FoldingSetNodeID &ID);
7614 static void Profile(llvm::FoldingSetNodeID &ID,
7615 const ObjCTypeParamDecl *OTPDecl,
7616 QualType CanonicalType,
7617 ArrayRef<ObjCProtocolDecl *> protocols);
7618
7619 ObjCTypeParamDecl *getDecl() const { return OTPDecl; }
7620};
7621
7622/// Represents a class type in Objective C.
7623///
7624/// Every Objective C type is a combination of a base type, a set of
7625/// type arguments (optional, for parameterized classes) and a list of
7626/// protocols.
7627///
7628/// Given the following declarations:
7629/// \code
7630/// \@class C<T>;
7631/// \@protocol P;
7632/// \endcode
7633///
7634/// 'C' is an ObjCInterfaceType C. It is sugar for an ObjCObjectType
7635/// with base C and no protocols.
7636///
7637/// 'C<P>' is an unspecialized ObjCObjectType with base C and protocol list [P].
7638/// 'C<C*>' is a specialized ObjCObjectType with type arguments 'C*' and no
7639/// protocol list.
7640/// 'C<C*><P>' is a specialized ObjCObjectType with base C, type arguments 'C*',
7641/// and protocol list [P].
7642///
7643/// 'id' is a TypedefType which is sugar for an ObjCObjectPointerType whose
7644/// pointee is an ObjCObjectType with base BuiltinType::ObjCIdType
7645/// and no protocols.
7646///
7647/// 'id<P>' is an ObjCObjectPointerType whose pointee is an ObjCObjectType
7648/// with base BuiltinType::ObjCIdType and protocol list [P]. Eventually
7649/// this should get its own sugar class to better represent the source.
7650class ObjCObjectType : public Type,
7651 public ObjCProtocolQualifiers<ObjCObjectType> {
7652 friend class ObjCProtocolQualifiers<ObjCObjectType>;
7653
7654 // ObjCObjectType.NumTypeArgs - the number of type arguments stored
7655 // after the ObjCObjectPointerType node.
7656 // ObjCObjectType.NumProtocols - the number of protocols stored
7657 // after the type arguments of ObjCObjectPointerType node.
7658 //
7659 // These protocols are those written directly on the type. If
7660 // protocol qualifiers ever become additive, the iterators will need
7661 // to get kindof complicated.
7662 //
7663 // In the canonical object type, these are sorted alphabetically
7664 // and uniqued.
7665
7666 /// Either a BuiltinType or an InterfaceType or sugar for either.
7667 QualType BaseType;
7668
7669 /// Cached superclass type.
7670 mutable llvm::PointerIntPair<const ObjCObjectType *, 1, bool>
7671 CachedSuperClassType;
7672
7673 QualType *getTypeArgStorage();
7674 const QualType *getTypeArgStorage() const {
7675 return const_cast<ObjCObjectType *>(this)->getTypeArgStorage();
7676 }
7677
7678 ObjCProtocolDecl **getProtocolStorageImpl();
7679 /// Return the number of qualifying protocols in this interface type,
7680 /// or 0 if there are none.
7681 unsigned getNumProtocolsImpl() const {
7682 return ObjCObjectTypeBits.NumProtocols;
7683 }
7684 void setNumProtocolsImpl(unsigned N) {
7685 ObjCObjectTypeBits.NumProtocols = N;
7686 }
7687
7688protected:
7689 enum Nonce_ObjCInterface { Nonce_ObjCInterface };
7690
7691 ObjCObjectType(QualType Canonical, QualType Base,
7692 ArrayRef<QualType> typeArgs,
7693 ArrayRef<ObjCProtocolDecl *> protocols,
7694 bool isKindOf);
7695
7696 ObjCObjectType(enum Nonce_ObjCInterface)
7697 : Type(ObjCInterface, QualType(), TypeDependence::None),
7698 BaseType(QualType(this_(), 0)) {
7699 ObjCObjectTypeBits.NumProtocols = 0;
7700 ObjCObjectTypeBits.NumTypeArgs = 0;
7701 ObjCObjectTypeBits.IsKindOf = 0;
7702 }
7703
7704 void computeSuperClassTypeSlow() const;
7705
7706public:
7707 /// Gets the base type of this object type. This is always (possibly
7708 /// sugar for) one of:
7709 /// - the 'id' builtin type (as opposed to the 'id' type visible to the
7710 /// user, which is a typedef for an ObjCObjectPointerType)
7711 /// - the 'Class' builtin type (same caveat)
7712 /// - an ObjCObjectType (currently always an ObjCInterfaceType)
7713 QualType getBaseType() const { return BaseType; }
7714
7715 bool isObjCId() const {
7716 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCId);
7717 }
7718
7719 bool isObjCClass() const {
7720 return getBaseType()->isSpecificBuiltinType(BuiltinType::ObjCClass);
7721 }
7722
7723 bool isObjCUnqualifiedId() const { return qual_empty() && isObjCId(); }
7724 bool isObjCUnqualifiedClass() const { return qual_empty() && isObjCClass(); }
7725 bool isObjCUnqualifiedIdOrClass() const {
7726 if (!qual_empty()) return false;
7727 if (const BuiltinType *T = getBaseType()->getAs<BuiltinType>())
7728 return T->getKind() == BuiltinType::ObjCId ||
7729 T->getKind() == BuiltinType::ObjCClass;
7730 return false;
7731 }
7732 bool isObjCQualifiedId() const { return !qual_empty() && isObjCId(); }
7733 bool isObjCQualifiedClass() const { return !qual_empty() && isObjCClass(); }
7734
7735 /// Gets the interface declaration for this object type, if the base type
7736 /// really is an interface.
7737 ObjCInterfaceDecl *getInterface() const;
7738
7739 /// Determine whether this object type is "specialized", meaning
7740 /// that it has type arguments.
7741 bool isSpecialized() const;
7742
7743 /// Determine whether this object type was written with type arguments.
7744 bool isSpecializedAsWritten() const {
7745 return ObjCObjectTypeBits.NumTypeArgs > 0;
7746 }
7747
7748 /// Determine whether this object type is "unspecialized", meaning
7749 /// that it has no type arguments.
7750 bool isUnspecialized() const { return !isSpecialized(); }
7751
7752 /// Determine whether this object type is "unspecialized" as
7753 /// written, meaning that it has no type arguments.
7754 bool isUnspecializedAsWritten() const { return !isSpecializedAsWritten(); }
7755
7756 /// Retrieve the type arguments of this object type (semantically).
7757 ArrayRef<QualType> getTypeArgs() const;
7758
7759 /// Retrieve the type arguments of this object type as they were
7760 /// written.
7761 ArrayRef<QualType> getTypeArgsAsWritten() const {
7762 return {getTypeArgStorage(), ObjCObjectTypeBits.NumTypeArgs};
7763 }
7764
7765 /// Whether this is a "__kindof" type as written.
7766 bool isKindOfTypeAsWritten() const { return ObjCObjectTypeBits.IsKindOf; }
7767
7768 /// Whether this ia a "__kindof" type (semantically).
7769 bool isKindOfType() const;
7770
7771 /// Retrieve the type of the superclass of this object type.
7772 ///
7773 /// This operation substitutes any type arguments into the
7774 /// superclass of the current class type, potentially producing a
7775 /// specialization of the superclass type. Produces a null type if
7776 /// there is no superclass.
7777 QualType getSuperClassType() const {
7778 if (!CachedSuperClassType.getInt())
7779 computeSuperClassTypeSlow();
7780
7781 assert(CachedSuperClassType.getInt() && "Superclass not set?");
7782 return QualType(CachedSuperClassType.getPointer(), 0);
7783 }
7784
7785 /// Strip off the Objective-C "kindof" type and (with it) any
7786 /// protocol qualifiers.
7787 QualType stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const;
7788
7789 bool isSugared() const { return false; }
7790 QualType desugar() const { return QualType(this, 0); }
7791
7792 static bool classof(const Type *T) {
7793 return T->getTypeClass() == ObjCObject ||
7794 T->getTypeClass() == ObjCInterface;
7795 }
7796};
7797
7798/// A class providing a concrete implementation
7799/// of ObjCObjectType, so as to not increase the footprint of
7800/// ObjCInterfaceType. Code outside of ASTContext and the core type
7801/// system should not reference this type.
7802class ObjCObjectTypeImpl : public ObjCObjectType, public llvm::FoldingSetNode {
7803 friend class ASTContext;
7804
7805 // If anyone adds fields here, ObjCObjectType::getProtocolStorage()
7806 // will need to be modified.
7807
7808 ObjCObjectTypeImpl(QualType Canonical, QualType Base,
7809 ArrayRef<QualType> typeArgs,
7810 ArrayRef<ObjCProtocolDecl *> protocols,
7811 bool isKindOf)
7812 : ObjCObjectType(Canonical, Base, typeArgs, protocols, isKindOf) {}
7813
7814public:
7815 void Profile(llvm::FoldingSetNodeID &ID);
7816 static void Profile(llvm::FoldingSetNodeID &ID,
7817 QualType Base,
7818 ArrayRef<QualType> typeArgs,
7819 ArrayRef<ObjCProtocolDecl *> protocols,
7820 bool isKindOf);
7821};
7822
7823inline QualType *ObjCObjectType::getTypeArgStorage() {
7824 return reinterpret_cast<QualType *>(static_cast<ObjCObjectTypeImpl*>(this)+1);
7825}
7826
7827inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorageImpl() {
7828 return reinterpret_cast<ObjCProtocolDecl**>(
7829 getTypeArgStorage() + ObjCObjectTypeBits.NumTypeArgs);
7830}
7831
7832inline ObjCProtocolDecl **ObjCTypeParamType::getProtocolStorageImpl() {
7833 return reinterpret_cast<ObjCProtocolDecl**>(
7834 static_cast<ObjCTypeParamType*>(this)+1);
7835}
7836
7837/// Interfaces are the core concept in Objective-C for object oriented design.
7838/// They basically correspond to C++ classes. There are two kinds of interface
7839/// types: normal interfaces like `NSString`, and qualified interfaces, which
7840/// are qualified with a protocol list like `NSString<NSCopyable, NSAmazing>`.
7841///
7842/// ObjCInterfaceType guarantees the following properties when considered
7843/// as a subtype of its superclass, ObjCObjectType:
7844/// - There are no protocol qualifiers. To reinforce this, code which
7845/// tries to invoke the protocol methods via an ObjCInterfaceType will
7846/// fail to compile.
7847/// - It is its own base type. That is, if T is an ObjCInterfaceType*,
7848/// T->getBaseType() == QualType(T, 0).
7849class ObjCInterfaceType : public ObjCObjectType {
7850 friend class ASTContext; // ASTContext creates these.
7851 friend class ASTReader;
7852 template <class T> friend class serialization::AbstractTypeReader;
7853
7854 ObjCInterfaceDecl *Decl;
7855
7856 ObjCInterfaceType(const ObjCInterfaceDecl *D)
7857 : ObjCObjectType(Nonce_ObjCInterface),
7858 Decl(const_cast<ObjCInterfaceDecl*>(D)) {}
7859
7860public:
7861 /// Get the declaration of this interface.
7862 ObjCInterfaceDecl *getDecl() const;
7863
7864 bool isSugared() const { return false; }
7865 QualType desugar() const { return QualType(this, 0); }
7866
7867 static bool classof(const Type *T) {
7868 return T->getTypeClass() == ObjCInterface;
7869 }
7870
7871 // Nonsense to "hide" certain members of ObjCObjectType within this
7872 // class. People asking for protocols on an ObjCInterfaceType are
7873 // not going to get what they want: ObjCInterfaceTypes are
7874 // guaranteed to have no protocols.
7875 enum {
7881 };
7882};
7883
7884inline ObjCInterfaceDecl *ObjCObjectType::getInterface() const {
7885 QualType baseType = getBaseType();
7886 while (const auto *ObjT = baseType->getAs<ObjCObjectType>()) {
7887 if (const auto *T = dyn_cast<ObjCInterfaceType>(ObjT))
7888 return T->getDecl();
7889
7890 baseType = ObjT->getBaseType();
7891 }
7892
7893 return nullptr;
7894}
7895
7896/// Represents a pointer to an Objective C object.
7897///
7898/// These are constructed from pointer declarators when the pointee type is
7899/// an ObjCObjectType (or sugar for one). In addition, the 'id' and 'Class'
7900/// types are typedefs for these, and the protocol-qualified types 'id<P>'
7901/// and 'Class<P>' are translated into these.
7902///
7903/// Pointers to pointers to Objective C objects are still PointerTypes;
7904/// only the first level of pointer gets it own type implementation.
7905class ObjCObjectPointerType : public Type, public llvm::FoldingSetNode {
7906 friend class ASTContext; // ASTContext creates these.
7907
7908 QualType PointeeType;
7909
7910 ObjCObjectPointerType(QualType Canonical, QualType Pointee)
7911 : Type(ObjCObjectPointer, Canonical, Pointee->getDependence()),
7912 PointeeType(Pointee) {}
7913
7914public:
7915 /// Gets the type pointed to by this ObjC pointer.
7916 /// The result will always be an ObjCObjectType or sugar thereof.
7917 QualType getPointeeType() const { return PointeeType; }
7918
7919 /// Gets the type pointed to by this ObjC pointer. Always returns non-null.
7920 ///
7921 /// This method is equivalent to getPointeeType() except that
7922 /// it discards any typedefs (or other sugar) between this
7923 /// type and the "outermost" object type. So for:
7924 /// \code
7925 /// \@class A; \@protocol P; \@protocol Q;
7926 /// typedef A<P> AP;
7927 /// typedef A A1;
7928 /// typedef A1<P> A1P;
7929 /// typedef A1P<Q> A1PQ;
7930 /// \endcode
7931 /// For 'A*', getObjectType() will return 'A'.
7932 /// For 'A<P>*', getObjectType() will return 'A<P>'.
7933 /// For 'AP*', getObjectType() will return 'A<P>'.
7934 /// For 'A1*', getObjectType() will return 'A'.
7935 /// For 'A1<P>*', getObjectType() will return 'A1<P>'.
7936 /// For 'A1P*', getObjectType() will return 'A1<P>'.
7937 /// For 'A1PQ*', getObjectType() will return 'A1<Q>', because
7938 /// adding protocols to a protocol-qualified base discards the
7939 /// old qualifiers (for now). But if it didn't, getObjectType()
7940 /// would return 'A1P<Q>' (and we'd have to make iterating over
7941 /// qualifiers more complicated).
7943 return PointeeType->castAs<ObjCObjectType>();
7944 }
7945
7946 /// If this pointer points to an Objective C
7947 /// \@interface type, gets the type for that interface. Any protocol
7948 /// qualifiers on the interface are ignored.
7949 ///
7950 /// \return null if the base type for this pointer is 'id' or 'Class'
7951 const ObjCInterfaceType *getInterfaceType() const;
7952
7953 /// If this pointer points to an Objective \@interface
7954 /// type, gets the declaration for that interface.
7955 ///
7956 /// \return null if the base type for this pointer is 'id' or 'Class'
7958 return getObjectType()->getInterface();
7959 }
7960
7961 /// True if this is equivalent to the 'id' type, i.e. if
7962 /// its object type is the primitive 'id' type with no protocols.
7963 bool isObjCIdType() const {
7964 return getObjectType()->isObjCUnqualifiedId();
7965 }
7966
7967 /// True if this is equivalent to the 'Class' type,
7968 /// i.e. if its object tive is the primitive 'Class' type with no protocols.
7969 bool isObjCClassType() const {
7970 return getObjectType()->isObjCUnqualifiedClass();
7971 }
7972
7973 /// True if this is equivalent to the 'id' or 'Class' type,
7974 bool isObjCIdOrClassType() const {
7975 return getObjectType()->isObjCUnqualifiedIdOrClass();
7976 }
7977
7978 /// True if this is equivalent to 'id<P>' for some non-empty set of
7979 /// protocols.
7981 return getObjectType()->isObjCQualifiedId();
7982 }
7983
7984 /// True if this is equivalent to 'Class<P>' for some non-empty set of
7985 /// protocols.
7987 return getObjectType()->isObjCQualifiedClass();
7988 }
7989
7990 /// Whether this is a "__kindof" type.
7991 bool isKindOfType() const { return getObjectType()->isKindOfType(); }
7992
7993 /// Whether this type is specialized, meaning that it has type arguments.
7994 bool isSpecialized() const { return getObjectType()->isSpecialized(); }
7995
7996 /// Whether this type is specialized, meaning that it has type arguments.
7998 return getObjectType()->isSpecializedAsWritten();
7999 }
8000
8001 /// Whether this type is unspecialized, meaning that is has no type arguments.
8002 bool isUnspecialized() const { return getObjectType()->isUnspecialized(); }
8003
8004 /// Determine whether this object type is "unspecialized" as
8005 /// written, meaning that it has no type arguments.
8007
8008 /// Retrieve the type arguments for this type.
8010 return getObjectType()->getTypeArgs();
8011 }
8012
8013 /// Retrieve the type arguments for this type.
8015 return getObjectType()->getTypeArgsAsWritten();
8016 }
8017
8018 /// An iterator over the qualifiers on the object type. Provided
8019 /// for convenience. This will always iterate over the full set of
8020 /// protocols on a type, not just those provided directly.
8021 using qual_iterator = ObjCObjectType::qual_iterator;
8022 using qual_range = llvm::iterator_range<qual_iterator>;
8023
8025
8027 return getObjectType()->qual_begin();
8028 }
8029
8031 return getObjectType()->qual_end();
8032 }
8033
8034 bool qual_empty() const { return getObjectType()->qual_empty(); }
8035
8036 /// Return the number of qualifying protocols on the object type.
8037 unsigned getNumProtocols() const {
8038 return getObjectType()->getNumProtocols();
8039 }
8040
8041 /// Retrieve a qualifying protocol by index on the object type.
8042 ObjCProtocolDecl *getProtocol(unsigned I) const {
8043 return getObjectType()->getProtocol(I);
8044 }
8045
8046 bool isSugared() const { return false; }
8047 QualType desugar() const { return QualType(this, 0); }
8048
8049 /// Retrieve the type of the superclass of this object pointer type.
8050 ///
8051 /// This operation substitutes any type arguments into the
8052 /// superclass of the current class type, potentially producing a
8053 /// pointer to a specialization of the superclass type. Produces a
8054 /// null type if there is no superclass.
8055 QualType getSuperClassType() const;
8056
8057 /// Strip off the Objective-C "kindof" type and (with it) any
8058 /// protocol qualifiers.
8059 const ObjCObjectPointerType *stripObjCKindOfTypeAndQuals(
8060 const ASTContext &ctx) const;
8061
8062 void Profile(llvm::FoldingSetNodeID &ID) {
8063 Profile(ID, getPointeeType());
8064 }
8065
8066 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
8067 ID.AddPointer(T.getAsOpaquePtr());
8068 }
8069
8070 static bool classof(const Type *T) {
8071 return T->getTypeClass() == ObjCObjectPointer;
8072 }
8073};
8074
8075class AtomicType : public Type, public llvm::FoldingSetNode {
8076 friend class ASTContext; // ASTContext creates these.
8077
8078 QualType ValueType;
8079
8080 AtomicType(QualType ValTy, QualType Canonical)
8081 : Type(Atomic, Canonical, ValTy->getDependence()), ValueType(ValTy) {}
8082
8083public:
8084 /// Gets the type contained by this atomic type, i.e.
8085 /// the type returned by performing an atomic load of this atomic type.
8086 QualType getValueType() const { return ValueType; }
8087
8088 bool isSugared() const { return false; }
8089 QualType desugar() const { return QualType(this, 0); }
8090
8091 void Profile(llvm::FoldingSetNodeID &ID) {
8092 Profile(ID, getValueType());
8093 }
8094
8095 static void Profile(llvm::FoldingSetNodeID &ID, QualType T) {
8096 ID.AddPointer(T.getAsOpaquePtr());
8097 }
8098
8099 static bool classof(const Type *T) {
8100 return T->getTypeClass() == Atomic;
8101 }
8102};
8103
8104/// PipeType - OpenCL20.
8105class PipeType : public Type, public llvm::FoldingSetNode {
8106 friend class ASTContext; // ASTContext creates these.
8107
8108 QualType ElementType;
8109 bool isRead;
8110
8111 PipeType(QualType elemType, QualType CanonicalPtr, bool isRead)
8112 : Type(Pipe, CanonicalPtr, elemType->getDependence()),
8113 ElementType(elemType), isRead(isRead) {}
8114
8115public:
8116 QualType getElementType() const { return ElementType; }
8117
8118 bool isSugared() const { return false; }
8119
8120 QualType desugar() const { return QualType(this, 0); }
8121
8122 void Profile(llvm::FoldingSetNodeID &ID) {
8124 }
8125
8126 static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead) {
8127 ID.AddPointer(T.getAsOpaquePtr());
8128 ID.AddBoolean(isRead);
8129 }
8130
8131 static bool classof(const Type *T) {
8132 return T->getTypeClass() == Pipe;
8133 }
8134
8135 bool isReadOnly() const { return isRead; }
8136};
8137
8138/// A fixed int type of a specified bitwidth.
8139class BitIntType final : public Type, public llvm::FoldingSetNode {
8140 friend class ASTContext;
8141 LLVM_PREFERRED_TYPE(bool)
8142 unsigned IsUnsigned : 1;
8143 unsigned NumBits : 24;
8144
8145protected:
8146 BitIntType(bool isUnsigned, unsigned NumBits);
8147
8148public:
8149 bool isUnsigned() const { return IsUnsigned; }
8150 bool isSigned() const { return !IsUnsigned; }
8151 unsigned getNumBits() const { return NumBits; }
8152
8153 bool isSugared() const { return false; }
8154 QualType desugar() const { return QualType(this, 0); }
8155
8156 void Profile(llvm::FoldingSetNodeID &ID) const {
8157 Profile(ID, isUnsigned(), getNumBits());
8158 }
8159
8160 static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned,
8161 unsigned NumBits) {
8162 ID.AddBoolean(IsUnsigned);
8163 ID.AddInteger(NumBits);
8164 }
8165
8166 static bool classof(const Type *T) { return T->getTypeClass() == BitInt; }
8167};
8168
8169class DependentBitIntType final : public Type, public llvm::FoldingSetNode {
8170 friend class ASTContext;
8171 llvm::PointerIntPair<Expr*, 1, bool> ExprAndUnsigned;
8172
8173protected:
8174 DependentBitIntType(bool IsUnsigned, Expr *NumBits);
8175
8176public:
8177 bool isUnsigned() const;
8178 bool isSigned() const { return !isUnsigned(); }
8179 Expr *getNumBitsExpr() const;
8180
8181 bool isSugared() const { return false; }
8182 QualType desugar() const { return QualType(this, 0); }
8183
8184 void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
8185 Profile(ID, Context, isUnsigned(), getNumBitsExpr());
8186 }
8187 static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
8188 bool IsUnsigned, Expr *NumBitsExpr);
8189
8190 static bool classof(const Type *T) {
8191 return T->getTypeClass() == DependentBitInt;
8192 }
8193};
8194
8195class PredefinedSugarType final : public Type {
8196public:
8197 friend class ASTContext;
8199
8200private:
8201 PredefinedSugarType(Kind KD, const IdentifierInfo *IdentName,
8202 QualType CanonicalType)
8203 : Type(PredefinedSugar, CanonicalType, TypeDependence::None),
8204 Name(IdentName) {
8205 PredefinedSugarTypeBits.Kind = llvm::to_underlying(KD);
8206 }
8207
8208 static StringRef getName(Kind KD);
8209
8210 const IdentifierInfo *Name;
8211
8212public:
8213 bool isSugared() const { return true; }
8214
8216
8217 Kind getKind() const { return Kind(PredefinedSugarTypeBits.Kind); }
8218
8219 const IdentifierInfo *getIdentifier() const { return Name; }
8220
8221 static bool classof(const Type *T) {
8222 return T->getTypeClass() == PredefinedSugar;
8223 }
8224};
8225
8226/// A qualifier set is used to build a set of qualifiers.
8228public:
8230
8231 /// Collect any qualifiers on the given type and return an
8232 /// unqualified type. The qualifiers are assumed to be consistent
8233 /// with those already in the type.
8235 addFastQualifiers(type.getLocalFastQualifiers());
8236 if (!type.hasLocalNonFastQualifiers())
8237 return type.getTypePtrUnsafe();
8238
8239 const ExtQuals *extQuals = type.getExtQualsUnsafe();
8241 return extQuals->getBaseType();
8242 }
8243
8244 /// Apply the collected qualifiers to the given type.
8245 QualType apply(const ASTContext &Context, QualType QT) const;
8246
8247 /// Apply the collected qualifiers to the given type.
8248 QualType apply(const ASTContext &Context, const Type* T) const;
8249};
8250
8251/// A container of type source information.
8252///
8253/// A client can read the relevant info using TypeLoc wrappers, e.g:
8254/// @code
8255/// TypeLoc TL = TypeSourceInfo->getTypeLoc();
8256/// TL.getBeginLoc().print(OS, SrcMgr);
8257/// @endcode
8258class alignas(8) TypeSourceInfo {
8259 // Contains a memory block after the class, used for type source information,
8260 // allocated by ASTContext.
8261 friend class ASTContext;
8262
8263 QualType Ty;
8264
8265 TypeSourceInfo(QualType ty, size_t DataSize); // implemented in TypeLoc.h
8266
8267public:
8268 /// Return the type wrapped by this type source info.
8269 QualType getType() const { return Ty; }
8270
8271 /// Return the TypeLoc wrapper for the type source info.
8272 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
8273
8274 /// Override the type stored in this TypeSourceInfo. Use with caution!
8275 void overrideType(QualType T) { Ty = T; }
8276};
8277
8278// Inline function definitions.
8279
8281 SplitQualType desugar =
8282 Ty->getLocallyUnqualifiedSingleStepDesugaredType().split();
8284 return desugar;
8285}
8286
8287inline const Type *QualType::getTypePtr() const {
8288 return getCommonPtr()->BaseType;
8289}
8290
8291inline const Type *QualType::getTypePtrOrNull() const {
8292 return (isNull() ? nullptr : getCommonPtr()->BaseType);
8293}
8294
8295inline bool QualType::isReferenceable() const {
8296 // C++ [defns.referenceable]
8297 // type that is either an object type, a function type that does not have
8298 // cv-qualifiers or a ref-qualifier, or a reference type.
8299 const Type &Self = **this;
8300 if (Self.isObjectType() || Self.isReferenceType())
8301 return true;
8302 if (const auto *F = Self.getAs<FunctionProtoType>())
8303 return F->getMethodQuals().empty() && F->getRefQualifier() == RQ_None;
8304
8305 return false;
8306}
8307
8310 return SplitQualType(getTypePtrUnsafe(),
8312
8313 const ExtQuals *eq = getExtQualsUnsafe();
8314 Qualifiers qs = eq->getQualifiers();
8316 return SplitQualType(eq->getBaseType(), qs);
8317}
8318
8320 Qualifiers Quals;
8322 Quals = getExtQualsUnsafe()->getQualifiers();
8324 return Quals;
8325}
8326
8328 Qualifiers quals = getCommonPtr()->CanonicalType.getLocalQualifiers();
8330 return quals;
8331}
8332
8333inline unsigned QualType::getCVRQualifiers() const {
8334 unsigned cvr = getCommonPtr()->CanonicalType.getLocalCVRQualifiers();
8335 cvr |= getLocalCVRQualifiers();
8336 return cvr;
8337}
8338
8340 QualType canon = getCommonPtr()->CanonicalType;
8342}
8343
8344inline bool QualType::isCanonical() const {
8345 return getTypePtr()->isCanonicalUnqualified();
8346}
8347
8348inline bool QualType::isCanonicalAsParam() const {
8349 if (!isCanonical()) return false;
8350 if (hasLocalQualifiers()) return false;
8351
8352 const Type *T = getTypePtr();
8353 if (T->isVariablyModifiedType() && T->hasSizedVLAType())
8354 return false;
8355
8356 return !isa<FunctionType>(T) &&
8358}
8359
8360inline bool QualType::isConstQualified() const {
8361 return isLocalConstQualified() ||
8362 getCommonPtr()->CanonicalType.isLocalConstQualified();
8363}
8364
8366 return isLocalRestrictQualified() ||
8367 getCommonPtr()->CanonicalType.isLocalRestrictQualified();
8368}
8369
8370
8372 return isLocalVolatileQualified() ||
8373 getCommonPtr()->CanonicalType.isLocalVolatileQualified();
8374}
8375
8376inline bool QualType::hasQualifiers() const {
8377 return hasLocalQualifiers() ||
8378 getCommonPtr()->CanonicalType.hasLocalQualifiers();
8379}
8380
8382 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
8383 return QualType(getTypePtr(), 0);
8384
8385 return QualType(getSplitUnqualifiedTypeImpl(*this).Ty, 0);
8386}
8387
8389 if (!getTypePtr()->getCanonicalTypeInternal().hasLocalQualifiers())
8390 return split();
8391
8392 return getSplitUnqualifiedTypeImpl(*this);
8393}
8394
8398
8402
8406
8407/// Check if this type has any address space qualifier.
8408inline bool QualType::hasAddressSpace() const {
8409 return getQualifiers().hasAddressSpace();
8410}
8411
8412/// Return the address space of this type.
8414 return getQualifiers().getAddressSpace();
8415}
8416
8417/// Return the gc attribute of this type.
8419 return getQualifiers().getObjCGCAttr();
8420}
8421
8423 if (const auto *PT = t.getAs<PointerType>()) {
8424 if (const auto *FT = PT->getPointeeType()->getAs<FunctionType>())
8425 return FT->getExtInfo();
8426 } else if (const auto *FT = t.getAs<FunctionType>())
8427 return FT->getExtInfo();
8428
8429 return FunctionType::ExtInfo();
8430}
8431
8435
8436/// Determine whether this type is more
8437/// qualified than the Other type. For example, "const volatile int"
8438/// is more qualified than "const int", "volatile int", and
8439/// "int". However, it is not more qualified than "const volatile
8440/// int".
8442 const ASTContext &Ctx) const {
8443 Qualifiers MyQuals = getQualifiers();
8444 Qualifiers OtherQuals = other.getQualifiers();
8445 return (MyQuals != OtherQuals && MyQuals.compatiblyIncludes(OtherQuals, Ctx));
8446}
8447
8448/// Determine whether this type is at last
8449/// as qualified as the Other type. For example, "const volatile
8450/// int" is at least as qualified as "const int", "volatile int",
8451/// "int", and "const volatile int".
8453 const ASTContext &Ctx) const {
8454 Qualifiers OtherQuals = other.getQualifiers();
8455
8456 // Ignore __unaligned qualifier if this type is a void.
8457 if (getUnqualifiedType()->isVoidType())
8458 OtherQuals.removeUnaligned();
8459
8460 return getQualifiers().compatiblyIncludes(OtherQuals, Ctx);
8461}
8462
8463/// If Type is a reference type (e.g., const
8464/// int&), returns the type that the reference refers to ("const
8465/// int"). Otherwise, returns the type itself. This routine is used
8466/// throughout Sema to implement C++ 5p6:
8467///
8468/// If an expression initially has the type "reference to T" (8.3.2,
8469/// 8.5.3), the type is adjusted to "T" prior to any further
8470/// analysis, the expression designates the object or function
8471/// denoted by the reference, and the expression is an lvalue.
8473 if (const auto *RefType = (*this)->getAs<ReferenceType>())
8474 return RefType->getPointeeType();
8475 else
8476 return *this;
8477}
8478
8480 return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
8481 getTypePtr()->isFunctionType());
8482}
8483
8484/// Tests whether the type is categorized as a fundamental type.
8485///
8486/// \returns True for types specified in C++0x [basic.fundamental].
8487inline bool Type::isFundamentalType() const {
8488 return isVoidType() ||
8489 isNullPtrType() ||
8490 // FIXME: It's really annoying that we don't have an
8491 // 'isArithmeticType()' which agrees with the standard definition.
8493}
8494
8495/// Tests whether the type is categorized as a compound type.
8496///
8497/// \returns True for types specified in C++0x [basic.compound].
8498inline bool Type::isCompoundType() const {
8499 // C++0x [basic.compound]p1:
8500 // Compound types can be constructed in the following ways:
8501 // -- arrays of objects of a given type [...];
8502 return isArrayType() ||
8503 // -- functions, which have parameters of given types [...];
8504 isFunctionType() ||
8505 // -- pointers to void or objects or functions [...];
8506 isPointerType() ||
8507 // -- references to objects or functions of a given type. [...]
8508 isReferenceType() ||
8509 // -- classes containing a sequence of objects of various types, [...];
8510 isRecordType() ||
8511 // -- unions, which are classes capable of containing objects of different
8512 // types at different times;
8513 isUnionType() ||
8514 // -- enumerations, which comprise a set of named constant values. [...];
8515 isEnumeralType() ||
8516 // -- pointers to non-static class members, [...].
8518}
8519
8520inline bool Type::isFunctionType() const {
8521 return isa<FunctionType>(CanonicalType);
8522}
8523
8524inline bool Type::isPointerType() const {
8525 return isa<PointerType>(CanonicalType);
8526}
8527
8529 return isPointerType() || isReferenceType();
8530}
8531
8532inline bool Type::isAnyPointerType() const {
8534}
8535
8536inline bool Type::isSignableType(const ASTContext &Ctx) const {
8538}
8539
8540inline bool Type::isSignablePointerType() const {
8542}
8543
8544inline bool Type::isBlockPointerType() const {
8545 return isa<BlockPointerType>(CanonicalType);
8546}
8547
8548inline bool Type::isReferenceType() const {
8549 return isa<ReferenceType>(CanonicalType);
8550}
8551
8552inline bool Type::isLValueReferenceType() const {
8553 return isa<LValueReferenceType>(CanonicalType);
8554}
8555
8556inline bool Type::isRValueReferenceType() const {
8557 return isa<RValueReferenceType>(CanonicalType);
8558}
8559
8560inline bool Type::isObjectPointerType() const {
8561 // Note: an "object pointer type" is not the same thing as a pointer to an
8562 // object type; rather, it is a pointer to an object type or a pointer to cv
8563 // void.
8564 if (const auto *T = getAs<PointerType>())
8565 return !T->getPointeeType()->isFunctionType();
8566 else
8567 return false;
8568}
8569
8571 if (const auto *Fn = getAs<FunctionProtoType>())
8572 return Fn->hasCFIUncheckedCallee();
8573 return false;
8574}
8575
8577 QualType Pointee;
8578 if (const auto *PT = getAs<PointerType>())
8579 Pointee = PT->getPointeeType();
8580 else if (const auto *RT = getAs<ReferenceType>())
8581 Pointee = RT->getPointeeType();
8582 else if (const auto *MPT = getAs<MemberPointerType>())
8583 Pointee = MPT->getPointeeType();
8584 else if (const auto *DT = getAs<DecayedType>())
8585 Pointee = DT->getPointeeType();
8586 else
8587 return false;
8588 return Pointee->isCFIUncheckedCalleeFunctionType();
8589}
8590
8591inline bool Type::isFunctionPointerType() const {
8592 if (const auto *T = getAs<PointerType>())
8593 return T->getPointeeType()->isFunctionType();
8594 else
8595 return false;
8596}
8597
8599 if (const auto *T = getAs<ReferenceType>())
8600 return T->getPointeeType()->isFunctionType();
8601 else
8602 return false;
8603}
8604
8605inline bool Type::isMemberPointerType() const {
8606 return isa<MemberPointerType>(CanonicalType);
8607}
8608
8610 if (const auto *T = getAs<MemberPointerType>())
8611 return T->isMemberFunctionPointer();
8612 else
8613 return false;
8614}
8615
8617 if (const auto *T = getAs<MemberPointerType>())
8618 return T->isMemberDataPointer();
8619 else
8620 return false;
8621}
8622
8623inline bool Type::isArrayType() const {
8624 return isa<ArrayType>(CanonicalType);
8625}
8626
8627inline bool Type::isConstantArrayType() const {
8628 return isa<ConstantArrayType>(CanonicalType);
8629}
8630
8631inline bool Type::isIncompleteArrayType() const {
8632 return isa<IncompleteArrayType>(CanonicalType);
8633}
8634
8635inline bool Type::isVariableArrayType() const {
8636 return isa<VariableArrayType>(CanonicalType);
8637}
8638
8639inline bool Type::isArrayParameterType() const {
8640 return isa<ArrayParameterType>(CanonicalType);
8641}
8642
8644 return isa<DependentSizedArrayType>(CanonicalType);
8645}
8646
8647inline bool Type::isBuiltinType() const {
8648 return isa<BuiltinType>(CanonicalType);
8649}
8650
8651inline bool Type::isRecordType() const {
8652 return isa<RecordType>(CanonicalType);
8653}
8654
8655inline bool Type::isEnumeralType() const {
8656 return isa<EnumType>(CanonicalType);
8657}
8658
8659inline bool Type::isAnyComplexType() const {
8660 return isa<ComplexType>(CanonicalType);
8661}
8662
8663inline bool Type::isVectorType() const {
8664 return isa<VectorType>(CanonicalType);
8665}
8666
8667inline bool Type::isExtVectorType() const {
8668 return isa<ExtVectorType>(CanonicalType);
8669}
8670
8671inline bool Type::isExtVectorBoolType() const {
8672 if (!isExtVectorType())
8673 return false;
8674 return cast<ExtVectorType>(CanonicalType)->getElementType()->isBooleanType();
8675}
8676
8678 return isVectorType() || isSveVLSBuiltinType();
8679}
8680
8681inline bool Type::isMatrixType() const {
8682 return isa<MatrixType>(CanonicalType);
8683}
8684
8685inline bool Type::isConstantMatrixType() const {
8686 return isa<ConstantMatrixType>(CanonicalType);
8687}
8688
8690 return isa<DependentAddressSpaceType>(CanonicalType);
8691}
8692
8694 return isa<ObjCObjectPointerType>(CanonicalType);
8695}
8696
8697inline bool Type::isObjCObjectType() const {
8698 return isa<ObjCObjectType>(CanonicalType);
8699}
8700
8702 return isa<ObjCInterfaceType>(CanonicalType) ||
8703 isa<ObjCObjectType>(CanonicalType);
8704}
8705
8706inline bool Type::isAtomicType() const {
8707 return isa<AtomicType>(CanonicalType);
8708}
8709
8710inline bool Type::isUndeducedAutoType() const {
8711 return isa<AutoType>(CanonicalType);
8712}
8713
8714inline bool Type::isObjCQualifiedIdType() const {
8715 if (const auto *OPT = getAs<ObjCObjectPointerType>())
8716 return OPT->isObjCQualifiedIdType();
8717 return false;
8718}
8719
8721 if (const auto *OPT = getAs<ObjCObjectPointerType>())
8722 return OPT->isObjCQualifiedClassType();
8723 return false;
8724}
8725
8726inline bool Type::isObjCIdType() const {
8727 if (const auto *OPT = getAs<ObjCObjectPointerType>())
8728 return OPT->isObjCIdType();
8729 return false;
8730}
8731
8732inline bool Type::isObjCClassType() const {
8733 if (const auto *OPT = getAs<ObjCObjectPointerType>())
8734 return OPT->isObjCClassType();
8735 return false;
8736}
8737
8738inline bool Type::isObjCSelType() const {
8739 if (const auto *OPT = getAs<PointerType>())
8740 return OPT->getPointeeType()->isSpecificBuiltinType(BuiltinType::ObjCSel);
8741 return false;
8742}
8743
8744inline bool Type::isObjCBuiltinType() const {
8745 return isObjCIdType() || isObjCClassType() || isObjCSelType();
8746}
8747
8748inline bool Type::isDecltypeType() const {
8749 return isa<DecltypeType>(this);
8750}
8751
8752#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
8753 inline bool Type::is##Id##Type() const { \
8754 return isSpecificBuiltinType(BuiltinType::Id); \
8755 }
8756#include "clang/Basic/OpenCLImageTypes.def"
8757
8758inline bool Type::isSamplerT() const {
8759 return isSpecificBuiltinType(BuiltinType::OCLSampler);
8760}
8761
8762inline bool Type::isEventT() const {
8763 return isSpecificBuiltinType(BuiltinType::OCLEvent);
8764}
8765
8766inline bool Type::isClkEventT() const {
8767 return isSpecificBuiltinType(BuiltinType::OCLClkEvent);
8768}
8769
8770inline bool Type::isQueueT() const {
8771 return isSpecificBuiltinType(BuiltinType::OCLQueue);
8772}
8773
8774inline bool Type::isReserveIDT() const {
8775 return isSpecificBuiltinType(BuiltinType::OCLReserveID);
8776}
8777
8778inline bool Type::isImageType() const {
8779#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) is##Id##Type() ||
8780 return
8781#include "clang/Basic/OpenCLImageTypes.def"
8782 false; // end boolean or operation
8783}
8784
8785inline bool Type::isPipeType() const {
8786 return isa<PipeType>(CanonicalType);
8787}
8788
8789inline bool Type::isBitIntType() const {
8790 return isa<BitIntType>(CanonicalType);
8791}
8792
8793#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
8794 inline bool Type::is##Id##Type() const { \
8795 return isSpecificBuiltinType(BuiltinType::Id); \
8796 }
8797#include "clang/Basic/OpenCLExtensionTypes.def"
8798
8800#define INTEL_SUBGROUP_AVC_TYPE(ExtType, Id) \
8801 isOCLIntelSubgroupAVC##Id##Type() ||
8802 return
8803#include "clang/Basic/OpenCLExtensionTypes.def"
8804 false; // end of boolean or operation
8805}
8806
8807inline bool Type::isOCLExtOpaqueType() const {
8808#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) is##Id##Type() ||
8809 return
8810#include "clang/Basic/OpenCLExtensionTypes.def"
8811 false; // end of boolean or operation
8812}
8813
8814inline bool Type::isOpenCLSpecificType() const {
8815 return isSamplerT() || isEventT() || isImageType() || isClkEventT() ||
8817}
8818
8819#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
8820 inline bool Type::is##Id##Type() const { \
8821 return isSpecificBuiltinType(BuiltinType::Id); \
8822 }
8823#include "clang/Basic/HLSLIntangibleTypes.def"
8824
8826#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) is##Id##Type() ||
8827 return
8828#include "clang/Basic/HLSLIntangibleTypes.def"
8829 false;
8830}
8831
8836
8839}
8840
8841inline bool Type::isHLSLInlineSpirvType() const {
8842 return isa<HLSLInlineSpirvType>(this);
8843}
8844
8845inline bool Type::isTemplateTypeParmType() const {
8846 return isa<TemplateTypeParmType>(CanonicalType);
8847}
8848
8849inline bool Type::isSpecificBuiltinType(unsigned K) const {
8850 if (const BuiltinType *BT = getAs<BuiltinType>()) {
8851 return BT->getKind() == static_cast<BuiltinType::Kind>(K);
8852 }
8853 return false;
8854}
8855
8856inline bool Type::isPlaceholderType() const {
8857 if (const auto *BT = dyn_cast<BuiltinType>(this))
8858 return BT->isPlaceholderType();
8859 return false;
8860}
8861
8863 if (const auto *BT = dyn_cast<BuiltinType>(this))
8864 if (BT->isPlaceholderType())
8865 return BT;
8866 return nullptr;
8867}
8868
8869inline bool Type::isSpecificPlaceholderType(unsigned K) const {
8871 return isSpecificBuiltinType(K);
8872}
8873
8875 if (const auto *BT = dyn_cast<BuiltinType>(this))
8876 return BT->isNonOverloadPlaceholderType();
8877 return false;
8878}
8879
8880inline bool Type::isVoidType() const {
8881 return isSpecificBuiltinType(BuiltinType::Void);
8882}
8883
8884inline bool Type::isHalfType() const {
8885 // FIXME: Should we allow complex __fp16? Probably not.
8886 return isSpecificBuiltinType(BuiltinType::Half);
8887}
8888
8889inline bool Type::isFloat16Type() const {
8890 return isSpecificBuiltinType(BuiltinType::Float16);
8891}
8892
8893inline bool Type::isFloat32Type() const {
8894 return isSpecificBuiltinType(BuiltinType::Float);
8895}
8896
8897inline bool Type::isDoubleType() const {
8898 return isSpecificBuiltinType(BuiltinType::Double);
8899}
8900
8901inline bool Type::isBFloat16Type() const {
8902 return isSpecificBuiltinType(BuiltinType::BFloat16);
8903}
8904
8905inline bool Type::isMFloat8Type() const {
8906 return isSpecificBuiltinType(BuiltinType::MFloat8);
8907}
8908
8909inline bool Type::isFloat128Type() const {
8910 return isSpecificBuiltinType(BuiltinType::Float128);
8911}
8912
8913inline bool Type::isIbm128Type() const {
8914 return isSpecificBuiltinType(BuiltinType::Ibm128);
8915}
8916
8917inline bool Type::isNullPtrType() const {
8918 return isSpecificBuiltinType(BuiltinType::NullPtr);
8919}
8920
8923
8924inline bool Type::isIntegerType() const {
8925 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8926 return BT->isInteger();
8927 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) {
8928 // Incomplete enum types are not treated as integer types.
8929 // FIXME: In C++, enum types are never integer types.
8930 return IsEnumDeclComplete(ET->getOriginalDecl()) &&
8931 !IsEnumDeclScoped(ET->getOriginalDecl());
8932 }
8933 return isBitIntType();
8934}
8935
8936inline bool Type::isFixedPointType() const {
8937 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8938 return BT->getKind() >= BuiltinType::ShortAccum &&
8939 BT->getKind() <= BuiltinType::SatULongFract;
8940 }
8941 return false;
8942}
8943
8945 return isFixedPointType() || isIntegerType();
8946}
8947
8951
8953 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8954 return BT->getKind() >= BuiltinType::SatShortAccum &&
8955 BT->getKind() <= BuiltinType::SatULongFract;
8956 }
8957 return false;
8958}
8959
8963
8964inline bool Type::isSignedFixedPointType() const {
8965 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType)) {
8966 return ((BT->getKind() >= BuiltinType::ShortAccum &&
8967 BT->getKind() <= BuiltinType::LongAccum) ||
8968 (BT->getKind() >= BuiltinType::ShortFract &&
8969 BT->getKind() <= BuiltinType::LongFract) ||
8970 (BT->getKind() >= BuiltinType::SatShortAccum &&
8971 BT->getKind() <= BuiltinType::SatLongAccum) ||
8972 (BT->getKind() >= BuiltinType::SatShortFract &&
8973 BT->getKind() <= BuiltinType::SatLongFract));
8974 }
8975 return false;
8976}
8977
8980}
8981
8982inline bool Type::isScalarType() const {
8983 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
8984 return BT->getKind() > BuiltinType::Void &&
8985 BT->getKind() <= BuiltinType::NullPtr;
8986 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
8987 // Enums are scalar types, but only if they are defined. Incomplete enums
8988 // are not treated as scalar types.
8989 return IsEnumDeclComplete(ET->getOriginalDecl());
8990 return isa<PointerType>(CanonicalType) ||
8991 isa<BlockPointerType>(CanonicalType) ||
8992 isa<MemberPointerType>(CanonicalType) ||
8993 isa<ComplexType>(CanonicalType) ||
8994 isa<ObjCObjectPointerType>(CanonicalType) ||
8995 isBitIntType();
8996}
8997
8999 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
9000 return BT->isInteger();
9001
9002 // Check for a complete enum type; incomplete enum types are not properly an
9003 // enumeration type in the sense required here.
9004 if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
9005 return IsEnumDeclComplete(ET->getOriginalDecl());
9006
9007 return isBitIntType();
9008}
9009
9010inline bool Type::isBooleanType() const {
9011 if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
9012 return BT->getKind() == BuiltinType::Bool;
9013 return false;
9014}
9015
9016inline bool Type::isUndeducedType() const {
9017 auto *DT = getContainedDeducedType();
9018 return DT && !DT->isDeduced();
9019}
9020
9021/// Determines whether this is a type for which one can define
9022/// an overloaded operator.
9023inline bool Type::isOverloadableType() const {
9024 if (!isDependentType())
9025 return isRecordType() || isEnumeralType();
9026 return !isArrayType() && !isFunctionType() && !isAnyPointerType() &&
9028}
9029
9030/// Determines whether this type is written as a typedef-name.
9031inline bool Type::isTypedefNameType() const {
9032 if (getAs<TypedefType>())
9033 return true;
9034 if (auto *TST = getAs<TemplateSpecializationType>())
9035 return TST->isTypeAlias();
9036 return false;
9037}
9038
9039/// Determines whether this type can decay to a pointer type.
9040inline bool Type::canDecayToPointerType() const {
9041 return isFunctionType() || (isArrayType() && !isArrayParameterType());
9042}
9043
9048
9050 return isObjCObjectPointerType();
9051}
9052
9054 const Type *type = this;
9055 while (const ArrayType *arrayType = type->getAsArrayTypeUnsafe())
9056 type = arrayType->getElementType().getTypePtr();
9057 return type;
9058}
9059
9061 const Type *type = this;
9062 if (type->isAnyPointerType())
9063 return type->getPointeeType().getTypePtr();
9064 else if (type->isArrayType())
9065 return type->getBaseElementTypeUnsafe();
9066 return type;
9067}
9068/// Insertion operator for partial diagnostics. This allows sending adress
9069/// spaces into a diagnostic with <<.
9071 LangAS AS) {
9072 PD.AddTaggedVal(llvm::to_underlying(AS),
9074 return PD;
9075}
9076
9077/// Insertion operator for partial diagnostics. This allows sending Qualifiers
9078/// into a diagnostic with <<.
9085
9086/// Insertion operator for partial diagnostics. This allows sending QualType's
9087/// into a diagnostic with <<.
9089 QualType T) {
9090 PD.AddTaggedVal(reinterpret_cast<uint64_t>(T.getAsOpaquePtr()),
9092 return PD;
9093}
9094
9095// Helper class template that is used by Type::getAs to ensure that one does
9096// not try to look through a qualified type to get to an array type.
9097template <typename T> using TypeIsArrayType = std::is_base_of<ArrayType, T>;
9098
9099// Member-template getAs<specific type>'.
9100template <typename T> const T *Type::getAs() const {
9101 static_assert(!TypeIsArrayType<T>::value,
9102 "ArrayType cannot be used with getAs!");
9103
9104 // If this is directly a T type, return it.
9105 if (const auto *Ty = dyn_cast<T>(this))
9106 return Ty;
9107
9108 // If the canonical form of this type isn't the right kind, reject it.
9109 if (!isa<T>(CanonicalType))
9110 return nullptr;
9111
9112 // If this is a typedef for the type, strip the typedef off without
9113 // losing all typedef information.
9115}
9116
9117template <typename T> const T *Type::getAsAdjusted() const {
9118 static_assert(!TypeIsArrayType<T>::value, "ArrayType cannot be used with getAsAdjusted!");
9119
9120 // If this is directly a T type, return it.
9121 if (const auto *Ty = dyn_cast<T>(this))
9122 return Ty;
9123
9124 // If the canonical form of this type isn't the right kind, reject it.
9125 if (!isa<T>(CanonicalType))
9126 return nullptr;
9127
9128 // Strip off type adjustments that do not modify the underlying nature of the
9129 // type.
9130 const Type *Ty = this;
9131 while (Ty) {
9132 if (const auto *A = dyn_cast<AttributedType>(Ty))
9133 Ty = A->getModifiedType().getTypePtr();
9134 else if (const auto *A = dyn_cast<BTFTagAttributedType>(Ty))
9135 Ty = A->getWrappedType().getTypePtr();
9136 else if (const auto *A = dyn_cast<HLSLAttributedResourceType>(Ty))
9137 Ty = A->getWrappedType().getTypePtr();
9138 else if (const auto *P = dyn_cast<ParenType>(Ty))
9139 Ty = P->desugar().getTypePtr();
9140 else if (const auto *A = dyn_cast<AdjustedType>(Ty))
9141 Ty = A->desugar().getTypePtr();
9142 else if (const auto *M = dyn_cast<MacroQualifiedType>(Ty))
9143 Ty = M->desugar().getTypePtr();
9144 else
9145 break;
9146 }
9147
9148 // Just because the canonical type is correct does not mean we can use cast<>,
9149 // since we may not have stripped off all the sugar down to the base type.
9150 return dyn_cast<T>(Ty);
9151}
9152
9154 // If this is directly an array type, return it.
9155 if (const auto *arr = dyn_cast<ArrayType>(this))
9156 return arr;
9157
9158 // If the canonical form of this type isn't the right kind, reject it.
9159 if (!isa<ArrayType>(CanonicalType))
9160 return nullptr;
9161
9162 // If this is a typedef for the type, strip the typedef off without
9163 // losing all typedef information.
9165}
9166
9167template <typename T> const T *Type::castAs() const {
9168 static_assert(!TypeIsArrayType<T>::value,
9169 "ArrayType cannot be used with castAs!");
9170
9171 if (const auto *ty = dyn_cast<T>(this)) return ty;
9172 assert(isa<T>(CanonicalType));
9174}
9175
9177 assert(isa<ArrayType>(CanonicalType));
9178 if (const auto *arr = dyn_cast<ArrayType>(this)) return arr;
9180}
9181
9182DecayedType::DecayedType(QualType OriginalType, QualType DecayedPtr,
9183 QualType CanonicalPtr)
9184 : AdjustedType(Decayed, OriginalType, DecayedPtr, CanonicalPtr) {
9185#ifndef NDEBUG
9186 QualType Adjusted = getAdjustedType();
9187 (void)AttributedType::stripOuterNullability(Adjusted);
9188 assert(isa<PointerType>(Adjusted));
9189#endif
9190}
9191
9193 QualType Decayed = getDecayedType();
9194 (void)AttributedType::stripOuterNullability(Decayed);
9195 return cast<PointerType>(Decayed)->getPointeeType();
9196}
9197
9198// Get the decimal string representation of a fixed point type, represented
9199// as a scaled integer.
9200// TODO: At some point, we should change the arguments to instead just accept an
9201// APFixedPoint instead of APSInt and scale.
9202void FixedPointValueToString(SmallVectorImpl<char> &Str, llvm::APSInt Val,
9203 unsigned Scale);
9204
9205inline FunctionEffectsRef FunctionEffectsRef::get(QualType QT) {
9206 const Type *TypePtr = QT.getTypePtr();
9207 while (true) {
9208 if (QualType Pointee = TypePtr->getPointeeType(); !Pointee.isNull())
9209 TypePtr = Pointee.getTypePtr();
9210 else if (TypePtr->isArrayType())
9211 TypePtr = TypePtr->getBaseElementTypeUnsafe();
9212 else
9213 break;
9214 }
9215 if (const auto *FPT = TypePtr->getAs<FunctionProtoType>())
9216 return FPT->getFunctionEffects();
9217 return {};
9218}
9219
9220} // namespace clang
9221
9222#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:8095
bool isSugared() const
Definition TypeBase.h:8088
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition TypeBase.h:8086
QualType desugar() const
Definition TypeBase.h:8089
friend class ASTContext
Definition TypeBase.h:8076
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:8091
static bool classof(const Type *T)
Definition TypeBase.h:8099
Attr - This represents one attribute.
Definition Attr.h:44
bool isSigned() const
Definition TypeBase.h:8150
static bool classof(const Type *T)
Definition TypeBase.h:8166
BitIntType(bool isUnsigned, unsigned NumBits)
Definition Type.cpp:424
static void Profile(llvm::FoldingSetNodeID &ID, bool IsUnsigned, unsigned NumBits)
Definition TypeBase.h:8160
bool isSugared() const
Definition TypeBase.h:8153
friend class ASTContext
Definition TypeBase.h:8140
bool isUnsigned() const
Definition TypeBase.h:8149
void Profile(llvm::FoldingSetNodeID &ID) const
Definition TypeBase.h:8156
unsigned getNumBits() const
Definition TypeBase.h:8151
QualType desugar() const
Definition TypeBase.h:8154
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:9192
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:8182
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition TypeBase.h:8184
DependentBitIntType(bool IsUnsigned, Expr *NumBits)
Definition Type.cpp:428
static bool classof(const Type *T)
Definition TypeBase.h:8190
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:265
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:4004
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:1999
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:9205
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:273
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:7849
QualType desugar() const
Definition TypeBase.h:7865
friend class ASTContext
Definition TypeBase.h:7850
static bool classof(const Type *T)
Definition TypeBase.h:7867
Represents a pointer to an Objective C object.
Definition TypeBase.h:7905
unsigned getNumProtocols() const
Return the number of qualifying protocols on the object type.
Definition TypeBase.h:8037
bool isSpecialized() const
Whether this type is specialized, meaning that it has type arguments.
Definition TypeBase.h:7994
qual_iterator qual_end() const
Definition TypeBase.h:8030
bool isObjCQualifiedClassType() const
True if this is equivalent to 'Class.
Definition TypeBase.h:7986
static void Profile(llvm::FoldingSetNodeID &ID, QualType T)
Definition TypeBase.h:8066
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
Definition TypeBase.h:7980
bool isSpecializedAsWritten() const
Whether this type is specialized, meaning that it has type arguments.
Definition TypeBase.h:7997
bool isUnspecializedAsWritten() const
Determine whether this object type is "unspecialized" as written, meaning that it has no type argumen...
Definition TypeBase.h:8006
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments for this type.
Definition TypeBase.h:8014
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:8062
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition TypeBase.h:7942
ObjCObjectType::qual_iterator qual_iterator
An iterator over the qualifiers on the object type.
Definition TypeBase.h:8021
llvm::iterator_range< qual_iterator > qual_range
Definition TypeBase.h:8022
static bool classof(const Type *T)
Definition TypeBase.h:8070
bool isUnspecialized() const
Whether this type is unspecialized, meaning that is has no type arguments.
Definition TypeBase.h:8002
bool isObjCIdType() const
True if this is equivalent to the 'id' type, i.e.
Definition TypeBase.h:7963
ObjCProtocolDecl * getProtocol(unsigned I) const
Retrieve a qualifying protocol by index on the object type.
Definition TypeBase.h:8042
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition TypeBase.h:7917
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface.
Definition TypeBase.h:7957
QualType desugar() const
Definition TypeBase.h:8047
qual_range quals() const
Definition TypeBase.h:8024
bool isObjCClassType() const
True if this is equivalent to the 'Class' type, i.e.
Definition TypeBase.h:7969
bool isObjCIdOrClassType() const
True if this is equivalent to the 'id' or 'Class' type,.
Definition TypeBase.h:7974
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments for this type.
Definition TypeBase.h:8009
qual_iterator qual_begin() const
Definition TypeBase.h:8026
bool isKindOfType() const
Whether this is a "__kindof" type.
Definition TypeBase.h:7991
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:8120
bool isSugared() const
Definition TypeBase.h:8118
static void Profile(llvm::FoldingSetNodeID &ID, QualType T, bool isRead)
Definition TypeBase.h:8126
QualType getElementType() const
Definition TypeBase.h:8116
void Profile(llvm::FoldingSetNodeID &ID)
Definition TypeBase.h:8122
static bool classof(const Type *T)
Definition TypeBase.h:8131
friend class ASTContext
Definition TypeBase.h:8106
bool isReadOnly() const
Definition TypeBase.h:8135
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:8198
static bool classof(const Type *T)
Definition TypeBase.h:8221
QualType desugar() const
Definition TypeBase.h:8215
const IdentifierInfo * getIdentifier() const
Definition TypeBase.h:8219
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:8371
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition TypeBase.h:8365
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:8418
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:8376
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:8287
LangAS getAddressSpace() const
Return the address space of this type.
Definition TypeBase.h:8413
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:8327
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:8295
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:8472
QualType getCanonicalType() const
Definition TypeBase.h:8339
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition TypeBase.h:8381
void removeLocalVolatile()
Definition TypeBase.h:8403
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:8308
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:8479
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:8441
bool isCanonicalAsParam() const
Definition TypeBase.h:8348
void removeLocalConst()
Definition TypeBase.h:8395
void removeLocalRestrict()
Definition TypeBase.h:8399
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:8388
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:8360
bool hasAddressSpace() const
Check if this type has any address space qualifier.
Definition TypeBase.h:8408
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:8344
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:8333
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:8291
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:8452
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:8319
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:8234
QualifierCollector(Qualifiers Qs=Qualifiers())
Definition TypeBase.h:8229
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:4309
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:3714
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:8261
QualType getType() const
Return the type wrapped by this type source info.
Definition TypeBase.h:8269
void overrideType(QualType T)
Override the type stored in this TypeSourceInfo. Use with caution!
Definition TypeBase.h:8275
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:8748
bool isDependentSizedArrayType() const
Definition TypeBase.h:8643
friend class ASTWriter
Definition TypeBase.h:2376
bool isFixedPointOrIntegerType() const
Return true if this is a fixed point or integer type.
Definition TypeBase.h:8944
bool isBlockPointerType() const
Definition TypeBase.h:8544
bool isVoidType() const
Definition TypeBase.h:8880
TypedefBitfields TypedefBits
Definition TypeBase.h:2319
UsingBitfields UsingBits
Definition TypeBase.h:2321
bool hasPointeeToToCFIUncheckedCalleeFunctionType() const
Definition TypeBase.h:8576
bool isBooleanType() const
Definition TypeBase.h:9010
bool isFunctionReferenceType() const
Definition TypeBase.h:8598
bool isSignableType(const ASTContext &Ctx) const
Definition TypeBase.h:8536
Type(const Type &)=delete
bool isObjCBuiltinType() const
Definition TypeBase.h:8744
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:8905
const Type * getPointeeOrArrayElementType() const
If this is a pointer type, return the pointee type.
Definition TypeBase.h:9060
bool isIncompleteArrayType() const
Definition TypeBase.h:8631
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:8856
bool isFloat16Type() const
Definition TypeBase.h:8889
ReferenceTypeBitfields ReferenceTypeBits
Definition TypeBase.h:2325
bool isSignablePointerType() const
Definition TypeBase.h:8540
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:9176
Type(Type &&)=delete
bool isDependentAddressSpaceType() const
Definition TypeBase.h:8689
bool isUndeducedAutoType() const
Definition TypeBase.h:8710
bool isRValueReferenceType() const
Definition TypeBase.h:8556
bool isFundamentalType() const
Tests whether the type is categorized as a fundamental type.
Definition TypeBase.h:8487
VectorTypeBitfields VectorTypeBits
Definition TypeBase.h:2328
SubstPackTypeBitfields SubstPackTypeBits
Definition TypeBase.h:2331
bool isConstantArrayType() const
Definition TypeBase.h:8627
bool canDecayToPointerType() const
Determines whether this type can decay to a pointer type.
Definition TypeBase.h:9040
bool isArrayType() const
Definition TypeBase.h:8623
bool isFunctionPointerType() const
Definition TypeBase.h:8591
bool isHLSLInlineSpirvType() const
Definition TypeBase.h:8841
bool isConvertibleToFixedPointType() const
Return true if this can be converted to (or from) a fixed point type.
Definition TypeBase.h:8948
bool isArithmeticType() const
Definition Type.cpp:2337
bool isConstantMatrixType() const
Definition TypeBase.h:8685
bool isHLSLBuiltinIntangibleType() const
Definition TypeBase.h:8825
bool isPointerType() const
Definition TypeBase.h:8524
const TemplateSpecializationType * castAsNonAliasTemplateSpecializationType() const
Definition TypeBase.h:2947
bool isArrayParameterType() const
Definition TypeBase.h:8639
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:8924
bool isObjCSelType() const
Definition TypeBase.h:8738
const T * castAs() const
Member-template castAs<specific type>.
Definition TypeBase.h:9167
BuiltinTypeBitfields BuiltinTypeBits
Definition TypeBase.h:2322
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
Definition TypeBase.h:8869
bool isReferenceType() const
Definition TypeBase.h:8548
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:8964
bool isObjectPointerType() const
Definition TypeBase.h:8560
bool isEnumeralType() const
Definition TypeBase.h:8655
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:8982
bool isVariableArrayType() const
Definition TypeBase.h:8635
bool isFloat128Type() const
Definition TypeBase.h:8909
bool isClkEventT() const
Definition TypeBase.h:8766
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:8714
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:8998
bool isExtVectorType() const
Definition TypeBase.h:8667
friend class ASTReader
Definition TypeBase.h:2375
bool isExtVectorBoolType() const
Definition TypeBase.h:8671
Type & operator=(const Type &)=delete
bool isObjCObjectOrInterfaceType() const
Definition TypeBase.h:8701
bool isImageType() const
Definition TypeBase.h:8778
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
Definition TypeBase.h:8874
bool isOCLIntelSubgroupAVCType() const
Definition TypeBase.h:8799
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:8785
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:8616
bool isLValueReferenceType() const
Definition TypeBase.h:8552
bool isBitIntType() const
Definition TypeBase.h:8789
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition TypeBase.h:8849
bool isBuiltinType() const
Helper methods to distinguish type categories.
Definition TypeBase.h:8647
bool isOpenCLSpecificType() const
Definition TypeBase.h:8814
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:8893
TypeBitfields TypeBits
Definition TypeBase.h:2313
bool isAnyComplexType() const
Definition TypeBase.h:8659
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition TypeBase.h:8936
bool isHalfType() const
Definition TypeBase.h:8884
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:8952
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:8862
QualType getCanonicalTypeInternal() const
Definition TypeBase.h:3119
friend class ASTContext
Definition TypeBase.h:2347
bool isHLSLSpecificType() const
Definition TypeBase.h:8832
bool isTemplateTypeParmType() const
Definition TypeBase.h:8845
@ 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:8770
PresefinedSugarTypeBitfields PredefinedSugarTypeBits
Definition TypeBase.h:2335
bool isCompoundType() const
Tests whether the type is categorized as a compound type.
Definition TypeBase.h:8498
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:9053
bool isMemberPointerType() const
Definition TypeBase.h:8605
bool isAtomicType() const
Definition TypeBase.h:8706
AttributedTypeBitfields AttributedTypeBits
Definition TypeBase.h:2316
bool isFunctionProtoType() const
Definition TypeBase.h:2601
bool isIbm128Type() const
Definition TypeBase.h:8913
bool isOverloadableType() const
Determines whether this is a type for which one can define an overloaded operator.
Definition TypeBase.h:9023
bool isObjCIdType() const
Definition TypeBase.h:8726
bool isMatrixType() const
Definition TypeBase.h:8681
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:8960
UnresolvedUsingBitfields UnresolvedUsingBits
Definition TypeBase.h:2320
bool isObjCObjectType() const
Definition TypeBase.h:8697
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:9153
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition TypeBase.h:9016
bool isObjectType() const
Determine whether this type is an object type.
Definition TypeBase.h:2510
bool isEventT() const
Definition TypeBase.h:8762
bool isDoubleType() const
Definition TypeBase.h:8897
bool isPointerOrReferenceType() const
Definition TypeBase.h:8528
Type * this_()
Definition TypeBase.h:2366
KeywordWrapperBitfields KeywordWrapperBits
Definition TypeBase.h:2326
FunctionTypeBitfields FunctionTypeBits
Definition TypeBase.h:2323
bool isBFloat16Type() const
Definition TypeBase.h:8901
void setDependence(TypeDependence D)
Definition TypeBase.h:2368
const T * getAsAdjusted() const
Member-template getAsAdjusted<specific type>.
Definition TypeBase.h:9117
bool isFunctionType() const
Definition TypeBase.h:8520
bool isObjCObjectPointerType() const
Definition TypeBase.h:8693
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:8609
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:8978
bool isVectorType() const
Definition TypeBase.h:8663
bool isObjCQualifiedClassType() const
Definition TypeBase.h:8720
bool isObjCClassType() const
Definition TypeBase.h:8732
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:8837
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:8807
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:8532
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:8677
bool isSamplerT() const
Definition TypeBase.h:8758
const T * getAs() const
Member-template getAs<specific type>'.
Definition TypeBase.h:9100
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:8917
bool isRecordType() const
Definition TypeBase.h:8651
TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits
Definition TypeBase.h:2332
bool isTypedefNameType() const
Determines whether this type is written as a typedef-name.
Definition TypeBase.h:9031
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:8774
bool hasObjCPointerRepresentation() const
Whether this type can represent an objective pointer type for the purpose of GC'ability.
Definition TypeBase.h:9049
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
Definition TypeBase.h:9044
AutoTypeBitfields AutoTypeBits
Definition TypeBase.h:2317
bool isCFIUncheckedCalleeFunctionType() const
Definition TypeBase.h:8570
Type & operator=(Type &&)=delete
Base class for declarations which introduce a typedef-name.
Definition Decl.h:3559
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:711
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:811
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:8422
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:5347
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
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
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:5357
std::is_base_of< ArrayType, T > TypeIsArrayType
Definition TypeBase.h:9097
@ Keyword
The name has been typo-corrected to a keyword.
Definition Sema.h:559
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
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:1745
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:8280
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