1 //===--- ASTContext.cpp - Context to hold long-lived AST nodes ------------===// 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 // This file implements the ASTContext interface. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/AST/ASTContext.h" 15 #include "CXXABI.h" 16 #include "clang/AST/ASTMutationListener.h" 17 #include "clang/AST/Attr.h" 18 #include "clang/AST/CharUnits.h" 19 #include "clang/AST/Comment.h" 20 #include "clang/AST/CommentCommandTraits.h" 21 #include "clang/AST/DeclCXX.h" 22 #include "clang/AST/DeclObjC.h" 23 #include "clang/AST/DeclTemplate.h" 24 #include "clang/AST/Expr.h" 25 #include "clang/AST/ExprCXX.h" 26 #include "clang/AST/ExternalASTSource.h" 27 #include "clang/AST/Mangle.h" 28 #include "clang/AST/MangleNumberingContext.h" 29 #include "clang/AST/RecordLayout.h" 30 #include "clang/AST/RecursiveASTVisitor.h" 31 #include "clang/AST/TypeLoc.h" 32 #include "clang/AST/VTableBuilder.h" 33 #include "clang/Basic/Builtins.h" 34 #include "clang/Basic/SourceManager.h" 35 #include "clang/Basic/TargetInfo.h" 36 #include "llvm/ADT/SmallString.h" 37 #include "llvm/ADT/StringExtras.h" 38 #include "llvm/ADT/Triple.h" 39 #include "llvm/Support/Capacity.h" 40 #include "llvm/Support/MathExtras.h" 41 #include "llvm/Support/raw_ostream.h" 42 #include <map> 43 44 using namespace clang; 45 46 unsigned ASTContext::NumImplicitDefaultConstructors; 47 unsigned ASTContext::NumImplicitDefaultConstructorsDeclared; 48 unsigned ASTContext::NumImplicitCopyConstructors; 49 unsigned ASTContext::NumImplicitCopyConstructorsDeclared; 50 unsigned ASTContext::NumImplicitMoveConstructors; 51 unsigned ASTContext::NumImplicitMoveConstructorsDeclared; 52 unsigned ASTContext::NumImplicitCopyAssignmentOperators; 53 unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared; 54 unsigned ASTContext::NumImplicitMoveAssignmentOperators; 55 unsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared; 56 unsigned ASTContext::NumImplicitDestructors; 57 unsigned ASTContext::NumImplicitDestructorsDeclared; 58 59 enum FloatingRank { 60 HalfRank, FloatRank, DoubleRank, LongDoubleRank 61 }; 62 63 RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const { 64 if (!CommentsLoaded && ExternalSource) { 65 ExternalSource->ReadComments(); 66 67 #ifndef NDEBUG 68 ArrayRef<RawComment *> RawComments = Comments.getComments(); 69 assert(std::is_sorted(RawComments.begin(), RawComments.end(), 70 BeforeThanCompare<RawComment>(SourceMgr))); 71 #endif 72 73 CommentsLoaded = true; 74 } 75 76 assert(D); 77 78 // User can not attach documentation to implicit declarations. 79 if (D->isImplicit()) 80 return nullptr; 81 82 // User can not attach documentation to implicit instantiations. 83 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 84 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 85 return nullptr; 86 } 87 88 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 89 if (VD->isStaticDataMember() && 90 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 91 return nullptr; 92 } 93 94 if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) { 95 if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 96 return nullptr; 97 } 98 99 if (const ClassTemplateSpecializationDecl *CTSD = 100 dyn_cast<ClassTemplateSpecializationDecl>(D)) { 101 TemplateSpecializationKind TSK = CTSD->getSpecializationKind(); 102 if (TSK == TSK_ImplicitInstantiation || 103 TSK == TSK_Undeclared) 104 return nullptr; 105 } 106 107 if (const EnumDecl *ED = dyn_cast<EnumDecl>(D)) { 108 if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 109 return nullptr; 110 } 111 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) { 112 // When tag declaration (but not definition!) is part of the 113 // decl-specifier-seq of some other declaration, it doesn't get comment 114 if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition()) 115 return nullptr; 116 } 117 // TODO: handle comments for function parameters properly. 118 if (isa<ParmVarDecl>(D)) 119 return nullptr; 120 121 // TODO: we could look up template parameter documentation in the template 122 // documentation. 123 if (isa<TemplateTypeParmDecl>(D) || 124 isa<NonTypeTemplateParmDecl>(D) || 125 isa<TemplateTemplateParmDecl>(D)) 126 return nullptr; 127 128 ArrayRef<RawComment *> RawComments = Comments.getComments(); 129 130 // If there are no comments anywhere, we won't find anything. 131 if (RawComments.empty()) 132 return nullptr; 133 134 // Find declaration location. 135 // For Objective-C declarations we generally don't expect to have multiple 136 // declarators, thus use declaration starting location as the "declaration 137 // location". 138 // For all other declarations multiple declarators are used quite frequently, 139 // so we use the location of the identifier as the "declaration location". 140 SourceLocation DeclLoc; 141 if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) || 142 isa<ObjCPropertyDecl>(D) || 143 isa<RedeclarableTemplateDecl>(D) || 144 isa<ClassTemplateSpecializationDecl>(D)) 145 DeclLoc = D->getLocStart(); 146 else { 147 DeclLoc = D->getLocation(); 148 if (DeclLoc.isMacroID()) { 149 if (isa<TypedefDecl>(D)) { 150 // If location of the typedef name is in a macro, it is because being 151 // declared via a macro. Try using declaration's starting location as 152 // the "declaration location". 153 DeclLoc = D->getLocStart(); 154 } else if (const TagDecl *TD = dyn_cast<TagDecl>(D)) { 155 // If location of the tag decl is inside a macro, but the spelling of 156 // the tag name comes from a macro argument, it looks like a special 157 // macro like NS_ENUM is being used to define the tag decl. In that 158 // case, adjust the source location to the expansion loc so that we can 159 // attach the comment to the tag decl. 160 if (SourceMgr.isMacroArgExpansion(DeclLoc) && 161 TD->isCompleteDefinition()) 162 DeclLoc = SourceMgr.getExpansionLoc(DeclLoc); 163 } 164 } 165 } 166 167 // If the declaration doesn't map directly to a location in a file, we 168 // can't find the comment. 169 if (DeclLoc.isInvalid() || !DeclLoc.isFileID()) 170 return nullptr; 171 172 // Find the comment that occurs just after this declaration. 173 ArrayRef<RawComment *>::iterator Comment; 174 { 175 // When searching for comments during parsing, the comment we are looking 176 // for is usually among the last two comments we parsed -- check them 177 // first. 178 RawComment CommentAtDeclLoc( 179 SourceMgr, SourceRange(DeclLoc), false, 180 LangOpts.CommentOpts.ParseAllComments); 181 BeforeThanCompare<RawComment> Compare(SourceMgr); 182 ArrayRef<RawComment *>::iterator MaybeBeforeDecl = RawComments.end() - 1; 183 bool Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc); 184 if (!Found && RawComments.size() >= 2) { 185 MaybeBeforeDecl--; 186 Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc); 187 } 188 189 if (Found) { 190 Comment = MaybeBeforeDecl + 1; 191 assert(Comment == std::lower_bound(RawComments.begin(), RawComments.end(), 192 &CommentAtDeclLoc, Compare)); 193 } else { 194 // Slow path. 195 Comment = std::lower_bound(RawComments.begin(), RawComments.end(), 196 &CommentAtDeclLoc, Compare); 197 } 198 } 199 200 // Decompose the location for the declaration and find the beginning of the 201 // file buffer. 202 std::pair<FileID, unsigned> DeclLocDecomp = SourceMgr.getDecomposedLoc(DeclLoc); 203 204 // First check whether we have a trailing comment. 205 if (Comment != RawComments.end() && 206 (*Comment)->isDocumentation() && (*Comment)->isTrailingComment() && 207 (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D) || 208 isa<ObjCMethodDecl>(D) || isa<ObjCPropertyDecl>(D))) { 209 std::pair<FileID, unsigned> CommentBeginDecomp 210 = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getBegin()); 211 // Check that Doxygen trailing comment comes after the declaration, starts 212 // on the same line and in the same file as the declaration. 213 if (DeclLocDecomp.first == CommentBeginDecomp.first && 214 SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second) 215 == SourceMgr.getLineNumber(CommentBeginDecomp.first, 216 CommentBeginDecomp.second)) { 217 return *Comment; 218 } 219 } 220 221 // The comment just after the declaration was not a trailing comment. 222 // Let's look at the previous comment. 223 if (Comment == RawComments.begin()) 224 return nullptr; 225 --Comment; 226 227 // Check that we actually have a non-member Doxygen comment. 228 if (!(*Comment)->isDocumentation() || (*Comment)->isTrailingComment()) 229 return nullptr; 230 231 // Decompose the end of the comment. 232 std::pair<FileID, unsigned> CommentEndDecomp 233 = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getEnd()); 234 235 // If the comment and the declaration aren't in the same file, then they 236 // aren't related. 237 if (DeclLocDecomp.first != CommentEndDecomp.first) 238 return nullptr; 239 240 // Get the corresponding buffer. 241 bool Invalid = false; 242 const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first, 243 &Invalid).data(); 244 if (Invalid) 245 return nullptr; 246 247 // Extract text between the comment and declaration. 248 StringRef Text(Buffer + CommentEndDecomp.second, 249 DeclLocDecomp.second - CommentEndDecomp.second); 250 251 // There should be no other declarations or preprocessor directives between 252 // comment and declaration. 253 if (Text.find_first_of(";{}#@") != StringRef::npos) 254 return nullptr; 255 256 return *Comment; 257 } 258 259 namespace { 260 /// If we have a 'templated' declaration for a template, adjust 'D' to 261 /// refer to the actual template. 262 /// If we have an implicit instantiation, adjust 'D' to refer to template. 263 const Decl *adjustDeclToTemplate(const Decl *D) { 264 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 265 // Is this function declaration part of a function template? 266 if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate()) 267 return FTD; 268 269 // Nothing to do if function is not an implicit instantiation. 270 if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) 271 return D; 272 273 // Function is an implicit instantiation of a function template? 274 if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate()) 275 return FTD; 276 277 // Function is instantiated from a member definition of a class template? 278 if (const FunctionDecl *MemberDecl = 279 FD->getInstantiatedFromMemberFunction()) 280 return MemberDecl; 281 282 return D; 283 } 284 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 285 // Static data member is instantiated from a member definition of a class 286 // template? 287 if (VD->isStaticDataMember()) 288 if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember()) 289 return MemberDecl; 290 291 return D; 292 } 293 if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) { 294 // Is this class declaration part of a class template? 295 if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate()) 296 return CTD; 297 298 // Class is an implicit instantiation of a class template or partial 299 // specialization? 300 if (const ClassTemplateSpecializationDecl *CTSD = 301 dyn_cast<ClassTemplateSpecializationDecl>(CRD)) { 302 if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation) 303 return D; 304 llvm::PointerUnion<ClassTemplateDecl *, 305 ClassTemplatePartialSpecializationDecl *> 306 PU = CTSD->getSpecializedTemplateOrPartial(); 307 return PU.is<ClassTemplateDecl*>() ? 308 static_cast<const Decl*>(PU.get<ClassTemplateDecl *>()) : 309 static_cast<const Decl*>( 310 PU.get<ClassTemplatePartialSpecializationDecl *>()); 311 } 312 313 // Class is instantiated from a member definition of a class template? 314 if (const MemberSpecializationInfo *Info = 315 CRD->getMemberSpecializationInfo()) 316 return Info->getInstantiatedFrom(); 317 318 return D; 319 } 320 if (const EnumDecl *ED = dyn_cast<EnumDecl>(D)) { 321 // Enum is instantiated from a member definition of a class template? 322 if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum()) 323 return MemberDecl; 324 325 return D; 326 } 327 // FIXME: Adjust alias templates? 328 return D; 329 } 330 } // unnamed namespace 331 332 const RawComment *ASTContext::getRawCommentForAnyRedecl( 333 const Decl *D, 334 const Decl **OriginalDecl) const { 335 D = adjustDeclToTemplate(D); 336 337 // Check whether we have cached a comment for this declaration already. 338 { 339 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos = 340 RedeclComments.find(D); 341 if (Pos != RedeclComments.end()) { 342 const RawCommentAndCacheFlags &Raw = Pos->second; 343 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) { 344 if (OriginalDecl) 345 *OriginalDecl = Raw.getOriginalDecl(); 346 return Raw.getRaw(); 347 } 348 } 349 } 350 351 // Search for comments attached to declarations in the redeclaration chain. 352 const RawComment *RC = nullptr; 353 const Decl *OriginalDeclForRC = nullptr; 354 for (auto I : D->redecls()) { 355 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos = 356 RedeclComments.find(I); 357 if (Pos != RedeclComments.end()) { 358 const RawCommentAndCacheFlags &Raw = Pos->second; 359 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) { 360 RC = Raw.getRaw(); 361 OriginalDeclForRC = Raw.getOriginalDecl(); 362 break; 363 } 364 } else { 365 RC = getRawCommentForDeclNoCache(I); 366 OriginalDeclForRC = I; 367 RawCommentAndCacheFlags Raw; 368 if (RC) { 369 Raw.setRaw(RC); 370 Raw.setKind(RawCommentAndCacheFlags::FromDecl); 371 } else 372 Raw.setKind(RawCommentAndCacheFlags::NoCommentInDecl); 373 Raw.setOriginalDecl(I); 374 RedeclComments[I] = Raw; 375 if (RC) 376 break; 377 } 378 } 379 380 // If we found a comment, it should be a documentation comment. 381 assert(!RC || RC->isDocumentation()); 382 383 if (OriginalDecl) 384 *OriginalDecl = OriginalDeclForRC; 385 386 // Update cache for every declaration in the redeclaration chain. 387 RawCommentAndCacheFlags Raw; 388 Raw.setRaw(RC); 389 Raw.setKind(RawCommentAndCacheFlags::FromRedecl); 390 Raw.setOriginalDecl(OriginalDeclForRC); 391 392 for (auto I : D->redecls()) { 393 RawCommentAndCacheFlags &R = RedeclComments[I]; 394 if (R.getKind() == RawCommentAndCacheFlags::NoCommentInDecl) 395 R = Raw; 396 } 397 398 return RC; 399 } 400 401 static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod, 402 SmallVectorImpl<const NamedDecl *> &Redeclared) { 403 const DeclContext *DC = ObjCMethod->getDeclContext(); 404 if (const ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(DC)) { 405 const ObjCInterfaceDecl *ID = IMD->getClassInterface(); 406 if (!ID) 407 return; 408 // Add redeclared method here. 409 for (const auto *Ext : ID->known_extensions()) { 410 if (ObjCMethodDecl *RedeclaredMethod = 411 Ext->getMethod(ObjCMethod->getSelector(), 412 ObjCMethod->isInstanceMethod())) 413 Redeclared.push_back(RedeclaredMethod); 414 } 415 } 416 } 417 418 comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC, 419 const Decl *D) const { 420 comments::DeclInfo *ThisDeclInfo = new (*this) comments::DeclInfo; 421 ThisDeclInfo->CommentDecl = D; 422 ThisDeclInfo->IsFilled = false; 423 ThisDeclInfo->fill(); 424 ThisDeclInfo->CommentDecl = FC->getDecl(); 425 if (!ThisDeclInfo->TemplateParameters) 426 ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters; 427 comments::FullComment *CFC = 428 new (*this) comments::FullComment(FC->getBlocks(), 429 ThisDeclInfo); 430 return CFC; 431 432 } 433 434 comments::FullComment *ASTContext::getLocalCommentForDeclUncached(const Decl *D) const { 435 const RawComment *RC = getRawCommentForDeclNoCache(D); 436 return RC ? RC->parse(*this, nullptr, D) : nullptr; 437 } 438 439 comments::FullComment *ASTContext::getCommentForDecl( 440 const Decl *D, 441 const Preprocessor *PP) const { 442 if (D->isInvalidDecl()) 443 return nullptr; 444 D = adjustDeclToTemplate(D); 445 446 const Decl *Canonical = D->getCanonicalDecl(); 447 llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos = 448 ParsedComments.find(Canonical); 449 450 if (Pos != ParsedComments.end()) { 451 if (Canonical != D) { 452 comments::FullComment *FC = Pos->second; 453 comments::FullComment *CFC = cloneFullComment(FC, D); 454 return CFC; 455 } 456 return Pos->second; 457 } 458 459 const Decl *OriginalDecl; 460 461 const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl); 462 if (!RC) { 463 if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) { 464 SmallVector<const NamedDecl*, 8> Overridden; 465 const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D); 466 if (OMD && OMD->isPropertyAccessor()) 467 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl()) 468 if (comments::FullComment *FC = getCommentForDecl(PDecl, PP)) 469 return cloneFullComment(FC, D); 470 if (OMD) 471 addRedeclaredMethods(OMD, Overridden); 472 getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden); 473 for (unsigned i = 0, e = Overridden.size(); i < e; i++) 474 if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP)) 475 return cloneFullComment(FC, D); 476 } 477 else if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) { 478 // Attach any tag type's documentation to its typedef if latter 479 // does not have one of its own. 480 QualType QT = TD->getUnderlyingType(); 481 if (const TagType *TT = QT->getAs<TagType>()) 482 if (const Decl *TD = TT->getDecl()) 483 if (comments::FullComment *FC = getCommentForDecl(TD, PP)) 484 return cloneFullComment(FC, D); 485 } 486 else if (const ObjCInterfaceDecl *IC = dyn_cast<ObjCInterfaceDecl>(D)) { 487 while (IC->getSuperClass()) { 488 IC = IC->getSuperClass(); 489 if (comments::FullComment *FC = getCommentForDecl(IC, PP)) 490 return cloneFullComment(FC, D); 491 } 492 } 493 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) { 494 if (const ObjCInterfaceDecl *IC = CD->getClassInterface()) 495 if (comments::FullComment *FC = getCommentForDecl(IC, PP)) 496 return cloneFullComment(FC, D); 497 } 498 else if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 499 if (!(RD = RD->getDefinition())) 500 return nullptr; 501 // Check non-virtual bases. 502 for (const auto &I : RD->bases()) { 503 if (I.isVirtual() || (I.getAccessSpecifier() != AS_public)) 504 continue; 505 QualType Ty = I.getType(); 506 if (Ty.isNull()) 507 continue; 508 if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) { 509 if (!(NonVirtualBase= NonVirtualBase->getDefinition())) 510 continue; 511 512 if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP)) 513 return cloneFullComment(FC, D); 514 } 515 } 516 // Check virtual bases. 517 for (const auto &I : RD->vbases()) { 518 if (I.getAccessSpecifier() != AS_public) 519 continue; 520 QualType Ty = I.getType(); 521 if (Ty.isNull()) 522 continue; 523 if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) { 524 if (!(VirtualBase= VirtualBase->getDefinition())) 525 continue; 526 if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP)) 527 return cloneFullComment(FC, D); 528 } 529 } 530 } 531 return nullptr; 532 } 533 534 // If the RawComment was attached to other redeclaration of this Decl, we 535 // should parse the comment in context of that other Decl. This is important 536 // because comments can contain references to parameter names which can be 537 // different across redeclarations. 538 if (D != OriginalDecl) 539 return getCommentForDecl(OriginalDecl, PP); 540 541 comments::FullComment *FC = RC->parse(*this, PP, D); 542 ParsedComments[Canonical] = FC; 543 return FC; 544 } 545 546 void 547 ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID, 548 TemplateTemplateParmDecl *Parm) { 549 ID.AddInteger(Parm->getDepth()); 550 ID.AddInteger(Parm->getPosition()); 551 ID.AddBoolean(Parm->isParameterPack()); 552 553 TemplateParameterList *Params = Parm->getTemplateParameters(); 554 ID.AddInteger(Params->size()); 555 for (TemplateParameterList::const_iterator P = Params->begin(), 556 PEnd = Params->end(); 557 P != PEnd; ++P) { 558 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { 559 ID.AddInteger(0); 560 ID.AddBoolean(TTP->isParameterPack()); 561 continue; 562 } 563 564 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 565 ID.AddInteger(1); 566 ID.AddBoolean(NTTP->isParameterPack()); 567 ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr()); 568 if (NTTP->isExpandedParameterPack()) { 569 ID.AddBoolean(true); 570 ID.AddInteger(NTTP->getNumExpansionTypes()); 571 for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) { 572 QualType T = NTTP->getExpansionType(I); 573 ID.AddPointer(T.getCanonicalType().getAsOpaquePtr()); 574 } 575 } else 576 ID.AddBoolean(false); 577 continue; 578 } 579 580 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 581 ID.AddInteger(2); 582 Profile(ID, TTP); 583 } 584 } 585 586 TemplateTemplateParmDecl * 587 ASTContext::getCanonicalTemplateTemplateParmDecl( 588 TemplateTemplateParmDecl *TTP) const { 589 // Check if we already have a canonical template template parameter. 590 llvm::FoldingSetNodeID ID; 591 CanonicalTemplateTemplateParm::Profile(ID, TTP); 592 void *InsertPos = nullptr; 593 CanonicalTemplateTemplateParm *Canonical 594 = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 595 if (Canonical) 596 return Canonical->getParam(); 597 598 // Build a canonical template parameter list. 599 TemplateParameterList *Params = TTP->getTemplateParameters(); 600 SmallVector<NamedDecl *, 4> CanonParams; 601 CanonParams.reserve(Params->size()); 602 for (TemplateParameterList::const_iterator P = Params->begin(), 603 PEnd = Params->end(); 604 P != PEnd; ++P) { 605 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) 606 CanonParams.push_back( 607 TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(), 608 SourceLocation(), 609 SourceLocation(), 610 TTP->getDepth(), 611 TTP->getIndex(), nullptr, false, 612 TTP->isParameterPack())); 613 else if (NonTypeTemplateParmDecl *NTTP 614 = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 615 QualType T = getCanonicalType(NTTP->getType()); 616 TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T); 617 NonTypeTemplateParmDecl *Param; 618 if (NTTP->isExpandedParameterPack()) { 619 SmallVector<QualType, 2> ExpandedTypes; 620 SmallVector<TypeSourceInfo *, 2> ExpandedTInfos; 621 for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) { 622 ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I))); 623 ExpandedTInfos.push_back( 624 getTrivialTypeSourceInfo(ExpandedTypes.back())); 625 } 626 627 Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 628 SourceLocation(), 629 SourceLocation(), 630 NTTP->getDepth(), 631 NTTP->getPosition(), nullptr, 632 T, 633 TInfo, 634 ExpandedTypes.data(), 635 ExpandedTypes.size(), 636 ExpandedTInfos.data()); 637 } else { 638 Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 639 SourceLocation(), 640 SourceLocation(), 641 NTTP->getDepth(), 642 NTTP->getPosition(), nullptr, 643 T, 644 NTTP->isParameterPack(), 645 TInfo); 646 } 647 CanonParams.push_back(Param); 648 649 } else 650 CanonParams.push_back(getCanonicalTemplateTemplateParmDecl( 651 cast<TemplateTemplateParmDecl>(*P))); 652 } 653 654 TemplateTemplateParmDecl *CanonTTP 655 = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 656 SourceLocation(), TTP->getDepth(), 657 TTP->getPosition(), 658 TTP->isParameterPack(), 659 nullptr, 660 TemplateParameterList::Create(*this, SourceLocation(), 661 SourceLocation(), 662 CanonParams.data(), 663 CanonParams.size(), 664 SourceLocation())); 665 666 // Get the new insert position for the node we care about. 667 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 668 assert(!Canonical && "Shouldn't be in the map!"); 669 (void)Canonical; 670 671 // Create the canonical template template parameter entry. 672 Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP); 673 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos); 674 return CanonTTP; 675 } 676 677 CXXABI *ASTContext::createCXXABI(const TargetInfo &T) { 678 if (!LangOpts.CPlusPlus) return nullptr; 679 680 switch (T.getCXXABI().getKind()) { 681 case TargetCXXABI::GenericARM: // Same as Itanium at this level 682 case TargetCXXABI::iOS: 683 case TargetCXXABI::iOS64: 684 case TargetCXXABI::GenericAArch64: 685 case TargetCXXABI::GenericItanium: 686 return CreateItaniumCXXABI(*this); 687 case TargetCXXABI::Microsoft: 688 return CreateMicrosoftCXXABI(*this); 689 } 690 llvm_unreachable("Invalid CXXABI type!"); 691 } 692 693 static const LangAS::Map *getAddressSpaceMap(const TargetInfo &T, 694 const LangOptions &LOpts) { 695 if (LOpts.FakeAddressSpaceMap) { 696 // The fake address space map must have a distinct entry for each 697 // language-specific address space. 698 static const unsigned FakeAddrSpaceMap[] = { 699 1, // opencl_global 700 2, // opencl_local 701 3, // opencl_constant 702 4, // cuda_device 703 5, // cuda_constant 704 6 // cuda_shared 705 }; 706 return &FakeAddrSpaceMap; 707 } else { 708 return &T.getAddressSpaceMap(); 709 } 710 } 711 712 static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI, 713 const LangOptions &LangOpts) { 714 switch (LangOpts.getAddressSpaceMapMangling()) { 715 case LangOptions::ASMM_Target: 716 return TI.useAddressSpaceMapMangling(); 717 case LangOptions::ASMM_On: 718 return true; 719 case LangOptions::ASMM_Off: 720 return false; 721 } 722 llvm_unreachable("getAddressSpaceMapMangling() doesn't cover anything."); 723 } 724 725 ASTContext::ASTContext(LangOptions& LOpts, SourceManager &SM, 726 IdentifierTable &idents, SelectorTable &sels, 727 Builtin::Context &builtins) 728 : FunctionProtoTypes(this_()), 729 TemplateSpecializationTypes(this_()), 730 DependentTemplateSpecializationTypes(this_()), 731 SubstTemplateTemplateParmPacks(this_()), 732 GlobalNestedNameSpecifier(nullptr), 733 Int128Decl(nullptr), UInt128Decl(nullptr), Float128StubDecl(nullptr), 734 BuiltinVaListDecl(nullptr), 735 ObjCIdDecl(nullptr), ObjCSelDecl(nullptr), ObjCClassDecl(nullptr), 736 ObjCProtocolClassDecl(nullptr), BOOLDecl(nullptr), 737 CFConstantStringTypeDecl(nullptr), ObjCInstanceTypeDecl(nullptr), 738 FILEDecl(nullptr), 739 jmp_bufDecl(nullptr), sigjmp_bufDecl(nullptr), ucontext_tDecl(nullptr), 740 BlockDescriptorType(nullptr), BlockDescriptorExtendedType(nullptr), 741 cudaConfigureCallDecl(nullptr), 742 NullTypeSourceInfo(QualType()), 743 FirstLocalImport(), LastLocalImport(), 744 SourceMgr(SM), LangOpts(LOpts), 745 AddrSpaceMap(nullptr), Target(nullptr), PrintingPolicy(LOpts), 746 Idents(idents), Selectors(sels), 747 BuiltinInfo(builtins), 748 DeclarationNames(*this), 749 ExternalSource(nullptr), Listener(nullptr), 750 Comments(SM), CommentsLoaded(false), 751 CommentCommandTraits(BumpAlloc, LOpts.CommentOpts), 752 LastSDM(nullptr, 0) 753 { 754 TUDecl = TranslationUnitDecl::Create(*this); 755 } 756 757 ASTContext::~ASTContext() { 758 ReleaseParentMapEntries(); 759 760 // Release the DenseMaps associated with DeclContext objects. 761 // FIXME: Is this the ideal solution? 762 ReleaseDeclContextMaps(); 763 764 // Call all of the deallocation functions on all of their targets. 765 for (DeallocationMap::const_iterator I = Deallocations.begin(), 766 E = Deallocations.end(); I != E; ++I) 767 for (unsigned J = 0, N = I->second.size(); J != N; ++J) 768 (I->first)((I->second)[J]); 769 770 // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed 771 // because they can contain DenseMaps. 772 for (llvm::DenseMap<const ObjCContainerDecl*, 773 const ASTRecordLayout*>::iterator 774 I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; ) 775 // Increment in loop to prevent using deallocated memory. 776 if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 777 R->Destroy(*this); 778 779 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator 780 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) { 781 // Increment in loop to prevent using deallocated memory. 782 if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 783 R->Destroy(*this); 784 } 785 786 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(), 787 AEnd = DeclAttrs.end(); 788 A != AEnd; ++A) 789 A->second->~AttrVec(); 790 791 llvm::DeleteContainerSeconds(MangleNumberingContexts); 792 } 793 794 void ASTContext::ReleaseParentMapEntries() { 795 if (!AllParents) return; 796 for (const auto &Entry : *AllParents) { 797 if (Entry.second.is<ast_type_traits::DynTypedNode *>()) { 798 delete Entry.second.get<ast_type_traits::DynTypedNode *>(); 799 } else { 800 assert(Entry.second.is<ParentVector *>()); 801 delete Entry.second.get<ParentVector *>(); 802 } 803 } 804 } 805 806 void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) { 807 Deallocations[Callback].push_back(Data); 808 } 809 810 void 811 ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) { 812 ExternalSource = Source; 813 } 814 815 void ASTContext::PrintStats() const { 816 llvm::errs() << "\n*** AST Context Stats:\n"; 817 llvm::errs() << " " << Types.size() << " types total.\n"; 818 819 unsigned counts[] = { 820 #define TYPE(Name, Parent) 0, 821 #define ABSTRACT_TYPE(Name, Parent) 822 #include "clang/AST/TypeNodes.def" 823 0 // Extra 824 }; 825 826 for (unsigned i = 0, e = Types.size(); i != e; ++i) { 827 Type *T = Types[i]; 828 counts[(unsigned)T->getTypeClass()]++; 829 } 830 831 unsigned Idx = 0; 832 unsigned TotalBytes = 0; 833 #define TYPE(Name, Parent) \ 834 if (counts[Idx]) \ 835 llvm::errs() << " " << counts[Idx] << " " << #Name \ 836 << " types\n"; \ 837 TotalBytes += counts[Idx] * sizeof(Name##Type); \ 838 ++Idx; 839 #define ABSTRACT_TYPE(Name, Parent) 840 #include "clang/AST/TypeNodes.def" 841 842 llvm::errs() << "Total bytes = " << TotalBytes << "\n"; 843 844 // Implicit special member functions. 845 llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/" 846 << NumImplicitDefaultConstructors 847 << " implicit default constructors created\n"; 848 llvm::errs() << NumImplicitCopyConstructorsDeclared << "/" 849 << NumImplicitCopyConstructors 850 << " implicit copy constructors created\n"; 851 if (getLangOpts().CPlusPlus) 852 llvm::errs() << NumImplicitMoveConstructorsDeclared << "/" 853 << NumImplicitMoveConstructors 854 << " implicit move constructors created\n"; 855 llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/" 856 << NumImplicitCopyAssignmentOperators 857 << " implicit copy assignment operators created\n"; 858 if (getLangOpts().CPlusPlus) 859 llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/" 860 << NumImplicitMoveAssignmentOperators 861 << " implicit move assignment operators created\n"; 862 llvm::errs() << NumImplicitDestructorsDeclared << "/" 863 << NumImplicitDestructors 864 << " implicit destructors created\n"; 865 866 if (ExternalSource) { 867 llvm::errs() << "\n"; 868 ExternalSource->PrintStats(); 869 } 870 871 BumpAlloc.PrintStats(); 872 } 873 874 RecordDecl *ASTContext::buildImplicitRecord(StringRef Name, 875 RecordDecl::TagKind TK) const { 876 SourceLocation Loc; 877 RecordDecl *NewDecl; 878 if (getLangOpts().CPlusPlus) 879 NewDecl = CXXRecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc, 880 Loc, &Idents.get(Name)); 881 else 882 NewDecl = RecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc, Loc, 883 &Idents.get(Name)); 884 NewDecl->setImplicit(); 885 return NewDecl; 886 } 887 888 TypedefDecl *ASTContext::buildImplicitTypedef(QualType T, 889 StringRef Name) const { 890 TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T); 891 TypedefDecl *NewDecl = TypedefDecl::Create( 892 const_cast<ASTContext &>(*this), getTranslationUnitDecl(), 893 SourceLocation(), SourceLocation(), &Idents.get(Name), TInfo); 894 NewDecl->setImplicit(); 895 return NewDecl; 896 } 897 898 TypedefDecl *ASTContext::getInt128Decl() const { 899 if (!Int128Decl) 900 Int128Decl = buildImplicitTypedef(Int128Ty, "__int128_t"); 901 return Int128Decl; 902 } 903 904 TypedefDecl *ASTContext::getUInt128Decl() const { 905 if (!UInt128Decl) 906 UInt128Decl = buildImplicitTypedef(UnsignedInt128Ty, "__uint128_t"); 907 return UInt128Decl; 908 } 909 910 TypeDecl *ASTContext::getFloat128StubType() const { 911 assert(LangOpts.CPlusPlus && "should only be called for c++"); 912 if (!Float128StubDecl) 913 Float128StubDecl = buildImplicitRecord("__float128"); 914 915 return Float128StubDecl; 916 } 917 918 void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) { 919 BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K); 920 R = CanQualType::CreateUnsafe(QualType(Ty, 0)); 921 Types.push_back(Ty); 922 } 923 924 void ASTContext::InitBuiltinTypes(const TargetInfo &Target) { 925 assert((!this->Target || this->Target == &Target) && 926 "Incorrect target reinitialization"); 927 assert(VoidTy.isNull() && "Context reinitialized?"); 928 929 this->Target = &Target; 930 931 ABI.reset(createCXXABI(Target)); 932 AddrSpaceMap = getAddressSpaceMap(Target, LangOpts); 933 AddrSpaceMapMangling = isAddrSpaceMapManglingEnabled(Target, LangOpts); 934 935 // C99 6.2.5p19. 936 InitBuiltinType(VoidTy, BuiltinType::Void); 937 938 // C99 6.2.5p2. 939 InitBuiltinType(BoolTy, BuiltinType::Bool); 940 // C99 6.2.5p3. 941 if (LangOpts.CharIsSigned) 942 InitBuiltinType(CharTy, BuiltinType::Char_S); 943 else 944 InitBuiltinType(CharTy, BuiltinType::Char_U); 945 // C99 6.2.5p4. 946 InitBuiltinType(SignedCharTy, BuiltinType::SChar); 947 InitBuiltinType(ShortTy, BuiltinType::Short); 948 InitBuiltinType(IntTy, BuiltinType::Int); 949 InitBuiltinType(LongTy, BuiltinType::Long); 950 InitBuiltinType(LongLongTy, BuiltinType::LongLong); 951 952 // C99 6.2.5p6. 953 InitBuiltinType(UnsignedCharTy, BuiltinType::UChar); 954 InitBuiltinType(UnsignedShortTy, BuiltinType::UShort); 955 InitBuiltinType(UnsignedIntTy, BuiltinType::UInt); 956 InitBuiltinType(UnsignedLongTy, BuiltinType::ULong); 957 InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong); 958 959 // C99 6.2.5p10. 960 InitBuiltinType(FloatTy, BuiltinType::Float); 961 InitBuiltinType(DoubleTy, BuiltinType::Double); 962 InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble); 963 964 // GNU extension, 128-bit integers. 965 InitBuiltinType(Int128Ty, BuiltinType::Int128); 966 InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128); 967 968 // C++ 3.9.1p5 969 if (TargetInfo::isTypeSigned(Target.getWCharType())) 970 InitBuiltinType(WCharTy, BuiltinType::WChar_S); 971 else // -fshort-wchar makes wchar_t be unsigned. 972 InitBuiltinType(WCharTy, BuiltinType::WChar_U); 973 if (LangOpts.CPlusPlus && LangOpts.WChar) 974 WideCharTy = WCharTy; 975 else { 976 // C99 (or C++ using -fno-wchar). 977 WideCharTy = getFromTargetType(Target.getWCharType()); 978 } 979 980 WIntTy = getFromTargetType(Target.getWIntType()); 981 982 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 983 InitBuiltinType(Char16Ty, BuiltinType::Char16); 984 else // C99 985 Char16Ty = getFromTargetType(Target.getChar16Type()); 986 987 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 988 InitBuiltinType(Char32Ty, BuiltinType::Char32); 989 else // C99 990 Char32Ty = getFromTargetType(Target.getChar32Type()); 991 992 // Placeholder type for type-dependent expressions whose type is 993 // completely unknown. No code should ever check a type against 994 // DependentTy and users should never see it; however, it is here to 995 // help diagnose failures to properly check for type-dependent 996 // expressions. 997 InitBuiltinType(DependentTy, BuiltinType::Dependent); 998 999 // Placeholder type for functions. 1000 InitBuiltinType(OverloadTy, BuiltinType::Overload); 1001 1002 // Placeholder type for bound members. 1003 InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember); 1004 1005 // Placeholder type for pseudo-objects. 1006 InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject); 1007 1008 // "any" type; useful for debugger-like clients. 1009 InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny); 1010 1011 // Placeholder type for unbridged ARC casts. 1012 InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast); 1013 1014 // Placeholder type for builtin functions. 1015 InitBuiltinType(BuiltinFnTy, BuiltinType::BuiltinFn); 1016 1017 // C99 6.2.5p11. 1018 FloatComplexTy = getComplexType(FloatTy); 1019 DoubleComplexTy = getComplexType(DoubleTy); 1020 LongDoubleComplexTy = getComplexType(LongDoubleTy); 1021 1022 // Builtin types for 'id', 'Class', and 'SEL'. 1023 InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId); 1024 InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass); 1025 InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel); 1026 1027 if (LangOpts.OpenCL) { 1028 InitBuiltinType(OCLImage1dTy, BuiltinType::OCLImage1d); 1029 InitBuiltinType(OCLImage1dArrayTy, BuiltinType::OCLImage1dArray); 1030 InitBuiltinType(OCLImage1dBufferTy, BuiltinType::OCLImage1dBuffer); 1031 InitBuiltinType(OCLImage2dTy, BuiltinType::OCLImage2d); 1032 InitBuiltinType(OCLImage2dArrayTy, BuiltinType::OCLImage2dArray); 1033 InitBuiltinType(OCLImage3dTy, BuiltinType::OCLImage3d); 1034 1035 InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler); 1036 InitBuiltinType(OCLEventTy, BuiltinType::OCLEvent); 1037 } 1038 1039 // Builtin type for __objc_yes and __objc_no 1040 ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ? 1041 SignedCharTy : BoolTy); 1042 1043 ObjCConstantStringType = QualType(); 1044 1045 ObjCSuperType = QualType(); 1046 1047 // void * type 1048 VoidPtrTy = getPointerType(VoidTy); 1049 1050 // nullptr type (C++0x 2.14.7) 1051 InitBuiltinType(NullPtrTy, BuiltinType::NullPtr); 1052 1053 // half type (OpenCL 6.1.1.1) / ARM NEON __fp16 1054 InitBuiltinType(HalfTy, BuiltinType::Half); 1055 1056 // Builtin type used to help define __builtin_va_list. 1057 VaListTagTy = QualType(); 1058 } 1059 1060 DiagnosticsEngine &ASTContext::getDiagnostics() const { 1061 return SourceMgr.getDiagnostics(); 1062 } 1063 1064 AttrVec& ASTContext::getDeclAttrs(const Decl *D) { 1065 AttrVec *&Result = DeclAttrs[D]; 1066 if (!Result) { 1067 void *Mem = Allocate(sizeof(AttrVec)); 1068 Result = new (Mem) AttrVec; 1069 } 1070 1071 return *Result; 1072 } 1073 1074 /// \brief Erase the attributes corresponding to the given declaration. 1075 void ASTContext::eraseDeclAttrs(const Decl *D) { 1076 llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D); 1077 if (Pos != DeclAttrs.end()) { 1078 Pos->second->~AttrVec(); 1079 DeclAttrs.erase(Pos); 1080 } 1081 } 1082 1083 // FIXME: Remove ? 1084 MemberSpecializationInfo * 1085 ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) { 1086 assert(Var->isStaticDataMember() && "Not a static data member"); 1087 return getTemplateOrSpecializationInfo(Var) 1088 .dyn_cast<MemberSpecializationInfo *>(); 1089 } 1090 1091 ASTContext::TemplateOrSpecializationInfo 1092 ASTContext::getTemplateOrSpecializationInfo(const VarDecl *Var) { 1093 llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos = 1094 TemplateOrInstantiation.find(Var); 1095 if (Pos == TemplateOrInstantiation.end()) 1096 return TemplateOrSpecializationInfo(); 1097 1098 return Pos->second; 1099 } 1100 1101 void 1102 ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, 1103 TemplateSpecializationKind TSK, 1104 SourceLocation PointOfInstantiation) { 1105 assert(Inst->isStaticDataMember() && "Not a static data member"); 1106 assert(Tmpl->isStaticDataMember() && "Not a static data member"); 1107 setTemplateOrSpecializationInfo(Inst, new (*this) MemberSpecializationInfo( 1108 Tmpl, TSK, PointOfInstantiation)); 1109 } 1110 1111 void 1112 ASTContext::setTemplateOrSpecializationInfo(VarDecl *Inst, 1113 TemplateOrSpecializationInfo TSI) { 1114 assert(!TemplateOrInstantiation[Inst] && 1115 "Already noted what the variable was instantiated from"); 1116 TemplateOrInstantiation[Inst] = TSI; 1117 } 1118 1119 FunctionDecl *ASTContext::getClassScopeSpecializationPattern( 1120 const FunctionDecl *FD){ 1121 assert(FD && "Specialization is 0"); 1122 llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos 1123 = ClassScopeSpecializationPattern.find(FD); 1124 if (Pos == ClassScopeSpecializationPattern.end()) 1125 return nullptr; 1126 1127 return Pos->second; 1128 } 1129 1130 void ASTContext::setClassScopeSpecializationPattern(FunctionDecl *FD, 1131 FunctionDecl *Pattern) { 1132 assert(FD && "Specialization is 0"); 1133 assert(Pattern && "Class scope specialization pattern is 0"); 1134 ClassScopeSpecializationPattern[FD] = Pattern; 1135 } 1136 1137 NamedDecl * 1138 ASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) { 1139 llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos 1140 = InstantiatedFromUsingDecl.find(UUD); 1141 if (Pos == InstantiatedFromUsingDecl.end()) 1142 return nullptr; 1143 1144 return Pos->second; 1145 } 1146 1147 void 1148 ASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) { 1149 assert((isa<UsingDecl>(Pattern) || 1150 isa<UnresolvedUsingValueDecl>(Pattern) || 1151 isa<UnresolvedUsingTypenameDecl>(Pattern)) && 1152 "pattern decl is not a using decl"); 1153 assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists"); 1154 InstantiatedFromUsingDecl[Inst] = Pattern; 1155 } 1156 1157 UsingShadowDecl * 1158 ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) { 1159 llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos 1160 = InstantiatedFromUsingShadowDecl.find(Inst); 1161 if (Pos == InstantiatedFromUsingShadowDecl.end()) 1162 return nullptr; 1163 1164 return Pos->second; 1165 } 1166 1167 void 1168 ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, 1169 UsingShadowDecl *Pattern) { 1170 assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"); 1171 InstantiatedFromUsingShadowDecl[Inst] = Pattern; 1172 } 1173 1174 FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) { 1175 llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos 1176 = InstantiatedFromUnnamedFieldDecl.find(Field); 1177 if (Pos == InstantiatedFromUnnamedFieldDecl.end()) 1178 return nullptr; 1179 1180 return Pos->second; 1181 } 1182 1183 void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, 1184 FieldDecl *Tmpl) { 1185 assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed"); 1186 assert(!Tmpl->getDeclName() && "Template field decl is not unnamed"); 1187 assert(!InstantiatedFromUnnamedFieldDecl[Inst] && 1188 "Already noted what unnamed field was instantiated from"); 1189 1190 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl; 1191 } 1192 1193 ASTContext::overridden_cxx_method_iterator 1194 ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const { 1195 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 1196 = OverriddenMethods.find(Method->getCanonicalDecl()); 1197 if (Pos == OverriddenMethods.end()) 1198 return nullptr; 1199 1200 return Pos->second.begin(); 1201 } 1202 1203 ASTContext::overridden_cxx_method_iterator 1204 ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const { 1205 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 1206 = OverriddenMethods.find(Method->getCanonicalDecl()); 1207 if (Pos == OverriddenMethods.end()) 1208 return nullptr; 1209 1210 return Pos->second.end(); 1211 } 1212 1213 unsigned 1214 ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const { 1215 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 1216 = OverriddenMethods.find(Method->getCanonicalDecl()); 1217 if (Pos == OverriddenMethods.end()) 1218 return 0; 1219 1220 return Pos->second.size(); 1221 } 1222 1223 void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method, 1224 const CXXMethodDecl *Overridden) { 1225 assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl()); 1226 OverriddenMethods[Method].push_back(Overridden); 1227 } 1228 1229 void ASTContext::getOverriddenMethods( 1230 const NamedDecl *D, 1231 SmallVectorImpl<const NamedDecl *> &Overridden) const { 1232 assert(D); 1233 1234 if (const CXXMethodDecl *CXXMethod = dyn_cast<CXXMethodDecl>(D)) { 1235 Overridden.append(overridden_methods_begin(CXXMethod), 1236 overridden_methods_end(CXXMethod)); 1237 return; 1238 } 1239 1240 const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D); 1241 if (!Method) 1242 return; 1243 1244 SmallVector<const ObjCMethodDecl *, 8> OverDecls; 1245 Method->getOverriddenMethods(OverDecls); 1246 Overridden.append(OverDecls.begin(), OverDecls.end()); 1247 } 1248 1249 void ASTContext::addedLocalImportDecl(ImportDecl *Import) { 1250 assert(!Import->NextLocalImport && "Import declaration already in the chain"); 1251 assert(!Import->isFromASTFile() && "Non-local import declaration"); 1252 if (!FirstLocalImport) { 1253 FirstLocalImport = Import; 1254 LastLocalImport = Import; 1255 return; 1256 } 1257 1258 LastLocalImport->NextLocalImport = Import; 1259 LastLocalImport = Import; 1260 } 1261 1262 //===----------------------------------------------------------------------===// 1263 // Type Sizing and Analysis 1264 //===----------------------------------------------------------------------===// 1265 1266 /// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified 1267 /// scalar floating point type. 1268 const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const { 1269 const BuiltinType *BT = T->getAs<BuiltinType>(); 1270 assert(BT && "Not a floating point type!"); 1271 switch (BT->getKind()) { 1272 default: llvm_unreachable("Not a floating point type!"); 1273 case BuiltinType::Half: return Target->getHalfFormat(); 1274 case BuiltinType::Float: return Target->getFloatFormat(); 1275 case BuiltinType::Double: return Target->getDoubleFormat(); 1276 case BuiltinType::LongDouble: return Target->getLongDoubleFormat(); 1277 } 1278 } 1279 1280 CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const { 1281 unsigned Align = Target->getCharWidth(); 1282 1283 bool UseAlignAttrOnly = false; 1284 if (unsigned AlignFromAttr = D->getMaxAlignment()) { 1285 Align = AlignFromAttr; 1286 1287 // __attribute__((aligned)) can increase or decrease alignment 1288 // *except* on a struct or struct member, where it only increases 1289 // alignment unless 'packed' is also specified. 1290 // 1291 // It is an error for alignas to decrease alignment, so we can 1292 // ignore that possibility; Sema should diagnose it. 1293 if (isa<FieldDecl>(D)) { 1294 UseAlignAttrOnly = D->hasAttr<PackedAttr>() || 1295 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 1296 } else { 1297 UseAlignAttrOnly = true; 1298 } 1299 } 1300 else if (isa<FieldDecl>(D)) 1301 UseAlignAttrOnly = 1302 D->hasAttr<PackedAttr>() || 1303 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 1304 1305 // If we're using the align attribute only, just ignore everything 1306 // else about the declaration and its type. 1307 if (UseAlignAttrOnly) { 1308 // do nothing 1309 1310 } else if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 1311 QualType T = VD->getType(); 1312 if (const ReferenceType *RT = T->getAs<ReferenceType>()) { 1313 if (ForAlignof) 1314 T = RT->getPointeeType(); 1315 else 1316 T = getPointerType(RT->getPointeeType()); 1317 } 1318 QualType BaseT = getBaseElementType(T); 1319 if (!BaseT->isIncompleteType() && !T->isFunctionType()) { 1320 // Adjust alignments of declarations with array type by the 1321 // large-array alignment on the target. 1322 if (const ArrayType *arrayType = getAsArrayType(T)) { 1323 unsigned MinWidth = Target->getLargeArrayMinWidth(); 1324 if (!ForAlignof && MinWidth) { 1325 if (isa<VariableArrayType>(arrayType)) 1326 Align = std::max(Align, Target->getLargeArrayAlign()); 1327 else if (isa<ConstantArrayType>(arrayType) && 1328 MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType))) 1329 Align = std::max(Align, Target->getLargeArrayAlign()); 1330 } 1331 } 1332 Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr())); 1333 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1334 if (VD->hasGlobalStorage()) 1335 Align = std::max(Align, getTargetInfo().getMinGlobalAlign()); 1336 } 1337 } 1338 1339 // Fields can be subject to extra alignment constraints, like if 1340 // the field is packed, the struct is packed, or the struct has a 1341 // a max-field-alignment constraint (#pragma pack). So calculate 1342 // the actual alignment of the field within the struct, and then 1343 // (as we're expected to) constrain that by the alignment of the type. 1344 if (const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) { 1345 const RecordDecl *Parent = Field->getParent(); 1346 // We can only produce a sensible answer if the record is valid. 1347 if (!Parent->isInvalidDecl()) { 1348 const ASTRecordLayout &Layout = getASTRecordLayout(Parent); 1349 1350 // Start with the record's overall alignment. 1351 unsigned FieldAlign = toBits(Layout.getAlignment()); 1352 1353 // Use the GCD of that and the offset within the record. 1354 uint64_t Offset = Layout.getFieldOffset(Field->getFieldIndex()); 1355 if (Offset > 0) { 1356 // Alignment is always a power of 2, so the GCD will be a power of 2, 1357 // which means we get to do this crazy thing instead of Euclid's. 1358 uint64_t LowBitOfOffset = Offset & (~Offset + 1); 1359 if (LowBitOfOffset < FieldAlign) 1360 FieldAlign = static_cast<unsigned>(LowBitOfOffset); 1361 } 1362 1363 Align = std::min(Align, FieldAlign); 1364 } 1365 } 1366 } 1367 1368 return toCharUnitsFromBits(Align); 1369 } 1370 1371 // getTypeInfoDataSizeInChars - Return the size of a type, in 1372 // chars. If the type is a record, its data size is returned. This is 1373 // the size of the memcpy that's performed when assigning this type 1374 // using a trivial copy/move assignment operator. 1375 std::pair<CharUnits, CharUnits> 1376 ASTContext::getTypeInfoDataSizeInChars(QualType T) const { 1377 std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T); 1378 1379 // In C++, objects can sometimes be allocated into the tail padding 1380 // of a base-class subobject. We decide whether that's possible 1381 // during class layout, so here we can just trust the layout results. 1382 if (getLangOpts().CPlusPlus) { 1383 if (const RecordType *RT = T->getAs<RecordType>()) { 1384 const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl()); 1385 sizeAndAlign.first = layout.getDataSize(); 1386 } 1387 } 1388 1389 return sizeAndAlign; 1390 } 1391 1392 /// getConstantArrayInfoInChars - Performing the computation in CharUnits 1393 /// instead of in bits prevents overflowing the uint64_t for some large arrays. 1394 std::pair<CharUnits, CharUnits> 1395 static getConstantArrayInfoInChars(const ASTContext &Context, 1396 const ConstantArrayType *CAT) { 1397 std::pair<CharUnits, CharUnits> EltInfo = 1398 Context.getTypeInfoInChars(CAT->getElementType()); 1399 uint64_t Size = CAT->getSize().getZExtValue(); 1400 assert((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <= 1401 (uint64_t)(-1)/Size) && 1402 "Overflow in array type char size evaluation"); 1403 uint64_t Width = EltInfo.first.getQuantity() * Size; 1404 unsigned Align = EltInfo.second.getQuantity(); 1405 if (!Context.getTargetInfo().getCXXABI().isMicrosoft() || 1406 Context.getTargetInfo().getPointerWidth(0) == 64) 1407 Width = llvm::RoundUpToAlignment(Width, Align); 1408 return std::make_pair(CharUnits::fromQuantity(Width), 1409 CharUnits::fromQuantity(Align)); 1410 } 1411 1412 std::pair<CharUnits, CharUnits> 1413 ASTContext::getTypeInfoInChars(const Type *T) const { 1414 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(T)) 1415 return getConstantArrayInfoInChars(*this, CAT); 1416 std::pair<uint64_t, unsigned> Info = getTypeInfo(T); 1417 return std::make_pair(toCharUnitsFromBits(Info.first), 1418 toCharUnitsFromBits(Info.second)); 1419 } 1420 1421 std::pair<CharUnits, CharUnits> 1422 ASTContext::getTypeInfoInChars(QualType T) const { 1423 return getTypeInfoInChars(T.getTypePtr()); 1424 } 1425 1426 std::pair<uint64_t, unsigned> ASTContext::getTypeInfo(const Type *T) const { 1427 TypeInfoMap::iterator it = MemoizedTypeInfo.find(T); 1428 if (it != MemoizedTypeInfo.end()) 1429 return it->second; 1430 1431 std::pair<uint64_t, unsigned> Info = getTypeInfoImpl(T); 1432 MemoizedTypeInfo.insert(std::make_pair(T, Info)); 1433 return Info; 1434 } 1435 1436 /// getTypeInfoImpl - Return the size of the specified type, in bits. This 1437 /// method does not work on incomplete types. 1438 /// 1439 /// FIXME: Pointers into different addr spaces could have different sizes and 1440 /// alignment requirements: getPointerInfo should take an AddrSpace, this 1441 /// should take a QualType, &c. 1442 std::pair<uint64_t, unsigned> 1443 ASTContext::getTypeInfoImpl(const Type *T) const { 1444 uint64_t Width=0; 1445 unsigned Align=8; 1446 switch (T->getTypeClass()) { 1447 #define TYPE(Class, Base) 1448 #define ABSTRACT_TYPE(Class, Base) 1449 #define NON_CANONICAL_TYPE(Class, Base) 1450 #define DEPENDENT_TYPE(Class, Base) case Type::Class: 1451 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \ 1452 case Type::Class: \ 1453 assert(!T->isDependentType() && "should not see dependent types here"); \ 1454 return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr()); 1455 #include "clang/AST/TypeNodes.def" 1456 llvm_unreachable("Should not see dependent types"); 1457 1458 case Type::FunctionNoProto: 1459 case Type::FunctionProto: 1460 // GCC extension: alignof(function) = 32 bits 1461 Width = 0; 1462 Align = 32; 1463 break; 1464 1465 case Type::IncompleteArray: 1466 case Type::VariableArray: 1467 Width = 0; 1468 Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); 1469 break; 1470 1471 case Type::ConstantArray: { 1472 const ConstantArrayType *CAT = cast<ConstantArrayType>(T); 1473 1474 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 1475 uint64_t Size = CAT->getSize().getZExtValue(); 1476 assert((Size == 0 || EltInfo.first <= (uint64_t)(-1)/Size) && 1477 "Overflow in array type bit size evaluation"); 1478 Width = EltInfo.first*Size; 1479 Align = EltInfo.second; 1480 if (!getTargetInfo().getCXXABI().isMicrosoft() || 1481 getTargetInfo().getPointerWidth(0) == 64) 1482 Width = llvm::RoundUpToAlignment(Width, Align); 1483 break; 1484 } 1485 case Type::ExtVector: 1486 case Type::Vector: { 1487 const VectorType *VT = cast<VectorType>(T); 1488 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType()); 1489 Width = EltInfo.first*VT->getNumElements(); 1490 Align = Width; 1491 // If the alignment is not a power of 2, round up to the next power of 2. 1492 // This happens for non-power-of-2 length vectors. 1493 if (Align & (Align-1)) { 1494 Align = llvm::NextPowerOf2(Align); 1495 Width = llvm::RoundUpToAlignment(Width, Align); 1496 } 1497 // Adjust the alignment based on the target max. 1498 uint64_t TargetVectorAlign = Target->getMaxVectorAlign(); 1499 if (TargetVectorAlign && TargetVectorAlign < Align) 1500 Align = TargetVectorAlign; 1501 break; 1502 } 1503 1504 case Type::Builtin: 1505 switch (cast<BuiltinType>(T)->getKind()) { 1506 default: llvm_unreachable("Unknown builtin type!"); 1507 case BuiltinType::Void: 1508 // GCC extension: alignof(void) = 8 bits. 1509 Width = 0; 1510 Align = 8; 1511 break; 1512 1513 case BuiltinType::Bool: 1514 Width = Target->getBoolWidth(); 1515 Align = Target->getBoolAlign(); 1516 break; 1517 case BuiltinType::Char_S: 1518 case BuiltinType::Char_U: 1519 case BuiltinType::UChar: 1520 case BuiltinType::SChar: 1521 Width = Target->getCharWidth(); 1522 Align = Target->getCharAlign(); 1523 break; 1524 case BuiltinType::WChar_S: 1525 case BuiltinType::WChar_U: 1526 Width = Target->getWCharWidth(); 1527 Align = Target->getWCharAlign(); 1528 break; 1529 case BuiltinType::Char16: 1530 Width = Target->getChar16Width(); 1531 Align = Target->getChar16Align(); 1532 break; 1533 case BuiltinType::Char32: 1534 Width = Target->getChar32Width(); 1535 Align = Target->getChar32Align(); 1536 break; 1537 case BuiltinType::UShort: 1538 case BuiltinType::Short: 1539 Width = Target->getShortWidth(); 1540 Align = Target->getShortAlign(); 1541 break; 1542 case BuiltinType::UInt: 1543 case BuiltinType::Int: 1544 Width = Target->getIntWidth(); 1545 Align = Target->getIntAlign(); 1546 break; 1547 case BuiltinType::ULong: 1548 case BuiltinType::Long: 1549 Width = Target->getLongWidth(); 1550 Align = Target->getLongAlign(); 1551 break; 1552 case BuiltinType::ULongLong: 1553 case BuiltinType::LongLong: 1554 Width = Target->getLongLongWidth(); 1555 Align = Target->getLongLongAlign(); 1556 break; 1557 case BuiltinType::Int128: 1558 case BuiltinType::UInt128: 1559 Width = 128; 1560 Align = 128; // int128_t is 128-bit aligned on all targets. 1561 break; 1562 case BuiltinType::Half: 1563 Width = Target->getHalfWidth(); 1564 Align = Target->getHalfAlign(); 1565 break; 1566 case BuiltinType::Float: 1567 Width = Target->getFloatWidth(); 1568 Align = Target->getFloatAlign(); 1569 break; 1570 case BuiltinType::Double: 1571 Width = Target->getDoubleWidth(); 1572 Align = Target->getDoubleAlign(); 1573 break; 1574 case BuiltinType::LongDouble: 1575 Width = Target->getLongDoubleWidth(); 1576 Align = Target->getLongDoubleAlign(); 1577 break; 1578 case BuiltinType::NullPtr: 1579 Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) 1580 Align = Target->getPointerAlign(0); // == sizeof(void*) 1581 break; 1582 case BuiltinType::ObjCId: 1583 case BuiltinType::ObjCClass: 1584 case BuiltinType::ObjCSel: 1585 Width = Target->getPointerWidth(0); 1586 Align = Target->getPointerAlign(0); 1587 break; 1588 case BuiltinType::OCLSampler: 1589 // Samplers are modeled as integers. 1590 Width = Target->getIntWidth(); 1591 Align = Target->getIntAlign(); 1592 break; 1593 case BuiltinType::OCLEvent: 1594 case BuiltinType::OCLImage1d: 1595 case BuiltinType::OCLImage1dArray: 1596 case BuiltinType::OCLImage1dBuffer: 1597 case BuiltinType::OCLImage2d: 1598 case BuiltinType::OCLImage2dArray: 1599 case BuiltinType::OCLImage3d: 1600 // Currently these types are pointers to opaque types. 1601 Width = Target->getPointerWidth(0); 1602 Align = Target->getPointerAlign(0); 1603 break; 1604 } 1605 break; 1606 case Type::ObjCObjectPointer: 1607 Width = Target->getPointerWidth(0); 1608 Align = Target->getPointerAlign(0); 1609 break; 1610 case Type::BlockPointer: { 1611 unsigned AS = getTargetAddressSpace( 1612 cast<BlockPointerType>(T)->getPointeeType()); 1613 Width = Target->getPointerWidth(AS); 1614 Align = Target->getPointerAlign(AS); 1615 break; 1616 } 1617 case Type::LValueReference: 1618 case Type::RValueReference: { 1619 // alignof and sizeof should never enter this code path here, so we go 1620 // the pointer route. 1621 unsigned AS = getTargetAddressSpace( 1622 cast<ReferenceType>(T)->getPointeeType()); 1623 Width = Target->getPointerWidth(AS); 1624 Align = Target->getPointerAlign(AS); 1625 break; 1626 } 1627 case Type::Pointer: { 1628 unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType()); 1629 Width = Target->getPointerWidth(AS); 1630 Align = Target->getPointerAlign(AS); 1631 break; 1632 } 1633 case Type::MemberPointer: { 1634 const MemberPointerType *MPT = cast<MemberPointerType>(T); 1635 std::tie(Width, Align) = ABI->getMemberPointerWidthAndAlign(MPT); 1636 break; 1637 } 1638 case Type::Complex: { 1639 // Complex types have the same alignment as their elements, but twice the 1640 // size. 1641 std::pair<uint64_t, unsigned> EltInfo = 1642 getTypeInfo(cast<ComplexType>(T)->getElementType()); 1643 Width = EltInfo.first*2; 1644 Align = EltInfo.second; 1645 break; 1646 } 1647 case Type::ObjCObject: 1648 return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); 1649 case Type::Adjusted: 1650 case Type::Decayed: 1651 return getTypeInfo(cast<AdjustedType>(T)->getAdjustedType().getTypePtr()); 1652 case Type::ObjCInterface: { 1653 const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); 1654 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); 1655 Width = toBits(Layout.getSize()); 1656 Align = toBits(Layout.getAlignment()); 1657 break; 1658 } 1659 case Type::Record: 1660 case Type::Enum: { 1661 const TagType *TT = cast<TagType>(T); 1662 1663 if (TT->getDecl()->isInvalidDecl()) { 1664 Width = 8; 1665 Align = 8; 1666 break; 1667 } 1668 1669 if (const EnumType *ET = dyn_cast<EnumType>(TT)) 1670 return getTypeInfo(ET->getDecl()->getIntegerType()); 1671 1672 const RecordType *RT = cast<RecordType>(TT); 1673 const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 1674 Width = toBits(Layout.getSize()); 1675 Align = toBits(Layout.getAlignment()); 1676 break; 1677 } 1678 1679 case Type::SubstTemplateTypeParm: 1680 return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> 1681 getReplacementType().getTypePtr()); 1682 1683 case Type::Auto: { 1684 const AutoType *A = cast<AutoType>(T); 1685 assert(!A->getDeducedType().isNull() && 1686 "cannot request the size of an undeduced or dependent auto type"); 1687 return getTypeInfo(A->getDeducedType().getTypePtr()); 1688 } 1689 1690 case Type::Paren: 1691 return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr()); 1692 1693 case Type::Typedef: { 1694 const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl(); 1695 std::pair<uint64_t, unsigned> Info 1696 = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); 1697 // If the typedef has an aligned attribute on it, it overrides any computed 1698 // alignment we have. This violates the GCC documentation (which says that 1699 // attribute(aligned) can only round up) but matches its implementation. 1700 if (unsigned AttrAlign = Typedef->getMaxAlignment()) 1701 Align = AttrAlign; 1702 else 1703 Align = Info.second; 1704 Width = Info.first; 1705 break; 1706 } 1707 1708 case Type::Elaborated: 1709 return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); 1710 1711 case Type::Attributed: 1712 return getTypeInfo( 1713 cast<AttributedType>(T)->getEquivalentType().getTypePtr()); 1714 1715 case Type::Atomic: { 1716 // Start with the base type information. 1717 std::pair<uint64_t, unsigned> Info 1718 = getTypeInfo(cast<AtomicType>(T)->getValueType()); 1719 Width = Info.first; 1720 Align = Info.second; 1721 1722 // If the size of the type doesn't exceed the platform's max 1723 // atomic promotion width, make the size and alignment more 1724 // favorable to atomic operations: 1725 if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth()) { 1726 // Round the size up to a power of 2. 1727 if (!llvm::isPowerOf2_64(Width)) 1728 Width = llvm::NextPowerOf2(Width); 1729 1730 // Set the alignment equal to the size. 1731 Align = static_cast<unsigned>(Width); 1732 } 1733 } 1734 1735 } 1736 1737 assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"); 1738 return std::make_pair(Width, Align); 1739 } 1740 1741 /// toCharUnitsFromBits - Convert a size in bits to a size in characters. 1742 CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const { 1743 return CharUnits::fromQuantity(BitSize / getCharWidth()); 1744 } 1745 1746 /// toBits - Convert a size in characters to a size in characters. 1747 int64_t ASTContext::toBits(CharUnits CharSize) const { 1748 return CharSize.getQuantity() * getCharWidth(); 1749 } 1750 1751 /// getTypeSizeInChars - Return the size of the specified type, in characters. 1752 /// This method does not work on incomplete types. 1753 CharUnits ASTContext::getTypeSizeInChars(QualType T) const { 1754 return getTypeInfoInChars(T).first; 1755 } 1756 CharUnits ASTContext::getTypeSizeInChars(const Type *T) const { 1757 return getTypeInfoInChars(T).first; 1758 } 1759 1760 /// getTypeAlignInChars - Return the ABI-specified alignment of a type, in 1761 /// characters. This method does not work on incomplete types. 1762 CharUnits ASTContext::getTypeAlignInChars(QualType T) const { 1763 return toCharUnitsFromBits(getTypeAlign(T)); 1764 } 1765 CharUnits ASTContext::getTypeAlignInChars(const Type *T) const { 1766 return toCharUnitsFromBits(getTypeAlign(T)); 1767 } 1768 1769 /// getPreferredTypeAlign - Return the "preferred" alignment of the specified 1770 /// type for the current target in bits. This can be different than the ABI 1771 /// alignment in cases where it is beneficial for performance to overalign 1772 /// a data type. 1773 unsigned ASTContext::getPreferredTypeAlign(const Type *T) const { 1774 unsigned ABIAlign = getTypeAlign(T); 1775 1776 if (Target->getTriple().getArch() == llvm::Triple::xcore) 1777 return ABIAlign; // Never overalign on XCore. 1778 1779 const TypedefType *TT = T->getAs<TypedefType>(); 1780 1781 // Double and long long should be naturally aligned if possible. 1782 T = T->getBaseElementTypeUnsafe(); 1783 if (const ComplexType *CT = T->getAs<ComplexType>()) 1784 T = CT->getElementType().getTypePtr(); 1785 if (T->isSpecificBuiltinType(BuiltinType::Double) || 1786 T->isSpecificBuiltinType(BuiltinType::LongLong) || 1787 T->isSpecificBuiltinType(BuiltinType::ULongLong)) 1788 // Don't increase the alignment if an alignment attribute was specified on a 1789 // typedef declaration. 1790 if (!TT || !TT->getDecl()->getMaxAlignment()) 1791 return std::max(ABIAlign, (unsigned)getTypeSize(T)); 1792 1793 return ABIAlign; 1794 } 1795 1796 /// getAlignOfGlobalVar - Return the alignment in bits that should be given 1797 /// to a global variable of the specified type. 1798 unsigned ASTContext::getAlignOfGlobalVar(QualType T) const { 1799 return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign()); 1800 } 1801 1802 /// getAlignOfGlobalVarInChars - Return the alignment in characters that 1803 /// should be given to a global variable of the specified type. 1804 CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T) const { 1805 return toCharUnitsFromBits(getAlignOfGlobalVar(T)); 1806 } 1807 1808 /// DeepCollectObjCIvars - 1809 /// This routine first collects all declared, but not synthesized, ivars in 1810 /// super class and then collects all ivars, including those synthesized for 1811 /// current class. This routine is used for implementation of current class 1812 /// when all ivars, declared and synthesized are known. 1813 /// 1814 void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, 1815 bool leafClass, 1816 SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const { 1817 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) 1818 DeepCollectObjCIvars(SuperClass, false, Ivars); 1819 if (!leafClass) { 1820 for (const auto *I : OI->ivars()) 1821 Ivars.push_back(I); 1822 } else { 1823 ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI); 1824 for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv; 1825 Iv= Iv->getNextIvar()) 1826 Ivars.push_back(Iv); 1827 } 1828 } 1829 1830 /// CollectInheritedProtocols - Collect all protocols in current class and 1831 /// those inherited by it. 1832 void ASTContext::CollectInheritedProtocols(const Decl *CDecl, 1833 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) { 1834 if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) { 1835 // We can use protocol_iterator here instead of 1836 // all_referenced_protocol_iterator since we are walking all categories. 1837 for (auto *Proto : OI->all_referenced_protocols()) { 1838 Protocols.insert(Proto->getCanonicalDecl()); 1839 for (auto *P : Proto->protocols()) { 1840 Protocols.insert(P->getCanonicalDecl()); 1841 CollectInheritedProtocols(P, Protocols); 1842 } 1843 } 1844 1845 // Categories of this Interface. 1846 for (const auto *Cat : OI->visible_categories()) 1847 CollectInheritedProtocols(Cat, Protocols); 1848 1849 if (ObjCInterfaceDecl *SD = OI->getSuperClass()) 1850 while (SD) { 1851 CollectInheritedProtocols(SD, Protocols); 1852 SD = SD->getSuperClass(); 1853 } 1854 } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) { 1855 for (auto *Proto : OC->protocols()) { 1856 Protocols.insert(Proto->getCanonicalDecl()); 1857 for (const auto *P : Proto->protocols()) 1858 CollectInheritedProtocols(P, Protocols); 1859 } 1860 } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) { 1861 for (auto *Proto : OP->protocols()) { 1862 Protocols.insert(Proto->getCanonicalDecl()); 1863 for (const auto *P : Proto->protocols()) 1864 CollectInheritedProtocols(P, Protocols); 1865 } 1866 } 1867 } 1868 1869 unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const { 1870 unsigned count = 0; 1871 // Count ivars declared in class extension. 1872 for (const auto *Ext : OI->known_extensions()) 1873 count += Ext->ivar_size(); 1874 1875 // Count ivar defined in this class's implementation. This 1876 // includes synthesized ivars. 1877 if (ObjCImplementationDecl *ImplDecl = OI->getImplementation()) 1878 count += ImplDecl->ivar_size(); 1879 1880 return count; 1881 } 1882 1883 bool ASTContext::isSentinelNullExpr(const Expr *E) { 1884 if (!E) 1885 return false; 1886 1887 // nullptr_t is always treated as null. 1888 if (E->getType()->isNullPtrType()) return true; 1889 1890 if (E->getType()->isAnyPointerType() && 1891 E->IgnoreParenCasts()->isNullPointerConstant(*this, 1892 Expr::NPC_ValueDependentIsNull)) 1893 return true; 1894 1895 // Unfortunately, __null has type 'int'. 1896 if (isa<GNUNullExpr>(E)) return true; 1897 1898 return false; 1899 } 1900 1901 /// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists. 1902 ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) { 1903 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 1904 I = ObjCImpls.find(D); 1905 if (I != ObjCImpls.end()) 1906 return cast<ObjCImplementationDecl>(I->second); 1907 return nullptr; 1908 } 1909 /// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists. 1910 ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) { 1911 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 1912 I = ObjCImpls.find(D); 1913 if (I != ObjCImpls.end()) 1914 return cast<ObjCCategoryImplDecl>(I->second); 1915 return nullptr; 1916 } 1917 1918 /// \brief Set the implementation of ObjCInterfaceDecl. 1919 void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD, 1920 ObjCImplementationDecl *ImplD) { 1921 assert(IFaceD && ImplD && "Passed null params"); 1922 ObjCImpls[IFaceD] = ImplD; 1923 } 1924 /// \brief Set the implementation of ObjCCategoryDecl. 1925 void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD, 1926 ObjCCategoryImplDecl *ImplD) { 1927 assert(CatD && ImplD && "Passed null params"); 1928 ObjCImpls[CatD] = ImplD; 1929 } 1930 1931 const ObjCInterfaceDecl *ASTContext::getObjContainingInterface( 1932 const NamedDecl *ND) const { 1933 if (const ObjCInterfaceDecl *ID = 1934 dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext())) 1935 return ID; 1936 if (const ObjCCategoryDecl *CD = 1937 dyn_cast<ObjCCategoryDecl>(ND->getDeclContext())) 1938 return CD->getClassInterface(); 1939 if (const ObjCImplDecl *IMD = 1940 dyn_cast<ObjCImplDecl>(ND->getDeclContext())) 1941 return IMD->getClassInterface(); 1942 1943 return nullptr; 1944 } 1945 1946 /// \brief Get the copy initialization expression of VarDecl,or NULL if 1947 /// none exists. 1948 Expr *ASTContext::getBlockVarCopyInits(const VarDecl*VD) { 1949 assert(VD && "Passed null params"); 1950 assert(VD->hasAttr<BlocksAttr>() && 1951 "getBlockVarCopyInits - not __block var"); 1952 llvm::DenseMap<const VarDecl*, Expr*>::iterator 1953 I = BlockVarCopyInits.find(VD); 1954 return (I != BlockVarCopyInits.end()) ? cast<Expr>(I->second) : nullptr; 1955 } 1956 1957 /// \brief Set the copy inialization expression of a block var decl. 1958 void ASTContext::setBlockVarCopyInits(VarDecl*VD, Expr* Init) { 1959 assert(VD && Init && "Passed null params"); 1960 assert(VD->hasAttr<BlocksAttr>() && 1961 "setBlockVarCopyInits - not __block var"); 1962 BlockVarCopyInits[VD] = Init; 1963 } 1964 1965 TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T, 1966 unsigned DataSize) const { 1967 if (!DataSize) 1968 DataSize = TypeLoc::getFullDataSizeForType(T); 1969 else 1970 assert(DataSize == TypeLoc::getFullDataSizeForType(T) && 1971 "incorrect data size provided to CreateTypeSourceInfo!"); 1972 1973 TypeSourceInfo *TInfo = 1974 (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8); 1975 new (TInfo) TypeSourceInfo(T); 1976 return TInfo; 1977 } 1978 1979 TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T, 1980 SourceLocation L) const { 1981 TypeSourceInfo *DI = CreateTypeSourceInfo(T); 1982 DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L); 1983 return DI; 1984 } 1985 1986 const ASTRecordLayout & 1987 ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const { 1988 return getObjCLayout(D, nullptr); 1989 } 1990 1991 const ASTRecordLayout & 1992 ASTContext::getASTObjCImplementationLayout( 1993 const ObjCImplementationDecl *D) const { 1994 return getObjCLayout(D->getClassInterface(), D); 1995 } 1996 1997 //===----------------------------------------------------------------------===// 1998 // Type creation/memoization methods 1999 //===----------------------------------------------------------------------===// 2000 2001 QualType 2002 ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const { 2003 unsigned fastQuals = quals.getFastQualifiers(); 2004 quals.removeFastQualifiers(); 2005 2006 // Check if we've already instantiated this type. 2007 llvm::FoldingSetNodeID ID; 2008 ExtQuals::Profile(ID, baseType, quals); 2009 void *insertPos = nullptr; 2010 if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) { 2011 assert(eq->getQualifiers() == quals); 2012 return QualType(eq, fastQuals); 2013 } 2014 2015 // If the base type is not canonical, make the appropriate canonical type. 2016 QualType canon; 2017 if (!baseType->isCanonicalUnqualified()) { 2018 SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split(); 2019 canonSplit.Quals.addConsistentQualifiers(quals); 2020 canon = getExtQualType(canonSplit.Ty, canonSplit.Quals); 2021 2022 // Re-find the insert position. 2023 (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos); 2024 } 2025 2026 ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals); 2027 ExtQualNodes.InsertNode(eq, insertPos); 2028 return QualType(eq, fastQuals); 2029 } 2030 2031 QualType 2032 ASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) const { 2033 QualType CanT = getCanonicalType(T); 2034 if (CanT.getAddressSpace() == AddressSpace) 2035 return T; 2036 2037 // If we are composing extended qualifiers together, merge together 2038 // into one ExtQuals node. 2039 QualifierCollector Quals; 2040 const Type *TypeNode = Quals.strip(T); 2041 2042 // If this type already has an address space specified, it cannot get 2043 // another one. 2044 assert(!Quals.hasAddressSpace() && 2045 "Type cannot be in multiple addr spaces!"); 2046 Quals.addAddressSpace(AddressSpace); 2047 2048 return getExtQualType(TypeNode, Quals); 2049 } 2050 2051 QualType ASTContext::getObjCGCQualType(QualType T, 2052 Qualifiers::GC GCAttr) const { 2053 QualType CanT = getCanonicalType(T); 2054 if (CanT.getObjCGCAttr() == GCAttr) 2055 return T; 2056 2057 if (const PointerType *ptr = T->getAs<PointerType>()) { 2058 QualType Pointee = ptr->getPointeeType(); 2059 if (Pointee->isAnyPointerType()) { 2060 QualType ResultType = getObjCGCQualType(Pointee, GCAttr); 2061 return getPointerType(ResultType); 2062 } 2063 } 2064 2065 // If we are composing extended qualifiers together, merge together 2066 // into one ExtQuals node. 2067 QualifierCollector Quals; 2068 const Type *TypeNode = Quals.strip(T); 2069 2070 // If this type already has an ObjCGC specified, it cannot get 2071 // another one. 2072 assert(!Quals.hasObjCGCAttr() && 2073 "Type cannot have multiple ObjCGCs!"); 2074 Quals.addObjCGCAttr(GCAttr); 2075 2076 return getExtQualType(TypeNode, Quals); 2077 } 2078 2079 const FunctionType *ASTContext::adjustFunctionType(const FunctionType *T, 2080 FunctionType::ExtInfo Info) { 2081 if (T->getExtInfo() == Info) 2082 return T; 2083 2084 QualType Result; 2085 if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(T)) { 2086 Result = getFunctionNoProtoType(FNPT->getReturnType(), Info); 2087 } else { 2088 const FunctionProtoType *FPT = cast<FunctionProtoType>(T); 2089 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 2090 EPI.ExtInfo = Info; 2091 Result = getFunctionType(FPT->getReturnType(), FPT->getParamTypes(), EPI); 2092 } 2093 2094 return cast<FunctionType>(Result.getTypePtr()); 2095 } 2096 2097 void ASTContext::adjustDeducedFunctionResultType(FunctionDecl *FD, 2098 QualType ResultType) { 2099 FD = FD->getMostRecentDecl(); 2100 while (true) { 2101 const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>(); 2102 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 2103 FD->setType(getFunctionType(ResultType, FPT->getParamTypes(), EPI)); 2104 if (FunctionDecl *Next = FD->getPreviousDecl()) 2105 FD = Next; 2106 else 2107 break; 2108 } 2109 if (ASTMutationListener *L = getASTMutationListener()) 2110 L->DeducedReturnType(FD, ResultType); 2111 } 2112 2113 /// getComplexType - Return the uniqued reference to the type for a complex 2114 /// number with the specified element type. 2115 QualType ASTContext::getComplexType(QualType T) const { 2116 // Unique pointers, to guarantee there is only one pointer of a particular 2117 // structure. 2118 llvm::FoldingSetNodeID ID; 2119 ComplexType::Profile(ID, T); 2120 2121 void *InsertPos = nullptr; 2122 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 2123 return QualType(CT, 0); 2124 2125 // If the pointee type isn't canonical, this won't be a canonical type either, 2126 // so fill in the canonical type field. 2127 QualType Canonical; 2128 if (!T.isCanonical()) { 2129 Canonical = getComplexType(getCanonicalType(T)); 2130 2131 // Get the new insert position for the node we care about. 2132 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 2133 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2134 } 2135 ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical); 2136 Types.push_back(New); 2137 ComplexTypes.InsertNode(New, InsertPos); 2138 return QualType(New, 0); 2139 } 2140 2141 /// getPointerType - Return the uniqued reference to the type for a pointer to 2142 /// the specified type. 2143 QualType ASTContext::getPointerType(QualType T) const { 2144 // Unique pointers, to guarantee there is only one pointer of a particular 2145 // structure. 2146 llvm::FoldingSetNodeID ID; 2147 PointerType::Profile(ID, T); 2148 2149 void *InsertPos = nullptr; 2150 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 2151 return QualType(PT, 0); 2152 2153 // If the pointee type isn't canonical, this won't be a canonical type either, 2154 // so fill in the canonical type field. 2155 QualType Canonical; 2156 if (!T.isCanonical()) { 2157 Canonical = getPointerType(getCanonicalType(T)); 2158 2159 // Get the new insert position for the node we care about. 2160 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 2161 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2162 } 2163 PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical); 2164 Types.push_back(New); 2165 PointerTypes.InsertNode(New, InsertPos); 2166 return QualType(New, 0); 2167 } 2168 2169 QualType ASTContext::getAdjustedType(QualType Orig, QualType New) const { 2170 llvm::FoldingSetNodeID ID; 2171 AdjustedType::Profile(ID, Orig, New); 2172 void *InsertPos = nullptr; 2173 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos); 2174 if (AT) 2175 return QualType(AT, 0); 2176 2177 QualType Canonical = getCanonicalType(New); 2178 2179 // Get the new insert position for the node we care about. 2180 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos); 2181 assert(!AT && "Shouldn't be in the map!"); 2182 2183 AT = new (*this, TypeAlignment) 2184 AdjustedType(Type::Adjusted, Orig, New, Canonical); 2185 Types.push_back(AT); 2186 AdjustedTypes.InsertNode(AT, InsertPos); 2187 return QualType(AT, 0); 2188 } 2189 2190 QualType ASTContext::getDecayedType(QualType T) const { 2191 assert((T->isArrayType() || T->isFunctionType()) && "T does not decay"); 2192 2193 QualType Decayed; 2194 2195 // C99 6.7.5.3p7: 2196 // A declaration of a parameter as "array of type" shall be 2197 // adjusted to "qualified pointer to type", where the type 2198 // qualifiers (if any) are those specified within the [ and ] of 2199 // the array type derivation. 2200 if (T->isArrayType()) 2201 Decayed = getArrayDecayedType(T); 2202 2203 // C99 6.7.5.3p8: 2204 // A declaration of a parameter as "function returning type" 2205 // shall be adjusted to "pointer to function returning type", as 2206 // in 6.3.2.1. 2207 if (T->isFunctionType()) 2208 Decayed = getPointerType(T); 2209 2210 llvm::FoldingSetNodeID ID; 2211 AdjustedType::Profile(ID, T, Decayed); 2212 void *InsertPos = nullptr; 2213 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos); 2214 if (AT) 2215 return QualType(AT, 0); 2216 2217 QualType Canonical = getCanonicalType(Decayed); 2218 2219 // Get the new insert position for the node we care about. 2220 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos); 2221 assert(!AT && "Shouldn't be in the map!"); 2222 2223 AT = new (*this, TypeAlignment) DecayedType(T, Decayed, Canonical); 2224 Types.push_back(AT); 2225 AdjustedTypes.InsertNode(AT, InsertPos); 2226 return QualType(AT, 0); 2227 } 2228 2229 /// getBlockPointerType - Return the uniqued reference to the type for 2230 /// a pointer to the specified block. 2231 QualType ASTContext::getBlockPointerType(QualType T) const { 2232 assert(T->isFunctionType() && "block of function types only"); 2233 // Unique pointers, to guarantee there is only one block of a particular 2234 // structure. 2235 llvm::FoldingSetNodeID ID; 2236 BlockPointerType::Profile(ID, T); 2237 2238 void *InsertPos = nullptr; 2239 if (BlockPointerType *PT = 2240 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 2241 return QualType(PT, 0); 2242 2243 // If the block pointee type isn't canonical, this won't be a canonical 2244 // type either so fill in the canonical type field. 2245 QualType Canonical; 2246 if (!T.isCanonical()) { 2247 Canonical = getBlockPointerType(getCanonicalType(T)); 2248 2249 // Get the new insert position for the node we care about. 2250 BlockPointerType *NewIP = 2251 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 2252 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2253 } 2254 BlockPointerType *New 2255 = new (*this, TypeAlignment) BlockPointerType(T, Canonical); 2256 Types.push_back(New); 2257 BlockPointerTypes.InsertNode(New, InsertPos); 2258 return QualType(New, 0); 2259 } 2260 2261 /// getLValueReferenceType - Return the uniqued reference to the type for an 2262 /// lvalue reference to the specified type. 2263 QualType 2264 ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const { 2265 assert(getCanonicalType(T) != OverloadTy && 2266 "Unresolved overloaded function type"); 2267 2268 // Unique pointers, to guarantee there is only one pointer of a particular 2269 // structure. 2270 llvm::FoldingSetNodeID ID; 2271 ReferenceType::Profile(ID, T, SpelledAsLValue); 2272 2273 void *InsertPos = nullptr; 2274 if (LValueReferenceType *RT = 2275 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 2276 return QualType(RT, 0); 2277 2278 const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 2279 2280 // If the referencee type isn't canonical, this won't be a canonical type 2281 // either, so fill in the canonical type field. 2282 QualType Canonical; 2283 if (!SpelledAsLValue || InnerRef || !T.isCanonical()) { 2284 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 2285 Canonical = getLValueReferenceType(getCanonicalType(PointeeType)); 2286 2287 // Get the new insert position for the node we care about. 2288 LValueReferenceType *NewIP = 2289 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 2290 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2291 } 2292 2293 LValueReferenceType *New 2294 = new (*this, TypeAlignment) LValueReferenceType(T, Canonical, 2295 SpelledAsLValue); 2296 Types.push_back(New); 2297 LValueReferenceTypes.InsertNode(New, InsertPos); 2298 2299 return QualType(New, 0); 2300 } 2301 2302 /// getRValueReferenceType - Return the uniqued reference to the type for an 2303 /// rvalue reference to the specified type. 2304 QualType ASTContext::getRValueReferenceType(QualType T) const { 2305 // Unique pointers, to guarantee there is only one pointer of a particular 2306 // structure. 2307 llvm::FoldingSetNodeID ID; 2308 ReferenceType::Profile(ID, T, false); 2309 2310 void *InsertPos = nullptr; 2311 if (RValueReferenceType *RT = 2312 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 2313 return QualType(RT, 0); 2314 2315 const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 2316 2317 // If the referencee type isn't canonical, this won't be a canonical type 2318 // either, so fill in the canonical type field. 2319 QualType Canonical; 2320 if (InnerRef || !T.isCanonical()) { 2321 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 2322 Canonical = getRValueReferenceType(getCanonicalType(PointeeType)); 2323 2324 // Get the new insert position for the node we care about. 2325 RValueReferenceType *NewIP = 2326 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 2327 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2328 } 2329 2330 RValueReferenceType *New 2331 = new (*this, TypeAlignment) RValueReferenceType(T, Canonical); 2332 Types.push_back(New); 2333 RValueReferenceTypes.InsertNode(New, InsertPos); 2334 return QualType(New, 0); 2335 } 2336 2337 /// getMemberPointerType - Return the uniqued reference to the type for a 2338 /// member pointer to the specified type, in the specified class. 2339 QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const { 2340 // Unique pointers, to guarantee there is only one pointer of a particular 2341 // structure. 2342 llvm::FoldingSetNodeID ID; 2343 MemberPointerType::Profile(ID, T, Cls); 2344 2345 void *InsertPos = nullptr; 2346 if (MemberPointerType *PT = 2347 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 2348 return QualType(PT, 0); 2349 2350 // If the pointee or class type isn't canonical, this won't be a canonical 2351 // type either, so fill in the canonical type field. 2352 QualType Canonical; 2353 if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) { 2354 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls)); 2355 2356 // Get the new insert position for the node we care about. 2357 MemberPointerType *NewIP = 2358 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 2359 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2360 } 2361 MemberPointerType *New 2362 = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical); 2363 Types.push_back(New); 2364 MemberPointerTypes.InsertNode(New, InsertPos); 2365 return QualType(New, 0); 2366 } 2367 2368 /// getConstantArrayType - Return the unique reference to the type for an 2369 /// array of the specified element type. 2370 QualType ASTContext::getConstantArrayType(QualType EltTy, 2371 const llvm::APInt &ArySizeIn, 2372 ArrayType::ArraySizeModifier ASM, 2373 unsigned IndexTypeQuals) const { 2374 assert((EltTy->isDependentType() || 2375 EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && 2376 "Constant array of VLAs is illegal!"); 2377 2378 // Convert the array size into a canonical width matching the pointer size for 2379 // the target. 2380 llvm::APInt ArySize(ArySizeIn); 2381 ArySize = 2382 ArySize.zextOrTrunc(Target->getPointerWidth(getTargetAddressSpace(EltTy))); 2383 2384 llvm::FoldingSetNodeID ID; 2385 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals); 2386 2387 void *InsertPos = nullptr; 2388 if (ConstantArrayType *ATP = 2389 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 2390 return QualType(ATP, 0); 2391 2392 // If the element type isn't canonical or has qualifiers, this won't 2393 // be a canonical type either, so fill in the canonical type field. 2394 QualType Canon; 2395 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 2396 SplitQualType canonSplit = getCanonicalType(EltTy).split(); 2397 Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize, 2398 ASM, IndexTypeQuals); 2399 Canon = getQualifiedType(Canon, canonSplit.Quals); 2400 2401 // Get the new insert position for the node we care about. 2402 ConstantArrayType *NewIP = 2403 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 2404 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2405 } 2406 2407 ConstantArrayType *New = new(*this,TypeAlignment) 2408 ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals); 2409 ConstantArrayTypes.InsertNode(New, InsertPos); 2410 Types.push_back(New); 2411 return QualType(New, 0); 2412 } 2413 2414 /// getVariableArrayDecayedType - Turns the given type, which may be 2415 /// variably-modified, into the corresponding type with all the known 2416 /// sizes replaced with [*]. 2417 QualType ASTContext::getVariableArrayDecayedType(QualType type) const { 2418 // Vastly most common case. 2419 if (!type->isVariablyModifiedType()) return type; 2420 2421 QualType result; 2422 2423 SplitQualType split = type.getSplitDesugaredType(); 2424 const Type *ty = split.Ty; 2425 switch (ty->getTypeClass()) { 2426 #define TYPE(Class, Base) 2427 #define ABSTRACT_TYPE(Class, Base) 2428 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 2429 #include "clang/AST/TypeNodes.def" 2430 llvm_unreachable("didn't desugar past all non-canonical types?"); 2431 2432 // These types should never be variably-modified. 2433 case Type::Builtin: 2434 case Type::Complex: 2435 case Type::Vector: 2436 case Type::ExtVector: 2437 case Type::DependentSizedExtVector: 2438 case Type::ObjCObject: 2439 case Type::ObjCInterface: 2440 case Type::ObjCObjectPointer: 2441 case Type::Record: 2442 case Type::Enum: 2443 case Type::UnresolvedUsing: 2444 case Type::TypeOfExpr: 2445 case Type::TypeOf: 2446 case Type::Decltype: 2447 case Type::UnaryTransform: 2448 case Type::DependentName: 2449 case Type::InjectedClassName: 2450 case Type::TemplateSpecialization: 2451 case Type::DependentTemplateSpecialization: 2452 case Type::TemplateTypeParm: 2453 case Type::SubstTemplateTypeParmPack: 2454 case Type::Auto: 2455 case Type::PackExpansion: 2456 llvm_unreachable("type should never be variably-modified"); 2457 2458 // These types can be variably-modified but should never need to 2459 // further decay. 2460 case Type::FunctionNoProto: 2461 case Type::FunctionProto: 2462 case Type::BlockPointer: 2463 case Type::MemberPointer: 2464 return type; 2465 2466 // These types can be variably-modified. All these modifications 2467 // preserve structure except as noted by comments. 2468 // TODO: if we ever care about optimizing VLAs, there are no-op 2469 // optimizations available here. 2470 case Type::Pointer: 2471 result = getPointerType(getVariableArrayDecayedType( 2472 cast<PointerType>(ty)->getPointeeType())); 2473 break; 2474 2475 case Type::LValueReference: { 2476 const LValueReferenceType *lv = cast<LValueReferenceType>(ty); 2477 result = getLValueReferenceType( 2478 getVariableArrayDecayedType(lv->getPointeeType()), 2479 lv->isSpelledAsLValue()); 2480 break; 2481 } 2482 2483 case Type::RValueReference: { 2484 const RValueReferenceType *lv = cast<RValueReferenceType>(ty); 2485 result = getRValueReferenceType( 2486 getVariableArrayDecayedType(lv->getPointeeType())); 2487 break; 2488 } 2489 2490 case Type::Atomic: { 2491 const AtomicType *at = cast<AtomicType>(ty); 2492 result = getAtomicType(getVariableArrayDecayedType(at->getValueType())); 2493 break; 2494 } 2495 2496 case Type::ConstantArray: { 2497 const ConstantArrayType *cat = cast<ConstantArrayType>(ty); 2498 result = getConstantArrayType( 2499 getVariableArrayDecayedType(cat->getElementType()), 2500 cat->getSize(), 2501 cat->getSizeModifier(), 2502 cat->getIndexTypeCVRQualifiers()); 2503 break; 2504 } 2505 2506 case Type::DependentSizedArray: { 2507 const DependentSizedArrayType *dat = cast<DependentSizedArrayType>(ty); 2508 result = getDependentSizedArrayType( 2509 getVariableArrayDecayedType(dat->getElementType()), 2510 dat->getSizeExpr(), 2511 dat->getSizeModifier(), 2512 dat->getIndexTypeCVRQualifiers(), 2513 dat->getBracketsRange()); 2514 break; 2515 } 2516 2517 // Turn incomplete types into [*] types. 2518 case Type::IncompleteArray: { 2519 const IncompleteArrayType *iat = cast<IncompleteArrayType>(ty); 2520 result = getVariableArrayType( 2521 getVariableArrayDecayedType(iat->getElementType()), 2522 /*size*/ nullptr, 2523 ArrayType::Normal, 2524 iat->getIndexTypeCVRQualifiers(), 2525 SourceRange()); 2526 break; 2527 } 2528 2529 // Turn VLA types into [*] types. 2530 case Type::VariableArray: { 2531 const VariableArrayType *vat = cast<VariableArrayType>(ty); 2532 result = getVariableArrayType( 2533 getVariableArrayDecayedType(vat->getElementType()), 2534 /*size*/ nullptr, 2535 ArrayType::Star, 2536 vat->getIndexTypeCVRQualifiers(), 2537 vat->getBracketsRange()); 2538 break; 2539 } 2540 } 2541 2542 // Apply the top-level qualifiers from the original. 2543 return getQualifiedType(result, split.Quals); 2544 } 2545 2546 /// getVariableArrayType - Returns a non-unique reference to the type for a 2547 /// variable array of the specified element type. 2548 QualType ASTContext::getVariableArrayType(QualType EltTy, 2549 Expr *NumElts, 2550 ArrayType::ArraySizeModifier ASM, 2551 unsigned IndexTypeQuals, 2552 SourceRange Brackets) const { 2553 // Since we don't unique expressions, it isn't possible to unique VLA's 2554 // that have an expression provided for their size. 2555 QualType Canon; 2556 2557 // Be sure to pull qualifiers off the element type. 2558 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 2559 SplitQualType canonSplit = getCanonicalType(EltTy).split(); 2560 Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM, 2561 IndexTypeQuals, Brackets); 2562 Canon = getQualifiedType(Canon, canonSplit.Quals); 2563 } 2564 2565 VariableArrayType *New = new(*this, TypeAlignment) 2566 VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets); 2567 2568 VariableArrayTypes.push_back(New); 2569 Types.push_back(New); 2570 return QualType(New, 0); 2571 } 2572 2573 /// getDependentSizedArrayType - Returns a non-unique reference to 2574 /// the type for a dependently-sized array of the specified element 2575 /// type. 2576 QualType ASTContext::getDependentSizedArrayType(QualType elementType, 2577 Expr *numElements, 2578 ArrayType::ArraySizeModifier ASM, 2579 unsigned elementTypeQuals, 2580 SourceRange brackets) const { 2581 assert((!numElements || numElements->isTypeDependent() || 2582 numElements->isValueDependent()) && 2583 "Size must be type- or value-dependent!"); 2584 2585 // Dependently-sized array types that do not have a specified number 2586 // of elements will have their sizes deduced from a dependent 2587 // initializer. We do no canonicalization here at all, which is okay 2588 // because they can't be used in most locations. 2589 if (!numElements) { 2590 DependentSizedArrayType *newType 2591 = new (*this, TypeAlignment) 2592 DependentSizedArrayType(*this, elementType, QualType(), 2593 numElements, ASM, elementTypeQuals, 2594 brackets); 2595 Types.push_back(newType); 2596 return QualType(newType, 0); 2597 } 2598 2599 // Otherwise, we actually build a new type every time, but we 2600 // also build a canonical type. 2601 2602 SplitQualType canonElementType = getCanonicalType(elementType).split(); 2603 2604 void *insertPos = nullptr; 2605 llvm::FoldingSetNodeID ID; 2606 DependentSizedArrayType::Profile(ID, *this, 2607 QualType(canonElementType.Ty, 0), 2608 ASM, elementTypeQuals, numElements); 2609 2610 // Look for an existing type with these properties. 2611 DependentSizedArrayType *canonTy = 2612 DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos); 2613 2614 // If we don't have one, build one. 2615 if (!canonTy) { 2616 canonTy = new (*this, TypeAlignment) 2617 DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0), 2618 QualType(), numElements, ASM, elementTypeQuals, 2619 brackets); 2620 DependentSizedArrayTypes.InsertNode(canonTy, insertPos); 2621 Types.push_back(canonTy); 2622 } 2623 2624 // Apply qualifiers from the element type to the array. 2625 QualType canon = getQualifiedType(QualType(canonTy,0), 2626 canonElementType.Quals); 2627 2628 // If we didn't need extra canonicalization for the element type, 2629 // then just use that as our result. 2630 if (QualType(canonElementType.Ty, 0) == elementType) 2631 return canon; 2632 2633 // Otherwise, we need to build a type which follows the spelling 2634 // of the element type. 2635 DependentSizedArrayType *sugaredType 2636 = new (*this, TypeAlignment) 2637 DependentSizedArrayType(*this, elementType, canon, numElements, 2638 ASM, elementTypeQuals, brackets); 2639 Types.push_back(sugaredType); 2640 return QualType(sugaredType, 0); 2641 } 2642 2643 QualType ASTContext::getIncompleteArrayType(QualType elementType, 2644 ArrayType::ArraySizeModifier ASM, 2645 unsigned elementTypeQuals) const { 2646 llvm::FoldingSetNodeID ID; 2647 IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals); 2648 2649 void *insertPos = nullptr; 2650 if (IncompleteArrayType *iat = 2651 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos)) 2652 return QualType(iat, 0); 2653 2654 // If the element type isn't canonical, this won't be a canonical type 2655 // either, so fill in the canonical type field. We also have to pull 2656 // qualifiers off the element type. 2657 QualType canon; 2658 2659 if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) { 2660 SplitQualType canonSplit = getCanonicalType(elementType).split(); 2661 canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0), 2662 ASM, elementTypeQuals); 2663 canon = getQualifiedType(canon, canonSplit.Quals); 2664 2665 // Get the new insert position for the node we care about. 2666 IncompleteArrayType *existing = 2667 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos); 2668 assert(!existing && "Shouldn't be in the map!"); (void) existing; 2669 } 2670 2671 IncompleteArrayType *newType = new (*this, TypeAlignment) 2672 IncompleteArrayType(elementType, canon, ASM, elementTypeQuals); 2673 2674 IncompleteArrayTypes.InsertNode(newType, insertPos); 2675 Types.push_back(newType); 2676 return QualType(newType, 0); 2677 } 2678 2679 /// getVectorType - Return the unique reference to a vector type of 2680 /// the specified element type and size. VectorType must be a built-in type. 2681 QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts, 2682 VectorType::VectorKind VecKind) const { 2683 assert(vecType->isBuiltinType()); 2684 2685 // Check if we've already instantiated a vector of this type. 2686 llvm::FoldingSetNodeID ID; 2687 VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind); 2688 2689 void *InsertPos = nullptr; 2690 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 2691 return QualType(VTP, 0); 2692 2693 // If the element type isn't canonical, this won't be a canonical type either, 2694 // so fill in the canonical type field. 2695 QualType Canonical; 2696 if (!vecType.isCanonical()) { 2697 Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind); 2698 2699 // Get the new insert position for the node we care about. 2700 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2701 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2702 } 2703 VectorType *New = new (*this, TypeAlignment) 2704 VectorType(vecType, NumElts, Canonical, VecKind); 2705 VectorTypes.InsertNode(New, InsertPos); 2706 Types.push_back(New); 2707 return QualType(New, 0); 2708 } 2709 2710 /// getExtVectorType - Return the unique reference to an extended vector type of 2711 /// the specified element type and size. VectorType must be a built-in type. 2712 QualType 2713 ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const { 2714 assert(vecType->isBuiltinType() || vecType->isDependentType()); 2715 2716 // Check if we've already instantiated a vector of this type. 2717 llvm::FoldingSetNodeID ID; 2718 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector, 2719 VectorType::GenericVector); 2720 void *InsertPos = nullptr; 2721 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 2722 return QualType(VTP, 0); 2723 2724 // If the element type isn't canonical, this won't be a canonical type either, 2725 // so fill in the canonical type field. 2726 QualType Canonical; 2727 if (!vecType.isCanonical()) { 2728 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts); 2729 2730 // Get the new insert position for the node we care about. 2731 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2732 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2733 } 2734 ExtVectorType *New = new (*this, TypeAlignment) 2735 ExtVectorType(vecType, NumElts, Canonical); 2736 VectorTypes.InsertNode(New, InsertPos); 2737 Types.push_back(New); 2738 return QualType(New, 0); 2739 } 2740 2741 QualType 2742 ASTContext::getDependentSizedExtVectorType(QualType vecType, 2743 Expr *SizeExpr, 2744 SourceLocation AttrLoc) const { 2745 llvm::FoldingSetNodeID ID; 2746 DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType), 2747 SizeExpr); 2748 2749 void *InsertPos = nullptr; 2750 DependentSizedExtVectorType *Canon 2751 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2752 DependentSizedExtVectorType *New; 2753 if (Canon) { 2754 // We already have a canonical version of this array type; use it as 2755 // the canonical type for a newly-built type. 2756 New = new (*this, TypeAlignment) 2757 DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0), 2758 SizeExpr, AttrLoc); 2759 } else { 2760 QualType CanonVecTy = getCanonicalType(vecType); 2761 if (CanonVecTy == vecType) { 2762 New = new (*this, TypeAlignment) 2763 DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr, 2764 AttrLoc); 2765 2766 DependentSizedExtVectorType *CanonCheck 2767 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2768 assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken"); 2769 (void)CanonCheck; 2770 DependentSizedExtVectorTypes.InsertNode(New, InsertPos); 2771 } else { 2772 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr, 2773 SourceLocation()); 2774 New = new (*this, TypeAlignment) 2775 DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc); 2776 } 2777 } 2778 2779 Types.push_back(New); 2780 return QualType(New, 0); 2781 } 2782 2783 /// getFunctionNoProtoType - Return a K&R style C function type like 'int()'. 2784 /// 2785 QualType 2786 ASTContext::getFunctionNoProtoType(QualType ResultTy, 2787 const FunctionType::ExtInfo &Info) const { 2788 const CallingConv CallConv = Info.getCC(); 2789 2790 // Unique functions, to guarantee there is only one function of a particular 2791 // structure. 2792 llvm::FoldingSetNodeID ID; 2793 FunctionNoProtoType::Profile(ID, ResultTy, Info); 2794 2795 void *InsertPos = nullptr; 2796 if (FunctionNoProtoType *FT = 2797 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 2798 return QualType(FT, 0); 2799 2800 QualType Canonical; 2801 if (!ResultTy.isCanonical()) { 2802 Canonical = getFunctionNoProtoType(getCanonicalType(ResultTy), Info); 2803 2804 // Get the new insert position for the node we care about. 2805 FunctionNoProtoType *NewIP = 2806 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2807 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2808 } 2809 2810 FunctionProtoType::ExtInfo newInfo = Info.withCallingConv(CallConv); 2811 FunctionNoProtoType *New = new (*this, TypeAlignment) 2812 FunctionNoProtoType(ResultTy, Canonical, newInfo); 2813 Types.push_back(New); 2814 FunctionNoProtoTypes.InsertNode(New, InsertPos); 2815 return QualType(New, 0); 2816 } 2817 2818 /// \brief Determine whether \p T is canonical as the result type of a function. 2819 static bool isCanonicalResultType(QualType T) { 2820 return T.isCanonical() && 2821 (T.getObjCLifetime() == Qualifiers::OCL_None || 2822 T.getObjCLifetime() == Qualifiers::OCL_ExplicitNone); 2823 } 2824 2825 QualType 2826 ASTContext::getFunctionType(QualType ResultTy, ArrayRef<QualType> ArgArray, 2827 const FunctionProtoType::ExtProtoInfo &EPI) const { 2828 size_t NumArgs = ArgArray.size(); 2829 2830 // Unique functions, to guarantee there is only one function of a particular 2831 // structure. 2832 llvm::FoldingSetNodeID ID; 2833 FunctionProtoType::Profile(ID, ResultTy, ArgArray.begin(), NumArgs, EPI, 2834 *this); 2835 2836 void *InsertPos = nullptr; 2837 if (FunctionProtoType *FTP = 2838 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 2839 return QualType(FTP, 0); 2840 2841 // Determine whether the type being created is already canonical or not. 2842 bool isCanonical = 2843 EPI.ExceptionSpecType == EST_None && isCanonicalResultType(ResultTy) && 2844 !EPI.HasTrailingReturn; 2845 for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 2846 if (!ArgArray[i].isCanonicalAsParam()) 2847 isCanonical = false; 2848 2849 // If this type isn't canonical, get the canonical version of it. 2850 // The exception spec is not part of the canonical type. 2851 QualType Canonical; 2852 if (!isCanonical) { 2853 SmallVector<QualType, 16> CanonicalArgs; 2854 CanonicalArgs.reserve(NumArgs); 2855 for (unsigned i = 0; i != NumArgs; ++i) 2856 CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i])); 2857 2858 FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI; 2859 CanonicalEPI.HasTrailingReturn = false; 2860 CanonicalEPI.ExceptionSpecType = EST_None; 2861 CanonicalEPI.NumExceptions = 0; 2862 2863 // Result types do not have ARC lifetime qualifiers. 2864 QualType CanResultTy = getCanonicalType(ResultTy); 2865 if (ResultTy.getQualifiers().hasObjCLifetime()) { 2866 Qualifiers Qs = CanResultTy.getQualifiers(); 2867 Qs.removeObjCLifetime(); 2868 CanResultTy = getQualifiedType(CanResultTy.getUnqualifiedType(), Qs); 2869 } 2870 2871 Canonical = getFunctionType(CanResultTy, CanonicalArgs, CanonicalEPI); 2872 2873 // Get the new insert position for the node we care about. 2874 FunctionProtoType *NewIP = 2875 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2876 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 2877 } 2878 2879 // FunctionProtoType objects are allocated with extra bytes after 2880 // them for three variable size arrays at the end: 2881 // - parameter types 2882 // - exception types 2883 // - consumed-arguments flags 2884 // Instead of the exception types, there could be a noexcept 2885 // expression, or information used to resolve the exception 2886 // specification. 2887 size_t Size = sizeof(FunctionProtoType) + 2888 NumArgs * sizeof(QualType); 2889 if (EPI.ExceptionSpecType == EST_Dynamic) { 2890 Size += EPI.NumExceptions * sizeof(QualType); 2891 } else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { 2892 Size += sizeof(Expr*); 2893 } else if (EPI.ExceptionSpecType == EST_Uninstantiated) { 2894 Size += 2 * sizeof(FunctionDecl*); 2895 } else if (EPI.ExceptionSpecType == EST_Unevaluated) { 2896 Size += sizeof(FunctionDecl*); 2897 } 2898 if (EPI.ConsumedParameters) 2899 Size += NumArgs * sizeof(bool); 2900 2901 FunctionProtoType *FTP = (FunctionProtoType*) Allocate(Size, TypeAlignment); 2902 FunctionProtoType::ExtProtoInfo newEPI = EPI; 2903 new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI); 2904 Types.push_back(FTP); 2905 FunctionProtoTypes.InsertNode(FTP, InsertPos); 2906 return QualType(FTP, 0); 2907 } 2908 2909 #ifndef NDEBUG 2910 static bool NeedsInjectedClassNameType(const RecordDecl *D) { 2911 if (!isa<CXXRecordDecl>(D)) return false; 2912 const CXXRecordDecl *RD = cast<CXXRecordDecl>(D); 2913 if (isa<ClassTemplatePartialSpecializationDecl>(RD)) 2914 return true; 2915 if (RD->getDescribedClassTemplate() && 2916 !isa<ClassTemplateSpecializationDecl>(RD)) 2917 return true; 2918 return false; 2919 } 2920 #endif 2921 2922 /// getInjectedClassNameType - Return the unique reference to the 2923 /// injected class name type for the specified templated declaration. 2924 QualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl, 2925 QualType TST) const { 2926 assert(NeedsInjectedClassNameType(Decl)); 2927 if (Decl->TypeForDecl) { 2928 assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 2929 } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) { 2930 assert(PrevDecl->TypeForDecl && "previous declaration has no type"); 2931 Decl->TypeForDecl = PrevDecl->TypeForDecl; 2932 assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 2933 } else { 2934 Type *newType = 2935 new (*this, TypeAlignment) InjectedClassNameType(Decl, TST); 2936 Decl->TypeForDecl = newType; 2937 Types.push_back(newType); 2938 } 2939 return QualType(Decl->TypeForDecl, 0); 2940 } 2941 2942 /// getTypeDeclType - Return the unique reference to the type for the 2943 /// specified type declaration. 2944 QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const { 2945 assert(Decl && "Passed null for Decl param"); 2946 assert(!Decl->TypeForDecl && "TypeForDecl present in slow case"); 2947 2948 if (const TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Decl)) 2949 return getTypedefType(Typedef); 2950 2951 assert(!isa<TemplateTypeParmDecl>(Decl) && 2952 "Template type parameter types are always available."); 2953 2954 if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) { 2955 assert(Record->isFirstDecl() && "struct/union has previous declaration"); 2956 assert(!NeedsInjectedClassNameType(Record)); 2957 return getRecordType(Record); 2958 } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) { 2959 assert(Enum->isFirstDecl() && "enum has previous declaration"); 2960 return getEnumType(Enum); 2961 } else if (const UnresolvedUsingTypenameDecl *Using = 2962 dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) { 2963 Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using); 2964 Decl->TypeForDecl = newType; 2965 Types.push_back(newType); 2966 } else 2967 llvm_unreachable("TypeDecl without a type?"); 2968 2969 return QualType(Decl->TypeForDecl, 0); 2970 } 2971 2972 /// getTypedefType - Return the unique reference to the type for the 2973 /// specified typedef name decl. 2974 QualType 2975 ASTContext::getTypedefType(const TypedefNameDecl *Decl, 2976 QualType Canonical) const { 2977 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2978 2979 if (Canonical.isNull()) 2980 Canonical = getCanonicalType(Decl->getUnderlyingType()); 2981 TypedefType *newType = new(*this, TypeAlignment) 2982 TypedefType(Type::Typedef, Decl, Canonical); 2983 Decl->TypeForDecl = newType; 2984 Types.push_back(newType); 2985 return QualType(newType, 0); 2986 } 2987 2988 QualType ASTContext::getRecordType(const RecordDecl *Decl) const { 2989 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2990 2991 if (const RecordDecl *PrevDecl = Decl->getPreviousDecl()) 2992 if (PrevDecl->TypeForDecl) 2993 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2994 2995 RecordType *newType = new (*this, TypeAlignment) RecordType(Decl); 2996 Decl->TypeForDecl = newType; 2997 Types.push_back(newType); 2998 return QualType(newType, 0); 2999 } 3000 3001 QualType ASTContext::getEnumType(const EnumDecl *Decl) const { 3002 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 3003 3004 if (const EnumDecl *PrevDecl = Decl->getPreviousDecl()) 3005 if (PrevDecl->TypeForDecl) 3006 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 3007 3008 EnumType *newType = new (*this, TypeAlignment) EnumType(Decl); 3009 Decl->TypeForDecl = newType; 3010 Types.push_back(newType); 3011 return QualType(newType, 0); 3012 } 3013 3014 QualType ASTContext::getAttributedType(AttributedType::Kind attrKind, 3015 QualType modifiedType, 3016 QualType equivalentType) { 3017 llvm::FoldingSetNodeID id; 3018 AttributedType::Profile(id, attrKind, modifiedType, equivalentType); 3019 3020 void *insertPos = nullptr; 3021 AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos); 3022 if (type) return QualType(type, 0); 3023 3024 QualType canon = getCanonicalType(equivalentType); 3025 type = new (*this, TypeAlignment) 3026 AttributedType(canon, attrKind, modifiedType, equivalentType); 3027 3028 Types.push_back(type); 3029 AttributedTypes.InsertNode(type, insertPos); 3030 3031 return QualType(type, 0); 3032 } 3033 3034 3035 /// \brief Retrieve a substitution-result type. 3036 QualType 3037 ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm, 3038 QualType Replacement) const { 3039 assert(Replacement.isCanonical() 3040 && "replacement types must always be canonical"); 3041 3042 llvm::FoldingSetNodeID ID; 3043 SubstTemplateTypeParmType::Profile(ID, Parm, Replacement); 3044 void *InsertPos = nullptr; 3045 SubstTemplateTypeParmType *SubstParm 3046 = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 3047 3048 if (!SubstParm) { 3049 SubstParm = new (*this, TypeAlignment) 3050 SubstTemplateTypeParmType(Parm, Replacement); 3051 Types.push_back(SubstParm); 3052 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 3053 } 3054 3055 return QualType(SubstParm, 0); 3056 } 3057 3058 /// \brief Retrieve a 3059 QualType ASTContext::getSubstTemplateTypeParmPackType( 3060 const TemplateTypeParmType *Parm, 3061 const TemplateArgument &ArgPack) { 3062 #ifndef NDEBUG 3063 for (TemplateArgument::pack_iterator P = ArgPack.pack_begin(), 3064 PEnd = ArgPack.pack_end(); 3065 P != PEnd; ++P) { 3066 assert(P->getKind() == TemplateArgument::Type &&"Pack contains a non-type"); 3067 assert(P->getAsType().isCanonical() && "Pack contains non-canonical type"); 3068 } 3069 #endif 3070 3071 llvm::FoldingSetNodeID ID; 3072 SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack); 3073 void *InsertPos = nullptr; 3074 if (SubstTemplateTypeParmPackType *SubstParm 3075 = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos)) 3076 return QualType(SubstParm, 0); 3077 3078 QualType Canon; 3079 if (!Parm->isCanonicalUnqualified()) { 3080 Canon = getCanonicalType(QualType(Parm, 0)); 3081 Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon), 3082 ArgPack); 3083 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos); 3084 } 3085 3086 SubstTemplateTypeParmPackType *SubstParm 3087 = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon, 3088 ArgPack); 3089 Types.push_back(SubstParm); 3090 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 3091 return QualType(SubstParm, 0); 3092 } 3093 3094 /// \brief Retrieve the template type parameter type for a template 3095 /// parameter or parameter pack with the given depth, index, and (optionally) 3096 /// name. 3097 QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index, 3098 bool ParameterPack, 3099 TemplateTypeParmDecl *TTPDecl) const { 3100 llvm::FoldingSetNodeID ID; 3101 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl); 3102 void *InsertPos = nullptr; 3103 TemplateTypeParmType *TypeParm 3104 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 3105 3106 if (TypeParm) 3107 return QualType(TypeParm, 0); 3108 3109 if (TTPDecl) { 3110 QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack); 3111 TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon); 3112 3113 TemplateTypeParmType *TypeCheck 3114 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 3115 assert(!TypeCheck && "Template type parameter canonical type broken"); 3116 (void)TypeCheck; 3117 } else 3118 TypeParm = new (*this, TypeAlignment) 3119 TemplateTypeParmType(Depth, Index, ParameterPack); 3120 3121 Types.push_back(TypeParm); 3122 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos); 3123 3124 return QualType(TypeParm, 0); 3125 } 3126 3127 TypeSourceInfo * 3128 ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name, 3129 SourceLocation NameLoc, 3130 const TemplateArgumentListInfo &Args, 3131 QualType Underlying) const { 3132 assert(!Name.getAsDependentTemplateName() && 3133 "No dependent template names here!"); 3134 QualType TST = getTemplateSpecializationType(Name, Args, Underlying); 3135 3136 TypeSourceInfo *DI = CreateTypeSourceInfo(TST); 3137 TemplateSpecializationTypeLoc TL = 3138 DI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>(); 3139 TL.setTemplateKeywordLoc(SourceLocation()); 3140 TL.setTemplateNameLoc(NameLoc); 3141 TL.setLAngleLoc(Args.getLAngleLoc()); 3142 TL.setRAngleLoc(Args.getRAngleLoc()); 3143 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3144 TL.setArgLocInfo(i, Args[i].getLocInfo()); 3145 return DI; 3146 } 3147 3148 QualType 3149 ASTContext::getTemplateSpecializationType(TemplateName Template, 3150 const TemplateArgumentListInfo &Args, 3151 QualType Underlying) const { 3152 assert(!Template.getAsDependentTemplateName() && 3153 "No dependent template names here!"); 3154 3155 unsigned NumArgs = Args.size(); 3156 3157 SmallVector<TemplateArgument, 4> ArgVec; 3158 ArgVec.reserve(NumArgs); 3159 for (unsigned i = 0; i != NumArgs; ++i) 3160 ArgVec.push_back(Args[i].getArgument()); 3161 3162 return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs, 3163 Underlying); 3164 } 3165 3166 #ifndef NDEBUG 3167 static bool hasAnyPackExpansions(const TemplateArgument *Args, 3168 unsigned NumArgs) { 3169 for (unsigned I = 0; I != NumArgs; ++I) 3170 if (Args[I].isPackExpansion()) 3171 return true; 3172 3173 return true; 3174 } 3175 #endif 3176 3177 QualType 3178 ASTContext::getTemplateSpecializationType(TemplateName Template, 3179 const TemplateArgument *Args, 3180 unsigned NumArgs, 3181 QualType Underlying) const { 3182 assert(!Template.getAsDependentTemplateName() && 3183 "No dependent template names here!"); 3184 // Look through qualified template names. 3185 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 3186 Template = TemplateName(QTN->getTemplateDecl()); 3187 3188 bool IsTypeAlias = 3189 Template.getAsTemplateDecl() && 3190 isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl()); 3191 QualType CanonType; 3192 if (!Underlying.isNull()) 3193 CanonType = getCanonicalType(Underlying); 3194 else { 3195 // We can get here with an alias template when the specialization contains 3196 // a pack expansion that does not match up with a parameter pack. 3197 assert((!IsTypeAlias || hasAnyPackExpansions(Args, NumArgs)) && 3198 "Caller must compute aliased type"); 3199 IsTypeAlias = false; 3200 CanonType = getCanonicalTemplateSpecializationType(Template, Args, 3201 NumArgs); 3202 } 3203 3204 // Allocate the (non-canonical) template specialization type, but don't 3205 // try to unique it: these types typically have location information that 3206 // we don't unique and don't want to lose. 3207 void *Mem = Allocate(sizeof(TemplateSpecializationType) + 3208 sizeof(TemplateArgument) * NumArgs + 3209 (IsTypeAlias? sizeof(QualType) : 0), 3210 TypeAlignment); 3211 TemplateSpecializationType *Spec 3212 = new (Mem) TemplateSpecializationType(Template, Args, NumArgs, CanonType, 3213 IsTypeAlias ? Underlying : QualType()); 3214 3215 Types.push_back(Spec); 3216 return QualType(Spec, 0); 3217 } 3218 3219 QualType 3220 ASTContext::getCanonicalTemplateSpecializationType(TemplateName Template, 3221 const TemplateArgument *Args, 3222 unsigned NumArgs) const { 3223 assert(!Template.getAsDependentTemplateName() && 3224 "No dependent template names here!"); 3225 3226 // Look through qualified template names. 3227 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 3228 Template = TemplateName(QTN->getTemplateDecl()); 3229 3230 // Build the canonical template specialization type. 3231 TemplateName CanonTemplate = getCanonicalTemplateName(Template); 3232 SmallVector<TemplateArgument, 4> CanonArgs; 3233 CanonArgs.reserve(NumArgs); 3234 for (unsigned I = 0; I != NumArgs; ++I) 3235 CanonArgs.push_back(getCanonicalTemplateArgument(Args[I])); 3236 3237 // Determine whether this canonical template specialization type already 3238 // exists. 3239 llvm::FoldingSetNodeID ID; 3240 TemplateSpecializationType::Profile(ID, CanonTemplate, 3241 CanonArgs.data(), NumArgs, *this); 3242 3243 void *InsertPos = nullptr; 3244 TemplateSpecializationType *Spec 3245 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 3246 3247 if (!Spec) { 3248 // Allocate a new canonical template specialization type. 3249 void *Mem = Allocate((sizeof(TemplateSpecializationType) + 3250 sizeof(TemplateArgument) * NumArgs), 3251 TypeAlignment); 3252 Spec = new (Mem) TemplateSpecializationType(CanonTemplate, 3253 CanonArgs.data(), NumArgs, 3254 QualType(), QualType()); 3255 Types.push_back(Spec); 3256 TemplateSpecializationTypes.InsertNode(Spec, InsertPos); 3257 } 3258 3259 assert(Spec->isDependentType() && 3260 "Non-dependent template-id type must have a canonical type"); 3261 return QualType(Spec, 0); 3262 } 3263 3264 QualType 3265 ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword, 3266 NestedNameSpecifier *NNS, 3267 QualType NamedType) const { 3268 llvm::FoldingSetNodeID ID; 3269 ElaboratedType::Profile(ID, Keyword, NNS, NamedType); 3270 3271 void *InsertPos = nullptr; 3272 ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 3273 if (T) 3274 return QualType(T, 0); 3275 3276 QualType Canon = NamedType; 3277 if (!Canon.isCanonical()) { 3278 Canon = getCanonicalType(NamedType); 3279 ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 3280 assert(!CheckT && "Elaborated canonical type broken"); 3281 (void)CheckT; 3282 } 3283 3284 T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon); 3285 Types.push_back(T); 3286 ElaboratedTypes.InsertNode(T, InsertPos); 3287 return QualType(T, 0); 3288 } 3289 3290 QualType 3291 ASTContext::getParenType(QualType InnerType) const { 3292 llvm::FoldingSetNodeID ID; 3293 ParenType::Profile(ID, InnerType); 3294 3295 void *InsertPos = nullptr; 3296 ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 3297 if (T) 3298 return QualType(T, 0); 3299 3300 QualType Canon = InnerType; 3301 if (!Canon.isCanonical()) { 3302 Canon = getCanonicalType(InnerType); 3303 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 3304 assert(!CheckT && "Paren canonical type broken"); 3305 (void)CheckT; 3306 } 3307 3308 T = new (*this) ParenType(InnerType, Canon); 3309 Types.push_back(T); 3310 ParenTypes.InsertNode(T, InsertPos); 3311 return QualType(T, 0); 3312 } 3313 3314 QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword, 3315 NestedNameSpecifier *NNS, 3316 const IdentifierInfo *Name, 3317 QualType Canon) const { 3318 if (Canon.isNull()) { 3319 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 3320 ElaboratedTypeKeyword CanonKeyword = Keyword; 3321 if (Keyword == ETK_None) 3322 CanonKeyword = ETK_Typename; 3323 3324 if (CanonNNS != NNS || CanonKeyword != Keyword) 3325 Canon = getDependentNameType(CanonKeyword, CanonNNS, Name); 3326 } 3327 3328 llvm::FoldingSetNodeID ID; 3329 DependentNameType::Profile(ID, Keyword, NNS, Name); 3330 3331 void *InsertPos = nullptr; 3332 DependentNameType *T 3333 = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos); 3334 if (T) 3335 return QualType(T, 0); 3336 3337 T = new (*this) DependentNameType(Keyword, NNS, Name, Canon); 3338 Types.push_back(T); 3339 DependentNameTypes.InsertNode(T, InsertPos); 3340 return QualType(T, 0); 3341 } 3342 3343 QualType 3344 ASTContext::getDependentTemplateSpecializationType( 3345 ElaboratedTypeKeyword Keyword, 3346 NestedNameSpecifier *NNS, 3347 const IdentifierInfo *Name, 3348 const TemplateArgumentListInfo &Args) const { 3349 // TODO: avoid this copy 3350 SmallVector<TemplateArgument, 16> ArgCopy; 3351 for (unsigned I = 0, E = Args.size(); I != E; ++I) 3352 ArgCopy.push_back(Args[I].getArgument()); 3353 return getDependentTemplateSpecializationType(Keyword, NNS, Name, 3354 ArgCopy.size(), 3355 ArgCopy.data()); 3356 } 3357 3358 QualType 3359 ASTContext::getDependentTemplateSpecializationType( 3360 ElaboratedTypeKeyword Keyword, 3361 NestedNameSpecifier *NNS, 3362 const IdentifierInfo *Name, 3363 unsigned NumArgs, 3364 const TemplateArgument *Args) const { 3365 assert((!NNS || NNS->isDependent()) && 3366 "nested-name-specifier must be dependent"); 3367 3368 llvm::FoldingSetNodeID ID; 3369 DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS, 3370 Name, NumArgs, Args); 3371 3372 void *InsertPos = nullptr; 3373 DependentTemplateSpecializationType *T 3374 = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 3375 if (T) 3376 return QualType(T, 0); 3377 3378 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 3379 3380 ElaboratedTypeKeyword CanonKeyword = Keyword; 3381 if (Keyword == ETK_None) CanonKeyword = ETK_Typename; 3382 3383 bool AnyNonCanonArgs = false; 3384 SmallVector<TemplateArgument, 16> CanonArgs(NumArgs); 3385 for (unsigned I = 0; I != NumArgs; ++I) { 3386 CanonArgs[I] = getCanonicalTemplateArgument(Args[I]); 3387 if (!CanonArgs[I].structurallyEquals(Args[I])) 3388 AnyNonCanonArgs = true; 3389 } 3390 3391 QualType Canon; 3392 if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) { 3393 Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS, 3394 Name, NumArgs, 3395 CanonArgs.data()); 3396 3397 // Find the insert position again. 3398 DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 3399 } 3400 3401 void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) + 3402 sizeof(TemplateArgument) * NumArgs), 3403 TypeAlignment); 3404 T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS, 3405 Name, NumArgs, Args, Canon); 3406 Types.push_back(T); 3407 DependentTemplateSpecializationTypes.InsertNode(T, InsertPos); 3408 return QualType(T, 0); 3409 } 3410 3411 QualType ASTContext::getPackExpansionType(QualType Pattern, 3412 Optional<unsigned> NumExpansions) { 3413 llvm::FoldingSetNodeID ID; 3414 PackExpansionType::Profile(ID, Pattern, NumExpansions); 3415 3416 assert(Pattern->containsUnexpandedParameterPack() && 3417 "Pack expansions must expand one or more parameter packs"); 3418 void *InsertPos = nullptr; 3419 PackExpansionType *T 3420 = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 3421 if (T) 3422 return QualType(T, 0); 3423 3424 QualType Canon; 3425 if (!Pattern.isCanonical()) { 3426 Canon = getCanonicalType(Pattern); 3427 // The canonical type might not contain an unexpanded parameter pack, if it 3428 // contains an alias template specialization which ignores one of its 3429 // parameters. 3430 if (Canon->containsUnexpandedParameterPack()) { 3431 Canon = getPackExpansionType(Canon, NumExpansions); 3432 3433 // Find the insert position again, in case we inserted an element into 3434 // PackExpansionTypes and invalidated our insert position. 3435 PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 3436 } 3437 } 3438 3439 T = new (*this) PackExpansionType(Pattern, Canon, NumExpansions); 3440 Types.push_back(T); 3441 PackExpansionTypes.InsertNode(T, InsertPos); 3442 return QualType(T, 0); 3443 } 3444 3445 /// CmpProtocolNames - Comparison predicate for sorting protocols 3446 /// alphabetically. 3447 static bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 3448 const ObjCProtocolDecl *RHS) { 3449 return LHS->getDeclName() < RHS->getDeclName(); 3450 } 3451 3452 static bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols, 3453 unsigned NumProtocols) { 3454 if (NumProtocols == 0) return true; 3455 3456 if (Protocols[0]->getCanonicalDecl() != Protocols[0]) 3457 return false; 3458 3459 for (unsigned i = 1; i != NumProtocols; ++i) 3460 if (!CmpProtocolNames(Protocols[i-1], Protocols[i]) || 3461 Protocols[i]->getCanonicalDecl() != Protocols[i]) 3462 return false; 3463 return true; 3464 } 3465 3466 static void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols, 3467 unsigned &NumProtocols) { 3468 ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 3469 3470 // Sort protocols, keyed by name. 3471 std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 3472 3473 // Canonicalize. 3474 for (unsigned I = 0, N = NumProtocols; I != N; ++I) 3475 Protocols[I] = Protocols[I]->getCanonicalDecl(); 3476 3477 // Remove duplicates. 3478 ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 3479 NumProtocols = ProtocolsEnd-Protocols; 3480 } 3481 3482 QualType ASTContext::getObjCObjectType(QualType BaseType, 3483 ObjCProtocolDecl * const *Protocols, 3484 unsigned NumProtocols) const { 3485 // If the base type is an interface and there aren't any protocols 3486 // to add, then the interface type will do just fine. 3487 if (!NumProtocols && isa<ObjCInterfaceType>(BaseType)) 3488 return BaseType; 3489 3490 // Look in the folding set for an existing type. 3491 llvm::FoldingSetNodeID ID; 3492 ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols); 3493 void *InsertPos = nullptr; 3494 if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos)) 3495 return QualType(QT, 0); 3496 3497 // Build the canonical type, which has the canonical base type and 3498 // a sorted-and-uniqued list of protocols. 3499 QualType Canonical; 3500 bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols); 3501 if (!ProtocolsSorted || !BaseType.isCanonical()) { 3502 if (!ProtocolsSorted) { 3503 SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols, 3504 Protocols + NumProtocols); 3505 unsigned UniqueCount = NumProtocols; 3506 3507 SortAndUniqueProtocols(&Sorted[0], UniqueCount); 3508 Canonical = getObjCObjectType(getCanonicalType(BaseType), 3509 &Sorted[0], UniqueCount); 3510 } else { 3511 Canonical = getObjCObjectType(getCanonicalType(BaseType), 3512 Protocols, NumProtocols); 3513 } 3514 3515 // Regenerate InsertPos. 3516 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos); 3517 } 3518 3519 unsigned Size = sizeof(ObjCObjectTypeImpl); 3520 Size += NumProtocols * sizeof(ObjCProtocolDecl *); 3521 void *Mem = Allocate(Size, TypeAlignment); 3522 ObjCObjectTypeImpl *T = 3523 new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols); 3524 3525 Types.push_back(T); 3526 ObjCObjectTypes.InsertNode(T, InsertPos); 3527 return QualType(T, 0); 3528 } 3529 3530 /// ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC's 3531 /// protocol list adopt all protocols in QT's qualified-id protocol 3532 /// list. 3533 bool ASTContext::ObjCObjectAdoptsQTypeProtocols(QualType QT, 3534 ObjCInterfaceDecl *IC) { 3535 if (!QT->isObjCQualifiedIdType()) 3536 return false; 3537 3538 if (const ObjCObjectPointerType *OPT = QT->getAs<ObjCObjectPointerType>()) { 3539 // If both the right and left sides have qualifiers. 3540 for (auto *Proto : OPT->quals()) { 3541 if (!IC->ClassImplementsProtocol(Proto, false)) 3542 return false; 3543 } 3544 return true; 3545 } 3546 return false; 3547 } 3548 3549 /// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in 3550 /// QT's qualified-id protocol list adopt all protocols in IDecl's list 3551 /// of protocols. 3552 bool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(QualType QT, 3553 ObjCInterfaceDecl *IDecl) { 3554 if (!QT->isObjCQualifiedIdType()) 3555 return false; 3556 const ObjCObjectPointerType *OPT = QT->getAs<ObjCObjectPointerType>(); 3557 if (!OPT) 3558 return false; 3559 if (!IDecl->hasDefinition()) 3560 return false; 3561 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols; 3562 CollectInheritedProtocols(IDecl, InheritedProtocols); 3563 if (InheritedProtocols.empty()) 3564 return false; 3565 // Check that if every protocol in list of id<plist> conforms to a protcol 3566 // of IDecl's, then bridge casting is ok. 3567 bool Conforms = false; 3568 for (auto *Proto : OPT->quals()) { 3569 Conforms = false; 3570 for (auto *PI : InheritedProtocols) { 3571 if (ProtocolCompatibleWithProtocol(Proto, PI)) { 3572 Conforms = true; 3573 break; 3574 } 3575 } 3576 if (!Conforms) 3577 break; 3578 } 3579 if (Conforms) 3580 return true; 3581 3582 for (auto *PI : InheritedProtocols) { 3583 // If both the right and left sides have qualifiers. 3584 bool Adopts = false; 3585 for (auto *Proto : OPT->quals()) { 3586 // return 'true' if 'PI' is in the inheritance hierarchy of Proto 3587 if ((Adopts = ProtocolCompatibleWithProtocol(PI, Proto))) 3588 break; 3589 } 3590 if (!Adopts) 3591 return false; 3592 } 3593 return true; 3594 } 3595 3596 /// getObjCObjectPointerType - Return a ObjCObjectPointerType type for 3597 /// the given object type. 3598 QualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const { 3599 llvm::FoldingSetNodeID ID; 3600 ObjCObjectPointerType::Profile(ID, ObjectT); 3601 3602 void *InsertPos = nullptr; 3603 if (ObjCObjectPointerType *QT = 3604 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 3605 return QualType(QT, 0); 3606 3607 // Find the canonical object type. 3608 QualType Canonical; 3609 if (!ObjectT.isCanonical()) { 3610 Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT)); 3611 3612 // Regenerate InsertPos. 3613 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 3614 } 3615 3616 // No match. 3617 void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment); 3618 ObjCObjectPointerType *QType = 3619 new (Mem) ObjCObjectPointerType(Canonical, ObjectT); 3620 3621 Types.push_back(QType); 3622 ObjCObjectPointerTypes.InsertNode(QType, InsertPos); 3623 return QualType(QType, 0); 3624 } 3625 3626 /// getObjCInterfaceType - Return the unique reference to the type for the 3627 /// specified ObjC interface decl. The list of protocols is optional. 3628 QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl, 3629 ObjCInterfaceDecl *PrevDecl) const { 3630 if (Decl->TypeForDecl) 3631 return QualType(Decl->TypeForDecl, 0); 3632 3633 if (PrevDecl) { 3634 assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"); 3635 Decl->TypeForDecl = PrevDecl->TypeForDecl; 3636 return QualType(PrevDecl->TypeForDecl, 0); 3637 } 3638 3639 // Prefer the definition, if there is one. 3640 if (const ObjCInterfaceDecl *Def = Decl->getDefinition()) 3641 Decl = Def; 3642 3643 void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment); 3644 ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl); 3645 Decl->TypeForDecl = T; 3646 Types.push_back(T); 3647 return QualType(T, 0); 3648 } 3649 3650 /// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique 3651 /// TypeOfExprType AST's (since expression's are never shared). For example, 3652 /// multiple declarations that refer to "typeof(x)" all contain different 3653 /// DeclRefExpr's. This doesn't effect the type checker, since it operates 3654 /// on canonical type's (which are always unique). 3655 QualType ASTContext::getTypeOfExprType(Expr *tofExpr) const { 3656 TypeOfExprType *toe; 3657 if (tofExpr->isTypeDependent()) { 3658 llvm::FoldingSetNodeID ID; 3659 DependentTypeOfExprType::Profile(ID, *this, tofExpr); 3660 3661 void *InsertPos = nullptr; 3662 DependentTypeOfExprType *Canon 3663 = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos); 3664 if (Canon) { 3665 // We already have a "canonical" version of an identical, dependent 3666 // typeof(expr) type. Use that as our canonical type. 3667 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, 3668 QualType((TypeOfExprType*)Canon, 0)); 3669 } else { 3670 // Build a new, canonical typeof(expr) type. 3671 Canon 3672 = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr); 3673 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos); 3674 toe = Canon; 3675 } 3676 } else { 3677 QualType Canonical = getCanonicalType(tofExpr->getType()); 3678 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical); 3679 } 3680 Types.push_back(toe); 3681 return QualType(toe, 0); 3682 } 3683 3684 /// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 3685 /// TypeOfType nodes. The only motivation to unique these nodes would be 3686 /// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 3687 /// an issue. This doesn't affect the type checker, since it operates 3688 /// on canonical types (which are always unique). 3689 QualType ASTContext::getTypeOfType(QualType tofType) const { 3690 QualType Canonical = getCanonicalType(tofType); 3691 TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical); 3692 Types.push_back(tot); 3693 return QualType(tot, 0); 3694 } 3695 3696 3697 /// \brief Unlike many "get<Type>" functions, we don't unique DecltypeType 3698 /// nodes. This would never be helpful, since each such type has its own 3699 /// expression, and would not give a significant memory saving, since there 3700 /// is an Expr tree under each such type. 3701 QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const { 3702 DecltypeType *dt; 3703 3704 // C++11 [temp.type]p2: 3705 // If an expression e involves a template parameter, decltype(e) denotes a 3706 // unique dependent type. Two such decltype-specifiers refer to the same 3707 // type only if their expressions are equivalent (14.5.6.1). 3708 if (e->isInstantiationDependent()) { 3709 llvm::FoldingSetNodeID ID; 3710 DependentDecltypeType::Profile(ID, *this, e); 3711 3712 void *InsertPos = nullptr; 3713 DependentDecltypeType *Canon 3714 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos); 3715 if (!Canon) { 3716 // Build a new, canonical typeof(expr) type. 3717 Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e); 3718 DependentDecltypeTypes.InsertNode(Canon, InsertPos); 3719 } 3720 dt = new (*this, TypeAlignment) 3721 DecltypeType(e, UnderlyingType, QualType((DecltypeType *)Canon, 0)); 3722 } else { 3723 dt = new (*this, TypeAlignment) 3724 DecltypeType(e, UnderlyingType, getCanonicalType(UnderlyingType)); 3725 } 3726 Types.push_back(dt); 3727 return QualType(dt, 0); 3728 } 3729 3730 /// getUnaryTransformationType - We don't unique these, since the memory 3731 /// savings are minimal and these are rare. 3732 QualType ASTContext::getUnaryTransformType(QualType BaseType, 3733 QualType UnderlyingType, 3734 UnaryTransformType::UTTKind Kind) 3735 const { 3736 UnaryTransformType *Ty = 3737 new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType, 3738 Kind, 3739 UnderlyingType->isDependentType() ? 3740 QualType() : getCanonicalType(UnderlyingType)); 3741 Types.push_back(Ty); 3742 return QualType(Ty, 0); 3743 } 3744 3745 /// getAutoType - Return the uniqued reference to the 'auto' type which has been 3746 /// deduced to the given type, or to the canonical undeduced 'auto' type, or the 3747 /// canonical deduced-but-dependent 'auto' type. 3748 QualType ASTContext::getAutoType(QualType DeducedType, bool IsDecltypeAuto, 3749 bool IsDependent) const { 3750 if (DeducedType.isNull() && !IsDecltypeAuto && !IsDependent) 3751 return getAutoDeductType(); 3752 3753 // Look in the folding set for an existing type. 3754 void *InsertPos = nullptr; 3755 llvm::FoldingSetNodeID ID; 3756 AutoType::Profile(ID, DeducedType, IsDecltypeAuto, IsDependent); 3757 if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos)) 3758 return QualType(AT, 0); 3759 3760 AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType, 3761 IsDecltypeAuto, 3762 IsDependent); 3763 Types.push_back(AT); 3764 if (InsertPos) 3765 AutoTypes.InsertNode(AT, InsertPos); 3766 return QualType(AT, 0); 3767 } 3768 3769 /// getAtomicType - Return the uniqued reference to the atomic type for 3770 /// the given value type. 3771 QualType ASTContext::getAtomicType(QualType T) const { 3772 // Unique pointers, to guarantee there is only one pointer of a particular 3773 // structure. 3774 llvm::FoldingSetNodeID ID; 3775 AtomicType::Profile(ID, T); 3776 3777 void *InsertPos = nullptr; 3778 if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos)) 3779 return QualType(AT, 0); 3780 3781 // If the atomic value type isn't canonical, this won't be a canonical type 3782 // either, so fill in the canonical type field. 3783 QualType Canonical; 3784 if (!T.isCanonical()) { 3785 Canonical = getAtomicType(getCanonicalType(T)); 3786 3787 // Get the new insert position for the node we care about. 3788 AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos); 3789 assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP; 3790 } 3791 AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical); 3792 Types.push_back(New); 3793 AtomicTypes.InsertNode(New, InsertPos); 3794 return QualType(New, 0); 3795 } 3796 3797 /// getAutoDeductType - Get type pattern for deducing against 'auto'. 3798 QualType ASTContext::getAutoDeductType() const { 3799 if (AutoDeductTy.isNull()) 3800 AutoDeductTy = QualType( 3801 new (*this, TypeAlignment) AutoType(QualType(), /*decltype(auto)*/false, 3802 /*dependent*/false), 3803 0); 3804 return AutoDeductTy; 3805 } 3806 3807 /// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'. 3808 QualType ASTContext::getAutoRRefDeductType() const { 3809 if (AutoRRefDeductTy.isNull()) 3810 AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType()); 3811 assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"); 3812 return AutoRRefDeductTy; 3813 } 3814 3815 /// getTagDeclType - Return the unique reference to the type for the 3816 /// specified TagDecl (struct/union/class/enum) decl. 3817 QualType ASTContext::getTagDeclType(const TagDecl *Decl) const { 3818 assert (Decl); 3819 // FIXME: What is the design on getTagDeclType when it requires casting 3820 // away const? mutable? 3821 return getTypeDeclType(const_cast<TagDecl*>(Decl)); 3822 } 3823 3824 /// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 3825 /// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 3826 /// needs to agree with the definition in <stddef.h>. 3827 CanQualType ASTContext::getSizeType() const { 3828 return getFromTargetType(Target->getSizeType()); 3829 } 3830 3831 /// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5). 3832 CanQualType ASTContext::getIntMaxType() const { 3833 return getFromTargetType(Target->getIntMaxType()); 3834 } 3835 3836 /// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5). 3837 CanQualType ASTContext::getUIntMaxType() const { 3838 return getFromTargetType(Target->getUIntMaxType()); 3839 } 3840 3841 /// getSignedWCharType - Return the type of "signed wchar_t". 3842 /// Used when in C++, as a GCC extension. 3843 QualType ASTContext::getSignedWCharType() const { 3844 // FIXME: derive from "Target" ? 3845 return WCharTy; 3846 } 3847 3848 /// getUnsignedWCharType - Return the type of "unsigned wchar_t". 3849 /// Used when in C++, as a GCC extension. 3850 QualType ASTContext::getUnsignedWCharType() const { 3851 // FIXME: derive from "Target" ? 3852 return UnsignedIntTy; 3853 } 3854 3855 QualType ASTContext::getIntPtrType() const { 3856 return getFromTargetType(Target->getIntPtrType()); 3857 } 3858 3859 QualType ASTContext::getUIntPtrType() const { 3860 return getCorrespondingUnsignedType(getIntPtrType()); 3861 } 3862 3863 /// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17) 3864 /// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 3865 QualType ASTContext::getPointerDiffType() const { 3866 return getFromTargetType(Target->getPtrDiffType(0)); 3867 } 3868 3869 /// \brief Return the unique type for "pid_t" defined in 3870 /// <sys/types.h>. We need this to compute the correct type for vfork(). 3871 QualType ASTContext::getProcessIDType() const { 3872 return getFromTargetType(Target->getProcessIDType()); 3873 } 3874 3875 //===----------------------------------------------------------------------===// 3876 // Type Operators 3877 //===----------------------------------------------------------------------===// 3878 3879 CanQualType ASTContext::getCanonicalParamType(QualType T) const { 3880 // Push qualifiers into arrays, and then discard any remaining 3881 // qualifiers. 3882 T = getCanonicalType(T); 3883 T = getVariableArrayDecayedType(T); 3884 const Type *Ty = T.getTypePtr(); 3885 QualType Result; 3886 if (isa<ArrayType>(Ty)) { 3887 Result = getArrayDecayedType(QualType(Ty,0)); 3888 } else if (isa<FunctionType>(Ty)) { 3889 Result = getPointerType(QualType(Ty, 0)); 3890 } else { 3891 Result = QualType(Ty, 0); 3892 } 3893 3894 return CanQualType::CreateUnsafe(Result); 3895 } 3896 3897 QualType ASTContext::getUnqualifiedArrayType(QualType type, 3898 Qualifiers &quals) { 3899 SplitQualType splitType = type.getSplitUnqualifiedType(); 3900 3901 // FIXME: getSplitUnqualifiedType() actually walks all the way to 3902 // the unqualified desugared type and then drops it on the floor. 3903 // We then have to strip that sugar back off with 3904 // getUnqualifiedDesugaredType(), which is silly. 3905 const ArrayType *AT = 3906 dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType()); 3907 3908 // If we don't have an array, just use the results in splitType. 3909 if (!AT) { 3910 quals = splitType.Quals; 3911 return QualType(splitType.Ty, 0); 3912 } 3913 3914 // Otherwise, recurse on the array's element type. 3915 QualType elementType = AT->getElementType(); 3916 QualType unqualElementType = getUnqualifiedArrayType(elementType, quals); 3917 3918 // If that didn't change the element type, AT has no qualifiers, so we 3919 // can just use the results in splitType. 3920 if (elementType == unqualElementType) { 3921 assert(quals.empty()); // from the recursive call 3922 quals = splitType.Quals; 3923 return QualType(splitType.Ty, 0); 3924 } 3925 3926 // Otherwise, add in the qualifiers from the outermost type, then 3927 // build the type back up. 3928 quals.addConsistentQualifiers(splitType.Quals); 3929 3930 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 3931 return getConstantArrayType(unqualElementType, CAT->getSize(), 3932 CAT->getSizeModifier(), 0); 3933 } 3934 3935 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 3936 return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0); 3937 } 3938 3939 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) { 3940 return getVariableArrayType(unqualElementType, 3941 VAT->getSizeExpr(), 3942 VAT->getSizeModifier(), 3943 VAT->getIndexTypeCVRQualifiers(), 3944 VAT->getBracketsRange()); 3945 } 3946 3947 const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT); 3948 return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(), 3949 DSAT->getSizeModifier(), 0, 3950 SourceRange()); 3951 } 3952 3953 /// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that 3954 /// may be similar (C++ 4.4), replaces T1 and T2 with the type that 3955 /// they point to and return true. If T1 and T2 aren't pointer types 3956 /// or pointer-to-member types, or if they are not similar at this 3957 /// level, returns false and leaves T1 and T2 unchanged. Top-level 3958 /// qualifiers on T1 and T2 are ignored. This function will typically 3959 /// be called in a loop that successively "unwraps" pointer and 3960 /// pointer-to-member types to compare them at each level. 3961 bool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) { 3962 const PointerType *T1PtrType = T1->getAs<PointerType>(), 3963 *T2PtrType = T2->getAs<PointerType>(); 3964 if (T1PtrType && T2PtrType) { 3965 T1 = T1PtrType->getPointeeType(); 3966 T2 = T2PtrType->getPointeeType(); 3967 return true; 3968 } 3969 3970 const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), 3971 *T2MPType = T2->getAs<MemberPointerType>(); 3972 if (T1MPType && T2MPType && 3973 hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0), 3974 QualType(T2MPType->getClass(), 0))) { 3975 T1 = T1MPType->getPointeeType(); 3976 T2 = T2MPType->getPointeeType(); 3977 return true; 3978 } 3979 3980 if (getLangOpts().ObjC1) { 3981 const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(), 3982 *T2OPType = T2->getAs<ObjCObjectPointerType>(); 3983 if (T1OPType && T2OPType) { 3984 T1 = T1OPType->getPointeeType(); 3985 T2 = T2OPType->getPointeeType(); 3986 return true; 3987 } 3988 } 3989 3990 // FIXME: Block pointers, too? 3991 3992 return false; 3993 } 3994 3995 DeclarationNameInfo 3996 ASTContext::getNameForTemplate(TemplateName Name, 3997 SourceLocation NameLoc) const { 3998 switch (Name.getKind()) { 3999 case TemplateName::QualifiedTemplate: 4000 case TemplateName::Template: 4001 // DNInfo work in progress: CHECKME: what about DNLoc? 4002 return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(), 4003 NameLoc); 4004 4005 case TemplateName::OverloadedTemplate: { 4006 OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate(); 4007 // DNInfo work in progress: CHECKME: what about DNLoc? 4008 return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc); 4009 } 4010 4011 case TemplateName::DependentTemplate: { 4012 DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 4013 DeclarationName DName; 4014 if (DTN->isIdentifier()) { 4015 DName = DeclarationNames.getIdentifier(DTN->getIdentifier()); 4016 return DeclarationNameInfo(DName, NameLoc); 4017 } else { 4018 DName = DeclarationNames.getCXXOperatorName(DTN->getOperator()); 4019 // DNInfo work in progress: FIXME: source locations? 4020 DeclarationNameLoc DNLoc; 4021 DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding(); 4022 DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding(); 4023 return DeclarationNameInfo(DName, NameLoc, DNLoc); 4024 } 4025 } 4026 4027 case TemplateName::SubstTemplateTemplateParm: { 4028 SubstTemplateTemplateParmStorage *subst 4029 = Name.getAsSubstTemplateTemplateParm(); 4030 return DeclarationNameInfo(subst->getParameter()->getDeclName(), 4031 NameLoc); 4032 } 4033 4034 case TemplateName::SubstTemplateTemplateParmPack: { 4035 SubstTemplateTemplateParmPackStorage *subst 4036 = Name.getAsSubstTemplateTemplateParmPack(); 4037 return DeclarationNameInfo(subst->getParameterPack()->getDeclName(), 4038 NameLoc); 4039 } 4040 } 4041 4042 llvm_unreachable("bad template name kind!"); 4043 } 4044 4045 TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const { 4046 switch (Name.getKind()) { 4047 case TemplateName::QualifiedTemplate: 4048 case TemplateName::Template: { 4049 TemplateDecl *Template = Name.getAsTemplateDecl(); 4050 if (TemplateTemplateParmDecl *TTP 4051 = dyn_cast<TemplateTemplateParmDecl>(Template)) 4052 Template = getCanonicalTemplateTemplateParmDecl(TTP); 4053 4054 // The canonical template name is the canonical template declaration. 4055 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl())); 4056 } 4057 4058 case TemplateName::OverloadedTemplate: 4059 llvm_unreachable("cannot canonicalize overloaded template"); 4060 4061 case TemplateName::DependentTemplate: { 4062 DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 4063 assert(DTN && "Non-dependent template names must refer to template decls."); 4064 return DTN->CanonicalTemplateName; 4065 } 4066 4067 case TemplateName::SubstTemplateTemplateParm: { 4068 SubstTemplateTemplateParmStorage *subst 4069 = Name.getAsSubstTemplateTemplateParm(); 4070 return getCanonicalTemplateName(subst->getReplacement()); 4071 } 4072 4073 case TemplateName::SubstTemplateTemplateParmPack: { 4074 SubstTemplateTemplateParmPackStorage *subst 4075 = Name.getAsSubstTemplateTemplateParmPack(); 4076 TemplateTemplateParmDecl *canonParameter 4077 = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack()); 4078 TemplateArgument canonArgPack 4079 = getCanonicalTemplateArgument(subst->getArgumentPack()); 4080 return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack); 4081 } 4082 } 4083 4084 llvm_unreachable("bad template name!"); 4085 } 4086 4087 bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) { 4088 X = getCanonicalTemplateName(X); 4089 Y = getCanonicalTemplateName(Y); 4090 return X.getAsVoidPointer() == Y.getAsVoidPointer(); 4091 } 4092 4093 TemplateArgument 4094 ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const { 4095 switch (Arg.getKind()) { 4096 case TemplateArgument::Null: 4097 return Arg; 4098 4099 case TemplateArgument::Expression: 4100 return Arg; 4101 4102 case TemplateArgument::Declaration: { 4103 ValueDecl *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl()); 4104 return TemplateArgument(D, Arg.isDeclForReferenceParam()); 4105 } 4106 4107 case TemplateArgument::NullPtr: 4108 return TemplateArgument(getCanonicalType(Arg.getNullPtrType()), 4109 /*isNullPtr*/true); 4110 4111 case TemplateArgument::Template: 4112 return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate())); 4113 4114 case TemplateArgument::TemplateExpansion: 4115 return TemplateArgument(getCanonicalTemplateName( 4116 Arg.getAsTemplateOrTemplatePattern()), 4117 Arg.getNumTemplateExpansions()); 4118 4119 case TemplateArgument::Integral: 4120 return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType())); 4121 4122 case TemplateArgument::Type: 4123 return TemplateArgument(getCanonicalType(Arg.getAsType())); 4124 4125 case TemplateArgument::Pack: { 4126 if (Arg.pack_size() == 0) 4127 return Arg; 4128 4129 TemplateArgument *CanonArgs 4130 = new (*this) TemplateArgument[Arg.pack_size()]; 4131 unsigned Idx = 0; 4132 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 4133 AEnd = Arg.pack_end(); 4134 A != AEnd; (void)++A, ++Idx) 4135 CanonArgs[Idx] = getCanonicalTemplateArgument(*A); 4136 4137 return TemplateArgument(CanonArgs, Arg.pack_size()); 4138 } 4139 } 4140 4141 // Silence GCC warning 4142 llvm_unreachable("Unhandled template argument kind"); 4143 } 4144 4145 NestedNameSpecifier * 4146 ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const { 4147 if (!NNS) 4148 return nullptr; 4149 4150 switch (NNS->getKind()) { 4151 case NestedNameSpecifier::Identifier: 4152 // Canonicalize the prefix but keep the identifier the same. 4153 return NestedNameSpecifier::Create(*this, 4154 getCanonicalNestedNameSpecifier(NNS->getPrefix()), 4155 NNS->getAsIdentifier()); 4156 4157 case NestedNameSpecifier::Namespace: 4158 // A namespace is canonical; build a nested-name-specifier with 4159 // this namespace and no prefix. 4160 return NestedNameSpecifier::Create(*this, nullptr, 4161 NNS->getAsNamespace()->getOriginalNamespace()); 4162 4163 case NestedNameSpecifier::NamespaceAlias: 4164 // A namespace is canonical; build a nested-name-specifier with 4165 // this namespace and no prefix. 4166 return NestedNameSpecifier::Create(*this, nullptr, 4167 NNS->getAsNamespaceAlias()->getNamespace() 4168 ->getOriginalNamespace()); 4169 4170 case NestedNameSpecifier::TypeSpec: 4171 case NestedNameSpecifier::TypeSpecWithTemplate: { 4172 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0)); 4173 4174 // If we have some kind of dependent-named type (e.g., "typename T::type"), 4175 // break it apart into its prefix and identifier, then reconsititute those 4176 // as the canonical nested-name-specifier. This is required to canonical