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