Coverage Report

Created: 2022-01-25 06:29

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