1 | //===- Type.h - C Language Family Type Representation -----------*- C++ -*-===// |
---|---|

2 | // |

3 | // The LLVM Compiler Infrastructure |

4 | // |

5 | // This file is distributed under the University of Illinois Open Source |

6 | // License. See LICENSE.TXT for details. |

7 | // |

8 | //===----------------------------------------------------------------------===// |

9 | // |

10 | /// \file |

11 | /// C Language Family Type Representation |

12 | /// |

13 | /// This file defines the clang::Type interface and subclasses, used to |

14 | /// represent types for languages in the C family. |

15 | // |

16 | //===----------------------------------------------------------------------===// |

17 | |

18 | #ifndef LLVM_CLANG_AST_TYPE_H |

19 | #define LLVM_CLANG_AST_TYPE_H |

20 | |

21 | #include "clang/AST/NestedNameSpecifier.h" |

22 | #include "clang/AST/TemplateName.h" |

23 | #include "clang/Basic/AddressSpaces.h" |

24 | #include "clang/Basic/AttrKinds.h" |

25 | #include "clang/Basic/Diagnostic.h" |

26 | #include "clang/Basic/ExceptionSpecificationType.h" |

27 | #include "clang/Basic/LLVM.h" |

28 | #include "clang/Basic/Linkage.h" |

29 | #include "clang/Basic/PartialDiagnostic.h" |

30 | #include "clang/Basic/SourceLocation.h" |

31 | #include "clang/Basic/Specifiers.h" |

32 | #include "clang/Basic/Visibility.h" |

33 | #include "llvm/ADT/APInt.h" |

34 | #include "llvm/ADT/APSInt.h" |

35 | #include "llvm/ADT/ArrayRef.h" |

36 | #include "llvm/ADT/FoldingSet.h" |

37 | #include "llvm/ADT/None.h" |

38 | #include "llvm/ADT/Optional.h" |

39 | #include "llvm/ADT/PointerIntPair.h" |

40 | #include "llvm/ADT/PointerUnion.h" |

41 | #include "llvm/ADT/StringRef.h" |

42 | #include "llvm/ADT/Twine.h" |

43 | #include "llvm/ADT/iterator_range.h" |

44 | #include "llvm/Support/Casting.h" |

45 | #include "llvm/Support/Compiler.h" |

46 | #include "llvm/Support/ErrorHandling.h" |

47 | #include "llvm/Support/PointerLikeTypeTraits.h" |

48 | #include "llvm/Support/type_traits.h" |

49 | #include "llvm/Support/TrailingObjects.h" |

50 | #include <cassert> |

51 | #include <cstddef> |

52 | #include <cstdint> |

53 | #include <cstring> |

54 | #include <string> |

55 | #include <type_traits> |

56 | #include <utility> |

57 | |

58 | namespace clang { |

59 | |

60 | class ExtQuals; |

61 | class QualType; |

62 | class TagDecl; |

63 | class Type; |

64 | |

65 | enum { |

66 | TypeAlignmentInBits = 4, |

67 | TypeAlignment = 1 << TypeAlignmentInBits |

68 | }; |

69 | |

70 | } // namespace clang |

71 | |

72 | namespace llvm { |

73 | |

74 | template <typename T> |

75 | struct PointerLikeTypeTraits; |

76 | template<> |

77 | struct PointerLikeTypeTraits< ::clang::Type*> { |

78 | static inline void *getAsVoidPointer(::clang::Type *P) { return P; } |

79 | |

80 | static inline ::clang::Type *getFromVoidPointer(void *P) { |

81 | return static_cast< ::clang::Type*>(P); |

82 | } |

83 | |

84 | enum { NumLowBitsAvailable = clang::TypeAlignmentInBits }; |

85 | }; |

86 | |

87 | template<> |

88 | struct PointerLikeTypeTraits< ::clang::ExtQuals*> { |

89 | static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; } |

90 | |

91 | static inline ::clang::ExtQuals *getFromVoidPointer(void *P) { |

92 | return static_cast< ::clang::ExtQuals*>(P); |

93 | } |

94 | |

95 | enum { NumLowBitsAvailable = clang::TypeAlignmentInBits }; |

96 | }; |

97 | |

98 | template <> |

99 | struct isPodLike<clang::QualType> { static const bool value = true; }; |

100 | |

101 | } // namespace llvm |

102 | |

103 | namespace clang { |

104 | |

105 | class ASTContext; |

106 | template <typename> class CanQual; |

107 | class CXXRecordDecl; |

108 | class DeclContext; |

109 | class EnumDecl; |

110 | class Expr; |

111 | class ExtQualsTypeCommonBase; |

112 | class FunctionDecl; |

113 | class IdentifierInfo; |

114 | class NamedDecl; |

115 | class ObjCInterfaceDecl; |

116 | class ObjCProtocolDecl; |

117 | class ObjCTypeParamDecl; |

118 | struct PrintingPolicy; |

119 | class RecordDecl; |

120 | class Stmt; |

121 | class TagDecl; |

122 | class TemplateArgument; |

123 | class TemplateArgumentListInfo; |

124 | class TemplateArgumentLoc; |

125 | class TemplateTypeParmDecl; |

126 | class TypedefNameDecl; |

127 | class UnresolvedUsingTypenameDecl; |

128 | |

129 | using CanQualType = CanQual<Type>; |

130 | |

131 | // Provide forward declarations for all of the *Type classes. |

132 | #define TYPE(Class, Base) class Class##Type; |

133 | #include "clang/AST/TypeNodes.def" |

134 | |

135 | /// The collection of all-type qualifiers we support. |

136 | /// Clang supports five independent qualifiers: |

137 | /// * C99: const, volatile, and restrict |

138 | /// * MS: __unaligned |

139 | /// * Embedded C (TR18037): address spaces |

140 | /// * Objective C: the GC attributes (none, weak, or strong) |

141 | class Qualifiers { |

142 | public: |

143 | enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ. |

144 | Const = 0x1, |

145 | Restrict = 0x2, |

146 | Volatile = 0x4, |

147 | CVRMask = Const | Volatile | Restrict |

148 | }; |

149 | |

150 | enum GC { |

151 | GCNone = 0, |

152 | Weak, |

153 | Strong |

154 | }; |

155 | |

156 | enum ObjCLifetime { |

157 | /// There is no lifetime qualification on this type. |

158 | OCL_None, |

159 | |

160 | /// This object can be modified without requiring retains or |

161 | /// releases. |

162 | OCL_ExplicitNone, |

163 | |

164 | /// Assigning into this object requires the old value to be |

165 | /// released and the new value to be retained. The timing of the |

166 | /// release of the old value is inexact: it may be moved to |

167 | /// immediately after the last known point where the value is |

168 | /// live. |

169 | OCL_Strong, |

170 | |

171 | /// Reading or writing from this object requires a barrier call. |

172 | OCL_Weak, |

173 | |

174 | /// Assigning into this object requires a lifetime extension. |

175 | OCL_Autoreleasing |

176 | }; |

177 | |

178 | enum { |

179 | /// The maximum supported address space number. |

180 | /// 23 bits should be enough for anyone. |

181 | MaxAddressSpace = 0x7fffffu, |

182 | |

183 | /// The width of the "fast" qualifier mask. |

184 | FastWidth = 3, |

185 | |

186 | /// The fast qualifier mask. |

187 | FastMask = (1 << FastWidth) - 1 |

188 | }; |

189 | |

190 | /// Returns the common set of qualifiers while removing them from |

191 | /// the given sets. |

192 | static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) { |

193 | // If both are only CVR-qualified, bit operations are sufficient. |

194 | if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) { |

195 | Qualifiers Q; |

196 | Q.Mask = L.Mask & R.Mask; |

197 | L.Mask &= ~Q.Mask; |

198 | R.Mask &= ~Q.Mask; |

199 | return Q; |

200 | } |

201 | |

202 | Qualifiers Q; |

203 | unsigned CommonCRV = L.getCVRQualifiers() & R.getCVRQualifiers(); |

204 | Q.addCVRQualifiers(CommonCRV); |

205 | L.removeCVRQualifiers(CommonCRV); |

206 | R.removeCVRQualifiers(CommonCRV); |

207 | |

208 | if (L.getObjCGCAttr() == R.getObjCGCAttr()) { |

209 | Q.setObjCGCAttr(L.getObjCGCAttr()); |

210 | L.removeObjCGCAttr(); |

211 | R.removeObjCGCAttr(); |

212 | } |

213 | |

214 | if (L.getObjCLifetime() == R.getObjCLifetime()) { |

215 | Q.setObjCLifetime(L.getObjCLifetime()); |

216 | L.removeObjCLifetime(); |

217 | R.removeObjCLifetime(); |

218 | } |

219 | |

220 | if (L.getAddressSpace() == R.getAddressSpace()) { |

221 | Q.setAddressSpace(L.getAddressSpace()); |

222 | L.removeAddressSpace(); |

223 | R.removeAddressSpace(); |

224 | } |

225 | return Q; |

226 | } |

227 | |

228 | static Qualifiers fromFastMask(unsigned Mask) { |

229 | Qualifiers Qs; |

230 | Qs.addFastQualifiers(Mask); |

231 | return Qs; |

232 | } |

233 | |

234 | static Qualifiers fromCVRMask(unsigned CVR) { |

235 | Qualifiers Qs; |

236 | Qs.addCVRQualifiers(CVR); |

237 | return Qs; |

238 | } |

239 | |

240 | static Qualifiers fromCVRUMask(unsigned CVRU) { |

241 | Qualifiers Qs; |

242 | Qs.addCVRUQualifiers(CVRU); |

243 | return Qs; |

244 | } |

245 | |

246 | // Deserialize qualifiers from an opaque representation. |

247 | static Qualifiers fromOpaqueValue(unsigned opaque) { |

248 | Qualifiers Qs; |

249 | Qs.Mask = opaque; |

250 | return Qs; |

251 | } |

252 | |

253 | // Serialize these qualifiers into an opaque representation. |

254 | unsigned getAsOpaqueValue() const { |

255 | return Mask; |

256 | } |

257 | |

258 | bool hasConst() const { return Mask & Const; } |

259 | void setConst(bool flag) { |

260 | Mask = (Mask & ~Const) | (flag ? Const : 0); |

261 | } |

262 | void removeConst() { Mask &= ~Const; } |

263 | void addConst() { Mask |= Const; } |

264 | |

265 | bool hasVolatile() const { return Mask & Volatile; } |

266 | void setVolatile(bool flag) { |

267 | Mask = (Mask & ~Volatile) | (flag ? Volatile : 0); |

268 | } |

269 | void removeVolatile() { Mask &= ~Volatile; } |

270 | void addVolatile() { Mask |= Volatile; } |

271 | |

272 | bool hasRestrict() const { return Mask & Restrict; } |

273 | void setRestrict(bool flag) { |

274 | Mask = (Mask & ~Restrict) | (flag ? Restrict : 0); |

275 | } |

276 | void removeRestrict() { Mask &= ~Restrict; } |

277 | void addRestrict() { Mask |= Restrict; } |

278 | |

279 | bool hasCVRQualifiers() const { return getCVRQualifiers(); } |

280 | unsigned getCVRQualifiers() const { return Mask & CVRMask; } |

281 | void setCVRQualifiers(unsigned mask) { |

282 | assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits"); |

283 | Mask = (Mask & ~CVRMask) | mask; |

284 | } |

285 | void removeCVRQualifiers(unsigned mask) { |

286 | assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits"); |

287 | Mask &= ~mask; |

288 | } |

289 | void removeCVRQualifiers() { |

290 | removeCVRQualifiers(CVRMask); |

291 | } |

292 | void addCVRQualifiers(unsigned mask) { |

293 | assert(!(mask & ~CVRMask) && "bitmask contains non-CVR bits"); |

294 | Mask |= mask; |

295 | } |

296 | void addCVRUQualifiers(unsigned mask) { |

297 | assert(!(mask & ~CVRMask & ~UMask) && "bitmask contains non-CVRU bits"); |

298 | Mask |= mask; |

299 | } |

300 | |

301 | bool hasUnaligned() const { return Mask & UMask; } |

302 | void setUnaligned(bool flag) { |

303 | Mask = (Mask & ~UMask) | (flag ? UMask : 0); |

304 | } |

305 | void removeUnaligned() { Mask &= ~UMask; } |

306 | void addUnaligned() { Mask |= UMask; } |

307 | |

308 | bool hasObjCGCAttr() const { return Mask & GCAttrMask; } |

309 | GC getObjCGCAttr() const { return GC((Mask & GCAttrMask) >> GCAttrShift); } |

310 | void setObjCGCAttr(GC type) { |

311 | Mask = (Mask & ~GCAttrMask) | (type << GCAttrShift); |

312 | } |

313 | void removeObjCGCAttr() { setObjCGCAttr(GCNone); } |

314 | void addObjCGCAttr(GC type) { |

315 | assert(type); |

316 | setObjCGCAttr(type); |

317 | } |

318 | Qualifiers withoutObjCGCAttr() const { |

319 | Qualifiers qs = *this; |

320 | qs.removeObjCGCAttr(); |

321 | return qs; |

322 | } |

323 | Qualifiers withoutObjCLifetime() const { |

324 | Qualifiers qs = *this; |

325 | qs.removeObjCLifetime(); |

326 | return qs; |

327 | } |

328 | |

329 | bool hasObjCLifetime() const { return Mask & LifetimeMask; } |

330 | ObjCLifetime getObjCLifetime() const { |

331 | return ObjCLifetime((Mask & LifetimeMask) >> LifetimeShift); |

332 | } |

333 | void setObjCLifetime(ObjCLifetime type) { |

334 | Mask = (Mask & ~LifetimeMask) | (type << LifetimeShift); |

335 | } |

336 | void removeObjCLifetime() { setObjCLifetime(OCL_None); } |

337 | void addObjCLifetime(ObjCLifetime type) { |

338 | assert(type); |

339 | assert(!hasObjCLifetime()); |

340 | Mask |= (type << LifetimeShift); |

341 | } |

342 | |

343 | /// True if the lifetime is neither None or ExplicitNone. |

344 | bool hasNonTrivialObjCLifetime() const { |

345 | ObjCLifetime lifetime = getObjCLifetime(); |

346 | return (lifetime > OCL_ExplicitNone); |

347 | } |

348 | |

349 | /// True if the lifetime is either strong or weak. |

350 | bool hasStrongOrWeakObjCLifetime() const { |

351 | ObjCLifetime lifetime = getObjCLifetime(); |

352 | return (lifetime == OCL_Strong || lifetime == OCL_Weak); |

353 | } |

354 | |

355 | bool hasAddressSpace() const { return Mask & AddressSpaceMask; } |

356 | LangAS getAddressSpace() const { |

357 | return static_cast<LangAS>(Mask >> AddressSpaceShift); |

358 | } |

359 | bool hasTargetSpecificAddressSpace() const { |

360 | return isTargetAddressSpace(getAddressSpace()); |

361 | } |

362 | /// Get the address space attribute value to be printed by diagnostics. |

363 | unsigned getAddressSpaceAttributePrintValue() const { |

364 | auto Addr = getAddressSpace(); |

365 | // This function is not supposed to be used with language specific |

366 | // address spaces. If that happens, the diagnostic message should consider |

367 | // printing the QualType instead of the address space value. |

368 | assert(Addr == LangAS::Default || hasTargetSpecificAddressSpace()); |

369 | if (Addr != LangAS::Default) |

370 | return toTargetAddressSpace(Addr); |

371 | // TODO: The diagnostic messages where Addr may be 0 should be fixed |

372 | // since it cannot differentiate the situation where 0 denotes the default |

373 | // address space or user specified __attribute__((address_space(0))). |

374 | return 0; |

375 | } |

376 | void setAddressSpace(LangAS space) { |

377 | assert((unsigned)space <= MaxAddressSpace); |

378 | Mask = (Mask & ~AddressSpaceMask) |

379 | | (((uint32_t) space) << AddressSpaceShift); |

380 | } |

381 | void removeAddressSpace() { setAddressSpace(LangAS::Default); } |

382 | void addAddressSpace(LangAS space) { |

383 | assert(space != LangAS::Default); |

384 | setAddressSpace(space); |

385 | } |

386 | |

387 | // Fast qualifiers are those that can be allocated directly |

388 | // on a QualType object. |

389 | bool hasFastQualifiers() const { return getFastQualifiers(); } |

390 | unsigned getFastQualifiers() const { return Mask & FastMask; } |

391 | void setFastQualifiers(unsigned mask) { |

392 | assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"); |

393 | Mask = (Mask & ~FastMask) | mask; |

394 | } |

395 | void removeFastQualifiers(unsigned mask) { |

396 | assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"); |

397 | Mask &= ~mask; |

398 | } |

399 | void removeFastQualifiers() { |

400 | removeFastQualifiers(FastMask); |

401 | } |

402 | void addFastQualifiers(unsigned mask) { |

403 | assert(!(mask & ~FastMask) && "bitmask contains non-fast qualifier bits"); |

404 | Mask |= mask; |

405 | } |

406 | |

407 | /// Return true if the set contains any qualifiers which require an ExtQuals |

408 | /// node to be allocated. |

409 | bool hasNonFastQualifiers() const { return Mask & ~FastMask; } |

410 | Qualifiers getNonFastQualifiers() const { |

411 | Qualifiers Quals = *this; |

412 | Quals.setFastQualifiers(0); |

413 | return Quals; |

414 | } |

415 | |

416 | /// Return true if the set contains any qualifiers. |

417 | bool hasQualifiers() const { return Mask; } |

418 | bool empty() const { return !Mask; } |

419 | |

420 | /// Add the qualifiers from the given set to this set. |

421 | void addQualifiers(Qualifiers Q) { |

422 | // If the other set doesn't have any non-boolean qualifiers, just |

423 | // bit-or it in. |

424 | if (!(Q.Mask & ~CVRMask)) |

425 | Mask |= Q.Mask; |

426 | else { |

427 | Mask |= (Q.Mask & CVRMask); |

428 | if (Q.hasAddressSpace()) |

429 | addAddressSpace(Q.getAddressSpace()); |

430 | if (Q.hasObjCGCAttr()) |

431 | addObjCGCAttr(Q.getObjCGCAttr()); |

432 | if (Q.hasObjCLifetime()) |

433 | addObjCLifetime(Q.getObjCLifetime()); |

434 | } |

435 | } |

436 | |

437 | /// Remove the qualifiers from the given set from this set. |

438 | void removeQualifiers(Qualifiers Q) { |

439 | // If the other set doesn't have any non-boolean qualifiers, just |

440 | // bit-and the inverse in. |

441 | if (!(Q.Mask & ~CVRMask)) |

442 | Mask &= ~Q.Mask; |

443 | else { |

444 | Mask &= ~(Q.Mask & CVRMask); |

445 | if (getObjCGCAttr() == Q.getObjCGCAttr()) |

446 | removeObjCGCAttr(); |

447 | if (getObjCLifetime() == Q.getObjCLifetime()) |

448 | removeObjCLifetime(); |

449 | if (getAddressSpace() == Q.getAddressSpace()) |

450 | removeAddressSpace(); |

451 | } |

452 | } |

453 | |

454 | /// Add the qualifiers from the given set to this set, given that |

455 | /// they don't conflict. |

456 | void addConsistentQualifiers(Qualifiers qs) { |

457 | assert(getAddressSpace() == qs.getAddressSpace() || |

458 | !hasAddressSpace() || !qs.hasAddressSpace()); |

459 | assert(getObjCGCAttr() == qs.getObjCGCAttr() || |

460 | !hasObjCGCAttr() || !qs.hasObjCGCAttr()); |

461 | assert(getObjCLifetime() == qs.getObjCLifetime() || |

462 | !hasObjCLifetime() || !qs.hasObjCLifetime()); |

463 | Mask |= qs.Mask; |

464 | } |

465 | |

466 | /// Returns true if this address space is a superset of the other one. |

467 | /// OpenCL v2.0 defines conversion rules (OpenCLC v2.0 s6.5.5) and notion of |

468 | /// overlapping address spaces. |

469 | /// CL1.1 or CL1.2: |

470 | /// every address space is a superset of itself. |

471 | /// CL2.0 adds: |

472 | /// __generic is a superset of any address space except for __constant. |

473 | bool isAddressSpaceSupersetOf(Qualifiers other) const { |

474 | return |

475 | // Address spaces must match exactly. |

476 | getAddressSpace() == other.getAddressSpace() || |

477 | // Otherwise in OpenCLC v2.0 s6.5.5: every address space except |

478 | // for __constant can be used as __generic. |

479 | (getAddressSpace() == LangAS::opencl_generic && |

480 | other.getAddressSpace() != LangAS::opencl_constant); |

481 | } |

482 | |

483 | /// Determines if these qualifiers compatibly include another set. |

484 | /// Generally this answers the question of whether an object with the other |

485 | /// qualifiers can be safely used as an object with these qualifiers. |

486 | bool compatiblyIncludes(Qualifiers other) const { |

487 | return isAddressSpaceSupersetOf(other) && |

488 | // ObjC GC qualifiers can match, be added, or be removed, but can't |

489 | // be changed. |

490 | (getObjCGCAttr() == other.getObjCGCAttr() || !hasObjCGCAttr() || |

491 | !other.hasObjCGCAttr()) && |

492 | // ObjC lifetime qualifiers must match exactly. |

493 | getObjCLifetime() == other.getObjCLifetime() && |

494 | // CVR qualifiers may subset. |

495 | (((Mask & CVRMask) | (other.Mask & CVRMask)) == (Mask & CVRMask)) && |

496 | // U qualifier may superset. |

497 | (!other.hasUnaligned() || hasUnaligned()); |

498 | } |

499 | |

500 | /// Determines if these qualifiers compatibly include another set of |

501 | /// qualifiers from the narrow perspective of Objective-C ARC lifetime. |

502 | /// |

503 | /// One set of Objective-C lifetime qualifiers compatibly includes the other |

504 | /// if the lifetime qualifiers match, or if both are non-__weak and the |

505 | /// including set also contains the 'const' qualifier, or both are non-__weak |

506 | /// and one is None (which can only happen in non-ARC modes). |

507 | bool compatiblyIncludesObjCLifetime(Qualifiers other) const { |

508 | if (getObjCLifetime() == other.getObjCLifetime()) |

509 | return true; |

510 | |

511 | if (getObjCLifetime() == OCL_Weak || other.getObjCLifetime() == OCL_Weak) |

512 | return false; |

513 | |

514 | if (getObjCLifetime() == OCL_None || other.getObjCLifetime() == OCL_None) |

515 | return true; |

516 | |

517 | return hasConst(); |

518 | } |

519 | |

520 | /// Determine whether this set of qualifiers is a strict superset of |

521 | /// another set of qualifiers, not considering qualifier compatibility. |

522 | bool isStrictSupersetOf(Qualifiers Other) const; |

523 | |

524 | bool operator==(Qualifiers Other) const { return Mask == Other.Mask; } |

525 | bool operator!=(Qualifiers Other) const { return Mask != Other.Mask; } |

526 | |

527 | explicit operator bool() const { return hasQualifiers(); } |

528 | |

529 | Qualifiers &operator+=(Qualifiers R) { |

530 | addQualifiers(R); |

531 | return *this; |

532 | } |

533 | |

534 | // Union two qualifier sets. If an enumerated qualifier appears |

535 | // in both sets, use the one from the right. |

536 | friend Qualifiers operator+(Qualifiers L, Qualifiers R) { |

537 | L += R; |

538 | return L; |

539 | } |

540 | |

541 | Qualifiers &operator-=(Qualifiers R) { |

542 | removeQualifiers(R); |

543 | return *this; |

544 | } |

545 | |

546 | /// Compute the difference between two qualifier sets. |

547 | friend Qualifiers operator-(Qualifiers L, Qualifiers R) { |

548 | L -= R; |

549 | return L; |

550 | } |

551 | |

552 | std::string getAsString() const; |

553 | std::string getAsString(const PrintingPolicy &Policy) const; |

554 | |

555 | bool isEmptyWhenPrinted(const PrintingPolicy &Policy) const; |

556 | void print(raw_ostream &OS, const PrintingPolicy &Policy, |

557 | bool appendSpaceIfNonEmpty = false) const; |

558 | |

559 | void Profile(llvm::FoldingSetNodeID &ID) const { |

560 | ID.AddInteger(Mask); |

561 | } |

562 | |

563 | private: |

564 | // bits: |0 1 2|3|4 .. 5|6 .. 8|9 ... 31| |

565 | // |C R V|U|GCAttr|Lifetime|AddressSpace| |

566 | uint32_t Mask = 0; |

567 | |

568 | static const uint32_t UMask = 0x8; |

569 | static const uint32_t UShift = 3; |

570 | static const uint32_t GCAttrMask = 0x30; |

571 | static const uint32_t GCAttrShift = 4; |

572 | static const uint32_t LifetimeMask = 0x1C0; |

573 | static const uint32_t LifetimeShift = 6; |

574 | static const uint32_t AddressSpaceMask = |

575 | ~(CVRMask | UMask | GCAttrMask | LifetimeMask); |

576 | static const uint32_t AddressSpaceShift = 9; |

577 | }; |

578 | |

579 | /// A std::pair-like structure for storing a qualified type split |

580 | /// into its local qualifiers and its locally-unqualified type. |

581 | struct SplitQualType { |

582 | /// The locally-unqualified type. |

583 | const Type *Ty = nullptr; |

584 | |

585 | /// The local qualifiers. |

586 | Qualifiers Quals; |

587 | |

588 | SplitQualType() = default; |

589 | SplitQualType(const Type *ty, Qualifiers qs) : Ty(ty), Quals(qs) {} |

590 | |

591 | SplitQualType getSingleStepDesugaredType() const; // end of this file |

592 | |

593 | // Make std::tie work. |

594 | std::pair<const Type *,Qualifiers> asPair() const { |

595 | return std::pair<const Type *, Qualifiers>(Ty, Quals); |

596 | } |

597 | |

598 | friend bool operator==(SplitQualType a, SplitQualType b) { |

599 | return a.Ty == b.Ty && a.Quals == b.Quals; |

600 | } |

601 | friend bool operator!=(SplitQualType a, SplitQualType b) { |

602 | return a.Ty != b.Ty || a.Quals != b.Quals; |

603 | } |

604 | }; |

605 | |

606 | /// The kind of type we are substituting Objective-C type arguments into. |

607 | /// |

608 | /// The kind of substitution affects the replacement of type parameters when |

609 | /// no concrete type information is provided, e.g., when dealing with an |

610 | /// unspecialized type. |

611 | enum class ObjCSubstitutionContext { |

612 | /// An ordinary type. |

613 | Ordinary, |

614 | |

615 | /// The result type of a method or function. |

616 | Result, |

617 | |

618 | /// The parameter type of a method or function. |

619 | Parameter, |

620 | |

621 | /// The type of a property. |

622 | Property, |

623 | |

624 | /// The superclass of a type. |

625 | Superclass, |

626 | }; |

627 | |

628 | /// A (possibly-)qualified type. |

629 | /// |

630 | /// For efficiency, we don't store CV-qualified types as nodes on their |

631 | /// own: instead each reference to a type stores the qualifiers. This |

632 | /// greatly reduces the number of nodes we need to allocate for types (for |

633 | /// example we only need one for 'int', 'const int', 'volatile int', |

634 | /// 'const volatile int', etc). |

635 | /// |

636 | /// As an added efficiency bonus, instead of making this a pair, we |

637 | /// just store the two bits we care about in the low bits of the |

638 | /// pointer. To handle the packing/unpacking, we make QualType be a |

639 | /// simple wrapper class that acts like a smart pointer. A third bit |

640 | /// indicates whether there are extended qualifiers present, in which |

641 | /// case the pointer points to a special structure. |

642 | class QualType { |

643 | friend class QualifierCollector; |

644 | |

645 | // Thankfully, these are efficiently composable. |

646 | llvm::PointerIntPair<llvm::PointerUnion<const Type *, const ExtQuals *>, |

647 | Qualifiers::FastWidth> Value; |

648 | |

649 | const ExtQuals *getExtQualsUnsafe() const { |

650 | return Value.getPointer().get<const ExtQuals*>(); |

651 | } |

652 | |

653 | const Type *getTypePtrUnsafe() const { |

654 | return Value.getPointer().get<const Type*>(); |

655 | } |

656 | |

657 | const ExtQualsTypeCommonBase *getCommonPtr() const { |

658 | assert(!isNull() && "Cannot retrieve a NULL type pointer"); |

659 | auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue()); |

660 | CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1); |

661 | return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal); |

662 | } |

663 | |

664 | public: |

665 | QualType() = default; |

666 | QualType(const Type *Ptr, unsigned Quals) : Value(Ptr, Quals) {} |

667 | QualType(const ExtQuals *Ptr, unsigned Quals) : Value(Ptr, Quals) {} |

668 | |

669 | unsigned getLocalFastQualifiers() const { return Value.getInt(); } |

670 | void setLocalFastQualifiers(unsigned Quals) { Value.setInt(Quals); } |

671 | |

672 | /// Retrieves a pointer to the underlying (unqualified) type. |

673 | /// |

674 | /// This function requires that the type not be NULL. If the type might be |

675 | /// NULL, use the (slightly less efficient) \c getTypePtrOrNull(). |

676 | const Type *getTypePtr() const; |

677 | |

678 | const Type *getTypePtrOrNull() const; |

679 | |

680 | /// Retrieves a pointer to the name of the base type. |

681 | const IdentifierInfo *getBaseTypeIdentifier() const; |

682 | |

683 | /// Divides a QualType into its unqualified type and a set of local |

684 | /// qualifiers. |

685 | SplitQualType split() const; |

686 | |

687 | void *getAsOpaquePtr() const { return Value.getOpaqueValue(); } |

688 | |

689 | static QualType getFromOpaquePtr(const void *Ptr) { |

690 | QualType T; |

691 | T.Value.setFromOpaqueValue(const_cast<void*>(Ptr)); |

692 | return T; |

693 | } |

694 | |

695 | const Type &operator*() const { |

696 | return *getTypePtr(); |

697 | } |

698 | |

699 | const Type *operator->() const { |

700 | return getTypePtr(); |

701 | } |

702 | |

703 | bool isCanonical() const; |

704 | bool isCanonicalAsParam() const; |

705 | |

706 | /// Return true if this QualType doesn't point to a type yet. |

707 | bool isNull() const { |

708 | return Value.getPointer().isNull(); |

709 | } |

710 | |

711 | /// Determine whether this particular QualType instance has the |

712 | /// "const" qualifier set, without looking through typedefs that may have |

713 | /// added "const" at a different level. |

714 | bool isLocalConstQualified() const { |

715 | return (getLocalFastQualifiers() & Qualifiers::Const); |

716 | } |

717 | |

718 | /// Determine whether this type is const-qualified. |

719 | bool isConstQualified() const; |

720 | |

721 | /// Determine whether this particular QualType instance has the |

722 | /// "restrict" qualifier set, without looking through typedefs that may have |

723 | /// added "restrict" at a different level. |

724 | bool isLocalRestrictQualified() const { |

725 | return (getLocalFastQualifiers() & Qualifiers::Restrict); |

726 | } |

727 | |

728 | /// Determine whether this type is restrict-qualified. |

729 | bool isRestrictQualified() const; |

730 | |

731 | /// Determine whether this particular QualType instance has the |

732 | /// "volatile" qualifier set, without looking through typedefs that may have |

733 | /// added "volatile" at a different level. |

734 | bool isLocalVolatileQualified() const { |

735 | return (getLocalFastQualifiers() & Qualifiers::Volatile); |

736 | } |

737 | |

738 | /// Determine whether this type is volatile-qualified. |

739 | bool isVolatileQualified() const; |

740 | |

741 | /// Determine whether this particular QualType instance has any |

742 | /// qualifiers, without looking through any typedefs that might add |

743 | /// qualifiers at a different level. |

744 | bool hasLocalQualifiers() const { |

745 | return getLocalFastQualifiers() || hasLocalNonFastQualifiers(); |

746 | } |

747 | |

748 | /// Determine whether this type has any qualifiers. |

749 | bool hasQualifiers() const; |

750 | |

751 | /// Determine whether this particular QualType instance has any |

752 | /// "non-fast" qualifiers, e.g., those that are stored in an ExtQualType |

753 | /// instance. |

754 | bool hasLocalNonFastQualifiers() const { |

755 | return Value.getPointer().is<const ExtQuals*>(); |

756 | } |

757 | |

758 | /// Retrieve the set of qualifiers local to this particular QualType |

759 | /// instance, not including any qualifiers acquired through typedefs or |

760 | /// other sugar. |

761 | Qualifiers getLocalQualifiers() const; |

762 | |

763 | /// Retrieve the set of qualifiers applied to this type. |

764 | Qualifiers getQualifiers() const; |

765 | |

766 | /// Retrieve the set of CVR (const-volatile-restrict) qualifiers |

767 | /// local to this particular QualType instance, not including any qualifiers |

768 | /// acquired through typedefs or other sugar. |

769 | unsigned getLocalCVRQualifiers() const { |

770 | return getLocalFastQualifiers(); |

771 | } |

772 | |

773 | /// Retrieve the set of CVR (const-volatile-restrict) qualifiers |

774 | /// applied to this type. |

775 | unsigned getCVRQualifiers() const; |

776 | |

777 | bool isConstant(const ASTContext& Ctx) const { |

778 | return QualType::isConstant(*this, Ctx); |

779 | } |

780 | |

781 | /// Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10). |

782 | bool isPODType(const ASTContext &Context) const; |

783 | |

784 | /// Return true if this is a POD type according to the rules of the C++98 |

785 | /// standard, regardless of the current compilation's language. |

786 | bool isCXX98PODType(const ASTContext &Context) const; |

787 | |

788 | /// Return true if this is a POD type according to the more relaxed rules |

789 | /// of the C++11 standard, regardless of the current compilation's language. |

790 | /// (C++0x [basic.types]p9). Note that, unlike |

791 | /// CXXRecordDecl::isCXX11StandardLayout, this takes DRs into account. |

792 | bool isCXX11PODType(const ASTContext &Context) const; |

793 | |

794 | /// Return true if this is a trivial type per (C++0x [basic.types]p9) |

795 | bool isTrivialType(const ASTContext &Context) const; |

796 | |

797 | /// Return true if this is a trivially copyable type (C++0x [basic.types]p9) |

798 | bool isTriviallyCopyableType(const ASTContext &Context) const; |

799 | |

800 | |

801 | /// Returns true if it is a class and it might be dynamic. |

802 | bool mayBeDynamicClass() const; |

803 | |

804 | /// Returns true if it is not a class or if the class might not be dynamic. |

805 | bool mayBeNotDynamicClass() const; |

806 | |

807 | // Don't promise in the API that anything besides 'const' can be |

808 | // easily added. |

809 | |

810 | /// Add the `const` type qualifier to this QualType. |

811 | void addConst() { |

812 | addFastQualifiers(Qualifiers::Const); |

813 | } |

814 | QualType withConst() const { |

815 | return withFastQualifiers(Qualifiers::Const); |

816 | } |

817 | |

818 | /// Add the `volatile` type qualifier to this QualType. |

819 | void addVolatile() { |

820 | addFastQualifiers(Qualifiers::Volatile); |

821 | } |

822 | QualType withVolatile() const { |

823 | return withFastQualifiers(Qualifiers::Volatile); |

824 | } |

825 | |

826 | /// Add the `restrict` qualifier to this QualType. |

827 | void addRestrict() { |

828 | addFastQualifiers(Qualifiers::Restrict); |

829 | } |

830 | QualType withRestrict() const { |

831 | return withFastQualifiers(Qualifiers::Restrict); |

832 | } |

833 | |

834 | QualType withCVRQualifiers(unsigned CVR) const { |

835 | return withFastQualifiers(CVR); |

836 | } |

837 | |

838 | void addFastQualifiers(unsigned TQs) { |

839 | assert(!(TQs & ~Qualifiers::FastMask) |

840 | && "non-fast qualifier bits set in mask!"); |

841 | Value.setInt(Value.getInt() | TQs); |

842 | } |

843 | |

844 | void removeLocalConst(); |

845 | void removeLocalVolatile(); |

846 | void removeLocalRestrict(); |

847 | void removeLocalCVRQualifiers(unsigned Mask); |

848 | |

849 | void removeLocalFastQualifiers() { Value.setInt(0); } |

850 | void removeLocalFastQualifiers(unsigned Mask) { |

851 | assert(!(Mask & ~Qualifiers::FastMask) && "mask has non-fast qualifiers"); |

852 | Value.setInt(Value.getInt() & ~Mask); |

853 | } |

854 | |

855 | // Creates a type with the given qualifiers in addition to any |

856 | // qualifiers already on this type. |

857 | QualType withFastQualifiers(unsigned TQs) const { |

858 | QualType T = *this; |

859 | T.addFastQualifiers(TQs); |

860 | return T; |

861 | } |

862 | |

863 | // Creates a type with exactly the given fast qualifiers, removing |

864 | // any existing fast qualifiers. |

865 | QualType withExactLocalFastQualifiers(unsigned TQs) const { |

866 | return withoutLocalFastQualifiers().withFastQualifiers(TQs); |

867 | } |

868 | |

869 | // Removes fast qualifiers, but leaves any extended qualifiers in place. |

870 | QualType withoutLocalFastQualifiers() const { |

871 | QualType T = *this; |

872 | T.removeLocalFastQualifiers(); |

873 | return T; |

874 | } |

875 | |

876 | QualType getCanonicalType() const; |

877 | |

878 | /// Return this type with all of the instance-specific qualifiers |

879 | /// removed, but without removing any qualifiers that may have been applied |

880 | /// through typedefs. |

881 | QualType getLocalUnqualifiedType() const { return QualType(getTypePtr(), 0); } |

882 | |

883 | /// Retrieve the unqualified variant of the given type, |

884 | /// removing as little sugar as possible. |

885 | /// |

886 | /// This routine looks through various kinds of sugar to find the |

887 | /// least-desugared type that is unqualified. For example, given: |

888 | /// |

889 | /// \code |

890 | /// typedef int Integer; |

891 | /// typedef const Integer CInteger; |

892 | /// typedef CInteger DifferenceType; |

893 | /// \endcode |

894 | /// |

895 | /// Executing \c getUnqualifiedType() on the type \c DifferenceType will |

896 | /// desugar until we hit the type \c Integer, which has no qualifiers on it. |

897 | /// |

898 | /// The resulting type might still be qualified if it's sugar for an array |

899 | /// type. To strip qualifiers even from within a sugared array type, use |

900 | /// ASTContext::getUnqualifiedArrayType. |

901 | inline QualType getUnqualifiedType() const; |

902 | |

903 | /// Retrieve the unqualified variant of the given type, removing as little |

904 | /// sugar as possible. |

905 | /// |

906 | /// Like getUnqualifiedType(), but also returns the set of |

907 | /// qualifiers that were built up. |

908 | /// |

909 | /// The resulting type might still be qualified if it's sugar for an array |

910 | /// type. To strip qualifiers even from within a sugared array type, use |

911 | /// ASTContext::getUnqualifiedArrayType. |

912 | inline SplitQualType getSplitUnqualifiedType() const; |

913 | |

914 | /// Determine whether this type is more qualified than the other |

915 | /// given type, requiring exact equality for non-CVR qualifiers. |

916 | bool isMoreQualifiedThan(QualType Other) const; |

917 | |

918 | /// Determine whether this type is at least as qualified as the other |

919 | /// given type, requiring exact equality for non-CVR qualifiers. |

920 | bool isAtLeastAsQualifiedAs(QualType Other) const; |

921 | |

922 | QualType getNonReferenceType() const; |

923 | |

924 | /// Determine the type of a (typically non-lvalue) expression with the |

925 | /// specified result type. |

926 | /// |

927 | /// This routine should be used for expressions for which the return type is |

928 | /// explicitly specified (e.g., in a cast or call) and isn't necessarily |

929 | /// an lvalue. It removes a top-level reference (since there are no |

930 | /// expressions of reference type) and deletes top-level cvr-qualifiers |

931 | /// from non-class types (in C++) or all types (in C). |

932 | QualType getNonLValueExprType(const ASTContext &Context) const; |

933 | |

934 | /// Return the specified type with any "sugar" removed from |

935 | /// the type. This takes off typedefs, typeof's etc. If the outer level of |

936 | /// the type is already concrete, it returns it unmodified. This is similar |

937 | /// to getting the canonical type, but it doesn't remove *all* typedefs. For |

938 | /// example, it returns "T*" as "T*", (not as "int*"), because the pointer is |

939 | /// concrete. |

940 | /// |

941 | /// Qualifiers are left in place. |

942 | QualType getDesugaredType(const ASTContext &Context) const { |

943 | return getDesugaredType(*this, Context); |

944 | } |

945 | |

946 | SplitQualType getSplitDesugaredType() const { |

947 | return getSplitDesugaredType(*this); |

948 | } |

949 | |

950 | /// Return the specified type with one level of "sugar" removed from |

951 | /// the type. |

952 | /// |

953 | /// This routine takes off the first typedef, typeof, etc. If the outer level |

954 | /// of the type is already concrete, it returns it unmodified. |

955 | QualType getSingleStepDesugaredType(const ASTContext &Context) const { |

956 | return getSingleStepDesugaredTypeImpl(*this, Context); |

957 | } |

958 | |

959 | /// Returns the specified type after dropping any |

960 | /// outer-level parentheses. |

961 | QualType IgnoreParens() const { |

962 | if (isa<ParenType>(*this)) |

963 | return QualType::IgnoreParens(*this); |

964 | return *this; |

965 | } |

966 | |

967 | /// Indicate whether the specified types and qualifiers are identical. |

968 | friend bool operator==(const QualType &LHS, const QualType &RHS) { |

969 | return LHS.Value == RHS.Value; |

970 | } |

971 | friend bool operator!=(const QualType &LHS, const QualType &RHS) { |

972 | return LHS.Value != RHS.Value; |

973 | } |

974 | |

975 | static std::string getAsString(SplitQualType split, |

976 | const PrintingPolicy &Policy) { |

977 | return getAsString(split.Ty, split.Quals, Policy); |

978 | } |

979 | static std::string getAsString(const Type *ty, Qualifiers qs, |

980 | const PrintingPolicy &Policy); |

981 | |

982 | std::string getAsString() const; |

983 | std::string getAsString(const PrintingPolicy &Policy) const; |

984 | |

985 | void print(raw_ostream &OS, const PrintingPolicy &Policy, |

986 | const Twine &PlaceHolder = Twine(), |

987 | unsigned Indentation = 0) const { |

988 | print(split(), OS, Policy, PlaceHolder, Indentation); |

989 | } |

990 | |

991 | static void print(SplitQualType split, raw_ostream &OS, |

992 | const PrintingPolicy &policy, const Twine &PlaceHolder, |

993 | unsigned Indentation = 0) { |

994 | return print(split.Ty, split.Quals, OS, policy, PlaceHolder, Indentation); |

995 | } |

996 | |

997 | static void print(const Type *ty, Qualifiers qs, |

998 | raw_ostream &OS, const PrintingPolicy &policy, |

999 | const Twine &PlaceHolder, |

1000 | unsigned Indentation = 0); |

1001 | |

1002 | void getAsStringInternal(std::string &Str, |

1003 | const PrintingPolicy &Policy) const { |

1004 | return getAsStringInternal(split(), Str, Policy); |

1005 | } |

1006 | |

1007 | static void getAsStringInternal(SplitQualType split, std::string &out, |

1008 | const PrintingPolicy &policy) { |

1009 | return getAsStringInternal(split.Ty, split.Quals, out, policy); |

1010 | } |

1011 | |

1012 | static void getAsStringInternal(const Type *ty, Qualifiers qs, |

1013 | std::string &out, |

1014 | const PrintingPolicy &policy); |

1015 | |

1016 | class StreamedQualTypeHelper { |

1017 | const QualType &T; |

1018 | const PrintingPolicy &Policy; |

1019 | const Twine &PlaceHolder; |

1020 | unsigned Indentation; |

1021 | |

1022 | public: |

1023 | StreamedQualTypeHelper(const QualType &T, const PrintingPolicy &Policy, |

1024 | const Twine &PlaceHolder, unsigned Indentation) |

1025 | : T(T), Policy(Policy), PlaceHolder(PlaceHolder), |

1026 | Indentation(Indentation) {} |

1027 | |

1028 | friend raw_ostream &operator<<(raw_ostream &OS, |

1029 | const StreamedQualTypeHelper &SQT) { |

1030 | SQT.T.print(OS, SQT.Policy, SQT.PlaceHolder, SQT.Indentation); |

1031 | return OS; |

1032 | } |

1033 | }; |

1034 | |

1035 | StreamedQualTypeHelper stream(const PrintingPolicy &Policy, |

1036 | const Twine &PlaceHolder = Twine(), |

1037 | unsigned Indentation = 0) const { |

1038 | return StreamedQualTypeHelper(*this, Policy, PlaceHolder, Indentation); |

1039 | } |

1040 | |

1041 | void dump(const char *s) const; |

1042 | void dump() const; |

1043 | void dump(llvm::raw_ostream &OS) const; |

1044 | |

1045 | void Profile(llvm::FoldingSetNodeID &ID) const { |

1046 | ID.AddPointer(getAsOpaquePtr()); |

1047 | } |

1048 | |

1049 | /// Return the address space of this type. |

1050 | inline LangAS getAddressSpace() const; |

1051 | |

1052 | /// Returns gc attribute of this type. |

1053 | inline Qualifiers::GC getObjCGCAttr() const; |

1054 | |

1055 | /// true when Type is objc's weak. |

1056 | bool isObjCGCWeak() const { |

1057 | return getObjCGCAttr() == Qualifiers::Weak; |

1058 | } |

1059 | |

1060 | /// true when Type is objc's strong. |

1061 | bool isObjCGCStrong() const { |

1062 | return getObjCGCAttr() == Qualifiers::Strong; |

1063 | } |

1064 | |

1065 | /// Returns lifetime attribute of this type. |

1066 | Qualifiers::ObjCLifetime getObjCLifetime() const { |

1067 | return getQualifiers().getObjCLifetime(); |

1068 | } |

1069 | |

1070 | bool hasNonTrivialObjCLifetime() const { |

1071 | return getQualifiers().hasNonTrivialObjCLifetime(); |

1072 | } |

1073 | |

1074 | bool hasStrongOrWeakObjCLifetime() const { |

1075 | return getQualifiers().hasStrongOrWeakObjCLifetime(); |

1076 | } |

1077 | |

1078 | // true when Type is objc's weak and weak is enabled but ARC isn't. |

1079 | bool isNonWeakInMRRWithObjCWeak(const ASTContext &Context) const; |

1080 | |

1081 | enum PrimitiveDefaultInitializeKind { |

1082 | /// The type does not fall into any of the following categories. Note that |

1083 | /// this case is zero-valued so that values of this enum can be used as a |

1084 | /// boolean condition for non-triviality. |

1085 | PDIK_Trivial, |

1086 | |

1087 | /// The type is an Objective-C retainable pointer type that is qualified |

1088 | /// with the ARC __strong qualifier. |

1089 | PDIK_ARCStrong, |

1090 | |

1091 | /// The type is an Objective-C retainable pointer type that is qualified |

1092 | /// with the ARC __weak qualifier. |

1093 | PDIK_ARCWeak, |

1094 | |

1095 | /// The type is a struct containing a field whose type is not PCK_Trivial. |

1096 | PDIK_Struct |

1097 | }; |

1098 | |

1099 | /// Functions to query basic properties of non-trivial C struct types. |

1100 | |

1101 | /// Check if this is a non-trivial type that would cause a C struct |

1102 | /// transitively containing this type to be non-trivial to default initialize |

1103 | /// and return the kind. |

1104 | PrimitiveDefaultInitializeKind |

1105 | isNonTrivialToPrimitiveDefaultInitialize() const; |

1106 | |

1107 | enum PrimitiveCopyKind { |

1108 | /// The type does not fall into any of the following categories. Note that |

1109 | /// this case is zero-valued so that values of this enum can be used as a |

1110 | /// boolean condition for non-triviality. |

1111 | PCK_Trivial, |

1112 | |

1113 | /// The type would be trivial except that it is volatile-qualified. Types |

1114 | /// that fall into one of the other non-trivial cases may additionally be |

1115 | /// volatile-qualified. |

1116 | PCK_VolatileTrivial, |

1117 | |

1118 | /// The type is an Objective-C retainable pointer type that is qualified |

1119 | /// with the ARC __strong qualifier. |

1120 | PCK_ARCStrong, |

1121 | |

1122 | /// The type is an Objective-C retainable pointer type that is qualified |

1123 | /// with the ARC __weak qualifier. |

1124 | PCK_ARCWeak, |

1125 | |

1126 | /// The type is a struct containing a field whose type is neither |

1127 | /// PCK_Trivial nor PCK_VolatileTrivial. |

1128 | /// Note that a C++ struct type does not necessarily match this; C++ copying |

1129 | /// semantics are too complex to express here, in part because they depend |

1130 | /// on the exact constructor or assignment operator that is chosen by |

1131 | /// overload resolution to do the copy. |

1132 | PCK_Struct |

1133 | }; |

1134 | |

1135 | /// Check if this is a non-trivial type that would cause a C struct |

1136 | /// transitively containing this type to be non-trivial to copy and return the |

1137 | /// kind. |

1138 | PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const; |

1139 | |

1140 | /// Check if this is a non-trivial type that would cause a C struct |

1141 | /// transitively containing this type to be non-trivial to destructively |

1142 | /// move and return the kind. Destructive move in this context is a C++-style |

1143 | /// move in which the source object is placed in a valid but unspecified state |

1144 | /// after it is moved, as opposed to a truly destructive move in which the |

1145 | /// source object is placed in an uninitialized state. |

1146 | PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const; |

1147 | |

1148 | enum DestructionKind { |

1149 | DK_none, |

1150 | DK_cxx_destructor, |

1151 | DK_objc_strong_lifetime, |

1152 | DK_objc_weak_lifetime, |

1153 | DK_nontrivial_c_struct |

1154 | }; |

1155 | |

1156 | /// Returns a nonzero value if objects of this type require |

1157 | /// non-trivial work to clean up after. Non-zero because it's |

1158 | /// conceivable that qualifiers (objc_gc(weak)?) could make |

1159 | /// something require destruction. |

1160 | DestructionKind isDestructedType() const { |

1161 | return isDestructedTypeImpl(*this); |

1162 | } |

1163 | |

1164 | /// Determine whether expressions of the given type are forbidden |

1165 | /// from being lvalues in C. |

1166 | /// |

1167 | /// The expression types that are forbidden to be lvalues are: |

1168 | /// - 'void', but not qualified void |

1169 | /// - function types |

1170 | /// |

1171 | /// The exact rule here is C99 6.3.2.1: |

1172 | /// An lvalue is an expression with an object type or an incomplete |

1173 | /// type other than void. |

1174 | bool isCForbiddenLValueType() const; |

1175 | |

1176 | /// Substitute type arguments for the Objective-C type parameters used in the |

1177 | /// subject type. |

1178 | /// |

1179 | /// \param ctx ASTContext in which the type exists. |

1180 | /// |

1181 | /// \param typeArgs The type arguments that will be substituted for the |

1182 | /// Objective-C type parameters in the subject type, which are generally |

1183 | /// computed via \c Type::getObjCSubstitutions. If empty, the type |

1184 | /// parameters will be replaced with their bounds or id/Class, as appropriate |

1185 | /// for the context. |

1186 | /// |

1187 | /// \param context The context in which the subject type was written. |

1188 | /// |

1189 | /// \returns the resulting type. |

1190 | QualType substObjCTypeArgs(ASTContext &ctx, |

1191 | ArrayRef<QualType> typeArgs, |

1192 | ObjCSubstitutionContext context) const; |

1193 | |

1194 | /// Substitute type arguments from an object type for the Objective-C type |

1195 | /// parameters used in the subject type. |

1196 | /// |

1197 | /// This operation combines the computation of type arguments for |

1198 | /// substitution (\c Type::getObjCSubstitutions) with the actual process of |

1199 | /// substitution (\c QualType::substObjCTypeArgs) for the convenience of |

1200 | /// callers that need to perform a single substitution in isolation. |

1201 | /// |

1202 | /// \param objectType The type of the object whose member type we're |

1203 | /// substituting into. For example, this might be the receiver of a message |

1204 | /// or the base of a property access. |

1205 | /// |

1206 | /// \param dc The declaration context from which the subject type was |

1207 | /// retrieved, which indicates (for example) which type parameters should |

1208 | /// be substituted. |

1209 | /// |

1210 | /// \param context The context in which the subject type was written. |

1211 | /// |

1212 | /// \returns the subject type after replacing all of the Objective-C type |

1213 | /// parameters with their corresponding arguments. |

1214 | QualType substObjCMemberType(QualType objectType, |

1215 | const DeclContext *dc, |

1216 | ObjCSubstitutionContext context) const; |

1217 | |

1218 | /// Strip Objective-C "__kindof" types from the given type. |

1219 | QualType stripObjCKindOfType(const ASTContext &ctx) const; |

1220 | |

1221 | /// Remove all qualifiers including _Atomic. |

1222 | QualType getAtomicUnqualifiedType() const; |

1223 | |

1224 | private: |

1225 | // These methods are implemented in a separate translation unit; |

1226 | // "static"-ize them to avoid creating temporary QualTypes in the |

1227 | // caller. |

1228 | static bool isConstant(QualType T, const ASTContext& Ctx); |

1229 | static QualType getDesugaredType(QualType T, const ASTContext &Context); |

1230 | static SplitQualType getSplitDesugaredType(QualType T); |

1231 | static SplitQualType getSplitUnqualifiedTypeImpl(QualType type); |

1232 | static QualType getSingleStepDesugaredTypeImpl(QualType type, |

1233 | const ASTContext &C); |

1234 | static QualType IgnoreParens(QualType T); |

1235 | static DestructionKind isDestructedTypeImpl(QualType type); |

1236 | }; |

1237 | |

1238 | } // namespace clang |

1239 | |

1240 | namespace llvm { |

1241 | |

1242 | /// Implement simplify_type for QualType, so that we can dyn_cast from QualType |

1243 | /// to a specific Type class. |

1244 | template<> struct simplify_type< ::clang::QualType> { |

1245 | using SimpleType = const ::clang::Type *; |

1246 | |

1247 | static SimpleType getSimplifiedValue(::clang::QualType Val) { |

1248 | return Val.getTypePtr(); |

1249 | } |

1250 | }; |

1251 | |

1252 | // Teach SmallPtrSet that QualType is "basically a pointer". |

1253 | template<> |

1254 | struct PointerLikeTypeTraits<clang::QualType> { |

1255 | static inline void *getAsVoidPointer(clang::QualType P) { |

1256 | return P.getAsOpaquePtr(); |

1257 | } |

1258 | |

1259 | static inline clang::QualType getFromVoidPointer(void *P) { |

1260 | return clang::QualType::getFromOpaquePtr(P); |

1261 | } |

1262 | |

1263 | // Various qualifiers go in low bits. |

1264 | enum { NumLowBitsAvailable = 0 }; |

1265 | }; |

1266 | |

1267 | } // namespace llvm |

1268 | |

1269 | namespace clang { |

1270 | |

1271 | /// Base class that is common to both the \c ExtQuals and \c Type |

1272 | /// classes, which allows \c QualType to access the common fields between the |

1273 | /// two. |

1274 | class ExtQualsTypeCommonBase { |

1275 | friend class ExtQuals; |

1276 | friend class QualType; |

1277 | friend class Type; |

1278 | |

1279 | /// The "base" type of an extended qualifiers type (\c ExtQuals) or |

1280 | /// a self-referential pointer (for \c Type). |

1281 | /// |

1282 | /// This pointer allows an efficient mapping from a QualType to its |

1283 | /// underlying type pointer. |

1284 | const Type *const BaseType; |

1285 | |

1286 | /// The canonical type of this type. A QualType. |

1287 | QualType CanonicalType; |

1288 | |

1289 | ExtQualsTypeCommonBase(const Type *baseType, QualType canon) |

1290 | : BaseType(baseType), CanonicalType(canon) {} |

1291 | }; |

1292 | |

1293 | /// We can encode up to four bits in the low bits of a |

1294 | /// type pointer, but there are many more type qualifiers that we want |

1295 | /// to be able to apply to an arbitrary type. Therefore we have this |

1296 | /// struct, intended to be heap-allocated and used by QualType to |

1297 | /// store qualifiers. |

1298 | /// |

1299 | /// The current design tags the 'const', 'restrict', and 'volatile' qualifiers |

1300 | /// in three low bits on the QualType pointer; a fourth bit records whether |

1301 | /// the pointer is an ExtQuals node. The extended qualifiers (address spaces, |

1302 | /// Objective-C GC attributes) are much more rare. |

1303 | class ExtQuals : public ExtQualsTypeCommonBase, public llvm::FoldingSetNode { |

1304 | // NOTE: changing the fast qualifiers should be straightforward as |

1305 | // long as you don't make 'const' non-fast. |

1306 | // 1. Qualifiers: |

1307 | // a) Modify the bitmasks (Qualifiers::TQ and DeclSpec::TQ). |

1308 | // Fast qualifiers must occupy the low-order bits. |

1309 | // b) Update Qualifiers::FastWidth and FastMask. |

1310 | // 2. QualType: |

1311 | // a) Update is{Volatile,Restrict}Qualified(), defined inline. |

1312 | // b) Update remove{Volatile,Restrict}, defined near the end of |

1313 | // this header. |

1314 | // 3. ASTContext: |

1315 | // a) Update get{Volatile,Restrict}Type. |

1316 | |

1317 | /// The immutable set of qualifiers applied by this node. Always contains |

1318 | /// extended qualifiers. |

1319 | Qualifiers Quals; |

1320 | |

1321 | ExtQuals *this_() { return this; } |

1322 | |

1323 | public: |

1324 | ExtQuals(const Type *baseType, QualType canon, Qualifiers quals) |

1325 | : ExtQualsTypeCommonBase(baseType, |

1326 | canon.isNull() ? QualType(this_(), 0) : canon), |

1327 | Quals(quals) { |

1328 | assert(Quals.hasNonFastQualifiers() |

1329 | && "ExtQuals created with no fast qualifiers"); |

1330 | assert(!Quals.hasFastQualifiers() |

1331 | && "ExtQuals created with fast qualifiers"); |

1332 | } |

1333 | |

1334 | Qualifiers getQualifiers() const { return Quals; } |

1335 | |

1336 | bool hasObjCGCAttr() const { return Quals.hasObjCGCAttr(); } |

1337 | Qualifiers::GC getObjCGCAttr() const { return Quals.getObjCGCAttr(); } |

1338 | |

1339 | bool hasObjCLifetime() const { return Quals.hasObjCLifetime(); } |

1340 | Qualifiers::ObjCLifetime getObjCLifetime() const { |

1341 | return Quals.getObjCLifetime(); |

1342 | } |

1343 | |

1344 | bool hasAddressSpace() const { return Quals.hasAddressSpace(); } |

1345 | LangAS getAddressSpace() const { return Quals.getAddressSpace(); } |

1346 | |

1347 | const Type *getBaseType() const { return BaseType; } |

1348 | |

1349 | public: |

1350 | void Profile(llvm::FoldingSetNodeID &ID) const { |

1351 | Profile(ID, getBaseType(), Quals); |

1352 | } |

1353 | |

1354 | static void Profile(llvm::FoldingSetNodeID &ID, |

1355 | const Type *BaseType, |

1356 | Qualifiers Quals) { |

1357 | assert(!Quals.hasFastQualifiers() && "fast qualifiers in ExtQuals hash!"); |

1358 | ID.AddPointer(BaseType); |

1359 | Quals.Profile(ID); |

1360 | } |

1361 | }; |

1362 | |

1363 | /// The kind of C++11 ref-qualifier associated with a function type. |

1364 | /// This determines whether a member function's "this" object can be an |

1365 | /// lvalue, rvalue, or neither. |

1366 | enum RefQualifierKind { |

1367 | /// No ref-qualifier was provided. |

1368 | RQ_None = 0, |

1369 | |

1370 | /// An lvalue ref-qualifier was provided (\c &). |

1371 | RQ_LValue, |

1372 | |

1373 | /// An rvalue ref-qualifier was provided (\c &&). |

1374 | RQ_RValue |

1375 | }; |

1376 | |

1377 | /// Which keyword(s) were used to create an AutoType. |

1378 | enum class AutoTypeKeyword { |

1379 | /// auto |

1380 | Auto, |

1381 | |

1382 | /// decltype(auto) |

1383 | DecltypeAuto, |

1384 | |

1385 | /// __auto_type (GNU extension) |

1386 | GNUAutoType |

1387 | }; |

1388 | |

1389 | /// The base class of the type hierarchy. |

1390 | /// |

1391 | /// A central concept with types is that each type always has a canonical |

1392 | /// type. A canonical type is the type with any typedef names stripped out |

1393 | /// of it or the types it references. For example, consider: |

1394 | /// |

1395 | /// typedef int foo; |

1396 | /// typedef foo* bar; |

1397 | /// 'int *' 'foo *' 'bar' |

1398 | /// |

1399 | /// There will be a Type object created for 'int'. Since int is canonical, its |

1400 | /// CanonicalType pointer points to itself. There is also a Type for 'foo' (a |

1401 | /// TypedefType). Its CanonicalType pointer points to the 'int' Type. Next |

1402 | /// there is a PointerType that represents 'int*', which, like 'int', is |

1403 | /// canonical. Finally, there is a PointerType type for 'foo*' whose canonical |

1404 | /// type is 'int*', and there is a TypedefType for 'bar', whose canonical type |

1405 | /// is also 'int*'. |

1406 | /// |

1407 | /// Non-canonical types are useful for emitting diagnostics, without losing |

1408 | /// information about typedefs being used. Canonical types are useful for type |

1409 | /// comparisons (they allow by-pointer equality tests) and useful for reasoning |

1410 | /// about whether something has a particular form (e.g. is a function type), |

1411 | /// because they implicitly, recursively, strip all typedefs out of a type. |

1412 | /// |

1413 | /// Types, once created, are immutable. |

1414 | /// |

1415 | class Type : public ExtQualsTypeCommonBase { |

1416 | public: |

1417 | enum TypeClass { |

1418 | #define TYPE(Class, Base) Class, |

1419 | #define LAST_TYPE(Class) TypeLast = Class, |

1420 | #define ABSTRACT_TYPE(Class, Base) |

1421 | #include "clang/AST/TypeNodes.def" |

1422 | TagFirst = Record, TagLast = Enum |

1423 | }; |

1424 | |

1425 | private: |

1426 | /// Bitfields required by the Type class. |

1427 | class TypeBitfields { |

1428 | friend class Type; |

1429 | template <class T> friend class TypePropertyCache; |

1430 | |

1431 | /// TypeClass bitfield - Enum that specifies what subclass this belongs to. |

1432 | unsigned TC : 8; |

1433 | |

1434 | /// Whether this type is a dependent type (C++ [temp.dep.type]). |

1435 | unsigned Dependent : 1; |

1436 | |

1437 | /// Whether this type somehow involves a template parameter, even |

1438 | /// if the resolution of the type does not depend on a template parameter. |

1439 | unsigned InstantiationDependent : 1; |

1440 | |

1441 | /// Whether this type is a variably-modified type (C99 6.7.5). |

1442 | unsigned VariablyModified : 1; |

1443 | |

1444 | /// Whether this type contains an unexpanded parameter pack |

1445 | /// (for C++11 variadic templates). |

1446 | unsigned ContainsUnexpandedParameterPack : 1; |

1447 | |

1448 | /// True if the cache (i.e. the bitfields here starting with |

1449 | /// 'Cache') is valid. |

1450 | mutable unsigned CacheValid : 1; |

1451 | |

1452 | /// Linkage of this type. |

1453 | mutable unsigned CachedLinkage : 3; |

1454 | |

1455 | /// Whether this type involves and local or unnamed types. |

1456 | mutable unsigned CachedLocalOrUnnamed : 1; |

1457 | |

1458 | /// Whether this type comes from an AST file. |

1459 | mutable unsigned FromAST : 1; |

1460 | |

1461 | bool isCacheValid() const { |

1462 | return CacheValid; |

1463 | } |

1464 | |

1465 | Linkage getLinkage() const { |

1466 | assert(isCacheValid() && "getting linkage from invalid cache"); |

1467 | return static_cast<Linkage>(CachedLinkage); |

1468 | } |

1469 | |

1470 | bool hasLocalOrUnnamedType() const { |

1471 | assert(isCacheValid() && "getting linkage from invalid cache"); |

1472 | return CachedLocalOrUnnamed; |

1473 | } |

1474 | }; |

1475 | enum { NumTypeBits = 18 }; |

1476 | |

1477 | protected: |

1478 | // These classes allow subclasses to somewhat cleanly pack bitfields |

1479 | // into Type. |

1480 | |

1481 | class ArrayTypeBitfields { |

1482 | friend class ArrayType; |

1483 | |

1484 | unsigned : NumTypeBits; |

1485 | |

1486 | /// CVR qualifiers from declarations like |

1487 | /// 'int X[static restrict 4]'. For function parameters only. |

1488 | unsigned IndexTypeQuals : 3; |

1489 | |

1490 | /// Storage class qualifiers from declarations like |

1491 | /// 'int X[static restrict 4]'. For function parameters only. |

1492 | /// Actually an ArrayType::ArraySizeModifier. |

1493 | unsigned SizeModifier : 3; |

1494 | }; |

1495 | |

1496 | class BuiltinTypeBitfields { |

1497 | friend class BuiltinType; |

1498 | |

1499 | unsigned : NumTypeBits; |

1500 | |

1501 | /// The kind (BuiltinType::Kind) of builtin type this is. |

1502 | unsigned Kind : 8; |

1503 | }; |

1504 | |

1505 | /// FunctionTypeBitfields store various bits belonging to FunctionProtoType. |

1506 | /// Only common bits are stored here. Additional uncommon bits are stored |

1507 | /// in a trailing object after FunctionProtoType. |

1508 | class FunctionTypeBitfields { |

1509 | friend class FunctionProtoType; |

1510 | friend class FunctionType; |

1511 | |

1512 | unsigned : NumTypeBits; |

1513 | |

1514 | /// Extra information which affects how the function is called, like |

1515 | /// regparm and the calling convention. |

1516 | unsigned ExtInfo : 12; |

1517 | |

1518 | /// The ref-qualifier associated with a \c FunctionProtoType. |

1519 | /// |

1520 | /// This is a value of type \c RefQualifierKind. |

1521 | unsigned RefQualifier : 2; |

1522 | |

1523 | /// Used only by FunctionProtoType, put here to pack with the |

1524 | /// other bitfields. |

1525 | /// The qualifiers are part of FunctionProtoType because... |

1526 | /// |

1527 | /// C++ 8.3.5p4: The return type, the parameter type list and the |

1528 | /// cv-qualifier-seq, [...], are part of the function type. |

1529 | unsigned TypeQuals : 4; |

1530 | |

1531 | /// The number of parameters this function has, not counting '...'. |

1532 | /// According to [implimits] 8 bits should be enough here but this is |

1533 | /// somewhat easy to exceed with metaprogramming and so we would like to |

1534 | /// keep NumParams as wide as reasonably possible. |

1535 | unsigned NumParams : 16; |

1536 | |

1537 | /// The type of exception specification this function has. |

1538 | unsigned ExceptionSpecType : 4; |

1539 | |

1540 | /// Whether this function has extended parameter information. |

1541 | unsigned HasExtParameterInfos : 1; |

1542 | |

1543 | /// Whether the function is variadic. |

1544 | unsigned Variadic : 1; |

1545 | |

1546 | /// Whether this function has a trailing return type. |

1547 | unsigned HasTrailingReturn : 1; |

1548 | }; |

1549 | |

1550 | class ObjCObjectTypeBitfields { |

1551 | friend class ObjCObjectType; |

1552 | |

1553 | unsigned : NumTypeBits; |

1554 | |

1555 | /// The number of type arguments stored directly on this object type. |

1556 | unsigned NumTypeArgs : 7; |

1557 | |

1558 | /// The number of protocols stored directly on this object type. |

1559 | unsigned NumProtocols : 6; |

1560 | |

1561 | /// Whether this is a "kindof" type. |

1562 | unsigned IsKindOf : 1; |

1563 | }; |

1564 | |

1565 | class ReferenceTypeBitfields { |

1566 | friend class ReferenceType; |

1567 | |

1568 | unsigned : NumTypeBits; |

1569 | |

1570 | /// True if the type was originally spelled with an lvalue sigil. |

1571 | /// This is never true of rvalue references but can also be false |

1572 | /// on lvalue references because of C++0x [dcl.typedef]p9, |

1573 | /// as follows: |

1574 | /// |

1575 | /// typedef int &ref; // lvalue, spelled lvalue |

1576 | /// typedef int &&rvref; // rvalue |

1577 | /// ref &a; // lvalue, inner ref, spelled lvalue |

1578 | /// ref &&a; // lvalue, inner ref |

1579 | /// rvref &a; // lvalue, inner ref, spelled lvalue |

1580 | /// rvref &&a; // rvalue, inner ref |

1581 | unsigned SpelledAsLValue : 1; |

1582 | |

1583 | /// True if the inner type is a reference type. This only happens |

1584 | /// in non-canonical forms. |

1585 | unsigned InnerRef : 1; |

1586 | }; |

1587 | |

1588 | class TypeWithKeywordBitfields { |

1589 | friend class TypeWithKeyword; |

1590 | |

1591 | unsigned : NumTypeBits; |

1592 | |

1593 | /// An ElaboratedTypeKeyword. 8 bits for efficient access. |

1594 | unsigned Keyword : 8; |

1595 | }; |

1596 | |

1597 | enum { NumTypeWithKeywordBits = 8 }; |

1598 | |

1599 | class ElaboratedTypeBitfields { |

1600 | friend class ElaboratedType; |

1601 | |

1602 | unsigned : NumTypeBits; |

1603 | unsigned : NumTypeWithKeywordBits; |

1604 | |

1605 | /// Whether the ElaboratedType has a trailing OwnedTagDecl. |

1606 | unsigned HasOwnedTagDecl : 1; |

1607 | }; |

1608 | |

1609 | class VectorTypeBitfields { |

1610 | friend class VectorType; |

1611 | friend class DependentVectorType; |

1612 | |

1613 | unsigned : NumTypeBits; |

1614 | |

1615 | /// The kind of vector, either a generic vector type or some |

1616 | /// target-specific vector type such as for AltiVec or Neon. |

1617 | unsigned VecKind : 3; |

1618 | |

1619 | /// The number of elements in the vector. |

1620 | unsigned NumElements : 29 - NumTypeBits; |

1621 | |

1622 | enum { MaxNumElements = (1 << (29 - NumTypeBits)) - 1 }; |

1623 | }; |

1624 | |

1625 | class AttributedTypeBitfields { |

1626 | friend class AttributedType; |

1627 | |

1628 | unsigned : NumTypeBits; |

1629 | |

1630 | /// An AttributedType::Kind |

1631 | unsigned AttrKind : 32 - NumTypeBits; |

1632 | }; |

1633 | |

1634 | class AutoTypeBitfields { |

1635 | friend class AutoType; |

1636 | |

1637 | unsigned : NumTypeBits; |

1638 | |

1639 | /// Was this placeholder type spelled as 'auto', 'decltype(auto)', |

1640 | /// or '__auto_type'? AutoTypeKeyword value. |

1641 | unsigned Keyword : 2; |

1642 | }; |

1643 | |

1644 | class SubstTemplateTypeParmPackTypeBitfields { |

1645 | friend class SubstTemplateTypeParmPackType; |

1646 | |

1647 | unsigned : NumTypeBits; |

1648 | |

1649 | /// The number of template arguments in \c Arguments, which is |

1650 | /// expected to be able to hold at least 1024 according to [implimits]. |

1651 | /// However as this limit is somewhat easy to hit with template |

1652 | /// metaprogramming we'd prefer to keep it as large as possible. |

1653 | /// At the moment it has been left as a non-bitfield since this type |

1654 | /// safely fits in 64 bits as an unsigned, so there is no reason to |

1655 | /// introduce the performance impact of a bitfield. |

1656 | unsigned NumArgs; |

1657 | }; |

1658 | |

1659 | class TemplateSpecializationTypeBitfields { |

1660 | friend class TemplateSpecializationType; |

1661 | |

1662 | unsigned : NumTypeBits; |

1663 | |

1664 | /// Whether this template specialization type is a substituted type alias. |

1665 | unsigned TypeAlias : 1; |

1666 | |

1667 | /// The number of template arguments named in this class template |

1668 | /// specialization, which is expected to be able to hold at least 1024 |

1669 | /// according to [implimits]. However, as this limit is somewhat easy to |

1670 | /// hit with template metaprogramming we'd prefer to keep it as large |

1671 | /// as possible. At the moment it has been left as a non-bitfield since |

1672 | /// this type safely fits in 64 bits as an unsigned, so there is no reason |

1673 | /// to introduce the performance impact of a bitfield. |

1674 | unsigned NumArgs; |

1675 | }; |

1676 | |

1677 | class DependentTemplateSpecializationTypeBitfields { |

1678 | friend class DependentTemplateSpecializationType; |

1679 | |

1680 | unsigned : NumTypeBits; |

1681 | unsigned : NumTypeWithKeywordBits; |

1682 | |

1683 | /// The number of template arguments named in this class template |

1684 | /// specialization, which is expected to be able to hold at least 1024 |

1685 | /// according to [implimits]. However, as this limit is somewhat easy to |

1686 | /// hit with template metaprogramming we'd prefer to keep it as large |

1687 | /// as possible. At the moment it has been left as a non-bitfield since |

1688 | /// this type safely fits in 64 bits as an unsigned, so there is no reason |

1689 | /// to introduce the performance impact of a bitfield. |

1690 | unsigned NumArgs; |

1691 | }; |

1692 | |

1693 | class PackExpansionTypeBitfields { |

1694 | friend class PackExpansionType; |

1695 | |

1696 | unsigned : NumTypeBits; |

1697 | |

1698 | /// The number of expansions that this pack expansion will |

1699 | /// generate when substituted (+1), which is expected to be able to |

1700 | /// hold at least 1024 according to [implimits]. However, as this limit |

1701 | /// is somewhat easy to hit with template metaprogramming we'd prefer to |

1702 | /// keep it as large as possible. At the moment it has been left as a |

1703 | /// non-bitfield since this type safely fits in 64 bits as an unsigned, so |

1704 | /// there is no reason to introduce the performance impact of a bitfield. |

1705 | /// |

1706 | /// This field will only have a non-zero value when some of the parameter |

1707 | /// packs that occur within the pattern have been substituted but others |

1708 | /// have not. |

1709 | unsigned NumExpansions; |

1710 | }; |

1711 | |

1712 | union { |

1713 | TypeBitfields TypeBits; |

1714 | ArrayTypeBitfields ArrayTypeBits; |

1715 | AttributedTypeBitfields AttributedTypeBits; |

1716 | AutoTypeBitfields AutoTypeBits; |

1717 | BuiltinTypeBitfields BuiltinTypeBits; |

1718 | FunctionTypeBitfields FunctionTypeBits; |

1719 | ObjCObjectTypeBitfields ObjCObjectTypeBits; |

1720 | ReferenceTypeBitfields ReferenceTypeBits; |

1721 | TypeWithKeywordBitfields TypeWithKeywordBits; |

1722 | ElaboratedTypeBitfields ElaboratedTypeBits; |

1723 | VectorTypeBitfields VectorTypeBits; |

1724 | SubstTemplateTypeParmPackTypeBitfields SubstTemplateTypeParmPackTypeBits; |

1725 | TemplateSpecializationTypeBitfields TemplateSpecializationTypeBits; |

1726 | DependentTemplateSpecializationTypeBitfields |

1727 | DependentTemplateSpecializationTypeBits; |

1728 | PackExpansionTypeBitfields PackExpansionTypeBits; |

1729 | |

1730 | static_assert(sizeof(TypeBitfields) <= 8, |

1731 | "TypeBitfields is larger than 8 bytes!"); |

1732 | static_assert(sizeof(ArrayTypeBitfields) <= 8, |

1733 | "ArrayTypeBitfields is larger than 8 bytes!"); |

1734 | static_assert(sizeof(AttributedTypeBitfields) <= 8, |

1735 | "AttributedTypeBitfields is larger than 8 bytes!"); |

1736 | static_assert(sizeof(AutoTypeBitfields) <= 8, |

1737 | "AutoTypeBitfields is larger than 8 bytes!"); |

1738 | static_assert(sizeof(BuiltinTypeBitfields) <= 8, |

1739 | "BuiltinTypeBitfields is larger than 8 bytes!"); |

1740 | static_assert(sizeof(FunctionTypeBitfields) <= 8, |

1741 | "FunctionTypeBitfields is larger than 8 bytes!"); |

1742 | static_assert(sizeof(ObjCObjectTypeBitfields) <= 8, |

1743 | "ObjCObjectTypeBitfields is larger than 8 bytes!"); |

1744 | static_assert(sizeof(ReferenceTypeBitfields) <= 8, |

1745 | "ReferenceTypeBitfields is larger than 8 bytes!"); |

1746 | static_assert(sizeof(TypeWithKeywordBitfields) <= 8, |

1747 | "TypeWithKeywordBitfields is larger than 8 bytes!"); |

1748 | static_assert(sizeof(ElaboratedTypeBitfields) <= 8, |

1749 | "ElaboratedTypeBitfields is larger than 8 bytes!"); |

1750 | static_assert(sizeof(VectorTypeBitfields) <= 8, |

1751 | "VectorTypeBitfields is larger than 8 bytes!"); |

1752 | static_assert(sizeof(SubstTemplateTypeParmPackTypeBitfields) <= 8, |

1753 | "SubstTemplateTypeParmPackTypeBitfields is larger" |

1754 | " than 8 bytes!"); |

1755 | static_assert(sizeof(TemplateSpecializationTypeBitfields) <= 8, |

1756 | "TemplateSpecializationTypeBitfields is larger" |

1757 | " than 8 bytes!"); |

1758 | static_assert(sizeof(DependentTemplateSpecializationTypeBitfields) <= 8, |

1759 | "DependentTemplateSpecializationTypeBitfields is larger" |

1760 | " than 8 bytes!"); |

1761 | static_assert(sizeof(PackExpansionTypeBitfields) <= 8, |

1762 | "PackExpansionTypeBitfields is larger than 8 bytes"); |

1763 | }; |

1764 | |

1765 | private: |

1766 | template <class T> friend class TypePropertyCache; |

1767 | |

1768 | /// Set whether this type comes from an AST file. |

1769 | void setFromAST(bool V = true) const { |

1770 | TypeBits.FromAST = V; |

1771 | } |

1772 | |

1773 | protected: |

1774 | friend class ASTContext; |

1775 | |

1776 | Type(TypeClass tc, QualType canon, bool Dependent, |

1777 | bool InstantiationDependent, bool VariablyModified, |

1778 | bool ContainsUnexpandedParameterPack) |

1779 | : ExtQualsTypeCommonBase(this, |

1780 | canon.isNull() ? QualType(this_(), 0) : canon) { |

1781 | TypeBits.TC = tc; |

1782 | TypeBits.Dependent = Dependent; |

1783 | TypeBits.InstantiationDependent = Dependent || InstantiationDependent; |

1784 | TypeBits.VariablyModified = VariablyModified; |

1785 | TypeBits.ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack; |

1786 | TypeBits.CacheValid = false; |

1787 | TypeBits.CachedLocalOrUnnamed = false; |

1788 | TypeBits.CachedLinkage = NoLinkage; |

1789 | TypeBits.FromAST = false; |

1790 | } |

1791 | |

1792 | // silence VC++ warning C4355: 'this' : used in base member initializer list |

1793 | Type *this_() { return this; } |

1794 | |

1795 | void setDependent(bool D = true) { |

1796 | TypeBits.Dependent = D; |

1797 | if (D) |

1798 | TypeBits.InstantiationDependent = true; |

1799 | } |

1800 | |

1801 | void setInstantiationDependent(bool D = true) { |

1802 | TypeBits.InstantiationDependent = D; } |

1803 | |

1804 | void setVariablyModified(bool VM = true) { TypeBits.VariablyModified = VM; } |

1805 | |

1806 | void setContainsUnexpandedParameterPack(bool PP = true) { |

1807 | TypeBits.ContainsUnexpandedParameterPack = PP; |

1808 | } |

1809 | |

1810 | public: |

1811 | friend class ASTReader; |

1812 | friend class ASTWriter; |

1813 | |

1814 | Type(const Type &) = delete; |

1815 | Type &operator=(const Type &) = delete; |

1816 | |

1817 | TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); } |

1818 | |

1819 | /// Whether this type comes from an AST file. |

1820 | bool isFromAST() const { return TypeBits.FromAST; } |

1821 | |

1822 | /// Whether this type is or contains an unexpanded parameter |

1823 | /// pack, used to support C++0x variadic templates. |

1824 | /// |

1825 | /// A type that contains a parameter pack shall be expanded by the |

1826 | /// ellipsis operator at some point. For example, the typedef in the |

1827 | /// following example contains an unexpanded parameter pack 'T': |

1828 | /// |

1829 | /// \code |

1830 | /// template<typename ...T> |

1831 | /// struct X { |

1832 | /// typedef T* pointer_types; // ill-formed; T is a parameter pack. |

1833 | /// }; |

1834 | /// \endcode |

1835 | /// |

1836 | /// Note that this routine does not specify which |

1837 | bool containsUnexpandedParameterPack() const { |

1838 | return TypeBits.ContainsUnexpandedParameterPack; |

1839 | } |

1840 | |

1841 | /// Determines if this type would be canonical if it had no further |

1842 | /// qualification. |

1843 | bool isCanonicalUnqualified() const { |

1844 | return CanonicalType == QualType(this, 0); |

1845 | } |

1846 | |

1847 | /// Pull a single level of sugar off of this locally-unqualified type. |

1848 | /// Users should generally prefer SplitQualType::getSingleStepDesugaredType() |

1849 | /// or QualType::getSingleStepDesugaredType(const ASTContext&). |

1850 | QualType getLocallyUnqualifiedSingleStepDesugaredType() const; |

1851 | |

1852 | /// Types are partitioned into 3 broad categories (C99 6.2.5p1): |

1853 | /// object types, function types, and incomplete types. |

1854 | |

1855 | /// Return true if this is an incomplete type. |

1856 | /// A type that can describe objects, but which lacks information needed to |

1857 | /// determine its size (e.g. void, or a fwd declared struct). Clients of this |

1858 | /// routine will need to determine if the size is actually required. |

1859 | /// |

1860 | /// Def If non-null, and the type refers to some kind of declaration |

1861 | /// that can be completed (such as a C struct, C++ class, or Objective-C |

1862 | /// class), will be set to the declaration. |

1863 | bool isIncompleteType(NamedDecl **Def = nullptr) const; |

1864 | |

1865 | /// Return true if this is an incomplete or object |

1866 | /// type, in other words, not a function type. |

1867 | bool isIncompleteOrObjectType() const { |

1868 | return !isFunctionType(); |

1869 | } |

1870 | |

1871 | /// Determine whether this type is an object type. |

1872 | bool isObjectType() const { |

1873 | // C++ [basic.types]p8: |

1874 | // An object type is a (possibly cv-qualified) type that is not a |

1875 | // function type, not a reference type, and not a void type. |

1876 | return !isReferenceType() && !isFunctionType() && !isVoidType(); |

1877 | } |

1878 | |

1879 | /// Return true if this is a literal type |

1880 | /// (C++11 [basic.types]p10) |

1881 | bool isLiteralType(const ASTContext &Ctx) const; |

1882 | |

1883 | /// Test if this type is a standard-layout type. |

1884 | /// (C++0x [basic.type]p9) |

1885 | bool isStandardLayoutType() const; |

1886 | |

1887 | /// Helper methods to distinguish type categories. All type predicates |

1888 | /// operate on the canonical type, ignoring typedefs and qualifiers. |

1889 | |

1890 | /// Returns true if the type is a builtin type. |

1891 | bool isBuiltinType() const; |

1892 | |

1893 | /// Test for a particular builtin type. |

1894 | bool isSpecificBuiltinType(unsigned K) const; |

1895 | |

1896 | /// Test for a type which does not represent an actual type-system type but |

1897 | /// is instead used as a placeholder for various convenient purposes within |

1898 | /// Clang. All such types are BuiltinTypes. |

1899 | bool isPlaceholderType() const; |

1900 | const BuiltinType *getAsPlaceholderType() const; |

1901 | |

1902 | /// Test for a specific placeholder type. |

1903 | bool isSpecificPlaceholderType(unsigned K) const; |

1904 | |

1905 | /// Test for a placeholder type other than Overload; see |

1906 | /// BuiltinType::isNonOverloadPlaceholderType. |

1907 | bool isNonOverloadPlaceholderType() const; |

1908 | |

1909 | /// isIntegerType() does *not* include complex integers (a GCC extension). |

1910 | /// isComplexIntegerType() can be used to test for complex integers. |

1911 | bool isIntegerType() const; // C99 6.2.5p17 (int, char, bool, enum) |

1912 | bool isEnumeralType() const; |

1913 | |

1914 | /// Determine whether this type is a scoped enumeration type. |

1915 | bool isScopedEnumeralType() const; |

1916 | bool isBooleanType() const; |

1917 | bool isCharType() const; |

1918 | bool isWideCharType() const; |

1919 | bool isChar8Type() const; |

1920 | bool isChar16Type() const; |

1921 | bool isChar32Type() const; |

1922 | bool isAnyCharacterType() const; |

1923 | bool isIntegralType(const ASTContext &Ctx) const; |

1924 | |

1925 | /// Determine whether this type is an integral or enumeration type. |

1926 | bool isIntegralOrEnumerationType() const; |

1927 | |

1928 | /// Determine whether this type is an integral or unscoped enumeration type. |

1929 | bool isIntegralOrUnscopedEnumerationType() const; |

1930 | |

1931 | /// Floating point categories. |

1932 | bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double) |

1933 | /// isComplexType() does *not* include complex integers (a GCC extension). |

1934 | /// isComplexIntegerType() can be used to test for complex integers. |

1935 | bool isComplexType() const; // C99 6.2.5p11 (complex) |

1936 | bool isAnyComplexType() const; // C99 6.2.5p11 (complex) + Complex Int. |

1937 | bool isFloatingType() const; // C99 6.2.5p11 (real floating + complex) |

1938 | bool isHalfType() const; // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half) |

1939 | bool isFloat16Type() const; // C11 extension ISO/IEC TS 18661 |

1940 | bool isFloat128Type() const; |

1941 | bool isRealType() const; // C99 6.2.5p17 (real floating + integer) |

1942 | bool isArithmeticType() const; // C99 6.2.5p18 (integer + floating) |

1943 | bool isVoidType() const; // C99 6.2.5p19 |

1944 | bool isScalarType() const; // C99 6.2.5p21 (arithmetic + pointers) |

1945 | bool isAggregateType() const; |

1946 | bool isFundamentalType() const; |

1947 | bool isCompoundType() const; |

1948 | |

1949 | // Type Predicates: Check to see if this type is structurally the specified |

1950 | // type, ignoring typedefs and qualifiers. |

1951 | bool isFunctionType() const; |

1952 | bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); } |

1953 | bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); } |

1954 | bool isPointerType() const; |

1955 | bool isAnyPointerType() const; // Any C pointer or ObjC object pointer |

1956 | bool isBlockPointerType() const; |

1957 | bool isVoidPointerType() const; |

1958 | bool isReferenceType() const; |

1959 | bool isLValueReferenceType() const; |

1960 | bool isRValueReferenceType() const; |

1961 | bool isFunctionPointerType() const; |

1962 | bool isMemberPointerType() const; |

1963 | bool isMemberFunctionPointerType() const; |

1964 | bool isMemberDataPointerType() const; |

1965 | bool isArrayType() const; |

1966 | bool isConstantArrayType() const; |

1967 | bool isIncompleteArrayType() const; |

1968 | bool isVariableArrayType() const; |

1969 | bool isDependentSizedArrayType() const; |

1970 | bool isRecordType() const; |

1971 | bool isClassType() const; |

1972 | bool isStructureType() const; |

1973 | bool isObjCBoxableRecordType() const; |

1974 | bool isInterfaceType() const; |

1975 | bool isStructureOrClassType() const; |

1976 | bool isUnionType() const; |

1977 | bool isComplexIntegerType() const; // GCC _Complex integer type. |

1978 | bool isVectorType() const; // GCC vector type. |

1979 | bool isExtVectorType() const; // Extended vector type. |

1980 | bool isDependentAddressSpaceType() const; // value-dependent address space qualifier |

1981 | bool isObjCObjectPointerType() const; // pointer to ObjC object |

1982 | bool isObjCRetainableType() const; // ObjC object or block pointer |

1983 | bool isObjCLifetimeType() const; // (array of)* retainable type |

1984 | bool isObjCIndirectLifetimeType() const; // (pointer to)* lifetime type |

1985 | bool isObjCNSObjectType() const; // __attribute__((NSObject)) |

1986 | bool isObjCIndependentClassType() const; // __attribute__((objc_independent_class)) |

1987 | // FIXME: change this to 'raw' interface type, so we can used 'interface' type |

1988 | // for the common case. |

1989 | bool isObjCObjectType() const; // NSString or typeof(*(id)0) |

1990 | bool isObjCQualifiedInterfaceType() const; // NSString<foo> |

1991 | bool isObjCQualifiedIdType() const; // id<foo> |

1992 | bool isObjCQualifiedClassType() const; // Class<foo> |

1993 | bool isObjCObjectOrInterfaceType() const; |

1994 | bool isObjCIdType() const; // id |

1995 | |

1996 | /// Was this type written with the special inert-in-ARC __unsafe_unretained |

1997 | /// qualifier? |

1998 | /// |

1999 | /// This approximates the answer to the following question: if this |

2000 | /// translation unit were compiled in ARC, would this type be qualified |

2001 | /// with __unsafe_unretained? |

2002 | bool isObjCInertUnsafeUnretainedType() const { |

2003 | return hasAttr(attr::ObjCInertUnsafeUnretained); |

2004 | } |

2005 | |

2006 | /// Whether the type is Objective-C 'id' or a __kindof type of an |

2007 | /// object type, e.g., __kindof NSView * or __kindof id |

2008 | /// <NSCopying>. |

2009 | /// |

2010 | /// \param bound Will be set to the bound on non-id subtype types, |

2011 | /// which will be (possibly specialized) Objective-C class type, or |

2012 | /// null for 'id. |

2013 | bool isObjCIdOrObjectKindOfType(const ASTContext &ctx, |

2014 | const ObjCObjectType *&bound) const; |

2015 | |

2016 | bool isObjCClassType() const; // Class |

2017 | |

2018 | /// Whether the type is Objective-C 'Class' or a __kindof type of an |

2019 | /// Class type, e.g., __kindof Class <NSCopying>. |

2020 | /// |

2021 | /// Unlike \c isObjCIdOrObjectKindOfType, there is no relevant bound |

2022 | /// here because Objective-C's type system cannot express "a class |

2023 | /// object for a subclass of NSFoo". |

2024 | bool isObjCClassOrClassKindOfType() const; |

2025 | |

2026 | bool isBlockCompatibleObjCPointerType(ASTContext &ctx) const; |

2027 | bool isObjCSelType() const; // Class |

2028 | bool isObjCBuiltinType() const; // 'id' or 'Class' |

2029 | bool isObjCARCBridgableType() const; |

2030 | bool isCARCBridgableType() const; |

2031 | bool isTemplateTypeParmType() const; // C++ template type parameter |

2032 | bool isNullPtrType() const; // C++11 std::nullptr_t |

2033 | bool isAlignValT() const; // C++17 std::align_val_t |

2034 | bool isStdByteType() const; // C++17 std::byte |

2035 | bool isAtomicType() const; // C11 _Atomic() |

2036 | |

2037 | #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ |

2038 | bool is##Id##Type() const; |

2039 | #include "clang/Basic/OpenCLImageTypes.def" |

2040 | |

2041 | bool isImageType() const; // Any OpenCL image type |

2042 | |

2043 | bool isSamplerT() const; // OpenCL sampler_t |

2044 | bool isEventT() const; // OpenCL event_t |

2045 | bool isClkEventT() const; // OpenCL clk_event_t |

2046 | bool isQueueT() const; // OpenCL queue_t |

2047 | bool isReserveIDT() const; // OpenCL reserve_id_t |

2048 | |

2049 | #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ |

2050 | bool is##Id##Type() const; |

2051 | #include "clang/Basic/OpenCLExtensionTypes.def" |

2052 | // Type defined in cl_intel_device_side_avc_motion_estimation OpenCL extension |

2053 | bool isOCLIntelSubgroupAVCType() const; |

2054 | bool isOCLExtOpaqueType() const; // Any OpenCL extension type |

2055 | |

2056 | bool isPipeType() const; // OpenCL pipe type |

2057 | bool isOpenCLSpecificType() const; // Any OpenCL specific type |

2058 | |

2059 | /// Determines if this type, which must satisfy |

2060 | /// isObjCLifetimeType(), is implicitly __unsafe_unretained rather |

2061 | /// than implicitly __strong. |

2062 | bool isObjCARCImplicitlyUnretainedType() const; |

2063 | |

2064 | /// Return the implicit lifetime for this type, which must not be dependent. |

2065 | Qualifiers::ObjCLifetime getObjCARCImplicitLifetime() const; |

2066 | |

2067 | enum ScalarTypeKind { |

2068 | STK_CPointer, |

2069 | STK_BlockPointer, |

2070 | STK_ObjCObjectPointer, |

2071 | STK_MemberPointer, |

2072 | STK_Bool, |

2073 | STK_Integral, |

2074 | STK_Floating, |

2075 | STK_IntegralComplex, |

2076 | STK_FloatingComplex, |

2077 | STK_FixedPoint |

2078 | }; |

2079 | |

2080 | /// Given that this is a scalar type, classify it. |

2081 | ScalarTypeKind getScalarTypeKind() const; |

2082 | |

2083 | /// Whether this type is a dependent type, meaning that its definition |

2084 | /// somehow depends on a template parameter (C++ [temp.dep.type]). |

2085 | bool isDependentType() const { return TypeBits.Dependent; } |

2086 | |

2087 | /// Determine whether this type is an instantiation-dependent type, |

2088 | /// meaning that the type involves a template parameter (even if the |

2089 | /// definition does not actually depend on the type substituted for that |

2090 | /// template parameter). |

2091 | bool isInstantiationDependentType() const { |

2092 | return TypeBits.InstantiationDependent; |

2093 | } |

2094 | |

2095 | /// Determine whether this type is an undeduced type, meaning that |

2096 | /// it somehow involves a C++11 'auto' type or similar which has not yet been |

2097 | /// deduced. |

2098 | bool isUndeducedType() const; |

2099 | |

2100 | /// Whether this type is a variably-modified type (C99 6.7.5). |

2101 | bool isVariablyModifiedType() const { return TypeBits.VariablyModified; } |

2102 | |

2103 | /// Whether this type involves a variable-length array type |

2104 | /// with a definite size. |

2105 | bool hasSizedVLAType() const; |

2106 | |

2107 | /// Whether this type is or contains a local or unnamed type. |

2108 | bool hasUnnamedOrLocalType() const; |

2109 | |

2110 | bool isOverloadableType() const; |

2111 | |

2112 | /// Determine wither this type is a C++ elaborated-type-specifier. |

2113 | bool isElaboratedTypeSpecifier() const; |

2114 | |

2115 | bool canDecayToPointerType() const; |

2116 | |

2117 | /// Whether this type is represented natively as a pointer. This includes |

2118 | /// pointers, references, block pointers, and Objective-C interface, |

2119 | /// qualified id, and qualified interface types, as well as nullptr_t. |

2120 | bool hasPointerRepresentation() const; |

2121 | |

2122 | /// Whether this type can represent an objective pointer type for the |

2123 | /// purpose of GC'ability |

2124 | bool hasObjCPointerRepresentation() const; |

2125 | |

2126 | /// Determine whether this type has an integer representation |

2127 | /// of some sort, e.g., it is an integer type or a vector. |

2128 | bool hasIntegerRepresentation() const; |

2129 | |

2130 | /// Determine whether this type has an signed integer representation |

2131 | /// of some sort, e.g., it is an signed integer type or a vector. |

2132 | bool hasSignedIntegerRepresentation() const; |

2133 | |

2134 | /// Determine whether this type has an unsigned integer representation |

2135 | /// of some sort, e.g., it is an unsigned integer type or a vector. |

2136 | bool hasUnsignedIntegerRepresentation() const; |

2137 | |

2138 | /// Determine whether this type has a floating-point representation |

2139 | /// of some sort, e.g., it is a floating-point type or a vector thereof. |

2140 | bool hasFloatingRepresentation() const; |

2141 | |

2142 | // Type Checking Functions: Check to see if this type is structurally the |

2143 | // specified type, ignoring typedefs and qualifiers, and return a pointer to |

2144 | // the best type we can. |

2145 | const RecordType *getAsStructureType() const; |

2146 | /// NOTE: getAs*ArrayType are methods on ASTContext. |

2147 | const RecordType *getAsUnionType() const; |

2148 | const ComplexType *getAsComplexIntegerType() const; // GCC complex int type. |

2149 | const ObjCObjectType *getAsObjCInterfaceType() const; |

2150 | |

2151 | // The following is a convenience method that returns an ObjCObjectPointerType |

2152 | // for object declared using an interface. |

2153 | const ObjCObjectPointerType *getAsObjCInterfacePointerType() const; |

2154 | const ObjCObjectPointerType *getAsObjCQualifiedIdType() const; |

2155 | const ObjCObjectPointerType *getAsObjCQualifiedClassType() const; |

2156 | const ObjCObjectType *getAsObjCQualifiedInterfaceType() const; |

2157 | |

2158 | /// Retrieves the CXXRecordDecl that this type refers to, either |

2159 | /// because the type is a RecordType or because it is the injected-class-name |

2160 | /// type of a class template or class template partial specialization. |

2161 | CXXRecordDecl *getAsCXXRecordDecl() const; |

2162 | |

2163 | /// Retrieves the RecordDecl this type refers to. |

2164 | RecordDecl *getAsRecordDecl() const; |

2165 | |

2166 | /// Retrieves the TagDecl that this type refers to, either |

2167 | /// because the type is a TagType or because it is the injected-class-name |

2168 | /// type of a class template or class template partial specialization. |

2169 | TagDecl *getAsTagDecl() const; |

2170 | |

2171 | /// If this is a pointer or reference to a RecordType, return the |

2172 | /// CXXRecordDecl that the type refers to. |

2173 | /// |

2174 | /// If this is not a pointer or reference, or the type being pointed to does |

2175 | /// not refer to a CXXRecordDecl, returns NULL. |

2176 | const CXXRecordDecl *getPointeeCXXRecordDecl() const; |

2177 | |

2178 | /// Get the DeducedType whose type will be deduced for a variable with |

2179 | /// an initializer of this type. This looks through declarators like pointer |

2180 | /// types, but not through decltype or typedefs. |

2181 | DeducedType *getContainedDeducedType() const; |

2182 | |

2183 | /// Get the AutoType whose type will be deduced for a variable with |

2184 | /// an initializer of this type. This looks through declarators like pointer |

2185 | /// types, but not through decltype or typedefs. |

2186 | AutoType *getContainedAutoType() const { |

2187 | return dyn_cast_or_null<AutoType>(getContainedDeducedType()); |

2188 | } |

2189 | |

2190 | /// Determine whether this type was written with a leading 'auto' |

2191 | /// corresponding to a trailing return type (possibly for a nested |

2192 | /// function type within a pointer to function type or similar). |

2193 | bool hasAutoForTrailingReturnType() const; |

2194 | |

2195 | /// Member-template getAs<specific type>'. Look through sugar for |

2196 | /// an instance of \<specific type>. This scheme will eventually |

2197 | /// replace the specific getAsXXXX methods above. |

2198 | /// |

2199 | /// There are some specializations of this member template listed |

2200 | /// immediately following this class. |

2201 | template <typename T> const T *getAs() const; |

2202 | |

2203 | /// Member-template getAsAdjusted<specific type>. Look through specific kinds |

2204 | /// of sugar (parens, attributes, etc) for an instance of \<specific type>. |

2205 | /// This is used when you need to walk over sugar nodes that represent some |

2206 | /// kind of type adjustment from a type that was written as a \<specific type> |

2207 | /// to another type that is still canonically a \<specific type>. |

2208 | template <typename T> const T *getAsAdjusted() const; |

2209 | |

2210 | /// A variant of getAs<> for array types which silently discards |

2211 | /// qualifiers from the outermost type. |

2212 | const ArrayType *getAsArrayTypeUnsafe() const; |

2213 | |

2214 | /// Member-template castAs<specific type>. Look through sugar for |

2215 | /// the underlying instance of \<specific type>. |

2216 | /// |

2217 | /// This method has the same relationship to getAs<T> as cast<T> has |

2218 | /// to dyn_cast<T>; which is to say, the underlying type *must* |

2219 | /// have the intended type, and this method will never return null. |

2220 | template <typename T> const T *castAs() const; |

2221 | |

2222 | /// A variant of castAs<> for array type which silently discards |

2223 | /// qualifiers from the outermost type. |

2224 | const ArrayType *castAsArrayTypeUnsafe() const; |

2225 | |

2226 | /// Determine whether this type had the specified attribute applied to it |

2227 | /// (looking through top-level type sugar). |

2228 | bool hasAttr(attr::Kind AK) const; |

2229 | |

2230 | /// Get the base element type of this type, potentially discarding type |

2231 | /// qualifiers. This should never be used when type qualifiers |

2232 | /// are meaningful. |

2233 | const Type *getBaseElementTypeUnsafe() const; |

2234 | |

2235 | /// If this is an array type, return the element type of the array, |

2236 | /// potentially with type qualifiers missing. |

2237 | /// This should never be used when type qualifiers are meaningful. |

2238 | const Type *getArrayElementTypeNoTypeQual() const; |

2239 | |

2240 | /// If this is a pointer type, return the pointee type. |

2241 | /// If this is an array type, return the array element type. |

2242 | /// This should never be used when type qualifiers are meaningful. |

2243 | const Type *getPointeeOrArrayElementType() const; |

2244 | |

2245 | /// If this is a pointer, ObjC object pointer, or block |

2246 | /// pointer, this returns the respective pointee. |

2247 | QualType getPointeeType() const; |

2248 | |

2249 | /// Return the specified type with any "sugar" removed from the type, |

2250 | /// removing any typedefs, typeofs, etc., as well as any qualifiers. |

2251 | const Type *getUnqualifiedDesugaredType() const; |

2252 | |

2253 | /// More type predicates useful for type checking/promotion |

2254 | bool isPromotableIntegerType() const; // C99 6.3.1.1p2 |

2255 | |

2256 | /// Return true if this is an integer type that is |

2257 | /// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], |

2258 | /// or an enum decl which has a signed representation. |

2259 | bool isSignedIntegerType() const; |

2260 | |

2261 | /// Return true if this is an integer type that is |

2262 | /// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], |

2263 | /// or an enum decl which has an unsigned representation. |

2264 | bool isUnsignedIntegerType() const; |

2265 | |

2266 | /// Determines whether this is an integer type that is signed or an |

2267 | /// enumeration types whose underlying type is a signed integer type. |

2268 | bool isSignedIntegerOrEnumerationType() const; |

2269 | |

2270 | /// Determines whether this is an integer type that is unsigned or an |

2271 | /// enumeration types whose underlying type is a unsigned integer type. |

2272 | bool isUnsignedIntegerOrEnumerationType() const; |

2273 | |

2274 | /// Return true if this is a fixed point type according to |

2275 | /// ISO/IEC JTC1 SC22 WG14 N1169. |

2276 | bool isFixedPointType() const; |

2277 | |

2278 | /// Return true if this is a saturated fixed point type according to |

2279 | /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned. |

2280 | bool isSaturatedFixedPointType() const; |

2281 | |

2282 | /// Return true if this is a saturated fixed point type according to |

2283 | /// ISO/IEC JTC1 SC22 WG14 N1169. This type can be signed or unsigned. |

2284 | bool isUnsaturatedFixedPointType() const; |

2285 | |

2286 | /// Return true if this is a fixed point type that is signed according |

2287 | /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated. |

2288 | bool isSignedFixedPointType() const; |

2289 | |

2290 | /// Return true if this is a fixed point type that is unsigned according |

2291 | /// to ISO/IEC JTC1 SC22 WG14 N1169. This type can also be saturated. |

2292 | bool isUnsignedFixedPointType() const; |

2293 | |

2294 | /// Return true if this is not a variable sized type, |

2295 | /// according to the rules of C99 6.7.5p3. It is not legal to call this on |

2296 | /// incomplete types. |

2297 | bool isConstantSizeType() const; |

2298 | |

2299 | /// Returns true if this type can be represented by some |

2300 | /// set of type specifiers. |

2301 | bool isSpecifierType() const; |

2302 | |

2303 | /// Determine the linkage of this type. |

2304 | Linkage getLinkage() const; |

2305 | |

2306 | /// Determine the visibility of this type. |

2307 | Visibility getVisibility() const { |

2308 | return getLinkageAndVisibility().getVisibility(); |

2309 | } |

2310 | |

2311 | /// Return true if the visibility was explicitly set is the code. |

2312 | bool isVisibilityExplicit() const { |

2313 | return getLinkageAndVisibility().isVisibilityExplicit(); |

2314 | } |

2315 | |

2316 | /// Determine the linkage and visibility of this type. |

2317 | LinkageInfo getLinkageAndVisibility() const; |

2318 | |

2319 | /// True if the computed linkage is valid. Used for consistency |

2320 | /// checking. Should always return true. |

2321 | bool isLinkageValid() const; |

2322 | |

2323 | /// Determine the nullability of the given type. |

2324 | /// |

2325 | /// Note that nullability is only captured as sugar within the type |

2326 | /// system, not as part of the canonical type, so nullability will |

2327 | /// be lost by canonicalization and desugaring. |

2328 | Optional<NullabilityKind> getNullability(const ASTContext &context) const; |

2329 | |

2330 | /// Determine whether the given type can have a nullability |

2331 | /// specifier applied to it, i.e., if it is any kind of pointer type. |

2332 | /// |

2333 | /// \param ResultIfUnknown The value to return if we don't yet know whether |

2334 | /// this type can have nullability because it is dependent. |

2335 | bool canHaveNullability(bool ResultIfUnknown = true) const; |

2336 | |

2337 | /// Retrieve the set of substitutions required when accessing a member |

2338 | /// of the Objective-C receiver type that is declared in the given context. |

2339 | /// |

2340 | /// \c *this is the type of the object we're operating on, e.g., the |

2341 | /// receiver for a message send or the base of a property access, and is |

2342 | /// expected to be of some object or object pointer type. |

2343 | /// |

2344 | /// \param dc The declaration context for which we are building up a |

2345 | /// substitution mapping, which should be an Objective-C class, extension, |

2346 | /// category, or method within. |

2347 | /// |

2348 | /// \returns an array of type arguments that can be substituted for |

2349 | /// the type parameters of the given declaration context in any type described |

2350 | /// within that context, or an empty optional to indicate that no |

2351 | /// substitution is required. |

2352 | Optional<ArrayRef<QualType>> |

2353 | getObjCSubstitutions(const DeclContext *dc) const; |

2354 | |

2355 | /// Determines if this is an ObjC interface type that may accept type |

2356 | /// parameters. |

2357 | bool acceptsObjCTypeParams() const; |

2358 | |

2359 | const char *getTypeClassName() const; |

2360 | |

2361 | QualType getCanonicalTypeInternal() const { |

2362 | return CanonicalType; |

2363 | } |

2364 | |

2365 | CanQualType getCanonicalTypeUnqualified() const; // in CanonicalType.h |

2366 | void dump() const; |

2367 | void dump(llvm::raw_ostream &OS) const; |

2368 | }; |

2369 | |

2370 | /// This will check for a TypedefType by removing any existing sugar |

2371 | /// until it reaches a TypedefType or a non-sugared type. |

2372 | template <> const TypedefType *Type::getAs() const; |

2373 | |

2374 | /// This will check for a TemplateSpecializationType by removing any |

2375 | /// existing sugar until it reaches a TemplateSpecializationType or a |

2376 | /// non-sugared type. |

2377 | template <> const TemplateSpecializationType *Type::getAs() const; |

2378 | |

2379 | /// This will check for an AttributedType by removing any existing sugar |

2380 | /// until it reaches an AttributedType or a non-sugared type. |

2381 | template <> const AttributedType *Type::getAs() const; |

2382 | |

2383 | // We can do canonical leaf types faster, because we don't have to |

2384 | // worry about preserving child type decoration. |

2385 | #define TYPE(Class, Base) |

2386 | #define LEAF_TYPE(Class) \ |

2387 | template <> inline const Class##Type *Type::getAs() const { \ |

2388 | return dyn_cast<Class##Type>(CanonicalType); \ |

2389 | } \ |

2390 | template <> inline const Class##Type *Type::castAs() const { \ |

2391 | return cast<Class##Type>(CanonicalType); \ |

2392 | } |

2393 | #include "clang/AST/TypeNodes.def" |

2394 | |

2395 | /// This class is used for builtin types like 'int'. Builtin |

2396 | /// types are always canonical and have a literal name field. |

2397 | class BuiltinType : public Type { |

2398 | public: |

2399 | enum Kind { |

2400 | // OpenCL image types |

2401 | #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) Id, |

2402 | #include "clang/Basic/OpenCLImageTypes.def" |

2403 | // OpenCL extension types |

2404 | #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) Id, |

2405 | #include "clang/Basic/OpenCLExtensionTypes.def" |

2406 | // All other builtin types |

2407 | #define BUILTIN_TYPE(Id, SingletonId) Id, |

2408 | #define LAST_BUILTIN_TYPE(Id) LastKind = Id |

2409 | #include "clang/AST/BuiltinTypes.def" |

2410 | }; |

2411 | |

2412 | private: |

2413 | friend class ASTContext; // ASTContext creates these. |

2414 | |

2415 | BuiltinType(Kind K) |

2416 | : Type(Builtin, QualType(), /*Dependent=*/(K == Dependent), |

2417 | /*InstantiationDependent=*/(K == Dependent), |

2418 | /*VariablyModified=*/false, |

2419 | /*Unexpanded parameter pack=*/false) { |

2420 | BuiltinTypeBits.Kind = K; |

2421 | } |

2422 | |

2423 | public: |

2424 | Kind getKind() const { return static_cast<Kind>(BuiltinTypeBits.Kind); } |

2425 | StringRef getName(const PrintingPolicy &Policy) const; |

2426 | |

2427 | const char *getNameAsCString(const PrintingPolicy &Policy) const { |

2428 | // The StringRef is null-terminated. |

2429 | StringRef str = getName(Policy); |

2430 | assert(!str.empty() && str.data()[str.size()] == '\0'); |

2431 | return str.data(); |

2432 | } |

2433 | |

2434 | bool isSugared() const { return false; } |

2435 | QualType desugar() const { return QualType(this, 0); } |

2436 | |

2437 | bool isInteger() const { |

2438 | return getKind() >= Bool && getKind() <= Int128; |

2439 | } |

2440 | |

2441 | bool isSignedInteger() const { |

2442 | return getKind() >= Char_S && getKind() <= Int128; |

2443 | } |

2444 | |

2445 | bool isUnsignedInteger() const { |

2446 | return getKind() >= Bool && getKind() <= UInt128; |

2447 | } |

2448 | |

2449 | bool isFloatingPoint() const { |

2450 | return getKind() >= Half && getKind() <= Float128; |

2451 | } |

2452 | |

2453 | /// Determines whether the given kind corresponds to a placeholder type. |

2454 | static bool isPlaceholderTypeKind(Kind K) { |

2455 | return K >= Overload; |

2456 | } |

2457 | |

2458 | /// Determines whether this type is a placeholder type, i.e. a type |

2459 | /// which cannot appear in arbitrary positions in a fully-formed |

2460 | /// expression. |

2461 | bool isPlaceholderType() const { |

2462 | return isPlaceholderTypeKind(getKind()); |

2463 | } |

2464 | |

2465 | /// Determines whether this type is a placeholder type other than |

2466 | /// Overload. Most placeholder types require only syntactic |

2467 | /// information about their context in order to be resolved (e.g. |

2468 | /// whether it is a call expression), which means they can (and |

2469 | /// should) be resolved in an earlier "phase" of analysis. |

2470 | /// Overload expressions sometimes pick up further information |

2471 | /// from their context, like whether the context expects a |

2472 | /// specific function-pointer type, and so frequently need |

2473 | /// special treatment. |

2474 | bool isNonOverloadPlaceholderType() const { |

2475 | return getKind() > Overload; |

2476 | } |

2477 | |

2478 | static bool classof(const Type *T) { return T->getTypeClass() == Builtin; } |

2479 | }; |

2480 | |

2481 | /// Complex values, per C99 6.2.5p11. This supports the C99 complex |

2482 | /// types (_Complex float etc) as well as the GCC integer complex extensions. |

2483 | class ComplexType : public Type, public llvm::FoldingSetNode { |

2484 | friend class ASTContext; // ASTContext creates these. |

2485 | |

2486 | QualType ElementType; |

2487 | |

2488 | ComplexType(QualType Element, QualType CanonicalPtr) |

2489 | : Type(Complex, CanonicalPtr, Element->isDependentType(), |

2490 | Element->isInstantiationDependentType(), |

2491 | Element->isVariablyModifiedType(), |

2492 | Element->containsUnexpandedParameterPack()), |

2493 | ElementType(Element) {} |

2494 | |

2495 | public: |

2496 | QualType getElementType() const { return ElementType; } |

2497 | |

2498 | bool isSugared() const { return false; } |

2499 | QualType desugar() const { return QualType(this, 0); } |

2500 | |

2501 | void Profile(llvm::FoldingSetNodeID &ID) { |

2502 | Profile(ID, getElementType()); |

2503 | } |

2504 | |

2505 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Element) { |

2506 | ID.AddPointer(Element.getAsOpaquePtr()); |

2507 | } |

2508 | |

2509 | static bool classof(const Type *T) { return T->getTypeClass() == Complex; } |

2510 | }; |

2511 | |

2512 | /// Sugar for parentheses used when specifying types. |

2513 | class ParenType : public Type, public llvm::FoldingSetNode { |

2514 | friend class ASTContext; // ASTContext creates these. |

2515 | |

2516 | QualType Inner; |

2517 | |

2518 | ParenType(QualType InnerType, QualType CanonType) |

2519 | : Type(Paren, CanonType, InnerType->isDependentType(), |

2520 | InnerType->isInstantiationDependentType(), |

2521 | InnerType->isVariablyModifiedType(), |

2522 | InnerType->containsUnexpandedParameterPack()), |

2523 | Inner(InnerType) {} |

2524 | |

2525 | public: |

2526 | QualType getInnerType() const { return Inner; } |

2527 | |

2528 | bool isSugared() const { return true; } |

2529 | QualType desugar() const { return getInnerType(); } |

2530 | |

2531 | void Profile(llvm::FoldingSetNodeID &ID) { |

2532 | Profile(ID, getInnerType()); |

2533 | } |

2534 | |

2535 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Inner) { |

2536 | Inner.Profile(ID); |

2537 | } |

2538 | |

2539 | static bool classof(const Type *T) { return T->getTypeClass() == Paren; } |

2540 | }; |

2541 | |

2542 | /// PointerType - C99 6.7.5.1 - Pointer Declarators. |

2543 | class PointerType : public Type, public llvm::FoldingSetNode { |

2544 | friend class ASTContext; // ASTContext creates these. |

2545 | |

2546 | QualType PointeeType; |

2547 | |

2548 | PointerType(QualType Pointee, QualType CanonicalPtr) |

2549 | : Type(Pointer, CanonicalPtr, Pointee->isDependentType(), |

2550 | Pointee->isInstantiationDependentType(), |

2551 | Pointee->isVariablyModifiedType(), |

2552 | Pointee->containsUnexpandedParameterPack()), |

2553 | PointeeType(Pointee) {} |

2554 | |

2555 | public: |

2556 | QualType getPointeeType() const { return PointeeType; } |

2557 | |

2558 | /// Returns true if address spaces of pointers overlap. |

2559 | /// OpenCL v2.0 defines conversion rules for pointers to different |

2560 | /// address spaces (OpenCLC v2.0 s6.5.5) and notion of overlapping |

2561 | /// address spaces. |

2562 | /// CL1.1 or CL1.2: |

2563 | /// address spaces overlap iff they are they same. |

2564 | /// CL2.0 adds: |

2565 | /// __generic overlaps with any address space except for __constant. |

2566 | bool isAddressSpaceOverlapping(const PointerType &other) const { |

2567 | Qualifiers thisQuals = PointeeType.getQualifiers(); |

2568 | Qualifiers otherQuals = other.getPointeeType().getQualifiers(); |

2569 | // Address spaces overlap if at least one of them is a superset of another |

2570 | return thisQuals.isAddressSpaceSupersetOf(otherQuals) || |

2571 | otherQuals.isAddressSpaceSupersetOf(thisQuals); |

2572 | } |

2573 | |

2574 | bool isSugared() const { return false; } |

2575 | QualType desugar() const { return QualType(this, 0); } |

2576 | |

2577 | void Profile(llvm::FoldingSetNodeID &ID) { |

2578 | Profile(ID, getPointeeType()); |

2579 | } |

2580 | |

2581 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) { |

2582 | ID.AddPointer(Pointee.getAsOpaquePtr()); |

2583 | } |

2584 | |

2585 | static bool classof(const Type *T) { return T->getTypeClass() == Pointer; } |

2586 | }; |

2587 | |

2588 | /// Represents a type which was implicitly adjusted by the semantic |

2589 | /// engine for arbitrary reasons. For example, array and function types can |

2590 | /// decay, and function types can have their calling conventions adjusted. |

2591 | class AdjustedType : public Type, public llvm::FoldingSetNode { |

2592 | QualType OriginalTy; |

2593 | QualType AdjustedTy; |

2594 | |

2595 | protected: |

2596 | friend class ASTContext; // ASTContext creates these. |

2597 | |

2598 | AdjustedType(TypeClass TC, QualType OriginalTy, QualType AdjustedTy, |

2599 | QualType CanonicalPtr) |

2600 | : Type(TC, CanonicalPtr, OriginalTy->isDependentType(), |

2601 | OriginalTy->isInstantiationDependentType(), |

2602 | OriginalTy->isVariablyModifiedType(), |

2603 | OriginalTy->containsUnexpandedParameterPack()), |

2604 | OriginalTy(OriginalTy), AdjustedTy(AdjustedTy) {} |

2605 | |

2606 | public: |

2607 | QualType getOriginalType() const { return OriginalTy; } |

2608 | QualType getAdjustedType() const { return AdjustedTy; } |

2609 | |

2610 | bool isSugared() const { return true; } |

2611 | QualType desugar() const { return AdjustedTy; } |

2612 | |

2613 | void Profile(llvm::FoldingSetNodeID &ID) { |

2614 | Profile(ID, OriginalTy, AdjustedTy); |

2615 | } |

2616 | |

2617 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Orig, QualType New) { |

2618 | ID.AddPointer(Orig.getAsOpaquePtr()); |

2619 | ID.AddPointer(New.getAsOpaquePtr()); |

2620 | } |

2621 | |

2622 | static bool classof(const Type *T) { |

2623 | return T->getTypeClass() == Adjusted || T->getTypeClass() == Decayed; |

2624 | } |

2625 | }; |

2626 | |

2627 | /// Represents a pointer type decayed from an array or function type. |

2628 | class DecayedType : public AdjustedType { |

2629 | friend class ASTContext; // ASTContext creates these. |

2630 | |

2631 | inline |

2632 | DecayedType(QualType OriginalType, QualType Decayed, QualType Canonical); |

2633 | |

2634 | public: |

2635 | QualType getDecayedType() const { return getAdjustedType(); } |

2636 | |

2637 | inline QualType getPointeeType() const; |

2638 | |

2639 | static bool classof(const Type *T) { return T->getTypeClass() == Decayed; } |

2640 | }; |

2641 | |

2642 | /// Pointer to a block type. |

2643 | /// This type is to represent types syntactically represented as |

2644 | /// "void (^)(int)", etc. Pointee is required to always be a function type. |

2645 | class BlockPointerType : public Type, public llvm::FoldingSetNode { |

2646 | friend class ASTContext; // ASTContext creates these. |

2647 | |

2648 | // Block is some kind of pointer type |

2649 | QualType PointeeType; |

2650 | |

2651 | BlockPointerType(QualType Pointee, QualType CanonicalCls) |

2652 | : Type(BlockPointer, CanonicalCls, Pointee->isDependentType(), |

2653 | Pointee->isInstantiationDependentType(), |

2654 | Pointee->isVariablyModifiedType(), |

2655 | Pointee->containsUnexpandedParameterPack()), |

2656 | PointeeType(Pointee) {} |

2657 | |

2658 | public: |

2659 | // Get the pointee type. Pointee is required to always be a function type. |

2660 | QualType getPointeeType() const { return PointeeType; } |

2661 | |

2662 | bool isSugared() const { return false; } |

2663 | QualType desugar() const { return QualType(this, 0); } |

2664 | |

2665 | void Profile(llvm::FoldingSetNodeID &ID) { |

2666 | Profile(ID, getPointeeType()); |

2667 | } |

2668 | |

2669 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee) { |

2670 | ID.AddPointer(Pointee.getAsOpaquePtr()); |

2671 | } |

2672 | |

2673 | static bool classof(const Type *T) { |

2674 | return T->getTypeClass() == BlockPointer; |

2675 | } |

2676 | }; |

2677 | |

2678 | /// Base for LValueReferenceType and RValueReferenceType |

2679 | class ReferenceType : public Type, public llvm::FoldingSetNode { |

2680 | QualType PointeeType; |

2681 | |

2682 | protected: |

2683 | ReferenceType(TypeClass tc, QualType Referencee, QualType CanonicalRef, |

2684 | bool SpelledAsLValue) |

2685 | : Type(tc, CanonicalRef, Referencee->isDependentType(), |

2686 | Referencee->isInstantiationDependentType(), |

2687 | Referencee->isVariablyModifiedType(), |

2688 | Referencee->containsUnexpandedParameterPack()), |

2689 | PointeeType(Referencee) { |

2690 | ReferenceTypeBits.SpelledAsLValue = SpelledAsLValue; |

2691 | ReferenceTypeBits.InnerRef = Referencee->isReferenceType(); |

2692 | } |

2693 | |

2694 | public: |

2695 | bool isSpelledAsLValue() const { return ReferenceTypeBits.SpelledAsLValue; } |

2696 | bool isInnerRef() const { return ReferenceTypeBits.InnerRef; } |

2697 | |

2698 | QualType getPointeeTypeAsWritten() const { return PointeeType; } |

2699 | |

2700 | QualType getPointeeType() const { |

2701 | // FIXME: this might strip inner qualifiers; okay? |

2702 | const ReferenceType *T = this; |

2703 | while (T->isInnerRef()) |

2704 | T = T->PointeeType->castAs<ReferenceType>(); |

2705 | return T->PointeeType; |

2706 | } |

2707 | |

2708 | void Profile(llvm::FoldingSetNodeID &ID) { |

2709 | Profile(ID, PointeeType, isSpelledAsLValue()); |

2710 | } |

2711 | |

2712 | static void Profile(llvm::FoldingSetNodeID &ID, |

2713 | QualType Referencee, |

2714 | bool SpelledAsLValue) { |

2715 | ID.AddPointer(Referencee.getAsOpaquePtr()); |

2716 | ID.AddBoolean(SpelledAsLValue); |

2717 | } |

2718 | |

2719 | static bool classof(const Type *T) { |

2720 | return T->getTypeClass() == LValueReference || |

2721 | T->getTypeClass() == RValueReference; |

2722 | } |

2723 | }; |

2724 | |

2725 | /// An lvalue reference type, per C++11 [dcl.ref]. |

2726 | class LValueReferenceType : public ReferenceType { |

2727 | friend class ASTContext; // ASTContext creates these |

2728 | |

2729 | LValueReferenceType(QualType Referencee, QualType CanonicalRef, |

2730 | bool SpelledAsLValue) |

2731 | : ReferenceType(LValueReference, Referencee, CanonicalRef, |

2732 | SpelledAsLValue) {} |

2733 | |

2734 | public: |

2735 | bool isSugared() const { return false; } |

2736 | QualType desugar() const { return QualType(this, 0); } |

2737 | |

2738 | static bool classof(const Type *T) { |

2739 | return T->getTypeClass() == LValueReference; |

2740 | } |

2741 | }; |

2742 | |

2743 | /// An rvalue reference type, per C++11 [dcl.ref]. |

2744 | class RValueReferenceType : public ReferenceType { |

2745 | friend class ASTContext; // ASTContext creates these |

2746 | |

2747 | RValueReferenceType(QualType Referencee, QualType CanonicalRef) |

2748 | : ReferenceType(RValueReference, Referencee, CanonicalRef, false) {} |

2749 | |

2750 | public: |

2751 | bool isSugared() const { return false; } |

2752 | QualType desugar() const { return QualType(this, 0); } |

2753 | |

2754 | static bool classof(const Type *T) { |

2755 | return T->getTypeClass() == RValueReference; |

2756 | } |

2757 | }; |

2758 | |

2759 | /// A pointer to member type per C++ 8.3.3 - Pointers to members. |

2760 | /// |

2761 | /// This includes both pointers to data members and pointer to member functions. |

2762 | class MemberPointerType : public Type, public llvm::FoldingSetNode { |

2763 | friend class ASTContext; // ASTContext creates these. |

2764 | |

2765 | QualType PointeeType; |

2766 | |

2767 | /// The class of which the pointee is a member. Must ultimately be a |

2768 | /// RecordType, but could be a typedef or a template parameter too. |

2769 | const Type *Class; |

2770 | |

2771 | MemberPointerType(QualType Pointee, const Type *Cls, QualType CanonicalPtr) |

2772 | : Type(MemberPointer, CanonicalPtr, |

2773 | Cls->isDependentType() || Pointee->isDependentType(), |

2774 | (Cls->isInstantiationDependentType() || |

2775 | Pointee->isInstantiationDependentType()), |

2776 | Pointee->isVariablyModifiedType(), |

2777 | (Cls->containsUnexpandedParameterPack() || |

2778 | Pointee->containsUnexpandedParameterPack())), |

2779 | PointeeType(Pointee), Class(Cls) {} |

2780 | |

2781 | public: |

2782 | QualType getPointeeType() const { return PointeeType; } |

2783 | |

2784 | /// Returns true if the member type (i.e. the pointee type) is a |

2785 | /// function type rather than a data-member type. |

2786 | bool isMemberFunctionPointer() const { |

2787 | return PointeeType->isFunctionProtoType(); |

2788 | } |

2789 | |

2790 | /// Returns true if the member type (i.e. the pointee type) is a |

2791 | /// data type rather than a function type. |

2792 | bool isMemberDataPointer() const { |

2793 | return !PointeeType->isFunctionProtoType(); |

2794 | } |

2795 | |

2796 | const Type *getClass() const { return Class; } |

2797 | CXXRecordDecl *getMostRecentCXXRecordDecl() const; |

2798 | |

2799 | bool isSugared() const { return false; } |

2800 | QualType desugar() const { return QualType(this, 0); } |

2801 | |

2802 | void Profile(llvm::FoldingSetNodeID &ID) { |

2803 | Profile(ID, getPointeeType(), getClass()); |

2804 | } |

2805 | |

2806 | static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee, |

2807 | const Type *Class) { |

2808 | ID.AddPointer(Pointee.getAsOpaquePtr()); |

2809 | ID.AddPointer(Class); |

2810 | } |

2811 | |

2812 | static bool classof(const Type *T) { |

2813 | return T->getTypeClass() == MemberPointer; |

2814 | } |

2815 | }; |

2816 | |

2817 | /// Represents an array type, per C99 6.7.5.2 - Array Declarators. |

2818 | class ArrayType : public Type, public llvm::FoldingSetNode { |

2819 | public: |

2820 | /// Capture whether this is a normal array (e.g. int X[4]) |

2821 | /// an array with a static size (e.g. int X[static 4]), or an array |

2822 | /// with a star size (e.g. int X[*]). |

2823 | /// 'static' is only allowed on function parameters. |

2824 | enum ArraySizeModifier { |

2825 | Normal, Static, Star |

2826 | }; |

2827 | |

2828 | private: |

2829 | /// The element type of the array. |

2830 | QualType ElementType; |

2831 | |

2832 | protected: |

2833 | friend class ASTContext; // ASTContext creates these. |

2834 | |

2835 | // C++ [temp.dep.type]p1: |

2836 | // A type is dependent if it is... |

2837 | // - an array type constructed from any dependent type or whose |

2838 | // size is specified by a constant expression that is |

2839 | // value-dependent, |

2840 | ArrayType(TypeClass tc, QualType et, QualType can, |

2841 | ArraySizeModifier sm, unsigned tq, |

2842 | bool ContainsUnexpandedParameterPack) |

2843 | : Type(tc, can, et->isDependentType() || tc == DependentSizedArray, |

2844 | et->isInstantiationDependentType() || tc == DependentSizedArray, |

2845 | (tc == VariableArray || et->isVariablyModifiedType()), |

2846 | ContainsUnexpandedParameterPack), |

2847 | ElementType(et) { |

2848 | ArrayTypeBits.IndexTypeQuals = tq; |

2849 | ArrayTypeBits.SizeModifier = sm; |

2850 | } |

2851 | |

2852 | public: |

2853 | QualType getElementType() const { return ElementType; } |

2854 | |

2855 | ArraySizeModifier getSizeModifier() const { |

2856 | return ArraySizeModifier(ArrayTypeBits.SizeModifier); |

2857 | } |

2858 | |

2859 | Qualifiers getIndexTypeQualifiers() const { |

2860 | return Qualifiers::fromCVRMask(getIndexTypeCVRQualifiers()); |

2861 | } |

2862 | |

2863 | unsigned getIndexTypeCVRQualifiers() const { |

2864 | return ArrayTypeBits.IndexTypeQuals; |

2865 | } |

2866 | |

2867 | static bool classof(const Type *T) { |

2868 | return T->getTypeClass() == ConstantArray || |

2869 | T->getTypeClass() == VariableArray || |

2870 | T->getTypeClass() == IncompleteArray || |

2871 | T->getTypeClass() == DependentSizedArray; |

2872 | } |

2873 | }; |

2874 | |

2875 | /// Represents the canonical version of C arrays with a specified constant size. |

2876 | /// For example, the canonical type for 'int A[4 + 4*100]' is a |

2877 | /// ConstantArrayType where the element type is 'int' and the size is 404. |

2878 | class ConstantArrayType : public ArrayType { |

2879 | llvm::APInt Size; // Allows us to unique the type. |

2880 | |

2881 | ConstantArrayType(QualType et, QualType can, const llvm::APInt &size, |

2882 | ArraySizeModifier sm, unsigned tq) |

2883 | : ArrayType(ConstantArray, et, can, sm, tq, |

2884 | et->containsUnexpandedParameterPack()), |

2885 | Size(size) {} |

2886 | |

2887 | protected: |

2888 | friend class ASTContext; // ASTContext creates these. |

2889 | |

2890 | ConstantArrayType(TypeClass tc, QualType et, QualType can, |

2891 | const llvm::APInt &size, ArraySizeModifier sm, unsigned tq) |

2892 | : ArrayType(tc, et, can, sm, tq, et->containsUnexpandedParameterPack()), |

2893 | Size(size) {} |

2894 | |

2895 | public: |

2896 | const llvm::APInt &getSize() const { return Size; } |

2897 | bool isSugared() const { return false; } |

2898 | QualType desugar() const { return QualType(this, 0); } |

2899 | |

2900 | /// Determine the number of bits required to address a member of |

2901 | // an array with the given element type and number of elements. |

2902 | static unsigned getNumAddressingBits(const ASTContext &Context, |

2903 | QualType ElementType, |

2904 | const llvm::APInt &NumElements); |

2905 | |

2906 | /// Determine the maximum number of active bits that an array's size |

2907 | /// can require, which limits the maximum size of the array. |

2908 | static unsigned getMaxSizeBits(const ASTContext &Context); |

2909 | |

2910 | void Profile(llvm::FoldingSetNodeID &ID) { |

2911 | Profile(ID, getElementType(), getSize(), |

2912 | getSizeModifier(), getIndexTypeCVRQualifiers()); |

2913 | } |

2914 | |

2915 | static void Profile(llvm::FoldingSetNodeID &ID, QualType ET, |

2916 | const llvm::APInt &ArraySize, ArraySizeModifier SizeMod, |

2917 | unsigned TypeQuals) { |

2918 | ID.AddPointer(ET.getAsOpaquePtr()); |

2919 | ID.AddInteger(ArraySize.getZExtValue()); |

2920 | ID.AddInteger(SizeMod); |

2921 | ID.AddInteger(TypeQuals); |

2922 | } |

2923 | |

2924 | static bool classof(const Type *T) { |

2925 | return T->getTypeClass() == ConstantArray; |

2926 | } |

2927 | }; |

2928 | |

2929 | /// Represents a C array with an unspecified size. For example 'int A[]' has |

2930 | /// an IncompleteArrayType where the element type is 'int' and the size is |

2931 | /// unspecified. |

2932 | class IncompleteArrayType : public ArrayType { |

2933 | friend class ASTContext; // ASTContext creates these. |

2934 | |

2935 | IncompleteArrayType(QualType et, QualType can, |

2936 | ArraySizeModifier sm, unsigned tq) |

2937 | : ArrayType(IncompleteArray, et, can, sm, tq, |

2938 | et->containsUnexpandedParameterPack()) {} |

2939 | |

2940 | public: |

2941 | friend class StmtIteratorBase; |

2942 | |

2943 | bool isSugared() const { return false; } |

2944 | QualType desugar() const { return QualType(this, 0); } |

2945 | |

2946 | static bool classof(const Type *T) { |

2947 | return T->getTypeClass() == IncompleteArray; |

2948 | } |

2949 | |

2950 | void Profile(llvm::FoldingSetNodeID &ID) { |

2951 | Profile(ID, getElementType(), getSizeModifier(), |

2952 | getIndexTypeCVRQualifiers()); |

2953 | } |

2954 | |

2955 | static void Profile(llvm::FoldingSetNodeID &ID, QualType ET, |

2956 | ArraySizeModifier SizeMod, unsigned TypeQuals) { |

2957 | ID.AddPointer(ET.getAsOpaquePtr()); |

2958 | ID.AddInteger(SizeMod); |

2959 | ID.AddInteger(TypeQuals); |

2960 | } |

2961 | }; |

2962 | |

2963 | /// Represents a C array with a specified size that is not an |

2964 | /// integer-constant-expression. For example, 'int s[x+foo()]'. |

2965 | /// Since the size expression is an arbitrary expression, we store it as such. |

2966 | /// |

2967 | /// Note: VariableArrayType's aren't uniqued (since the expressions aren't) and |

2968 | /// should not be: two lexically equivalent variable array types could mean |

2969 | /// different things, for example, these variables do not have the same type |

2970 | /// dynamically: |

2971 | /// |

2972 | /// void foo(int x) { |

2973 | /// int Y[x]; |

2974 | /// ++x; |

2975 | /// int Z[x]; |

2976 | /// } |

2977 | class VariableArrayType : public ArrayType { |

2978 | friend class ASTContext; // ASTContext creates these. |

2979 | |

2980 | /// An assignment-expression. VLA's are only permitted within |

2981 | /// a function block. |

2982 | Stmt *SizeExpr; |

2983 | |

2984 | /// The range spanned by the left and right array brackets. |

2985 | SourceRange Brackets; |

2986 | |

2987 | VariableArrayType(QualType et, QualType can, Expr *e, |

2988 | ArraySizeModifier sm, unsigned tq, |

2989 | SourceRange brackets) |

2990 | : ArrayType(VariableArray, et, can, sm, tq, |

2991 | et->containsUnexpandedParameterPack()), |

2992 | SizeExpr((Stmt*) e), Brackets(brackets) {} |

2993 | |

2994 | public: |

2995 | friend class StmtIteratorBase; |

2996 | |

2997 | Expr *getSizeExpr() const { |

2998 | // We use C-style casts instead of cast<> here because we do not wish |

2999 | // to have a dependency of Type.h on Stmt.h/Expr.h. |

3000 | return (Expr*) SizeExpr; |

3001 | } |

3002 | |

3003 | SourceRange getBracketsRange() const { return Brackets; } |

3004 | SourceLocation getLBracketLoc() const { return Brackets.getBegin(); } |

3005 | SourceLocation getRBracketLoc() const { return Brackets.getEnd(); } |

3006 | |

3007 | bool isSugared() const { return false; } |

3008 | QualType desugar() const { return QualType(this, 0); } |

3009 | |

3010 | static bool classof(const Type *T) { |

3011 | return T->getTypeClass() == VariableArray; |

3012 | } |

3013 | |

3014 | void Profile(llvm::FoldingSetNodeID &ID) { |

3015 | llvm_unreachable("Cannot unique VariableArrayTypes."); |

3016 | } |

3017 | }; |

3018 | |

3019 | /// Represents an array type in C++ whose size is a value-dependent expression. |

3020 | /// |

3021 | /// For example: |

3022 | /// \code |

3023 | /// template<typename T, int Size> |

3024 | /// class array { |

3025 | /// T data[Size]; |

3026 | /// }; |

3027 | /// \endcode |

3028 | /// |

3029 | /// For these types, we won't actually know what the array bound is |

3030 | /// until template instantiation occurs, at which point this will |

3031 | /// become either a ConstantArrayType or a VariableArrayType. |

3032 | class DependentSizedArrayType : public ArrayType { |

3033 | friend class ASTContext; // ASTContext creates these. |

3034 | |

3035 | const ASTContext &Context; |

3036 | |

3037 | /// An assignment expression that will instantiate to the |

3038 | /// size of the array. |

3039 | /// |

3040 | /// The expression itself might be null, in which case the array |

3041 | /// type will have its size deduced from an initializer. |

3042 | Stmt *SizeExpr; |

3043 | |

3044 | /// The range spanned by the left and right array brackets. |

3045 | SourceRange Brackets; |

3046 | |

3047 | DependentSizedArrayType(const ASTContext &Context, QualType et, QualType can, |

3048 | Expr *e, ArraySizeModifier sm, unsigned tq, |

3049 | SourceRange brackets); |

3050 | |

3051 | public: |

3052 | friend class StmtIteratorBase; |

3053 | |

3054 | Expr *getSizeExpr() const { |

3055 | // We use C-style casts instead of cast<> here because we do not wish |

3056 | // to have a dependency of Type.h on Stmt.h/Expr.h. |

3057 | return (Expr*) SizeExpr; |

3058 | } |

3059 | |

3060 | SourceRange getBracketsRange() const { return Brackets; } |

3061 | SourceLocation getLBracketLoc() const { return Brackets.getBegin(); } |

3062 | SourceLocation getRBracketLoc() const { return Brackets.getEnd(); } |

3063 | |

3064 | bool isSugared() const { return false; } |

3065 | QualType desugar() const { return QualType(this, 0); } |

3066 | |

3067 | static bool classof(const Type *T) { |

3068 | return T->getTypeClass() == DependentSizedArray; |

3069 | } |

3070 | |

3071 | void Profile(llvm::FoldingSetNodeID &ID) { |

3072 | Profile(ID, Context, getElementType(), |

3073 | getSizeModifier(), getIndexTypeCVRQualifiers(), getSizeExpr()); |

3074 | } |

3075 | |

3076 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, |

3077 | QualType ET, ArraySizeModifier SizeMod, |

3078 | unsigned TypeQuals, Expr *E); |

3079 | }; |

3080 | |

3081 | /// Represents an extended address space qualifier where the input address space |

3082 | /// value is dependent. Non-dependent address spaces are not represented with a |

3083 | /// special Type subclass; they are stored on an ExtQuals node as part of a QualType. |

3084 | /// |

3085 | /// For example: |

3086 | /// \code |

3087 | /// template<typename T, int AddrSpace> |

3088 | /// class AddressSpace { |

3089 | /// typedef T __attribute__((address_space(AddrSpace))) type; |

3090 | /// } |

3091 | /// \endcode |

3092 | class DependentAddressSpaceType : public Type, public llvm::FoldingSetNode { |

3093 | friend class ASTContext; |

3094 | |

3095 | const ASTContext &Context; |

3096 | Expr *AddrSpaceExpr; |

3097 | QualType PointeeType; |

3098 | SourceLocation loc; |

3099 | |

3100 | DependentAddressSpaceType(const ASTContext &Context, QualType PointeeType, |

3101 | QualType can, Expr *AddrSpaceExpr, |

3102 | SourceLocation loc); |

3103 | |

3104 | public: |

3105 | Expr *getAddrSpaceExpr() const { return AddrSpaceExpr; } |

3106 | QualType getPointeeType() const { return PointeeType; } |

3107 | SourceLocation getAttributeLoc() const { return loc; } |

3108 | |

3109 | bool isSugared() const { return false; } |

3110 | QualType desugar() const { return QualType(this, 0); } |

3111 | |

3112 | static bool classof(const Type *T) { |

3113 | return T->getTypeClass() == DependentAddressSpace; |

3114 | } |

3115 | |

3116 | void Profile(llvm::FoldingSetNodeID &ID) { |

3117 | Profile(ID, Context, getPointeeType(), getAddrSpaceExpr()); |

3118 | } |

3119 | |

3120 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, |

3121 | QualType PointeeType, Expr *AddrSpaceExpr); |

3122 | }; |

3123 | |

3124 | /// Represents an extended vector type where either the type or size is |

3125 | /// dependent. |

3126 | /// |

3127 | /// For example: |

3128 | /// \code |

3129 | /// template<typename T, int Size> |

3130 | /// class vector { |

3131 | /// typedef T __attribute__((ext_vector_type(Size))) type; |

3132 | /// } |

3133 | /// \endcode |

3134 | class DependentSizedExtVectorType : public Type, public llvm::FoldingSetNode { |

3135 | friend class ASTContext; |

3136 | |

3137 | const ASTContext &Context; |

3138 | Expr *SizeExpr; |

3139 | |

3140 | /// The element type of the array. |

3141 | QualType ElementType; |

3142 | |

3143 | SourceLocation loc; |

3144 | |

3145 | DependentSizedExtVectorType(const ASTContext &Context, QualType ElementType, |

3146 | QualType can, Expr *SizeExpr, SourceLocation loc); |

3147 | |

3148 | public: |

3149 | Expr *getSizeExpr() const { return SizeExpr; } |

3150 | QualType getElementType() const { return ElementType; } |

3151 | SourceLocation getAttributeLoc() const { return loc; } |

3152 | |

3153 | bool isSugared() const { return false; } |

3154 | QualType desugar() const { return QualType(this, 0); } |

3155 | |

3156 | static bool classof(const Type *T) { |

3157 | return T->getTypeClass() == DependentSizedExtVector; |

3158 | } |

3159 | |

3160 | void Profile(llvm::FoldingSetNodeID &ID) { |

3161 | Profile(ID, Context, getElementType(), getSizeExpr()); |

3162 | } |

3163 | |

3164 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, |

3165 | QualType ElementType, Expr *SizeExpr); |

3166 | }; |

3167 | |

3168 | |

3169 | /// Represents a GCC generic vector type. This type is created using |

3170 | /// __attribute__((vector_size(n)), where "n" specifies the vector size in |

3171 | /// bytes; or from an Altivec __vector or vector declaration. |

3172 | /// Since the constructor takes the number of vector elements, the |

3173 | /// client is responsible for converting the size into the number of elements. |

3174 | class VectorType : public Type, public llvm::FoldingSetNode { |

3175 | public: |

3176 | enum VectorKind { |

3177 | /// not a target-specific vector type |

3178 | GenericVector, |

3179 | |

3180 | /// is AltiVec vector |

3181 | AltiVecVector, |

3182 | |

3183 | /// is AltiVec 'vector Pixel' |

3184 | AltiVecPixel, |

3185 | |

3186 | /// is AltiVec 'vector bool ...' |

3187 | AltiVecBool, |

3188 | |

3189 | /// is ARM Neon vector |

3190 | NeonVector, |

3191 | |

3192 | /// is ARM Neon polynomial vector |

3193 | NeonPolyVector |

3194 | }; |

3195 | |

3196 | protected: |

3197 | friend class ASTContext; // ASTContext creates these. |

3198 | |

3199 | /// The element type of the vector. |

3200 | QualType ElementType; |

3201 | |

3202 | VectorType(QualType vecType, unsigned nElements, QualType canonType, |

3203 | VectorKind vecKind); |

3204 | |

3205 | VectorType(TypeClass tc, QualType vecType, unsigned nElements, |

3206 | QualType canonType, VectorKind vecKind); |

3207 | |

3208 | public: |

3209 | QualType getElementType() const { return ElementType; } |

3210 | unsigned getNumElements() const { return VectorTypeBits.NumElements; } |

3211 | |

3212 | static bool isVectorSizeTooLarge(unsigned NumElements) { |

3213 | return NumElements > VectorTypeBitfields::MaxNumElements; |

3214 | } |

3215 | |

3216 | bool isSugared() const { return false; } |

3217 | QualType desugar() const { return QualType(this, 0); } |

3218 | |

3219 | VectorKind getVectorKind() const { |

3220 | return VectorKind(VectorTypeBits.VecKind); |

3221 | } |

3222 | |

3223 | void Profile(llvm::FoldingSetNodeID &ID) { |

3224 | Profile(ID, getElementType(), getNumElements(), |

3225 | getTypeClass(), getVectorKind()); |

3226 | } |

3227 | |

3228 | static void Profile(llvm::FoldingSetNodeID &ID, QualType ElementType, |

3229 | unsigned NumElements, TypeClass TypeClass, |

3230 | VectorKind VecKind) { |

3231 | ID.AddPointer(ElementType.getAsOpaquePtr()); |

3232 | ID.AddInteger(NumElements); |

3233 | ID.AddInteger(TypeClass); |

3234 | ID.AddInteger(VecKind); |

3235 | } |

3236 | |

3237 | static bool classof(const Type *T) { |

3238 | return T->getTypeClass() == Vector || T->getTypeClass() == ExtVector; |

3239 | } |

3240 | }; |

3241 | |

3242 | /// Represents a vector type where either the type or size is dependent. |

3243 | //// |

3244 | /// For example: |

3245 | /// \code |

3246 | /// template<typename T, int Size> |

3247 | /// class vector { |

3248 | /// typedef T __attribute__((vector_size(Size))) type; |

3249 | /// } |

3250 | /// \endcode |

3251 | class DependentVectorType : public Type, public llvm::FoldingSetNode { |

3252 | friend class ASTContext; |

3253 | |

3254 | const ASTContext &Context; |

3255 | QualType ElementType; |

3256 | Expr *SizeExpr; |

3257 | SourceLocation Loc; |

3258 | |

3259 | DependentVectorType(const ASTContext &Context, QualType ElementType, |

3260 | QualType CanonType, Expr *SizeExpr, |

3261 | SourceLocation Loc, VectorType::VectorKind vecKind); |

3262 | |

3263 | public: |

3264 | Expr *getSizeExpr() const { return SizeExpr; } |

3265 | QualType getElementType() const { return ElementType; } |

3266 | SourceLocation getAttributeLoc() const { return Loc; } |

3267 | VectorType::VectorKind getVectorKind() const { |

3268 | return VectorType::VectorKind(VectorTypeBits.VecKind); |

3269 | } |

3270 | |

3271 | bool isSugared() const { return false; } |

3272 | QualType desugar() const { return QualType(this, 0); } |

3273 | |

3274 | static bool classof(const Type *T) { |

3275 | return T->getTypeClass() == DependentVector; |

3276 | } |

3277 | |

3278 | void Profile(llvm::FoldingSetNodeID &ID) { |

3279 | Profile(ID, Context, getElementType(), getSizeExpr(), getVectorKind()); |

3280 | } |

3281 | |

3282 | static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, |

3283 | QualType ElementType, const Expr *SizeExpr, |

3284 | VectorType::VectorKind VecKind); |

3285 | }; |

3286 | |

3287 | /// ExtVectorType - Extended vector type. This type is created using |

3288 | /// __attribute__((ext_vector_type(n)), where "n" is the number of elements. |

3289 | /// Unlike vector_size, ext_vector_type is only allowed on typedef's. This |

3290 | /// class enables syntactic extensions, like Vector Components for accessing |

3291 | /// points (as .xyzw), colors (as .rgba), and textures (modeled after OpenGL |

3292 | /// Shading Language). |

3293 | class ExtVectorType : public VectorType { |

3294 | friend class ASTContext; // ASTContext creates these. |

3295 | |

3296 | ExtVectorType(QualType vecType, unsigned nElements, QualType canonType) |

3297 | : VectorType(ExtVector, vecType, nElements, canonType, GenericVector) {} |

3298 | |

3299 | public: |

3300 | static int getPointAccessorIdx(char c) { |

3301 | switch (c) { |

3302 | default: return -1; |

3303 | case 'x': case 'r': return 0; |

3304 | case 'y': case 'g': return 1; |

3305 | case 'z': case 'b': return 2; |

3306 | case 'w': case 'a': return 3; |

3307 | } |

3308 | } |

3309 | |

3310 | static int getNumericAccessorIdx(char c) { |

3311 | switch (c) { |

3312 | default: return -1; |

3313 | case '0': return 0; |

3314 | case '1': return 1; |

3315 | case '2': return 2; |

3316 | case '3': return 3; |

3317 | case '4': return 4; |

3318 | case '5': return 5; |

3319 | case '6': return 6; |

3320 | case '7': return 7; |

3321 | case '8': return 8; |

3322 | case '9': return 9; |

3323 | case 'A': |

3324 | case 'a': return 10; |

3325 | case 'B': |

3326 | case 'b': return 11; |

3327 | case 'C': |

3328 | case 'c': return 12; |

3329 | case 'D': |

3330 | case 'd': return 13; |

3331 | case 'E': |

3332 | case 'e': return 14; |

3333 | case 'F': |

3334 | case 'f': return 15; |

3335 | } |

3336 | } |

3337 | |

3338 | static int getAccessorIdx(char c, bool isNumericAccessor) { |

3339 | if (isNumericAccessor) |

3340 | return getNumericAccessorIdx(c); |

3341 | else |

3342 | return getPointAccessorIdx(c); |

3343 | } |

3344 | |

3345 | bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const { |

3346 | if (int idx = getAccessorIdx(c, isNumericAccessor)+1) |

3347 | return unsigned(idx-1) < getNumElements(); |

3348 | return false; |

3349 | } |

3350 | |

3351 | bool isSugared() const { return false; } |

3352 | QualType desugar() const { return QualType(this, 0); } |

3353 | |

3354 | static bool classof(const Type *T) { |

3355 | return T->getTypeClass() == ExtVector; |

3356 | } |

3357 | }; |

3358 | |

3359 | /// FunctionType - C99 6.7.5.3 - Function Declarators. This is the common base |

3360 | /// class of FunctionNoProtoType and FunctionProtoType. |

3361 | class FunctionType : public Type { |

3362 | // The type returned by the function. |

3363 | QualType ResultType; |

3364 | |

3365 | public: |

3366 | /// Interesting information about a specific parameter that can't simply |

3367 | /// be reflected in parameter's type. This is only used by FunctionProtoType |

3368 | /// but is in FunctionType to make this class available during the |

3369 | /// specification of the bases of FunctionProtoType. |

3370 | /// |

3371 | /// It makes sense to model language features this way when there's some |

3372 | /// sort of parameter-specific override (such as an attribute) that |

3373 | /// affects how the function is called. For example, the ARC ns_consumed |

3374 | /// attribute changes whether a parameter is passed at +0 (the default) |

3375 | /// or +1 (ns_consumed). This must be reflected in the function type, |

3376 | /// but isn't really a change to the parameter type. |

3377 | /// |

3378 | /// One serious disadvantage of modelling language features this way is |

3379 | /// that they generally do not work with language features that attempt |

3380 | /// to destructure types. For example, template argument deduction will |

3381 | /// not be able to match a parameter declared as |

3382 | /// T (*)(U) |

3383 | /// against an argument of type |

3384 | /// void (*)(__attribute__((ns_consumed)) id) |

3385 | /// because the substitution of T=void, U=id into the former will |

3386 | /// not produce the latter. |

3387 | class ExtParameterInfo { |

3388 | enum { |

3389 | ABIMask = 0x0F, |

3390 | IsConsumed = 0x10, |

3391 | HasPassObjSize = 0x20, |

3392 | IsNoEscape = 0x40, |

3393 | }; |

3394 | unsigned char Data = 0; |

3395 | |

3396 | public: |

3397 | ExtParameterInfo() = default; |

3398 | |

3399 | /// Return the ABI treatment of this parameter. |

3400 | ParameterABI getABI() const { return ParameterABI(Data & ABIMask); } |

3401 | ExtParameterInfo withABI(ParameterABI kind) const { |

3402 | ExtParameterInfo copy = *this; |

3403 | copy.Data = (copy.Data & ~ABIMask) | unsigned(kind); |

3404 | return copy; |

3405 | } |

3406 | |

3407 | /// Is this parameter considered "consumed" by Objective-C ARC? |

3408 | /// Consumed parameters must have retainable object type. |

3409 | bool isConsumed() const { return (Data & IsConsumed); } |

3410 | ExtParameterInfo withIsConsumed(bool consumed) const { |

3411 | ExtParameterInfo copy = *this; |

3412 | if (consumed) |

3413 | copy.Data |= IsConsumed; |

3414 | else |

3415 | copy.Data &= ~IsConsumed; |

3416 | return copy; |

3417 | } |

3418 | |

3419 | bool hasPassObjectSize() const { return Data & HasPassObjSize; } |

3420 | ExtParameterInfo withHasPassObjectSize() const { |

3421 | ExtParameterInfo Copy = *this; |

3422 | Copy.Data |= HasPassObjSize; |

3423 | return Copy; |

3424 | } |

3425 | |

3426 | bool isNoEscape() const { return Data & IsNoEscape; } |

3427 | ExtParameterInfo withIsNoEscape(bool NoEscape) const { |

3428 | ExtParameterInfo Copy = *this; |

3429 | if (NoEscape) |

3430 | Copy.Data |= IsNoEscape; |

3431 | else |

3432 | Copy.Data &= ~IsNoEscape; |

3433 | return Copy; |

3434 | } |

3435 | |

3436 | unsigned char getOpaqueValue() const { return Data; } |

3437 | static ExtParameterInfo getFromOpaqueValue(unsigned char data) { |

3438 | ExtParameterInfo result; |

3439 | result.Data = data; |

3440 | return result; |

3441 | } |

3442 | |

3443 | friend bool operator==(ExtParameterInfo lhs, ExtParameterInfo rhs) { |

3444 | return lhs.Data == rhs.Data; |

3445 | } |

3446 | |

3447 | friend bool operator!=(ExtParameterInfo lhs, ExtParameterInfo rhs) { |

3448 | return lhs.Data != rhs.Data; |

3449 | } |

3450 | }; |

3451 | |

3452 | /// A class which abstracts out some details necessary for |

3453 | /// making a call. |

3454 | /// |

3455 | /// It is not actually used directly for storing this information in |

3456 | /// a FunctionType, although FunctionType does currently use the |

3457 | /// same bit-pattern. |

3458 | /// |

3459 | // If you add a field (say Foo), other than the obvious places (both, |

3460 | // constructors, compile failures), what you need to update is |

3461 | // * Operator== |

3462 | // * getFoo |

3463 | // * withFoo |

3464 | // * functionType. Add Foo, getFoo. |

3465 | // * ASTContext::getFooType |

3466 | // * ASTContext::mergeFunctionTypes |

3467 | // * FunctionNoProtoType::Profile |

3468 | // * FunctionProtoType::Profile |

3469 | // * TypePrinter::PrintFunctionProto |

3470 | // * AST read and write |

3471 | // * Codegen |

3472 | class ExtInfo { |

3473 | friend class FunctionType; |

3474 | |

3475 | // Feel free to rearrange or add bits, but if you go over 12, |

3476 | // you'll need to adjust both the Bits field below and |

3477 | // Type::FunctionTypeBitfields. |

3478 | |

3479 | // | CC |noreturn|produces|nocallersavedregs|regparm|nocfcheck| |

3480 | // |0 .. 4| 5 | 6 | 7 |8 .. 10| 11 | |

3481 | // |

3482 | // regparm is either 0 (no regparm attribute) or the regparm value+1. |

3483 | enum { CallConvMask = 0x1F }; |

3484 | enum { NoReturnMask = 0x20 }; |

3485 | enum { ProducesResultMask = 0x40 }; |

3486 | enum { NoCallerSavedRegsMask = 0x80 }; |

3487 | enum { NoCfCheckMask = 0x800 }; |

3488 | enum { |

3489 | RegParmMask = ~(CallConvMask | NoReturnMask | ProducesResultMask | |

3490 | NoCallerSavedRegsMask | NoCfCheckMask), |

3491 | RegParmOffset = 8 |

3492 | }; // Assumed to be the last field |

3493 | uint16_t Bits = CC_C; |

3494 | |

3495 | ExtInfo(unsigned Bits) : Bits(static_cast<uint16_t>(Bits)) {} |

3496 | |

3497 | public: |

3498 | // Constructor with no defaults. Use this when you know that you |

3499 | // have all the elements (when reading an AST file for example). |

3500 | ExtInfo(bool noReturn, bool hasRegParm, unsigned regParm, CallingConv cc, |

3501 | bool producesResult, bool noCallerSavedRegs, bool NoCfCheck) { |

3502 | assert((!hasRegParm || regParm < 7) && "Invalid regparm value"); |

3503 | Bits = ((unsigned)cc) | (noReturn ? NoReturnMask : 0) | |

3504 | (producesResult ? ProducesResultMask : 0) | |

3505 | (noCallerSavedRegs ? NoCallerSavedRegsMask : 0) | |

3506 | (hasRegParm ? ((regParm + 1) << RegParmOffset) : 0) | |

3507 | (NoCfCheck ? NoCfCheckMask : 0); |

3508 | } |

3509 | |

3510 | // Constructor with all defaults. Use when for example creating a |

3511 | // function known to use defaults. |

3512 | ExtInfo() = default; |

3513 | |

3514 | // Constructor with just the calling convention, which is an important part |

3515 | // of the canonical type. |

3516 | ExtInfo(CallingConv CC) : Bits(CC) {} |

3517 | |

3518 | bool getNoReturn() const { return Bits & NoReturnMask; } |

3519 | bool getProducesResult() const { return Bits & ProducesResultMask; } |

3520 | bool getNoCallerSavedRegs() const { return Bits & NoCallerSavedRegsMask; } |

3521 | bool getNoCfCheck() const { return Bits & NoCfCheckMask; } |

3522 | bool getHasRegParm() const { return (Bits >> RegParmOffset) != 0; } |

3523 | |

3524 | unsigned getRegParm() const { |

3525 | unsigned RegParm = (Bits & RegParmMask) >> RegParmOffset; |

3526 | if (RegParm > 0) |

3527 | --RegParm; |

3528 | return RegParm; |

3529 | } |

3530 | |

3531 | CallingConv getCC() const { return CallingConv(Bits & CallConvMask); } |

3532 | |

3533 | bool operator==(ExtInfo Other) const { |

3534 | return Bits == Other.Bits; |

3535 | } |

3536 | bool operator!=(ExtInfo Other) const { |

3537 | return Bits != Other.Bits; |

3538 | } |

3539 | |

3540 | // Note that we don't have setters. That is by design, use |

3541 | // the following with methods instead of mutating these objects. |

3542 | |

3543 | ExtInfo withNoReturn(bool noReturn) const { |

3544 | if (noReturn) |

3545 | return ExtInfo(Bits | NoReturnMask); |

3546 | else |

3547 | return ExtInfo(Bits & ~NoReturnMask); |

3548 | } |

3549 | |

3550 | ExtInfo withProducesResult(bool producesResult) const { |

3551 | if (producesResult) |

3552 | return ExtInfo(Bits | ProducesResultMask); |

3553 | else |

3554 | return ExtInfo(Bits & ~ProducesResultMask); |

3555 | } |

3556 | |

3557 | ExtInfo withNoCallerSavedRegs(bool noCallerSavedRegs) const { |

3558 | if (noCallerSavedRegs) |

3559 | return ExtInfo(Bits | NoCallerSavedRegsMask); |

3560 | else |

3561 | return ExtInfo(Bits & ~NoCallerSavedRegsMask); |

3562 | } |

3563 | |

3564 | ExtInfo withNoCfCheck(bool noCfCheck) const { |

3565 | if (noCfCheck) |

3566 | return ExtInfo(Bits | NoCfCheckMask); |

3567 | else |

3568 | return ExtInfo(Bits & ~NoCfCheckMask); |

3569 | } |

3570 | |

3571 | ExtInfo withRegParm(unsigned RegParm) const { |

3572 | assert(RegParm < 7 && "Invalid regparm value"); |

3573 | return ExtInfo((Bits & ~RegParmMask) | |

3574 | ((RegParm + 1) << RegParmOffset)); |

3575 | } |

3576 | |

3577 | ExtInfo withCallingConv(CallingConv cc) const { |

3578 | return ExtInfo((Bits & ~CallConvMask) | (unsigned) cc); |

3579 | } |

3580 | |

3581 | void Profile(llvm::FoldingSetNodeID &ID) const { |

3582 | ID.AddInteger(Bits); |

3583 | } |

3584 | }; |

3585 | |

3586 | /// A simple holder for a QualType representing a type in an |

3587 | /// exception specification. Unfortunately needed by FunctionProtoType |

3588 | /// because TrailingObjects cannot handle repeated types. |

3589 | struct ExceptionType { QualType Type; }; |

3590 | |

3591 | /// A simple holder for various uncommon bits which do not fit in |

3592 | /// FunctionTypeBitfields. Aligned to alignof(void *) to maintain the |

3593 | /// alignment of subsequent objects in TrailingObjects. You must update |

3594 | /// hasExtraBitfields in FunctionProtoType after adding extra data here. |

3595 | struct alignas(void *) FunctionTypeExtraBitfields { |

3596 | /// The number of types in the exception specification. |

3597 | /// A whole unsigned is not needed here and according to |

3598 | /// [implimits] 8 bits would be enough here. |

3599 | unsigned NumExceptionType; |

3600 | }; |

3601 | |

3602 | protected: |

3603 | FunctionType(TypeClass tc, QualType res, |

3604 | QualType Canonical, bool Dependent, |

3605 | bool InstantiationDependent, |

3606 | bool VariablyModified, bool ContainsUnexpandedParameterPack, |

3607 | ExtInfo Info) |

3608 | : Type(tc, Canonical, Dependent, InstantiationDependent, VariablyModified, |

3609 | ContainsUnexpandedParameterPack), |

3610 | ResultType(res) { |

3611 | FunctionTypeBits.ExtInfo = Info.Bits; |

3612 | } |

3613 | |

3614 | unsigned getTypeQuals() const { return FunctionTypeBits.TypeQuals; } |

3615 | |

3616 | public: |

3617 | QualType getReturnType() const { return ResultType; } |

3618 | |

3619 | bool getHasRegParm() const { return getExtInfo().getHasRegParm(); } |

3620 | unsigned getRegParmType() const { return getExtInfo().getRegParm(); } |

3621 | |

3622 | /// Determine whether this function type includes the GNU noreturn |

3623 | /// attribute. The C++11 [[noreturn]] attribute does not affect the function |

3624 | /// type. |

3625 | bool getNoReturnAttr() const { return getExtInfo().getNoReturn(); } |

3626 | |

3627 | CallingConv getCallConv() const { return getExtInfo().getCC(); } |

3628 |