Coverage Report

Created: 2021-06-15 06:44

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/AST/Type.h
Line
Count
Source (jump to first uncovered line)
1
//===- Type.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_H
18
#define LLVM_CLANG_AST_TYPE_H
19
20
#include "clang/AST/DependenceFlags.h"
21
#include "clang/AST/NestedNameSpecifier.h"
22
#include "clang/AST/TemplateName.h"
23
#include "clang/Basic/AddressSpaces.h"
24
#include "clang/Basic/AttrKinds.h"
25
#include "clang/Basic/Diagnostic.h"
26
#include "clang/Basic/ExceptionSpecificationType.h"
27
#include "clang/Basic/LLVM.h"
28
#include "clang/Basic/Linkage.h"
29
#include "clang/Basic/PartialDiagnostic.h"
30
#include "clang/Basic/SourceLocation.h"
31
#include "clang/Basic/Specifiers.h"
32
#include "clang/Basic/Visibility.h"
33
#include "llvm/ADT/APInt.h"
34
#include "llvm/ADT/APSInt.h"
35
#include "llvm/ADT/ArrayRef.h"
36
#include "llvm/ADT/FoldingSet.h"
37
#include "llvm/ADT/None.h"
38
#include "llvm/ADT/Optional.h"
39
#include "llvm/ADT/PointerIntPair.h"
40
#include "llvm/ADT/PointerUnion.h"
41
#include "llvm/ADT/StringRef.h"
42
#include "llvm/ADT/Twine.h"
43
#include "llvm/ADT/iterator_range.h"
44
#include "llvm/Support/Casting.h"
45
#include "llvm/Support/Compiler.h"
46
#include "llvm/Support/ErrorHandling.h"
47
#include "llvm/Support/PointerLikeTypeTraits.h"
48
#include "llvm/Support/TrailingObjects.h"
49
#include "llvm/Support/type_traits.h"
50
#include <cassert>
51
#include <cstddef>
52
#include <cstdint>
53
#include <cstring>
54
#include <string>
55
#include <type_traits>
56
#include <utility>
57
58
namespace clang {
59
60
class ExtQuals;
61
class QualType;
62
class ConceptDecl;
63
class TagDecl;
64
class TemplateParameterList;
65
class Type;
66
67
enum {
68
  TypeAlignmentInBits = 4,
69
  TypeAlignment = 1 << TypeAlignmentInBits
70
};
71
72
namespace serialization {
73
  template <class T> class AbstractTypeReader;
74
  template <class T> class AbstractTypeWriter;
75
}
76
77
} // namespace clang
78
79
namespace llvm {
80
81
  template <typename T>
82
  struct PointerLikeTypeTraits;
83
  template<>
84
  struct PointerLikeTypeTraits< ::clang::Type*> {
85
3.08G
    static inline void *getAsVoidPointer(::clang::Type *P) { return P; }
86
87
156M
    static inline ::clang::Type *getFromVoidPointer(void *P) {
88
156M
      return static_cast< ::clang::Type*>(P);
89
156M
    }
90
91
    static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
92
  };
93
94
  template<>
95
  struct PointerLikeTypeTraits< ::clang::ExtQuals*> {
96
575k
    static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; }
97
98
4.59M
    static inline ::clang::ExtQuals *getFromVoidPointer(void *P) {
99
4.59M
      return static_cast< ::clang::ExtQuals*>(P);
100
4.59M
    }
101
102
    static constexpr int NumLowBitsAvailable = clang::TypeAlignmentInBits;
103
  };
104
105
} // namespace llvm
106
107
namespace clang {
108
109
class ASTContext;
110
template <typename> class CanQual;
111
class CXXRecordDecl;
112
class DeclContext;
113
class EnumDecl;
114
class Expr;
115
class ExtQualsTypeCommonBase;
116
class FunctionDecl;
117
class IdentifierInfo;
118
class NamedDecl;
119
class ObjCInterfaceDecl;
120
class ObjCProtocolDecl;
121
class ObjCTypeParamDecl;
122
struct PrintingPolicy;
123
class RecordDecl;
124
class Stmt;
125
class TagDecl;
126
class TemplateArgument;
127
class TemplateArgumentListInfo;
128
class TemplateArgumentLoc;
129
class TemplateTypeParmDecl;
130
class TypedefNameDecl;
131
class UnresolvedUsingTypenameDecl;
132
133
using CanQualType = CanQual<Type>;
134
135
// Provide forward declarations for all of the *Type classes.
136
#define TYPE(Class, Base) class Class##Type;
137
#include "clang/AST/TypeNodes.inc"
138
139
/// The collection of all-type qualifiers we support.
140
/// Clang supports five independent qualifiers:
141
/// * C99: const, volatile, and restrict
142
/// * MS: __unaligned
143
/// * Embedded C (TR18037): address spaces
144
/// * Objective C: the GC attributes (none, weak, or strong)
145
class Qualifiers {
146
public:
147
  enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ.
148
    Const    = 0x1,
149
    Restrict = 0x2,
150
    Volatile = 0x4,
151
    CVRMask = Const | Volatile | Restrict
152
  };
153
154
  enum GC {
155
    GCNone = 0,
156
    Weak,
157
    Strong
158
  };
159
160
  enum ObjCLifetime {
161
    /// There is no lifetime qualification on this type.
162
    OCL_None,
163
164
    /// This object can be modified without requiring retains or
165
    /// releases.
166
    OCL_ExplicitNone,
167
168
    /// Assigning into this object requires the old value to be
169
    /// released and the new value to be retained.  The timing of the
170
    /// release of the old value is inexact: it may be moved to
171
    /// immediately after the last known point where the value is
172
    /// live.
173
    OCL_Strong,
174
175
    /// Reading or writing from this object requires a barrier call.
176
    OCL_Weak,
177
178
    /// Assigning into this object requires a lifetime extension.
179
    OCL_Autoreleasing
180
  };
181
182
  enum {
183
    /// The maximum supported address space number.
184
    /// 23 bits should be enough for anyone.
185
    MaxAddressSpace = 0x7fffffu,
186
187
    /// The width of the "fast" qualifier mask.
188
    FastWidth = 3,
189
190
    /// The fast qualifier mask.
191
    FastMask = (1 << FastWidth) - 1
192
  };
193
194
  /// Returns the common set of qualifiers while removing them from
195
  /// the given sets.
196
10.3M
  static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) {
197
    // If both are only CVR-qualified, bit operations are sufficient.
198
10.3M
    if (!(L.Mask & ~CVRMask) && 
!(R.Mask & ~CVRMask)10.3M
) {
199
10.3M
      Qualifiers Q;
200
10.3M
      Q.Mask = L.Mask & R.Mask;
201
10.3M
      L.Mask &= ~Q.Mask;
202
10.3M
      R.Mask &= ~Q.Mask;
203
10.3M
      return Q;
204
10.3M
    }
205
206
1.00k
    Qualifiers Q;
207
1.00k
    unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers();
208
1.00k
    Q.addCVRQualifiers(CommonCRV);
209
1.00k
    L.removeCVRQualifiers(CommonCRV);
210
1.00k
    R.removeCVRQualifiers(CommonCRV);
211
212
1.00k
    if (L.getObjCGCAttr() == R.getObjCGCAttr()) {
213
1.00k
      Q.setObjCGCAttr(L.getObjCGCAttr());
214
1.00k
      L.removeObjCGCAttr();
215
1.00k
      R.removeObjCGCAttr();
216
1.00k
    }
217
218
1.00k
    if (L.getObjCLifetime() == R.getObjCLifetime()) {
219
797
      Q.setObjCLifetime(L.getObjCLifetime());
220
797
      L.removeObjCLifetime();
221
797
      R.removeObjCLifetime();
222
797
    }
223
224
1.00k
    if (L.getAddressSpace() == R.getAddressSpace()) {
225
224
      Q.setAddressSpace(L.getAddressSpace());
226
224
      L.removeAddressSpace();
227
224
      R.removeAddressSpace();
228
224
    }
229
1.00k
    return Q;
230
10.3M
  }
231
232
162M
  static Qualifiers fromFastMask(unsigned Mask) {
233
162M
    Qualifiers Qs;
234
162M
    Qs.addFastQualifiers(Mask);
235
162M
    return Qs;
236
162M
  }
237
238
6.63M
  static Qualifiers fromCVRMask(unsigned CVR) {
239
6.63M
    Qualifiers Qs;
240
6.63M
    Qs.addCVRQualifiers(CVR);
241
6.63M
    return Qs;
242
6.63M
  }
243
244
1.23M
  static Qualifiers fromCVRUMask(unsigned CVRU) {
245
1.23M
    Qualifiers Qs;
246
1.23M
    Qs.addCVRUQualifiers(CVRU);
247
1.23M
    return Qs;
248
1.23M
  }
249
250
  // Deserialize qualifiers from an opaque representation.
251
708k
  static Qualifiers fromOpaqueValue(unsigned opaque) {
252
708k
    Qualifiers Qs;
253
708k
    Qs.Mask = opaque;
254
708k
    return Qs;
255
708k
  }
256
257
  // Serialize these qualifiers into an opaque representation.
258
4.80M
  unsigned getAsOpaqueValue() const {
259
4.80M
    return Mask;
260
4.80M
  }
261
262
8.35M
  bool hasConst() const { return Mask & Const; }
263
884
  bool hasOnlyConst() const { return Mask == Const; }
264
100k
  void removeConst() { Mask &= ~Const; }
265
277k
  void addConst() { Mask |= Const; }
266
267
8.72M
  bool hasVolatile() const { return Mask & Volatile; }
268
26
  bool hasOnlyVolatile() const { return Mask == Volatile; }
269
1.66k
  void removeVolatile() { Mask &= ~Volatile; }
270
94.8k
  void addVolatile() { Mask |= Volatile; }
271
272
7.15M
  bool hasRestrict() const { return Mask & Restrict; }
273
20
  bool hasOnlyRestrict() const { return Mask == Restrict; }
274
1.11M
  void removeRestrict() { Mask &= ~Restrict; }
275
93.6k
  void addRestrict() { Mask |= Restrict; }
276
277
29
  bool hasCVRQualifiers() const { return getCVRQualifiers(); }
278
23.2M
  unsigned getCVRQualifiers() const { return Mask & CVRMask; }
279
48.8k
  unsigned getCVRUQualifiers() const { return Mask & (CVRMask | UMask); }
280
281
774k
  void setCVRQualifiers(unsigned mask) {
282
774k
    assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits");
283
0
    Mask = (Mask & ~CVRMask) | mask;
284
774k
  }
285
5.34M
  void removeCVRQualifiers(unsigned mask) {
286
5.34M
    assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits");
287
0
    Mask &= ~mask;
288
5.34M
  }
289
3.95M
  void removeCVRQualifiers() {
290
3.95M
    removeCVRQualifiers(CVRMask);
291
3.95M
  }
292
6.84M
  void addCVRQualifiers(unsigned mask) {
293
6.84M
    assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits");
294
0
    Mask |= mask;
295
6.84M
  }
296
32.6M
  void addCVRUQualifiers(unsigned mask) {
297
32.6M
    assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits");
298
0
    Mask |= mask;
299
32.6M
  }
300
301
27.5M
  bool hasUnaligned() const { return Mask & UMask; }
302
5.61M
  void setUnaligned(bool flag) {
303
5.61M
    Mask = (Mask & ~UMask) | (flag ? 
UMask154
:
05.61M
);
304
5.61M
  }
305
152k
  void removeUnaligned() { Mask &= ~UMask; }
306
0
  void addUnaligned() { Mask |= UMask; }
307
308
1.59M
  bool hasObjCGCAttr() const { return Mask & GCAttrMask; }
309
35.8M
  GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); }
310
8.08M
  void setObjCGCAttr(GC type) {
311
8.08M
    Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift);
312
8.08M
  }
313
2.31M
  void removeObjCGCAttr() { setObjCGCAttr(GCNone); }
314
255
  void addObjCGCAttr(GC type) {
315
255
    assert(type);
316
0
    setObjCGCAttr(type);
317
255
  }
318
320
  Qualifiers withoutObjCGCAttr() const {
319
320
    Qualifiers qs = *this;
320
320
    qs.removeObjCGCAttr();
321
320
    return qs;
322
320
  }
323
973
  Qualifiers withoutObjCLifetime() const {
324
973
    Qualifiers qs = *this;
325
973
    qs.removeObjCLifetime();
326
973
    return qs;
327
973
  }
328
6
  Qualifiers withoutAddressSpace() const {
329
6
    Qualifiers qs = *this;
330
6
    qs.removeAddressSpace();
331
6
    return qs;
332
6
  }
333
334
44.6M
  bool hasObjCLifetime() const { return Mask & LifetimeMask; }
335
91.8M
  ObjCLifetime getObjCLifetime() const {
336
91.8M
    return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift);
337
91.8M
  }
338
317k
  void setObjCLifetime(ObjCLifetime type) {
339
317k
    Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift);
340
317k
  }
341
266k
  void removeObjCLifetime() { setObjCLifetime(OCL_None); }
342
25.7k
  void addObjCLifetime(ObjCLifetime type) {
343
25.7k
    assert(type);
344
0
    assert(!hasObjCLifetime());
345
0
    Mask |= (type << LifetimeShift);
346
25.7k
  }
347
348
  /// True if the lifetime is neither None or ExplicitNone.
349
3.81M
  bool hasNonTrivialObjCLifetime() const {
350
3.81M
    ObjCLifetime lifetime = getObjCLifetime();
351
3.81M
    return (lifetime > OCL_ExplicitNone);
352
3.81M
  }
353
354
  /// True if the lifetime is either strong or weak.
355
193
  bool hasStrongOrWeakObjCLifetime() const {
356
193
    ObjCLifetime lifetime = getObjCLifetime();
357
193
    return (lifetime == OCL_Strong || 
lifetime == OCL_Weak191
);
358
193
  }
359
360
26.8M
  bool hasAddressSpace() const { return Mask & AddressSpaceMask; }
361
223M
  LangAS getAddressSpace() const {
362
223M
    return static_cast<LangAS>(Mask >> AddressSpaceShift);
363
223M
  }
364
10
  bool hasTargetSpecificAddressSpace() const {
365
10
    return isTargetAddressSpace(getAddressSpace());
366
10
  }
367
  /// Get the address space attribute value to be printed by diagnostics.
368
10
  unsigned getAddressSpaceAttributePrintValue() const {
369
10
    auto Addr = getAddressSpace();
370
    // This function is not supposed to be used with language specific
371
    // address spaces. If that happens, the diagnostic message should consider
372
    // printing the QualType instead of the address space value.
373
10
    assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace());
374
10
    if (Addr != LangAS::Default)
375
10
      return toTargetAddressSpace(Addr);
376
    // TODO: The diagnostic messages where Addr may be 0 should be fixed
377
    // since it cannot differentiate the situation where 0 denotes the default
378
    // address space or user specified __attribute__((address_space(0))).
379
0
    return 0;
380
10
  }
381
618k
  void setAddressSpace(LangAS space) {
382
618k
    assert((unsigned)space <= MaxAddressSpace);
383
0
    Mask = (Mask & ~AddressSpaceMask)
384
618k
         | (((uint32_t) space) << AddressSpaceShift);
385
618k
  }
386
74.1k
  void removeAddressSpace() { setAddressSpace(LangAS::Default); }
387
470k
  void addAddressSpace(LangAS space) {
388
470k
    assert(space != LangAS::Default);
389
0
    setAddressSpace(space);
390
470k
  }
391
392
  // Fast qualifiers are those that can be allocated directly
393
  // on a QualType object.
394
1.47M
  bool hasFastQualifiers() const { return getFastQualifiers(); }
395
107M
  unsigned getFastQualifiers() const { return Mask & FastMask; }
396
0
  void setFastQualifiers(unsigned mask) {
397
0
    assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits");
398
0
    Mask = (Mask & ~FastMask) | mask;
399
0
  }
400
551k
  void removeFastQualifiers(unsigned mask) {
401
551k
    assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits");
402
0
    Mask &= ~mask;
403
551k
  }
404
551k
  void removeFastQualifiers() {
405
551k
    removeFastQualifiers(FastMask);
406
551k
  }
407
1.10G
  void addFastQualifiers(unsigned mask) {
408
1.10G
    assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits");
409
0
    Mask |= mask;
410
1.10G
  }
411
412
  /// Return true if the set contains any qualifiers which require an ExtQuals
413
  /// node to be allocated.
414
122M
  bool hasNonFastQualifiers() const { return Mask & ~FastMask; }
415
0
  Qualifiers getNonFastQualifiers() const {
416
0
    Qualifiers Quals = *this;
417
0
    Quals.setFastQualifiers(0);
418
0
    return Quals;
419
0
  }
420
421
  /// Return true if the set contains any qualifiers.
422
22.4M
  bool hasQualifiers() const { return Mask; }
423
3.17M
  bool empty() const { return !Mask; }
424
425
  /// Add the qualifiers from the given set to this set.
426
21.9M
  void addQualifiers(Qualifiers Q) {
427
    // If the other set doesn't have any non-boolean qualifiers, just
428
    // bit-or it in.
429
21.9M
    if (!(Q.Mask & ~CVRMask))
430
21.9M
      Mask |= Q.Mask;
431
1.13k
    else {
432
1.13k
      Mask |= (Q.Mask & CVRMask);
433
1.13k
      if (Q.hasAddressSpace())
434
774
        addAddressSpace(Q.getAddressSpace());
435
1.13k
      if (Q.hasObjCGCAttr())
436
38
        addObjCGCAttr(Q.getObjCGCAttr());
437
1.13k
      if (Q.hasObjCLifetime())
438
320
        addObjCLifetime(Q.getObjCLifetime());
439
1.13k
    }
440
21.9M
  }
441
442
  /// Remove the qualifiers from the given set from this set.
443
24.0k
  void removeQualifiers(Qualifiers Q) {
444
    // If the other set doesn't have any non-boolean qualifiers, just
445
    // bit-and the inverse in.
446
24.0k
    if (!(Q.Mask & ~CVRMask))
447
23.9k
      Mask &= ~Q.Mask;
448
47
    else {
449
47
      Mask &= ~(Q.Mask & CVRMask);
450
47
      if (getObjCGCAttr() == Q.getObjCGCAttr())
451
47
        removeObjCGCAttr();
452
47
      if (getObjCLifetime() == Q.getObjCLifetime())
453
47
        removeObjCLifetime();
454
47
      if (getAddressSpace() == Q.getAddressSpace())
455
6
        removeAddressSpace();
456
47
    }
457
24.0k
  }
458
459
  /// Add the qualifiers from the given set to this set, given that
460
  /// they don't conflict.
461
843k
  void addConsistentQualifiers(Qualifiers qs) {
462
843k
    assert(getAddressSpace() == qs.getAddressSpace() ||
463
843k
           !hasAddressSpace() || !qs.hasAddressSpace());
464
0
    assert(getObjCGCAttr() == qs.getObjCGCAttr() ||
465
843k
           !hasObjCGCAttr() || !qs.hasObjCGCAttr());
466
0
    assert(getObjCLifetime() == qs.getObjCLifetime() ||
467
843k
           !hasObjCLifetime() || !qs.hasObjCLifetime());
468
0
    Mask |= qs.Mask;
469
843k
  }
470
471
  /// Returns true if address space A is equal to or a superset of B.
472
  /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of
473
  /// overlapping address spaces.
474
  /// CL1.1 or CL1.2:
475
  ///   every address space is a superset of itself.
476
  /// CL2.0 adds:
477
  ///   __generic is a superset of any address space except for __constant.
478
8.68M
  static bool isAddressSpaceSupersetOf(LangAS A, LangAS B) {
479
    // Address spaces must match exactly.
480
8.68M
    return A == B ||
481
           // Otherwise in OpenCLC v2.0 s6.5.5: every address space except
482
           // for __constant can be used as __generic.
483
8.68M
           
(121k
A == LangAS::opencl_generic121k
&&
B != LangAS::opencl_constant6.05k
) ||
484
           // We also define global_device and global_host address spaces,
485
           // to distinguish global pointers allocated on host from pointers
486
           // allocated on device, which are a subset of __global.
487
8.68M
           
(119k
A == LangAS::opencl_global119k
&&
(54.5k
B == LangAS::opencl_global_device54.5k
||
488
54.5k
                                           
B == LangAS::opencl_global_host54.4k
)) ||
489
8.68M
           
(119k
A == LangAS::sycl_global119k
&&
(19
B == LangAS::sycl_global_device19
||
490
19
                                         
B == LangAS::sycl_global_host16
)) ||
491
           // Consider pointer size address spaces to be equivalent to default.
492
8.68M
           
(119k
(119k
isPtrSizeAddressSpace(A)119k
||
A == LangAS::Default119k
) &&
493
119k
            
(254
isPtrSizeAddressSpace(B)254
||
B == LangAS::Default248
)) ||
494
           // Default is a superset of SYCL address spaces.
495
8.68M
           
(119k
A == LangAS::Default119k
&&
496
119k
            
(246
B == LangAS::sycl_private246
||
B == LangAS::sycl_local226
||
497
246
             
B == LangAS::sycl_global190
||
B == LangAS::sycl_global_device144
||
498
246
             
B == LangAS::sycl_global_host136
));
499
8.68M
  }
500
501
  /// Returns true if the address space in these qualifiers is equal to or
502
  /// a superset of the address space in the argument qualifiers.
503
6.94M
  bool isAddressSpaceSupersetOf(Qualifiers other) const {
504
6.94M
    return isAddressSpaceSupersetOf(getAddressSpace(), other.getAddressSpace());
505
6.94M
  }
506
507
  /// Determines if these qualifiers compatibly include another set.
508
  /// Generally this answers the question of whether an object with the other
509
  /// qualifiers can be safely used as an object with these qualifiers.
510
6.82M
  bool compatiblyIncludes(Qualifiers other) const {
511
6.82M
    return isAddressSpaceSupersetOf(other) &&
512
           // ObjC GC qualifiers can match, be added, or be removed, but can't
513
           // be changed.
514
6.82M
           
(6.74M
getObjCGCAttr() == other.getObjCGCAttr()6.74M
||
!hasObjCGCAttr()18
||
515
6.74M
            
!other.hasObjCGCAttr()15
) &&
516
           // ObjC lifetime qualifiers must match exactly.
517
6.82M
           
getObjCLifetime() == other.getObjCLifetime()6.74M
&&
518
           // CVR qualifiers may subset.
519
6.82M
           
(((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask))6.74M
&&
520
           // U qualifier may superset.
521
6.82M
           
(6.49M
!other.hasUnaligned()6.49M
||
hasUnaligned()35
);
522
6.82M
  }
523
524
  /// Determines if these qualifiers compatibly include another set of
525
  /// qualifiers from the narrow perspective of Objective-C ARC lifetime.
526
  ///
527
  /// One set of Objective-C lifetime qualifiers compatibly includes the other
528
  /// if the lifetime qualifiers match, or if both are non-__weak and the
529
  /// including set also contains the 'const' qualifier, or both are non-__weak
530
  /// and one is None (which can only happen in non-ARC modes).
531
24.8k
  bool compatiblyIncludesObjCLifetime(Qualifiers other) const {
532
24.8k
    if (getObjCLifetime() == other.getObjCLifetime())
533
24.5k
      return true;
534
535
287
    if (getObjCLifetime() == OCL_Weak || 
other.getObjCLifetime() == OCL_Weak236
)
536
128
      return false;
537
538
159
    if (getObjCLifetime() == OCL_None || 
other.getObjCLifetime() == OCL_None127
)
539
72
      return true;
540
541
87
    return hasConst();
542
159
  }
543
544
  /// Determine whether this set of qualifiers is a strict superset of
545
  /// another set of qualifiers, not considering qualifier compatibility.
546
  bool isStrictSupersetOf(Qualifiers Other) const;
547
548
2.71M
  bool operator==(Qualifiers Other) const { return Mask == Other.Mask; }
549
36.4M
  bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; }
550
551
22.3M
  explicit operator bool() const { return hasQualifiers(); }
552
553
21.9M
  Qualifiers &operator+=(Qualifiers R) {
554
21.9M
    addQualifiers(R);
555
21.9M
    return *this;
556
21.9M
  }
557
558
  // Union two qualifier sets.  If an enumerated qualifier appears
559
  // in both sets, use the one from the right.
560
898k
  friend Qualifiers operator+(Qualifiers L, Qualifiers R) {
561
898k
    L += R;
562
898k
    return L;
563
898k
  }
564
565
24.0k
  Qualifiers &operator-=(Qualifiers R) {
566
24.0k
    removeQualifiers(R);
567
24.0k
    return *this;
568
24.0k
  }
569
570
  /// Compute the difference between two qualifier sets.
571
18.6k
  friend Qualifiers operator-(Qualifiers L, Qualifiers R) {
572
18.6k
    L -= R;
573
18.6k
    return L;
574
18.6k
  }
575
576
  std::string getAsString() const;
577
  std::string getAsString(const PrintingPolicy &Policy) const;
578
579
  static std::string getAddrSpaceAsString(LangAS AS);
580
581
  bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const;
582
  void print(raw_ostream &OS, const PrintingPolicy &Policy,
583
             bool appendSpaceIfNonEmpty = false) const;
584
585
155M
  void Profile(llvm::FoldingSetNodeID &ID) const {
586
155M
    ID.AddInteger(Mask);
587
155M
  }
588
589
private:
590
  // bits:     |0 1 2|3|4 .. 5|6  ..  8|9   ...   31|
591
  //           |C R V|U|GCAttr|Lifetime|AddressSpace|
592
  uint32_t Mask = 0;
593
594
  static const uint32_t UMask = 0x8;
595
  static const uint32_t UShift = 3;
596
  static const uint32_t GCAttrMask = 0x30;
597
  static const uint32_t GCAttrShift = 4;
598
  static const uint32_t LifetimeMask = 0x1C0;
599
  static const uint32_t LifetimeShift = 6;
600
  static const uint32_t AddressSpaceMask =
601
      ~(CVRMask | UMask | GCAttrMask | LifetimeMask);
602
  static const uint32_t AddressSpaceShift = 9;
603
};
604
605
/// A std::pair-like structure for storing a qualified type split
606
/// into its local qualifiers and its locally-unqualified type.
607
struct SplitQualType {
608
  /// The locally-unqualified type.
609
  const Type *Ty = nullptr;
610
611
  /// The local qualifiers.
612
  Qualifiers Quals;
613
614
  SplitQualType() = default;
615
92.3M
  SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {}
616
617
  SplitQualType getSingleStepDesugaredType() const; // end of this file
618
619
  // Make std::tie work.
620
1.02M
  std::pair<const Type *,Qualifiers> asPair() const {
621
1.02M
    return std::pair<const Type *, Qualifiers>(Ty, Quals);
622
1.02M
  }
623
624
0
  friend bool operator==(SplitQualType a, SplitQualType b) {
625
0
    return a.Ty == b.Ty && a.Quals == b.Quals;
626
0
  }
627
48.7k
  friend bool operator!=(SplitQualType a, SplitQualType b) {
628
48.7k
    return a.Ty != b.Ty || 
a.Quals != b.Quals46.0k
;
629
48.7k
  }
630
};
631
632
/// The kind of type we are substituting Objective-C type arguments into.
633
///
634
/// The kind of substitution affects the replacement of type parameters when
635
/// no concrete type information is provided, e.g., when dealing with an
636
/// unspecialized type.
637
enum class ObjCSubstitutionContext {
638
  /// An ordinary type.
639
  Ordinary,
640
641
  /// The result type of a method or function.
642
  Result,
643
644
  /// The parameter type of a method or function.
645
  Parameter,
646
647
  /// The type of a property.
648
  Property,
649
650
  /// The superclass of a type.
651
  Superclass,
652
};
653
654
/// A (possibly-)qualified type.
655
///
656
/// For efficiency, we don't store CV-qualified types as nodes on their
657
/// own: instead each reference to a type stores the qualifiers.  This
658
/// greatly reduces the number of nodes we need to allocate for types (for
659
/// example we only need one for 'int', 'const int', 'volatile int',
660
/// 'const volatile int', etc).
661
///
662
/// As an added efficiency bonus, instead of making this a pair, we
663
/// just store the two bits we care about in the low bits of the
664
/// pointer.  To handle the packing/unpacking, we make QualType be a
665
/// simple wrapper class that acts like a smart pointer.  A third bit
666
/// indicates whether there are extended qualifiers present, in which
667
/// case the pointer points to a special structure.
668
class QualType {
669
  friend class QualifierCollector;
670
671
  // Thankfully, these are efficiently composable.
672
  llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>,
673
                       Qualifiers::FastWidth> Value;
674
675
4.59M
  const ExtQuals *getExtQualsUnsafe() const {
676
4.59M
    return Value.getPointer().get<const ExtQuals*>();
677
4.59M
  }
678
679
156M
  const Type *getTypePtrUnsafe() const {
680
156M
    return Value.getPointer().get<const Type*>();
681
156M
  }
682
683
31.0G
  const ExtQualsTypeCommonBase *getCommonPtr() const {
684
31.0G
    assert(!isNull() && "Cannot retrieve a NULL type pointer");
685
0
    auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
686
31.0G
    CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
687
31.0G
    return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
688
31.0G
  }
689
690
public:
691
12.0G
  QualType() = default;
692
3.08G
  QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
693
575k
  QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {}
694
695
8.00G
  unsigned getLocalFastQualifiers() const { return Value.getInt(); }
696
0
  void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); }
697
698
  /// Retrieves a pointer to the underlying (unqualified) type.
699
  ///
700
  /// This function requires that the type not be NULL. If the type might be
701
  /// NULL, use the (slightly less efficient) \c getTypePtrOrNull().
702
  const Type *getTypePtr() const;
703
704
  const Type *getTypePtrOrNull() const;
705
706
  /// Retrieves a pointer to the name of the base type.
707
  const IdentifierInfo *getBaseTypeIdentifier() const;
708
709
  /// Divides a QualType into its unqualified type and a set of local
710
  /// qualifiers.
711
  SplitQualType split() const;
712
713
2.88G
  void *getAsOpaquePtr() const { return Value.getOpaqueValue(); }
714
715
8.67G
  static QualType getFromOpaquePtr(const void *Ptr) {
716
8.67G
    QualType T;
717
8.67G
    T.Value.setFromOpaqueValue(const_cast<void*>(Ptr));
718
8.67G
    return T;
719
8.67G
  }
720
721
2.75M
  const Type &operator*() const {
722
2.75M
    return *getTypePtr();
723
2.75M
  }
724
725
9.17G
  const Type *operator->() const {
726
9.17G
    return getTypePtr();
727
9.17G
  }
728
729
  bool isCanonical() const;
730
  bool isCanonicalAsParam() const;
731
732
  /// Return true if this QualType doesn't point to a type yet.
733
36.6G
  bool isNull() const {
734
36.6G
    return Value.getPointer().isNull();
735
36.6G
  }
736
737
  /// Determine whether this particular QualType instance has the
738
  /// "const" qualifier set, without looking through typedefs that may have
739
  /// added "const" at a different level.
740
63.1M
  bool isLocalConstQualified() const {
741
63.1M
    return (getLocalFastQualifiers() & Qualifiers::Const);
742
63.1M
  }
743
744
  /// Determine whether this type is const-qualified.
745
  bool isConstQualified() const;
746
747
  /// Determine whether this particular QualType instance has the
748
  /// "restrict" qualifier set, without looking through typedefs that may have
749
  /// added "restrict" at a different level.
750
609k
  bool isLocalRestrictQualified() const {
751
609k
    return (getLocalFastQualifiers() & Qualifiers::Restrict);
752
609k
  }
753
754
  /// Determine whether this type is restrict-qualified.
755
  bool isRestrictQualified() const;
756
757
  /// Determine whether this particular QualType instance has the
758
  /// "volatile" qualifier set, without looking through typedefs that may have
759
  /// added "volatile" at a different level.
760
398M
  bool isLocalVolatileQualified() const {
761
398M
    return (getLocalFastQualifiers() & Qualifiers::Volatile);
762
398M
  }
763
764
  /// Determine whether this type is volatile-qualified.
765
  bool isVolatileQualified() const;
766
767
  /// Determine whether this particular QualType instance has any
768
  /// qualifiers, without looking through any typedefs that might add
769
  /// qualifiers at a different level.
770
4.78G
  bool hasLocalQualifiers() const {
771
4.78G
    return getLocalFastQualifiers() || 
hasLocalNonFastQualifiers()4.69G
;
772
4.78G
  }
773
774
  /// Determine whether this type has any qualifiers.
775
  bool hasQualifiers() const;
776
777
  /// Determine whether this particular QualType instance has any
778
  /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType
779
  /// instance.
780
5.31G
  bool hasLocalNonFastQualifiers() const {
781
5.31G
    return Value.getPointer().is<const ExtQuals*>();
782
5.31G
  }
783
784
  /// Retrieve the set of qualifiers local to this particular QualType
785
  /// instance, not including any qualifiers acquired through typedefs or
786
  /// other sugar.
787
  Qualifiers getLocalQualifiers() const;
788
789
  /// Retrieve the set of qualifiers applied to this type.
790
  Qualifiers getQualifiers() const;
791
792
  /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
793
  /// local to this particular QualType instance, not including any qualifiers
794
  /// acquired through typedefs or other sugar.
795
74.6M
  unsigned getLocalCVRQualifiers() const {
796
74.6M
    return getLocalFastQualifiers();
797
74.6M
  }
798
799
  /// Retrieve the set of CVR (const-volatile-restrict) qualifiers
800
  /// applied to this type.
801
  unsigned getCVRQualifiers() const;
802
803
23.3M
  bool isConstant(const ASTContext& Ctx) const {
804
23.3M
    return QualType::isConstant(*this, Ctx);
805
23.3M
  }
806
807
  /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
808
  bool isPODType(const ASTContext &Context) const;
809
810
  /// Return true if this is a POD type according to the rules of the C++98
811
  /// standard, regardless of the current compilation's language.
812
  bool isCXX98PODType(const ASTContext &Context) const;
813
814
  /// Return true if this is a POD type according to the more relaxed rules
815
  /// of the C++11 standard, regardless of the current compilation's language.
816
  /// (C++0x [basic.types]p9). Note that, unlike
817
  /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account.
818
  bool isCXX11PODType(const ASTContext &Context) const;
819
820
  /// Return true if this is a trivial type per (C++0x [basic.types]p9)
821
  bool isTrivialType(const ASTContext &Context) const;
822
823
  /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
824
  bool isTriviallyCopyableType(const ASTContext &Context) const;
825
826
827
  /// Returns true if it is a class and it might be dynamic.
828
  bool mayBeDynamicClass() const;
829
830
  /// Returns true if it is not a class or if the class might not be dynamic.
831
  bool mayBeNotDynamicClass() const;
832
833
  // Don't promise in the API that anything besides 'const' can be
834
  // easily added.
835
836
  /// Add the `const` type qualifier to this QualType.
837
294k
  void addConst() {
838
294k
    addFastQualifiers(Qualifiers::Const);
839
294k
  }
840
4.13M
  QualType withConst() const {
841
4.13M
    return withFastQualifiers(Qualifiers::Const);
842
4.13M
  }
843
844
  /// Add the `volatile` type qualifier to this QualType.
845
112
  void addVolatile() {
846
112
    addFastQualifiers(Qualifiers::Volatile);
847
112
  }
848
394
  QualType withVolatile() const {
849
394
    return withFastQualifiers(Qualifiers::Volatile);
850
394
  }
851
852
  /// Add the `restrict` qualifier to this QualType.
853
142
  void addRestrict() {
854
142
    addFastQualifiers(Qualifiers::Restrict);
855
142
  }
856
1.18M
  QualType withRestrict() const {
857
1.18M
    return withFastQualifiers(Qualifiers::Restrict);
858
1.18M
  }
859
860
9.10k
  QualType withCVRQualifiers(unsigned CVR) const {
861
9.10k
    return withFastQualifiers(CVR);
862
9.10k
  }
863
864
1.77G
  void addFastQualifiers(unsigned TQs) {
865
1.77G
    assert(!(TQs & ~Qualifiers::FastMask)
866
1.77G
           && "non-fast qualifier bits set in mask!");
867
0
    Value.setInt(Value.getInt() | TQs);
868
1.77G
  }
869
870
  void removeLocalConst();
871
  void removeLocalVolatile();
872
  void removeLocalRestrict();
873
  void removeLocalCVRQualifiers(unsigned Mask);
874
875
12.5M
  void removeLocalFastQualifiers() { Value.setInt(0); }
876
82.2k
  void removeLocalFastQualifiers(unsigned Mask) {
877
82.2k
    assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers");
878
0
    Value.setInt(Value.getInt() & ~Mask);
879
82.2k
  }
880
881
  // Creates a type with the given qualifiers in addition to any
882
  // qualifiers already on this type.
883
1.77G
  QualType withFastQualifiers(unsigned TQs) const {
884
1.77G
    QualType T = *this;
885
1.77G
    T.addFastQualifiers(TQs);
886
1.77G
    return T;
887
1.77G
  }
888
889
  // Creates a type with exactly the given fast qualifiers, removing
890
  // any existing fast qualifiers.
891
0
  QualType withExactLocalFastQualifiers(unsigned TQs) const {
892
0
    return withoutLocalFastQualifiers().withFastQualifiers(TQs);
893
0
  }
894
895
  // Removes fast qualifiers, but leaves any extended qualifiers in place.
896
622
  QualType withoutLocalFastQualifiers() const {
897
622
    QualType T = *this;
898
622
    T.removeLocalFastQualifiers();
899
622
    return T;
900
622
  }
901
902
  QualType getCanonicalType() const;
903
904
  /// Return this type with all of the instance-specific qualifiers
905
  /// removed, but without removing any qualifiers that may have been applied
906
  /// through typedefs.
907
99.8M
  QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); }
908
909
  /// Retrieve the unqualified variant of the given type,
910
  /// removing as little sugar as possible.
911
  ///
912
  /// This routine looks through various kinds of sugar to find the
913
  /// least-desugared type that is unqualified. For example, given:
914
  ///
915
  /// \code
916
  /// typedef int Integer;
917
  /// typedef const Integer CInteger;
918
  /// typedef CInteger DifferenceType;
919
  /// \endcode
920
  ///
921
  /// Executing \c getUnqualifiedType() on the type \c DifferenceType will
922
  /// desugar until we hit the type \c Integer, which has no qualifiers on it.
923
  ///
924
  /// The resulting type might still be qualified if it's sugar for an array
925
  /// type.  To strip qualifiers even from within a sugared array type, use
926
  /// ASTContext::getUnqualifiedArrayType.
927
  inline QualType getUnqualifiedType() const;
928
929
  /// Retrieve the unqualified variant of the given type, removing as little
930
  /// sugar as possible.
931
  ///
932
  /// Like getUnqualifiedType(), but also returns the set of
933
  /// qualifiers that were built up.
934
  ///
935
  /// The resulting type might still be qualified if it's sugar for an array
936
  /// type.  To strip qualifiers even from within a sugared array type, use
937
  /// ASTContext::getUnqualifiedArrayType.
938
  inline SplitQualType getSplitUnqualifiedType() const;
939
940
  /// Determine whether this type is more qualified than the other
941
  /// given type, requiring exact equality for non-CVR qualifiers.
942
  bool isMoreQualifiedThan(QualType Other) const;
943
944
  /// Determine whether this type is at least as qualified as the other
945
  /// given type, requiring exact equality for non-CVR qualifiers.
946
  bool isAtLeastAsQualifiedAs(QualType Other) const;
947
948
  QualType getNonReferenceType() const;
949
950
  /// Determine the type of a (typically non-lvalue) expression with the
951
  /// specified result type.
952
  ///
953
  /// This routine should be used for expressions for which the return type is
954
  /// explicitly specified (e.g., in a cast or call) and isn't necessarily
955
  /// an lvalue. It removes a top-level reference (since there are no
956
  /// expressions of reference type) and deletes top-level cvr-qualifiers
957
  /// from non-class types (in C++) or all types (in C).
958
  QualType getNonLValueExprType(const ASTContext &Context) const;
959
960
  /// Remove an outer pack expansion type (if any) from this type. Used as part
961
  /// of converting the type of a declaration to the type of an expression that
962
  /// references that expression. It's meaningless for an expression to have a
963
  /// pack expansion type.
964
  QualType getNonPackExpansionType() const;
965
966
  /// Return the specified type with any "sugar" removed from
967
  /// the type.  This takes off typedefs, typeof's etc.  If the outer level of
968
  /// the type is already concrete, it returns it unmodified.  This is similar
969
  /// to getting the canonical type, but it doesn't remove *all* typedefs.  For
970
  /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is
971
  /// concrete.
972
  ///
973
  /// Qualifiers are left in place.
974
846k
  QualType getDesugaredType(const ASTContext &Context) const {
975
846k
    return getDesugaredType(*this, Context);
976
846k
  }
977
978
51.5M
  SplitQualType getSplitDesugaredType() const {
979
51.5M
    return getSplitDesugaredType(*this);
980
51.5M
  }
981
982
  /// Return the specified type with one level of "sugar" removed from
983
  /// the type.
984
  ///
985
  /// This routine takes off the first typedef, typeof, etc. If the outer level
986
  /// of the type is already concrete, it returns it unmodified.
987
1.21k
  QualType getSingleStepDesugaredType(const ASTContext &Context) const {
988
1.21k
    return getSingleStepDesugaredTypeImpl(*this, Context);
989
1.21k
  }
990
991
  /// Returns the specified type after dropping any
992
  /// outer-level parentheses.
993
422
  QualType IgnoreParens() const {
994
422
    if (isa<ParenType>(*this))
995
34
      return QualType::IgnoreParens(*this);
996
388
    return *this;
997
422
  }
998
999
  /// Indicate whether the specified types and qualifiers are identical.
1000
3.50G
  friend bool operator==(const QualType &LHS, const QualType &RHS) {
1001
3.50G
    return LHS.Value == RHS.Value;
1002
3.50G
  }
1003
281M
  friend bool operator!=(const QualType &LHS, const QualType &RHS) {
1004
281M
    return LHS.Value != RHS.Value;
1005
281M
  }
1006
36
  friend bool operator<(const QualType &LHS, const QualType &RHS) {
1007
36
    return LHS.Value < RHS.Value;
1008
36
  }
1009
1010
  static std::string getAsString(SplitQualType split,
1011
88.7k
                                 const PrintingPolicy &Policy) {
1012
88.7k
    return getAsString(split.Ty, split.Quals, Policy);
1013
88.7k
  }
1014
  static std::string getAsString(const Type *ty, Qualifiers qs,
1015
                                 const PrintingPolicy &Policy);
1016
1017
  std::string getAsString() const;
1018
  std::string getAsString(const PrintingPolicy &Policy) const;
1019
1020
  void print(raw_ostream &OS, const PrintingPolicy &Policy,
1021
             const Twine &PlaceHolder = Twine(),
1022
             unsigned Indentation = 0) const;
1023
1024
  static void print(SplitQualType split, raw_ostream &OS,
1025
                    const PrintingPolicy &policy, const Twine &PlaceHolder,
1026
1.46M
                    unsigned Indentation = 0) {
1027
1.46M
    return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation);
1028
1.46M
  }
1029
1030
  static void print(const Type *ty, Qualifiers qs,
1031
                    raw_ostream &OS, const PrintingPolicy &policy,
1032
                    const Twine &PlaceHolder,
1033
                    unsigned Indentation = 0);
1034
1035
  void getAsStringInternal(std::string &Str,
1036
                           const PrintingPolicy &Policy) const;
1037
1038
  static void getAsStringInternal(SplitQualType split, std::string &out,
1039
589k
                                  const PrintingPolicy &policy) {
1040
589k
    return getAsStringInternal(split.Ty, split.Quals, out, policy);
1041
589k
  }
1042
1043
  static void getAsStringInternal(const Type *ty, Qualifiers qs,
1044
                                  std::string &out,
1045
                                  const PrintingPolicy &policy);
1046
1047
  class StreamedQualTypeHelper {
1048
    const QualType &T;
1049
    const PrintingPolicy &Policy;
1050
    const Twine &PlaceHolder;
1051
    unsigned Indentation;
1052
1053
  public:
1054
    StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy,
1055
                           const Twine &PlaceHolder, unsigned Indentation)
1056
        : T(T), Policy(Policy), PlaceHolder(PlaceHolder),
1057
3.00k
          Indentation(Indentation) {}
1058
1059
    friend raw_ostream &operator<<(raw_ostream &OS,
1060
3.00k
                                   const StreamedQualTypeHelper &SQT) {
1061
3.00k
      SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation);
1062
3.00k
      return OS;
1063
3.00k
    }
1064
  };
1065
1066
  StreamedQualTypeHelper stream(const PrintingPolicy &Policy,
1067
                                const Twine &PlaceHolder = Twine(),
1068
3.00k
                                unsigned Indentation = 0) const {
1069
3.00k
    return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation);
1070
3.00k
  }
1071
1072
  void dump(const char *s) const;
1073
  void dump() const;
1074
  void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
1075
1076
43.1M
  void Profile(llvm::FoldingSetNodeID &ID) const {
1077
43.1M
    ID.AddPointer(getAsOpaquePtr());
1078
43.1M
  }
1079
1080
  /// Check if this type has any address space qualifier.
1081
  inline bool hasAddressSpace() const;
1082
1083
  /// Return the address space of this type.
1084
  inline LangAS getAddressSpace() const;
1085
1086
  /// Returns true if address space qualifiers overlap with T address space
1087
  /// qualifiers.
1088
  /// OpenCL C defines conversion rules for pointers to different address spaces
1089
  /// and notion of overlapping address spaces.
1090
  /// CL1.1 or CL1.2:
1091
  ///   address spaces overlap iff they are they same.
1092
  /// OpenCL C v2.0 s6.5.5 adds:
1093
  ///   __generic overlaps with any address space except for __constant.
1094
8.92k
  bool isAddressSpaceOverlapping(QualType T) const {
1095
8.92k
    Qualifiers Q = getQualifiers();
1096
8.92k
    Qualifiers TQ = T.getQualifiers();
1097
    // Address spaces overlap if at least one of them is a superset of another
1098
8.92k
    return Q.isAddressSpaceSupersetOf(TQ) || 
TQ.isAddressSpaceSupersetOf(Q)265
;
1099
8.92k
  }
1100
1101
  /// Returns gc attribute of this type.
1102
  inline Qualifiers::GC getObjCGCAttr() const;
1103
1104
  /// true when Type is objc's weak.
1105
4.17M
  bool isObjCGCWeak() const {
1106
4.17M
    return getObjCGCAttr() == Qualifiers::Weak;
1107
4.17M
  }
1108
1109
  /// true when Type is objc's strong.
1110
2.06M
  bool isObjCGCStrong() const {
1111
2.06M
    return getObjCGCAttr() == Qualifiers::Strong;
1112
2.06M
  }
1113
1114
  /// Returns lifetime attribute of this type.
1115
50.3M
  Qualifiers::ObjCLifetime getObjCLifetime() const {
1116
50.3M
    return getQualifiers().getObjCLifetime();
1117
50.3M
  }
1118
1119
3.81M
  bool hasNonTrivialObjCLifetime() const {
1120
3.81M
    return getQualifiers().hasNonTrivialObjCLifetime();
1121
3.81M
  }
1122
1123
193
  bool hasStrongOrWeakObjCLifetime() const {
1124
193
    return getQualifiers().hasStrongOrWeakObjCLifetime();
1125
193
  }
1126
1127
  // true when Type is objc's weak and weak is enabled but ARC isn't.
1128
  bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const;
1129
1130
  enum PrimitiveDefaultInitializeKind {
1131
    /// The type does not fall into any of the following categories. Note that
1132
    /// this case is zero-valued so that values of this enum can be used as a
1133
    /// boolean condition for non-triviality.
1134
    PDIK_Trivial,
1135
1136
    /// The type is an Objective-C retainable pointer type that is qualified
1137
    /// with the ARC __strong qualifier.
1138
    PDIK_ARCStrong,
1139
1140
    /// The type is an Objective-C retainable pointer type that is qualified
1141
    /// with the ARC __weak qualifier.
1142
    PDIK_ARCWeak,
1143
1144
    /// The type is a struct containing a field whose type is not PCK_Trivial.
1145
    PDIK_Struct
1146
  };
1147
1148
  /// Functions to query basic properties of non-trivial C struct types.
1149
1150
  /// Check if this is a non-trivial type that would cause a C struct
1151
  /// transitively containing this type to be non-trivial to default initialize
1152
  /// and return the kind.
1153
  PrimitiveDefaultInitializeKind
1154
  isNonTrivialToPrimitiveDefaultInitialize() const;
1155
1156
  enum PrimitiveCopyKind {
1157
    /// The type does not fall into any of the following categories. Note that
1158
    /// this case is zero-valued so that values of this enum can be used as a
1159
    /// boolean condition for non-triviality.
1160
    PCK_Trivial,
1161
1162
    /// The type would be trivial except that it is volatile-qualified. Types
1163
    /// that fall into one of the other non-trivial cases may additionally be
1164
    /// volatile-qualified.
1165
    PCK_VolatileTrivial,
1166
1167
    /// The type is an Objective-C retainable pointer type that is qualified
1168
    /// with the ARC __strong qualifier.
1169
    PCK_ARCStrong,
1170
1171
    /// The type is an Objective-C retainable pointer type that is qualified
1172
    /// with the ARC __weak qualifier.
1173
    PCK_ARCWeak,
1174
1175
    /// The type is a struct containing a field whose type is neither
1176
    /// PCK_Trivial nor PCK_VolatileTrivial.
1177
    /// Note that a C++ struct type does not necessarily match this; C++ copying
1178
    /// semantics are too complex to express here, in part because they depend
1179
    /// on the exact constructor or assignment operator that is chosen by
1180
    /// overload resolution to do the copy.
1181
    PCK_Struct
1182
  };
1183
1184
  /// Check if this is a non-trivial type that would cause a C struct
1185
  /// transitively containing this type to be non-trivial to copy and return the
1186
  /// kind.
1187
  PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const;
1188
1189
  /// Check if this is a non-trivial type that would cause a C struct
1190
  /// transitively containing this type to be non-trivial to destructively
1191
  /// move and return the kind. Destructive move in this context is a C++-style
1192
  /// move in which the source object is placed in a valid but unspecified state
1193
  /// after it is moved, as opposed to a truly destructive move in which the
1194
  /// source object is placed in an uninitialized state.
1195
  PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const;
1196
1197
  enum DestructionKind {
1198
    DK_none,
1199
    DK_cxx_destructor,
1200
    DK_objc_strong_lifetime,
1201
    DK_objc_weak_lifetime,
1202
    DK_nontrivial_c_struct
1203
  };
1204
1205
  /// Returns a nonzero value if objects of this type require
1206
  /// non-trivial work to clean up after.  Non-zero because it's
1207
  /// conceivable that qualifiers (objc_gc(weak)?) could make
1208
  /// something require destruction.
1209
20.0M
  DestructionKind isDestructedType() const {
1210
20.0M
    return isDestructedTypeImpl(*this);
1211
20.0M
  }
1212
1213
  /// Check if this is or contains a C union that is non-trivial to
1214
  /// default-initialize, which is a union that has a member that is non-trivial
1215
  /// to default-initialize. If this returns true,
1216
  /// isNonTrivialToPrimitiveDefaultInitialize returns PDIK_Struct.
1217
  bool hasNonTrivialToPrimitiveDefaultInitializeCUnion() const;
1218
1219
  /// Check if this is or contains a C union that is non-trivial to destruct,
1220
  /// which is a union that has a member that is non-trivial to destruct. If
1221
  /// this returns true, isDestructedType returns DK_nontrivial_c_struct.
1222
  bool hasNonTrivialToPrimitiveDestructCUnion() const;
1223
1224
  /// Check if this is or contains a C union that is non-trivial to copy, which
1225
  /// is a union that has a member that is non-trivial to copy. If this returns
1226
  /// true, isNonTrivialToPrimitiveCopy returns PCK_Struct.
1227
  bool hasNonTrivialToPrimitiveCopyCUnion() const;
1228
1229
  /// Determine whether expressions of the given type are forbidden
1230
  /// from being lvalues in C.
1231
  ///
1232
  /// The expression types that are forbidden to be lvalues are:
1233
  ///   - 'void', but not qualified void
1234
  ///   - function types
1235
  ///
1236
  /// The exact rule here is C99 6.3.2.1:
1237
  ///   An lvalue is an expression with an object type or an incomplete
1238
  ///   type other than void.
1239
  bool isCForbiddenLValueType() const;
1240
1241
  /// Substitute type arguments for the Objective-C type parameters used in the
1242
  /// subject type.
1243
  ///
1244
  /// \param ctx ASTContext in which the type exists.
1245
  ///
1246
  /// \param typeArgs The type arguments that will be substituted for the
1247
  /// Objective-C type parameters in the subject type, which are generally
1248
  /// computed via \c Type::getObjCSubstitutions. If empty, the type
1249
  /// parameters will be replaced with their bounds or id/Class, as appropriate
1250
  /// for the context.
1251
  ///
1252
  /// \param context The context in which the subject type was written.
1253
  ///
1254
  /// \returns the resulting type.
1255
  QualType substObjCTypeArgs(ASTContext &ctx,
1256
                             ArrayRef<QualType> typeArgs,
1257
                             ObjCSubstitutionContext context) const;
1258
1259
  /// Substitute type arguments from an object type for the Objective-C type
1260
  /// parameters used in the subject type.
1261
  ///
1262
  /// This operation combines the computation of type arguments for
1263
  /// substitution (\c Type::getObjCSubstitutions) with the actual process of
1264
  /// substitution (\c QualType::substObjCTypeArgs) for the convenience of
1265
  /// callers that need to perform a single substitution in isolation.
1266
  ///
1267
  /// \param objectType The type of the object whose member type we're
1268
  /// substituting into. For example, this might be the receiver of a message
1269
  /// or the base of a property access.
1270
  ///
1271
  /// \param dc The declaration context from which the subject type was
1272
  /// retrieved, which indicates (for example) which type parameters should
1273
  /// be substituted.
1274
  ///
1275
  /// \param context The context in which the subject type was written.
1276
  ///
1277
  /// \returns the subject type after replacing all of the Objective-C type
1278
  /// parameters with their corresponding arguments.
1279
  QualType substObjCMemberType(QualType objectType,
1280
                               const DeclContext *dc,
1281
                               ObjCSubstitutionContext context) const;
1282
1283
  /// Strip Objective-C "__kindof" types from the given type.
1284
  QualType stripObjCKindOfType(const ASTContext &ctx) const;
1285
1286
  /// Remove all qualifiers including _Atomic.
1287
  QualType getAtomicUnqualifiedType() const;
1288
1289
private:
1290
  // These methods are implemented in a separate translation unit;
1291
  // "static"-ize them to avoid creating temporary QualTypes in the
1292
  // caller.
1293
  static bool isConstant(QualType T, const ASTContext& Ctx);
1294
  static QualType getDesugaredType(QualType T, const ASTContext &Context);
1295
  static SplitQualType getSplitDesugaredType(QualType T);
1296
  static SplitQualType getSplitUnqualifiedTypeImpl(QualType type);
1297
  static QualType getSingleStepDesugaredTypeImpl(QualType type,
1298
                                                 const ASTContext &C);
1299
  static QualType IgnoreParens(QualType T);
1300
  static DestructionKind isDestructedTypeImpl(QualType type);
1301
1302
  /// Check if \param RD is or contains a non-trivial C union.
1303
  static bool hasNonTrivialToPrimitiveDefaultInitializeCUnion(const RecordDecl *RD);
1304
  static bool hasNonTrivialToPrimitiveDestructCUnion(const RecordDecl *RD);
1305
  static bool hasNonTrivialToPrimitiveCopyCUnion(const RecordDecl *RD);
1306
};
1307
1308
} // namespace clang
1309
1310
namespace llvm {
1311
1312
/// Implement simplify_type for QualType, so that we can dyn_cast from QualType
1313
/// to a specific Type class.
1314
template<> struct simplify_type< ::clang::QualType> {
1315
  using SimpleType = const ::clang::Type *;
1316
1317
11.3G
  static SimpleType getSimplifiedValue(::clang::QualType Val) {
1318
11.3G
    return Val.getTypePtr();
1319
11.3G
  }
1320
};
1321
1322
// Teach SmallPtrSet that QualType is "basically a pointer".
1323
template<>
1324
struct PointerLikeTypeTraits<clang::QualType> {
1325
139M
  static inline void *getAsVoidPointer(clang::QualType P) {
1326
139M
    return P.getAsOpaquePtr();
1327
139M
  }
1328
1329
180M
  static inline clang::QualType getFromVoidPointer(void *P) {
1330
180M
    return clang::QualType::getFromOpaquePtr(P);
1331
180M
  }
1332
1333
  // Various qualifiers go in low bits.
1334
  static constexpr int NumLowBitsAvailable = 0;
1335
};
1336
1337
} // namespace llvm
1338
1339
namespace clang {
1340
1341
/// Base class that is common to both the \c ExtQuals and \c Type
1342
/// classes, which allows \c QualType to access the common fields between the
1343
/// two.
1344
class ExtQualsTypeCommonBase {
1345
  friend class ExtQuals;
1346
  friend class QualType;
1347
  friend class Type;
1348
1349
  /// The "base" type of an extended qualifiers type (\c ExtQuals) or
1350
  /// a self-referential pointer (for \c Type).
1351
  ///
1352
  /// This pointer allows an efficient mapping from a QualType to its
1353
  /// underlying type pointer.
1354
  const Type *const BaseType;
1355
1356
  /// The canonical type of this type.  A QualType.
1357
  QualType CanonicalType;
1358
1359
  ExtQualsTypeCommonBase(const Type *baseType, QualType canon)
1360
74.8M
      : BaseType(baseType), CanonicalType(canon) {}
1361
};
1362
1363
/// We can encode up to four bits in the low bits of a
1364
/// type pointer, but there are many more type qualifiers that we want
1365
/// to be able to apply to an arbitrary type.  Therefore we have this
1366
/// struct, intended to be heap-allocated and used by QualType to
1367
/// store qualifiers.
1368
///
1369
/// The current design tags the 'const', 'restrict', and 'volatile' qualifiers
1370
/// in three low bits on the QualType pointer; a fourth bit records whether
1371
/// the pointer is an ExtQuals node. The extended qualifiers (address spaces,
1372
/// Objective-C GC attributes) are much more rare.
1373
class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode {
1374
  // NOTE: changing the fast qualifiers should be straightforward as
1375
  // long as you don't make 'const' non-fast.
1376
  // 1. Qualifiers:
1377
  //    a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ).
1378
  //       Fast qualifiers must occupy the low-order bits.
1379
  //    b) Update Qualifiers::FastWidth and FastMask.
1380
  // 2. QualType:
1381
  //    a) Update is{Volatile,Restrict}Qualified(), defined inline.
1382
  //    b) Update remove{Volatile,Restrict}, defined near the end of
1383
  //       this header.
1384
  // 3. ASTContext:
1385
  //    a) Update get{Volatile,Restrict}Type.
1386
1387
  /// The immutable set of qualifiers applied by this node. Always contains
1388
  /// extended qualifiers.
1389
  Qualifiers Quals;
1390
1391
24.2k
  ExtQuals *this_() { return this; }
1392
1393
public:
1394
  ExtQuals(const Type *baseType, QualType canon, Qualifiers quals)
1395
      : ExtQualsTypeCommonBase(baseType,
1396
                               canon.isNull() ? QualType(this_(), 0) : canon),
1397
40.9k
        Quals(quals) {
1398
40.9k
    assert(Quals.hasNonFastQualifiers()
1399
40.9k
           && "ExtQuals created with no fast qualifiers");
1400
0
    assert(!Quals.hasFastQualifiers()
1401
40.9k
           && "ExtQuals created with fast qualifiers");
1402
40.9k
  }
1403
1404
5.10M
  Qualifiers getQualifiers() const { return Quals; }
1405
1406
0
  bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); }
1407
0
  Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); }
1408
1409
0
  bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); }
1410
0
  Qualifiers::ObjCLifetime getObjCLifetime() const {
1411
0
    return Quals.getObjCLifetime();
1412
0
  }
1413
1414
0
  bool hasAddressSpace() const { return Quals.hasAddressSpace(); }
1415
0
  LangAS getAddressSpace() const { return Quals.getAddressSpace(); }
1416
1417
1.58M
  const Type *getBaseType() const { return BaseType; }
1418
1419
public:
1420
878k
  void Profile(llvm::FoldingSetNodeID &ID) const {
1421
878k
    Profile(ID, getBaseType(), Quals);
1422
878k
  }
1423
1424
  static void Profile(llvm::FoldingSetNodeID &ID,
1425
                      const Type *BaseType,
1426
1.43M
                      Qualifiers Quals) {
1427
1.43M
    assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!");
1428
0
    ID.AddPointer(BaseType);
1429
1.43M
    Quals.Profile(ID);
1430
1.43M
  }
1431
};
1432
1433
/// The kind of C++11 ref-qualifier associated with a function type.
1434
/// This determines whether a member function's "this" object can be an
1435
/// lvalue, rvalue, or neither.
1436
enum RefQualifierKind {
1437
  /// No ref-qualifier was provided.
1438
  RQ_None = 0,
1439
1440
  /// An lvalue ref-qualifier was provided (\c &).
1441
  RQ_LValue,
1442
1443
  /// An rvalue ref-qualifier was provided (\c &&).
1444
  RQ_RValue
1445
};
1446
1447
/// Which keyword(s) were used to create an AutoType.
1448
enum class AutoTypeKeyword {
1449
  /// auto
1450
  Auto,
1451
1452
  /// decltype(auto)
1453
  DecltypeAuto,
1454
1455
  /// __auto_type (GNU extension)
1456
  GNUAutoType
1457
};
1458
1459
/// The base class of the type hierarchy.
1460
///
1461
/// A central concept with types is that each type always has a canonical
1462
/// type.  A canonical type is the type with any typedef names stripped out
1463
/// of it or the types it references.  For example, consider:
1464
///
1465
///  typedef int  foo;
1466
///  typedef foo* bar;
1467
///    'int *'    'foo *'    'bar'
1468
///
1469
/// There will be a Type object created for 'int'.  Since int is canonical, its
1470
/// CanonicalType pointer points to itself.  There is also a Type for 'foo' (a
1471
/// TypedefType).  Its CanonicalType pointer points to the 'int' Type.  Next
1472
/// there is a PointerType that represents 'int*', which, like 'int', is
1473
/// canonical.  Finally, there is a PointerType type for 'foo*' whose canonical
1474
/// type is 'int*', and there is a TypedefType for 'bar', whose canonical type
1475
/// is also 'int*'.
1476
///
1477
/// Non-canonical types are useful for emitting diagnostics, without losing
1478
/// information about typedefs being used.  Canonical types are useful for type
1479
/// comparisons (they allow by-pointer equality tests) and useful for reasoning
1480
/// about whether something has a particular form (e.g. is a function type),
1481
/// because they implicitly, recursively, strip all typedefs out of a type.
1482
///
1483
/// Types, once created, are immutable.
1484
///
1485
class alignas(8) Type : public ExtQualsTypeCommonBase {
1486
public:
1487
  enum TypeClass {
1488
#define TYPE(Class, Base) Class,
1489
#define LAST_TYPE(Class) TypeLast = Class
1490
#define ABSTRACT_TYPE(Class, Base)
1491
#include "clang/AST/TypeNodes.inc"
1492
  };
1493
1494
private:
1495
  /// Bitfields required by the Type class.
1496
  class TypeBitfields {
1497
    friend class Type;
1498
    template <class T> friend class TypePropertyCache;
1499
1500
    /// TypeClass bitfield - Enum that specifies what subclass this belongs to.
1501
    unsigned TC : 8;
1502
1503
    /// Store information on the type dependency.
1504
    unsigned Dependence : llvm::BitWidth<TypeDependence>;
1505
1506
    /// True if the cache (i.e. the bitfields here starting with
1507
    /// 'Cache') is valid.
1508
    mutable unsigned CacheValid : 1;
1509
1510
    /// Linkage of this type.
1511
    mutable unsigned CachedLinkage : 3;
1512
1513
    /// Whether this type involves and local or unnamed types.
1514
    mutable unsigned CachedLocalOrUnnamed : 1;
1515
1516
    /// Whether this type comes from an AST file.
1517
    mutable unsigned FromAST : 1;
1518
1519
20.2M
    bool isCacheValid() const {
1520
20.2M
      return CacheValid;
1521
20.2M
    }
1522
1523
7.96M
    Linkage getLinkage() const {
1524
7.96M
      assert(isCacheValid() && "getting linkage from invalid cache");
1525
0
      return static_cast<Linkage>(CachedLinkage);
1526
7.96M
    }
1527
1528
2.94M
    bool hasLocalOrUnnamedType() const {
1529
2.94M
      assert(isCacheValid() && "getting linkage from invalid cache");
1530
0
      return CachedLocalOrUnnamed;
1531
2.94M
    }
1532
  };
1533
  enum { NumTypeBits = 8 + llvm::BitWidth<TypeDependence> + 6 };
1534
1535
protected:
1536
  // These classes allow subclasses to somewhat cleanly pack bitfields
1537
  // into Type.
1538
1539
  class ArrayTypeBitfields {
1540
    friend class ArrayType;
1541
1542
    unsigned : NumTypeBits;
1543
1544
    /// CVR qualifiers from declarations like
1545
    /// 'int X[static restrict 4]'. For function parameters only.
1546
    unsigned IndexTypeQuals : 3;
1547
1548
    /// Storage class qualifiers from declarations like
1549
    /// 'int X[static restrict 4]'. For function parameters only.
1550
    /// Actually an ArrayType::ArraySizeModifier.
1551
    unsigned SizeModifier : 3;
1552
  };
1553
1554
  class ConstantArrayTypeBitfields {
1555
    friend class ConstantArrayType;
1556
1557
    unsigned : NumTypeBits + 3 + 3;
1558
1559
    /// Whether we have a stored size expression.
1560
    unsigned HasStoredSizeExpr : 1;
1561
  };
1562
1563
  class BuiltinTypeBitfields {
1564
    friend class BuiltinType;
1565
1566
    unsigned : NumTypeBits;
1567
1568
    /// The kind (BuiltinType::Kind) of builtin type this is.
1569
    unsigned Kind : 8;
1570
  };
1571
1572
  /// FunctionTypeBitfields store various bits belonging to FunctionProtoType.
1573
  /// Only common bits are stored here. Additional uncommon bits are stored
1574
  /// in a trailing object after FunctionProtoType.
1575
  class FunctionTypeBitfields {
1576
    friend class FunctionProtoType;
1577
    friend class FunctionType;
1578
1579
    unsigned : NumTypeBits;
1580
1581
    /// Extra information which affects how the function is called, like
1582
    /// regparm and the calling convention.
1583
    unsigned ExtInfo : 13;
1584
1585
    /// The ref-qualifier associated with a \c FunctionProtoType.
1586
    ///
1587
    /// This is a value of type \c RefQualifierKind.
1588
    unsigned RefQualifier : 2;
1589
1590
    /// Used only by FunctionProtoType, put here to pack with the
1591
    /// other bitfields.
1592
    /// The qualifiers are part of FunctionProtoType because...
1593
    ///
1594
    /// C++ 8.3.5p4: The return type, the parameter type list and the
1595
    /// cv-qualifier-seq, [...], are part of the function type.
1596
    unsigned FastTypeQuals : Qualifiers::FastWidth;
1597
    /// Whether this function has extended Qualifiers.
1598
    unsigned HasExtQuals : 1;
1599
1600
    /// The number of parameters this function has, not counting '...'.
1601
    /// According to [implimits] 8 bits should be enough here but this is
1602
    /// somewhat easy to exceed with metaprogramming and so we would like to
1603
    /// keep NumParams as wide as reasonably possible.
1604
    unsigned NumParams : 16;
1605
1606
    /// The type of exception specification this function has.
1607
    unsigned ExceptionSpecType : 4;
1608
1609
    /// Whether this function has extended parameter information.
1610
    unsigned HasExtParameterInfos : 1;
1611
1612
    /// Whether the function is variadic.
1613
    unsigned Variadic : 1;
1614
1615
    /// Whether this function has a trailing return type.
1616
    unsigned HasTrailingReturn : 1;
1617
  };
1618
1619
  class ObjCObjectTypeBitfields {
1620
    friend class ObjCObjectType;
1621
1622
    unsigned : NumTypeBits;
1623
1624
    /// The number of type arguments stored directly on this object type.
1625
    unsigned NumTypeArgs : 7;
1626
1627
    /// The number of protocols stored directly on this object type.
1628
    unsigned NumProtocols : 6;
1629
1630
    /// Whether this is a "kindof" type.
1631
    unsigned IsKindOf : 1;
1632
  };
1633
1634
  class ReferenceTypeBitfields {
1635
    friend class ReferenceType;
1636
1637
    unsigned : NumTypeBits;
1638
1639
    /// True if the type was originally spelled with an lvalue sigil.
1640
    /// This is never true of rvalue references but can also be false
1641
    /// on lvalue references because of C++0x [dcl.typedef]p9,
1642
    /// as follows:
1643
    ///
1644
    ///   typedef int &ref;    // lvalue, spelled lvalue
1645
    ///   typedef int &&rvref; // rvalue
1646
    ///   ref &a;              // lvalue, inner ref, spelled lvalue
1647
    ///   ref &&a;             // lvalue, inner ref
1648
    ///   rvref &a;            // lvalue, inner ref, spelled lvalue
1649
    ///   rvref &&a;           // rvalue, inner ref
1650
    unsigned SpelledAsLValue : 1;
1651
1652
    /// True if the inner type is a reference type.  This only happens
1653
    /// in non-canonical forms.
1654
    unsigned InnerRef : 1;
1655
  };
1656
1657
  class TypeWithKeywordBitfields {
1658
    friend class TypeWithKeyword;
1659
1660
    unsigned : NumTypeBits;
1661
1662
    /// An ElaboratedTypeKeyword.  8 bits for efficient access.
1663
    unsigned Keyword : 8;
1664
  };
1665
1666
  enum { NumTypeWithKeywordBits = 8 };
1667
1668
  class ElaboratedTypeBitfields {
1669
    friend class ElaboratedType;
1670
1671
    unsigned : NumTypeBits;
1672
    unsigned : NumTypeWithKeywordBits;
1673
1674
    /// Whether the ElaboratedType has a trailing OwnedTagDecl.
1675
    unsigned HasOwnedTagDecl : 1;
1676
  };
1677
1678
  class VectorTypeBitfields {
1679
    friend class VectorType;
1680
    friend class DependentVectorType;
1681
1682
    unsigned : NumTypeBits;
1683
1684
    /// The kind of vector, either a generic vector type or some
1685
    /// target-specific vector type such as for AltiVec or Neon.
1686
    unsigned VecKind : 3;
1687
    /// The number of elements in the vector.
1688
    uint32_t NumElements;
1689
  };
1690
1691
  class AttributedTypeBitfields {
1692
    friend class AttributedType;
1693
1694
    unsigned : NumTypeBits;
1695
1696
    /// An AttributedType::Kind
1697
    unsigned AttrKind : 32 - NumTypeBits;
1698
  };
1699
1700
  class AutoTypeBitfields {
1701
    friend class AutoType;
1702
1703
    unsigned : NumTypeBits;
1704
1705
    /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
1706
    /// or '__auto_type'?  AutoTypeKeyword value.
1707
    unsigned Keyword : 2;
1708
1709
    /// The number of template arguments in the type-constraints, which is
1710
    /// expected to be able to hold at least 1024 according to [implimits].
1711
    /// However as this limit is somewhat easy to hit with template
1712
    /// metaprogramming we'd prefer to keep it as large as possible.
1713
    /// At the moment it has been left as a non-bitfield since this type
1714
    /// safely fits in 64 bits as an unsigned, so there is no reason to
1715
    /// introduce the performance impact of a bitfield.
1716
    unsigned NumArgs;
1717
  };
1718
1719
  class SubstTemplateTypeParmPackTypeBitfields {
1720
    friend class SubstTemplateTypeParmPackType;
1721
1722
    unsigned : NumTypeBits;
1723
1724
    /// The number of template arguments in \c Arguments, which is
1725
    /// expected to be able to hold at least 1024 according to [implimits].
1726
    /// However as this limit is somewhat easy to hit with template
1727
    /// metaprogramming we'd prefer to keep it as large as possible.
1728
    /// At the moment it has been left as a non-bitfield since this type
1729
    /// safely fits in 64 bits as an unsigned, so there is no reason to
1730
    /// introduce the performance impact of a bitfield.
1731
    unsigned NumArgs;
1732
  };
1733
1734
  class TemplateSpecializationTypeBitfields {
1735
    friend class TemplateSpecializationType;
1736
1737
    unsigned : NumTypeBits;
1738
1739
    /// Whether this template specialization type is a substituted type alias.
1740
    unsigned TypeAlias : 1;
1741
1742
    /// The number of template arguments named in this class template
1743
    /// specialization, which is expected to be able to hold at least 1024
1744
    /// according to [implimits]. However, as this limit is somewhat easy to
1745
    /// hit with template metaprogramming we'd prefer to keep it as large
1746
    /// as possible. At the moment it has been left as a non-bitfield since
1747
    /// this type safely fits in 64 bits as an unsigned, so there is no reason
1748
    /// to introduce the performance impact of a bitfield.
1749
    unsigned NumArgs;
1750
  };
1751
1752
  class DependentTemplateSpecializationTypeBitfields {
1753
    friend class DependentTemplateSpecializationType;
1754
1755
    unsigned : NumTypeBits;
1756
    unsigned : NumTypeWithKeywordBits;
1757
1758
    /// The number of template arguments named in this class template
1759
    /// specialization, which is expected to be able to hold at least 1024
1760
    /// according to [implimits]. However, as this limit is somewhat easy to
1761
    /// hit with template metaprogramming we'd prefer to keep it as large
1762
    /// as possible. At the moment it has been left as a non-bitfield since
1763
    /// this type safely fits in 64 bits as an unsigned, so there is no reason
1764
    /// to introduce the performance impact of a bitfield.
1765
    unsigned NumArgs;
1766
  };
1767
1768
  class PackExpansionTypeBitfields {
1769
    friend class PackExpansionType;
1770
1771
    unsigned : NumTypeBits;
1772
1773
    /// The number of expansions that this pack expansion will
1774
    /// generate when substituted (+1), which is expected to be able to
1775
    /// hold at least 1024 according to [implimits]. However, as this limit
1776
    /// is somewhat easy to hit with template metaprogramming we'd prefer to
1777
    /// keep it as large as possible. At the moment it has been left as a
1778
    /// non-bitfield since this type safely fits in 64 bits as an unsigned, so
1779
    /// there is no reason to introduce the performance impact of a bitfield.
1780
    ///
1781
    /// This field will only have a non-zero value when some of the parameter
1782
    /// packs that occur within the pattern have been substituted but others
1783
    /// have not.
1784
    unsigned NumExpansions;
1785
  };
1786
1787
  union {
1788
    TypeBitfields TypeBits;
1789
    ArrayTypeBitfields ArrayTypeBits;
1790
    ConstantArrayTypeBitfields ConstantArrayTypeBits;
1791
    AttributedTypeBitfields AttributedTypeBits;
1792
    AutoTypeBitfields AutoTypeBits;
1793
    BuiltinTypeBitfields BuiltinTypeBits;
1794
    FunctionTypeBitfields FunctionTypeBits;
1795
    ObjCObjectTypeBitfields ObjCObjectTypeBits;
1796
    ReferenceTypeBitfields ReferenceTypeBits;
1797
    TypeWithKeywordBitfields TypeWithKeywordBits;
1798
    ElaboratedTypeBitfields ElaboratedTypeBits;
1799
    VectorTypeBitfields VectorTypeBits;
1800
    SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits;
1801
    TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits;
1802
    DependentTemplateSpecializationTypeBitfields
1803
      DependentTemplateSpecializationTypeBits;
1804
    PackExpansionTypeBitfields PackExpansionTypeBits;
1805
  };
1806
1807
private:
1808
  template <class T> friend class TypePropertyCache;
1809
1810
  /// Set whether this type comes from an AST file.
1811
7.49M
  void setFromAST(bool V = true) const {
1812
7.49M
    TypeBits.FromAST = V;
1813
7.49M
  }
1814
1815
protected:
1816
  friend class ASTContext;
1817
1818
  Type(TypeClass tc, QualType canon, TypeDependence Dependence)
1819
      : ExtQualsTypeCommonBase(this,
1820
74.8M
                               canon.isNull() ? QualType(this_(), 0) : canon) {
1821
74.8M
    static_assert(sizeof(*this) <= 8 + sizeof(ExtQualsTypeCommonBase),
1822
74.8M
                  "changing bitfields changed sizeof(Type)!");
1823
74.8M
    static_assert(alignof(decltype(*this)) % sizeof(void *) == 0,
1824
74.8M
                  "Insufficient alignment!");
1825
74.8M
    TypeBits.TC = tc;
1826
74.8M
    TypeBits.Dependence = static_cast<unsigned>(Dependence);
1827
74.8M
    TypeBits.CacheValid = false;
1828
74.8M
    TypeBits.CachedLocalOrUnnamed = false;
1829
74.8M
    TypeBits.CachedLinkage = NoLinkage;
1830
74.8M
    TypeBits.FromAST = false;
1831
74.8M
  }
1832
1833
  // silence VC++ warning C4355: 'this' : used in base member initializer list
1834
25.2M
  Type *this_() { return this; }
1835
1836
74.3M
  void setDependence(TypeDependence D) {
1837
74.3M
    TypeBits.Dependence = static_cast<unsigned>(D);
1838
74.3M
  }
1839
1840
74.3M
  void addDependence(TypeDependence D) { setDependence(getDependence() | D); }
1841
1842
public:
1843
  friend class ASTReader;
1844
  friend class ASTWriter;
1845
  template <class T> friend class serialization::AbstractTypeReader;
1846
  template <class T> friend class serialization::AbstractTypeWriter;
1847
1848
  Type(const Type &) = delete;
1849
  Type(Type &&) = delete;
1850
  Type &operator=(const Type &) = delete;
1851
  Type &operator=(Type &&) = delete;
1852
1853
28.9G
  TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
1854
1855
  /// Whether this type comes from an AST file.
1856
4.85k
  bool isFromAST() const { return TypeBits.FromAST; }
1857
1858
  /// Whether this type is or contains an unexpanded parameter
1859
  /// pack, used to support C++0x variadic templates.
1860
  ///
1861
  /// A type that contains a parameter pack shall be expanded by the
1862
  /// ellipsis operator at some point. For example, the typedef in the
1863
  /// following example contains an unexpanded parameter pack 'T':
1864
  ///
1865
  /// \code
1866
  /// template<typename ...T>
1867
  /// struct X {
1868
  ///   typedef T* pointer_types; // ill-formed; T is a parameter pack.
1869
  /// };
1870
  /// \endcode
1871
  ///
1872
  /// Note that this routine does not specify which
1873
39.8M
  bool containsUnexpandedParameterPack() const {
1874
39.8M
    return getDependence() & TypeDependence::UnexpandedPack;
1875
39.8M
  }
1876
1877
  /// Determines if this type would be canonical if it had no further
1878
  /// qualification.
1879
1.87G
  bool isCanonicalUnqualified() const {
1880
1.87G
    return CanonicalType == QualType(this, 0);
1881
1.87G
  }
1882
1883
  /// Pull a single level of sugar off of this locally-unqualified type.
1884
  /// Users should generally prefer SplitQualType::getSingleStepDesugaredType()
1885
  /// or QualType::getSingleStepDesugaredType(const ASTContext&).
1886
  QualType getLocallyUnqualifiedSingleStepDesugaredType() const;
1887
1888
  /// As an extension, we classify types as one of "sized" or "sizeless";
1889
  /// every type is one or the other.  Standard types are all sized;
1890
  /// sizeless types are purely an extension.
1891
  ///
1892
  /// Sizeless types contain data with no specified size, alignment,
1893
  /// or layout.
1894
  bool isSizelessType() const;
1895
  bool isSizelessBuiltinType() const;
1896
1897
  /// Determines if this is a sizeless type supported by the
1898
  /// 'arm_sve_vector_bits' type attribute, which can be applied to a single
1899
  /// SVE vector or predicate, excluding tuple types such as svint32x4_t.
1900
  bool isVLSTBuiltinType() const;
1901
1902
  /// Returns the representative type for the element of an SVE builtin type.
1903
  /// This is used to represent fixed-length SVE vectors created with the
1904
  /// 'arm_sve_vector_bits' type attribute as VectorType.
1905
  QualType getSveEltType(const ASTContext &Ctx) const;
1906
1907
  /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
1908
  /// object types, function types, and incomplete types.
1909
1910
  /// Return true if this is an incomplete type.
1911
  /// A type that can describe objects, but which lacks information needed to
1912
  /// determine its size (e.g. void, or a fwd declared struct). Clients of this
1913
  /// routine will need to determine if the size is actually required.
1914
  ///
1915
  /// Def If non-null, and the type refers to some kind of declaration
1916
  /// that can be completed (such as a C struct, C++ class, or Objective-C
1917
  /// class), will be set to the declaration.
1918
  bool isIncompleteType(NamedDecl **Def = nullptr) const;
1919
1920
  /// Return true if this is an incomplete or object
1921
  /// type, in other words, not a function type.
1922
811k
  bool isIncompleteOrObjectType() const {
1923
811k
    return !isFunctionType();
1924
811k
  }
1925
1926
  /// Determine whether this type is an object type.
1927
712k
  bool isObjectType() const {
1928
    // C++ [basic.types]p8:
1929
    //   An object type is a (possibly cv-qualified) type that is not a
1930
    //   function type, not a reference type, and not a void type.
1931
712k
    return !isReferenceType() && 
!isFunctionType()690k
&&
!isVoidType()538k
;
1932
712k
  }
1933
1934
  /// Return true if this is a literal type
1935
  /// (C++11 [basic.types]p10)
1936
  bool isLiteralType(const ASTContext &Ctx) const;
1937
1938
  /// Determine if this type is a structural type, per C++20 [temp.param]p7.
1939
  bool isStructuralType() const;
1940
1941
  /// Test if this type is a standard-layout type.
1942
  /// (C++0x [basic.type]p9)
1943
  bool isStandardLayoutType() const;
1944
1945
  /// Helper methods to distinguish type categories. All type predicates
1946
  /// operate on the canonical type, ignoring typedefs and qualifiers.
1947
1948
  /// Returns true if the type is a builtin type.
1949
  bool isBuiltinType() const;
1950
1951
  /// Test for a particular builtin type.
1952
  bool isSpecificBuiltinType(unsigned K) const;
1953
1954
  /// Test for a type which does not represent an actual type-system type but
1955
  /// is instead used as a placeholder for various convenient purposes within
1956
  /// Clang.  All such types are BuiltinTypes.
1957
  bool isPlaceholderType() const;
1958
  const BuiltinType *getAsPlaceholderType() const;
1959
1960
  /// Test for a specific placeholder type.
1961
  bool isSpecificPlaceholderType(unsigned K) const;
1962
1963
  /// Test for a placeholder type other than Overload; see
1964
  /// BuiltinType::isNonOverloadPlaceholderType.
1965
  bool isNonOverloadPlaceholderType() const;
1966
1967
  /// isIntegerType() does *not* include complex integers (a GCC extension).
1968
  /// isComplexIntegerType() can be used to test for complex integers.
1969
  bool isIntegerType() const;     // C99 6.2.5p17 (int, char, bool, enum)
1970
  bool isEnumeralType() const;
1971
1972
  /// Determine whether this type is a scoped enumeration type.
1973
  bool isScopedEnumeralType() const;
1974
  bool isBooleanType() const;
1975
  bool isCharType() const;
1976
  bool isWideCharType() const;
1977
  bool isChar8Type() const;
1978
  bool isChar16Type() const;
1979
  bool isChar32Type() const;
1980
  bool isAnyCharacterType() const;
1981
  bool isIntegralType(const ASTContext &Ctx) const;
1982
1983
  /// Determine whether this type is an integral or enumeration type.
1984
  bool isIntegralOrEnumerationType() const;
1985
1986
  /// Determine whether this type is an integral or unscoped enumeration type.
1987
  bool isIntegralOrUnscopedEnumerationType() const;
1988
  bool isUnscopedEnumerationType() const;
1989
1990
  /// Floating point categories.
1991
  bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
1992
  /// isComplexType() does *not* include complex integers (a GCC extension).
1993
  /// isComplexIntegerType() can be used to test for complex integers.
1994
  bool isComplexType() const;      // C99 6.2.5p11 (complex)
1995
  bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
1996
  bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
1997
  bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
1998
  bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
1999
  bool isBFloat16Type() const;
2000
  bool isFloat128Type() const;
2001
  bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
2002
  bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
2003
  bool isVoidType() const;         // C99 6.2.5p19
2004
  bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
2005
  bool isAggregateType() const;
2006
  bool isFundamentalType() const;
2007
  bool isCompoundType() const;
2008
2009
  // Type Predicates: Check to see if this type is structurally the specified
2010
  // type, ignoring typedefs and qualifiers.
2011
  bool isFunctionType() const;
2012
2.89k
  bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
2013
139M
  bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
2014
  bool isPointerType() const;
2015
  bool isAnyPointerType() const;   // Any C pointer or ObjC object pointer
2016
  bool isBlockPointerType() const;
2017
  bool isVoidPointerType() const;
2018
  bool isReferenceType() const;
2019
  bool isLValueReferenceType() const;
2020
  bool isRValueReferenceType() const;
2021
  bool isObjectPointerType() const;
2022
  bool isFunctionPointerType() const;
2023
  bool isFunctionReferenceType() const;
2024
  bool isMemberPointerType() const;
2025
  bool isMemberFunctionPointerType() const;
2026
  bool isMemberDataPointerType() const;
2027
  bool isArrayType() const;
2028
  bool isConstantArrayType() const;
2029
  bool isIncompleteArrayType() const;
2030
  bool isVariableArrayType() const;
2031
  bool isDependentSizedArrayType() const;
2032
  bool isRecordType() const;
2033
  bool isClassType() const;
2034
  bool isStructureType() const;
2035
  bool isObjCBoxableRecordType() const;
2036
  bool isInterfaceType() const;
2037
  bool isStructureOrClassType() const;
2038
  bool isUnionType() const;
2039
  bool isComplexIntegerType() const;            // GCC _Complex integer type.
2040
  bool isVectorType() const;                    // GCC vector type.
2041
  bool isExtVectorType() const;                 // Extended vector type.
2042
  bool isMatrixType() const;                    // Matrix type.
2043
  bool isConstantMatrixType() const;            // Constant matrix type.
2044
  bool isDependentAddressSpaceType() const;     // value-dependent address space qualifier
2045
  bool isObjCObjectPointerType() const;         // pointer to ObjC object
2046
  bool isObjCRetainableType() const;            // ObjC object or block pointer
2047
  bool isObjCLifetimeType() const;              // (array of)* retainable type
2048
  bool isObjCIndirectLifetimeType() const;      // (pointer to)* lifetime type
2049
  bool isObjCNSObjectType() const;              // __attribute__((NSObject))
2050
  bool isObjCIndependentClassType() const;      // __attribute__((objc_independent_class))
2051
  // FIXME: change this to 'raw' interface type, so we can used 'interface' type
2052
  // for the common case.
2053
  bool isObjCObjectType() const;                // NSString or typeof(*(id)0)
2054
  bool isObjCQualifiedInterfaceType() const;    // NSString<foo>
2055
  bool isObjCQualifiedIdType() const;           // id<foo>
2056
  bool isObjCQualifiedClassType() const;        // Class<foo>
2057
  bool isObjCObjectOrInterfaceType() const;
2058
  bool isObjCIdType() const;                    // id
2059
  bool isDecltypeType() const;
2060
  /// Was this type written with the special inert-in-ARC __unsafe_unretained
2061
  /// qualifier?
2062
  ///
2063
  /// This approximates the answer to the following question: if this
2064
  /// translation unit were compiled in ARC, would this type be qualified
2065
  /// with __unsafe_unretained?
2066
82
  bool isObjCInertUnsafeUnretainedType() const {
2067
82
    return hasAttr(attr::ObjCInertUnsafeUnretained);
2068
82
  }
2069
2070
  /// Whether the type is Objective-C 'id' or a __kindof type of an
2071
  /// object type, e.g., __kindof NSView * or __kindof id
2072
  /// <NSCopying>.
2073
  ///
2074
  /// \param bound Will be set to the bound on non-id subtype types,
2075
  /// which will be (possibly specialized) Objective-C class type, or
2076
  /// null for 'id.
2077
  bool isObjCIdOrObjectKindOfType(const ASTContext &ctx,
2078
                                  const ObjCObjectType *&bound) const;
2079
2080
  bool isObjCClassType() const;                 // Class
2081
2082
  /// Whether the type is Objective-C 'Class' or a __kindof type of an
2083
  /// Class type, e.g., __kindof Class <NSCopying>.
2084
  ///
2085
  /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound
2086
  /// here because Objective-C's type system cannot express "a class
2087
  /// object for a subclass of NSFoo".
2088
  bool isObjCClassOrClassKindOfType() const;
2089
2090
  bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const;
2091
  bool isObjCSelType() const;                 // Class
2092
  bool isObjCBuiltinType() const;               // 'id' or 'Class'
2093
  bool isObjCARCBridgableType() const;
2094
  bool isCARCBridgableType() const;
2095
  bool isTemplateTypeParmType() const;          // C++ template type parameter
2096
  bool isNullPtrType() const;                   // C++11 std::nullptr_t
2097
  bool isNothrowT() const;                      // C++   std::nothrow_t
2098
  bool isAlignValT() const;                     // C++17 std::align_val_t
2099
  bool isStdByteType() const;                   // C++17 std::byte
2100
  bool isAtomicType() const;                    // C11 _Atomic()
2101
  bool isUndeducedAutoType() const;             // C++11 auto or
2102
                                                // C++14 decltype(auto)
2103
  bool isTypedefNameType() const;               // typedef or alias template
2104
2105
#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
2106
  bool is##Id##Type() const;
2107
#include "clang/Basic/OpenCLImageTypes.def"
2108
2109
  bool isImageType() const;                     // Any OpenCL image type
2110
2111
  bool isSamplerT() const;                      // OpenCL sampler_t
2112
  bool isEventT() const;                        // OpenCL event_t
2113
  bool isClkEventT() const;                     // OpenCL clk_event_t
2114
  bool isQueueT() const;                        // OpenCL queue_t
2115
  bool isReserveIDT() const;                    // OpenCL reserve_id_t
2116
2117
#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
2118
  bool is##Id##Type() const;
2119
#include "clang/Basic/OpenCLExtensionTypes.def"
2120
  // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension
2121
  bool isOCLIntelSubgroupAVCType() const;
2122
  bool isOCLExtOpaqueType() const;              // Any OpenCL extension type
2123
2124
  bool isPipeType() const;                      // OpenCL pipe type
2125
  bool isExtIntType() const;                    // Extended Int Type
2126
  bool isOpenCLSpecificType() const;            // Any OpenCL specific type
2127
2128
  /// Determines if this type, which must satisfy
2129
  /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather
2130
  /// than implicitly __strong.
2131
  bool isObjCARCImplicitlyUnretainedType() const;
2132
2133
  /// Check if the type is the CUDA device builtin surface type.
2134
  bool isCUDADeviceBuiltinSurfaceType() const;
2135
  /// Check if the type is the CUDA device builtin texture type.
2136
  bool isCUDADeviceBuiltinTextureType() const;
2137
2138
  /// Return the implicit lifetime for this type, which must not be dependent.
2139
  Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const;
2140
2141
  enum ScalarTypeKind {
2142
    STK_CPointer,
2143
    STK_BlockPointer,
2144
    STK_ObjCObjectPointer,
2145
    STK_MemberPointer,
2146
    STK_Bool,
2147
    STK_Integral,
2148
    STK_Floating,
2149
    STK_IntegralComplex,
2150
    STK_FloatingComplex,
2151
    STK_FixedPoint
2152
  };
2153
2154
  /// Given that this is a scalar type, classify it.
2155
  ScalarTypeKind getScalarTypeKind() const;
2156
2157
1.01G
  TypeDependence getDependence() const {
2158
1.01G
    return static_cast<TypeDependence>(TypeBits.Dependence);
2159
1.01G
  }
2160
2161
  /// Whether this type is an error type.
2162
143M
  bool containsErrors() const {
2163
143M
    return getDependence() & TypeDependence::Error;
2164
143M
  }
2165
2166
  /// Whether this type is a dependent type, meaning that its definition
2167
  /// somehow depends on a template parameter (C++ [temp.dep.type]).
2168
340M
  bool isDependentType() const {
2169
340M
    return getDependence() & TypeDependence::Dependent;
2170
340M
  }
2171
2172
  /// Determine whether this type is an instantiation-dependent type,
2173
  /// meaning that the type involves a template parameter (even if the
2174
  /// definition does not actually depend on the type substituted for that
2175
  /// template parameter).
2176
54.9M
  bool isInstantiationDependentType() const {
2177
54.9M
    return getDependence() & TypeDependence::Instantiation;
2178
54.9M
  }
2179
2180
  /// Determine whether this type is an undeduced type, meaning that
2181
  /// it somehow involves a C++11 'auto' type or similar which has not yet been
2182
  /// deduced.
2183
  bool isUndeducedType() const;
2184
2185
  /// Whether this type is a variably-modified type (C99 6.7.5).
2186
147M
  bool isVariablyModifiedType() const {
2187
147M
    return getDependence() & TypeDependence::VariablyModified;
2188
147M
  }
2189
2190
  /// Whether this type involves a variable-length array type
2191
  /// with a definite size.
2192
  bool hasSizedVLAType() const;
2193
2194
  /// Whether this type is or contains a local or unnamed type.
2195
  bool hasUnnamedOrLocalType() const;
2196
2197
  bool isOverloadableType() const;
2198
2199
  /// Determine wither this type is a C++ elaborated-type-specifier.
2200
  bool isElaboratedTypeSpecifier() const;
2201
2202
  bool canDecayToPointerType() const;
2203
2204
  /// Whether this type is represented natively as a pointer.  This includes
2205
  /// pointers, references, block pointers, and Objective-C interface,
2206
  /// qualified id, and qualified interface types, as well as nullptr_t.
2207
  bool hasPointerRepresentation() const;
2208
2209
  /// Whether this type can represent an objective pointer type for the
2210
  /// purpose of GC'ability
2211
  bool hasObjCPointerRepresentation() const;
2212
2213
  /// Determine whether this type has an integer representation
2214
  /// of some sort, e.g., it is an integer type or a vector.
2215
  bool hasIntegerRepresentation() const;
2216
2217
  /// Determine whether this type has an signed integer representation
2218
  /// of some sort, e.g., it is an signed integer type or a vector.
2219
  bool hasSignedIntegerRepresentation() const;
2220
2221
  /// Determine whether this type has an unsigned integer representation
2222
  /// of some sort, e.g., it is an unsigned integer type or a vector.
2223
  bool hasUnsignedIntegerRepresentation() const;
2224
2225
  /// Determine whether this type has a floating-point representation
2226
  /// of some sort, e.g., it is a floating-point type or a vector thereof.
2227
  bool hasFloatingRepresentation() const;
2228
2229
  // Type Checking Functions: Check to see if this type is structurally the
2230
  // specified type, ignoring typedefs and qualifiers, and return a pointer to
2231
  // the best type we can.
2232
  const RecordType *getAsStructureType() const;
2233
  /// NOTE: getAs*ArrayType are methods on ASTContext.
2234
  const RecordType *getAsUnionType() const;
2235
  const ComplexType *getAsComplexIntegerType() const; // GCC complex int type.
2236
  const ObjCObjectType *getAsObjCInterfaceType() const;
2237
2238
  // The following is a convenience method that returns an ObjCObjectPointerType
2239
  // for object declared using an interface.
2240
  const ObjCObjectPointerType *getAsObjCInterfacePointerType() const;
2241
  const ObjCObjectPointerType *getAsObjCQualifiedIdType() const;
2242
  const ObjCObjectPointerType *getAsObjCQualifiedClassType() const;
2243
  const ObjCObjectType *getAsObjCQualifiedInterfaceType() const;
2244
2245
  /// Retrieves the CXXRecordDecl that this type refers to, either
2246
  /// because the type is a RecordType or because it is the injected-class-name
2247
  /// type of a class template or class template partial specialization.
2248
  CXXRecordDecl *getAsCXXRecordDecl() const;
2249
2250
  /// Retrieves the RecordDecl this type refers to.
2251
  RecordDecl *getAsRecordDecl() const;
2252
2253
  /// Retrieves the TagDecl that this type refers to, either
2254
  /// because the type is a TagType or because it is the injected-class-name
2255
  /// type of a class template or class template partial specialization.
2256
  TagDecl *getAsTagDecl() const;
2257
2258
  /// If this is a pointer or reference to a RecordType, return the
2259
  /// CXXRecordDecl that the type refers to.
2260
  ///
2261
  /// If this is not a pointer or reference, or the type being pointed to does
2262
  /// not refer to a CXXRecordDecl, returns NULL.
2263
  const CXXRecordDecl *getPointeeCXXRecordDecl() const;
2264
2265
  /// Get the DeducedType whose type will be deduced for a variable with
2266
  /// an initializer of this type. This looks through declarators like pointer
2267
  /// types, but not through decltype or typedefs.
2268
  DeducedType *getContainedDeducedType() const;
2269
2270
  /// Get the AutoType whose type will be deduced for a variable with
2271
  /// an initializer of this type. This looks through declarators like pointer
2272
  /// types, but not through decltype or typedefs.
2273
3.03M
  AutoType *getContainedAutoType() const {
2274
3.03M
    return dyn_cast_or_null<AutoType>(getContainedDeducedType());
2275
3.03M
  }
2276
2277
  /// Determine whether this type was written with a leading 'auto'
2278
  /// corresponding to a trailing return type (possibly for a nested
2279
  /// function type within a pointer to function type or similar).
2280
  bool hasAutoForTrailingReturnType() const;
2281
2282
  /// Member-template getAs<specific type>'.  Look through sugar for
2283
  /// an instance of \<specific type>.   This scheme will eventually
2284
  /// replace the specific getAsXXXX methods above.
2285
  ///
2286
  /// There are some specializations of this member template listed
2287
  /// immediately following this class.
2288
  template <typename T> const T *getAs() const;
2289
2290
  /// Member-template getAsAdjusted<specific type>. Look through specific kinds
2291
  /// of sugar (parens, attributes, etc) for an instance of \<specific type>.
2292
  /// This is used when you need to walk over sugar nodes that represent some
2293
  /// kind of type adjustment from a type that was written as a \<specific type>
2294
  /// to another type that is still canonically a \<specific type>.
2295
  template <typename T> const T *getAsAdjusted() const;
2296
2297
  /// A variant of getAs<> for array types which silently discards
2298
  /// qualifiers from the outermost type.
2299
  const ArrayType *getAsArrayTypeUnsafe() const;
2300
2301
  /// Member-template castAs<specific type>.  Look through sugar for
2302
  /// the underlying instance of \<specific type>.
2303
  ///
2304
  /// This method has the same relationship to getAs<T> as cast<T> has
2305
  /// to dyn_cast<T>; which is to say, the underlying type *must*
2306
  /// have the intended type, and this method will never return null.
2307
  template <typename T> const T *castAs() const;
2308
2309
  /// A variant of castAs<> for array type which silently discards
2310
  /// qualifiers from the outermost type.
2311
  const ArrayType *castAsArrayTypeUnsafe() const;
2312
2313
  /// Determine whether this type had the specified attribute applied to it
2314
  /// (looking through top-level type sugar).
2315
  bool hasAttr(attr::Kind AK) const;
2316
2317
  /// Get the base element type of this type, potentially discarding type
2318
  /// qualifiers.  This should never be used when type qualifiers
2319
  /// are meaningful.
2320
  const Type *getBaseElementTypeUnsafe() const;
2321
2322
  /// If this is an array type, return the element type of the array,
2323
  /// potentially with type qualifiers missing.
2324
  /// This should never be used when type qualifiers are meaningful.
2325
  const Type *getArrayElementTypeNoTypeQual() const;
2326
2327
  /// If this is a pointer type, return the pointee type.
2328
  /// If this is an array type, return the array element type.
2329
  /// This should never be used when type qualifiers are meaningful.
2330
  const Type *getPointeeOrArrayElementType() const;
2331
2332
  /// If this is a pointer, ObjC object pointer, or block
2333
  /// pointer, this returns the respective pointee.
2334
  QualType getPointeeType() const;
2335
2336
  /// Return the specified type with any "sugar" removed from the type,
2337
  /// removing any typedefs, typeofs, etc., as well as any qualifiers.
2338
  const Type *getUnqualifiedDesugaredType() const;
2339
2340
  /// More type predicates useful for type checking/promotion
2341
  bool isPromotableIntegerType() const; // C99 6.3.1.1p2
2342
2343
  /// Return true if this is an integer type that is
2344
  /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..],
2345
  /// or an enum decl which has a signed representation.
2346
  bool isSignedIntegerType() const;
2347
2348
  /// Return true if this is an integer type that is
2349
  /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool],
2350
  /// or an enum decl which has an unsigned representation.
2351
  bool isUnsignedIntegerType() const;
2352
2353
  /// Determines whether this is an integer type that is signed or an
2354
  /// enumeration types whose underlying type is a signed integer type.
2355
  bool isSignedIntegerOrEnumerationType() const;
2356
2357
  /// Determines whether this is an integer type that is unsigned or an
2358
  /// enumeration types whose underlying type is a unsigned integer type.
2359
  bool isUnsignedIntegerOrEnumerationType() const;
2360
2361
  /// Return true if this is a fixed point type according to
2362
  /// ISO/IEC JTC1 SC22 WG14 N1169.
2363
  bool isFixedPointType() const;
2364
2365
  /// Return true if this is a fixed point or integer type.
2366
  bool isFixedPointOrIntegerType() const;
2367
2368
  /// Return true if this is a saturated fixed point type according to
2369
  /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2370
  bool isSaturatedFixedPointType() const;
2371
2372
  /// Return true if this is a saturated fixed point type according to
2373
  /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned.
2374
  bool isUnsaturatedFixedPointType() const;
2375
2376
  /// Return true if this is a fixed point type that is signed according
2377
  /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2378
  bool isSignedFixedPointType() const;
2379
2380
  /// Return true if this is a fixed point type that is unsigned according
2381
  /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated.
2382
  bool isUnsignedFixedPointType() const;
2383
2384
  /// Return true if this is not a variable sized type,
2385
  /// according to the rules of C99 6.7.5p3.  It is not legal to call this on
2386
  /// incomplete types.
2387
  bool isConstantSizeType() const;
2388
2389
  /// Returns true if this type can be represented by some
2390
  /// set of type specifiers.
2391
  bool isSpecifierType() const;
2392
2393
  /// Determine the linkage of this type.
2394
  Linkage getLinkage() const;
2395
2396
  /// Determine the visibility of this type.
2397
2.13k
  Visibility getVisibility() const {
2398
2.13k
    return getLinkageAndVisibility().getVisibility();
2399
2.13k
  }
2400
2401
  /// Return true if the visibility was explicitly set is the code.
2402
0
  bool isVisibilityExplicit() const {
2403
0
    return getLinkageAndVisibility().isVisibilityExplicit();
2404
0
  }
2405
2406
  /// Determine the linkage and visibility of this type.
2407
  LinkageInfo getLinkageAndVisibility() const;
2408
2409
  /// True if the computed linkage is valid. Used for consistency
2410
  /// checking. Should always return true.
2411
  bool isLinkageValid() const;
2412
2413
  /// Determine the nullability of the given type.
2414
  ///
2415
  /// Note that nullability is only captured as sugar within the type
2416
  /// system, not as part of the canonical type, so nullability will
2417
  /// be lost by canonicalization and desugaring.
2418
  Optional<NullabilityKind> getNullability(const ASTContext &context) const;
2419
2420
  /// Determine whether the given type can have a nullability
2421
  /// specifier applied to it, i.e., if it is any kind of pointer type.
2422
  ///
2423
  /// \param ResultIfUnknown The value to return if we don't yet know whether
2424
  ///        this type can have nullability because it is dependent.
2425
  bool canHaveNullability(bool ResultIfUnknown = true) const;
2426
2427
  /// Retrieve the set of substitutions required when accessing a member
2428
  /// of the Objective-C receiver type that is declared in the given context.
2429
  ///
2430
  /// \c *this is the type of the object we're operating on, e.g., the
2431
  /// receiver for a message send or the base of a property access, and is
2432
  /// expected to be of some object or object pointer type.
2433
  ///
2434
  /// \param dc The declaration context for which we are building up a
2435
  /// substitution mapping, which should be an Objective-C class, extension,
2436
  /// category, or method within.
2437
  ///
2438
  /// \returns an array of type arguments that can be substituted for
2439
  /// the type parameters of the given declaration context in any type described
2440
  /// within that context, or an empty optional to indicate that no
2441
  /// substitution is required.
2442
  Optional<ArrayRef<QualType>>
2443
  getObjCSubstitutions(const DeclContext *dc) const;
2444
2445
  /// Determines if this is an ObjC interface type that may accept type
2446
  /// parameters.
2447
  bool acceptsObjCTypeParams() const;
2448
2449
  const char *getTypeClassName() const;
2450
2451
938M
  QualType getCanonicalTypeInternal() const {
2452
938M
    return CanonicalType;
2453
938M
  }
2454
2455
  CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h
2456
  void dump() const;
2457
  void dump(llvm::raw_ostream &OS, const ASTContext &Context) const;
2458
};
2459
2460
/// This will check for a TypedefType by removing any existing sugar
2461
/// until it reaches a TypedefType or a non-sugared type.
2462
template <> const TypedefType *Type::getAs() const;
2463
2464
/// This will check for a TemplateSpecializationType by removing any
2465
/// existing sugar until it reaches a TemplateSpecializationType or a
2466
/// non-sugared type.
2467
template <> const TemplateSpecializationType *Type::getAs() const;
2468
2469
/// This will check for an AttributedType by removing any existing sugar
2470
/// until it reaches an AttributedType or a non-sugared type.
2471
template <> const AttributedType *Type::getAs() const;
2472
2473
// We can do canonical leaf types faster, because we don't have to
2474
// worry about preserving child type decoration.
2475
#define TYPE(Class, Base)
2476
#define LEAF_TYPE(Class) \
2477
1.54G
template <> inline const Class##Type *Type::getAs() const { \
2478
1.54G
  return dyn_cast<Class##Type>(CanonicalType); \
2479
1.54G
} \
clang::BuiltinType const* clang::Type::getAs<clang::BuiltinType>() const
Line
Count
Source
2477
927M
template <> inline const Class##Type *Type::getAs() const { \
2478
927M
  return dyn_cast<Class##Type>(CanonicalType); \
2479
927M
} \
clang::EnumType const* clang::Type::getAs<clang::EnumType>() const
Line
Count
Source
2477
86.5M
template <> inline const Class##Type *Type::getAs() const { \
2478
86.5M
  return dyn_cast<Class##Type>(CanonicalType); \
2479
86.5M
} \
clang::InjectedClassNameType const* clang::Type::getAs<clang::InjectedClassNameType>() const
Line
Count
Source
2477
315M
template <> inline const Class##Type *Type::getAs() const { \
2478
315M
  return dyn_cast<Class##Type>(CanonicalType); \
2479
315M
} \
clang::ObjCInterfaceType const* clang::Type::getAs<clang::ObjCInterfaceType>() const
Line
Count
Source
2477
121M
template <> inline const Class##Type *Type::getAs() const { \
2478
121M
  return dyn_cast<Class##Type>(CanonicalType); \
2479
121M
} \
clang::RecordType const* clang::Type::getAs<clang::RecordType>() const
Line
Count
Source
2477
89.2M
template <> inline const Class##Type *Type::getAs() const { \
2478
89.2M
  return dyn_cast<Class##Type>(CanonicalType); \
2479
89.2M
} \
clang::TemplateTypeParmType const* clang::Type::getAs<clang::TemplateTypeParmType>() const
Line
Count
Source
2477
3.38M
template <> inline const Class##Type *Type::getAs() const { \
2478
3.38M
  return dyn_cast<Class##Type>(CanonicalType); \
2479
3.38M
} \
2480
218M
template <> inline const Class##Type *Type::castAs() const { \
2481
218M
  return cast<Class##Type>(CanonicalType); \
2482
218M
}
clang::BuiltinType const* clang::Type::castAs<clang::BuiltinType>() const
Line
Count
Source
2480
2.51M
template <> inline const Class##Type *Type::castAs() const { \
2481
2.51M
  return cast<Class##Type>(CanonicalType); \
2482
2.51M
}
clang::EnumType const* clang::Type::castAs<clang::EnumType>() const
Line
Count
Source
2480
398k
template <> inline const Class##Type *Type::castAs() const { \
2481
398k
  return cast<Class##Type>(CanonicalType); \
2482
398k
}
Unexecuted instantiation: clang::InjectedClassNameType const* clang::Type::castAs<clang::InjectedClassNameType>() const
clang::ObjCInterfaceType const* clang::Type::castAs<clang::ObjCInterfaceType>() const
Line
Count
Source
2480
24.8k
template <> inline const Class##Type *Type::castAs() const { \
2481
24.8k
  return cast<Class##Type>(CanonicalType); \
2482
24.8k
}
clang::RecordType const* clang::Type::castAs<clang::RecordType>() const
Line
Count
Source
2480
8.67M
template <> inline const Class##Type *Type::castAs() const { \
2481
8.67M
  return cast<Class##Type>(CanonicalType); \
2482
8.67M
}
clang::TemplateTypeParmType const* clang::Type::castAs<clang::TemplateTypeParmType>() const
Line
Count
Source
2480
207M
template <> inline const Class##Type *Type::castAs() const { \
2481
207M
  return cast<Class##Type>(CanonicalType); \
2482
207M
}
2483
#include "clang/AST/TypeNodes.inc"
2484
2485
/// This class is used for builtin types like 'int'.  Builtin
2486
/// types are always canonical and have a literal name field.
2487
class BuiltinType : public Type {
2488
public:
2489
  enum Kind {
2490
// OpenCL image types
2491
#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id,
2492
#include "clang/Basic/OpenCLImageTypes.def"
2493
// OpenCL extension types
2494
#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id,
2495
#include "clang/Basic/OpenCLExtensionTypes.def"
2496
// SVE Types
2497
#define SVE_TYPE(Name, Id, SingletonId) Id,
2498
#include "clang/Basic/AArch64SVEACLETypes.def"
2499
// PPC MMA Types
2500
#define PPC_VECTOR_TYPE(Name, Id, Size) Id,
2501
#include "clang/Basic/PPCTypes.def"
2502
// RVV Types
2503
#define RVV_TYPE(Name, Id, SingletonId) Id,
2504
#include "clang/Basic/RISCVVTypes.def"
2505
// All other builtin types
2506
#define BUILTIN_TYPE(Id, SingletonId) Id,
2507
#define LAST_BUILTIN_TYPE(Id) LastKind = Id
2508
#include "clang/AST/BuiltinTypes.def"
2509
  };
2510
2511
private:
2512
  friend class ASTContext; // ASTContext creates these.
2513
2514
  BuiltinType(Kind K)
2515
      : Type(Builtin, QualType(),
2516
             K == Dependent ? TypeDependence::DependentInstantiation
2517
6.38M
                            : TypeDependence::None) {
2518
6.38M
    BuiltinTypeBits.Kind = K;
2519
6.38M
  }
2520
2521
public:
2522
1.65G
  Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); }
2523
  StringRef getName(const PrintingPolicy &Policy) const;
2524
2525
3.12k
  const char *getNameAsCString(const PrintingPolicy &Policy) const {
2526
    // The StringRef is null-terminated.
2527
3.12k
    StringRef str = getName(Policy);
2528
3.12k
    assert(!str.empty() && str.data()[str.size()] == '\0');
2529
0
    return str.data();
2530
3.12k
  }
2531
2532
67.7M
  bool isSugared() const { return false; }
2533
0
  QualType desugar() const { return QualType(this, 0); }
2534
2535
4.22M
  bool isInteger() const {
2536
4.22M
    return getKind() >= Bool && 
getKind() <= Int1284.22M
;
2537
4.22M
  }
2538
2539
102k
  bool isSignedInteger() const {
2540
102k
    return getKind() >= Char_S && 
getKind() <= Int12864.7k
;
2541
102k
  }
2542
2543
3.08M
  bool isUnsignedInteger() const {
2544
3.08M
    return getKind() >= Bool && getKind() <= UInt128;
2545
3.08M
  }
2546
2547
9.65M
  bool isFloatingPoint() const {
2548
9.65M
    return getKind() >= Half && 
getKind() <= Float1284.71M
;
2549
9.65M
  }
2550
2551
  /// Determines whether the given kind corresponds to a placeholder type.
2552
64.5M
  static bool isPlaceholderTypeKind(Kind K) {
2553
64.5M
    return K >= Overload;
2554
64.5M
  }
2555
2556
  /// Determines whether this type is a placeholder type, i.e. a type
2557
  /// which cannot appear in arbitrary positions in a fully-formed
2558
  /// expression.
2559
59.5M
  bool isPlaceholderType() const {
2560
59.5M
    return isPlaceholderTypeKind(getKind());
2561
59.5M
  }
2562
2563
  /// Determines whether this type is a placeholder type other than
2564
  /// Overload.  Most placeholder types require only syntactic
2565
  /// information about their context in order to be resolved (e.g.
2566
  /// whether it is a call expression), which means they can (and
2567
  /// should) be resolved in an earlier "phase" of analysis.
2568
  /// Overload expressions sometimes pick up further information
2569
  /// from their context, like whether the context expects a
2570
  /// specific function-pointer type, and so frequently need
2571
  /// special treatment.
2572
4.80M
  bool isNonOverloadPlaceholderType() const {
2573
4.80M
    return getKind() > Overload;
2574
4.80M
  }
2575
2576
3.12G
  static bool classof(const Type *T) { return T->getTypeClass() == Builtin; }
2577
};
2578
2579
/// Complex values, per C99 6.2.5p11.  This supports the C99 complex
2580
/// types (_Complex float etc) as well as the GCC integer complex extensions.
2581
class ComplexType : public Type, public llvm::FoldingSetNode {
2582
  friend class ASTContext; // ASTContext creates these.
2583
2584
  QualType ElementType;
2585
2586
  ComplexType(QualType Element, QualType CanonicalPtr)
2587
      : Type(Complex, CanonicalPtr, Element->getDependence()),
2588
405k
        ElementType(Element) {}
2589
2590
public:
2591
54.4k
  QualType getElementType() const { return ElementType; }
2592
2593
13.1k
  bool isSugared() const { return false; }
2594
0
  QualType desugar() const { return QualType(this, 0); }
2595
2596
22.5k
  void Profile(llvm::FoldingSetNodeID &ID) {
2597
22.5k
    Profile(ID, getElementType());
2598
22.5k
  }
2599
2600
440k
  static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) {
2601
440k
    ID.AddPointer(Element.getAsOpaquePtr());
2602
440k
  }
2603
2604
83.0M
  static bool classof(const Type *T) { return T->getTypeClass() == Complex; }
2605
};
2606
2607
/// Sugar for parentheses used when specifying types.
2608
class ParenType : public Type, public llvm::FoldingSetNode {
2609
  friend class ASTContext; // ASTContext creates these.
2610
2611
  QualType Inner;
2612
2613
  ParenType(QualType InnerType, QualType CanonType)
2614
205k
      : Type(Paren, CanonType, InnerType->getDependence()), Inner(InnerType) {}
2615
2616
public:
2617
3.10M
  QualType getInnerType() const { return Inner; }
2618
2619
432k
  bool isSugared() const { return true; }
2620
433k
  QualType desugar() const { return getInnerType(); }
2621
2622
805k
  void Profile(llvm::FoldingSetNodeID &ID) {
2623
805k
    Profile(ID, getInnerType());
2624
805k
  }
2625
2626
1.12M
  static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) {
2627
1.12M
    Inner.Profile(ID);
2628
1.12M
  }
2629
2630
40.9M
  static bool classof(const Type *T) { return T->getTypeClass() == Paren; }
2631
};
2632
2633
/// PointerType - C99 6.7.5.1 - Pointer Declarators.
2634
class PointerType : public Type, public llvm::FoldingSetNode {
2635
  friend class ASTContext; // ASTContext creates these.
2636
2637
  QualType PointeeType;
2638
2639
  PointerType(QualType Pointee, QualType CanonicalPtr)
2640
      : Type(Pointer, CanonicalPtr, Pointee->getDependence()),
2641
5.03M
        PointeeType(Pointee) {}
2642
2643
public:
2644
153M
  QualType getPointeeType() const { return PointeeType; }
2645
2646
19.2M
  bool isSugared() const { return false; }
2647
0
  QualType desugar() const { return QualType(this, 0); }
2648
2649
42.4M
  void Profile(llvm::FoldingSetNodeID &ID) {
2650
42.4M
    Profile(ID, getPointeeType());
2651
42.4M
  }
2652
2653
70.0M
  static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2654
70.0M
    ID.AddPointer(Pointee.getAsOpaquePtr());
2655
70.0M
  }
2656
2657
1.57G
  static bool classof(const Type *T) { return T->getTypeClass() == Pointer; }
2658
};
2659
2660
/// Represents a type which was implicitly adjusted by the semantic
2661
/// engine for arbitrary reasons.  For example, array and function types can
2662
/// decay, and function types can have their calling conventions adjusted.
2663
class AdjustedType : public Type, public llvm::FoldingSetNode {
2664
  QualType OriginalTy;
2665
  QualType AdjustedTy;
2666
2667
protected:
2668
  friend class ASTContext; // ASTContext creates these.
2669
2670
  AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy,
2671
               QualType CanonicalPtr)
2672
      : Type(TC, CanonicalPtr, OriginalTy->getDependence()),
2673
28.9k
        OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {}
2674
2675
public:
2676
32.4k
  QualType getOriginalType() const { return OriginalTy; }
2677
44.0k
  QualType getAdjustedType() const { return AdjustedTy; }
2678
2679
57.2k
  bool isSugared() const { return true; }
2680
57.2k
  QualType desugar() const { return AdjustedTy; }
2681
2682
87.6k
  void Profile(llvm::FoldingSetNodeID &ID) {
2683
87.6k
    Profile(ID, OriginalTy, AdjustedTy);
2684
87.6k
  }
2685
2686
172k
  static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) {
2687
172k
    ID.AddPointer(Orig.getAsOpaquePtr());
2688
172k
    ID.AddPointer(New.getAsOpaquePtr());
2689
172k
  }
2690
2691
73.5M
  static bool classof(const Type *T) {
2692
73.5M
    return T->getTypeClass() == Adjusted || 
T->getTypeClass() == Decayed73.5M
;
2693
73.5M
  }
2694
};
2695
2696
/// Represents a pointer type decayed from an array or function type.
2697
class DecayedType : public AdjustedType {
2698
  friend class ASTContext; // ASTContext creates these.
2699
2700
  inline
2701
  DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical);
2702
2703
public:
2704
98
  QualType getDecayedType() const { return getAdjustedType(); }
2705
2706
  inline QualType getPointeeType() const;
2707
2708
12.9M
  static bool classof(const Type *T) { return T->getTypeClass() == Decayed; }
2709
};
2710
2711
/// Pointer to a block type.
2712
/// This type is to represent types syntactically represented as
2713
/// "void (^)(int)", etc. Pointee is required to always be a function type.
2714
class BlockPointerType : public Type, public llvm::FoldingSetNode {
2715
  friend class ASTContext; // ASTContext creates these.
2716
2717
  // Block is some kind of pointer type
2718
  QualType PointeeType;
2719
2720
  BlockPointerType(QualType Pointee, QualType CanonicalCls)
2721
      : Type(BlockPointer, CanonicalCls, Pointee->getDependence()),
2722
63.1k
        PointeeType(Pointee) {}
2723
2724
public:
2725
  // Get the pointee type. Pointee is required to always be a function type.
2726
519k
  QualType getPointeeType() const { return PointeeType; }
2727
2728
139k
  bool isSugared() const { return false; }
2729
0
  QualType desugar() const { return QualType(this, 0); }
2730
2731
170k
  void Profile(llvm::FoldingSetNodeID &ID) {
2732
170k
      Profile(ID, getPointeeType());
2733
170k
  }
2734
2735
266k
  static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) {
2736
266k
      ID.AddPointer(Pointee.getAsOpaquePtr());
2737
266k
  }
2738
2739
327M
  static bool classof(const Type *T) {
2740
327M
    return T->getTypeClass() == BlockPointer;
2741
327M
  }
2742
};
2743
2744
/// Base for LValueReferenceType and RValueReferenceType
2745
class ReferenceType : public Type, public llvm::FoldingSetNode {
2746
  QualType PointeeType;
2747
2748
protected:
2749
  ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef,
2750
                bool SpelledAsLValue)
2751
      : Type(tc, CanonicalRef, Referencee->getDependence()),
2752
2.70M
        PointeeType(Referencee) {
2753
2.70M
    ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue;
2754
2.70M
    ReferenceTypeBits.InnerRef = Referencee->isReferenceType();
2755
2.70M
  }
2756
2757
public:
2758
21.2M
  bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; }
2759
19.3M
  bool isInnerRef() const { return ReferenceTypeBits.InnerRef; }
2760
2761
28.6M
  QualType getPointeeTypeAsWritten() const { return PointeeType; }
2762
2763
18.2M
  QualType getPointeeType() const {
2764
    // FIXME: this might strip inner qualifiers; okay?
2765
18.2M
    const ReferenceType *T = this;
2766
18.3M
    while (T->isInnerRef())
2767
162k
      T = T->PointeeType->castAs<ReferenceType>();
2768
18.2M
    return T->PointeeType;
2769
18.2M
  }
2770
2771
19.3M
  void Profile(llvm::FoldingSetNodeID &ID) {
2772
19.3M
    Profile(ID, PointeeType, isSpelledAsLValue());
2773
19.3M
  }
2774
2775
  static void Profile(llvm::FoldingSetNodeID &ID,
2776
                      QualType Referencee,
2777
29.7M
                      bool SpelledAsLValue) {
2778
29.7M
    ID.AddPointer(Referencee.getAsOpaquePtr());
2779
29.7M
    ID.AddBoolean(SpelledAsLValue);
2780
29.7M
  }
2781
2782
693M
  static bool classof(const Type *T) {
2783
693M
    return T->getTypeClass() == LValueReference ||
2784
693M
           
T->getTypeClass() == RValueReference630M
;
2785
693M
  }
2786
};
2787
2788
/// An lvalue reference type, per C++11 [dcl.ref].
2789
class LValueReferenceType : public ReferenceType {
2790
  friend class ASTContext; // ASTContext creates these
2791
2792
  LValueReferenceType(QualType Referencee, QualType CanonicalRef,
2793
                      bool SpelledAsLValue)
2794
      : ReferenceType(LValueReference, Referencee, CanonicalRef,
2795
2.14M
                      SpelledAsLValue) {}
2796
2797
public:
2798
1.75M
  bool isSugared() const { return false; }
2799
0
  QualType desugar() const { return QualType(this, 0); }
2800
2801
37.8M
  static bool classof(const Type *T) {
2802
37.8M
    return T->getTypeClass() == LValueReference;
2803
37.8M
  }
2804
};
2805
2806
/// An rvalue reference type, per C++11 [dcl.ref].
2807
class RValueReferenceType : public ReferenceType {
2808
  friend class ASTContext; // ASTContext creates these
2809
2810
  RValueReferenceType(QualType Referencee, QualType CanonicalRef)
2811
557k
       : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {}
2812
2813
public:
2814
264k
  bool isSugared() const { return false; }
2815
0
  QualType desugar() const { return QualType(this, 0); }
2816
2817
18.9M
  static bool classof(const Type *T) {
2818
18.9M
    return T->getTypeClass() == RValueReference;
2819
18.9M
  }
2820
};
2821
2822
/// A pointer to member type per C++ 8.3.3 - Pointers to members.
2823
///
2824
/// This includes both pointers to data members and pointer to member functions.
2825
class MemberPointerType : public Type, public llvm::FoldingSetNode {
2826
  friend class ASTContext; // ASTContext creates these.
2827
2828
  QualType PointeeType;
2829
2830
  /// The class of which the pointee is a member. Must ultimately be a
2831
  /// RecordType, but could be a typedef or a template parameter too.
2832
  const Type *Class;
2833
2834
  MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr)
2835
      : Type(MemberPointer, CanonicalPtr,
2836
             (Cls->getDependence() & ~TypeDependence::VariablyModified) |
2837
                 Pointee->getDependence()),
2838
47.0k
        PointeeType(Pointee), Class(Cls) {}
2839
2840
public:
2841
584k
  QualType getPointeeType() const { return PointeeType; }
2842
2843
  /// Returns true if the member type (i.e. the pointee type) is a
2844
  /// function type rather than a data-member type.
2845
5.21k
  bool isMemberFunctionPointer() const {
2846
5.21k
    return PointeeType->isFunctionProtoType();
2847
5.21k
  }
2848
2849
  /// Returns true if the member type (i.e. the pointee type) is a
2850
  /// data type rather than a function type.
2851
793
  bool isMemberDataPointer() const {
2852
793
    return !PointeeType->isFunctionProtoType();
2853
793
  }
2854
2855
234k
  const Type *getClass() const { return Class; }
2856
  CXXRecordDecl *getMostRecentCXXRecordDecl() const;
2857
2858
45.6k
  bool isSugared() const { return false; }
2859
0
  QualType desugar() const { return QualType(this, 0); }
2860
2861
72.2k
  void Profile(llvm::FoldingSetNodeID &ID) {
2862
72.2k
    Profile(ID, getPointeeType(), getClass());
2863
72.2k
  }
2864
2865
  static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
2866
136k
                      const Type *Class) {
2867
136k
    ID.AddPointer(Pointee.getAsOpaquePtr());
2868
136k
    ID.AddPointer(Class);
2869
136k
  }
2870
2871
516M
  static bool classof(const Type *T) {
2872
516M
    return T->getTypeClass() == MemberPointer;
2873
516M
  }
2874
};
2875
2876
/// Represents an array type, per C99 6.7.5.2 - Array Declarators.
2877
class ArrayType : public Type, public llvm::FoldingSetNode {
2878
public:
2879
  /// Capture whether this is a normal array (e.g. int X[4])
2880
  /// an array with a static size (e.g. int X[static 4]), or an array
2881
  /// with a star size (e.g. int X[*]).
2882
  /// 'static' is only allowed on function parameters.
2883
  enum ArraySizeModifier {
2884
    Normal, Static, Star
2885
  };
2886
2887
private:
2888
  /// The element type of the array.
2889
  QualType ElementType;
2890
2891
protected:
2892
  friend class ASTContext; // ASTContext creates these.
2893
2894
  ArrayType(TypeClass tc, QualType et, QualType can, ArraySizeModifier sm,
2895
            unsigned tq, const Expr *sz = nullptr);
2896
2897
public:
2898
14.0M
  QualType getElementType() const { return ElementType; }
2899
2900
7.08M
  ArraySizeModifier getSizeModifier() const {
2901
7.08M
    return ArraySizeModifier(ArrayTypeBits.SizeModifier);
2902
7.08M
  }
2903
2904
587k
  Qualifiers getIndexTypeQualifiers() const {
2905
587k
    return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers());
2906
587k
  }
2907
2908
7.63M
  unsigned getIndexTypeCVRQualifiers() const {
2909
7.63M
    return ArrayTypeBits.IndexTypeQuals;
2910
7.63M
  }
2911
2912
1.21G
  static bool classof(const Type *T) {
2913
1.21G
    return T->getTypeClass() == ConstantArray ||
2914
1.21G
           
T->getTypeClass() == VariableArray1.20G
||
2915
1.21G
           
T->getTypeClass() == IncompleteArray1.20G
||
2916
1.21G
           
T->getTypeClass() == DependentSizedArray1.19G
;
2917
1.21G
  }
2918
};
2919
2920
/// Represents the canonical version of C arrays with a specified constant size.
2921
/// For example, the canonical type for 'int A[4 + 4*100]' is a
2922
/// ConstantArrayType where the element type is 'int' and the size is 404.
2923
class ConstantArrayType final
2924
    : public ArrayType,
2925
      private llvm::TrailingObjects<ConstantArrayType, const Expr *> {
2926
  friend class ASTContext; // ASTContext creates these.
2927
  friend TrailingObjects;
2928
2929
  llvm::APInt Size; // Allows us to unique the type.
2930
2931
  ConstantArrayType(QualType et, QualType can, const llvm::APInt &size,
2932
                    const Expr *sz, ArraySizeModifier sm, unsigned tq)
2933
541k
      : ArrayType(ConstantArray, et, can, sm, tq, sz), Size(size) {
2934
541k
    ConstantArrayTypeBits.HasStoredSizeExpr = sz != nullptr;
2935
541k
    if (ConstantArrayTypeBits.HasStoredSizeExpr) {
2936
13
      assert(!can.isNull() && "canonical constant array should not have size");
2937
0
      *getTrailingObjects<const Expr*>() = sz;
2938
13
    }
2939
541k
  }
2940
2941
0
  unsigned numTrailingObjects(OverloadToken<const Expr*>) const {
2942
0
    return ConstantArrayTypeBits.HasStoredSizeExpr;
2943
0
  }
2944
2945
public:
2946
7.64M
  const llvm::APInt &getSize() const { return Size; }
2947
6.94M
  const Expr *getSizeExpr() const {
2948
6.94M
    return ConstantArrayTypeBits.HasStoredSizeExpr
2949
6.94M
               ? 
*getTrailingObjects<const Expr *>()40
2950
6.94M
               : 
nullptr6.94M
;
2951
6.94M
  }
2952
1.91M
  bool isSugared() const { return false; }
2953
0
  QualType desugar() const { return QualType(this, 0); }
2954
2955
  /// Determine the number of bits required to address a member of
2956
  // an array with the given element type and number of elements.
2957
  static unsigned getNumAddressingBits(const ASTContext &Context,
2958
                                       QualType ElementType,
2959
                                       const llvm::APInt &NumElements);
2960
2961
  /// Determine the maximum number of active bits that an array's size
2962
  /// can require, which limits the maximum size of the array.
2963
  static unsigned getMaxSizeBits(const ASTContext &Context);
2964
2965
6.88M
  void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
2966
6.88M
    Profile(ID, Ctx, getElementType(), getSize(), getSizeExpr(),
2967
6.88M
            getSizeModifier(), getIndexTypeCVRQualifiers());
2968
6.88M
  }
2969
2970
  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx,
2971
                      QualType ET, const llvm::APInt &ArraySize,
2972
                      const Expr *SizeExpr, ArraySizeModifier SizeMod,
2973
                      unsigned TypeQuals);
2974
2975
17.5M
  static bool classof(const Type *T) {
2976
17.5M
    return T->getTypeClass() == ConstantArray;
2977
17.5M
  }
2978
};
2979
2980
/// Represents a C array with an unspecified size.  For example 'int A[]' has
2981
/// an IncompleteArrayType where the element type is 'int' and the size is
2982
/// unspecified.
2983
class IncompleteArrayType : public ArrayType {
2984
  friend class ASTContext; // ASTContext creates these.
2985
2986
  IncompleteArrayType(QualType et, QualType can,
2987
                      ArraySizeModifier sm, unsigned tq)
2988
47.9k
      : ArrayType(IncompleteArray, et, can, sm, tq) {}
2989
2990
public:
2991
  friend class StmtIteratorBase;
2992
2993
73.1k
  bool isSugared() const { return false; }
2994
0
  QualType desugar() const { return QualType(this, 0); }
2995
2996
27.2M
  static bool classof(const Type *T) {
2997
27.2M
    return T->getTypeClass() == IncompleteArray;
2998
27.2M
  }
2999
3000
65.3k
  void Profile(llvm::FoldingSetNodeID &ID) {
3001
65.3k
    Profile(ID, getElementType(), getSizeModifier(),
3002
65.3k
            getIndexTypeCVRQualifiers());
3003
65.3k
  }
3004
3005
  static void Profile(llvm::FoldingSetNodeID &ID, QualType ET,
3006
151k
                      ArraySizeModifier SizeMod, unsigned TypeQuals) {
3007
151k
    ID.AddPointer(ET.getAsOpaquePtr());
3008
151k
    ID.AddInteger(SizeMod);
3009
151k
    ID.AddInteger(TypeQuals);
3010
151k
  }
3011
};
3012
3013
/// Represents a C array with a specified size that is not an
3014
/// integer-constant-expression.  For example, 'int s[x+foo()]'.
3015
/// Since the size expression is an arbitrary expression, we store it as such.
3016
///
3017
/// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and
3018
/// should not be: two lexically equivalent variable array types could mean
3019
/// different things, for example, these variables do not have the same type
3020
/// dynamically:
3021
///
3022
/// void foo(int x) {
3023
///   int Y[x];
3024
///   ++x;
3025
///   int Z[x];
3026
/// }
3027
class VariableArrayType : public ArrayType {
3028
  friend class ASTContext; // ASTContext creates these.
3029
3030
  /// An assignment-expression. VLA's are only permitted within
3031
  /// a function block.
3032
  Stmt *SizeExpr;
3033
3034
  /// The range spanned by the left and right array brackets.
3035
  SourceRange Brackets;
3036
3037
  VariableArrayType(QualType et, QualType can, Expr *e,
3038
                    ArraySizeModifier sm, unsigned tq,
3039
                    SourceRange brackets)
3040
      : ArrayType(VariableArray, et, can, sm, tq, e),
3041
7.44k
        SizeExpr((Stmt*) e), Brackets(brackets) {}
3042
3043
public:
3044
  friend class StmtIteratorBase;
3045
3046
62.8k
  Expr *getSizeExpr() const {
3047
    // We use C-style casts instead of cast<> here because we do not wish
3048
    // to have a dependency of Type.h on Stmt.h/Expr.h.
3049
62.8k
    return (Expr*) SizeExpr;
3050
62.8k
  }
3051
3052
180
  SourceRange getBracketsRange() const { return Brackets; }
3053
1.54k
  SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3054
1.54k
  SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3055
3056
45.9k
  bool isSugared() const { return false; }
3057
33
  QualType desugar() const { return QualType(this, 0); }
3058
3059
27.4M
  static bool classof(const Type *T) {
3060
27.4M
    return T->getTypeClass() == VariableArray;
3061
27.4M
  }
3062
3063
0
  void Profile(llvm::FoldingSetNodeID &ID) {
3064
0
    llvm_unreachable("Cannot unique VariableArrayTypes.");
3065
0
  }
3066
};
3067
3068
/// Represents an array type in C++ whose size is a value-dependent expression.
3069
///
3070
/// For example:
3071
/// \code
3072
/// template<typename T, int Size>
3073
/// class array {
3074
///   T data[Size];
3075
/// };
3076
/// \endcode
3077
///
3078
/// For these types, we won't actually know what the array bound is
3079
/// until template instantiation occurs, at which point this will
3080
/// become either a ConstantArrayType or a VariableArrayType.
3081
class DependentSizedArrayType : public ArrayType {
3082
  friend class ASTContext; // ASTContext creates these.
3083
3084
  const ASTContext &Context;
3085
3086
  /// An assignment expression that will instantiate to the
3087
  /// size of the array.
3088
  ///
3089
  /// The expression itself might be null, in which case the array
3090
  /// type will have its size deduced from an initializer.
3091
  Stmt *SizeExpr;
3092
3093
  /// The range spanned by the left and right array brackets.
3094
  SourceRange Brackets;
3095
3096
  DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can,
3097
                          Expr *e, ArraySizeModifier sm, unsigned tq,
3098
                          SourceRange brackets);
3099
3100
public:
3101
  friend class StmtIteratorBase;
3102
3103
36.2k
  Expr *getSizeExpr() const {
3104
    // We use C-style casts instead of cast<> here because we do not wish
3105
    // to have a dependency of Type.h on Stmt.h/Expr.h.
3106
36.2k
    return (Expr*) SizeExpr;
3107
36.2k
  }
3108
3109
1.02k
  SourceRange getBracketsRange() const { return Brackets; }
3110
1.22k
  SourceLocation getLBracketLoc() const { return Brackets.getBegin(); }
3111
1.22k
  SourceLocation getRBracketLoc() const { return Brackets.getEnd(); }
3112
3113
39.8k
  bool isSugared() const { return false; }
3114
0
  QualType desugar() const { return QualType(this, 0); }
3115
3116
245k
  static bool classof(const Type *T) {
3117
245k
    return T->getTypeClass() == DependentSizedArray;
3118
245k
  }
3119
3120
8.65k
  void Profile(llvm::FoldingSetNodeID &ID) {
3121
8.65k
    Profile(ID, Context, getElementType(),
3122
8.65k
            getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr());
3123
8.65k
  }
3124
3125
  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3126
                      QualType ET, ArraySizeModifier SizeMod,
3127
                      unsigned TypeQuals, Expr *E);
3128
};
3129
3130
/// Represents an extended address space qualifier where the input address space
3131
/// value is dependent. Non-dependent address spaces are not represented with a
3132
/// special Type subclass; they are stored on an ExtQuals node as part of a QualType.
3133
///
3134
/// For example:
3135
/// \code
3136
/// template<typename T, int AddrSpace>
3137
/// class AddressSpace {
3138
///   typedef T __attribute__((address_space(AddrSpace))) type;
3139
/// }
3140
/// \endcode
3141
class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode {
3142
  friend class ASTContext;
3143
3144
  const ASTContext &Context;
3145
  Expr *AddrSpaceExpr;
3146
  QualType PointeeType;
3147
  SourceLocation loc;
3148
3149
  DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType,
3150
                            QualType can, Expr *AddrSpaceExpr,
3151
                            SourceLocation loc);
3152
3153
public:
3154
149
  Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; }
3155
493
  QualType getPointeeType() const { return PointeeType; }
3156
37
  SourceLocation getAttributeLoc() const { return loc; }
3157
3158
10
  bool isSugared() const { return false; }
3159
0
  QualType desugar() const { return QualType(this, 0); }
3160
3161
55.0M
  static bool classof(const Type *T) {
3162
55.0M
    return T->getTypeClass() == DependentAddressSpace;
3163
55.0M
  }
3164
3165
19
  void Profile(llvm::FoldingSetNodeID &ID) {
3166
19
    Profile(ID, Context, getPointeeType(), getAddrSpaceExpr());
3167
19
  }
3168
3169
  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3170
                      QualType PointeeType, Expr *AddrSpaceExpr);
3171
};
3172
3173
/// Represents an extended vector type where either the type or size is
3174
/// dependent.
3175
///
3176
/// For example:
3177
/// \code
3178
/// template<typename T, int Size>
3179
/// class vector {
3180
///   typedef T __attribute__((ext_vector_type(Size))) type;
3181
/// }
3182
/// \endcode
3183
class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode {
3184
  friend class ASTContext;
3185
3186
  const ASTContext &Context;
3187
  Expr *SizeExpr;
3188
3189
  /// The element type of the array.
3190
  QualType ElementType;
3191
3192
  SourceLocation loc;
3193
3194
  DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType,
3195
                              QualType can, Expr *SizeExpr, SourceLocation loc);
3196
3197
public:
3198
57
  Expr *getSizeExpr() const { return SizeExpr; }
3199
391
  QualType getElementType() const { return ElementType; }
3200
26
  SourceLocation getAttributeLoc() const { return loc; }
3201
3202
0
  bool isSugared() const { return false; }
3203
0
  QualType desugar() const { return QualType(this, 0); }
3204
3205
710
  static bool classof(const Type *T) {
3206
710
    return T->getTypeClass() == DependentSizedExtVector;
3207
710
  }
3208
3209
8
  void Profile(llvm::FoldingSetNodeID &ID) {
3210
8
    Profile(ID, Context, getElementType(), getSizeExpr());
3211
8
  }
3212
3213
  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3214
                      QualType ElementType, Expr *SizeExpr);
3215
};
3216
3217
3218
/// Represents a GCC generic vector type. This type is created using
3219
/// __attribute__((vector_size(n)), where "n" specifies the vector size in
3220
/// bytes; or from an Altivec __vector or vector declaration.
3221
/// Since the constructor takes the number of vector elements, the
3222
/// client is responsible for converting the size into the number of elements.
3223
class VectorType : public Type, public llvm::FoldingSetNode {
3224
public:
3225
  enum VectorKind {
3226
    /// not a target-specific vector type
3227
    GenericVector,
3228
3229
    /// is AltiVec vector
3230
    AltiVecVector,
3231
3232
    /// is AltiVec 'vector Pixel'
3233
    AltiVecPixel,
3234
3235
    /// is AltiVec 'vector bool ...'
3236
    AltiVecBool,
3237
3238
    /// is ARM Neon vector
3239
    NeonVector,
3240
3241
    /// is ARM Neon polynomial vector
3242
    NeonPolyVector,
3243
3244
    /// is AArch64 SVE fixed-length data vector
3245
    SveFixedLengthDataVector,
3246
3247
    /// is AArch64 SVE fixed-length predicate vector
3248
    SveFixedLengthPredicateVector
3249
  };
3250
3251
protected:
3252
  friend class ASTContext; // ASTContext creates these.
3253
3254
  /// The element type of the vector.
3255
  QualType ElementType;
3256
3257
  VectorType(QualType vecType, unsigned nElements, QualType canonType,
3258
             VectorKind vecKind);
3259
3260
  VectorType(TypeClass tc, QualType vecType, unsigned nElements,
3261
             QualType canonType, VectorKind vecKind);
3262
3263
public:
3264
27.8M
  QualType getElementType() const { return ElementType; }
3265
27.0M
  unsigned getNumElements() const { return VectorTypeBits.NumElements; }
3266
3267
26.4M
  bool isSugared() const { return false; }
3268
0
  QualType desugar() const { return QualType(this, 0); }
3269
3270
18.7M
  VectorKind getVectorKind() const {
3271
18.7M
    return VectorKind(VectorTypeBits.VecKind);
3272
18.7M
  }
3273
3274
8.07M
  void Profile(llvm::FoldingSetNodeID &ID) {
3275
8.07M
    Profile(ID, getElementType(), getNumElements(),
3276
8.07M
            getTypeClass(), getVectorKind());
3277
8.07M
  }
3278
3279
  static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
3280
                      unsigned NumElements, TypeClass TypeClass,
3281
13.9M
                      VectorKind VecKind) {
3282
13.9M
    ID.AddPointer(ElementType.getAsOpaquePtr());
3283
13.9M
    ID.AddInteger(NumElements);
3284
13.9M
    ID.AddInteger(TypeClass);
3285
13.9M
    ID.AddInteger(VecKind);
3286
13.9M
  }
3287
3288
283M
  static bool classof(const Type *T) {
3289
283M
    return T->getTypeClass() == Vector || 
T->getTypeClass() == ExtVector151M
;
3290
283M
  }
3291
};
3292
3293
/// Represents a vector type where either the type or size is dependent.
3294
////
3295
/// For example:
3296
/// \code
3297
/// template<typename T, int Size>
3298
/// class vector {
3299
///   typedef T __attribute__((vector_size(Size))) type;
3300
/// }
3301
/// \endcode
3302
class DependentVectorType : public Type, public llvm::FoldingSetNode {
3303
  friend class ASTContext;
3304
3305
  const ASTContext &Context;
3306
  QualType ElementType;
3307
  Expr *SizeExpr;
3308
  SourceLocation Loc;
3309
3310
  DependentVectorType(const ASTContext &Context, QualType ElementType,
3311
                           QualType CanonType, Expr *SizeExpr,
3312
                           SourceLocation Loc, VectorType::VectorKind vecKind);
3313
3314
public:
3315
104
  Expr *getSizeExpr() const { return SizeExpr; }
3316
789
  QualType getElementType() const { return ElementType; }
3317
85
  SourceLocation getAttributeLoc() const { return Loc; }
3318
99
  VectorType::VectorKind getVectorKind() const {
3319
99
    return VectorType::VectorKind(VectorTypeBits.VecKind);
3320
99
  }
3321
3322
60
  bool isSugared() const { return false; }
3323
0
  QualType desugar() const { return QualType(this, 0); }
3324
3325
1.61k
  static bool classof(const Type *T) {
3326
1.61k
    return T->getTypeClass() == DependentVector;
3327
1.61k
  }
3328
3329
14
  void Profile(llvm::FoldingSetNodeID &ID) {
3330
14
    Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind());
3331
14
  }
3332
3333
  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3334
                      QualType ElementType, const Expr *SizeExpr,
3335
                      VectorType::VectorKind VecKind);
3336
};
3337
3338
/// ExtVectorType - Extended vector type. This type is created using
3339
/// __attribute__((ext_vector_type(n)), where "n" is the number of elements.
3340
/// Unlike vector_size, ext_vector_type is only allowed on typedef's. This
3341
/// class enables syntactic extensions, like Vector Components for accessing
3342
/// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL
3343
/// Shading Language).
3344
class ExtVectorType : public VectorType {
3345
  friend class ASTContext; // ASTContext creates these.
3346
3347
  ExtVectorType(QualType vecType, unsigned nElements, QualType canonType)
3348
5.75k
      : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {}
3349
3350
public:
3351
1.60k
  static int getPointAccessorIdx(char c) {
3352
1.60k
    switch (c) {
3353
7
    default: return -1;
3354
732
    
case 'x': 648
case 'r': return 0;
3355
586
    
case 'y': 518
case 'g': return 1;
3356
164
    
case 'z': 102
case 'b': return 2;
3357
118
    
case 'w': 91
case 'a': return 3;
3358
1.60k
    }
3359
1.60k
  }
3360
3361
123
  static int getNumericAccessorIdx(char c) {
3362
123
    switch (c) {
3363
29
      default: return -1;
3364
28
      case '0': return 0;
3365
11
      case '1': return 1;
3366
10
      case '2': return 2;
3367
10
      case '3': return 3;
3368
6
      case '4': return 4;
3369
0
      case '5': return 5;
3370
4
      case '6': return 6;
3371
0
      case '7': return 7;
3372
0
      case '8': return 8;
3373
0
      case '9': return 9;
3374
0
      case 'A':
3375
3
      case 'a': return 10;
3376
0
      case 'B':
3377
8
      case 'b': return 11;
3378
0
      case 'C':
3379
3
      case 'c': return 12;
3380
0
      case 'D':
3381
3
      case 'd': return 13;
3382
0
      case 'E':
3383
0
      case 'e': return 14;
3384
4
      case 'F':
3385
8
      case 'f': return 15;
3386
123
    }
3387
123
  }
3388
3389
1.00k
  static int getAccessorIdx(char c, bool isNumericAccessor) {
3390
1.00k
    if (isNumericAccessor)
3391
53
      return getNumericAccessorIdx(c);
3392
953
    else
3393
953
      return getPointAccessorIdx(c);
3394
1.00k
  }
3395
3396
658
  bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const {
3397
658
    if (int idx = getAccessorIdx(c, isNumericAccessor)+1)
3398
658
      return unsigned(idx-1) < getNumElements();
3399
0
    return false;
3400
658
  }
3401
3402
522k
  bool isSugared() const { return false; }
3403
0
  QualType desugar() const { return QualType(this, 0); }
3404
3405
10.4M
  static bool classof(const Type *T) {
3406
10.4M
    return T->getTypeClass() == ExtVector;
3407
10.4M
  }
3408
};
3409
3410
/// Represents a matrix type, as defined in the Matrix Types clang extensions.
3411
/// __attribute__((matrix_type(rows, columns))), where "rows" specifies
3412
/// number of rows and "columns" specifies the number of columns.
3413
class MatrixType : public Type, public llvm::FoldingSetNode {
3414
protected:
3415
  friend class ASTContext;
3416
3417
  /// The element type of the matrix.
3418
  QualType ElementType;
3419
3420
  MatrixType(QualType ElementTy, QualType CanonElementTy);
3421
3422
  MatrixType(TypeClass TypeClass, QualType ElementTy, QualType CanonElementTy,
3423
             const Expr *RowExpr = nullptr, const Expr *ColumnExpr = nullptr);
3424
3425
public:
3426
  /// Returns type of the elements being stored in the matrix
3427
3.59k
  QualType getElementType() const { return ElementType; }
3428
3429
  /// Valid elements types are the following:
3430
  /// * an integer type (as in C2x 6.2.5p19), but excluding enumerated types
3431
  ///   and _Bool
3432
  /// * the standard floating types float or double
3433
  /// * a half-precision floating point type, if one is supported on the target
3434
993
  static bool isValidElementType(QualType T) {
3435
993
    return T->isDependentType() ||
3436
993
           
(978
T->isRealType()978
&&
!T->isBooleanType()973
&&
!T->isEnumeralType()971
);
3437
993
  }
3438
3439
3.22k
  bool isSugared() const { return false; }
3440
0
  QualType desugar() const { return QualType(this, 0); }
3441
3442
58.9M
  static bool classof(const Type *T) {
3443
58.9M
    return T->getTypeClass() == ConstantMatrix ||
3444
58.9M
           
T->getTypeClass() == DependentSizedMatrix58.9M
;
3445
58.9M
  }
3446
};
3447
3448
/// Represents a concrete matrix type with constant number of rows and columns
3449
class ConstantMatrixType final : public MatrixType {
3450
protected:
3451
  friend class ASTContext;
3452
3453
  /// The element type of the matrix.
3454
  // FIXME: Appears to be unused? There is also MatrixType::ElementType...
3455
  QualType ElementType;
3456
3457
  /// Number of rows and columns.
3458
  unsigned NumRows;
3459
  unsigned NumColumns;
3460
3461
  static constexpr unsigned MaxElementsPerDimension = (1 << 20) - 1;
3462
3463
  ConstantMatrixType(QualType MatrixElementType, unsigned NRows,
3464
                     unsigned NColumns, QualType CanonElementType);
3465
3466
  ConstantMatrixType(TypeClass typeClass, QualType MatrixType, unsigned NRows,
3467
                     unsigned NColumns, QualType CanonElementType);
3468
3469
public:
3470
  /// Returns the number of rows in the matrix.
3471
2.59k
  unsigned getNumRows() const { return NumRows; }
3472
3473
  /// Returns the number of columns in the matrix.
3474
2.53k
  unsigned getNumColumns() const { return NumColumns; }
3475
3476
  /// Returns the number of elements required to embed the matrix into a vector.
3477
0
  unsigned getNumElementsFlattened() const {
3478
0
    return getNumRows() * getNumColumns();
3479
0
  }
3480
3481
  /// Returns true if \p NumElements is a valid matrix dimension.
3482
1.88k
  static constexpr bool isDimensionValid(size_t NumElements) {
3483
1.88k
    return NumElements > 0 && NumElements <= MaxElementsPerDimension;
3484
1.88k
  }
3485
3486
  /// Returns the maximum number of elements per dimension.
3487
6
  static constexpr unsigned getMaxElementsPerDimension() {
3488
6
    return MaxElementsPerDimension;
3489
6
  }
3490
3491
424
  void Profile(llvm::FoldingSetNodeID &ID) {
3492
424
    Profile(ID, getElementType(), getNumRows(), getNumColumns(),
3493
424
            getTypeClass());
3494
424
  }
3495
3496
  static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType,
3497
                      unsigned NumRows, unsigned NumColumns,
3498
1.03k
                      TypeClass TypeClass) {
3499
1.03k
    ID.AddPointer(ElementType.getAsOpaquePtr());
3500
1.03k
    ID.AddInteger(NumRows);
3501
1.03k
    ID.AddInteger(NumColumns);
3502
1.03k
    ID.AddInteger(TypeClass);
3503
1.03k
  }
3504
3505
12.0M
  static bool classof(const Type *T) {
3506
12.0M
    return T->getTypeClass() == ConstantMatrix;
3507
12.0M
  }
3508
};
3509
3510
/// Represents a matrix type where the type and the number of rows and columns
3511
/// is dependent on a template.
3512
class DependentSizedMatrixType final : public MatrixType {
3513
  friend class ASTContext;
3514
3515
  const ASTContext &Context;
3516
  Expr *RowExpr;
3517
  Expr *ColumnExpr;
3518
3519
  SourceLocation loc;
3520
3521
  DependentSizedMatrixType(const ASTContext &Context, QualType ElementType,
3522
                           QualType CanonicalType, Expr *RowExpr,
3523
                           Expr *ColumnExpr, SourceLocation loc);
3524
3525
public:
3526
733
  QualType getElementType() const { return ElementType; }
3527
481
  Expr *getRowExpr() const { return RowExpr; }
3528
414
  Expr *getColumnExpr() const { return ColumnExpr; }
3529
216
  SourceLocation getAttributeLoc() const { return loc; }
3530
3531
76
  bool isSugared() const { return false; }
3532
0
  QualType desugar() const { return QualType(this, 0); }
3533
3534
3.32k
  static bool classof(const Type *T) {
3535
3.32k
    return T->getTypeClass() == DependentSizedMatrix;
3536
3.32k
  }
3537
3538
26
  void Profile(llvm::FoldingSetNodeID &ID) {
3539
26
    Profile(ID, Context, getElementType(), getRowExpr(), getColumnExpr());
3540
26
  }
3541
3542
  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
3543
                      QualType ElementType, Expr *RowExpr, Expr *ColumnExpr);
3544
};
3545
3546
/// FunctionType - C99 6.7.5.3 - Function Declarators.  This is the common base
3547
/// class of FunctionNoProtoType and FunctionProtoType.
3548
class FunctionType : public Type {
3549
  // The type returned by the function.
3550
  QualType ResultType;
3551
3552
public:
3553
  /// Interesting information about a specific parameter that can't simply
3554
  /// be reflected in parameter's type. This is only used by FunctionProtoType
3555
  /// but is in FunctionType to make this class available during the
3556
  /// specification of the bases of FunctionProtoType.
3557
  ///
3558
  /// It makes sense to model language features this way when there's some
3559
  /// sort of parameter-specific override (such as an attribute) that
3560
  /// affects how the function is called.  For example, the ARC ns_consumed
3561
  /// attribute changes whether a parameter is passed at +0 (the default)
3562
  /// or +1 (ns_consumed).  This must be reflected in the function type,
3563
  /// but isn't really a change to the parameter type.
3564
  ///
3565
  /// One serious disadvantage of modelling language features this way is
3566
  /// that they generally do not work with language features that attempt
3567
  /// to destructure types.  For example, template argument deduction will
3568
  /// not be able to match a parameter declared as
3569
  ///   T (*)(U)
3570
  /// against an argument of type
3571
  ///   void (*)(__attribute__((ns_consumed)) id)
3572
  /// because the substitution of T=void, U=id into the former will
3573
  /// not produce the latter.
3574
  class ExtParameterInfo {
3575
    enum {
3576
      ABIMask = 0x0F,
3577
      IsConsumed = 0x10,
3578
      HasPassObjSize = 0x20,
3579
      IsNoEscape = 0x40,
3580
    };
3581
    unsigned char Data = 0;
3582
3583
  public:
3584
41.1M
    ExtParameterInfo() = default;
3585
3586
    /// Return the ABI treatment of this parameter.
3587
2.67M
    ParameterABI getABI() const { return ParameterABI(Data & ABIMask); }
3588
171
    ExtParameterInfo withABI(ParameterABI kind) const {
3589
171
      ExtParameterInfo copy = *this;
3590
171
      copy.Data = (copy.Data & ~ABIMask) | unsigned(kind);
3591
171
      return copy;
3592
171
    }
3593
3594
    /// Is this parameter considered "consumed" by Objective-C ARC?
3595
    /// Consumed parameters must have retainable object type.
3596
31.0k
    bool isConsumed() const { return (Data & IsConsumed); }
3597
78
    ExtParameterInfo withIsConsumed(bool consumed) const {
3598
78
      ExtParameterInfo copy = *this;
3599
78
      if (consumed)
3600
78
        copy.Data |= IsConsumed;
3601
0
      else
3602
0
        copy.Data &= ~IsConsumed;
3603
78
      return copy;
3604
78
    }
3605
3606
2.35k
    bool hasPassObjectSize() const { return Data & HasPassObjSize; }
3607
126
    ExtParameterInfo withHasPassObjectSize() const {
3608
126
      ExtParameterInfo Copy = *this;
3609
126
      Copy.Data |= HasPassObjSize;
3610
126
      return Copy;
3611
126
    }
3612
3613
7.28M
    bool isNoEscape() const { return Data & IsNoEscape; }
3614
22.4k
    ExtParameterInfo withIsNoEscape(bool NoEscape) const {
3615
22.4k
      ExtParameterInfo Copy = *this;
3616
22.4k
      if (NoEscape)
3617
8.08k
        Copy.Data |= IsNoEscape;
3618
14.3k
      else
3619
14.3k
        Copy.Data &= ~IsNoEscape;
3620
22.4k
      return Copy;
3621
22.4k
    }
3622
3623
464k
    unsigned char getOpaqueValue() const { return Data; }
3624
4
    static ExtParameterInfo getFromOpaqueValue(unsigned char data) {
3625
4
      ExtParameterInfo result;
3626
4
      result.Data = data;
3627
4
      return result;
3628
4
    }
3629
3630
84
    friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3631
84
      return lhs.Data == rhs.Data;
3632
84
    }
3633
3634
196
    friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) {
3635
196
      return lhs.Data != rhs.Data;
3636
196
    }
3637
  };
3638
3639
  /// A class which abstracts out some details necessary for
3640
  /// making a call.
3641
  ///
3642
  /// It is not actually used directly for storing this information in
3643
  /// a FunctionType, although FunctionType does currently use the
3644
  /// same bit-pattern.
3645
  ///
3646
  // If you add a field (say Foo), other than the obvious places (both,
3647
  // constructors, compile failures), what you need to update is
3648
  // * Operator==
3649
  // * getFoo
3650
  // * withFoo
3651
  // * functionType. Add Foo, getFoo.
3652
  // * ASTContext::getFooType
3653
  // * ASTContext::mergeFunctionTypes
3654
  // * FunctionNoProtoType::Profile
3655
  // * FunctionProtoType::Profile
3656
  // * TypePrinter::PrintFunctionProto
3657
  // * AST read and write
3658
  // * Codegen
3659
  class ExtInfo {
3660
    friend class FunctionType;
3661
3662
    // Feel free to rearrange or add bits, but if you go over 16, you'll need to
3663
    // adjust the Bits field below, and if you add bits, you'll need to adjust
3664
    // Type::FunctionTypeBitfields::ExtInfo as well.
3665
3666
    // |  CC  |noreturn|produces|nocallersavedregs|regparm|nocfcheck|cmsenscall|
3667
    // |0 .. 4|   5    |    6   |       7         |8 .. 10|    11   |    12    |
3668
    //
3669
    // regparm is either 0 (no regparm attribute) or the regparm value+1.
3670
    enum { CallConvMask = 0x1F };
3671
    enum { NoReturnMask = 0x20 };
3672
    enum { ProducesResultMask = 0x40 };
3673
    enum { NoCallerSavedRegsMask = 0x80 };
3674
    enum {
3675
      RegParmMask =  0x700,
3676
      RegParmOffset = 8
3677
    };
3678
    enum { NoCfCheckMask = 0x800 };
3679
    enum { CmseNSCallMask = 0x1000 };
3680
    uint16_t Bits = CC_C;
3681
3682
165M
    ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {}
3683
3684
  public:
3685
    // Constructor with no defaults. Use this when you know that you
3686
    // have all the elements (when reading an AST file for example).
3687
    ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc,
3688
            bool producesResult, bool noCallerSavedRegs, bool NoCfCheck,
3689
685k
            bool cmseNSCall) {
3690
685k
      assert((!hasRegParm || regParm < 7) && "Invalid regparm value");
3691
685k
      Bits = ((unsigned)cc) | (noReturn ? 
NoReturnMask319
:
0685k
) |
3692
685k
             (producesResult ? 
ProducesResultMask0
: 0) |
3693
685k
             (noCallerSavedRegs ? 
NoCallerSavedRegsMask0
: 0) |
3694
685k
             (hasRegParm ? 
((regParm + 1) << RegParmOffset)0
: 0) |
3695
685k
             (NoCfCheck ? 
NoCfCheckMask0
: 0) |
3696
685k
             (cmseNSCall ? 
CmseNSCallMask1
:
0685k
);
3697
685k
    }
3698
3699
    // Constructor with all defaults. Use when for example creating a
3700
    // function known to use defaults.
3701
146M
    ExtInfo() = default;
3702
3703
    // Constructor with just the calling convention, which is an important part
3704
    // of the canonical type.
3705
34.6M
    ExtInfo(CallingConv CC) : Bits(CC) {}
3706
3707
9.84M
    bool getNoReturn() const { return Bits & NoReturnMask; }
3708
4.19M
    bool getProducesResult() const { return Bits & ProducesResultMask; }
3709
36.3M
    bool getCmseNSCall() const { return Bits & CmseNSCallMask; }
3710
3.11M
    bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; }
3711
2.61M
    bool getNoCfCheck() const { return Bits & NoCfCheckMask; }
3712
3.07M
    bool getHasRegParm() const { return ((Bits & RegParmMask) >> RegParmOffset) != 0; }
3713
3714
3.11M
    unsigned getRegParm() const {
3715
3.11M
      unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset;
3716
3.11M
      if (RegParm > 0)
3717
211
        --RegParm;
3718
3.11M
      return RegParm;
3719
3.11M
    }
3720
3721
9.69M
    CallingConv getCC() const { return CallingConv(Bits & CallConvMask); }
3722
3723
1.15M
    bool operator==(ExtInfo Other) const {
3724
1.15M
      return Bits == Other.Bits;
3725
1.15M
    }
3726
17
    bool operator!=(ExtInfo Other) const {
3727
17
      return Bits != Other.Bits;
3728
17
    }
3729
3730
    // Note that we don't have setters. That is by design, use
3731
    // the following with methods instead of mutating these objects.
3732
3733
19.8k
    ExtInfo withNoReturn(bool noReturn) const {
3734
19.8k
      if (noReturn)
3735
8.01k
        return ExtInfo(Bits | NoReturnMask);
3736
11.8k
      else
3737
11.8k
        return ExtInfo(Bits & ~NoReturnMask);
3738
19.8k
    }
3739
3740
449
    ExtInfo withProducesResult(bool producesResult) const {
3741
449
      if (producesResult)
3742
449
        return ExtInfo(Bits | ProducesResultMask);
3743
0
      else
3744
0
        return ExtInfo(Bits & ~ProducesResultMask);
3745
449
    }
3746
3747
77
    ExtInfo withCmseNSCall(bool cmseNSCall) const {
3748
77
      if (cmseNSCall)
3749
77
        return ExtInfo(Bits | CmseNSCallMask);
3750
0
      else
3751
0
        return ExtInfo(Bits & ~CmseNSCallMask);
3752
77
    }
3753
3754
24
    ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const {
3755
24
      if (noCallerSavedRegs)
3756
24
        return ExtInfo(Bits | NoCallerSavedRegsMask);
3757
0
      else
3758
0
        return ExtInfo(Bits & ~NoCallerSavedRegsMask);
3759
24
    }
3760
3761
12
    ExtInfo withNoCfCheck(bool noCfCheck) const {
3762
12
      if (noCfCheck)
3763
12
        return ExtInfo(Bits | NoCfCheckMask);
3764
0
      else
3765
0
        return ExtInfo(Bits & ~NoCfCheckMask);
3766
12
    }
3767
3768
84
    ExtInfo withRegParm(unsigned RegParm) const {
3769
84
      assert(RegParm < 7 && "Invalid regparm value");
3770
0
      return ExtInfo((Bits & ~RegParmMask) |
3771
84
                     ((RegParm + 1) << RegParmOffset));
3772
84
    }
3773
3774
441k
    ExtInfo withCallingConv(CallingConv cc) const {
3775
441k
      return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc);
3776
441k
    }
3777
3778
154M
    void Profile(llvm::FoldingSetNodeID &ID) const {
3779
154M
      ID.AddInteger(Bits);
3780
154M
    }
3781
  };
3782
3783
  /// A simple holder for a QualType representing a type in an
3784
  /// exception specification. Unfortunately needed by FunctionProtoType
3785
  /// because TrailingObjects cannot handle repeated types.
3786
  struct ExceptionType { QualType Type; };
3787
3788
  /// A simple holder for various uncommon bits which do not fit in
3789
  /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the
3790
  /// alignment of subsequent objects in TrailingObjects. You must update
3791
  /// hasExtraBitfields in FunctionProtoType after adding extra data here.
3792
  struct alignas(void *) FunctionTypeExtraBitfields {
3793
    /// The number of types in the exception specification.
3794
    /// A whole unsigned is not needed here and according to
3795
    /// [implimits] 8 bits would be enough here.
3796
    unsigned NumExceptionType;
3797
  };
3798
3799
protected:
3800
  FunctionType(TypeClass tc, QualType res, QualType Canonical,
3801
               TypeDependence Dependence, ExtInfo Info)
3802
17.0M
      : Type(tc, Canonical, Dependence), ResultType(res) {
3803
17.0M
    FunctionTypeBits.ExtInfo = Info.Bits;
3804
17.0M
  }
3805
3806
123M
  Qualifiers getFastTypeQuals() const {
3807
123M
    return Qualifiers::fromFastMask(FunctionTypeBits.FastTypeQuals);
3808
123M
  }
3809
3810
public:
3811
430M
  QualType getReturnType() const { return ResultType; }
3812
3813
161
  bool getHasRegParm() const { return getExtInfo().getHasRegParm(); }
3814
10
  unsigned getRegParmType() const { return getExtInfo().getRegParm(); }
3815
3816
  /// Determine whether this function type includes the GNU noreturn
3817
  /// attribute. The C++11 [[noreturn]] attribute does not affect the function
3818
  /// type.
3819
6.30M
  bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); }
3820
3821
34.2M
  bool getCmseNSCallAttr() const { return getExtInfo().getCmseNSCall(); }
3822
5.32M
  CallingConv getCallConv() const { return getExtInfo().getCC(); }
3823
164M
  ExtInfo getExtInfo() const { return ExtInfo(FunctionTypeBits.ExtInfo); }
3824
3825
  static_assert((~Qualifiers::FastMask & Qualifiers::CVRMask) == 0,
3826
                "Const, volatile and restrict are assumed to be a subset of "
3827
                "the fast qualifiers.");
3828
3829
714k
  bool isConst() const { return getFastTypeQuals().hasConst(); }
3830
655k
  bool isVolatile() const { return getFastTypeQuals().hasVolatile(); }
3831
30.4k
  bool isRestrict() const { return getFastTypeQuals().hasRestrict(); }
3832
3833
  /// Determine the type of an expression that calls a function of
3834
  /// this type.
3835
4.87M
  QualType getCallResultType(const ASTContext &Context) const {
3836
4.87M
    return getReturnType().getNonLValueExprType(Context);
3837
4.87M
  }
3838
3839
  static StringRef getNameForCallConv(CallingConv CC);
3840
3841
1.62G
  static bool classof(const Type *T) {
3842
1.62G
    return T->getTypeClass() == FunctionNoProto ||
3843
1.62G
           
T->getTypeClass() == FunctionProto1.61G
;
3844
1.62G
  }
3845
};
3846
3847
/// Represents a K&R-style 'int foo()' function, which has
3848
/// no information available about its arguments.
3849
class FunctionNoProtoType : public FunctionType, public llvm::FoldingSetNode {
3850
  friend class ASTContext; // ASTContext creates these.
3851
3852
  FunctionNoProtoType(QualType Result, QualType Canonical, ExtInfo Info)
3853
      : FunctionType(FunctionNoProto, Result, Canonical,
3854
                     Result->getDependence() &
3855
                         ~(TypeDependence::DependentInstantiation |
3856
                           TypeDependence::UnexpandedPack),
3857
159k
                     Info) {}
3858
3859
public:
3860
  // No additional state past what FunctionType provides.
3861
3862
11.3k
  bool isSugared() const { return false; }
3863
0
  QualType desugar() const { return QualType(this, 0); }
3864
3865
323k
  void Profile(llvm::FoldingSetNodeID &ID) {
3866
323k
    Profile(ID, getReturnType(), getExtInfo());
3867
323k
  }
3868
3869
  static void Profile(llvm::FoldingSetNodeID &ID, QualType ResultType,
3870
643k
                      ExtInfo Info) {
3871
643k
    Info.Profile(ID);
3872
643k
    ID.AddPointer(ResultType.getAsOpaquePtr());
3873
643k
  }
3874
3875
627M
  static bool classof(const Type *T) {
3876
627M
    return T->getTypeClass() == FunctionNoProto;
3877
627M
  }
3878
};
3879
3880
/// Represents a prototype with parameter type info, e.g.
3881
/// 'int foo(int)' or 'int foo(void)'.  'void' is represented as having no
3882
/// parameters, not as having a single void parameter. Such a type can have
3883
/// an exception specification, but this specification is not part of the
3884
/// canonical type. FunctionProtoType has several trailing objects, some of
3885
/// which optional. For more information about the trailing objects see
3886
/// the first comment inside FunctionProtoType.
3887
class FunctionProtoType final
3888
    : public FunctionType,
3889
      public llvm::FoldingSetNode,
3890
      private llvm::TrailingObjects<
3891
          FunctionProtoType, QualType, SourceLocation,
3892
          FunctionType::FunctionTypeExtraBitfields, FunctionType::ExceptionType,
3893
          Expr *, FunctionDecl *, FunctionType::ExtParameterInfo, Qualifiers> {
3894
  friend class ASTContext; // ASTContext creates these.
3895
  friend TrailingObjects;
3896
3897
  // FunctionProtoType is followed by several trailing objects, some of
3898
  // which optional. They are in order:
3899
  //
3900
  // * An array of getNumParams() QualType holding the parameter types.
3901
  //   Always present. Note that for the vast majority of FunctionProtoType,
3902
  //   these will be the only trailing objects.
3903
  //
3904
  // * Optionally if the function is variadic, the SourceLocation of the
3905
  //   ellipsis.
3906
  //
3907
  // * Optionally if some extra data is stored in FunctionTypeExtraBitfields
3908
  //   (see FunctionTypeExtraBitfields and FunctionTypeBitfields):
3909
  //   a single FunctionTypeExtraBitfields. Present if and only if
3910
  //   hasExtraBitfields() is true.
3911
  //
3912
  // * Optionally exactly one of:
3913
  //   * an array of getNumExceptions() ExceptionType,
3914
  //   * a single Expr *,
3915
  //   * a pair of FunctionDecl *,
3916
  //   * a single FunctionDecl *
3917
  //   used to store information about the various types of exception
3918
  //   specification. See getExceptionSpecSize for the details.
3919
  //
3920
  // * Optionally an array of getNumParams() ExtParameterInfo holding
3921
  //   an ExtParameterInfo for each of the parameters. Present if and
3922
  //   only if hasExtParameterInfos() is true.
3923
  //
3924
  // * Optionally a Qualifiers object to represent extra qualifiers that can't
3925
  //   be represented by FunctionTypeBitfields.FastTypeQuals. Present if and only
3926
  //   if hasExtQualifiers() is true.
3927
  //
3928
  // The optional FunctionTypeExtraBitfields has to be before the data
3929
  // related to the exception specification since it contains the number
3930
  // of exception types.
3931
  //
3932
  // We put the ExtParameterInfos last.  If all were equal, it would make
3933
  // more sense to put these before the exception specification, because
3934
  // it's much easier to skip past them compared to the elaborate switch
3935
  // required to skip the exception specification.  However, all is not
3936
  // equal; ExtParameterInfos are used to model very uncommon features,
3937
  // and it's better not to burden the more common paths.
3938
3939
public:
3940
  /// Holds information about the various types of exception specification.
3941
  /// ExceptionSpecInfo is not stored as such in FunctionProtoType but is
3942
  /// used to group together the various bits of information about the
3943
  /// exception specification.
3944
  struct ExceptionSpecInfo {
3945
    /// The kind of exception specification this is.
3946
    ExceptionSpecificationType Type = EST_None;
3947
3948
    /// Explicitly-specified list of exception types.
3949
    ArrayRef<QualType> Exceptions;
3950
3951
    /// Noexcept expression, if this is a computed noexcept specification.
3952
    Expr *NoexceptExpr = nullptr;
3953
3954
    /// The function whose exception specification this is, for
3955
    /// EST_Unevaluated and EST_Uninstantiated.
3956
    FunctionDecl *SourceDecl = nullptr;
3957
3958
    /// The function template whose exception specification this is instantiated
3959
    /// from, for EST_Uninstantiated.
3960
    FunctionDecl *SourceTemplate = nullptr;
3961
3962
260M
    ExceptionSpecInfo() = default;
3963
3964
113k
    ExceptionSpecInfo(ExceptionSpecificationType EST) : Type(EST) {}
3965
  };
3966
3967
  /// Extra information about a function prototype. ExtProtoInfo is not
3968
  /// stored as such in FunctionProtoType but is used to group together
3969
  /// the various bits of extra information about a function prototype.
3970
  struct ExtProtoInfo {
3971
    FunctionType::ExtInfo ExtInfo;
3972
    bool Variadic : 1;
3973
    bool HasTrailingReturn : 1;
3974
    Qualifiers TypeQuals;
3975
    RefQualifierKind RefQualifier = RQ_None;
3976
    ExceptionSpecInfo ExceptionSpec;
3977
    const ExtParameterInfo *ExtParameterInfos = nullptr;
3978
    SourceLocation EllipsisLoc;
3979
3980
146M
    ExtProtoInfo() : Variadic(false), HasTrailingReturn(false) {}
3981
3982
    ExtProtoInfo(CallingConv CC)
3983
369k
        : ExtInfo(CC), Variadic(false), HasTrailingReturn(false) {}
3984
3985
682k
    ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &ESI) {
3986
682k
      ExtProtoInfo Result(*this);
3987
682k
      Result.ExceptionSpec = ESI;
3988
682k
      return Result;
3989
682k
    }
3990
  };
3991
3992
private:
3993
6.91M
  unsigned numTrailingObjects(OverloadToken<QualType>) const {
3994
6.91M
    return getNumParams();
3995
6.91M
  }
3996
3997
5.99M
  unsigned numTrailingObjects(OverloadToken<SourceLocation>) const {
3998
5.99M
    return isVariadic();
3999
5.99M
  }
4000
4001
5.99M
  unsigned numTrailingObjects(OverloadToken<FunctionTypeExtraBitfields>) const {
4002
5.99M
    return hasExtraBitfields();
4003
5.99M
  }
4004
4005
4.18M
  unsigned numTrailingObjects(OverloadToken<ExceptionType>) const {
4006
4.18M
    return getExceptionSpecSize().NumExceptionType;
4007
4.18M
  }
4008
4009
2.74M
  unsigned numTrailingObjects(OverloadToken<Expr *>) const {
4010
2.74M
    return getExceptionSpecSize().NumExprPtr;
4011
2.74M
  }
4012
4013
113k
  unsigned numTrailingObjects(OverloadToken<FunctionDecl *>) const {
4014
113k
    return getExceptionSpecSize().NumFunctionDeclPtr;
4015
113k
  }
4016
4017
3.55k
  unsigned numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
4018
3.55k
    return hasExtParameterInfos() ? 
getNumParams()0
: 0;
4019
3.55k
  }
4020
4021
  /// Determine whether there are any argument types that
4022
  /// contain an unexpanded parameter pack.
4023
  static bool containsAnyUnexpandedParameterPack(const QualType *ArgArray,
4024
0
                                                 unsigned numArgs) {
4025
0
    for (unsigned Idx = 0; Idx < numArgs; ++Idx)
4026
0
      if (ArgArray[Idx]->containsUnexpandedParameterPack())
4027
0
        return true;
4028
0
4029
0
    return false;
4030
0
  }
4031
4032
  FunctionProtoType(QualType result, ArrayRef<QualType> params,
4033
                    QualType canonical, const ExtProtoInfo &epi);
4034
4035
  /// This struct is returned by getExceptionSpecSize and is used to
4036
  /// translate an ExceptionSpecificationType to the number and kind
4037
  /// of trailing objects related to the exception specification.
4038
  struct ExceptionSpecSizeHolder {
4039
    unsigned NumExceptionType;
4040
    unsigned NumExprPtr;
4041
    unsigned NumFunctionDeclPtr;
4042
  };
4043
4044
  /// Return the number and kind of trailing objects
4045
  /// related to the exception specification.
4046
  static ExceptionSpecSizeHolder
4047
23.9M
  getExceptionSpecSize(ExceptionSpecificationType EST, unsigned NumExceptions) {
4048
23.9M
    switch (EST) {
4049
15.3M
    case EST_None:
4050
15.3M
    case EST_DynamicNone:
4051
15.3M
    case EST_MSAny:
4052
16.4M
    case EST_BasicNoexcept:
4053
16.4M
    case EST_Unparsed:
4054
16.4M
    case EST_NoThrow:
4055
16.4M
      return {0, 0, 0};
4056
4057
630
    case EST_Dynamic:
4058
630
      return {NumExceptions, 0, 0};
4059
4060
1.58M
    case EST_DependentNoexcept:
4061
1.59M
    case EST_NoexceptFalse:
4062
1.64M
    case EST_NoexceptTrue:
4063
1.64M
      return {0, 1, 0};
4064
4065
861k
    case EST_Uninstantiated:
4066
861k
      return {0, 0, 2};
4067
4068
4.95M
    case EST_Unevaluated:
4069
4.95M
      return {0, 0, 1};
4070
23.9M
    }
4071
23.9M
    
llvm_unreachable0
("bad exception specification kind");
4072
23.9M
  }
4073
4074
  /// Return the number and kind of trailing objects
4075
  /// related to the exception specification.
4076
7.04M
  ExceptionSpecSizeHolder getExceptionSpecSize() const {
4077
7.04M
    return getExceptionSpecSize(getExceptionSpecType(), getNumExceptions());
4078
7.04M
  }
4079
4080
  /// Whether the trailing FunctionTypeExtraBitfields is present.
4081
39.8M
  static bool hasExtraBitfields(ExceptionSpecificationType EST) {
4082
    // If the exception spec type is EST_Dynamic then we have > 0 exception
4083
    // types and the exact number is stored in FunctionTypeExtraBitfields.
4084
39.8M
    return EST == EST_Dynamic;
4085
39.8M
  }
4086
4087
  /// Whether the trailing FunctionTypeExtraBitfields is present.
4088
5.99M
  bool hasExtraBitfields() const {
4089
5.99M
    return hasExtraBitfields(getExceptionSpecType());
4090
5.99M
  }
4091
4092
122M
  bool hasExtQualifiers() const {
4093
122M
    return FunctionTypeBits.HasExtQuals;
4094
122M
  }
4095
4096
public:
4097
1.25G
  unsigned getNumParams() const { return FunctionTypeBits.NumParams; }
4098
4099
24.4M
  QualType getParamType(unsigned i) const {
4100
24.4M
    assert(i < getNumParams() && "invalid parameter index");
4101
0
    return param_type_begin()[i];
4102
24.4M
  }
4103
4104
1.92M
  ArrayRef<QualType> getParamTypes() const {
4105
1.92M
    return llvm::makeArrayRef(param_type_begin(), param_type_end());
4106
1.92M
  }
4107
4108
110M
  ExtProtoInfo getExtProtoInfo() const {
4109
110M
    ExtProtoInfo EPI;
4110
110M
    EPI.ExtInfo = getExtInfo();
4111
110M
    EPI.Variadic = isVariadic();
4112
110M
    EPI.EllipsisLoc = getEllipsisLoc();
4113
110M
    EPI.HasTrailingReturn = hasTrailingReturn();
4114
110M
    EPI.ExceptionSpec = getExceptionSpecInfo();
4115
110M
    EPI.TypeQuals = getMethodQuals();
4116
110M
    EPI.RefQualifier = getRefQualifier();
4117
110M
    EPI.ExtParameterInfos = getExtParameterInfosOrNull();
4118
110M
    return EPI;
4119
110M
  }
4120
4121
  /// Get the kind of exception specification on this function.
4122
392M
  ExceptionSpecificationType getExceptionSpecType() const {
4123
392M
    return static_cast<ExceptionSpecificationType>(
4124
392M
        FunctionTypeBits.ExceptionSpecType);
4125
392M
  }
4126
4127
  /// Return whether this function has any kind of exception spec.
4128
150M
  bool hasExceptionSpec() const { return getExceptionSpecType() != EST_None; }
4129
4130
  /// Return whether this function has a dynamic (throw) exception spec.
4131
47.1k
  bool hasDynamicExceptionSpec() const {
4132
47.1k
    return isDynamicExceptionSpec(getExceptionSpecType());
4133
47.1k
  }
4134
4135
  /// Return whether this function has a noexcept exception spec.
4136
0
  bool hasNoexceptExceptionSpec() const {
4137
0
    return isNoexceptExceptionSpec(getExceptionSpecType());
4138
0
  }
4139
4140
  /// Return whether this function has a dependent exception spec.
4141
  bool hasDependentExceptionSpec() const;
4142
4143
  /// Return whether this function has an instantiation-dependent exception
4144
  /// spec.
4145
  bool hasInstantiationDependentExceptionSpec() const;
4146
4147
  /// Return all the available information about this type's exception spec.
4148
111M
  ExceptionSpecInfo getExceptionSpecInfo() const {
4149
111M
    ExceptionSpecInfo Result;
4150
111M
    Result.Type = getExceptionSpecType();
4151
111M
    if (Result.Type == EST_Dynamic) {
4152
2.27k
      Result.Exceptions = exceptions();
4153
111M
    } else if (isComputedNoexcept(Result.Type)) {
4154
1.20M
      Result.NoexceptExpr = getNoexceptExpr();
4155
109M
    } else if (Result.Type == EST_Uninstantiated) {
4156
162k
      Result.SourceDecl = getExceptionSpecDecl();
4157
162k
      Result.SourceTemplate = getExceptionSpecTemplate();
4158
109M
    } else if (Result.Type == EST_Unevaluated) {
4159
1.55M
      Result.SourceDecl = getExceptionSpecDecl();
4160
1.55M
    }
4161
111M
    return Result;
4162
111M
  }
4163
4164
  /// Return the number of types in the exception specification.
4165
7.94M
  unsigned getNumExceptions() const {
4166
7.94M
    return getExceptionSpecType() == EST_Dynamic
4167
7.94M
               ? getTrailingObjects<FunctionTypeExtraBitfields>()
4168
4.63k
                     ->NumExceptionType
4169
7.94M
               : 
07.94M
;
4170
7.94M
  }
4171
4172
  /// Return the ith exception type, where 0 <= i < getNumExceptions().
4173
847
  QualType getExceptionType(unsigned i) const {
4174
847
    assert(i < getNumExceptions() && "Invalid exception number!");
4175
0
    return exception_begin()[i];
4176
847
  }
4177
4178
  /// Return the expression inside noexcept(expression), or a null pointer
4179
  /// if there is none (because the exception spec is not of this form).
4180
1.88M
  Expr *getNoexceptExpr() const {
4181
1.88M
    if (!isComputedNoexcept(getExceptionSpecType()))
4182
636k
      return nullptr;
4183
1.24M
    return *getTrailingObjects<Expr *>();
4184
1.88M
  }
4185
4186
  /// If this function type has an exception specification which hasn't
4187
  /// been determined yet (either because it has not been evaluated or because
4188
  /// it has not been instantiated), this is the function whose exception
4189
  /// specification is represented by this type.
4190
1.91M
  FunctionDecl *getExceptionSpecDecl() const {
4191
1.91M
    if (getExceptionSpecType() != EST_Uninstantiated &&
4192
1.91M
        
getExceptionSpecType() != EST_Unevaluated1.73M
)
4193
0
      return nullptr;
4194
1.91M
    return getTrailingObjects<FunctionDecl *>()[0];
4195
1.91M
  }
4196
4197
  /// If this function type has an uninstantiated exception
4198
  /// specification, this is the function whose exception specification
4199
  /// should be instantiated to find the exception specification for
4200
  /// this type.
4201
168k
  FunctionDecl *getExceptionSpecTemplate() const {
4202
168k
    if (getExceptionSpecType() != EST_Uninstantiated)
4203
0
      return nullptr;
4204
168k
    return getTrailingObjects<FunctionDecl *>()[1];
4205
168k
  }
4206
4207
  /// Determine whether this function type has a non-throwing exception
4208
  /// specification.
4209
  CanThrowResult canThrow() const;
4210
4211
  /// Determine whether this function type has a non-throwing exception
4212
  /// specification. If this depends on template arguments, returns
4213
  /// \c ResultIfDependent.
4214
1.24M
  bool isNothrow(bool ResultIfDependent = false) const {
4215
1.24M
    return ResultIfDependent ? 
canThrow() != CT_Can1.81k
:
canThrow() == CT_Cannot1.24M
;
4216
1.24M
  }
4217
4218
  /// Whether this function prototype is variadic.
4219
537M
  bool isVariadic() const { return FunctionTypeBits.Variadic; }
4220
4221
110M
  SourceLocation getEllipsisLoc() const {
4222
110M
    return isVariadic() ? 
*getTrailingObjects<SourceLocation>()780k
4223
110M
                        : 
SourceLocation()110M
;
4224
110M
  }
4225
4226
  /// Determines whether this function prototype contains a
4227
  /// parameter pack at the end.
4228
  ///
4229
  /// A function template whose last parameter is a parameter pack can be
4230
  /// called with an arbitrary number of arguments, much like a variadic
4231
  /// function.
4232
  bool isTemplateVariadic() const;
4233
4234
  /// Whether this function prototype has a trailing return type.
4235
117M
  bool hasTrailingReturn() const { return FunctionTypeBits.HasTrailingReturn; }
4236
4237
122M
  Qualifiers getMethodQuals() const {
4238
122M
    if (hasExtQualifiers())
4239
2.97k
      return *getTrailingObjects<Qualifiers>();
4240
122M
    else
4241
122M
      return getFastTypeQuals();
4242
122M
  }
4243
4244
  /// Retrieve the ref-qualifier associated with this function type.
4245
117M
  RefQualifierKind getRefQualifier() const {
4246
117M
    return static_cast<RefQualifierKind>(FunctionTypeBits.RefQualifier);
4247
117M
  }
4248
4249
  using param_type_iterator = const QualType *;
4250
  using param_type_range = llvm::iterator_range<param_type_iterator>;
4251
4252
13.4M
  param_type_range param_types() const {
4253
13.4M
    return param_type_range(param_type_begin(), param_type_end());
4254
13.4M
  }
4255
4256
607M
  param_type_iterator param_type_begin() const {
4257
607M
    return getTrailingObjects<QualType>();
4258
607M
  }
4259
4260
164M
  param_type_iterator param_type_end() const {
4261
164M
    return param_type_begin() + getNumParams();
4262
164M
  }
4263
4264
  using exception_iterator = const QualType *;
4265
4266
901k
  ArrayRef<QualType> exceptions() const {
4267
901k
    return llvm::makeArrayRef(exception_begin(), exception_end());
4268
901k
  }
4269
4270
1.80M
  exception_iterator exception_begin() const {
4271
1.80M
    return reinterpret_cast<exception_iterator>(
4272
1.80M
        getTrailingObjects<ExceptionType>());
4273
1.80M
  }
4274
4275
901k
  exception_iterator exception_end() const {
4276
901k
    return exception_begin() + getNumExceptions();
4277
901k
  }
4278
4279
  /// Is there any interesting extra information for any of the parameters
4280
  /// of this function type?
4281
121M
  bool hasExtParameterInfos() const {
4282
121M
    return FunctionTypeBits.HasExtParameterInfos;
4283
121M
  }
4284
4285
1.53k
  ArrayRef<ExtParameterInfo> getExtParameterInfos() const {
4286
1.53k
    assert(hasExtParameterInfos());
4287
0
    return ArrayRef<ExtParameterInfo>(getTrailingObjects<ExtParameterInfo>(),
4288
1.53k
                                      getNumParams());
4289
1.53k
  }
4290
4291
  /// Return a pointer to the beginning of the array of extra parameter
4292
  /// information, if present, or else null if none of the parameters
4293
  /// carry it.  This is equivalent to getExtProtoInfo().ExtParameterInfos.
4294
112M
  const ExtParameterInfo *getExtParameterInfosOrNull() const {
4295
112M
    if (!hasExtParameterInfos())
4296
112M
      return nullptr;
4297
94.1k
    return getTrailingObjects<ExtParameterInfo>();
4298
112M
  }
4299
4300
5.93M
  ExtParameterInfo getExtParameterInfo(unsigned I) const {
4301
5.93M
    assert(I < getNumParams() && "parameter index out of range");
4302
5.93M
    if (hasExtParameterInfos())
4303
1.23k
      return getTrailingObjects<ExtParameterInfo>()[I];
4304
5.93M
    return ExtParameterInfo();
4305
5.93M
  }
4306
4307
0
  ParameterABI getParameterABI(unsigned I) const {
4308
0
    assert(I < getNumParams() && "parameter index out of range");
4309
0
    if (hasExtParameterInfos())
4310
0
      return getTrailingObjects<ExtParameterInfo>()[I].getABI();
4311
0
    return ParameterABI::Ordinary;
4312
0
  }
4313
4314
27.0k
  bool isParamConsumed(unsigned I) const {
4315
27.0k
    assert(I < getNumParams() && "parameter index out of range");
4316
27.0k
    if (hasExtParameterInfos())
4317
14
      return getTrailingObjects<ExtParameterInfo>()[I].isConsumed();
4318
27.0k
    return false;
4319
27.0k
  }
4320
4321
3.01M
  bool isSugared() const { return false; }
4322
163
  QualType desugar() const { return QualType(this, 0); }
4323
4324
  void printExceptionSpecification(raw_ostream &OS,
4325
                                   const PrintingPolicy &Policy) const;
4326
4327
2.26G
  static bool classof(const Type *T) {
4328
2.26G
    return T->getTypeClass() == FunctionProto;
4329
2.26G
  }
4330
4331
  void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
4332
  static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
4333
                      param_type_iterator ArgTys, unsigned NumArgs,
4334
                      const ExtProtoInfo &EPI, const ASTContext &Context,
4335
                      bool Canonical);
4336
};
4337
4338
/// Represents the dependent type named by a dependently-scoped
4339
/// typename using declaration, e.g.
4340
///   using typename Base<T>::foo;
4341
///
4342
/// Template instantiation turns these into the underlying type.
4343
class UnresolvedUsingType : public Type {
4344
  friend class ASTContext; // ASTContext creates these.
4345
4346
  UnresolvedUsingTypenameDecl *Decl;
4347
4348
  UnresolvedUsingType(const UnresolvedUsingTypenameDecl *D)
4349
      : Type(UnresolvedUsing, QualType(),
4350
             TypeDependence::DependentInstantiation),
4351
1.01k
        Decl(const_cast<UnresolvedUsingTypenameDecl *>(D)) {}
4352
4353
public:
4354
1.13k
  UnresolvedUsingTypenameDecl *getDecl() const { return Decl; }
4355
4356
294
  bool isSugared() const { return false; }
4357
0
  QualType desugar() const { return QualType(this, 0); }
4358
4359
18.0k
  static bool classof(const Type *T) {
4360
18.0k
    return T->getTypeClass() == UnresolvedUsing;
4361
18.0k
  }
4362
4363
0
  void Profile(llvm::FoldingSetNodeID &ID) {
4364
0
    return Profile(ID, Decl);
4365
0
  }
4366
4367
  static void Profile(llvm::FoldingSetNodeID &ID,
4368
0
                      UnresolvedUsingTypenameDecl *D) {
4369
0
    ID.AddPointer(D);
4370
0
  }
4371
};
4372
4373
class TypedefType : public Type {
4374
  TypedefNameDecl *Decl;
4375
4376
private:
4377
  friend class ASTContext; // ASTContext creates these.
4378
4379
  TypedefType(TypeClass tc, const TypedefNameDecl *D, QualType underlying,
4380
              QualType can);
4381
4382
public:
4383
117M
  TypedefNameDecl *getDecl() const { return Decl; }
4384
4385
98.3M
  bool isSugared() const { return true; }
4386
  QualType desugar() const;
4387
4388
763M
  static bool classof(const Type *T) { return T->getTypeClass() == Typedef; }
4389
};
4390
4391
/// Sugar type that represents a type that was qualified by a qualifier written
4392
/// as a macro invocation.
4393
class MacroQualifiedType : public Type {
4394
  friend class ASTContext; // ASTContext creates these.
4395
4396
  QualType UnderlyingTy;
4397
  const IdentifierInfo *MacroII;
4398
4399
  MacroQualifiedType(QualType UnderlyingTy, QualType CanonTy,
4400
                     const IdentifierInfo *MacroII)
4401
      : Type(MacroQualified, CanonTy, UnderlyingTy->getDependence()),
4402
210k
        UnderlyingTy(UnderlyingTy), MacroII(MacroII) {
4403
210k
    assert(isa<AttributedType>(UnderlyingTy) &&
4404
210k
           "Expected a macro qualified type to only wrap attributed types.");
4405
210k
  }
4406
4407
public:
4408
7.25k
  const IdentifierInfo *getMacroIdentifier() const { return MacroII; }
4409
1.81M
  QualType getUnderlyingType() const { return UnderlyingTy; }
4410
4411
  /// Return this attributed type's modified type with no qualifiers attached to
4412
  /// it.
4413
  QualType getModifiedType() const;
4414
4415
364k
  bool isSugared() const { return true; }
4416
  QualType desugar() const;
4417
4418
77.4M
  static bool classof(const Type *T) {
4419
77.4M
    return T->getTypeClass() == MacroQualified;
4420
77.4M
  }
4421
};
4422
4423
/// Represents a `typeof` (or __typeof__) expression (a GCC extension).
4424
class TypeOfExprType : public Type {
4425
  Expr *TOExpr;
4426
4427
protected:
4428
  friend class ASTContext; // ASTContext creates these.
4429
4430
  TypeOfExprType(Expr *E, QualType can = QualType());
4431
4432
public:
4433
19.1k
  Expr *getUnderlyingExpr() const { return TOExpr; }
4434
4435
  /// Remove a single level of sugar.
4436
  QualType desugar() const;
4437
4438
  /// Returns whether this type directly provides sugar.
4439
  bool isSugared() const;
4440
4441
112k
  static bool classof(const Type *T) { return T->getTypeClass() == TypeOfExpr; }
4442
};
4443
4444
/// Internal representation of canonical, dependent
4445
/// `typeof(expr)` types.
4446
///
4447
/// This class is used internally by the ASTContext to manage
4448
/// canonical, dependent types, only. Clients will only see instances
4449
/// of this class via TypeOfExprType nodes.
4450
class DependentTypeOfExprType
4451
  : public TypeOfExprType, public llvm::FoldingSetNode {
4452
  const ASTContext &Context;
4453
4454
public:
4455
  DependentTypeOfExprType(const ASTContext &Context, Expr *E)
4456
248
      : TypeOfExprType(E), Context(Context) {}
4457
4458
906
  void Profile(llvm::FoldingSetNodeID &ID) {
4459
906
    Profile(ID, Context, getUnderlyingExpr());
4460
906
  }
4461
4462
  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4463
                      Expr *E);
4464
};
4465
4466
/// Represents `typeof(type)`, a GCC extension.
4467
class TypeOfType : public Type {
4468
  friend class ASTContext; // ASTContext creates these.
4469
4470
  QualType TOType;
4471
4472
  TypeOfType(QualType T, QualType can)
4473
117
      : Type(TypeOf, can, T->getDependence()), TOType(T) {
4474
117
    assert(!isa<TypedefType>(can) && "Invalid canonical type");
4475
117
  }
4476
4477
public:
4478
618
  QualType getUnderlyingType() const { return TOType; }
4479
4480
  /// Remove a single level of sugar.
4481
573
  QualType desugar() const { return getUnderlyingType(); }
4482
4483
  /// Returns whether this type directly provides sugar.
4484
539
  bool isSugared() const { return true; }
4485
4486
1.27k
  static bool classof(const Type *T) { return T->getTypeClass() == TypeOf; }
4487
};
4488
4489
/// Represents the type `decltype(expr)` (C++11).
4490
class DecltypeType : public Type {
4491
  Expr *E;
4492
  QualType UnderlyingType;
4493
4494
protected:
4495
  friend class ASTContext; // ASTContext creates these.
4496
4497
  DecltypeType(Expr *E, QualType underlyingType, QualType can = QualType());
4498
4499
public:
4500
422k
  Expr *getUnderlyingExpr() const { return E; }
4501
178k
  QualType getUnderlyingType() const { return UnderlyingType; }
4502
4503
  /// Remove a single level of sugar.
4504
  QualType desugar() const;
4505
4506
  /// Returns whether this type directly provides sugar.
4507
  bool isSugared() const;
4508
4509
5.33M
  static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
4510
};
4511
4512
/// Internal representation of canonical, dependent
4513
/// decltype(expr) types.
4514
///
4515
/// This class is used internally by the ASTContext to manage
4516
/// canonical, dependent types, only. Clients will only see instances
4517
/// of this class via DecltypeType nodes.
4518
class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
4519
  const ASTContext &Context;
4520
4521
public:
4522
  DependentDecltypeType(const ASTContext &Context, Expr *E);
4523
4524
132k
  void Profile(llvm::FoldingSetNodeID &ID) {
4525
132k
    Profile(ID, Context, getUnderlyingExpr());
4526
132k
  }
4527
4528
  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
4529
                      Expr *E);
4530
};
4531
4532
/// A unary type transform, which is a type constructed from another.
4533
class UnaryTransformType : public Type {
4534
public:
4535
  enum UTTKind {
4536
    EnumUnderlyingType
4537
  };
4538
4539
private:
4540
  /// The untransformed type.
4541
  QualType BaseType;
4542
4543
  /// The transformed type if not dependent, otherwise the same as BaseType.
4544
  QualType UnderlyingType;
4545
4546
  UTTKind UKind;
4547
4548
protected:
4549
  friend class ASTContext;
4550
4551
  UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
4552
                     QualType CanonicalTy);
4553
4554
public:
4555
7.47k
  bool isSugared() const { return !isDependentType(); }
4556
7.90k
  QualType desugar() const { return UnderlyingType; }
4557
4558
824
  QualType getUnderlyingType() const { return UnderlyingType; }
4559
792
  QualType getBaseType() const { return BaseType; }
4560
4561
1.16k
  UTTKind getUTTKind() const { return UKind; }
4562
4563
28.1k
  static bool classof(const Type *T) {
4564
28.1k
    return T->getTypeClass() == UnaryTransform;
4565
28.1k
  }
4566
};
4567
4568
/// Internal representation of canonical, dependent
4569
/// __underlying_type(type) types.
4570
///
4571
/// This class is used internally by the ASTContext to manage
4572
/// canonical, dependent types, only. Clients will only see instances
4573
/// of this class via UnaryTransformType nodes.
4574
class DependentUnaryTransformType : public UnaryTransformType,
4575
                                    public llvm::FoldingSetNode {
4576
public:
4577
  DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
4578
                              UTTKind UKind);
4579
4580
6
  void Profile(llvm::FoldingSetNodeID &ID) {
4581
6
    Profile(ID, getBaseType(), getUTTKind());
4582
6
  }
4583
4584
  static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
4585
481
                      UTTKind UKind) {
4586
481
    ID.AddPointer(BaseType.getAsOpaquePtr());
4587
481
    ID.AddInteger((unsigned)UKind);
4588
481
  }
4589
};
4590
4591
class TagType : public Type {
4592
  friend class ASTReader;
4593
  template <class T> friend class serialization::AbstractTypeReader;
4594
4595
  /// Stores the TagDecl associated with this type. The decl may point to any
4596
  /// TagDecl that declares the entity.
4597
  TagDecl *decl;
4598
4599
protected:
4600
  TagType(TypeClass TC, const TagDecl *D, QualType can);
4601
4602
public:
4603
  TagDecl *getDecl() const;
4604
4605
  /// Determines whether this type is in the process of being defined.
4606
  bool isBeingDefined() const;
4607
4608
1.05G
  static bool classof(const Type *T) {
4609
1.05G
    return T->getTypeClass() == Enum || 
T->getTypeClass() == Record1.02G
;
4610
1.05G
  }
4611
};
4612
4613
/// A helper class that allows the use of isa/cast/dyncast
4614
/// to detect TagType objects of structs/unions/classes.
4615
class RecordType : public TagType {
4616
protected:
4617
  friend class ASTContext; // ASTContext creates these.
4618
4619
  explicit RecordType(const RecordDecl *D)
4620
3.57M
      : TagType(Record, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4621
  explicit RecordType(TypeClass TC, RecordDecl *D)
4622
0
      : TagType(TC, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4623
4624
public:
4625
58.1M
  RecordDecl *getDecl() const {
4626
58.1M
    return reinterpret_cast<RecordDecl*>(TagType::getDecl());
4627
58.1M
  }
4628
4629
  /// Recursively check all fields in the record for const-ness. If any field
4630
  /// is declared const, return true. Otherwise, return false.
4631
  bool hasConstFields() const;
4632
4633
28.7M
  bool isSugared() const { return false; }
4634
0
  QualType desugar() const { return QualType(this, 0); }
4635
4636
364M
  static bool classof(const Type *T) { return T->getTypeClass() == Record; }
4637
};
4638
4639
/// A helper class that allows the use of isa/cast/dyncast
4640
/// to detect TagType objects of enums.
4641
class EnumType : public TagType {
4642
  friend class ASTContext; // ASTContext creates these.
4643
4644
  explicit EnumType(const EnumDecl *D)
4645
473k
      : TagType(Enum, reinterpret_cast<const TagDecl*>(D), QualType()) {}
4646
4647
public:
4648
53.2M
  EnumDecl *getDecl() const {
4649
53.2M
    return reinterpret_cast<EnumDecl*>(TagType::getDecl());
4650
53.2M
  }
4651
4652
3.49M
  bool isSugared() const { return false; }
4653
0
  QualType desugar() const { return QualType(this, 0); }
4654
4655
219M
  static bool classof(const Type *T) { return T->getTypeClass() == Enum; }
4656
};
4657
4658
/// An attributed type is a type to which a type attribute has been applied.
4659
///
4660
/// The "modified type" is the fully-sugared type to which the attributed
4661
/// type was applied; generally it is not canonically equivalent to the
4662
/// attributed type. The "equivalent type" is the minimally-desugared type
4663
/// which the type is canonically equivalent to.
4664
///
4665
/// For example, in the following attributed type:
4666
///     int32_t __attribute__((vector_size(16)))
4667
///   - the modified type is the TypedefType for int32_t
4668
///   - the equivalent type is VectorType(16, int32_t)
4669
///   - the canonical type is VectorType(16, int)
4670
class AttributedType : public Type, public llvm::FoldingSetNode {
4671
public:
4672
  using Kind = attr::Kind;
4673
4674
private:
4675
  friend class ASTContext; // ASTContext creates these
4676
4677
  QualType ModifiedType;
4678
  QualType EquivalentType;
4679
4680
  AttributedType(QualType canon, attr::Kind attrKind, QualType modified,
4681
                 QualType equivalent)
4682
      : Type(Attributed, canon, equivalent->getDependence()),
4683
392k
        ModifiedType(modified), EquivalentType(equivalent) {
4684
392k
    AttributedTypeBits.AttrKind = attrKind;
4685
392k
  }
4686
4687
public:
4688
7.04M
  Kind getAttrKind() const {
4689
7.04M
    return static_cast<Kind>(AttributedTypeBits.AttrKind);
4690
7.04M
  }
4691
4692
17.5M
  QualType getModifiedType() const { return ModifiedType; }
4693
2.70M
  QualType getEquivalentType() const { return EquivalentType; }
4694
4695
2.55M
  bool isSugared() const { return true; }
4696
2.55M
  QualType desugar() const { return getEquivalentType(); }
4697
4698
  /// Does this attribute behave like a type qualifier?
4699
  ///
4700
  /// A type qualifier adjusts a type to provide specialized rules for
4701
  /// a specific object, like the standard const and volatile qualifiers.
4702
  /// This includes attributes controlling things like nullability,
4703
  /// address spaces, and ARC ownership.  The value of the object is still
4704
  /// largely described by the modified type.
4705
  ///
4706
  /// In contrast, many type attributes "rewrite" their modified type to
4707
  /// produce a fundamentally different type, not necessarily related in any
4708
  /// formalizable way to the original type.  For example, calling convention
4709
  /// and vector attributes are not simple type qualifiers.
4710
  ///
4711
  /// Type qualifiers are often, but not always, reflected in the canonical
4712
  /// type.
4713
  bool isQualifier() const;
4714
4715
  bool isMSTypeSpec() const;
4716
4717
  bool isCallingConv() const;
4718
4719
  llvm::Optional<NullabilityKind> getImmediateNullability() const;
4720
4721
  /// Retrieve the attribute kind corresponding to the given
4722
  /// nullability kind.
4723
16.9k
  static Kind getNullabilityAttrKind(NullabilityKind kind) {
4724
16.9k
    switch (kind) {
4725
9.17k
    case NullabilityKind::NonNull:
4726
9.17k
      return attr::TypeNonNull;
4727
4728
7.78k
    case NullabilityKind::Nullable:
4729
7.78k
      return attr::TypeNullable;
4730
4731
0
    case NullabilityKind::NullableResult:
4732
0
      return attr::TypeNullableResult;
4733
4734
7
    case NullabilityKind::Unspecified:
4735
7
      return attr::TypeNullUnspecified;
4736
16.9k
    }
4737
16.9k
    
llvm_unreachable0
("Unknown nullability kind.");
4738
16.9k
  }
4739
4740
  /// Strip off the top-level nullability annotation on the given
4741
  /// type, if it's there.
4742
  ///
4743
  /// \param T The type to strip. If the type is exactly an
4744
  /// AttributedType specifying nullability (without looking through
4745
  /// type sugar), the nullability is returned and this type changed
4746
  /// to the underlying modified type.
4747
  ///
4748
  /// \returns the top-level nullability, if present.
4749
  static Optional<NullabilityKind> stripOuterNullability(QualType &T);
4750
4751
5.18M
  void Profile(llvm::FoldingSetNodeID &ID) {
4752
5.18M
    Profile(ID, getAttrKind(), ModifiedType, EquivalentType);
4753
5.18M
  }
4754
4755
  static void Profile(llvm::FoldingSetNodeID &ID, Kind attrKind,
4756
8.41M
                      QualType modified, QualType equivalent) {
4757
8.41M
    ID.AddInteger(attrKind);
4758
8.41M
    ID.AddPointer(modified.getAsOpaquePtr());
4759
8.41M
    ID.AddPointer(equivalent.getAsOpaquePtr());
4760
8.41M
  }
4761
4762
337M
  static bool classof(const Type *T) {
4763
337M
    return T->getTypeClass() == Attributed;
4764
337M
  }
4765
};
4766
4767
class TemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4768
  friend class ASTContext; // ASTContext creates these
4769
4770
  // Helper data collector for canonical types.
4771
  struct CanonicalTTPTInfo {
4772
    unsigned Depth : 15;
4773
    unsigned ParameterPack : 1;
4774
    unsigned Index : 16;
4775
  };
4776
4777
  union {
4778
    // Info for the canonical type.
4779
    CanonicalTTPTInfo CanTTPTInfo;
4780
4781
    // Info for the non-canonical type.
4782
    TemplateTypeParmDecl *TTPDecl;
4783
  };
4784
4785
  /// Build a non-canonical type.
4786
  TemplateTypeParmType(TemplateTypeParmDecl *TTPDecl, QualType Canon)
4787
      : Type(TemplateTypeParm, Canon,
4788
             TypeDependence::DependentInstantiation |
4789
                 (Canon->getDependence() & TypeDependence::UnexpandedPack)),
4790
3.86M
        TTPDecl(TTPDecl) {}
4791
4792
  /// Build the canonical type.
4793
  TemplateTypeParmType(unsigned D, unsigned I, bool PP)
4794
      : Type(TemplateTypeParm, QualType(this, 0),
4795
             TypeDependence::DependentInstantiation |
4796
53.8k
                 (PP ? TypeDependence::UnexpandedPack : TypeDependence::None)) {
4797
53.8k
    CanTTPTInfo.Depth = D;
4798
53.8k
    CanTTPTInfo.Index = I;
4799
53.8k
    CanTTPTInfo.ParameterPack = PP;
4800
53.8k
  }
4801
4802
167M
  const CanonicalTTPTInfo& getCanTTPTInfo() const {
4803
167M
    QualType Can = getCanonicalTypeInternal();
4804
167M
    return Can->castAs<TemplateTypeParmType>()->CanTTPTInfo;
4805
167M
  }
4806
4807
public:
4808
53.4M
  unsigned getDepth() const { return getCanTTPTInfo().Depth; }
4809
43.7M
  unsigned getIndex() const { return getCanTTPTInfo().Index; }
4810
69.8M
  bool isParameterPack() const { return getCanTTPTInfo().ParameterPack; }
4811
4812
27.2M
  TemplateTypeParmDecl *getDecl() const {
4813
27.2M
    return isCanonicalUnqualified() ? 
nullptr4.09M
:
TTPDecl23.1M
;
4814
27.2M
  }
4815
4816
  IdentifierInfo *getIdentifier() const;
4817
4818
1.19M
  bool isSugared() const { return false; }
4819
0
  QualType desugar() const { return QualType(this, 0); }
4820
4821
24.3M
  void Profile(llvm::FoldingSetNodeID &ID) {
4822
24.3M
    Profile(ID, getDepth(), getIndex(), isParameterPack(), getDecl());
4823
24.3M
  }
4824
4825
  static void Profile(llvm::FoldingSetNodeID &ID, unsigned Depth,
4826
                      unsigned Index, bool ParameterPack,
4827
33.6M
                      TemplateTypeParmDecl *TTPDecl) {
4828
33.6M
    ID.AddInteger(Depth);
4829
33.6M
    ID.AddInteger(Index);
4830
33.6M
    ID.AddBoolean(ParameterPack);
4831
33.6M
    ID.AddPointer(TTPDecl);
4832
33.6M
  }
4833
4834
359M
  static bool classof(const Type *T) {
4835
359M
    return T->getTypeClass() == TemplateTypeParm;
4836
359M
  }
4837
};
4838
4839
/// Represents the result of substituting a type for a template
4840
/// type parameter.
4841
///
4842
/// Within an instantiated template, all template type parameters have
4843
/// been replaced with these.  They are used solely to record that a
4844
/// type was originally written as a template type parameter;
4845
/// therefore they are never canonical.
4846
class SubstTemplateTypeParmType : public Type, public llvm::FoldingSetNode {
4847
  friend class ASTContext;
4848
4849
  // The original type parameter.
4850
  const TemplateTypeParmType *Replaced;
4851
4852
  SubstTemplateTypeParmType(const TemplateTypeParmType *Param, QualType Canon)
4853
      : Type(SubstTemplateTypeParm, Canon, Canon->getDependence()),
4854
1.71M
        Replaced(Param) {}
4855
4856
public:
4857
  /// Gets the template parameter that was substituted for.
4858
8.42M
  const TemplateTypeParmType *getReplacedParameter() const {
4859
8.42M
    return Replaced;
4860
8.42M
  }
4861
4862
  /// Gets the type that was substituted for the template
4863
  /// parameter.
4864
12.9M
  QualType getReplacementType() const {
4865
12.9M
    return getCanonicalTypeInternal();
4866
12.9M
  }
4867
4868
4.15M
  bool isSugared() const { return true; }
4869
4.16M
  QualType desugar() const { return getReplacementType(); }
4870
4871
8.31M
  void Profile(llvm::FoldingSetNodeID &ID) {
4872
8.31M
    Profile(ID, getReplacedParameter(), getReplacementType());
4873
8.31M
  }
4874
4875
  static void Profile(llvm::FoldingSetNodeID &ID,
4876
                      const TemplateTypeParmType *Replaced,
4877
13.1M
                      QualType Replacement) {
4878
13.1M
    ID.AddPointer(Replaced);
4879
13.1M
    ID.AddPointer(Replacement.getAsOpaquePtr());
4880
13.1M
  }
4881
4882
78.7M
  static bool classof(const Type *T) {
4883
78.7M
    return T->getTypeClass() == SubstTemplateTypeParm;
4884
78.7M
  }
4885
};
4886
4887
/// Represents the result of substituting a set of types for a template
4888
/// type parameter pack.
4889
///
4890
/// When a pack expansion in the source code contains multiple parameter packs
4891
/// and those parameter packs correspond to different levels of template
4892
/// parameter lists, this type node is used to represent a template type
4893
/// parameter pack from an outer level, which has already had its argument pack
4894
/// substituted but that still lives within a pack expansion that itself
4895
/// could not be instantiated. When actually performing a substitution into
4896
/// that pack expansion (e.g., when all template parameters have corresponding
4897
/// arguments), this type will be replaced with the \c SubstTemplateTypeParmType
4898
/// at the current pack substitution index.
4899
class SubstTemplateTypeParmPackType : public Type, public llvm::FoldingSetNode {
4900
  friend class ASTContext;
4901
4902
  /// The original type parameter.
4903
  const TemplateTypeParmType *Replaced;
4904
4905
  /// A pointer to the set of template arguments that this
4906
  /// parameter pack is instantiated with.
4907
  const TemplateArgument *Arguments;
4908
4909
  SubstTemplateTypeParmPackType(const TemplateTypeParmType *Param,
4910
                                QualType Canon,
4911
                                const TemplateArgument &ArgPack);
4912
4913
public:
4914
0
  IdentifierInfo *getIdentifier() const { return Replaced->getIdentifier(); }
4915
4916
  /// Gets the template parameter that was substituted for.
4917
53.1k
  const TemplateTypeParmType *getReplacedParameter() const {
4918
53.1k
    return Replaced;
4919
53.1k
  }
4920
4921
93.3k
  unsigned getNumArgs() const {
4922
93.3k
    return SubstTemplateTypeParmPackTypeBits.NumArgs;
4923
93.3k
  }
4924
4925
14
  bool isSugared() const { return false; }
4926
0
  QualType desugar() const { return QualType(this, 0); }
4927
4928
  TemplateArgument getArgumentPack() const;
4929
4930
  void Profile(llvm::FoldingSetNodeID &ID);
4931
  static void Profile(llvm::FoldingSetNodeID &ID,
4932
                      const TemplateTypeParmType *Replaced,
4933
                      const TemplateArgument &ArgPack);
4934
4935
2.33M
  static bool classof(const Type *T) {
4936
2.33M
    return T->getTypeClass() == SubstTemplateTypeParmPack;
4937
2.33M
  }
4938
};
4939
4940
/// Common base class for placeholders for types that get replaced by
4941
/// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
4942
/// class template types, and constrained type names.
4943
///
4944
/// These types are usually a placeholder for a deduced type. However, before
4945
/// the initializer is attached, or (usually) if the initializer is
4946
/// type-dependent, there is no deduced type and the type is canonical. In
4947
/// the latter case, it is also a dependent type.
4948
class DeducedType : public Type {
4949
protected:
4950
  DeducedType(TypeClass TC, QualType DeducedAsType,
4951
              TypeDependence ExtraDependence)
4952
      : Type(TC,
4953
             // FIXME: Retain the sugared deduced type?
4954
             DeducedAsType.isNull() ? QualType(this, 0)
4955
                                    : DeducedAsType.getCanonicalType(),
4956
             ExtraDependence | (DeducedAsType.isNull()
4957
                                    ? TypeDependence::None
4958
                                    : DeducedAsType->getDependence() &
4959
15.6k
                                          ~TypeDependence::VariablyModified)) {}
4960
4961
public:
4962
190k
  bool isSugared() const { return !isCanonicalUnqualified(); }
4963
186k
  QualType desugar() const { return getCanonicalTypeInternal(); }
4964
4965
  /// Get the type deduced for this placeholder type, or null if it's
4966
  /// either not been deduced or was deduced to a dependent type.
4967
79.8k
  QualType getDeducedType() const {
4968
79.8k
    return !isCanonicalUnqualified() ? 
getCanonicalTypeInternal()47.9k
:
QualType()31.9k
;
4969
79.8k
  }
4970
108k
  bool isDeduced() const {
4971
108k
    return !isCanonicalUnqualified() || 
isDependentType()66.8k
;
4972
108k
  }
4973
4974
276M
  static bool classof(const Type *T) {
4975
276M
    return T->getTypeClass() == Auto ||
4976
276M
           
T->getTypeClass() == DeducedTemplateSpecialization275M
;
4977
276M
  }
4978
};
4979
4980
/// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
4981
/// by a type-constraint.
4982
class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
4983
  friend class ASTContext; // ASTContext creates these
4984
4985
  ConceptDecl *TypeConstraintConcept;
4986
4987
  AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
4988
           TypeDependence ExtraDependence, ConceptDecl *CD,
4989
           ArrayRef<TemplateArgument> TypeConstraintArgs);
4990
4991
92.3k
  const TemplateArgument *getArgBuffer() const {
4992
92.3k
    return reinterpret_cast<const TemplateArgument*>(this+1);
4993
92.3k
  }
4994
4995
76
  TemplateArgument *getArgBuffer() {
4996
76
    return reinterpret_cast<TemplateArgument*>(this+1);
4997
76
  }
4998
4999
public:
5000
  /// Retrieve the template arguments.
5001
92.3k
  const TemplateArgument *getArgs() const {
5002
92.3k
    return getArgBuffer();
5003
92.3k
  }
5004
5005
  /// Retrieve the number of template arguments.
5006
378k
  unsigned getNumArgs() const {
5007
378k
    return AutoTypeBits.NumArgs;
5008
378k
  }
5009
5010
  const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5011
5012
64.8k
  ArrayRef<TemplateArgument> getTypeConstraintArguments() const {
5013
64.8k
    return {getArgs(), getNumArgs()};
5014
64.8k
  }
5015
5016
64.8k
  ConceptDecl *getTypeConstraintConcept() const {
5017
64.8k
    return TypeConstraintConcept;
5018
64.8k
  }
5019
5020
128k
  bool isConstrained() const {
5021
128k
    return TypeConstraintConcept != nullptr;
5022
128k
  }
5023
5024
53.8k
  bool isDecltypeAuto() const {
5025
53.8k
    return getKeyword() == AutoTypeKeyword::DecltypeAuto;
5026
53.8k
  }
5027
5028
162k
  AutoTypeKeyword getKeyword() const {
5029
162k
    return (AutoTypeKeyword)AutoTypeBits.Keyword;
5030
162k
  }
5031
5032
31.8k
  void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) {
5033
31.8k
    Profile(ID, Context, getDeducedType(), getKeyword(), isDependentType(),
5034
31.8k
            getTypeConstraintConcept(), getTypeConstraintArguments());
5035
31.8k
  }
5036
5037
  static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
5038
                      QualType Deduced, AutoTypeKeyword Keyword,
5039
                      bool IsDependent, ConceptDecl *CD,
5040
                      ArrayRef<TemplateArgument> Arguments);
5041
5042
8.99M
  static bool classof(const Type *T) {
5043
8.99M
    return T->getTypeClass() == Auto;
5044
8.99M
  }
5045
};
5046
5047
/// Represents a C++17 deduced template specialization type.
5048
class DeducedTemplateSpecializationType : public DeducedType,
5049
                                          public llvm::FoldingSetNode {
5050
  friend class ASTContext; // ASTContext creates these
5051
5052
  /// The name of the template whose arguments will be deduced.
5053
  TemplateName Template;
5054
5055
  DeducedTemplateSpecializationType(TemplateName Template,
5056
                                    QualType DeducedAsType,
5057
                                    bool IsDeducedAsDependent)
5058
      : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
5059
                    toTypeDependence(Template.getDependence()) |
5060
                        (IsDeducedAsDependent
5061
                             ? TypeDependence::DependentInstantiation
5062
                             : TypeDependence::None)),
5063
885
        Template(Template) {}
5064
5065
public:
5066
  /// Retrieve the name of the template that we are deducing.
5067
3.44k
  TemplateName getTemplateName() const { return Template;}
5068
5069
1.80k
  void Profile(llvm::FoldingSetNodeID &ID) {
5070
1.80k
    Profile(ID, getTemplateName(), getDeducedType(), isDependentType());
5071
1.80k
  }
5072
5073
  static void Profile(llvm::FoldingSetNodeID &ID, TemplateName Template,
5074
3.60k
                      QualType Deduced, bool IsDependent) {
5075
3.60k
    Template.Profile(ID);
5076
3.60k
    ID.AddPointer(Deduced.getAsOpaquePtr());
5077
3.60k
    ID.AddBoolean(IsDependent);
5078
3.60k
  }
5079
5080
7.69M
  static bool classof(const Type *T) {
5081
7.69M
    return T->getTypeClass() == DeducedTemplateSpecialization;
5082
7.69M
  }
5083
};
5084
5085
/// Represents a type template specialization; the template
5086
/// must be a class template, a type alias template, or a template
5087
/// template parameter.  A template which cannot be resolved to one of
5088
/// these, e.g. because it is written with a dependent scope
5089
/// specifier, is instead represented as a
5090
/// @c DependentTemplateSpecializationType.
5091
///
5092
/// A non-dependent template specialization type is always "sugar",
5093
/// typically for a \c RecordType.  For example, a class template
5094
/// specialization type of \c vector<int> will refer to a tag type for
5095
/// the instantiation \c std::vector<int, std::allocator<int>>
5096
///
5097
/// Template specializations are dependent if either the template or
5098
/// any of the template arguments are dependent, in which case the
5099
/// type may also be canonical.
5100
///
5101
/// Instances of this type are allocated with a trailing array of
5102
/// TemplateArguments, followed by a QualType representing the
5103
/// non-canonical aliased type when the template is a type alias
5104
/// template.
5105
class alignas(8) TemplateSpecializationType
5106
    : public Type,
5107
      public llvm::FoldingSetNode {
5108
  friend class ASTContext; // ASTContext creates these
5109
5110
  /// The name of the template being specialized.  This is
5111
  /// either a TemplateName::Template (in which case it is a
5112
  /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
5113
  /// TypeAliasTemplateDecl*), a
5114
  /// TemplateName::SubstTemplateTemplateParmPack, or a
5115
  /// TemplateName::SubstTemplateTemplateParm (in which case the
5116
  /// replacement must, recursively, be one of these).
5117
  TemplateName Template;
5118
5119
  TemplateSpecializationType(TemplateName T,
5120
                             ArrayRef<TemplateArgument> Args,
5121
                             QualType Canon,
5122
                             QualType Aliased);
5123
5124
public:
5125
  /// Determine whether any of the given template arguments are dependent.
5126
  ///
5127
  /// The converted arguments should be supplied when known; whether an
5128
  /// argument is dependent can depend on the conversions performed on it
5129
  /// (for example, a 'const int' passed as a template argument might be
5130
  /// dependent if the parameter is a reference but non-dependent if the
5131
  /// parameter is an int).
5132
  ///
5133
  /// Note that the \p Args parameter is unused: this is intentional, to remind
5134
  /// the caller that they need to pass in the converted arguments, not the
5135
  /// specified arguments.
5136
  static bool
5137
  anyDependentTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
5138
                                ArrayRef<TemplateArgument> Converted);
5139
  static bool
5140
  anyDependentTemplateArguments(const TemplateArgumentListInfo &,
5141
                                ArrayRef<TemplateArgument> Converted);
5142
  static bool anyInstantiationDependentTemplateArguments(
5143
      ArrayRef<TemplateArgumentLoc> Args);
5144
5145
  /// True if this template specialization type matches a current
5146
  /// instantiation in the context in which it is found.
5147
874k
  bool isCurrentInstantiation() const {
5148
874k
    return isa<InjectedClassNameType>(getCanonicalTypeInternal());
5149
874k
  }
5150
5151
  /// Determine if this template specialization type is for a type alias
5152
  /// template that has been substituted.
5153
  ///
5154
  /// Nearly every template specialization type whose template is an alias
5155
  /// template will be substituted. However, this is not the case when
5156
  /// the specialization contains a pack expansion but the template alias
5157
  /// does not have a corresponding parameter pack, e.g.,
5158
  ///
5159
  /// \code
5160
  /// template<typename T, typename U, typename V> struct S;
5161
  /// template<typename T, typename U> using A = S<T, int, U>;
5162
  /// template<typename... Ts> struct X {
5163
  ///   typedef A<Ts...> type; // not a type alias
5164
  /// };
5165
  /// \endcode
5166
30.1M
  bool isTypeAlias() const { return TemplateSpecializationTypeBits.TypeAlias; }
5167
5168
  /// Get the aliased type, if this is a specialization of a type alias
5169
  /// template.
5170
536k
  QualType getAliasedType() const {
5171
536k
    assert(isTypeAlias() && "not a type alias template specialization");
5172
0
    return *reinterpret_cast<const QualType*>(end());
5173
536k
  }
5174
5175
  using iterator = const TemplateArgument *;
5176
5177
63
  iterator begin() const { return getArgs(); }
5178
  iterator end() const; // defined inline in TemplateBase.h
5179
5180
  /// Retrieve the name of the template that we are specializing.
5181
11.6M
  TemplateName getTemplateName() const { return Template; }
5182
5183
  /// Retrieve the template arguments.
5184
28.0M
  const TemplateArgument *getArgs() const {
5185
28.0M
    return reinterpret_cast<const TemplateArgument *>(this + 1);
5186
28.0M
  }
5187
5188
  /// Retrieve the number of template arguments.
5189
66.1M
  unsigned getNumArgs() const {
5190
66.1M
    return TemplateSpecializationTypeBits.NumArgs;
5191
66.1M
  }
5192
5193
  /// Retrieve a specific template argument as a type.
5194
  /// \pre \c isArgType(Arg)
5195
  const TemplateArgument &getArg(unsigned Idx) const; // in TemplateBase.h
5196
5197
10.3M
  ArrayRef<TemplateArgument> template_arguments() const {
5198
10.3M
    return {getArgs(), getNumArgs()};
5199
10.3M
  }
5200
5201
10.6M
  bool isSugared() const {
5202
10.6M
    return !isDependentType() || 
isCurrentInstantiation()874k
||
isTypeAlias()874k
;
5203
10.6M
  }
5204
5205
9.93M
  QualType desugar() const {
5206
9.93M
    return isTypeAlias() ? 
getAliasedType()506k
:
getCanonicalTypeInternal()9.43M
;
5207
9.93M
  }
5208
5209
7.84M
  void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx) {
5210
7.84M
    Profile(ID, Template, template_arguments(), Ctx);
5211
7.84M
    if (isTypeAlias())
5212
0
      getAliasedType().Profile(ID);
5213
7.84M
  }
5214
5215
  static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
5216
                      ArrayRef<TemplateArgument> Args,
5217
                      const ASTContext &Context);
5218
5219
316M
  static bool classof(const Type *T) {
5220
316M
    return T->getTypeClass() == TemplateSpecialization;
5221
316M
  }
5222
};
5223
5224
/// Print a template argument list, including the '<' and '>'
5225
/// enclosing the template arguments.
5226
void printTemplateArgumentList(raw_ostream &OS,
5227
                               ArrayRef<TemplateArgument> Args,
5228
                               const PrintingPolicy &Policy,
5229
                               const TemplateParameterList *TPL = nullptr);
5230
5231
void printTemplateArgumentList(raw_ostream &OS,
5232
                               ArrayRef<TemplateArgumentLoc> Args,
5233
                               const PrintingPolicy &Policy,
5234
                               const TemplateParameterList *TPL = nullptr);
5235
5236
void printTemplateArgumentList(raw_ostream &OS,
5237
                               const TemplateArgumentListInfo &Args,
5238
                               const PrintingPolicy &Policy,
5239
                               const TemplateParameterList *TPL = nullptr);
5240
5241
/// The injected class name of a C++ class template or class
5242
/// template partial specialization.  Used to record that a type was
5243
/// spelled with a bare identifier rather than as a template-id; the
5244
/// equivalent for non-templated classes is just RecordType.
5245
///
5246
/// Injected class name types are always dependent.  Template
5247
/// instantiation turns these into RecordTypes.
5248
///
5249
/// Injected class name types are always canonical.  This works
5250
/// because it is impossible to compare an injected class name type
5251
/// with the corresponding non-injected template type, for the same
5252
/// reason that it is impossible to directly compare template
5253
/// parameters from different dependent contexts: injected class name
5254
/// types can only occur within the scope of a particular templated
5255
/// declaration, and within that scope every template specialization
5256
/// will canonicalize to the injected class name (when appropriate
5257
/// according to the rules of the language).
5258
class InjectedClassNameType : public Type {
5259
  friend class ASTContext; // ASTContext creates these.
5260
  friend class ASTNodeImporter;
5261
  friend class ASTReader; // FIXME: ASTContext::getInjectedClassNameType is not
5262
                          // currently suitable for AST reading, too much
5263
                          // interdependencies.
5264
  template <class T> friend class serialization::AbstractTypeReader;
5265
5266
  CXXRecordDecl *Decl;
5267
5268
  /// The template specialization which this type represents.
5269
  /// For example, in
5270
  ///   template <class T> class A { ... };
5271
  /// this is A<T>, whereas in
5272
  ///   template <class X, class Y> class A<B<X,Y> > { ... };
5273
  /// this is A<B<X,Y> >.
5274
  ///
5275
  /// It is always unqualified, always a template specialization type,
5276
  /// and always dependent.
5277
  QualType InjectedType;
5278
5279
  InjectedClassNameType(CXXRecordDecl *D, QualType TST)
5280
      : Type(InjectedClassName, QualType(),
5281
             TypeDependence::DependentInstantiation),
5282
603k
        Decl(D), InjectedType(TST) {
5283
603k
    assert(isa<TemplateSpecializationType>(TST));
5284
0
    assert(!TST.hasQualifiers());
5285
0
    assert(TST->isDependentType());
5286
603k
  }
5287
5288
public:
5289
1.81M
  QualType getInjectedSpecializationType() const { return InjectedType; }
5290
5291
125k
  const TemplateSpecializationType *getInjectedTST() const {
5292
125k
    return cast<TemplateSpecializationType>(InjectedType.getTypePtr());
5293
125k
  }
5294
5295
1
  TemplateName getTemplateName() const {
5296
1
    return getInjectedTST()->getTemplateName();
5297
1
  }
5298
5299
  CXXRecordDecl *getDecl() const;
5300
5301
395k
  bool isSugared() const { return false; }
5302
0
  QualType desugar() const { return QualType(this, 0); }
5303
5304
339M
  static bool classof(const Type *T) {
5305
339M
    return T->getTypeClass() == InjectedClassName;
5306
339M
  }
5307
};
5308
5309
/// The kind of a tag type.
5310
enum TagTypeKind {
5311
  /// The "struct" keyword.
5312
  TTK_Struct,
5313
5314
  /// The "__interface" keyword.
5315
  TTK_Interface,
5316
5317
  /// The "union" keyword.
5318
  TTK_Union,
5319
5320
  /// The "class" keyword.
5321
  TTK_Class,
5322
5323
  /// The "enum" keyword.
5324
  TTK_Enum
5325
};
5326
5327
/// The elaboration keyword that precedes a qualified type name or
5328
/// introduces an elaborated-type-specifier.
5329
enum ElaboratedTypeKeyword {
5330
  /// The "struct" keyword introduces the elaborated-type-specifier.
5331
  ETK_Struct,
5332
5333
  /// The "__interface" keyword introduces the elaborated-type-specifier.
5334
  ETK_Interface,
5335
5336
  /// The "union" keyword introduces the elaborated-type-specifier.
5337
  ETK_Union,
5338
5339
  /// The "class" keyword introduces the elaborated-type-specifier.
5340
  ETK_Class,
5341
5342
  /// The "enum" keyword introduces the elaborated-type-specifier.
5343
  ETK_Enum,
5344
5345
  /// The "typename" keyword precedes the qualified type name, e.g.,
5346
  /// \c typename T::type.
5347
  ETK_Typename,
5348
5349
  /// No keyword precedes the qualified type name.
5350
  ETK_None
5351
};
5352
5353
/// A helper class for Type nodes having an ElaboratedTypeKeyword.
5354
/// The keyword in stored in the free bits of the base class.
5355
/// Also provides a few static helpers for converting and printing
5356
/// elaborated type keyword and tag type kind enumerations.
5357
class TypeWithKeyword : public Type {
5358
protected:
5359
  TypeWithKeyword(ElaboratedTypeKeyword Keyword, TypeClass tc,
5360
                  QualType Canonical, TypeDependence Dependence)
5361
3.48M
      : Type(tc, Canonical, Dependence) {
5362
3.48M
    TypeWithKeywordBits.Keyword = Keyword;
5363
3.48M
  }
5364
5365
public:
5366
14.8M
  ElaboratedTypeKeyword getKeyword() const {
5367
14.8M
    return static_cast<ElaboratedTypeKeyword>(TypeWithKeywordBits.Keyword);
5368
14.8M
  }
5369
5370
  /// Converts a type specifier (DeclSpec::TST) into an elaborated type keyword.
5371
  static ElaboratedTypeKeyword getKeywordForTypeSpec(unsigned TypeSpec);
5372
5373
  /// Converts a type specifier (DeclSpec::TST) into a tag type kind.
5374
  /// It is an error to provide a type specifier which *isn't* a tag kind here.
5375
  static TagTypeKind getTagTypeKindForTypeSpec(unsigned TypeSpec);
5376
5377
  /// Converts a TagTypeKind into an elaborated type keyword.
5378
  static ElaboratedTypeKeyword getKeywordForTagTypeKind(TagTypeKind Tag);
5379
5380
  /// Converts an elaborated type keyword into a TagTypeKind.
5381
  /// It is an error to provide an elaborated type keyword
5382
  /// which *isn't* a tag kind here.