ASTContext.cpp revision 181e3ecc0907ae0103586a9f4db52241995a8267
15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===--- ASTContext.cpp - Context to hold long-lived AST nodes ------------===// 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// The LLVM Compiler Infrastructure 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 55821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This file is distributed under the University of Illinois Open Source 65821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// License. See LICENSE.TXT for details. 75821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 85821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===----------------------------------------------------------------------===// 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This file implements the ASTContext interface. 115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 12cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)//===----------------------------------------------------------------------===// 132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 142a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/AST/ASTContext.h" 155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "CXXABI.h" 165d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)#include "clang/AST/ASTMutationListener.h" 175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/Attr.h" 182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/AST/CharUnits.h" 192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/AST/Comment.h" 205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/CommentCommandTraits.h" 21eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include "clang/AST/DeclCXX.h" 225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/DeclObjC.h" 237dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch#include "clang/AST/DeclTemplate.h" 245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/Expr.h" 255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/ExprCXX.h" 265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/ExternalASTSource.h" 271e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/AST/Mangle.h" 281e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/AST/RecordLayout.h" 295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/TypeLoc.h" 302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Basic/Builtins.h" 311320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci#include "clang/Basic/SourceManager.h" 325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/TargetInfo.h" 335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/SmallString.h" 345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/StringExtras.h" 355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/Capacity.h" 362a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "llvm/Support/MathExtras.h" 375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/raw_ostream.h" 382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include <map> 395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 40cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)using namespace clang; 415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)unsigned ASTContext::NumImplicitDefaultConstructors; 435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)unsigned ASTContext::NumImplicitDefaultConstructorsDeclared; 445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)unsigned ASTContext::NumImplicitCopyConstructors; 455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)unsigned ASTContext::NumImplicitCopyConstructorsDeclared; 465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)unsigned ASTContext::NumImplicitMoveConstructors; 475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)unsigned ASTContext::NumImplicitMoveConstructorsDeclared; 485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)unsigned ASTContext::NumImplicitCopyAssignmentOperators; 495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared; 50cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)unsigned ASTContext::NumImplicitMoveAssignmentOperators; 51cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)unsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared; 52cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)unsigned ASTContext::NumImplicitDestructors; 53cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)unsigned ASTContext::NumImplicitDestructorsDeclared; 545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)enum FloatingRank { 565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) HalfRank, FloatRank, DoubleRank, LongDoubleRank 575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const { 605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!CommentsLoaded && ExternalSource) { 615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalSource->ReadComments(); 625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CommentsLoaded = true; 635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(D); 66cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) 675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // User can not attach documentation to implicit declarations. 685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (D->isImplicit()) 69a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch return NULL; 70a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch 71a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch // User can not attach documentation to implicit instantiations. 72a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 73a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 74a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch return NULL; 75a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 76a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch 77a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 78a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (VD->isStaticDataMember() && 79a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 80116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch return NULL; 81116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch } 82116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 83a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) { 84a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 85a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch return NULL; 86a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 87a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch 88a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (const ClassTemplateSpecializationDecl *CTSD = 89a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch dyn_cast<ClassTemplateSpecializationDecl>(D)) { 90a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch TemplateSpecializationKind TSK = CTSD->getSpecializationKind(); 91a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (TSK == TSK_ImplicitInstantiation || 92a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch TSK == TSK_Undeclared) 93a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch return NULL; 94a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 95a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch 96a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (const EnumDecl *ED = dyn_cast<EnumDecl>(D)) { 97a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation) 98a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch return NULL; 99a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 100a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (const TagDecl *TD = dyn_cast<TagDecl>(D)) { 101a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch // When tag declaration (but not definition!) is part of the 102a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch // decl-specifier-seq of some other declaration, it doesn't get comment 103a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition()) 104a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch return NULL; 105a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 106a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch // TODO: handle comments for function parameters properly. 107a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (isa<ParmVarDecl>(D)) 1085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return NULL; 1095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // TODO: we could look up template parameter documentation in the template 1115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // documentation. 1125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (isa<TemplateTypeParmDecl>(D) || 1135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) isa<NonTypeTemplateParmDecl>(D) || 1145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) isa<TemplateTemplateParmDecl>(D)) 1155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return NULL; 1165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ArrayRef<RawComment *> RawComments = Comments.getComments(); 1185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // If there are no comments anywhere, we won't find anything. 1202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (RawComments.empty()) 1215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return NULL; 1225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Find declaration location. 1245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // For Objective-C declarations we generally don't expect to have multiple 1255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // declarators, thus use declaration starting location as the "declaration 1265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // location". 1275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // For all other declarations multiple declarators are used quite frequently, 128cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) // so we use the location of the identifier as the "declaration location". 129cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) SourceLocation DeclLoc; 130cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) || 131cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) isa<ObjCPropertyDecl>(D) || 132cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) isa<RedeclarableTemplateDecl>(D) || 1330529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch isa<ClassTemplateSpecializationDecl>(D)) 1340529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch DeclLoc = D->getLocStart(); 135cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) else 136cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) DeclLoc = D->getLocation(); 1375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1382a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If the declaration doesn't map directly to a location in a file, we 1392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // can't find the comment. 1402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (DeclLoc.isInvalid() || !DeclLoc.isFileID()) 1410529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return NULL; 1420529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 143cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) // Find the comment that occurs just after this declaration. 144cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) ArrayRef<RawComment *>::iterator Comment; 1455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) { 1465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // When searching for comments during parsing, the comment we are looking 1475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // for is usually among the last two comments we parsed -- check them 1485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // first. 1495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RawComment CommentAtDeclLoc( 1502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) SourceMgr, SourceRange(DeclLoc), false, 1515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) LangOpts.CommentOpts.ParseAllComments); 1525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BeforeThanCompare<RawComment> Compare(SourceMgr); 1532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) ArrayRef<RawComment *>::iterator MaybeBeforeDecl = RawComments.end() - 1; 1542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc); 1555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!Found && RawComments.size() >= 2) { 1565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MaybeBeforeDecl--; 1572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc); 1585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 1595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1602a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (Found) { 1612a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) Comment = MaybeBeforeDecl + 1; 1622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) assert(Comment == std::lower_bound(RawComments.begin(), RawComments.end(), 1632a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) &CommentAtDeclLoc, Compare)); 1642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 16590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Slow path. 16690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) Comment = std::lower_bound(RawComments.begin(), RawComments.end(), 16790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) &CommentAtDeclLoc, Compare); 1680f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles) } 1690f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles) } 1700f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles) 1712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Decompose the location for the declaration and find the beginning of the 1725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // file buffer. 1735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::pair<FileID, unsigned> DeclLocDecomp = SourceMgr.getDecomposedLoc(DeclLoc); 1745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 175f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) // First check whether we have a trailing comment. 176f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) if (Comment != RawComments.end() && 177f8ee788a64d60abd8f2d742a5fdedde054ecd910Torne (Richard Coles) (*Comment)->isDocumentation() && (*Comment)->isTrailingComment() && 1785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D))) { 1795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::pair<FileID, unsigned> CommentBeginDecomp 1802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getBegin()); 1812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Check that Doxygen trailing comment comes after the declaration, starts 1825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // on the same line and in the same file as the declaration. 1835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (DeclLocDecomp.first == CommentBeginDecomp.first && 1842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second) 1855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) == SourceMgr.getLineNumber(CommentBeginDecomp.first, 1865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CommentBeginDecomp.second)) { 187cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) return *Comment; 188cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) } 189cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) } 190cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) 1915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The comment just after the declaration was not a trailing comment. 1925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Let's look at the previous comment. 19358e6fbe4ee35d65e14b626c557d37565bf8ad179Ben Murdoch if (Comment == RawComments.begin()) 19458e6fbe4ee35d65e14b626c557d37565bf8ad179Ben Murdoch return NULL; 19558e6fbe4ee35d65e14b626c557d37565bf8ad179Ben Murdoch --Comment; 196cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) 197cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) // Check that we actually have a non-member Doxygen comment. 198cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) if (!(*Comment)->isDocumentation() || (*Comment)->isTrailingComment()) 1995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return NULL; 2005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Decompose the end of the comment. 2020529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch std::pair<FileID, unsigned> CommentEndDecomp 203cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getEnd()); 2040529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 2055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // If the comment and the declaration aren't in the same file, then they 2065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // aren't related. 2075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (DeclLocDecomp.first != CommentEndDecomp.first) 2085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return NULL; 2095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Get the corresponding buffer. 2115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool Invalid = false; 2125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first, 2135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) &Invalid).data(); 2145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Invalid) 2150529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch return NULL; 2165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Extract text between the comment and declaration. 2185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StringRef Text(Buffer + CommentEndDecomp.second, 2190529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch DeclLocDecomp.second - CommentEndDecomp.second); 2200529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 2215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // There should be no other declarations or preprocessor directives between 222cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) // comment and declaration. 2235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Text.find_first_of(",;{}#@") != StringRef::npos) 2245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return NULL; 2255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return *Comment; 2275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 2285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)namespace { 2305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)/// If we have a 'templated' declaration for a template, adjust 'D' to 2315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)/// refer to the actual template. 2320529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch/// If we have an implicit instantiation, adjust 'D' to refer to template. 2330529e5d033099cbfc42635f6f6183833b09dff6eBen Murdochconst Decl *adjustDeclToTemplate(const Decl *D) { 2345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 2355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Is this function declaration part of a function template? 2365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate()) 2375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return FTD; 2385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Nothing to do if function is not an implicit instantiation. 2405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation) 2415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return D; 2425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Function is an implicit instantiation of a function template? 2445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate()) 2455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return FTD; 2465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Function is instantiated from a member definition of a class template? 2485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const FunctionDecl *MemberDecl = 2495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FD->getInstantiatedFromMemberFunction()) 2505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return MemberDecl; 2515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return D; 2535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 2555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Static data member is instantiated from a member definition of a class 2562a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // template? 25790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) if (VD->isStaticDataMember()) 2580f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles) if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember()) 2590f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles) return MemberDecl; 2605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return D; 2625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) { 2645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Is this class declaration part of a class template? 2655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate()) 2665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return CTD; 2675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Class is an implicit instantiation of a class template or partial 2695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // specialization? 2705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const ClassTemplateSpecializationDecl *CTSD = 2715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) dyn_cast<ClassTemplateSpecializationDecl>(CRD)) { 2725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation) 2735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return D; 2745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::PointerUnion<ClassTemplateDecl *, 2755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ClassTemplatePartialSpecializationDecl *> 2765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PU = CTSD->getSpecializedTemplateOrPartial(); 2775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return PU.is<ClassTemplateDecl*>() ? 2782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) static_cast<const Decl*>(PU.get<ClassTemplateDecl *>()) : 2795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) static_cast<const Decl*>( 2805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PU.get<ClassTemplatePartialSpecializationDecl *>()); 2815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 2835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Class is instantiated from a member definition of a class template? 2845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const MemberSpecializationInfo *Info = 2855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CRD->getMemberSpecializationInfo()) 2865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Info->getInstantiatedFrom(); 2875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return D; 2895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const EnumDecl *ED = dyn_cast<EnumDecl>(D)) { 2915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Enum is instantiated from a member definition of a class template? 2925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum()) 2935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return MemberDecl; 2945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return D; 2965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 2975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // FIXME: Adjust alias templates? 2982a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return D; 2995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 3005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} // unnamed namespace 3015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)const RawComment *ASTContext::getRawCommentForAnyRedecl( 3035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const Decl *D, 3045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const Decl **OriginalDecl) const { 3055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) D = adjustDeclToTemplate(D); 3065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Check whether we have cached a comment for this declaration already. 3082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) { 3095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos = 3105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RedeclComments.find(D); 3115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Pos != RedeclComments.end()) { 3125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const RawCommentAndCacheFlags &Raw = Pos->second; 3135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) { 3145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (OriginalDecl) 3155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *OriginalDecl = Raw.getOriginalDecl(); 3165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Raw.getRaw(); 3175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Search for comments attached to declarations in the redeclaration chain. 3225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const RawComment *RC = NULL; 3235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const Decl *OriginalDeclForRC = NULL; 3245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (Decl::redecl_iterator I = D->redecls_begin(), 3255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) E = D->redecls_end(); 3265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) I != E; ++I) { 3275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos = 3285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RedeclComments.find(*I); 3295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Pos != RedeclComments.end()) { 3305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const RawCommentAndCacheFlags &Raw = Pos->second; 3315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) { 3325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RC = Raw.getRaw(); 3335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) OriginalDeclForRC = Raw.getOriginalDecl(); 3345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) break; 3355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else { 3375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RC = getRawCommentForDeclNoCache(*I); 3385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) OriginalDeclForRC = *I; 3395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RawCommentAndCacheFlags Raw; 3405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (RC) { 3415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Raw.setRaw(RC); 3425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Raw.setKind(RawCommentAndCacheFlags::FromDecl); 3435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } else 3445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Raw.setKind(RawCommentAndCacheFlags::NoCommentInDecl); 3455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Raw.setOriginalDecl(*I); 3465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RedeclComments[*I] = Raw; 3475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (RC) 3485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) break; 3495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // If we found a comment, it should be a documentation comment. 3535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(!RC || RC->isDocumentation()); 3542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 3555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (OriginalDecl) 3565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *OriginalDecl = OriginalDeclForRC; 3575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Update cache for every declaration in the redeclaration chain. 3592a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RawCommentAndCacheFlags Raw; 360a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) Raw.setRaw(RC); 361a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) Raw.setKind(RawCommentAndCacheFlags::FromRedecl); 3625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Raw.setOriginalDecl(OriginalDeclForRC); 3635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (Decl::redecl_iterator I = D->redecls_begin(), 3655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) E = D->redecls_end(); 3665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) I != E; ++I) { 3675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RawCommentAndCacheFlags &R = RedeclComments[*I]; 3685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (R.getKind() == RawCommentAndCacheFlags::NoCommentInDecl) 369a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch R = Raw; 370a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 3715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return RC; 3735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 3745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod, 3765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SmallVectorImpl<const NamedDecl *> &Redeclared) { 3775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const DeclContext *DC = ObjCMethod->getDeclContext(); 3780529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch if (const ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(DC)) { 3795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const ObjCInterfaceDecl *ID = IMD->getClassInterface(); 3805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!ID) 3815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return; 3825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Add redeclared method here. 383a1401311d1ab56c4ed0a474bd38c108f75cb0cd9Torne (Richard Coles) for (ObjCInterfaceDecl::known_extensions_iterator 3840529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch Ext = ID->known_extensions_begin(), 3855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExtEnd = ID->known_extensions_end(); 3865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Ext != ExtEnd; ++Ext) { 3875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (ObjCMethodDecl *RedeclaredMethod = 3885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Ext->getMethod(ObjCMethod->getSelector(), 3895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ObjCMethod->isInstanceMethod())) 390a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch Redeclared.push_back(RedeclaredMethod); 391a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 392a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 3935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 3945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC, 3965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const Decl *D) const { 3975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) comments::DeclInfo *ThisDeclInfo = new (*this) comments::DeclInfo; 3985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ThisDeclInfo->CommentDecl = D; 3995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ThisDeclInfo->IsFilled = false; 4005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ThisDeclInfo->fill(); 4015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ThisDeclInfo->CommentDecl = FC->getDecl(); 4025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) comments::FullComment *CFC = 4035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) new (*this) comments::FullComment(FC->getBlocks(), 4045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ThisDeclInfo); 405a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch return CFC; 4065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 408cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) 409cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)comments::FullComment *ASTContext::getCommentForDecl( 410cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) const Decl *D, 411cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) const Preprocessor *PP) const { 412cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) D = adjustDeclToTemplate(D); 413cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) 414cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) const Decl *Canonical = D->getCanonicalDecl(); 415cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos = 416cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) ParsedComments.find(Canonical); 417cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) 418cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) if (Pos != ParsedComments.end()) { 4195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Canonical != D) { 4205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) comments::FullComment *FC = Pos->second; 4215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) comments::FullComment *CFC = cloneFullComment(FC, D); 4225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return CFC; 4235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Pos->second; 4255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const Decl *OriginalDecl; 4285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl); 4305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!RC) { 4315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) { 432cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) SmallVector<const NamedDecl*, 8> Overridden; 4335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D); 4345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (OMD && OMD->isPropertyAccessor()) 4355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl()) 4365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (comments::FullComment *FC = getCommentForDecl(PDecl, PP)) 4375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return cloneFullComment(FC, D); 4385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (OMD) 4392a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) addRedeclaredMethods(OMD, Overridden); 4402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden); 4415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (unsigned i = 0, e = Overridden.size(); i < e; i++) 4425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP)) 4435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return cloneFullComment(FC, D); 4445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4452a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) else if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) { 4462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Attach any tag type's documentation to its typedef if latter 4475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // does not have one of its own. 4485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) QualType QT = TD->getUnderlyingType(); 4492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (const TagType *TT = QT->getAs<TagType>()) 4502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (const Decl *TD = TT->getDecl()) 4515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (comments::FullComment *FC = getCommentForDecl(TD, PP)) 4525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return cloneFullComment(FC, D); 4532a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 4542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) else if (const ObjCInterfaceDecl *IC = dyn_cast<ObjCInterfaceDecl>(D)) { 4552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) while (IC->getSuperClass()) { 4565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IC = IC->getSuperClass(); 4575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (comments::FullComment *FC = getCommentForDecl(IC, PP)) 4585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return cloneFullComment(FC, D); 4595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) { 4625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const ObjCInterfaceDecl *IC = CD->getClassInterface()) 4635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (comments::FullComment *FC = getCommentForDecl(IC, PP)) 4645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return cloneFullComment(FC, D); 4655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 467a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) if (!(RD = RD->getDefinition())) 468a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) return NULL; 469a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) // Check non-virtual bases. 470a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) for (CXXRecordDecl::base_class_const_iterator I = 471a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) RD->bases_begin(), E = RD->bases_end(); I != E; ++I) { 472a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) if (I->isVirtual() || (I->getAccessSpecifier() != AS_public)) 473a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) continue; 474a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) QualType Ty = I->getType(); 475a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) if (Ty.isNull()) 476a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) continue; 477a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) { 478a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) if (!(NonVirtualBase= NonVirtualBase->getDefinition())) 4795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) continue; 4805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP)) 4825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return cloneFullComment(FC, D); 4835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Check virtual bases. 4865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (CXXRecordDecl::base_class_const_iterator I = 4872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) RD->vbases_begin(), E = RD->vbases_end(); I != E; ++I) { 4885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (I->getAccessSpecifier() != AS_public) 4895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) continue; 4905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) QualType Ty = I->getType(); 4915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Ty.isNull()) 4925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) continue; 4937d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) { 4945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!(VirtualBase= VirtualBase->getDefinition())) 4955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) continue; 4965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP)) 4975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return cloneFullComment(FC, D); 498a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 4995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 5005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 5015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return NULL; 5025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 5035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // If the RawComment was attached to other redeclaration of this Decl, we 5051320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // should parse the comment in context of that other Decl. This is important 5061320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // because comments can contain references to parameter names which can be 5071320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // different across redeclarations. 5081320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (D != OriginalDecl) 5091320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci return getCommentForDecl(OriginalDecl, PP); 5101320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 5111320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci comments::FullComment *FC = RC->parse(*this, PP, D); 5121320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ParsedComments[Canonical] = FC; 5131320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci return FC; 5141320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci} 5151320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 5161320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tuccivoid 5171320f92c476a1ad9d19dba2a48c72b75566198e9Primiano TucciASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID, 5181320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TemplateTemplateParmDecl *Parm) { 5191320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddInteger(Parm->getDepth()); 5201320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddInteger(Parm->getPosition()); 5211320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddBoolean(Parm->isParameterPack()); 5221320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 5231320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TemplateParameterList *Params = Parm->getTemplateParameters(); 5241320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddInteger(Params->size()); 5251320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci for (TemplateParameterList::const_iterator P = Params->begin(), 5261320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci PEnd = Params->end(); 5271320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci P != PEnd; ++P) { 5281320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { 5291320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddInteger(0); 5301320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddBoolean(TTP->isParameterPack()); 5311320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci continue; 5321320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 5331320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 5341320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 5351320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddInteger(1); 5361320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddBoolean(NTTP->isParameterPack()); 5371320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr()); 5381320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (NTTP->isExpandedParameterPack()) { 5391320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddBoolean(true); 5401320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddInteger(NTTP->getNumExpansionTypes()); 5411320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) { 5421320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci QualType T = NTTP->getExpansionType(I); 5431320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddPointer(T.getCanonicalType().getAsOpaquePtr()); 5441320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 5451320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } else 5461320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddBoolean(false); 5471320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci continue; 5481320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 5491320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 5501320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 5511320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ID.AddInteger(2); 5521320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Profile(ID, TTP); 5535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 5545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 5555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)TemplateTemplateParmDecl * 5575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)ASTContext::getCanonicalTemplateTemplateParmDecl( 5581320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TemplateTemplateParmDecl *TTP) const { 5591320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // Check if we already have a canonical template template parameter. 5605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::FoldingSetNodeID ID; 5615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CanonicalTemplateTemplateParm::Profile(ID, TTP); 5621320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci void *InsertPos = 0; 5635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CanonicalTemplateTemplateParm *Canonical 5645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 5655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Canonical) 5665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Canonical->getParam(); 5675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5681320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci // Build a canonical template parameter list. 569a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) TemplateParameterList *Params = TTP->getTemplateParameters(); 570a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) SmallVector<NamedDecl *, 4> CanonParams; 5715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CanonParams.reserve(Params->size()); 5725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (TemplateParameterList::const_iterator P = Params->begin(), 5735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PEnd = Params->end(); 5741320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci P != PEnd; ++P) { 5751320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) 5761320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci CanonParams.push_back( 5771320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(), 5781320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SourceLocation(), 5791320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SourceLocation(), 5801320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TTP->getDepth(), 5811320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TTP->getIndex(), 0, false, 5821320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TTP->isParameterPack())); 5831320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci else if (NonTypeTemplateParmDecl *NTTP 5841320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 5851320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci QualType T = getCanonicalType(NTTP->getType()); 5861320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T); 5871320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci NonTypeTemplateParmDecl *Param; 5881320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci if (NTTP->isExpandedParameterPack()) { 5891320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SmallVector<QualType, 2> ExpandedTypes; 5901320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SmallVector<TypeSourceInfo *, 2> ExpandedTInfos; 5911320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) { 5925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I))); 5935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExpandedTInfos.push_back( 5945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) getTrivialTypeSourceInfo(ExpandedTypes.back())); 5951320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 5961320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 5971320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 5981320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SourceLocation(), 5991320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SourceLocation(), 6001320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci NTTP->getDepth(), 6011320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci NTTP->getPosition(), 0, 6021320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci T, 6031320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TInfo, 6041320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ExpandedTypes.data(), 6051320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ExpandedTypes.size(), 6061320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci ExpandedTInfos.data()); 6071320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } else { 6081320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 6091320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SourceLocation(), 6101320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SourceLocation(), 6111320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci NTTP->getDepth(), 6121320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci NTTP->getPosition(), 0, 6131320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci T, 6141320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci NTTP->isParameterPack(), 6151320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TInfo); 6161320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 6171320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci CanonParams.push_back(Param); 6181320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 6191320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } else 6201320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci CanonParams.push_back(getCanonicalTemplateTemplateParmDecl( 6211320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci cast<TemplateTemplateParmDecl>(*P))); 6221320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci } 6231320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 6241320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TemplateTemplateParmDecl *CanonTTP 6251320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(), 6261320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SourceLocation(), TTP->getDepth(), 6271320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TTP->getPosition(), 6281320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TTP->isParameterPack(), 6291320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci 0, 6301320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci TemplateParameterList::Create(*this, SourceLocation(), 6311320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SourceLocation(), 6321320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci CanonParams.data(), 6331320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci CanonParams.size(), 6341320f92c476a1ad9d19dba2a48c72b75566198e9Primiano Tucci SourceLocation())); 635a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) 636a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) // Get the new insert position for the node we care about. 637a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos); 638a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) assert(Canonical == 0 && "Shouldn't be in the map!"); 639a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) (void)Canonical; 640a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) 641a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) // Create the canonical template template parameter entry. 642a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP); 6430529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos); 644a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) return CanonTTP; 645a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles)} 646a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) 647a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles)CXXABI *ASTContext::createCXXABI(const TargetInfo &T) { 648a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) if (!LangOpts.CPlusPlus) return 0; 649a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) 650a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) switch (T.getCXXABI().getKind()) { 651a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) case TargetCXXABI::GenericARM: 652a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) case TargetCXXABI::iOS: 653a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) return CreateARMCXXABI(*this); 654a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) case TargetCXXABI::GenericAArch64: // Same as Itanium at this level 655a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) case TargetCXXABI::GenericItanium: 656a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) return CreateItaniumCXXABI(*this); 657a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) case TargetCXXABI::Microsoft: 658a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) return CreateMicrosoftCXXABI(*this); 659a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) } 660a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) llvm_unreachable("Invalid CXXABI type!"); 661a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles)} 662a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) 663a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles)static const LangAS::Map *getAddressSpaceMap(const TargetInfo &T, 664a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) const LangOptions &LOpts) { 665a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) if (LOpts.FakeAddressSpaceMap) { 666a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) // The fake address space map must have a distinct entry for each 667a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) // language-specific address space. 668a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) static const unsigned FakeAddrSpaceMap[] = { 6695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1, // opencl_global 6705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2, // opencl_local 6715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3, // opencl_constant 6725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4, // cuda_device 6735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5, // cuda_constant 6745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6 // cuda_shared 6755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) }; 6762a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return &FakeAddrSpaceMap; 6772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } else { 6785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return &T.getAddressSpaceMap(); 6795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 6815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6825d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)ASTContext::ASTContext(LangOptions& LOpts, SourceManager &SM, 6835d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const TargetInfo *t, 6845d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) IdentifierTable &idents, SelectorTable &sels, 6855d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) Builtin::Context &builtins, 6865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned size_reserve, 6875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool DelayInitialization) 6885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) : FunctionProtoTypes(this_()), 6895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TemplateSpecializationTypes(this_()), 6905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DependentTemplateSpecializationTypes(this_()), 6915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SubstTemplateTemplateParmPacks(this_()), 6925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) GlobalNestedNameSpecifier(0), 6935d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) Int128Decl(0), UInt128Decl(0), 6945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BuiltinVaListDecl(0), 6955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ObjCIdDecl(0), ObjCSelDecl(0), ObjCClassDecl(0), ObjCProtocolClassDecl(0), 6965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BOOLDecl(0), 6975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CFConstantStringTypeDecl(0), ObjCInstanceTypeDecl(0), 6985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FILEDecl(0), 6995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) jmp_bufDecl(0), sigjmp_bufDecl(0), ucontext_tDecl(0), 7005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BlockDescriptorType(0), BlockDescriptorExtendedType(0), 7015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) cudaConfigureCallDecl(0), 7020529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch NullTypeSourceInfo(QualType()), 7030529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch FirstLocalImport(), LastLocalImport(), 7045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceMgr(SM), LangOpts(LOpts), 7055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) AddrSpaceMap(0), Target(t), PrintingPolicy(LOpts), 7065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Idents(idents), Selectors(sels), 7075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BuiltinInfo(builtins), 7085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DeclarationNames(*this), 7095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalSource(0), Listener(0), 7105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Comments(SM), CommentsLoaded(false), 711a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) CommentCommandTraits(BumpAlloc, LOpts.CommentOpts), 712a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) LastSDM(0, 0), 7135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UniqueBlockByRefTypeID(0) 7145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles){ 7155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (size_reserve > 0) Types.reserve(size_reserve); 7165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TUDecl = TranslationUnitDecl::Create(*this); 7175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!DelayInitialization) { 7192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) assert(t && "No target supplied for ASTContext initialization"); 7205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinTypes(*t); 7215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 7235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)ASTContext::~ASTContext() { 7255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Release the DenseMaps associated with DeclContext objects. 7262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // FIXME: Is this the ideal solution? 7275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ReleaseDeclContextMaps(); 7285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Call all of the deallocation functions. 7305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (unsigned I = 0, N = Deallocations.size(); I != N; ++I) 7315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Deallocations[I].first(Deallocations[I].second); 7325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed 7345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // because they can contain DenseMaps. 7355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (llvm::DenseMap<const ObjCContainerDecl*, 7365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const ASTRecordLayout*>::iterator 7375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; ) 7385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Increment in loop to prevent using deallocated memory. 7395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 7405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) R->Destroy(*this); 7415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator 7435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) { 7445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Increment in loop to prevent using deallocated memory. 7455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second)) 7465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) R->Destroy(*this); 7475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(), 7502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) AEnd = DeclAttrs.end(); 7512a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) A != AEnd; ++A) 7525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) A->second->~AttrVec(); 7535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 7545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) { 7565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Deallocations.push_back(std::make_pair(Callback, Data)); 7575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 7585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void 7605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)ASTContext::setExternalSource(OwningPtr<ExternalASTSource> &Source) { 7615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalSource.reset(Source.take()); 7625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 76390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 7645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void ASTContext::PrintStats() const { 7655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << "\n*** AST Context Stats:\n"; 7665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << " " << Types.size() << " types total.\n"; 7675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned counts[] = { 7695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define TYPE(Name, Parent) 0, 7705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define ABSTRACT_TYPE(Name, Parent) 7715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/TypeNodes.def" 7725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 0 // Extra 7735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) }; 7745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) for (unsigned i = 0, e = Types.size(); i != e; ++i) { 7765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Type *T = Types[i]; 7775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) counts[(unsigned)T->getTypeClass()]++; 7785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned Idx = 0; 7815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned TotalBytes = 0; 7825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define TYPE(Name, Parent) \ 7835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (counts[Idx]) \ 7845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << " " << counts[Idx] << " " << #Name \ 7855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << " types\n"; \ 7865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TotalBytes += counts[Idx] * sizeof(Name##Type); \ 7870529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch ++Idx; 7880529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch#define ABSTRACT_TYPE(Name, Parent) 7895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/AST/TypeNodes.def" 7905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << "Total bytes = " << TotalBytes << "\n"; 7925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Implicit special member functions. 7945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/" 7955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << NumImplicitDefaultConstructors 7965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << " implicit default constructors created\n"; 7975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << NumImplicitCopyConstructorsDeclared << "/" 7985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << NumImplicitCopyConstructors 7995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << " implicit copy constructors created\n"; 8005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (getLangOpts().CPlusPlus) 8015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << NumImplicitMoveConstructorsDeclared << "/" 8025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << NumImplicitMoveConstructors 8035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << " implicit move constructors created\n"; 8045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/" 8055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << NumImplicitCopyAssignmentOperators 8065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << " implicit copy assignment operators created\n"; 8075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (getLangOpts().CPlusPlus) 8085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/" 8095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << NumImplicitMoveAssignmentOperators 8105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << " implicit move assignment operators created\n"; 8115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << NumImplicitDestructorsDeclared << "/" 8125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) << NumImplicitDestructors 8130529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch << " implicit destructors created\n"; 8140529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 8155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (ExternalSource.get()) { 8165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::errs() << "\n"; 8175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalSource->PrintStats(); 8185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 8195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BumpAlloc.PrintStats(); 8215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 8225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8235f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)TypedefDecl *ASTContext::getInt128Decl() const { 8245f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) if (!Int128Decl) { 8255f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(Int128Ty); 8265f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) Int128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 8275f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) getTranslationUnitDecl(), 8285f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) SourceLocation(), 8295f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) SourceLocation(), 8305f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) &Idents.get("__int128_t"), 8315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TInfo); 8325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 8335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Int128Decl; 8355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 8360529e5d033099cbfc42635f6f6183833b09dff6eBen Murdoch 8370529e5d033099cbfc42635f6f6183833b09dff6eBen MurdochTypedefDecl *ASTContext::getUInt128Decl() const { 8385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!UInt128Decl) { 8395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(UnsignedInt128Ty); 8405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) UInt128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 8415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) getTranslationUnitDecl(), 8425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation(), 8435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation(), 8445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) &Idents.get("__uint128_t"), 8455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TInfo); 8465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 8475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 848cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles) return UInt128Decl; 8492a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 8502a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 8515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) { 8525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K); 8535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) R = CanQualType::CreateUnsafe(QualType(Ty, 0)); 8545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Types.push_back(Ty); 8555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 8565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8572a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void ASTContext::InitBuiltinTypes(const TargetInfo &Target) { 8585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert((!this->Target || this->Target == &Target) && 8595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) "Incorrect target reinitialization"); 8605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(VoidTy.isNull() && "Context reinitialized?"); 8615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) this->Target = &Target; 8635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ABI.reset(createCXXABI(Target)); 8655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) AddrSpaceMap = getAddressSpaceMap(Target, LangOpts); 8665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // C99 6.2.5p19. 8685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(VoidTy, BuiltinType::Void); 8695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // C99 6.2.5p2. 8715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(BoolTy, BuiltinType::Bool); 8725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // C99 6.2.5p3. 8735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (LangOpts.CharIsSigned) 8745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(CharTy, BuiltinType::Char_S); 8755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else 8765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(CharTy, BuiltinType::Char_U); 8775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // C99 6.2.5p4. 8785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(SignedCharTy, BuiltinType::SChar); 8795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(ShortTy, BuiltinType::Short); 8805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(IntTy, BuiltinType::Int); 8815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(LongTy, BuiltinType::Long); 8825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(LongLongTy, BuiltinType::LongLong); 8831e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) 8841e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) // C99 6.2.5p6. 8855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(UnsignedCharTy, BuiltinType::UChar); 8865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(UnsignedShortTy, BuiltinType::UShort); 8875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(UnsignedIntTy, BuiltinType::UInt); 8885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(UnsignedLongTy, BuiltinType::ULong); 8895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong); 8905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // C99 6.2.5p10. 8925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(FloatTy, BuiltinType::Float); 8935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(DoubleTy, BuiltinType::Double); 8945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble); 8955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // GNU extension, 128-bit integers. 8975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(Int128Ty, BuiltinType::Int128); 8985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128); 8995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // C++ 3.9.1p5 9015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (TargetInfo::isTypeSigned(Target.getWCharType())) 9025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(WCharTy, BuiltinType::WChar_S); 9035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else // -fshort-wchar makes wchar_t be unsigned. 9045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(WCharTy, BuiltinType::WChar_U); 9055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (LangOpts.CPlusPlus && LangOpts.WChar) 9065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) WideCharTy = WCharTy; 9075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else { 9085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // C99 (or C++ using -fno-wchar). 9095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) WideCharTy = getFromTargetType(Target.getWCharType()); 9105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 9115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) WIntTy = getFromTargetType(Target.getWIntType()); 9135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 9155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(Char16Ty, BuiltinType::Char16); 9165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else // C99 9175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Char16Ty = getFromTargetType(Target.getChar16Type()); 9185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++ 9205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(Char32Ty, BuiltinType::Char32); 9215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else // C99 9225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Char32Ty = getFromTargetType(Target.getChar32Type()); 9235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Placeholder type for type-dependent expressions whose type is 9255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // completely unknown. No code should ever check a type against 9265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // DependentTy and users should never see it; however, it is here to 9275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // help diagnose failures to properly check for type-dependent 9285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // expressions. 9295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(DependentTy, BuiltinType::Dependent); 9305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Placeholder type for functions. 9325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(OverloadTy, BuiltinType::Overload); 9335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Placeholder type for bound members. 9355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember); 9365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 93790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Placeholder type for pseudo-objects. 9385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject); 9395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // "any" type; useful for debugger-like clients. 9415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny); 9425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Placeholder type for unbridged ARC casts. 9445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast); 9455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Placeholder type for builtin functions. 9475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(BuiltinFnTy, BuiltinType::BuiltinFn); 9485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // C99 6.2.5p11. 9505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FloatComplexTy = getComplexType(FloatTy); 9515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DoubleComplexTy = getComplexType(DoubleTy); 9525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) LongDoubleComplexTy = getComplexType(LongDoubleTy); 9535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Builtin types for 'id', 'Class', and 'SEL'. 9555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId); 9565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass); 9575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel); 9585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (LangOpts.OpenCL) { 9605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(OCLImage1dTy, BuiltinType::OCLImage1d); 9615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(OCLImage1dArrayTy, BuiltinType::OCLImage1dArray); 9625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(OCLImage1dBufferTy, BuiltinType::OCLImage1dBuffer); 9635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(OCLImage2dTy, BuiltinType::OCLImage2d); 9645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(OCLImage2dArrayTy, BuiltinType::OCLImage2dArray); 9655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(OCLImage3dTy, BuiltinType::OCLImage3d); 9665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler); 9685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(OCLEventTy, BuiltinType::OCLEvent); 9695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 9705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Builtin type for __objc_yes and __objc_no 972a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7Torne (Richard Coles) ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ? 9735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SignedCharTy : BoolTy); 9745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ObjCConstantStringType = QualType(); 9765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ObjCSuperType = QualType(); 9785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // void * type 9805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VoidPtrTy = getPointerType(VoidTy); 9815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // nullptr type (C++0x 2.14.7) 9835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(NullPtrTy, BuiltinType::NullPtr); 9845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // half type (OpenCL 6.1.1.1) / ARM NEON __fp16 9865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InitBuiltinType(HalfTy, BuiltinType::Half); 9875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Builtin type used to help define __builtin_va_list. 9895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) VaListTagTy = QualType(); 9905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 9912a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 9925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)DiagnosticsEngine &ASTContext::getDiagnostics() const { 9932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return SourceMgr.getDiagnostics(); 9945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 995a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch 9965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)AttrVec& ASTContext::getDeclAttrs(const Decl *D) { 9975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) AttrVec *&Result = DeclAttrs[D]; 9985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!Result) { 9995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void *Mem = Allocate(sizeof(AttrVec)); 10005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Result = new (Mem) AttrVec; 10015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 10025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return *Result; 1004a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch} 1005a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch 1006a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch/// \brief Erase the attributes corresponding to the given declaration. 1007a02191e04bc25c4935f804f2c080ae28663d096dBen Murdochvoid ASTContext::eraseDeclAttrs(const Decl *D) { 1008a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D); 1009a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch if (Pos != DeclAttrs.end()) { 1010a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch Pos->second->~AttrVec(); 1011a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch DeclAttrs.erase(Pos); 1012a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch } 1013a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch} 10145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)MemberSpecializationInfo * 10162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) { 10172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) assert(Var->isStaticDataMember() && "Not a static data member"); 10182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>::iterator Pos 10197dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch = InstantiatedFromStaticDataMember.find(Var); 10205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Pos == InstantiatedFromStaticDataMember.end()) 10212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return 0; 10225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Pos->second; 10245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void 10275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, 10285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TemplateSpecializationKind TSK, 10295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation PointOfInstantiation) { 10302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) assert(Inst->isStaticDataMember() && "Not a static data member"); 10315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(Tmpl->isStaticDataMember() && "Not a static data member"); 10327dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch assert(!InstantiatedFromStaticDataMember[Inst] && 10335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) "Already noted what static data member was instantiated from"); 10345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InstantiatedFromStaticDataMember[Inst] 10355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) = new (*this) MemberSpecializationInfo(Tmpl, TSK, PointOfInstantiation); 10365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)FunctionDecl *ASTContext::getClassScopeSpecializationPattern( 10395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const FunctionDecl *FD){ 10405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(FD && "Specialization is 0"); 10415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos 10425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) = ClassScopeSpecializationPattern.find(FD); 10435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Pos == ClassScopeSpecializationPattern.end()) 10445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return 0; 10455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Pos->second; 10475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void ASTContext::setClassScopeSpecializationPattern(FunctionDecl *FD, 10505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FunctionDecl *Pattern) { 10515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(FD && "Specialization is 0"); 10525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(Pattern && "Class scope specialization pattern is 0"); 10535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ClassScopeSpecializationPattern[FD] = Pattern; 10545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)NamedDecl * 10575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)ASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) { 10585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos 10595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) = InstantiatedFromUsingDecl.find(UUD); 10605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Pos == InstantiatedFromUsingDecl.end()) 10615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return 0; 10622a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 10635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Pos->second; 10645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void 10672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)ASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) { 10685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert((isa<UsingDecl>(Pattern) || 10695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) isa<UnresolvedUsingValueDecl>(Pattern) || 10705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) isa<UnresolvedUsingTypenameDecl>(Pattern)) && 10715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) "pattern decl is not a using decl"); 10725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists"); 10735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InstantiatedFromUsingDecl[Inst] = Pattern; 10745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)UsingShadowDecl * 10775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) { 10785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos 10795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) = InstantiatedFromUsingShadowDecl.find(Inst); 10805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Pos == InstantiatedFromUsingShadowDecl.end()) 10815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return 0; 10825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return Pos->second; 10845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 1085868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 10865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)void 10875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, 10885f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) UsingShadowDecl *Pattern) { 10895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"); 10905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InstantiatedFromUsingShadowDecl[Inst] = Pattern; 10915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 10925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) { 10945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos 10955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) = InstantiatedFromUnnamedFieldDecl.find(Field); 10965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Pos == InstantiatedFromUnnamedFieldDecl.end()) 10975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return 0; 10985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 10995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Pos->second; 1100a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch} 1101a02191e04bc25c4935f804f2c080ae28663d096dBen Murdoch 11022a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, 11035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FieldDecl *Tmpl) { 11045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed"); 11055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(!Tmpl->getDeclName() && "Template field decl is not unnamed"); 11065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(!InstantiatedFromUnnamedFieldDecl[Inst] && 11072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) "Already noted what unnamed field was instantiated from"); 11082a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 11095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl; 11105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 11112a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 1112868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)bool ASTContext::ZeroBitfieldFollowsNonBitfield(const FieldDecl *FD, 11135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const FieldDecl *LastFD) const { 1114868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) return (FD->isBitField() && LastFD && !LastFD->isBitField() && 1115868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) FD->getBitWidthValue(*this) == 0); 11162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 11175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 11185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)bool ASTContext::ZeroBitfieldFollowsBitfield(const FieldDecl *FD, 1119 const FieldDecl *LastFD) const { 1120 return (FD->isBitField() && LastFD && LastFD->isBitField() && 1121 FD->getBitWidthValue(*this) == 0 && 1122 LastFD->getBitWidthValue(*this) != 0); 1123} 1124 1125bool ASTContext::BitfieldFollowsBitfield(const FieldDecl *FD, 1126 const FieldDecl *LastFD) const { 1127 return (FD->isBitField() && LastFD && LastFD->isBitField() && 1128 FD->getBitWidthValue(*this) && 1129 LastFD->getBitWidthValue(*this)); 1130} 1131 1132bool ASTContext::NonBitfieldFollowsBitfield(const FieldDecl *FD, 1133 const FieldDecl *LastFD) const { 1134 return (!FD->isBitField() && LastFD && LastFD->isBitField() && 1135 LastFD->getBitWidthValue(*this)); 1136} 1137 1138bool ASTContext::BitfieldFollowsNonBitfield(const FieldDecl *FD, 1139 const FieldDecl *LastFD) const { 1140 return (FD->isBitField() && LastFD && !LastFD->isBitField() && 1141 FD->getBitWidthValue(*this)); 1142} 1143 1144ASTContext::overridden_cxx_method_iterator 1145ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const { 1146 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 1147 = OverriddenMethods.find(Method->getCanonicalDecl()); 1148 if (Pos == OverriddenMethods.end()) 1149 return 0; 1150 1151 return Pos->second.begin(); 1152} 1153 1154ASTContext::overridden_cxx_method_iterator 1155ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const { 1156 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 1157 = OverriddenMethods.find(Method->getCanonicalDecl()); 1158 if (Pos == OverriddenMethods.end()) 1159 return 0; 1160 1161 return Pos->second.end(); 1162} 1163 1164unsigned 1165ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const { 1166 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos 1167 = OverriddenMethods.find(Method->getCanonicalDecl()); 1168 if (Pos == OverriddenMethods.end()) 1169 return 0; 1170 1171 return Pos->second.size(); 1172} 1173 1174void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method, 1175 const CXXMethodDecl *Overridden) { 1176 assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl()); 1177 OverriddenMethods[Method].push_back(Overridden); 1178} 1179 1180void ASTContext::getOverriddenMethods( 1181 const NamedDecl *D, 1182 SmallVectorImpl<const NamedDecl *> &Overridden) const { 1183 assert(D); 1184 1185 if (const CXXMethodDecl *CXXMethod = dyn_cast<CXXMethodDecl>(D)) { 1186 Overridden.append(overridden_methods_begin(CXXMethod), 1187 overridden_methods_end(CXXMethod)); 1188 return; 1189 } 1190 1191 const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D); 1192 if (!Method) 1193 return; 1194 1195 SmallVector<const ObjCMethodDecl *, 8> OverDecls; 1196 Method->getOverriddenMethods(OverDecls); 1197 Overridden.append(OverDecls.begin(), OverDecls.end()); 1198} 1199 1200void ASTContext::addedLocalImportDecl(ImportDecl *Import) { 1201 assert(!Import->NextLocalImport && "Import declaration already in the chain"); 1202 assert(!Import->isFromASTFile() && "Non-local import declaration"); 1203 if (!FirstLocalImport) { 1204 FirstLocalImport = Import; 1205 LastLocalImport = Import; 1206 return; 1207 } 1208 1209 LastLocalImport->NextLocalImport = Import; 1210 LastLocalImport = Import; 1211} 1212 1213//===----------------------------------------------------------------------===// 1214// Type Sizing and Analysis 1215//===----------------------------------------------------------------------===// 1216 1217/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified 1218/// scalar floating point type. 1219const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const { 1220 const BuiltinType *BT = T->getAs<BuiltinType>(); 1221 assert(BT && "Not a floating point type!"); 1222 switch (BT->getKind()) { 1223 default: llvm_unreachable("Not a floating point type!"); 1224 case BuiltinType::Half: return Target->getHalfFormat(); 1225 case BuiltinType::Float: return Target->getFloatFormat(); 1226 case BuiltinType::Double: return Target->getDoubleFormat(); 1227 case BuiltinType::LongDouble: return Target->getLongDoubleFormat(); 1228 } 1229} 1230 1231/// getDeclAlign - Return a conservative estimate of the alignment of the 1232/// specified decl. Note that bitfields do not have a valid alignment, so 1233/// this method will assert on them. 1234/// If @p RefAsPointee, references are treated like their underlying type 1235/// (for alignof), else they're treated like pointers (for CodeGen). 1236CharUnits ASTContext::getDeclAlign(const Decl *D, bool RefAsPointee) const { 1237 unsigned Align = Target->getCharWidth(); 1238 1239 bool UseAlignAttrOnly = false; 1240 if (unsigned AlignFromAttr = D->getMaxAlignment()) { 1241 Align = AlignFromAttr; 1242 1243 // __attribute__((aligned)) can increase or decrease alignment 1244 // *except* on a struct or struct member, where it only increases 1245 // alignment unless 'packed' is also specified. 1246 // 1247 // It is an error for alignas to decrease alignment, so we can 1248 // ignore that possibility; Sema should diagnose it. 1249 if (isa<FieldDecl>(D)) { 1250 UseAlignAttrOnly = D->hasAttr<PackedAttr>() || 1251 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 1252 } else { 1253 UseAlignAttrOnly = true; 1254 } 1255 } 1256 else if (isa<FieldDecl>(D)) 1257 UseAlignAttrOnly = 1258 D->hasAttr<PackedAttr>() || 1259 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>(); 1260 1261 // If we're using the align attribute only, just ignore everything 1262 // else about the declaration and its type. 1263 if (UseAlignAttrOnly) { 1264 // do nothing 1265 1266 } else if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) { 1267 QualType T = VD->getType(); 1268 if (const ReferenceType* RT = T->getAs<ReferenceType>()) { 1269 if (RefAsPointee) 1270 T = RT->getPointeeType(); 1271 else 1272 T = getPointerType(RT->getPointeeType()); 1273 } 1274 if (!T->isIncompleteType() && !T->isFunctionType()) { 1275 // Adjust alignments of declarations with array type by the 1276 // large-array alignment on the target. 1277 unsigned MinWidth = Target->getLargeArrayMinWidth(); 1278 const ArrayType *arrayType; 1279 if (MinWidth && (arrayType = getAsArrayType(T))) { 1280 if (isa<VariableArrayType>(arrayType)) 1281 Align = std::max(Align, Target->getLargeArrayAlign()); 1282 else if (isa<ConstantArrayType>(arrayType) && 1283 MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType))) 1284 Align = std::max(Align, Target->getLargeArrayAlign()); 1285 1286 // Walk through any array types while we're at it. 1287 T = getBaseElementType(arrayType); 1288 } 1289 Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr())); 1290 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 1291 if (VD->hasGlobalStorage()) 1292 Align = std::max(Align, getTargetInfo().getMinGlobalAlign()); 1293 } 1294 } 1295 1296 // Fields can be subject to extra alignment constraints, like if 1297 // the field is packed, the struct is packed, or the struct has a 1298 // a max-field-alignment constraint (#pragma pack). So calculate 1299 // the actual alignment of the field within the struct, and then 1300 // (as we're expected to) constrain that by the alignment of the type. 1301 if (const FieldDecl *field = dyn_cast<FieldDecl>(VD)) { 1302 // So calculate the alignment of the field. 1303 const ASTRecordLayout &layout = getASTRecordLayout(field->getParent()); 1304 1305 // Start with the record's overall alignment. 1306 unsigned fieldAlign = toBits(layout.getAlignment()); 1307 1308 // Use the GCD of that and the offset within the record. 1309 uint64_t offset = layout.getFieldOffset(field->getFieldIndex()); 1310 if (offset > 0) { 1311 // Alignment is always a power of 2, so the GCD will be a power of 2, 1312 // which means we get to do this crazy thing instead of Euclid's. 1313 uint64_t lowBitOfOffset = offset & (~offset + 1); 1314 if (lowBitOfOffset < fieldAlign) 1315 fieldAlign = static_cast<unsigned>(lowBitOfOffset); 1316 } 1317 1318 Align = std::min(Align, fieldAlign); 1319 } 1320 } 1321 1322 return toCharUnitsFromBits(Align); 1323} 1324 1325// getTypeInfoDataSizeInChars - Return the size of a type, in 1326// chars. If the type is a record, its data size is returned. This is 1327// the size of the memcpy that's performed when assigning this type 1328// using a trivial copy/move assignment operator. 1329std::pair<CharUnits, CharUnits> 1330ASTContext::getTypeInfoDataSizeInChars(QualType T) const { 1331 std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T); 1332 1333 // In C++, objects can sometimes be allocated into the tail padding 1334 // of a base-class subobject. We decide whether that's possible 1335 // during class layout, so here we can just trust the layout results. 1336 if (getLangOpts().CPlusPlus) { 1337 if (const RecordType *RT = T->getAs<RecordType>()) { 1338 const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl()); 1339 sizeAndAlign.first = layout.getDataSize(); 1340 } 1341 } 1342 1343 return sizeAndAlign; 1344} 1345 1346std::pair<CharUnits, CharUnits> 1347ASTContext::getTypeInfoInChars(const Type *T) const { 1348 std::pair<uint64_t, unsigned> Info = getTypeInfo(T); 1349 return std::make_pair(toCharUnitsFromBits(Info.first), 1350 toCharUnitsFromBits(Info.second)); 1351} 1352 1353std::pair<CharUnits, CharUnits> 1354ASTContext::getTypeInfoInChars(QualType T) const { 1355 return getTypeInfoInChars(T.getTypePtr()); 1356} 1357 1358std::pair<uint64_t, unsigned> ASTContext::getTypeInfo(const Type *T) const { 1359 TypeInfoMap::iterator it = MemoizedTypeInfo.find(T); 1360 if (it != MemoizedTypeInfo.end()) 1361 return it->second; 1362 1363 std::pair<uint64_t, unsigned> Info = getTypeInfoImpl(T); 1364 MemoizedTypeInfo.insert(std::make_pair(T, Info)); 1365 return Info; 1366} 1367 1368/// getTypeInfoImpl - Return the size of the specified type, in bits. This 1369/// method does not work on incomplete types. 1370/// 1371/// FIXME: Pointers into different addr spaces could have different sizes and 1372/// alignment requirements: getPointerInfo should take an AddrSpace, this 1373/// should take a QualType, &c. 1374std::pair<uint64_t, unsigned> 1375ASTContext::getTypeInfoImpl(const Type *T) const { 1376 uint64_t Width=0; 1377 unsigned Align=8; 1378 switch (T->getTypeClass()) { 1379#define TYPE(Class, Base) 1380#define ABSTRACT_TYPE(Class, Base) 1381#define NON_CANONICAL_TYPE(Class, Base) 1382#define DEPENDENT_TYPE(Class, Base) case Type::Class: 1383#include "clang/AST/TypeNodes.def" 1384 llvm_unreachable("Should not see dependent types"); 1385 1386 case Type::FunctionNoProto: 1387 case Type::FunctionProto: 1388 // GCC extension: alignof(function) = 32 bits 1389 Width = 0; 1390 Align = 32; 1391 break; 1392 1393 case Type::IncompleteArray: 1394 case Type::VariableArray: 1395 Width = 0; 1396 Align = getTypeAlign(cast<ArrayType>(T)->getElementType()); 1397 break; 1398 1399 case Type::ConstantArray: { 1400 const ConstantArrayType *CAT = cast<ConstantArrayType>(T); 1401 1402 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType()); 1403 uint64_t Size = CAT->getSize().getZExtValue(); 1404 assert((Size == 0 || EltInfo.first <= (uint64_t)(-1)/Size) && 1405 "Overflow in array type bit size evaluation"); 1406 Width = EltInfo.first*Size; 1407 Align = EltInfo.second; 1408 Width = llvm::RoundUpToAlignment(Width, Align); 1409 break; 1410 } 1411 case Type::ExtVector: 1412 case Type::Vector: { 1413 const VectorType *VT = cast<VectorType>(T); 1414 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType()); 1415 Width = EltInfo.first*VT->getNumElements(); 1416 Align = Width; 1417 // If the alignment is not a power of 2, round up to the next power of 2. 1418 // This happens for non-power-of-2 length vectors. 1419 if (Align & (Align-1)) { 1420 Align = llvm::NextPowerOf2(Align); 1421 Width = llvm::RoundUpToAlignment(Width, Align); 1422 } 1423 // Adjust the alignment based on the target max. 1424 uint64_t TargetVectorAlign = Target->getMaxVectorAlign(); 1425 if (TargetVectorAlign && TargetVectorAlign < Align) 1426 Align = TargetVectorAlign; 1427 break; 1428 } 1429 1430 case Type::Builtin: 1431 switch (cast<BuiltinType>(T)->getKind()) { 1432 default: llvm_unreachable("Unknown builtin type!"); 1433 case BuiltinType::Void: 1434 // GCC extension: alignof(void) = 8 bits. 1435 Width = 0; 1436 Align = 8; 1437 break; 1438 1439 case BuiltinType::Bool: 1440 Width = Target->getBoolWidth(); 1441 Align = Target->getBoolAlign(); 1442 break; 1443 case BuiltinType::Char_S: 1444 case BuiltinType::Char_U: 1445 case BuiltinType::UChar: 1446 case BuiltinType::SChar: 1447 Width = Target->getCharWidth(); 1448 Align = Target->getCharAlign(); 1449 break; 1450 case BuiltinType::WChar_S: 1451 case BuiltinType::WChar_U: 1452 Width = Target->getWCharWidth(); 1453 Align = Target->getWCharAlign(); 1454 break; 1455 case BuiltinType::Char16: 1456 Width = Target->getChar16Width(); 1457 Align = Target->getChar16Align(); 1458 break; 1459 case BuiltinType::Char32: 1460 Width = Target->getChar32Width(); 1461 Align = Target->getChar32Align(); 1462 break; 1463 case BuiltinType::UShort: 1464 case BuiltinType::Short: 1465 Width = Target->getShortWidth(); 1466 Align = Target->getShortAlign(); 1467 break; 1468 case BuiltinType::UInt: 1469 case BuiltinType::Int: 1470 Width = Target->getIntWidth(); 1471 Align = Target->getIntAlign(); 1472 break; 1473 case BuiltinType::ULong: 1474 case BuiltinType::Long: 1475 Width = Target->getLongWidth(); 1476 Align = Target->getLongAlign(); 1477 break; 1478 case BuiltinType::ULongLong: 1479 case BuiltinType::LongLong: 1480 Width = Target->getLongLongWidth(); 1481 Align = Target->getLongLongAlign(); 1482 break; 1483 case BuiltinType::Int128: 1484 case BuiltinType::UInt128: 1485 Width = 128; 1486 Align = 128; // int128_t is 128-bit aligned on all targets. 1487 break; 1488 case BuiltinType::Half: 1489 Width = Target->getHalfWidth(); 1490 Align = Target->getHalfAlign(); 1491 break; 1492 case BuiltinType::Float: 1493 Width = Target->getFloatWidth(); 1494 Align = Target->getFloatAlign(); 1495 break; 1496 case BuiltinType::Double: 1497 Width = Target->getDoubleWidth(); 1498 Align = Target->getDoubleAlign(); 1499 break; 1500 case BuiltinType::LongDouble: 1501 Width = Target->getLongDoubleWidth(); 1502 Align = Target->getLongDoubleAlign(); 1503 break; 1504 case BuiltinType::NullPtr: 1505 Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t) 1506 Align = Target->getPointerAlign(0); // == sizeof(void*) 1507 break; 1508 case BuiltinType::ObjCId: 1509 case BuiltinType::ObjCClass: 1510 case BuiltinType::ObjCSel: 1511 Width = Target->getPointerWidth(0); 1512 Align = Target->getPointerAlign(0); 1513 break; 1514 case BuiltinType::OCLSampler: 1515 // Samplers are modeled as integers. 1516 Width = Target->getIntWidth(); 1517 Align = Target->getIntAlign(); 1518 break; 1519 case BuiltinType::OCLEvent: 1520 case BuiltinType::OCLImage1d: 1521 case BuiltinType::OCLImage1dArray: 1522 case BuiltinType::OCLImage1dBuffer: 1523 case BuiltinType::OCLImage2d: 1524 case BuiltinType::OCLImage2dArray: 1525 case BuiltinType::OCLImage3d: 1526 // Currently these types are pointers to opaque types. 1527 Width = Target->getPointerWidth(0); 1528 Align = Target->getPointerAlign(0); 1529 break; 1530 } 1531 break; 1532 case Type::ObjCObjectPointer: 1533 Width = Target->getPointerWidth(0); 1534 Align = Target->getPointerAlign(0); 1535 break; 1536 case Type::BlockPointer: { 1537 unsigned AS = getTargetAddressSpace( 1538 cast<BlockPointerType>(T)->getPointeeType()); 1539 Width = Target->getPointerWidth(AS); 1540 Align = Target->getPointerAlign(AS); 1541 break; 1542 } 1543 case Type::LValueReference: 1544 case Type::RValueReference: { 1545 // alignof and sizeof should never enter this code path here, so we go 1546 // the pointer route. 1547 unsigned AS = getTargetAddressSpace( 1548 cast<ReferenceType>(T)->getPointeeType()); 1549 Width = Target->getPointerWidth(AS); 1550 Align = Target->getPointerAlign(AS); 1551 break; 1552 } 1553 case Type::Pointer: { 1554 unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType()); 1555 Width = Target->getPointerWidth(AS); 1556 Align = Target->getPointerAlign(AS); 1557 break; 1558 } 1559 case Type::MemberPointer: { 1560 const MemberPointerType *MPT = cast<MemberPointerType>(T); 1561 llvm::tie(Width, Align) = ABI->getMemberPointerWidthAndAlign(MPT); 1562 break; 1563 } 1564 case Type::Complex: { 1565 // Complex types have the same alignment as their elements, but twice the 1566 // size. 1567 std::pair<uint64_t, unsigned> EltInfo = 1568 getTypeInfo(cast<ComplexType>(T)->getElementType()); 1569 Width = EltInfo.first*2; 1570 Align = EltInfo.second; 1571 break; 1572 } 1573 case Type::ObjCObject: 1574 return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr()); 1575 case Type::ObjCInterface: { 1576 const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T); 1577 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl()); 1578 Width = toBits(Layout.getSize()); 1579 Align = toBits(Layout.getAlignment()); 1580 break; 1581 } 1582 case Type::Record: 1583 case Type::Enum: { 1584 const TagType *TT = cast<TagType>(T); 1585 1586 if (TT->getDecl()->isInvalidDecl()) { 1587 Width = 8; 1588 Align = 8; 1589 break; 1590 } 1591 1592 if (const EnumType *ET = dyn_cast<EnumType>(TT)) 1593 return getTypeInfo(ET->getDecl()->getIntegerType()); 1594 1595 const RecordType *RT = cast<RecordType>(TT); 1596 const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl()); 1597 Width = toBits(Layout.getSize()); 1598 Align = toBits(Layout.getAlignment()); 1599 break; 1600 } 1601 1602 case Type::SubstTemplateTypeParm: 1603 return getTypeInfo(cast<SubstTemplateTypeParmType>(T)-> 1604 getReplacementType().getTypePtr()); 1605 1606 case Type::Auto: { 1607 const AutoType *A = cast<AutoType>(T); 1608 assert(!A->getDeducedType().isNull() && 1609 "cannot request the size of an undeduced or dependent auto type"); 1610 return getTypeInfo(A->getDeducedType().getTypePtr()); 1611 } 1612 1613 case Type::Paren: 1614 return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr()); 1615 1616 case Type::Typedef: { 1617 const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl(); 1618 std::pair<uint64_t, unsigned> Info 1619 = getTypeInfo(Typedef->getUnderlyingType().getTypePtr()); 1620 // If the typedef has an aligned attribute on it, it overrides any computed 1621 // alignment we have. This violates the GCC documentation (which says that 1622 // attribute(aligned) can only round up) but matches its implementation. 1623 if (unsigned AttrAlign = Typedef->getMaxAlignment()) 1624 Align = AttrAlign; 1625 else 1626 Align = Info.second; 1627 Width = Info.first; 1628 break; 1629 } 1630 1631 case Type::TypeOfExpr: 1632 return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType() 1633 .getTypePtr()); 1634 1635 case Type::TypeOf: 1636 return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr()); 1637 1638 case Type::Decltype: 1639 return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType() 1640 .getTypePtr()); 1641 1642 case Type::UnaryTransform: 1643 return getTypeInfo(cast<UnaryTransformType>(T)->getUnderlyingType()); 1644 1645 case Type::Elaborated: 1646 return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr()); 1647 1648 case Type::Attributed: 1649 return getTypeInfo( 1650 cast<AttributedType>(T)->getEquivalentType().getTypePtr()); 1651 1652 case Type::TemplateSpecialization: { 1653 assert(getCanonicalType(T) != T && 1654 "Cannot request the size of a dependent type"); 1655 const TemplateSpecializationType *TST = cast<TemplateSpecializationType>(T); 1656 // A type alias template specialization may refer to a typedef with the 1657 // aligned attribute on it. 1658 if (TST->isTypeAlias()) 1659 return getTypeInfo(TST->getAliasedType().getTypePtr()); 1660 else 1661 return getTypeInfo(getCanonicalType(T)); 1662 } 1663 1664 case Type::Atomic: { 1665 // Start with the base type information. 1666 std::pair<uint64_t, unsigned> Info 1667 = getTypeInfo(cast<AtomicType>(T)->getValueType()); 1668 Width = Info.first; 1669 Align = Info.second; 1670 1671 // If the size of the type doesn't exceed the platform's max 1672 // atomic promotion width, make the size and alignment more 1673 // favorable to atomic operations: 1674 if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth()) { 1675 // Round the size up to a power of 2. 1676 if (!llvm::isPowerOf2_64(Width)) 1677 Width = llvm::NextPowerOf2(Width); 1678 1679 // Set the alignment equal to the size. 1680 Align = static_cast<unsigned>(Width); 1681 } 1682 } 1683 1684 } 1685 1686 assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"); 1687 return std::make_pair(Width, Align); 1688} 1689 1690/// toCharUnitsFromBits - Convert a size in bits to a size in characters. 1691CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const { 1692 return CharUnits::fromQuantity(BitSize / getCharWidth()); 1693} 1694 1695/// toBits - Convert a size in characters to a size in characters. 1696int64_t ASTContext::toBits(CharUnits CharSize) const { 1697 return CharSize.getQuantity() * getCharWidth(); 1698} 1699 1700/// getTypeSizeInChars - Return the size of the specified type, in characters. 1701/// This method does not work on incomplete types. 1702CharUnits ASTContext::getTypeSizeInChars(QualType T) const { 1703 return toCharUnitsFromBits(getTypeSize(T)); 1704} 1705CharUnits ASTContext::getTypeSizeInChars(const Type *T) const { 1706 return toCharUnitsFromBits(getTypeSize(T)); 1707} 1708 1709/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in 1710/// characters. This method does not work on incomplete types. 1711CharUnits ASTContext::getTypeAlignInChars(QualType T) const { 1712 return toCharUnitsFromBits(getTypeAlign(T)); 1713} 1714CharUnits ASTContext::getTypeAlignInChars(const Type *T) const { 1715 return toCharUnitsFromBits(getTypeAlign(T)); 1716} 1717 1718/// getPreferredTypeAlign - Return the "preferred" alignment of the specified 1719/// type for the current target in bits. This can be different than the ABI 1720/// alignment in cases where it is beneficial for performance to overalign 1721/// a data type. 1722unsigned ASTContext::getPreferredTypeAlign(const Type *T) const { 1723 unsigned ABIAlign = getTypeAlign(T); 1724 1725 // Double and long long should be naturally aligned if possible. 1726 if (const ComplexType* CT = T->getAs<ComplexType>()) 1727 T = CT->getElementType().getTypePtr(); 1728 if (T->isSpecificBuiltinType(BuiltinType::Double) || 1729 T->isSpecificBuiltinType(BuiltinType::LongLong) || 1730 T->isSpecificBuiltinType(BuiltinType::ULongLong)) 1731 return std::max(ABIAlign, (unsigned)getTypeSize(T)); 1732 1733 return ABIAlign; 1734} 1735 1736/// getAlignOfGlobalVar - Return the alignment in bits that should be given 1737/// to a global variable of the specified type. 1738unsigned ASTContext::getAlignOfGlobalVar(QualType T) const { 1739 return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign()); 1740} 1741 1742/// getAlignOfGlobalVarInChars - Return the alignment in characters that 1743/// should be given to a global variable of the specified type. 1744CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T) const { 1745 return toCharUnitsFromBits(getAlignOfGlobalVar(T)); 1746} 1747 1748/// DeepCollectObjCIvars - 1749/// This routine first collects all declared, but not synthesized, ivars in 1750/// super class and then collects all ivars, including those synthesized for 1751/// current class. This routine is used for implementation of current class 1752/// when all ivars, declared and synthesized are known. 1753/// 1754void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, 1755 bool leafClass, 1756 SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const { 1757 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass()) 1758 DeepCollectObjCIvars(SuperClass, false, Ivars); 1759 if (!leafClass) { 1760 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(), 1761 E = OI->ivar_end(); I != E; ++I) 1762 Ivars.push_back(*I); 1763 } else { 1764 ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI); 1765 for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv; 1766 Iv= Iv->getNextIvar()) 1767 Ivars.push_back(Iv); 1768 } 1769} 1770 1771/// CollectInheritedProtocols - Collect all protocols in current class and 1772/// those inherited by it. 1773void ASTContext::CollectInheritedProtocols(const Decl *CDecl, 1774 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) { 1775 if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) { 1776 // We can use protocol_iterator here instead of 1777 // all_referenced_protocol_iterator since we are walking all categories. 1778 for (ObjCInterfaceDecl::all_protocol_iterator P = OI->all_referenced_protocol_begin(), 1779 PE = OI->all_referenced_protocol_end(); P != PE; ++P) { 1780 ObjCProtocolDecl *Proto = (*P); 1781 Protocols.insert(Proto->getCanonicalDecl()); 1782 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1783 PE = Proto->protocol_end(); P != PE; ++P) { 1784 Protocols.insert((*P)->getCanonicalDecl()); 1785 CollectInheritedProtocols(*P, Protocols); 1786 } 1787 } 1788 1789 // Categories of this Interface. 1790 for (ObjCInterfaceDecl::visible_categories_iterator 1791 Cat = OI->visible_categories_begin(), 1792 CatEnd = OI->visible_categories_end(); 1793 Cat != CatEnd; ++Cat) { 1794 CollectInheritedProtocols(*Cat, Protocols); 1795 } 1796 1797 if (ObjCInterfaceDecl *SD = OI->getSuperClass()) 1798 while (SD) { 1799 CollectInheritedProtocols(SD, Protocols); 1800 SD = SD->getSuperClass(); 1801 } 1802 } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) { 1803 for (ObjCCategoryDecl::protocol_iterator P = OC->protocol_begin(), 1804 PE = OC->protocol_end(); P != PE; ++P) { 1805 ObjCProtocolDecl *Proto = (*P); 1806 Protocols.insert(Proto->getCanonicalDecl()); 1807 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1808 PE = Proto->protocol_end(); P != PE; ++P) 1809 CollectInheritedProtocols(*P, Protocols); 1810 } 1811 } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) { 1812 for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(), 1813 PE = OP->protocol_end(); P != PE; ++P) { 1814 ObjCProtocolDecl *Proto = (*P); 1815 Protocols.insert(Proto->getCanonicalDecl()); 1816 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(), 1817 PE = Proto->protocol_end(); P != PE; ++P) 1818 CollectInheritedProtocols(*P, Protocols); 1819 } 1820 } 1821} 1822 1823unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const { 1824 unsigned count = 0; 1825 // Count ivars declared in class extension. 1826 for (ObjCInterfaceDecl::known_extensions_iterator 1827 Ext = OI->known_extensions_begin(), 1828 ExtEnd = OI->known_extensions_end(); 1829 Ext != ExtEnd; ++Ext) { 1830 count += Ext->ivar_size(); 1831 } 1832 1833 // Count ivar defined in this class's implementation. This 1834 // includes synthesized ivars. 1835 if (ObjCImplementationDecl *ImplDecl = OI->getImplementation()) 1836 count += ImplDecl->ivar_size(); 1837 1838 return count; 1839} 1840 1841bool ASTContext::isSentinelNullExpr(const Expr *E) { 1842 if (!E) 1843 return false; 1844 1845 // nullptr_t is always treated as null. 1846 if (E->getType()->isNullPtrType()) return true; 1847 1848 if (E->getType()->isAnyPointerType() && 1849 E->IgnoreParenCasts()->isNullPointerConstant(*this, 1850 Expr::NPC_ValueDependentIsNull)) 1851 return true; 1852 1853 // Unfortunately, __null has type 'int'. 1854 if (isa<GNUNullExpr>(E)) return true; 1855 1856 return false; 1857} 1858 1859/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists. 1860ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) { 1861 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 1862 I = ObjCImpls.find(D); 1863 if (I != ObjCImpls.end()) 1864 return cast<ObjCImplementationDecl>(I->second); 1865 return 0; 1866} 1867/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists. 1868ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) { 1869 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator 1870 I = ObjCImpls.find(D); 1871 if (I != ObjCImpls.end()) 1872 return cast<ObjCCategoryImplDecl>(I->second); 1873 return 0; 1874} 1875 1876/// \brief Set the implementation of ObjCInterfaceDecl. 1877void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD, 1878 ObjCImplementationDecl *ImplD) { 1879 assert(IFaceD && ImplD && "Passed null params"); 1880 ObjCImpls[IFaceD] = ImplD; 1881} 1882/// \brief Set the implementation of ObjCCategoryDecl. 1883void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD, 1884 ObjCCategoryImplDecl *ImplD) { 1885 assert(CatD && ImplD && "Passed null params"); 1886 ObjCImpls[CatD] = ImplD; 1887} 1888 1889const ObjCInterfaceDecl *ASTContext::getObjContainingInterface( 1890 const NamedDecl *ND) const { 1891 if (const ObjCInterfaceDecl *ID = 1892 dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext())) 1893 return ID; 1894 if (const ObjCCategoryDecl *CD = 1895 dyn_cast<ObjCCategoryDecl>(ND->getDeclContext())) 1896 return CD->getClassInterface(); 1897 if (const ObjCImplDecl *IMD = 1898 dyn_cast<ObjCImplDecl>(ND->getDeclContext())) 1899 return IMD->getClassInterface(); 1900 1901 return 0; 1902} 1903 1904/// \brief Get the copy initialization expression of VarDecl,or NULL if 1905/// none exists. 1906Expr *ASTContext::getBlockVarCopyInits(const VarDecl*VD) { 1907 assert(VD && "Passed null params"); 1908 assert(VD->hasAttr<BlocksAttr>() && 1909 "getBlockVarCopyInits - not __block var"); 1910 llvm::DenseMap<const VarDecl*, Expr*>::iterator 1911 I = BlockVarCopyInits.find(VD); 1912 return (I != BlockVarCopyInits.end()) ? cast<Expr>(I->second) : 0; 1913} 1914 1915/// \brief Set the copy inialization expression of a block var decl. 1916void ASTContext::setBlockVarCopyInits(VarDecl*VD, Expr* Init) { 1917 assert(VD && Init && "Passed null params"); 1918 assert(VD->hasAttr<BlocksAttr>() && 1919 "setBlockVarCopyInits - not __block var"); 1920 BlockVarCopyInits[VD] = Init; 1921} 1922 1923TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T, 1924 unsigned DataSize) const { 1925 if (!DataSize) 1926 DataSize = TypeLoc::getFullDataSizeForType(T); 1927 else 1928 assert(DataSize == TypeLoc::getFullDataSizeForType(T) && 1929 "incorrect data size provided to CreateTypeSourceInfo!"); 1930 1931 TypeSourceInfo *TInfo = 1932 (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8); 1933 new (TInfo) TypeSourceInfo(T); 1934 return TInfo; 1935} 1936 1937TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T, 1938 SourceLocation L) const { 1939 TypeSourceInfo *DI = CreateTypeSourceInfo(T); 1940 DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L); 1941 return DI; 1942} 1943 1944const ASTRecordLayout & 1945ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const { 1946 return getObjCLayout(D, 0); 1947} 1948 1949const ASTRecordLayout & 1950ASTContext::getASTObjCImplementationLayout( 1951 const ObjCImplementationDecl *D) const { 1952 return getObjCLayout(D->getClassInterface(), D); 1953} 1954 1955//===----------------------------------------------------------------------===// 1956// Type creation/memoization methods 1957//===----------------------------------------------------------------------===// 1958 1959QualType 1960ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const { 1961 unsigned fastQuals = quals.getFastQualifiers(); 1962 quals.removeFastQualifiers(); 1963 1964 // Check if we've already instantiated this type. 1965 llvm::FoldingSetNodeID ID; 1966 ExtQuals::Profile(ID, baseType, quals); 1967 void *insertPos = 0; 1968 if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) { 1969 assert(eq->getQualifiers() == quals); 1970 return QualType(eq, fastQuals); 1971 } 1972 1973 // If the base type is not canonical, make the appropriate canonical type. 1974 QualType canon; 1975 if (!baseType->isCanonicalUnqualified()) { 1976 SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split(); 1977 canonSplit.Quals.addConsistentQualifiers(quals); 1978 canon = getExtQualType(canonSplit.Ty, canonSplit.Quals); 1979 1980 // Re-find the insert position. 1981 (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos); 1982 } 1983 1984 ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals); 1985 ExtQualNodes.InsertNode(eq, insertPos); 1986 return QualType(eq, fastQuals); 1987} 1988 1989QualType 1990ASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) const { 1991 QualType CanT = getCanonicalType(T); 1992 if (CanT.getAddressSpace() == AddressSpace) 1993 return T; 1994 1995 // If we are composing extended qualifiers together, merge together 1996 // into one ExtQuals node. 1997 QualifierCollector Quals; 1998 const Type *TypeNode = Quals.strip(T); 1999 2000 // If this type already has an address space specified, it cannot get 2001 // another one. 2002 assert(!Quals.hasAddressSpace() && 2003 "Type cannot be in multiple addr spaces!"); 2004 Quals.addAddressSpace(AddressSpace); 2005 2006 return getExtQualType(TypeNode, Quals); 2007} 2008 2009QualType ASTContext::getObjCGCQualType(QualType T, 2010 Qualifiers::GC GCAttr) const { 2011 QualType CanT = getCanonicalType(T); 2012 if (CanT.getObjCGCAttr() == GCAttr) 2013 return T; 2014 2015 if (const PointerType *ptr = T->getAs<PointerType>()) { 2016 QualType Pointee = ptr->getPointeeType(); 2017 if (Pointee->isAnyPointerType()) { 2018 QualType ResultType = getObjCGCQualType(Pointee, GCAttr); 2019 return getPointerType(ResultType); 2020 } 2021 } 2022 2023 // If we are composing extended qualifiers together, merge together 2024 // into one ExtQuals node. 2025 QualifierCollector Quals; 2026 const Type *TypeNode = Quals.strip(T); 2027 2028 // If this type already has an ObjCGC specified, it cannot get 2029 // another one. 2030 assert(!Quals.hasObjCGCAttr() && 2031 "Type cannot have multiple ObjCGCs!"); 2032 Quals.addObjCGCAttr(GCAttr); 2033 2034 return getExtQualType(TypeNode, Quals); 2035} 2036 2037const FunctionType *ASTContext::adjustFunctionType(const FunctionType *T, 2038 FunctionType::ExtInfo Info) { 2039 if (T->getExtInfo() == Info) 2040 return T; 2041 2042 QualType Result; 2043 if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(T)) { 2044 Result = getFunctionNoProtoType(FNPT->getResultType(), Info); 2045 } else { 2046 const FunctionProtoType *FPT = cast<FunctionProtoType>(T); 2047 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 2048 EPI.ExtInfo = Info; 2049 Result = getFunctionType(FPT->getResultType(), 2050 ArrayRef<QualType>(FPT->arg_type_begin(), 2051 FPT->getNumArgs()), 2052 EPI); 2053 } 2054 2055 return cast<FunctionType>(Result.getTypePtr()); 2056} 2057 2058void ASTContext::adjustDeducedFunctionResultType(FunctionDecl *FD, 2059 QualType ResultType) { 2060 FD = FD->getMostRecentDecl(); 2061 while (true) { 2062 const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>(); 2063 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 2064 FD->setType(getFunctionType(ResultType, FPT->getArgTypes(), EPI)); 2065 if (FunctionDecl *Next = FD->getPreviousDecl()) 2066 FD = Next; 2067 else 2068 break; 2069 } 2070 if (ASTMutationListener *L = getASTMutationListener()) 2071 L->DeducedReturnType(FD, ResultType); 2072} 2073 2074/// getComplexType - Return the uniqued reference to the type for a complex 2075/// number with the specified element type. 2076QualType ASTContext::getComplexType(QualType T) const { 2077 // Unique pointers, to guarantee there is only one pointer of a particular 2078 // structure. 2079 llvm::FoldingSetNodeID ID; 2080 ComplexType::Profile(ID, T); 2081 2082 void *InsertPos = 0; 2083 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos)) 2084 return QualType(CT, 0); 2085 2086 // If the pointee type isn't canonical, this won't be a canonical type either, 2087 // so fill in the canonical type field. 2088 QualType Canonical; 2089 if (!T.isCanonical()) { 2090 Canonical = getComplexType(getCanonicalType(T)); 2091 2092 // Get the new insert position for the node we care about. 2093 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos); 2094 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2095 } 2096 ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical); 2097 Types.push_back(New); 2098 ComplexTypes.InsertNode(New, InsertPos); 2099 return QualType(New, 0); 2100} 2101 2102/// getPointerType - Return the uniqued reference to the type for a pointer to 2103/// the specified type. 2104QualType ASTContext::getPointerType(QualType T) const { 2105 // Unique pointers, to guarantee there is only one pointer of a particular 2106 // structure. 2107 llvm::FoldingSetNodeID ID; 2108 PointerType::Profile(ID, T); 2109 2110 void *InsertPos = 0; 2111 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 2112 return QualType(PT, 0); 2113 2114 // If the pointee type isn't canonical, this won't be a canonical type either, 2115 // so fill in the canonical type field. 2116 QualType Canonical; 2117 if (!T.isCanonical()) { 2118 Canonical = getPointerType(getCanonicalType(T)); 2119 2120 // Get the new insert position for the node we care about. 2121 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos); 2122 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2123 } 2124 PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical); 2125 Types.push_back(New); 2126 PointerTypes.InsertNode(New, InsertPos); 2127 return QualType(New, 0); 2128} 2129 2130/// getBlockPointerType - Return the uniqued reference to the type for 2131/// a pointer to the specified block. 2132QualType ASTContext::getBlockPointerType(QualType T) const { 2133 assert(T->isFunctionType() && "block of function types only"); 2134 // Unique pointers, to guarantee there is only one block of a particular 2135 // structure. 2136 llvm::FoldingSetNodeID ID; 2137 BlockPointerType::Profile(ID, T); 2138 2139 void *InsertPos = 0; 2140 if (BlockPointerType *PT = 2141 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 2142 return QualType(PT, 0); 2143 2144 // If the block pointee type isn't canonical, this won't be a canonical 2145 // type either so fill in the canonical type field. 2146 QualType Canonical; 2147 if (!T.isCanonical()) { 2148 Canonical = getBlockPointerType(getCanonicalType(T)); 2149 2150 // Get the new insert position for the node we care about. 2151 BlockPointerType *NewIP = 2152 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 2153 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2154 } 2155 BlockPointerType *New 2156 = new (*this, TypeAlignment) BlockPointerType(T, Canonical); 2157 Types.push_back(New); 2158 BlockPointerTypes.InsertNode(New, InsertPos); 2159 return QualType(New, 0); 2160} 2161 2162/// getLValueReferenceType - Return the uniqued reference to the type for an 2163/// lvalue reference to the specified type. 2164QualType 2165ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const { 2166 assert(getCanonicalType(T) != OverloadTy && 2167 "Unresolved overloaded function type"); 2168 2169 // Unique pointers, to guarantee there is only one pointer of a particular 2170 // structure. 2171 llvm::FoldingSetNodeID ID; 2172 ReferenceType::Profile(ID, T, SpelledAsLValue); 2173 2174 void *InsertPos = 0; 2175 if (LValueReferenceType *RT = 2176 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 2177 return QualType(RT, 0); 2178 2179 const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 2180 2181 // If the referencee type isn't canonical, this won't be a canonical type 2182 // either, so fill in the canonical type field. 2183 QualType Canonical; 2184 if (!SpelledAsLValue || InnerRef || !T.isCanonical()) { 2185 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 2186 Canonical = getLValueReferenceType(getCanonicalType(PointeeType)); 2187 2188 // Get the new insert position for the node we care about. 2189 LValueReferenceType *NewIP = 2190 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 2191 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2192 } 2193 2194 LValueReferenceType *New 2195 = new (*this, TypeAlignment) LValueReferenceType(T, Canonical, 2196 SpelledAsLValue); 2197 Types.push_back(New); 2198 LValueReferenceTypes.InsertNode(New, InsertPos); 2199 2200 return QualType(New, 0); 2201} 2202 2203/// getRValueReferenceType - Return the uniqued reference to the type for an 2204/// rvalue reference to the specified type. 2205QualType ASTContext::getRValueReferenceType(QualType T) const { 2206 // Unique pointers, to guarantee there is only one pointer of a particular 2207 // structure. 2208 llvm::FoldingSetNodeID ID; 2209 ReferenceType::Profile(ID, T, false); 2210 2211 void *InsertPos = 0; 2212 if (RValueReferenceType *RT = 2213 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos)) 2214 return QualType(RT, 0); 2215 2216 const ReferenceType *InnerRef = T->getAs<ReferenceType>(); 2217 2218 // If the referencee type isn't canonical, this won't be a canonical type 2219 // either, so fill in the canonical type field. 2220 QualType Canonical; 2221 if (InnerRef || !T.isCanonical()) { 2222 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T); 2223 Canonical = getRValueReferenceType(getCanonicalType(PointeeType)); 2224 2225 // Get the new insert position for the node we care about. 2226 RValueReferenceType *NewIP = 2227 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos); 2228 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2229 } 2230 2231 RValueReferenceType *New 2232 = new (*this, TypeAlignment) RValueReferenceType(T, Canonical); 2233 Types.push_back(New); 2234 RValueReferenceTypes.InsertNode(New, InsertPos); 2235 return QualType(New, 0); 2236} 2237 2238/// getMemberPointerType - Return the uniqued reference to the type for a 2239/// member pointer to the specified type, in the specified class. 2240QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const { 2241 // Unique pointers, to guarantee there is only one pointer of a particular 2242 // structure. 2243 llvm::FoldingSetNodeID ID; 2244 MemberPointerType::Profile(ID, T, Cls); 2245 2246 void *InsertPos = 0; 2247 if (MemberPointerType *PT = 2248 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 2249 return QualType(PT, 0); 2250 2251 // If the pointee or class type isn't canonical, this won't be a canonical 2252 // type either, so fill in the canonical type field. 2253 QualType Canonical; 2254 if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) { 2255 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls)); 2256 2257 // Get the new insert position for the node we care about. 2258 MemberPointerType *NewIP = 2259 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 2260 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2261 } 2262 MemberPointerType *New 2263 = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical); 2264 Types.push_back(New); 2265 MemberPointerTypes.InsertNode(New, InsertPos); 2266 return QualType(New, 0); 2267} 2268 2269/// getConstantArrayType - Return the unique reference to the type for an 2270/// array of the specified element type. 2271QualType ASTContext::getConstantArrayType(QualType EltTy, 2272 const llvm::APInt &ArySizeIn, 2273 ArrayType::ArraySizeModifier ASM, 2274 unsigned IndexTypeQuals) const { 2275 assert((EltTy->isDependentType() || 2276 EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && 2277 "Constant array of VLAs is illegal!"); 2278 2279 // Convert the array size into a canonical width matching the pointer size for 2280 // the target. 2281 llvm::APInt ArySize(ArySizeIn); 2282 ArySize = 2283 ArySize.zextOrTrunc(Target->getPointerWidth(getTargetAddressSpace(EltTy))); 2284 2285 llvm::FoldingSetNodeID ID; 2286 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals); 2287 2288 void *InsertPos = 0; 2289 if (ConstantArrayType *ATP = 2290 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos)) 2291 return QualType(ATP, 0); 2292 2293 // If the element type isn't canonical or has qualifiers, this won't 2294 // be a canonical type either, so fill in the canonical type field. 2295 QualType Canon; 2296 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 2297 SplitQualType canonSplit = getCanonicalType(EltTy).split(); 2298 Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize, 2299 ASM, IndexTypeQuals); 2300 Canon = getQualifiedType(Canon, canonSplit.Quals); 2301 2302 // Get the new insert position for the node we care about. 2303 ConstantArrayType *NewIP = 2304 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos); 2305 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2306 } 2307 2308 ConstantArrayType *New = new(*this,TypeAlignment) 2309 ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals); 2310 ConstantArrayTypes.InsertNode(New, InsertPos); 2311 Types.push_back(New); 2312 return QualType(New, 0); 2313} 2314 2315/// getVariableArrayDecayedType - Turns the given type, which may be 2316/// variably-modified, into the corresponding type with all the known 2317/// sizes replaced with [*]. 2318QualType ASTContext::getVariableArrayDecayedType(QualType type) const { 2319 // Vastly most common case. 2320 if (!type->isVariablyModifiedType()) return type; 2321 2322 QualType result; 2323 2324 SplitQualType split = type.getSplitDesugaredType(); 2325 const Type *ty = split.Ty; 2326 switch (ty->getTypeClass()) { 2327#define TYPE(Class, Base) 2328#define ABSTRACT_TYPE(Class, Base) 2329#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 2330#include "clang/AST/TypeNodes.def" 2331 llvm_unreachable("didn't desugar past all non-canonical types?"); 2332 2333 // These types should never be variably-modified. 2334 case Type::Builtin: 2335 case Type::Complex: 2336 case Type::Vector: 2337 case Type::ExtVector: 2338 case Type::DependentSizedExtVector: 2339 case Type::ObjCObject: 2340 case Type::ObjCInterface: 2341 case Type::ObjCObjectPointer: 2342 case Type::Record: 2343 case Type::Enum: 2344 case Type::UnresolvedUsing: 2345 case Type::TypeOfExpr: 2346 case Type::TypeOf: 2347 case Type::Decltype: 2348 case Type::UnaryTransform: 2349 case Type::DependentName: 2350 case Type::InjectedClassName: 2351 case Type::TemplateSpecialization: 2352 case Type::DependentTemplateSpecialization: 2353 case Type::TemplateTypeParm: 2354 case Type::SubstTemplateTypeParmPack: 2355 case Type::Auto: 2356 case Type::PackExpansion: 2357 llvm_unreachable("type should never be variably-modified"); 2358 2359 // These types can be variably-modified but should never need to 2360 // further decay. 2361 case Type::FunctionNoProto: 2362 case Type::FunctionProto: 2363 case Type::BlockPointer: 2364 case Type::MemberPointer: 2365 return type; 2366 2367 // These types can be variably-modified. All these modifications 2368 // preserve structure except as noted by comments. 2369 // TODO: if we ever care about optimizing VLAs, there are no-op 2370 // optimizations available here. 2371 case Type::Pointer: 2372 result = getPointerType(getVariableArrayDecayedType( 2373 cast<PointerType>(ty)->getPointeeType())); 2374 break; 2375 2376 case Type::LValueReference: { 2377 const LValueReferenceType *lv = cast<LValueReferenceType>(ty); 2378 result = getLValueReferenceType( 2379 getVariableArrayDecayedType(lv->getPointeeType()), 2380 lv->isSpelledAsLValue()); 2381 break; 2382 } 2383 2384 case Type::RValueReference: { 2385 const RValueReferenceType *lv = cast<RValueReferenceType>(ty); 2386 result = getRValueReferenceType( 2387 getVariableArrayDecayedType(lv->getPointeeType())); 2388 break; 2389 } 2390 2391 case Type::Atomic: { 2392 const AtomicType *at = cast<AtomicType>(ty); 2393 result = getAtomicType(getVariableArrayDecayedType(at->getValueType())); 2394 break; 2395 } 2396 2397 case Type::ConstantArray: { 2398 const ConstantArrayType *cat = cast<ConstantArrayType>(ty); 2399 result = getConstantArrayType( 2400 getVariableArrayDecayedType(cat->getElementType()), 2401 cat->getSize(), 2402 cat->getSizeModifier(), 2403 cat->getIndexTypeCVRQualifiers()); 2404 break; 2405 } 2406 2407 case Type::DependentSizedArray: { 2408 const DependentSizedArrayType *dat = cast<DependentSizedArrayType>(ty); 2409 result = getDependentSizedArrayType( 2410 getVariableArrayDecayedType(dat->getElementType()), 2411 dat->getSizeExpr(), 2412 dat->getSizeModifier(), 2413 dat->getIndexTypeCVRQualifiers(), 2414 dat->getBracketsRange()); 2415 break; 2416 } 2417 2418 // Turn incomplete types into [*] types. 2419 case Type::IncompleteArray: { 2420 const IncompleteArrayType *iat = cast<IncompleteArrayType>(ty); 2421 result = getVariableArrayType( 2422 getVariableArrayDecayedType(iat->getElementType()), 2423 /*size*/ 0, 2424 ArrayType::Normal, 2425 iat->getIndexTypeCVRQualifiers(), 2426 SourceRange()); 2427 break; 2428 } 2429 2430 // Turn VLA types into [*] types. 2431 case Type::VariableArray: { 2432 const VariableArrayType *vat = cast<VariableArrayType>(ty); 2433 result = getVariableArrayType( 2434 getVariableArrayDecayedType(vat->getElementType()), 2435 /*size*/ 0, 2436 ArrayType::Star, 2437 vat->getIndexTypeCVRQualifiers(), 2438 vat->getBracketsRange()); 2439 break; 2440 } 2441 } 2442 2443 // Apply the top-level qualifiers from the original. 2444 return getQualifiedType(result, split.Quals); 2445} 2446 2447/// getVariableArrayType - Returns a non-unique reference to the type for a 2448/// variable array of the specified element type. 2449QualType ASTContext::getVariableArrayType(QualType EltTy, 2450 Expr *NumElts, 2451 ArrayType::ArraySizeModifier ASM, 2452 unsigned IndexTypeQuals, 2453 SourceRange Brackets) const { 2454 // Since we don't unique expressions, it isn't possible to unique VLA's 2455 // that have an expression provided for their size. 2456 QualType Canon; 2457 2458 // Be sure to pull qualifiers off the element type. 2459 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) { 2460 SplitQualType canonSplit = getCanonicalType(EltTy).split(); 2461 Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM, 2462 IndexTypeQuals, Brackets); 2463 Canon = getQualifiedType(Canon, canonSplit.Quals); 2464 } 2465 2466 VariableArrayType *New = new(*this, TypeAlignment) 2467 VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets); 2468 2469 VariableArrayTypes.push_back(New); 2470 Types.push_back(New); 2471 return QualType(New, 0); 2472} 2473 2474/// getDependentSizedArrayType - Returns a non-unique reference to 2475/// the type for a dependently-sized array of the specified element 2476/// type. 2477QualType ASTContext::getDependentSizedArrayType(QualType elementType, 2478 Expr *numElements, 2479 ArrayType::ArraySizeModifier ASM, 2480 unsigned elementTypeQuals, 2481 SourceRange brackets) const { 2482 assert((!numElements || numElements->isTypeDependent() || 2483 numElements->isValueDependent()) && 2484 "Size must be type- or value-dependent!"); 2485 2486 // Dependently-sized array types that do not have a specified number 2487 // of elements will have their sizes deduced from a dependent 2488 // initializer. We do no canonicalization here at all, which is okay 2489 // because they can't be used in most locations. 2490 if (!numElements) { 2491 DependentSizedArrayType *newType 2492 = new (*this, TypeAlignment) 2493 DependentSizedArrayType(*this, elementType, QualType(), 2494 numElements, ASM, elementTypeQuals, 2495 brackets); 2496 Types.push_back(newType); 2497 return QualType(newType, 0); 2498 } 2499 2500 // Otherwise, we actually build a new type every time, but we 2501 // also build a canonical type. 2502 2503 SplitQualType canonElementType = getCanonicalType(elementType).split(); 2504 2505 void *insertPos = 0; 2506 llvm::FoldingSetNodeID ID; 2507 DependentSizedArrayType::Profile(ID, *this, 2508 QualType(canonElementType.Ty, 0), 2509 ASM, elementTypeQuals, numElements); 2510 2511 // Look for an existing type with these properties. 2512 DependentSizedArrayType *canonTy = 2513 DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos); 2514 2515 // If we don't have one, build one. 2516 if (!canonTy) { 2517 canonTy = new (*this, TypeAlignment) 2518 DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0), 2519 QualType(), numElements, ASM, elementTypeQuals, 2520 brackets); 2521 DependentSizedArrayTypes.InsertNode(canonTy, insertPos); 2522 Types.push_back(canonTy); 2523 } 2524 2525 // Apply qualifiers from the element type to the array. 2526 QualType canon = getQualifiedType(QualType(canonTy,0), 2527 canonElementType.Quals); 2528 2529 // If we didn't need extra canonicalization for the element type, 2530 // then just use that as our result. 2531 if (QualType(canonElementType.Ty, 0) == elementType) 2532 return canon; 2533 2534 // Otherwise, we need to build a type which follows the spelling 2535 // of the element type. 2536 DependentSizedArrayType *sugaredType 2537 = new (*this, TypeAlignment) 2538 DependentSizedArrayType(*this, elementType, canon, numElements, 2539 ASM, elementTypeQuals, brackets); 2540 Types.push_back(sugaredType); 2541 return QualType(sugaredType, 0); 2542} 2543 2544QualType ASTContext::getIncompleteArrayType(QualType elementType, 2545 ArrayType::ArraySizeModifier ASM, 2546 unsigned elementTypeQuals) const { 2547 llvm::FoldingSetNodeID ID; 2548 IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals); 2549 2550 void *insertPos = 0; 2551 if (IncompleteArrayType *iat = 2552 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos)) 2553 return QualType(iat, 0); 2554 2555 // If the element type isn't canonical, this won't be a canonical type 2556 // either, so fill in the canonical type field. We also have to pull 2557 // qualifiers off the element type. 2558 QualType canon; 2559 2560 if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) { 2561 SplitQualType canonSplit = getCanonicalType(elementType).split(); 2562 canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0), 2563 ASM, elementTypeQuals); 2564 canon = getQualifiedType(canon, canonSplit.Quals); 2565 2566 // Get the new insert position for the node we care about. 2567 IncompleteArrayType *existing = 2568 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos); 2569 assert(!existing && "Shouldn't be in the map!"); (void) existing; 2570 } 2571 2572 IncompleteArrayType *newType = new (*this, TypeAlignment) 2573 IncompleteArrayType(elementType, canon, ASM, elementTypeQuals); 2574 2575 IncompleteArrayTypes.InsertNode(newType, insertPos); 2576 Types.push_back(newType); 2577 return QualType(newType, 0); 2578} 2579 2580/// getVectorType - Return the unique reference to a vector type of 2581/// the specified element type and size. VectorType must be a built-in type. 2582QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts, 2583 VectorType::VectorKind VecKind) const { 2584 assert(vecType->isBuiltinType()); 2585 2586 // Check if we've already instantiated a vector of this type. 2587 llvm::FoldingSetNodeID ID; 2588 VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind); 2589 2590 void *InsertPos = 0; 2591 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 2592 return QualType(VTP, 0); 2593 2594 // If the element type isn't canonical, this won't be a canonical type either, 2595 // so fill in the canonical type field. 2596 QualType Canonical; 2597 if (!vecType.isCanonical()) { 2598 Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind); 2599 2600 // Get the new insert position for the node we care about. 2601 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2602 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2603 } 2604 VectorType *New = new (*this, TypeAlignment) 2605 VectorType(vecType, NumElts, Canonical, VecKind); 2606 VectorTypes.InsertNode(New, InsertPos); 2607 Types.push_back(New); 2608 return QualType(New, 0); 2609} 2610 2611/// getExtVectorType - Return the unique reference to an extended vector type of 2612/// the specified element type and size. VectorType must be a built-in type. 2613QualType 2614ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const { 2615 assert(vecType->isBuiltinType() || vecType->isDependentType()); 2616 2617 // Check if we've already instantiated a vector of this type. 2618 llvm::FoldingSetNodeID ID; 2619 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector, 2620 VectorType::GenericVector); 2621 void *InsertPos = 0; 2622 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos)) 2623 return QualType(VTP, 0); 2624 2625 // If the element type isn't canonical, this won't be a canonical type either, 2626 // so fill in the canonical type field. 2627 QualType Canonical; 2628 if (!vecType.isCanonical()) { 2629 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts); 2630 2631 // Get the new insert position for the node we care about. 2632 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2633 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2634 } 2635 ExtVectorType *New = new (*this, TypeAlignment) 2636 ExtVectorType(vecType, NumElts, Canonical); 2637 VectorTypes.InsertNode(New, InsertPos); 2638 Types.push_back(New); 2639 return QualType(New, 0); 2640} 2641 2642QualType 2643ASTContext::getDependentSizedExtVectorType(QualType vecType, 2644 Expr *SizeExpr, 2645 SourceLocation AttrLoc) const { 2646 llvm::FoldingSetNodeID ID; 2647 DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType), 2648 SizeExpr); 2649 2650 void *InsertPos = 0; 2651 DependentSizedExtVectorType *Canon 2652 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2653 DependentSizedExtVectorType *New; 2654 if (Canon) { 2655 // We already have a canonical version of this array type; use it as 2656 // the canonical type for a newly-built type. 2657 New = new (*this, TypeAlignment) 2658 DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0), 2659 SizeExpr, AttrLoc); 2660 } else { 2661 QualType CanonVecTy = getCanonicalType(vecType); 2662 if (CanonVecTy == vecType) { 2663 New = new (*this, TypeAlignment) 2664 DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr, 2665 AttrLoc); 2666 2667 DependentSizedExtVectorType *CanonCheck 2668 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos); 2669 assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken"); 2670 (void)CanonCheck; 2671 DependentSizedExtVectorTypes.InsertNode(New, InsertPos); 2672 } else { 2673 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr, 2674 SourceLocation()); 2675 New = new (*this, TypeAlignment) 2676 DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc); 2677 } 2678 } 2679 2680 Types.push_back(New); 2681 return QualType(New, 0); 2682} 2683 2684/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'. 2685/// 2686QualType 2687ASTContext::getFunctionNoProtoType(QualType ResultTy, 2688 const FunctionType::ExtInfo &Info) const { 2689 const CallingConv DefaultCC = Info.getCC(); 2690 const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2691 CC_X86StdCall : DefaultCC; 2692 // Unique functions, to guarantee there is only one function of a particular 2693 // structure. 2694 llvm::FoldingSetNodeID ID; 2695 FunctionNoProtoType::Profile(ID, ResultTy, Info); 2696 2697 void *InsertPos = 0; 2698 if (FunctionNoProtoType *FT = 2699 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 2700 return QualType(FT, 0); 2701 2702 QualType Canonical; 2703 if (!ResultTy.isCanonical() || 2704 getCanonicalCallConv(CallConv) != CallConv) { 2705 Canonical = 2706 getFunctionNoProtoType(getCanonicalType(ResultTy), 2707 Info.withCallingConv(getCanonicalCallConv(CallConv))); 2708 2709 // Get the new insert position for the node we care about. 2710 FunctionNoProtoType *NewIP = 2711 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2712 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2713 } 2714 2715 FunctionProtoType::ExtInfo newInfo = Info.withCallingConv(CallConv); 2716 FunctionNoProtoType *New = new (*this, TypeAlignment) 2717 FunctionNoProtoType(ResultTy, Canonical, newInfo); 2718 Types.push_back(New); 2719 FunctionNoProtoTypes.InsertNode(New, InsertPos); 2720 return QualType(New, 0); 2721} 2722 2723/// \brief Determine whether \p T is canonical as the result type of a function. 2724static bool isCanonicalResultType(QualType T) { 2725 return T.isCanonical() && 2726 (T.getObjCLifetime() == Qualifiers::OCL_None || 2727 T.getObjCLifetime() == Qualifiers::OCL_ExplicitNone); 2728} 2729 2730/// getFunctionType - Return a normal function type with a typed argument 2731/// list. isVariadic indicates whether the argument list includes '...'. 2732QualType 2733ASTContext::getFunctionType(QualType ResultTy, ArrayRef<QualType> ArgArray, 2734 const FunctionProtoType::ExtProtoInfo &EPI) const { 2735 size_t NumArgs = ArgArray.size(); 2736 2737 // Unique functions, to guarantee there is only one function of a particular 2738 // structure. 2739 llvm::FoldingSetNodeID ID; 2740 FunctionProtoType::Profile(ID, ResultTy, ArgArray.begin(), NumArgs, EPI, 2741 *this); 2742 2743 void *InsertPos = 0; 2744 if (FunctionProtoType *FTP = 2745 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) 2746 return QualType(FTP, 0); 2747 2748 // Determine whether the type being created is already canonical or not. 2749 bool isCanonical = 2750 EPI.ExceptionSpecType == EST_None && isCanonicalResultType(ResultTy) && 2751 !EPI.HasTrailingReturn; 2752 for (unsigned i = 0; i != NumArgs && isCanonical; ++i) 2753 if (!ArgArray[i].isCanonicalAsParam()) 2754 isCanonical = false; 2755 2756 const CallingConv DefaultCC = EPI.ExtInfo.getCC(); 2757 const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ? 2758 CC_X86StdCall : DefaultCC; 2759 2760 // If this type isn't canonical, get the canonical version of it. 2761 // The exception spec is not part of the canonical type. 2762 QualType Canonical; 2763 if (!isCanonical || getCanonicalCallConv(CallConv) != CallConv) { 2764 SmallVector<QualType, 16> CanonicalArgs; 2765 CanonicalArgs.reserve(NumArgs); 2766 for (unsigned i = 0; i != NumArgs; ++i) 2767 CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i])); 2768 2769 FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI; 2770 CanonicalEPI.HasTrailingReturn = false; 2771 CanonicalEPI.ExceptionSpecType = EST_None; 2772 CanonicalEPI.NumExceptions = 0; 2773 CanonicalEPI.ExtInfo 2774 = CanonicalEPI.ExtInfo.withCallingConv(getCanonicalCallConv(CallConv)); 2775 2776 // Result types do not have ARC lifetime qualifiers. 2777 QualType CanResultTy = getCanonicalType(ResultTy); 2778 if (ResultTy.getQualifiers().hasObjCLifetime()) { 2779 Qualifiers Qs = CanResultTy.getQualifiers(); 2780 Qs.removeObjCLifetime(); 2781 CanResultTy = getQualifiedType(CanResultTy.getUnqualifiedType(), Qs); 2782 } 2783 2784 Canonical = getFunctionType(CanResultTy, CanonicalArgs, CanonicalEPI); 2785 2786 // Get the new insert position for the node we care about. 2787 FunctionProtoType *NewIP = 2788 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos); 2789 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 2790 } 2791 2792 // FunctionProtoType objects are allocated with extra bytes after 2793 // them for three variable size arrays at the end: 2794 // - parameter types 2795 // - exception types 2796 // - consumed-arguments flags 2797 // Instead of the exception types, there could be a noexcept 2798 // expression, or information used to resolve the exception 2799 // specification. 2800 size_t Size = sizeof(FunctionProtoType) + 2801 NumArgs * sizeof(QualType); 2802 if (EPI.ExceptionSpecType == EST_Dynamic) { 2803 Size += EPI.NumExceptions * sizeof(QualType); 2804 } else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) { 2805 Size += sizeof(Expr*); 2806 } else if (EPI.ExceptionSpecType == EST_Uninstantiated) { 2807 Size += 2 * sizeof(FunctionDecl*); 2808 } else if (EPI.ExceptionSpecType == EST_Unevaluated) { 2809 Size += sizeof(FunctionDecl*); 2810 } 2811 if (EPI.ConsumedArguments) 2812 Size += NumArgs * sizeof(bool); 2813 2814 FunctionProtoType *FTP = (FunctionProtoType*) Allocate(Size, TypeAlignment); 2815 FunctionProtoType::ExtProtoInfo newEPI = EPI; 2816 newEPI.ExtInfo = EPI.ExtInfo.withCallingConv(CallConv); 2817 new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI); 2818 Types.push_back(FTP); 2819 FunctionProtoTypes.InsertNode(FTP, InsertPos); 2820 return QualType(FTP, 0); 2821} 2822 2823#ifndef NDEBUG 2824static bool NeedsInjectedClassNameType(const RecordDecl *D) { 2825 if (!isa<CXXRecordDecl>(D)) return false; 2826 const CXXRecordDecl *RD = cast<CXXRecordDecl>(D); 2827 if (isa<ClassTemplatePartialSpecializationDecl>(RD)) 2828 return true; 2829 if (RD->getDescribedClassTemplate() && 2830 !isa<ClassTemplateSpecializationDecl>(RD)) 2831 return true; 2832 return false; 2833} 2834#endif 2835 2836/// getInjectedClassNameType - Return the unique reference to the 2837/// injected class name type for the specified templated declaration. 2838QualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl, 2839 QualType TST) const { 2840 assert(NeedsInjectedClassNameType(Decl)); 2841 if (Decl->TypeForDecl) { 2842 assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 2843 } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) { 2844 assert(PrevDecl->TypeForDecl && "previous declaration has no type"); 2845 Decl->TypeForDecl = PrevDecl->TypeForDecl; 2846 assert(isa<InjectedClassNameType>(Decl->TypeForDecl)); 2847 } else { 2848 Type *newType = 2849 new (*this, TypeAlignment) InjectedClassNameType(Decl, TST); 2850 Decl->TypeForDecl = newType; 2851 Types.push_back(newType); 2852 } 2853 return QualType(Decl->TypeForDecl, 0); 2854} 2855 2856/// getTypeDeclType - Return the unique reference to the type for the 2857/// specified type declaration. 2858QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const { 2859 assert(Decl && "Passed null for Decl param"); 2860 assert(!Decl->TypeForDecl && "TypeForDecl present in slow case"); 2861 2862 if (const TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Decl)) 2863 return getTypedefType(Typedef); 2864 2865 assert(!isa<TemplateTypeParmDecl>(Decl) && 2866 "Template type parameter types are always available."); 2867 2868 if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) { 2869 assert(!Record->getPreviousDecl() && 2870 "struct/union has previous declaration"); 2871 assert(!NeedsInjectedClassNameType(Record)); 2872 return getRecordType(Record); 2873 } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) { 2874 assert(!Enum->getPreviousDecl() && 2875 "enum has previous declaration"); 2876 return getEnumType(Enum); 2877 } else if (const UnresolvedUsingTypenameDecl *Using = 2878 dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) { 2879 Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using); 2880 Decl->TypeForDecl = newType; 2881 Types.push_back(newType); 2882 } else 2883 llvm_unreachable("TypeDecl without a type?"); 2884 2885 return QualType(Decl->TypeForDecl, 0); 2886} 2887 2888/// getTypedefType - Return the unique reference to the type for the 2889/// specified typedef name decl. 2890QualType 2891ASTContext::getTypedefType(const TypedefNameDecl *Decl, 2892 QualType Canonical) const { 2893 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2894 2895 if (Canonical.isNull()) 2896 Canonical = getCanonicalType(Decl->getUnderlyingType()); 2897 TypedefType *newType = new(*this, TypeAlignment) 2898 TypedefType(Type::Typedef, Decl, Canonical); 2899 Decl->TypeForDecl = newType; 2900 Types.push_back(newType); 2901 return QualType(newType, 0); 2902} 2903 2904QualType ASTContext::getRecordType(const RecordDecl *Decl) const { 2905 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2906 2907 if (const RecordDecl *PrevDecl = Decl->getPreviousDecl()) 2908 if (PrevDecl->TypeForDecl) 2909 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2910 2911 RecordType *newType = new (*this, TypeAlignment) RecordType(Decl); 2912 Decl->TypeForDecl = newType; 2913 Types.push_back(newType); 2914 return QualType(newType, 0); 2915} 2916 2917QualType ASTContext::getEnumType(const EnumDecl *Decl) const { 2918 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0); 2919 2920 if (const EnumDecl *PrevDecl = Decl->getPreviousDecl()) 2921 if (PrevDecl->TypeForDecl) 2922 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0); 2923 2924 EnumType *newType = new (*this, TypeAlignment) EnumType(Decl); 2925 Decl->TypeForDecl = newType; 2926 Types.push_back(newType); 2927 return QualType(newType, 0); 2928} 2929 2930QualType ASTContext::getAttributedType(AttributedType::Kind attrKind, 2931 QualType modifiedType, 2932 QualType equivalentType) { 2933 llvm::FoldingSetNodeID id; 2934 AttributedType::Profile(id, attrKind, modifiedType, equivalentType); 2935 2936 void *insertPos = 0; 2937 AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos); 2938 if (type) return QualType(type, 0); 2939 2940 QualType canon = getCanonicalType(equivalentType); 2941 type = new (*this, TypeAlignment) 2942 AttributedType(canon, attrKind, modifiedType, equivalentType); 2943 2944 Types.push_back(type); 2945 AttributedTypes.InsertNode(type, insertPos); 2946 2947 return QualType(type, 0); 2948} 2949 2950 2951/// \brief Retrieve a substitution-result type. 2952QualType 2953ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm, 2954 QualType Replacement) const { 2955 assert(Replacement.isCanonical() 2956 && "replacement types must always be canonical"); 2957 2958 llvm::FoldingSetNodeID ID; 2959 SubstTemplateTypeParmType::Profile(ID, Parm, Replacement); 2960 void *InsertPos = 0; 2961 SubstTemplateTypeParmType *SubstParm 2962 = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 2963 2964 if (!SubstParm) { 2965 SubstParm = new (*this, TypeAlignment) 2966 SubstTemplateTypeParmType(Parm, Replacement); 2967 Types.push_back(SubstParm); 2968 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 2969 } 2970 2971 return QualType(SubstParm, 0); 2972} 2973 2974/// \brief Retrieve a 2975QualType ASTContext::getSubstTemplateTypeParmPackType( 2976 const TemplateTypeParmType *Parm, 2977 const TemplateArgument &ArgPack) { 2978#ifndef NDEBUG 2979 for (TemplateArgument::pack_iterator P = ArgPack.pack_begin(), 2980 PEnd = ArgPack.pack_end(); 2981 P != PEnd; ++P) { 2982 assert(P->getKind() == TemplateArgument::Type &&"Pack contains a non-type"); 2983 assert(P->getAsType().isCanonical() && "Pack contains non-canonical type"); 2984 } 2985#endif 2986 2987 llvm::FoldingSetNodeID ID; 2988 SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack); 2989 void *InsertPos = 0; 2990 if (SubstTemplateTypeParmPackType *SubstParm 2991 = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos)) 2992 return QualType(SubstParm, 0); 2993 2994 QualType Canon; 2995 if (!Parm->isCanonicalUnqualified()) { 2996 Canon = getCanonicalType(QualType(Parm, 0)); 2997 Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon), 2998 ArgPack); 2999 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos); 3000 } 3001 3002 SubstTemplateTypeParmPackType *SubstParm 3003 = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon, 3004 ArgPack); 3005 Types.push_back(SubstParm); 3006 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos); 3007 return QualType(SubstParm, 0); 3008} 3009 3010/// \brief Retrieve the template type parameter type for a template 3011/// parameter or parameter pack with the given depth, index, and (optionally) 3012/// name. 3013QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index, 3014 bool ParameterPack, 3015 TemplateTypeParmDecl *TTPDecl) const { 3016 llvm::FoldingSetNodeID ID; 3017 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl); 3018 void *InsertPos = 0; 3019 TemplateTypeParmType *TypeParm 3020 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 3021 3022 if (TypeParm) 3023 return QualType(TypeParm, 0); 3024 3025 if (TTPDecl) { 3026 QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack); 3027 TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon); 3028 3029 TemplateTypeParmType *TypeCheck 3030 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos); 3031 assert(!TypeCheck && "Template type parameter canonical type broken"); 3032 (void)TypeCheck; 3033 } else 3034 TypeParm = new (*this, TypeAlignment) 3035 TemplateTypeParmType(Depth, Index, ParameterPack); 3036 3037 Types.push_back(TypeParm); 3038 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos); 3039 3040 return QualType(TypeParm, 0); 3041} 3042 3043TypeSourceInfo * 3044ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name, 3045 SourceLocation NameLoc, 3046 const TemplateArgumentListInfo &Args, 3047 QualType Underlying) const { 3048 assert(!Name.getAsDependentTemplateName() && 3049 "No dependent template names here!"); 3050 QualType TST = getTemplateSpecializationType(Name, Args, Underlying); 3051 3052 TypeSourceInfo *DI = CreateTypeSourceInfo(TST); 3053 TemplateSpecializationTypeLoc TL = 3054 DI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>(); 3055 TL.setTemplateKeywordLoc(SourceLocation()); 3056 TL.setTemplateNameLoc(NameLoc); 3057 TL.setLAngleLoc(Args.getLAngleLoc()); 3058 TL.setRAngleLoc(Args.getRAngleLoc()); 3059 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3060 TL.setArgLocInfo(i, Args[i].getLocInfo()); 3061 return DI; 3062} 3063 3064QualType 3065ASTContext::getTemplateSpecializationType(TemplateName Template, 3066 const TemplateArgumentListInfo &Args, 3067 QualType Underlying) const { 3068 assert(!Template.getAsDependentTemplateName() && 3069 "No dependent template names here!"); 3070 3071 unsigned NumArgs = Args.size(); 3072 3073 SmallVector<TemplateArgument, 4> ArgVec; 3074 ArgVec.reserve(NumArgs); 3075 for (unsigned i = 0; i != NumArgs; ++i) 3076 ArgVec.push_back(Args[i].getArgument()); 3077 3078 return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs, 3079 Underlying); 3080} 3081 3082#ifndef NDEBUG 3083static bool hasAnyPackExpansions(const TemplateArgument *Args, 3084 unsigned NumArgs) { 3085 for (unsigned I = 0; I != NumArgs; ++I) 3086 if (Args[I].isPackExpansion()) 3087 return true; 3088 3089 return true; 3090} 3091#endif 3092 3093QualType 3094ASTContext::getTemplateSpecializationType(TemplateName Template, 3095 const TemplateArgument *Args, 3096 unsigned NumArgs, 3097 QualType Underlying) const { 3098 assert(!Template.getAsDependentTemplateName() && 3099 "No dependent template names here!"); 3100 // Look through qualified template names. 3101 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 3102 Template = TemplateName(QTN->getTemplateDecl()); 3103 3104 bool IsTypeAlias = 3105 Template.getAsTemplateDecl() && 3106 isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl()); 3107 QualType CanonType; 3108 if (!Underlying.isNull()) 3109 CanonType = getCanonicalType(Underlying); 3110 else { 3111 // We can get here with an alias template when the specialization contains 3112 // a pack expansion that does not match up with a parameter pack. 3113 assert((!IsTypeAlias || hasAnyPackExpansions(Args, NumArgs)) && 3114 "Caller must compute aliased type"); 3115 IsTypeAlias = false; 3116 CanonType = getCanonicalTemplateSpecializationType(Template, Args, 3117 NumArgs); 3118 } 3119 3120 // Allocate the (non-canonical) template specialization type, but don't 3121 // try to unique it: these types typically have location information that 3122 // we don't unique and don't want to lose. 3123 void *Mem = Allocate(sizeof(TemplateSpecializationType) + 3124 sizeof(TemplateArgument) * NumArgs + 3125 (IsTypeAlias? sizeof(QualType) : 0), 3126 TypeAlignment); 3127 TemplateSpecializationType *Spec 3128 = new (Mem) TemplateSpecializationType(Template, Args, NumArgs, CanonType, 3129 IsTypeAlias ? Underlying : QualType()); 3130 3131 Types.push_back(Spec); 3132 return QualType(Spec, 0); 3133} 3134 3135QualType 3136ASTContext::getCanonicalTemplateSpecializationType(TemplateName Template, 3137 const TemplateArgument *Args, 3138 unsigned NumArgs) const { 3139 assert(!Template.getAsDependentTemplateName() && 3140 "No dependent template names here!"); 3141 3142 // Look through qualified template names. 3143 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName()) 3144 Template = TemplateName(QTN->getTemplateDecl()); 3145 3146 // Build the canonical template specialization type. 3147 TemplateName CanonTemplate = getCanonicalTemplateName(Template); 3148 SmallVector<TemplateArgument, 4> CanonArgs; 3149 CanonArgs.reserve(NumArgs); 3150 for (unsigned I = 0; I != NumArgs; ++I) 3151 CanonArgs.push_back(getCanonicalTemplateArgument(Args[I])); 3152 3153 // Determine whether this canonical template specialization type already 3154 // exists. 3155 llvm::FoldingSetNodeID ID; 3156 TemplateSpecializationType::Profile(ID, CanonTemplate, 3157 CanonArgs.data(), NumArgs, *this); 3158 3159 void *InsertPos = 0; 3160 TemplateSpecializationType *Spec 3161 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 3162 3163 if (!Spec) { 3164 // Allocate a new canonical template specialization type. 3165 void *Mem = Allocate((sizeof(TemplateSpecializationType) + 3166 sizeof(TemplateArgument) * NumArgs), 3167 TypeAlignment); 3168 Spec = new (Mem) TemplateSpecializationType(CanonTemplate, 3169 CanonArgs.data(), NumArgs, 3170 QualType(), QualType()); 3171 Types.push_back(Spec); 3172 TemplateSpecializationTypes.InsertNode(Spec, InsertPos); 3173 } 3174 3175 assert(Spec->isDependentType() && 3176 "Non-dependent template-id type must have a canonical type"); 3177 return QualType(Spec, 0); 3178} 3179 3180QualType 3181ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword, 3182 NestedNameSpecifier *NNS, 3183 QualType NamedType) const { 3184 llvm::FoldingSetNodeID ID; 3185 ElaboratedType::Profile(ID, Keyword, NNS, NamedType); 3186 3187 void *InsertPos = 0; 3188 ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 3189 if (T) 3190 return QualType(T, 0); 3191 3192 QualType Canon = NamedType; 3193 if (!Canon.isCanonical()) { 3194 Canon = getCanonicalType(NamedType); 3195 ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos); 3196 assert(!CheckT && "Elaborated canonical type broken"); 3197 (void)CheckT; 3198 } 3199 3200 T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon); 3201 Types.push_back(T); 3202 ElaboratedTypes.InsertNode(T, InsertPos); 3203 return QualType(T, 0); 3204} 3205 3206QualType 3207ASTContext::getParenType(QualType InnerType) const { 3208 llvm::FoldingSetNodeID ID; 3209 ParenType::Profile(ID, InnerType); 3210 3211 void *InsertPos = 0; 3212 ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 3213 if (T) 3214 return QualType(T, 0); 3215 3216 QualType Canon = InnerType; 3217 if (!Canon.isCanonical()) { 3218 Canon = getCanonicalType(InnerType); 3219 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos); 3220 assert(!CheckT && "Paren canonical type broken"); 3221 (void)CheckT; 3222 } 3223 3224 T = new (*this) ParenType(InnerType, Canon); 3225 Types.push_back(T); 3226 ParenTypes.InsertNode(T, InsertPos); 3227 return QualType(T, 0); 3228} 3229 3230QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword, 3231 NestedNameSpecifier *NNS, 3232 const IdentifierInfo *Name, 3233 QualType Canon) const { 3234 assert(NNS->isDependent() && "nested-name-specifier must be dependent"); 3235 3236 if (Canon.isNull()) { 3237 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 3238 ElaboratedTypeKeyword CanonKeyword = Keyword; 3239 if (Keyword == ETK_None) 3240 CanonKeyword = ETK_Typename; 3241 3242 if (CanonNNS != NNS || CanonKeyword != Keyword) 3243 Canon = getDependentNameType(CanonKeyword, CanonNNS, Name); 3244 } 3245 3246 llvm::FoldingSetNodeID ID; 3247 DependentNameType::Profile(ID, Keyword, NNS, Name); 3248 3249 void *InsertPos = 0; 3250 DependentNameType *T 3251 = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos); 3252 if (T) 3253 return QualType(T, 0); 3254 3255 T = new (*this) DependentNameType(Keyword, NNS, Name, Canon); 3256 Types.push_back(T); 3257 DependentNameTypes.InsertNode(T, InsertPos); 3258 return QualType(T, 0); 3259} 3260 3261QualType 3262ASTContext::getDependentTemplateSpecializationType( 3263 ElaboratedTypeKeyword Keyword, 3264 NestedNameSpecifier *NNS, 3265 const IdentifierInfo *Name, 3266 const TemplateArgumentListInfo &Args) const { 3267 // TODO: avoid this copy 3268 SmallVector<TemplateArgument, 16> ArgCopy; 3269 for (unsigned I = 0, E = Args.size(); I != E; ++I) 3270 ArgCopy.push_back(Args[I].getArgument()); 3271 return getDependentTemplateSpecializationType(Keyword, NNS, Name, 3272 ArgCopy.size(), 3273 ArgCopy.data()); 3274} 3275 3276QualType 3277ASTContext::getDependentTemplateSpecializationType( 3278 ElaboratedTypeKeyword Keyword, 3279 NestedNameSpecifier *NNS, 3280 const IdentifierInfo *Name, 3281 unsigned NumArgs, 3282 const TemplateArgument *Args) const { 3283 assert((!NNS || NNS->isDependent()) && 3284 "nested-name-specifier must be dependent"); 3285 3286 llvm::FoldingSetNodeID ID; 3287 DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS, 3288 Name, NumArgs, Args); 3289 3290 void *InsertPos = 0; 3291 DependentTemplateSpecializationType *T 3292 = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 3293 if (T) 3294 return QualType(T, 0); 3295 3296 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 3297 3298 ElaboratedTypeKeyword CanonKeyword = Keyword; 3299 if (Keyword == ETK_None) CanonKeyword = ETK_Typename; 3300 3301 bool AnyNonCanonArgs = false; 3302 SmallVector<TemplateArgument, 16> CanonArgs(NumArgs); 3303 for (unsigned I = 0; I != NumArgs; ++I) { 3304 CanonArgs[I] = getCanonicalTemplateArgument(Args[I]); 3305 if (!CanonArgs[I].structurallyEquals(Args[I])) 3306 AnyNonCanonArgs = true; 3307 } 3308 3309 QualType Canon; 3310 if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) { 3311 Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS, 3312 Name, NumArgs, 3313 CanonArgs.data()); 3314 3315 // Find the insert position again. 3316 DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos); 3317 } 3318 3319 void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) + 3320 sizeof(TemplateArgument) * NumArgs), 3321 TypeAlignment); 3322 T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS, 3323 Name, NumArgs, Args, Canon); 3324 Types.push_back(T); 3325 DependentTemplateSpecializationTypes.InsertNode(T, InsertPos); 3326 return QualType(T, 0); 3327} 3328 3329QualType ASTContext::getPackExpansionType(QualType Pattern, 3330 Optional<unsigned> NumExpansions) { 3331 llvm::FoldingSetNodeID ID; 3332 PackExpansionType::Profile(ID, Pattern, NumExpansions); 3333 3334 assert(Pattern->containsUnexpandedParameterPack() && 3335 "Pack expansions must expand one or more parameter packs"); 3336 void *InsertPos = 0; 3337 PackExpansionType *T 3338 = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 3339 if (T) 3340 return QualType(T, 0); 3341 3342 QualType Canon; 3343 if (!Pattern.isCanonical()) { 3344 Canon = getCanonicalType(Pattern); 3345 // The canonical type might not contain an unexpanded parameter pack, if it 3346 // contains an alias template specialization which ignores one of its 3347 // parameters. 3348 if (Canon->containsUnexpandedParameterPack()) { 3349 Canon = getPackExpansionType(getCanonicalType(Pattern), NumExpansions); 3350 3351 // Find the insert position again, in case we inserted an element into 3352 // PackExpansionTypes and invalidated our insert position. 3353 PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos); 3354 } 3355 } 3356 3357 T = new (*this) PackExpansionType(Pattern, Canon, NumExpansions); 3358 Types.push_back(T); 3359 PackExpansionTypes.InsertNode(T, InsertPos); 3360 return QualType(T, 0); 3361} 3362 3363/// CmpProtocolNames - Comparison predicate for sorting protocols 3364/// alphabetically. 3365static bool CmpProtocolNames(const ObjCProtocolDecl *LHS, 3366 const ObjCProtocolDecl *RHS) { 3367 return LHS->getDeclName() < RHS->getDeclName(); 3368} 3369 3370static bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols, 3371 unsigned NumProtocols) { 3372 if (NumProtocols == 0) return true; 3373 3374 if (Protocols[0]->getCanonicalDecl() != Protocols[0]) 3375 return false; 3376 3377 for (unsigned i = 1; i != NumProtocols; ++i) 3378 if (!CmpProtocolNames(Protocols[i-1], Protocols[i]) || 3379 Protocols[i]->getCanonicalDecl() != Protocols[i]) 3380 return false; 3381 return true; 3382} 3383 3384static void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols, 3385 unsigned &NumProtocols) { 3386 ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols; 3387 3388 // Sort protocols, keyed by name. 3389 std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames); 3390 3391 // Canonicalize. 3392 for (unsigned I = 0, N = NumProtocols; I != N; ++I) 3393 Protocols[I] = Protocols[I]->getCanonicalDecl(); 3394 3395 // Remove duplicates. 3396 ProtocolsEnd = std::unique(Protocols, ProtocolsEnd); 3397 NumProtocols = ProtocolsEnd-Protocols; 3398} 3399 3400QualType ASTContext::getObjCObjectType(QualType BaseType, 3401 ObjCProtocolDecl * const *Protocols, 3402 unsigned NumProtocols) const { 3403 // If the base type is an interface and there aren't any protocols 3404 // to add, then the interface type will do just fine. 3405 if (!NumProtocols && isa<ObjCInterfaceType>(BaseType)) 3406 return BaseType; 3407 3408 // Look in the folding set for an existing type. 3409 llvm::FoldingSetNodeID ID; 3410 ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols); 3411 void *InsertPos = 0; 3412 if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos)) 3413 return QualType(QT, 0); 3414 3415 // Build the canonical type, which has the canonical base type and 3416 // a sorted-and-uniqued list of protocols. 3417 QualType Canonical; 3418 bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols); 3419 if (!ProtocolsSorted || !BaseType.isCanonical()) { 3420 if (!ProtocolsSorted) { 3421 SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols, 3422 Protocols + NumProtocols); 3423 unsigned UniqueCount = NumProtocols; 3424 3425 SortAndUniqueProtocols(&Sorted[0], UniqueCount); 3426 Canonical = getObjCObjectType(getCanonicalType(BaseType), 3427 &Sorted[0], UniqueCount); 3428 } else { 3429 Canonical = getObjCObjectType(getCanonicalType(BaseType), 3430 Protocols, NumProtocols); 3431 } 3432 3433 // Regenerate InsertPos. 3434 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos); 3435 } 3436 3437 unsigned Size = sizeof(ObjCObjectTypeImpl); 3438 Size += NumProtocols * sizeof(ObjCProtocolDecl *); 3439 void *Mem = Allocate(Size, TypeAlignment); 3440 ObjCObjectTypeImpl *T = 3441 new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols); 3442 3443 Types.push_back(T); 3444 ObjCObjectTypes.InsertNode(T, InsertPos); 3445 return QualType(T, 0); 3446} 3447 3448/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for 3449/// the given object type. 3450QualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const { 3451 llvm::FoldingSetNodeID ID; 3452 ObjCObjectPointerType::Profile(ID, ObjectT); 3453 3454 void *InsertPos = 0; 3455 if (ObjCObjectPointerType *QT = 3456 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos)) 3457 return QualType(QT, 0); 3458 3459 // Find the canonical object type. 3460 QualType Canonical; 3461 if (!ObjectT.isCanonical()) { 3462 Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT)); 3463 3464 // Regenerate InsertPos. 3465 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos); 3466 } 3467 3468 // No match. 3469 void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment); 3470 ObjCObjectPointerType *QType = 3471 new (Mem) ObjCObjectPointerType(Canonical, ObjectT); 3472 3473 Types.push_back(QType); 3474 ObjCObjectPointerTypes.InsertNode(QType, InsertPos); 3475 return QualType(QType, 0); 3476} 3477 3478/// getObjCInterfaceType - Return the unique reference to the type for the 3479/// specified ObjC interface decl. The list of protocols is optional. 3480QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl, 3481 ObjCInterfaceDecl *PrevDecl) const { 3482 if (Decl->TypeForDecl) 3483 return QualType(Decl->TypeForDecl, 0); 3484 3485 if (PrevDecl) { 3486 assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"); 3487 Decl->TypeForDecl = PrevDecl->TypeForDecl; 3488 return QualType(PrevDecl->TypeForDecl, 0); 3489 } 3490 3491 // Prefer the definition, if there is one. 3492 if (const ObjCInterfaceDecl *Def = Decl->getDefinition()) 3493 Decl = Def; 3494 3495 void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment); 3496 ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl); 3497 Decl->TypeForDecl = T; 3498 Types.push_back(T); 3499 return QualType(T, 0); 3500} 3501 3502/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique 3503/// TypeOfExprType AST's (since expression's are never shared). For example, 3504/// multiple declarations that refer to "typeof(x)" all contain different 3505/// DeclRefExpr's. This doesn't effect the type checker, since it operates 3506/// on canonical type's (which are always unique). 3507QualType ASTContext::getTypeOfExprType(Expr *tofExpr) const { 3508 TypeOfExprType *toe; 3509 if (tofExpr->isTypeDependent()) { 3510 llvm::FoldingSetNodeID ID; 3511 DependentTypeOfExprType::Profile(ID, *this, tofExpr); 3512 3513 void *InsertPos = 0; 3514 DependentTypeOfExprType *Canon 3515 = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos); 3516 if (Canon) { 3517 // We already have a "canonical" version of an identical, dependent 3518 // typeof(expr) type. Use that as our canonical type. 3519 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, 3520 QualType((TypeOfExprType*)Canon, 0)); 3521 } else { 3522 // Build a new, canonical typeof(expr) type. 3523 Canon 3524 = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr); 3525 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos); 3526 toe = Canon; 3527 } 3528 } else { 3529 QualType Canonical = getCanonicalType(tofExpr->getType()); 3530 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical); 3531 } 3532 Types.push_back(toe); 3533 return QualType(toe, 0); 3534} 3535 3536/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique 3537/// TypeOfType AST's. The only motivation to unique these nodes would be 3538/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be 3539/// an issue. This doesn't effect the type checker, since it operates 3540/// on canonical type's (which are always unique). 3541QualType ASTContext::getTypeOfType(QualType tofType) const { 3542 QualType Canonical = getCanonicalType(tofType); 3543 TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical); 3544 Types.push_back(tot); 3545 return QualType(tot, 0); 3546} 3547 3548 3549/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique 3550/// DecltypeType AST's. The only motivation to unique these nodes would be 3551/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be 3552/// an issue. This doesn't effect the type checker, since it operates 3553/// on canonical types (which are always unique). 3554QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const { 3555 DecltypeType *dt; 3556 3557 // C++0x [temp.type]p2: 3558 // If an expression e involves a template parameter, decltype(e) denotes a 3559 // unique dependent type. Two such decltype-specifiers refer to the same 3560 // type only if their expressions are equivalent (14.5.6.1). 3561 if (e->isInstantiationDependent()) { 3562 llvm::FoldingSetNodeID ID; 3563 DependentDecltypeType::Profile(ID, *this, e); 3564 3565 void *InsertPos = 0; 3566 DependentDecltypeType *Canon 3567 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos); 3568 if (Canon) { 3569 // We already have a "canonical" version of an equivalent, dependent 3570 // decltype type. Use that as our canonical type. 3571 dt = new (*this, TypeAlignment) DecltypeType(e, UnderlyingType, 3572 QualType((DecltypeType*)Canon, 0)); 3573 } else { 3574 // Build a new, canonical typeof(expr) type. 3575 Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e); 3576 DependentDecltypeTypes.InsertNode(Canon, InsertPos); 3577 dt = Canon; 3578 } 3579 } else { 3580 dt = new (*this, TypeAlignment) DecltypeType(e, UnderlyingType, 3581 getCanonicalType(UnderlyingType)); 3582 } 3583 Types.push_back(dt); 3584 return QualType(dt, 0); 3585} 3586 3587/// getUnaryTransformationType - We don't unique these, since the memory 3588/// savings are minimal and these are rare. 3589QualType ASTContext::getUnaryTransformType(QualType BaseType, 3590 QualType UnderlyingType, 3591 UnaryTransformType::UTTKind Kind) 3592 const { 3593 UnaryTransformType *Ty = 3594 new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType, 3595 Kind, 3596 UnderlyingType->isDependentType() ? 3597 QualType() : getCanonicalType(UnderlyingType)); 3598 Types.push_back(Ty); 3599 return QualType(Ty, 0); 3600} 3601 3602/// getAutoType - Return the uniqued reference to the 'auto' type which has been 3603/// deduced to the given type, or to the canonical undeduced 'auto' type, or the 3604/// canonical deduced-but-dependent 'auto' type. 3605QualType ASTContext::getAutoType(QualType DeducedType, bool IsDecltypeAuto, 3606 bool IsDependent) const { 3607 if (DeducedType.isNull() && !IsDecltypeAuto && !IsDependent) 3608 return getAutoDeductType(); 3609 3610 // Look in the folding set for an existing type. 3611 void *InsertPos = 0; 3612 llvm::FoldingSetNodeID ID; 3613 AutoType::Profile(ID, DeducedType, IsDecltypeAuto, IsDependent); 3614 if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos)) 3615 return QualType(AT, 0); 3616 3617 AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType, 3618 IsDecltypeAuto, 3619 IsDependent); 3620 Types.push_back(AT); 3621 if (InsertPos) 3622 AutoTypes.InsertNode(AT, InsertPos); 3623 return QualType(AT, 0); 3624} 3625 3626/// getAtomicType - Return the uniqued reference to the atomic type for 3627/// the given value type. 3628QualType ASTContext::getAtomicType(QualType T) const { 3629 // Unique pointers, to guarantee there is only one pointer of a particular 3630 // structure. 3631 llvm::FoldingSetNodeID ID; 3632 AtomicType::Profile(ID, T); 3633 3634 void *InsertPos = 0; 3635 if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos)) 3636 return QualType(AT, 0); 3637 3638 // If the atomic value type isn't canonical, this won't be a canonical type 3639 // either, so fill in the canonical type field. 3640 QualType Canonical; 3641 if (!T.isCanonical()) { 3642 Canonical = getAtomicType(getCanonicalType(T)); 3643 3644 // Get the new insert position for the node we care about. 3645 AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos); 3646 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP; 3647 } 3648 AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical); 3649 Types.push_back(New); 3650 AtomicTypes.InsertNode(New, InsertPos); 3651 return QualType(New, 0); 3652} 3653 3654/// getAutoDeductType - Get type pattern for deducing against 'auto'. 3655QualType ASTContext::getAutoDeductType() const { 3656 if (AutoDeductTy.isNull()) 3657 AutoDeductTy = QualType( 3658 new (*this, TypeAlignment) AutoType(QualType(), /*decltype(auto)*/false, 3659 /*dependent*/false), 3660 0); 3661 return AutoDeductTy; 3662} 3663 3664/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'. 3665QualType ASTContext::getAutoRRefDeductType() const { 3666 if (AutoRRefDeductTy.isNull()) 3667 AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType()); 3668 assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"); 3669 return AutoRRefDeductTy; 3670} 3671 3672/// getTagDeclType - Return the unique reference to the type for the 3673/// specified TagDecl (struct/union/class/enum) decl. 3674QualType ASTContext::getTagDeclType(const TagDecl *Decl) const { 3675 assert (Decl); 3676 // FIXME: What is the design on getTagDeclType when it requires casting 3677 // away const? mutable? 3678 return getTypeDeclType(const_cast<TagDecl*>(Decl)); 3679} 3680 3681/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result 3682/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and 3683/// needs to agree with the definition in <stddef.h>. 3684CanQualType ASTContext::getSizeType() const { 3685 return getFromTargetType(Target->getSizeType()); 3686} 3687 3688/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5). 3689CanQualType ASTContext::getIntMaxType() const { 3690 return getFromTargetType(Target->getIntMaxType()); 3691} 3692 3693/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5). 3694CanQualType ASTContext::getUIntMaxType() const { 3695 return getFromTargetType(Target->getUIntMaxType()); 3696} 3697 3698/// getSignedWCharType - Return the type of "signed wchar_t". 3699/// Used when in C++, as a GCC extension. 3700QualType ASTContext::getSignedWCharType() const { 3701 // FIXME: derive from "Target" ? 3702 return WCharTy; 3703} 3704 3705/// getUnsignedWCharType - Return the type of "unsigned wchar_t". 3706/// Used when in C++, as a GCC extension. 3707QualType ASTContext::getUnsignedWCharType() const { 3708 // FIXME: derive from "Target" ? 3709 return UnsignedIntTy; 3710} 3711 3712QualType ASTContext::getIntPtrType() const { 3713 return getFromTargetType(Target->getIntPtrType()); 3714} 3715 3716QualType ASTContext::getUIntPtrType() const { 3717 return getCorrespondingUnsignedType(getIntPtrType()); 3718} 3719 3720/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17) 3721/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9). 3722QualType ASTContext::getPointerDiffType() const { 3723 return getFromTargetType(Target->getPtrDiffType(0)); 3724} 3725 3726/// \brief Return the unique type for "pid_t" defined in 3727/// <sys/types.h>. We need this to compute the correct type for vfork(). 3728QualType ASTContext::getProcessIDType() const { 3729 return getFromTargetType(Target->getProcessIDType()); 3730} 3731 3732//===----------------------------------------------------------------------===// 3733// Type Operators 3734//===----------------------------------------------------------------------===// 3735 3736CanQualType ASTContext::getCanonicalParamType(QualType T) const { 3737 // Push qualifiers into arrays, and then discard any remaining 3738 // qualifiers. 3739 T = getCanonicalType(T); 3740 T = getVariableArrayDecayedType(T); 3741 const Type *Ty = T.getTypePtr(); 3742 QualType Result; 3743 if (isa<ArrayType>(Ty)) { 3744 Result = getArrayDecayedType(QualType(Ty,0)); 3745 } else if (isa<FunctionType>(Ty)) { 3746 Result = getPointerType(QualType(Ty, 0)); 3747 } else { 3748 Result = QualType(Ty, 0); 3749 } 3750 3751 return CanQualType::CreateUnsafe(Result); 3752} 3753 3754QualType ASTContext::getUnqualifiedArrayType(QualType type, 3755 Qualifiers &quals) { 3756 SplitQualType splitType = type.getSplitUnqualifiedType(); 3757 3758 // FIXME: getSplitUnqualifiedType() actually walks all the way to 3759 // the unqualified desugared type and then drops it on the floor. 3760 // We then have to strip that sugar back off with 3761 // getUnqualifiedDesugaredType(), which is silly. 3762 const ArrayType *AT = 3763 dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType()); 3764 3765 // If we don't have an array, just use the results in splitType. 3766 if (!AT) { 3767 quals = splitType.Quals; 3768 return QualType(splitType.Ty, 0); 3769 } 3770 3771 // Otherwise, recurse on the array's element type. 3772 QualType elementType = AT->getElementType(); 3773 QualType unqualElementType = getUnqualifiedArrayType(elementType, quals); 3774 3775 // If that didn't change the element type, AT has no qualifiers, so we 3776 // can just use the results in splitType. 3777 if (elementType == unqualElementType) { 3778 assert(quals.empty()); // from the recursive call 3779 quals = splitType.Quals; 3780 return QualType(splitType.Ty, 0); 3781 } 3782 3783 // Otherwise, add in the qualifiers from the outermost type, then 3784 // build the type back up. 3785 quals.addConsistentQualifiers(splitType.Quals); 3786 3787 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 3788 return getConstantArrayType(unqualElementType, CAT->getSize(), 3789 CAT->getSizeModifier(), 0); 3790 } 3791 3792 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 3793 return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0); 3794 } 3795 3796 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) { 3797 return getVariableArrayType(unqualElementType, 3798 VAT->getSizeExpr(), 3799 VAT->getSizeModifier(), 3800 VAT->getIndexTypeCVRQualifiers(), 3801 VAT->getBracketsRange()); 3802 } 3803 3804 const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT); 3805 return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(), 3806 DSAT->getSizeModifier(), 0, 3807 SourceRange()); 3808} 3809 3810/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that 3811/// may be similar (C++ 4.4), replaces T1 and T2 with the type that 3812/// they point to and return true. If T1 and T2 aren't pointer types 3813/// or pointer-to-member types, or if they are not similar at this 3814/// level, returns false and leaves T1 and T2 unchanged. Top-level 3815/// qualifiers on T1 and T2 are ignored. This function will typically 3816/// be called in a loop that successively "unwraps" pointer and 3817/// pointer-to-member types to compare them at each level. 3818bool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) { 3819 const PointerType *T1PtrType = T1->getAs<PointerType>(), 3820 *T2PtrType = T2->getAs<PointerType>(); 3821 if (T1PtrType && T2PtrType) { 3822 T1 = T1PtrType->getPointeeType(); 3823 T2 = T2PtrType->getPointeeType(); 3824 return true; 3825 } 3826 3827 const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), 3828 *T2MPType = T2->getAs<MemberPointerType>(); 3829 if (T1MPType && T2MPType && 3830 hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0), 3831 QualType(T2MPType->getClass(), 0))) { 3832 T1 = T1MPType->getPointeeType(); 3833 T2 = T2MPType->getPointeeType(); 3834 return true; 3835 } 3836 3837 if (getLangOpts().ObjC1) { 3838 const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(), 3839 *T2OPType = T2->getAs<ObjCObjectPointerType>(); 3840 if (T1OPType && T2OPType) { 3841 T1 = T1OPType->getPointeeType(); 3842 T2 = T2OPType->getPointeeType(); 3843 return true; 3844 } 3845 } 3846 3847 // FIXME: Block pointers, too? 3848 3849 return false; 3850} 3851 3852DeclarationNameInfo 3853ASTContext::getNameForTemplate(TemplateName Name, 3854 SourceLocation NameLoc) const { 3855 switch (Name.getKind()) { 3856 case TemplateName::QualifiedTemplate: 3857 case TemplateName::Template: 3858 // DNInfo work in progress: CHECKME: what about DNLoc? 3859 return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(), 3860 NameLoc); 3861 3862 case TemplateName::OverloadedTemplate: { 3863 OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate(); 3864 // DNInfo work in progress: CHECKME: what about DNLoc? 3865 return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc); 3866 } 3867 3868 case TemplateName::DependentTemplate: { 3869 DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 3870 DeclarationName DName; 3871 if (DTN->isIdentifier()) { 3872 DName = DeclarationNames.getIdentifier(DTN->getIdentifier()); 3873 return DeclarationNameInfo(DName, NameLoc); 3874 } else { 3875 DName = DeclarationNames.getCXXOperatorName(DTN->getOperator()); 3876 // DNInfo work in progress: FIXME: source locations? 3877 DeclarationNameLoc DNLoc; 3878 DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding(); 3879 DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding(); 3880 return DeclarationNameInfo(DName, NameLoc, DNLoc); 3881 } 3882 } 3883 3884 case TemplateName::SubstTemplateTemplateParm: { 3885 SubstTemplateTemplateParmStorage *subst 3886 = Name.getAsSubstTemplateTemplateParm(); 3887 return DeclarationNameInfo(subst->getParameter()->getDeclName(), 3888 NameLoc); 3889 } 3890 3891 case TemplateName::SubstTemplateTemplateParmPack: { 3892 SubstTemplateTemplateParmPackStorage *subst 3893 = Name.getAsSubstTemplateTemplateParmPack(); 3894 return DeclarationNameInfo(subst->getParameterPack()->getDeclName(), 3895 NameLoc); 3896 } 3897 } 3898 3899 llvm_unreachable("bad template name kind!"); 3900} 3901 3902TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const { 3903 switch (Name.getKind()) { 3904 case TemplateName::QualifiedTemplate: 3905 case TemplateName::Template: { 3906 TemplateDecl *Template = Name.getAsTemplateDecl(); 3907 if (TemplateTemplateParmDecl *TTP 3908 = dyn_cast<TemplateTemplateParmDecl>(Template)) 3909 Template = getCanonicalTemplateTemplateParmDecl(TTP); 3910 3911 // The canonical template name is the canonical template declaration. 3912 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl())); 3913 } 3914 3915 case TemplateName::OverloadedTemplate: 3916 llvm_unreachable("cannot canonicalize overloaded template"); 3917 3918 case TemplateName::DependentTemplate: { 3919 DependentTemplateName *DTN = Name.getAsDependentTemplateName(); 3920 assert(DTN && "Non-dependent template names must refer to template decls."); 3921 return DTN->CanonicalTemplateName; 3922 } 3923 3924 case TemplateName::SubstTemplateTemplateParm: { 3925 SubstTemplateTemplateParmStorage *subst 3926 = Name.getAsSubstTemplateTemplateParm(); 3927 return getCanonicalTemplateName(subst->getReplacement()); 3928 } 3929 3930 case TemplateName::SubstTemplateTemplateParmPack: { 3931 SubstTemplateTemplateParmPackStorage *subst 3932 = Name.getAsSubstTemplateTemplateParmPack(); 3933 TemplateTemplateParmDecl *canonParameter 3934 = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack()); 3935 TemplateArgument canonArgPack 3936 = getCanonicalTemplateArgument(subst->getArgumentPack()); 3937 return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack); 3938 } 3939 } 3940 3941 llvm_unreachable("bad template name!"); 3942} 3943 3944bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) { 3945 X = getCanonicalTemplateName(X); 3946 Y = getCanonicalTemplateName(Y); 3947 return X.getAsVoidPointer() == Y.getAsVoidPointer(); 3948} 3949 3950TemplateArgument 3951ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const { 3952 switch (Arg.getKind()) { 3953 case TemplateArgument::Null: 3954 return Arg; 3955 3956 case TemplateArgument::Expression: 3957 return Arg; 3958 3959 case TemplateArgument::Declaration: { 3960 ValueDecl *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl()); 3961 return TemplateArgument(D, Arg.isDeclForReferenceParam()); 3962 } 3963 3964 case TemplateArgument::NullPtr: 3965 return TemplateArgument(getCanonicalType(Arg.getNullPtrType()), 3966 /*isNullPtr*/true); 3967 3968 case TemplateArgument::Template: 3969 return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate())); 3970 3971 case TemplateArgument::TemplateExpansion: 3972 return TemplateArgument(getCanonicalTemplateName( 3973 Arg.getAsTemplateOrTemplatePattern()), 3974 Arg.getNumTemplateExpansions()); 3975 3976 case TemplateArgument::Integral: 3977 return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType())); 3978 3979 case TemplateArgument::Type: 3980 return TemplateArgument(getCanonicalType(Arg.getAsType())); 3981 3982 case TemplateArgument::Pack: { 3983 if (Arg.pack_size() == 0) 3984 return Arg; 3985 3986 TemplateArgument *CanonArgs 3987 = new (*this) TemplateArgument[Arg.pack_size()]; 3988 unsigned Idx = 0; 3989 for (TemplateArgument::pack_iterator A = Arg.pack_begin(), 3990 AEnd = Arg.pack_end(); 3991 A != AEnd; (void)++A, ++Idx) 3992 CanonArgs[Idx] = getCanonicalTemplateArgument(*A); 3993 3994 return TemplateArgument(CanonArgs, Arg.pack_size()); 3995 } 3996 } 3997 3998 // Silence GCC warning 3999 llvm_unreachable("Unhandled template argument kind"); 4000} 4001 4002NestedNameSpecifier * 4003ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const { 4004 if (!NNS) 4005 return 0; 4006 4007 switch (NNS->getKind()) { 4008 case NestedNameSpecifier::Identifier: 4009 // Canonicalize the prefix but keep the identifier the same. 4010 return NestedNameSpecifier::Create(*this, 4011 getCanonicalNestedNameSpecifier(NNS->getPrefix()), 4012 NNS->getAsIdentifier()); 4013 4014 case NestedNameSpecifier::Namespace: 4015 // A namespace is canonical; build a nested-name-specifier with 4016 // this namespace and no prefix. 4017 return NestedNameSpecifier::Create(*this, 0, 4018 NNS->getAsNamespace()->getOriginalNamespace()); 4019 4020 case NestedNameSpecifier::NamespaceAlias: 4021 // A namespace is canonical; build a nested-name-specifier with 4022 // this namespace and no prefix. 4023 return NestedNameSpecifier::Create(*this, 0, 4024 NNS->getAsNamespaceAlias()->getNamespace() 4025 ->getOriginalNamespace()); 4026 4027 case NestedNameSpecifier::TypeSpec: 4028 case NestedNameSpecifier::TypeSpecWithTemplate: { 4029 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0)); 4030 4031 // If we have some kind of dependent-named type (e.g., "typename T::type"), 4032 // break it apart into its prefix and identifier, then reconsititute those 4033 // as the canonical nested-name-specifier. This is required to canonicalize 4034 // a dependent nested-name-specifier involving typedefs of dependent-name 4035 // types, e.g., 4036 // typedef typename T::type T1; 4037 // typedef typename T1::type T2; 4038 if (const DependentNameType *DNT = T->getAs<DependentNameType>()) 4039 return NestedNameSpecifier::Create(*this, DNT->getQualifier(), 4040 const_cast<IdentifierInfo *>(DNT->getIdentifier())); 4041 4042 // Otherwise, just canonicalize the type, and force it to be a TypeSpec. 4043 // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the 4044 // first place? 4045 return NestedNameSpecifier::Create(*this, 0, false, 4046 const_cast<Type*>(T.getTypePtr())); 4047 } 4048 4049 case NestedNameSpecifier::Global: 4050 // The global specifier is canonical and unique. 4051 return NNS; 4052 } 4053 4054 llvm_unreachable("Invalid NestedNameSpecifier::Kind!"); 4055} 4056 4057 4058const ArrayType *ASTContext::getAsArrayType(QualType T) const { 4059 // Handle the non-qualified case efficiently. 4060 if (!T.hasLocalQualifiers()) { 4061 // Handle the common positive case fast. 4062 if (const ArrayType *AT = dyn_cast<ArrayType>(T)) 4063 return AT; 4064 } 4065 4066 // Handle the common negative case fast. 4067 if (!isa<ArrayType>(T.getCanonicalType())) 4068 return 0; 4069 4070 // Apply any qualifiers from the array type to the element type. This 4071 // implements C99 6.7.3p8: "If the specification of an array type includes 4072 // any type qualifiers, the element type is so qualified, not the array type." 4073 4074 // If we get here, we either have type qualifiers on the type, or we have 4075 // sugar such as a typedef in the way. If we have type qualifiers on the type 4076 // we must propagate them down into the element type. 4077 4078 SplitQualType split = T.getSplitDesugaredType(); 4079 Qualifiers qs = split.Quals; 4080 4081 // If we have a simple case, just return now. 4082 const ArrayType *ATy = dyn_cast<ArrayType>(split.Ty); 4083 if (ATy == 0 || qs.empty()) 4084 return ATy; 4085 4086 // Otherwise, we have an array and we have qualifiers on it. Push the 4087 // qualifiers into the array element type and return a new array type. 4088 QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs); 4089 4090 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy)) 4091 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(), 4092 CAT->getSizeModifier(), 4093 CAT->getIndexTypeCVRQualifiers())); 4094 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy)) 4095 return cast<ArrayType>(getIncompleteArrayType(NewEltTy, 4096 IAT->getSizeModifier(), 4097 IAT->getIndexTypeCVRQualifiers())); 4098 4099 if (const DependentSizedArrayType *DSAT 4100 = dyn_cast<DependentSizedArrayType>(ATy)) 4101 return cast<ArrayType>( 4102 getDependentSizedArrayType(NewEltTy, 4103 DSAT->getSizeExpr(), 4104 DSAT->getSizeModifier(), 4105 DSAT->getIndexTypeCVRQualifiers(), 4106 DSAT->getBracketsRange())); 4107 4108 const VariableArrayType *VAT = cast<VariableArrayType>(ATy); 4109 return cast<ArrayType>(getVariableArrayType(NewEltTy, 4110 VAT->getSizeExpr(), 4111 VAT->getSizeModifier(), 4112 VAT->getIndexTypeCVRQualifiers(), 4113 VAT->getBracketsRange())); 4114} 4115 4116QualType ASTContext::getAdjustedParameterType(QualType T) const { 4117 // C99 6.7.5.3p7: 4118 // A declaration of a parameter as "array of type" shall be 4119 // adjusted to "qualified pointer to type", where the type 4120 // qualifiers (if any) are those specified within the [ and ] of 4121 // the array type derivation. 4122 if (T->isArrayType()) 4123 return getArrayDecayedType(T); 4124 4125 // C99 6.7.5.3p8: 4126 // A declaration of a parameter as "function returning type" 4127 // shall be adjusted to "pointer to function returning type", as 4128 // in 6.3.2.1. 4129 if (T->isFunctionType()) 4130 return getPointerType(T); 4131 4132 return T; 4133} 4134 4135QualType ASTContext::getSignatureParameterType(QualType T) const { 4136 T = getVariableArrayDecayedType(T); 4137 T = getAdjustedParameterType(T); 4138 return T.getUnqualifiedType(); 4139} 4140 4141/// getArrayDecayedType - Return the properly qualified result of decaying the 4142/// specified array type to a pointer. This operation is non-trivial when 4143/// handling typedefs etc. The canonical type of "T" must be an array type, 4144/// this returns a pointer to a properly qualified element of the array. 4145/// 4146/// See C99 6.7.5.3p7 and C99 6.3.2.1p3. 4147QualType ASTContext::getArrayDecayedType(QualType Ty) const { 4148 // Get the element type with 'getAsArrayType' so that we don't lose any 4149 // typedefs in the element type of the array. This also handles propagation 4150 // of type qualifiers from the array type into the element type if present 4151 // (C99 6.7.3p8). 4152 const ArrayType *PrettyArrayType = getAsArrayType(Ty); 4153 assert(PrettyArrayType && "Not an array type!"); 4154 4155 QualType PtrTy = getPointerType(PrettyArrayType->getElementType()); 4156 4157 // int x[restrict 4] -> int *restrict 4158 return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers()); 4159} 4160 4161QualType ASTContext::getBaseElementType(const ArrayType *array) const { 4162 return getBaseElementType(array->getElementType()); 4163} 4164 4165QualType ASTContext::getBaseElementType(QualType type) const { 4166 Qualifiers qs; 4167 while (true) { 4168 SplitQualType split = type.getSplitDesugaredType(); 4169 const ArrayType *array = split.Ty->getAsArrayTypeUnsafe(); 4170 if (!array) break; 4171 4172 type = array->getElementType(); 4173 qs.addConsistentQualifiers(split.Quals); 4174 } 4175 4176 return getQualifiedType(type, qs); 4177} 4178 4179/// getConstantArrayElementCount - Returns number of constant array elements. 4180uint64_t 4181ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const { 4182 uint64_t ElementCount = 1; 4183 do { 4184 ElementCount *= CA->getSize().getZExtValue(); 4185 CA = dyn_cast_or_null<ConstantArrayType>( 4186 CA->getElementType()->getAsArrayTypeUnsafe()); 4187 } while (CA); 4188 return ElementCount; 4189} 4190 4191/// getFloatingRank - Return a relative rank for floating point types. 4192/// This routine will assert if passed a built-in type that isn't a float. 4193static FloatingRank getFloatingRank(QualType T) { 4194 if (const ComplexType *CT = T->getAs<ComplexType>()) 4195 return getFloatingRank(CT->getElementType()); 4196 4197 assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"); 4198 switch (T->getAs<BuiltinType>()->getKind()) { 4199 default: llvm_unreachable("getFloatingRank(): not a floating type"); 4200 case BuiltinType::Half: return HalfRank; 4201 case BuiltinType::Float: return FloatRank; 4202 case BuiltinType::Double: return DoubleRank; 4203 case BuiltinType::LongDouble: return LongDoubleRank; 4204 } 4205} 4206 4207/// getFloatingTypeOfSizeWithinDomain - Returns a real floating 4208/// point or a complex type (based on typeDomain/typeSize). 4209/// 'typeDomain' is a real floating point or complex type. 4210/// 'typeSize' is a real floating point or complex type. 4211QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size, 4212 QualType Domain) const { 4213 FloatingRank EltRank = getFloatingRank(Size); 4214 if (Domain->isComplexType()) { 4215 switch (EltRank) { 4216 case HalfRank: llvm_unreachable("Complex half is not supported"); 4217 case FloatRank: return FloatComplexTy; 4218 case DoubleRank: return DoubleComplexTy; 4219 case LongDoubleRank: return LongDoubleComplexTy; 4220 } 4221 } 4222 4223 assert(Domain->isRealFloatingType() && "Unknown domain!"); 4224 switch (EltRank) { 4225 case HalfRank: return HalfTy; 4226 case FloatRank: return FloatTy; 4227 case DoubleRank: return DoubleTy; 4228 case LongDoubleRank: return LongDoubleTy; 4229 } 4230 llvm_unreachable("getFloatingRank(): illegal value for rank"); 4231} 4232 4233/// getFloatingTypeOrder - Compare the rank of the two specified floating 4234/// point types, ignoring the domain of the type (i.e. 'double' == 4235/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If 4236/// LHS < RHS, return -1. 4237int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const { 4238 FloatingRank LHSR = getFloatingRank(LHS); 4239 FloatingRank RHSR = getFloatingRank(RHS); 4240 4241 if (LHSR == RHSR) 4242 return 0; 4243 if (LHSR > RHSR) 4244 return 1; 4245 return -1; 4246} 4247 4248/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This 4249/// routine will assert if passed a built-in type that isn't an integer or enum, 4250/// or if it is not canonicalized. 4251unsigned ASTContext::getIntegerRank(const Type *T) const { 4252 assert(T->isCanonicalUnqualified() && "T should be canonicalized"); 4253 4254 switch (cast<BuiltinType>(T)->getKind()) { 4255 default: llvm_unreachable("getIntegerRank(): not a built-in integer"); 4256 case BuiltinType::Bool: 4257 return 1 + (getIntWidth(BoolTy) << 3); 4258 case BuiltinType::Char_S: 4259 case BuiltinType::Char_U: 4260 case BuiltinType::SChar: 4261 case BuiltinType::UChar: 4262 return 2 + (getIntWidth(CharTy) << 3); 4263 case BuiltinType::Short: 4264 case BuiltinType::UShort: 4265 return 3 + (getIntWidth(ShortTy) << 3); 4266 case BuiltinType::Int: 4267 case BuiltinType::UInt: 4268 return 4 + (getIntWidth(IntTy) << 3); 4269 case BuiltinType::Long: 4270 case BuiltinType::ULong: 4271 return 5 + (getIntWidth(LongTy) << 3); 4272 case BuiltinType::LongLong: 4273 case BuiltinType::ULongLong: 4274 return 6 + (getIntWidth(LongLongTy) << 3); 4275 case BuiltinType::Int128: 4276 case BuiltinType::UInt128: 4277 return 7 + (getIntWidth(Int128Ty) << 3); 4278 } 4279} 4280 4281/// \brief Whether this is a promotable bitfield reference according 4282/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions). 4283/// 4284/// \returns the type this bit-field will promote to, or NULL if no 4285/// promotion occurs. 4286QualType ASTContext::isPromotableBitField(Expr *E) const { 4287 if (E->isTypeDependent() || E->isValueDependent()) 4288 return QualType(); 4289 4290 FieldDecl *Field = E->getSourceBitField(); // FIXME: conditional bit-fields? 4291 if (!Field) 4292 return QualType(); 4293 4294 QualType FT = Field->getType(); 4295 4296 uint64_t BitWidth = Field->getBitWidthValue(*this); 4297 uint64_t IntSize = getTypeSize(IntTy); 4298 // GCC extension compatibility: if the bit-field size is less than or equal 4299 // to the size of int, it gets promoted no matter what its type is. 4300 // For instance, unsigned long bf : 4 gets promoted to signed int. 4301 if (BitWidth < IntSize) 4302 return IntTy; 4303 4304 if (BitWidth == IntSize) 4305 return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy; 4306 4307 // Types bigger than int are not subject to promotions, and therefore act 4308 // like the base type. 4309 // FIXME: This doesn't quite match what gcc does, but what gcc does here 4310 // is ridiculous. 4311 return QualType(); 4312} 4313 4314/// getPromotedIntegerType - Returns the type that Promotable will 4315/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable 4316/// integer type. 4317QualType ASTContext::getPromotedIntegerType(QualType Promotable) const { 4318 assert(!Promotable.isNull()); 4319 assert(Promotable->isPromotableIntegerType()); 4320 if (const EnumType *ET = Promotable->getAs<EnumType>()) 4321 return ET->getDecl()->getPromotionType(); 4322 4323 if (const BuiltinType *BT = Promotable->getAs<BuiltinType>()) { 4324 // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t 4325 // (3.9.1) can be converted to a prvalue of the first of the following 4326 // types that can represent all the values of its underlying type: 4327 // int, unsigned int, long int, unsigned long int, long long int, or 4328 // unsigned long long int [...] 4329 // FIXME: Is there some better way to compute this? 4330 if (BT->getKind() == BuiltinType::WChar_S || 4331 BT->getKind() == BuiltinType::WChar_U || 4332 BT->getKind() == BuiltinType::Char16 || 4333 BT->getKind() == BuiltinType::Char32) { 4334 bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S; 4335 uint64_t FromSize = getTypeSize(BT); 4336 QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy, 4337 LongLongTy, UnsignedLongLongTy }; 4338 for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) { 4339 uint64_t ToSize = getTypeSize(PromoteTypes[Idx]); 4340 if (FromSize < ToSize || 4341 (FromSize == ToSize && 4342 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) 4343 return PromoteTypes[Idx]; 4344 } 4345 llvm_unreachable("char type should fit into long long"); 4346 } 4347 } 4348 4349 // At this point, we should have a signed or unsigned integer type. 4350 if (Promotable->isSignedIntegerType()) 4351 return IntTy; 4352 uint64_t PromotableSize = getIntWidth(Promotable); 4353 uint64_t IntSize = getIntWidth(IntTy); 4354 assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize); 4355 return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy; 4356} 4357 4358/// \brief Recurses in pointer/array types until it finds an objc retainable 4359/// type and returns its ownership. 4360Qualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const { 4361 while (!T.isNull()) { 4362 if (T.getObjCLifetime() != Qualifiers::OCL_None) 4363 return T.getObjCLifetime(); 4364 if (T->isArrayType()) 4365 T = getBaseElementType(T); 4366 else if (const PointerType *PT = T->getAs<PointerType>()) 4367 T = PT->getPointeeType(); 4368 else if (const ReferenceType *RT = T->getAs<ReferenceType>()) 4369 T = RT->getPointeeType(); 4370 else 4371 break; 4372 } 4373 4374 return Qualifiers::OCL_None; 4375} 4376 4377/// getIntegerTypeOrder - Returns the highest ranked integer type: 4378/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If 4379/// LHS < RHS, return -1. 4380int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const { 4381 const Type *LHSC = getCanonicalType(LHS).getTypePtr(); 4382 const Type *RHSC = getCanonicalType(RHS).getTypePtr(); 4383 if (LHSC == RHSC) return 0; 4384 4385 bool LHSUnsigned = LHSC->isUnsignedIntegerType(); 4386 bool RHSUnsigned = RHSC->isUnsignedIntegerType(); 4387 4388 unsigned LHSRank = getIntegerRank(LHSC); 4389 unsigned RHSRank = getIntegerRank(RHSC); 4390 4391 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned. 4392 if (LHSRank == RHSRank) return 0; 4393 return LHSRank > RHSRank ? 1 : -1; 4394 } 4395 4396 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa. 4397 if (LHSUnsigned) { 4398 // If the unsigned [LHS] type is larger, return it. 4399 if (LHSRank >= RHSRank) 4400 return 1; 4401 4402 // If the signed type can represent all values of the unsigned type, it 4403 // wins. Because we are dealing with 2's complement and types that are 4404 // powers of two larger than each other, this is always safe. 4405 return -1; 4406 } 4407 4408 // If the unsigned [RHS] type is larger, return it. 4409 if (RHSRank >= LHSRank) 4410 return -1; 4411 4412 // If the signed type can represent all values of the unsigned type, it 4413 // wins. Because we are dealing with 2's complement and types that are 4414 // powers of two larger than each other, this is always safe. 4415 return 1; 4416} 4417 4418static RecordDecl * 4419CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK, 4420 DeclContext *DC, IdentifierInfo *Id) { 4421 SourceLocation Loc; 4422 if (Ctx.getLangOpts().CPlusPlus) 4423 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 4424 else 4425 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id); 4426} 4427 4428// getCFConstantStringType - Return the type used for constant CFStrings. 4429QualType ASTContext::getCFConstantStringType() const { 4430 if (!CFConstantStringTypeDecl) { 4431 CFConstantStringTypeDecl = 4432 CreateRecordDecl(*this, TTK_Struct, TUDecl, 4433 &Idents.get("NSConstantString")); 4434 CFConstantStringTypeDecl->startDefinition(); 4435 4436 QualType FieldTypes[4]; 4437 4438 // const int *isa; 4439 FieldTypes[0] = getPointerType(IntTy.withConst()); 4440 // int flags; 4441 FieldTypes[1] = IntTy; 4442 // const char *str; 4443 FieldTypes[2] = getPointerType(CharTy.withConst()); 4444 // long length; 4445 FieldTypes[3] = LongTy; 4446 4447 // Create fields 4448 for (unsigned i = 0; i < 4; ++i) { 4449 FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl, 4450 SourceLocation(), 4451 SourceLocation(), 0, 4452 FieldTypes[i], /*TInfo=*/0, 4453 /*BitWidth=*/0, 4454 /*Mutable=*/false, 4455 ICIS_NoInit); 4456 Field->setAccess(AS_public); 4457 CFConstantStringTypeDecl->addDecl(Field); 4458 } 4459 4460 CFConstantStringTypeDecl->completeDefinition(); 4461 } 4462 4463 return getTagDeclType(CFConstantStringTypeDecl); 4464} 4465 4466QualType ASTContext::getObjCSuperType() const { 4467 if (ObjCSuperType.isNull()) { 4468 RecordDecl *ObjCSuperTypeDecl = 4469 CreateRecordDecl(*this, TTK_Struct, TUDecl, &Idents.get("objc_super")); 4470 TUDecl->addDecl(ObjCSuperTypeDecl); 4471 ObjCSuperType = getTagDeclType(ObjCSuperTypeDecl); 4472 } 4473 return ObjCSuperType; 4474} 4475 4476void ASTContext::setCFConstantStringType(QualType T) { 4477 const RecordType *Rec = T->getAs<RecordType>(); 4478 assert(Rec && "Invalid CFConstantStringType"); 4479 CFConstantStringTypeDecl = Rec->getDecl(); 4480} 4481 4482QualType ASTContext::getBlockDescriptorType() const { 4483 if (BlockDescriptorType) 4484 return getTagDeclType(BlockDescriptorType); 4485 4486 RecordDecl *T; 4487 // FIXME: Needs the FlagAppleBlock bit. 4488 T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 4489 &Idents.get("__block_descriptor")); 4490 T->startDefinition(); 4491 4492 QualType FieldTypes[] = { 4493 UnsignedLongTy, 4494 UnsignedLongTy, 4495 }; 4496 4497 const char *FieldNames[] = { 4498 "reserved", 4499 "Size" 4500 }; 4501 4502 for (size_t i = 0; i < 2; ++i) { 4503 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 4504 SourceLocation(), 4505 &Idents.get(FieldNames[i]), 4506 FieldTypes[i], /*TInfo=*/0, 4507 /*BitWidth=*/0, 4508 /*Mutable=*/false, 4509 ICIS_NoInit); 4510 Field->setAccess(AS_public); 4511 T->addDecl(Field); 4512 } 4513 4514 T->completeDefinition(); 4515 4516 BlockDescriptorType = T; 4517 4518 return getTagDeclType(BlockDescriptorType); 4519} 4520 4521QualType ASTContext::getBlockDescriptorExtendedType() const { 4522 if (BlockDescriptorExtendedType) 4523 return getTagDeclType(BlockDescriptorExtendedType); 4524 4525 RecordDecl *T; 4526 // FIXME: Needs the FlagAppleBlock bit. 4527 T = CreateRecordDecl(*this, TTK_Struct, TUDecl, 4528 &Idents.get("__block_descriptor_withcopydispose")); 4529 T->startDefinition(); 4530 4531 QualType FieldTypes[] = { 4532 UnsignedLongTy, 4533 UnsignedLongTy, 4534 getPointerType(VoidPtrTy), 4535 getPointerType(VoidPtrTy) 4536 }; 4537 4538 const char *FieldNames[] = { 4539 "reserved", 4540 "Size", 4541 "CopyFuncPtr", 4542 "DestroyFuncPtr" 4543 }; 4544 4545 for (size_t i = 0; i < 4; ++i) { 4546 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(), 4547 SourceLocation(), 4548 &Idents.get(FieldNames[i]), 4549 FieldTypes[i], /*TInfo=*/0, 4550 /*BitWidth=*/0, 4551 /*Mutable=*/false, 4552 ICIS_NoInit); 4553 Field->setAccess(AS_public); 4554 T->addDecl(Field); 4555 } 4556 4557 T->completeDefinition(); 4558 4559 BlockDescriptorExtendedType = T; 4560 4561 return getTagDeclType(BlockDescriptorExtendedType); 4562} 4563 4564/// BlockRequiresCopying - Returns true if byref variable "D" of type "Ty" 4565/// requires copy/dispose. Note that this must match the logic 4566/// in buildByrefHelpers. 4567bool ASTContext::BlockRequiresCopying(QualType Ty, 4568 const VarDecl *D) { 4569 if (const CXXRecordDecl *record = Ty->getAsCXXRecordDecl()) { 4570 const Expr *copyExpr = getBlockVarCopyInits(D); 4571 if (!copyExpr && record->hasTrivialDestructor()) return false; 4572 4573 return true; 4574 } 4575 4576 if (!Ty->isObjCRetainableType()) return false; 4577 4578 Qualifiers qs = Ty.getQualifiers(); 4579 4580 // If we have lifetime, that dominates. 4581 if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) { 4582 assert(getLangOpts().ObjCAutoRefCount); 4583 4584 switch (lifetime) { 4585 case Qualifiers::OCL_None: llvm_unreachable("impossible"); 4586 4587 // These are just bits as far as the runtime is concerned. 4588 case Qualifiers::OCL_ExplicitNone: 4589 case Qualifiers::OCL_Autoreleasing: 4590 return false; 4591 4592 // Tell the runtime that this is ARC __weak, called by the 4593 // byref routines. 4594 case Qualifiers::OCL_Weak: 4595 // ARC __strong __block variables need to be retained. 4596 case Qualifiers::OCL_Strong: 4597 return true; 4598 } 4599 llvm_unreachable("fell out of lifetime switch!"); 4600 } 4601 return (Ty->isBlockPointerType() || isObjCNSObjectType(Ty) || 4602 Ty->isObjCObjectPointerType()); 4603} 4604 4605bool ASTContext::getByrefLifetime(QualType Ty, 4606 Qualifiers::ObjCLifetime &LifeTime, 4607 bool &HasByrefExtendedLayout) const { 4608 4609 if (!getLangOpts().ObjC1 || 4610 getLangOpts().getGC() != LangOptions::NonGC) 4611 return false; 4612 4613 HasByrefExtendedLayout = false; 4614 if (Ty->isRecordType()) { 4615 HasByrefExtendedLayout = true; 4616 LifeTime = Qualifiers::OCL_None; 4617 } 4618 else if (getLangOpts().ObjCAutoRefCount) 4619 LifeTime = Ty.getObjCLifetime(); 4620 // MRR. 4621 else if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) 4622 LifeTime = Qualifiers::OCL_ExplicitNone; 4623 else 4624 LifeTime = Qualifiers::OCL_None; 4625 return true; 4626} 4627 4628TypedefDecl *ASTContext::getObjCInstanceTypeDecl() { 4629 if (!ObjCInstanceTypeDecl) 4630 ObjCInstanceTypeDecl = TypedefDecl::Create(*this, 4631 getTranslationUnitDecl(), 4632 SourceLocation(), 4633 SourceLocation(), 4634 &Idents.get("instancetype"), 4635 getTrivialTypeSourceInfo(getObjCIdType())); 4636 return ObjCInstanceTypeDecl; 4637} 4638 4639// This returns true if a type has been typedefed to BOOL: 4640// typedef <type> BOOL; 4641static bool isTypeTypedefedAsBOOL(QualType T) { 4642 if (const TypedefType *TT = dyn_cast<TypedefType>(T)) 4643 if (IdentifierInfo *II = TT->getDecl()->getIdentifier()) 4644 return II->isStr("BOOL"); 4645 4646 return false; 4647} 4648 4649/// getObjCEncodingTypeSize returns size of type for objective-c encoding 4650/// purpose. 4651CharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const { 4652 if (!type->isIncompleteArrayType() && type->isIncompleteType()) 4653 return CharUnits::Zero(); 4654 4655 CharUnits sz = getTypeSizeInChars(type); 4656 4657 // Make all integer and enum types at least as large as an int 4658 if (sz.isPositive() && type->isIntegralOrEnumerationType()) 4659 sz = std::max(sz, getTypeSizeInChars(IntTy)); 4660 // Treat arrays as pointers, since that's how they're passed in. 4661 else if (type->isArrayType()) 4662 sz = getTypeSizeInChars(VoidPtrTy); 4663 return sz; 4664} 4665 4666static inline 4667std::string charUnitsToString(const CharUnits &CU) { 4668 return llvm::itostr(CU.getQuantity()); 4669} 4670 4671/// getObjCEncodingForBlock - Return the encoded type for this block 4672/// declaration. 4673std::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const { 4674 std::string S; 4675 4676 const BlockDecl *Decl = Expr->getBlockDecl(); 4677 QualType BlockTy = 4678 Expr->getType()->getAs<BlockPointerType>()->getPointeeType(); 4679 // Encode result type. 4680 if (getLangOpts().EncodeExtendedBlockSig) 4681 getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, 4682 BlockTy->getAs<FunctionType>()->getResultType(), 4683 S, true /*Extended*/); 4684 else 4685 getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getResultType(), 4686 S); 4687 // Compute size of all parameters. 4688 // Start with computing size of a pointer in number of bytes. 4689 // FIXME: There might(should) be a better way of doing this computation! 4690 SourceLocation Loc; 4691 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 4692 CharUnits ParmOffset = PtrSize; 4693 for (BlockDecl::param_const_iterator PI = Decl->param_begin(), 4694 E = Decl->param_end(); PI != E; ++PI) { 4695 QualType PType = (*PI)->getType(); 4696 CharUnits sz = getObjCEncodingTypeSize(PType); 4697 if (sz.isZero()) 4698 continue; 4699 assert (sz.isPositive() && "BlockExpr - Incomplete param type"); 4700 ParmOffset += sz; 4701 } 4702 // Size of the argument frame 4703 S += charUnitsToString(ParmOffset); 4704 // Block pointer and offset. 4705 S += "@?0"; 4706 4707 // Argument types. 4708 ParmOffset = PtrSize; 4709 for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E = 4710 Decl->param_end(); PI != E; ++PI) { 4711 ParmVarDecl *PVDecl = *PI; 4712 QualType PType = PVDecl->getOriginalType(); 4713 if (const ArrayType *AT = 4714 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 4715 // Use array's original type only if it has known number of 4716 // elements. 4717 if (!isa<ConstantArrayType>(AT)) 4718 PType = PVDecl->getType(); 4719 } else if (PType->isFunctionType()) 4720 PType = PVDecl->getType(); 4721 if (getLangOpts().EncodeExtendedBlockSig) 4722 getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, PType, 4723 S, true /*Extended*/); 4724 else 4725 getObjCEncodingForType(PType, S); 4726 S += charUnitsToString(ParmOffset); 4727 ParmOffset += getObjCEncodingTypeSize(PType); 4728 } 4729 4730 return S; 4731} 4732 4733bool ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl, 4734 std::string& S) { 4735 // Encode result type. 4736 getObjCEncodingForType(Decl->getResultType(), S); 4737 CharUnits ParmOffset; 4738 // Compute size of all parameters. 4739 for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 4740 E = Decl->param_end(); PI != E; ++PI) { 4741 QualType PType = (*PI)->getType(); 4742 CharUnits sz = getObjCEncodingTypeSize(PType); 4743 if (sz.isZero()) 4744 continue; 4745 4746 assert (sz.isPositive() && 4747 "getObjCEncodingForFunctionDecl - Incomplete param type"); 4748 ParmOffset += sz; 4749 } 4750 S += charUnitsToString(ParmOffset); 4751 ParmOffset = CharUnits::Zero(); 4752 4753 // Argument types. 4754 for (FunctionDecl::param_const_iterator PI = Decl->param_begin(), 4755 E = Decl->param_end(); PI != E; ++PI) { 4756 ParmVarDecl *PVDecl = *PI; 4757 QualType PType = PVDecl->getOriginalType(); 4758 if (const ArrayType *AT = 4759 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 4760 // Use array's original type only if it has known number of 4761 // elements. 4762 if (!isa<ConstantArrayType>(AT)) 4763 PType = PVDecl->getType(); 4764 } else if (PType->isFunctionType()) 4765 PType = PVDecl->getType(); 4766 getObjCEncodingForType(PType, S); 4767 S += charUnitsToString(ParmOffset); 4768 ParmOffset += getObjCEncodingTypeSize(PType); 4769 } 4770 4771 return false; 4772} 4773 4774/// getObjCEncodingForMethodParameter - Return the encoded type for a single 4775/// method parameter or return type. If Extended, include class names and 4776/// block object types. 4777void ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, 4778 QualType T, std::string& S, 4779 bool Extended) const { 4780 // Encode type qualifer, 'in', 'inout', etc. for the parameter. 4781 getObjCEncodingForTypeQualifier(QT, S); 4782 // Encode parameter type. 4783 getObjCEncodingForTypeImpl(T, S, true, true, 0, 4784 true /*OutermostType*/, 4785 false /*EncodingProperty*/, 4786 false /*StructField*/, 4787 Extended /*EncodeBlockParameters*/, 4788 Extended /*EncodeClassNames*/); 4789} 4790 4791/// getObjCEncodingForMethodDecl - Return the encoded type for this method 4792/// declaration. 4793bool ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, 4794 std::string& S, 4795 bool Extended) const { 4796 // FIXME: This is not very efficient. 4797 // Encode return type. 4798 getObjCEncodingForMethodParameter(Decl->getObjCDeclQualifier(), 4799 Decl->getResultType(), S, Extended); 4800 // Compute size of all parameters. 4801 // Start with computing size of a pointer in number of bytes. 4802 // FIXME: There might(should) be a better way of doing this computation! 4803 SourceLocation Loc; 4804 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy); 4805 // The first two arguments (self and _cmd) are pointers; account for 4806 // their size. 4807 CharUnits ParmOffset = 2 * PtrSize; 4808 for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 4809 E = Decl->sel_param_end(); PI != E; ++PI) { 4810 QualType PType = (*PI)->getType(); 4811 CharUnits sz = getObjCEncodingTypeSize(PType); 4812 if (sz.isZero()) 4813 continue; 4814 4815 assert (sz.isPositive() && 4816 "getObjCEncodingForMethodDecl - Incomplete param type"); 4817 ParmOffset += sz; 4818 } 4819 S += charUnitsToString(ParmOffset); 4820 S += "@0:"; 4821 S += charUnitsToString(PtrSize); 4822 4823 // Argument types. 4824 ParmOffset = 2 * PtrSize; 4825 for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(), 4826 E = Decl->sel_param_end(); PI != E; ++PI) { 4827 const ParmVarDecl *PVDecl = *PI; 4828 QualType PType = PVDecl->getOriginalType(); 4829 if (const ArrayType *AT = 4830 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) { 4831 // Use array's original type only if it has known number of 4832 // elements. 4833 if (!isa<ConstantArrayType>(AT)) 4834 PType = PVDecl->getType(); 4835 } else if (PType->isFunctionType()) 4836 PType = PVDecl->getType(); 4837 getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(), 4838 PType, S, Extended); 4839 S += charUnitsToString(ParmOffset); 4840 ParmOffset += getObjCEncodingTypeSize(PType); 4841 } 4842 4843 return false; 4844} 4845 4846/// getObjCEncodingForPropertyDecl - Return the encoded type for this 4847/// property declaration. If non-NULL, Container must be either an 4848/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be 4849/// NULL when getting encodings for protocol properties. 4850/// Property attributes are stored as a comma-delimited C string. The simple 4851/// attributes readonly and bycopy are encoded as single characters. The 4852/// parametrized attributes, getter=name, setter=name, and ivar=name, are 4853/// encoded as single characters, followed by an identifier. Property types 4854/// are also encoded as a parametrized attribute. The characters used to encode 4855/// these attributes are defined by the following enumeration: 4856/// @code 4857/// enum PropertyAttributes { 4858/// kPropertyReadOnly = 'R', // property is read-only. 4859/// kPropertyBycopy = 'C', // property is a copy of the value last assigned 4860/// kPropertyByref = '&', // property is a reference to the value last assigned 4861/// kPropertyDynamic = 'D', // property is dynamic 4862/// kPropertyGetter = 'G', // followed by getter selector name 4863/// kPropertySetter = 'S', // followed by setter selector name 4864/// kPropertyInstanceVariable = 'V' // followed by instance variable name 4865/// kPropertyType = 'T' // followed by old-style type encoding. 4866/// kPropertyWeak = 'W' // 'weak' property 4867/// kPropertyStrong = 'P' // property GC'able 4868/// kPropertyNonAtomic = 'N' // property non-atomic 4869/// }; 4870/// @endcode 4871void ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, 4872 const Decl *Container, 4873 std::string& S) const { 4874 // Collect information from the property implementation decl(s). 4875 bool Dynamic = false; 4876 ObjCPropertyImplDecl *SynthesizePID = 0; 4877 4878 // FIXME: Duplicated code due to poor abstraction. 4879 if (Container) { 4880 if (const ObjCCategoryImplDecl *CID = 4881 dyn_cast<ObjCCategoryImplDecl>(Container)) { 4882 for (ObjCCategoryImplDecl::propimpl_iterator 4883 i = CID->propimpl_begin(), e = CID->propimpl_end(); 4884 i != e; ++i) { 4885 ObjCPropertyImplDecl *PID = *i; 4886 if (PID->getPropertyDecl() == PD) { 4887 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4888 Dynamic = true; 4889 } else { 4890 SynthesizePID = PID; 4891 } 4892 } 4893 } 4894 } else { 4895 const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container); 4896 for (ObjCCategoryImplDecl::propimpl_iterator 4897 i = OID->propimpl_begin(), e = OID->propimpl_end(); 4898 i != e; ++i) { 4899 ObjCPropertyImplDecl *PID = *i; 4900 if (PID->getPropertyDecl() == PD) { 4901 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) { 4902 Dynamic = true; 4903 } else { 4904 SynthesizePID = PID; 4905 } 4906 } 4907 } 4908 } 4909 } 4910 4911 // FIXME: This is not very efficient. 4912 S = "T"; 4913 4914 // Encode result type. 4915 // GCC has some special rules regarding encoding of properties which 4916 // closely resembles encoding of ivars. 4917 getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0, 4918 true /* outermost type */, 4919 true /* encoding for property */); 4920 4921 if (PD->isReadOnly()) { 4922 S += ",R"; 4923 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_copy) 4924 S += ",C"; 4925 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_retain) 4926 S += ",&"; 4927 } else { 4928 switch (PD->getSetterKind()) { 4929 case ObjCPropertyDecl::Assign: break; 4930 case ObjCPropertyDecl::Copy: S += ",C"; break; 4931 case ObjCPropertyDecl::Retain: S += ",&"; break; 4932 case ObjCPropertyDecl::Weak: S += ",W"; break; 4933 } 4934 } 4935 4936 // It really isn't clear at all what this means, since properties 4937 // are "dynamic by default". 4938 if (Dynamic) 4939 S += ",D"; 4940 4941 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic) 4942 S += ",N"; 4943 4944 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) { 4945 S += ",G"; 4946 S += PD->getGetterName().getAsString(); 4947 } 4948 4949 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) { 4950 S += ",S"; 4951 S += PD->getSetterName().getAsString(); 4952 } 4953 4954 if (SynthesizePID) { 4955 const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl(); 4956 S += ",V"; 4957 S += OID->getNameAsString(); 4958 } 4959 4960 // FIXME: OBJCGC: weak & strong 4961} 4962 4963/// getLegacyIntegralTypeEncoding - 4964/// Another legacy compatibility encoding: 32-bit longs are encoded as 4965/// 'l' or 'L' , but not always. For typedefs, we need to use 4966/// 'i' or 'I' instead if encoding a struct field, or a pointer! 4967/// 4968void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const { 4969 if (isa<TypedefType>(PointeeTy.getTypePtr())) { 4970 if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) { 4971 if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32) 4972 PointeeTy = UnsignedIntTy; 4973 else 4974 if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32) 4975 PointeeTy = IntTy; 4976 } 4977 } 4978} 4979 4980void ASTContext::getObjCEncodingForType(QualType T, std::string& S, 4981 const FieldDecl *Field) const { 4982 // We follow the behavior of gcc, expanding structures which are 4983 // directly pointed to, and expanding embedded structures. Note that 4984 // these rules are sufficient to prevent recursive encoding of the 4985 // same type. 4986 getObjCEncodingForTypeImpl(T, S, true, true, Field, 4987 true /* outermost type */); 4988} 4989 4990static char getObjCEncodingForPrimitiveKind(const ASTContext *C, 4991 BuiltinType::Kind kind) { 4992 switch (kind) { 4993 case BuiltinType::Void: return 'v'; 4994 case BuiltinType::Bool: return 'B'; 4995 case BuiltinType::Char_U: 4996 case BuiltinType::UChar: return 'C'; 4997 case BuiltinType::Char16: 4998 case BuiltinType::UShort: return 'S'; 4999 case BuiltinType::Char32: 5000 case BuiltinType::UInt: return 'I'; 5001 case BuiltinType::ULong: 5002 return C->getTargetInfo().getLongWidth() == 32 ? 'L' : 'Q'; 5003 case BuiltinType::UInt128: return 'T'; 5004 case BuiltinType::ULongLong: return 'Q'; 5005 case BuiltinType::Char_S: 5006 case BuiltinType::SChar: return 'c'; 5007 case BuiltinType::Short: return 's'; 5008 case BuiltinType::WChar_S: 5009 case BuiltinType::WChar_U: 5010 case BuiltinType::Int: return 'i'; 5011 case BuiltinType::Long: 5012 return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q'; 5013 case BuiltinType::LongLong: return 'q'; 5014 case BuiltinType::Int128: return 't'; 5015 case BuiltinType::Float: return 'f'; 5016 case BuiltinType::Double: return 'd'; 5017 case BuiltinType::LongDouble: return 'D'; 5018 case BuiltinType::NullPtr: return '*'; // like char* 5019 5020 case BuiltinType::Half: 5021 // FIXME: potentially need @encodes for these! 5022 return ' '; 5023 5024 case BuiltinType::ObjCId: 5025 case BuiltinType::ObjCClass: 5026 case BuiltinType::ObjCSel: 5027 llvm_unreachable("@encoding ObjC primitive type"); 5028 5029 // OpenCL and placeholder types don't need @encodings. 5030 case BuiltinType::OCLImage1d: 5031 case BuiltinType::OCLImage1dArray: 5032 case BuiltinType::OCLImage1dBuffer: 5033 case BuiltinType::OCLImage2d: 5034 case BuiltinType::OCLImage2dArray: 5035 case BuiltinType::OCLImage3d: 5036 case BuiltinType::OCLEvent: 5037 case BuiltinType::OCLSampler: 5038 case BuiltinType::Dependent: 5039#define BUILTIN_TYPE(KIND, ID) 5040#define PLACEHOLDER_TYPE(KIND, ID) \ 5041 case BuiltinType::KIND: 5042#include "clang/AST/BuiltinTypes.def" 5043 llvm_unreachable("invalid builtin type for @encode"); 5044 } 5045 llvm_unreachable("invalid BuiltinType::Kind value"); 5046} 5047 5048static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) { 5049 EnumDecl *Enum = ET->getDecl(); 5050 5051 // The encoding of an non-fixed enum type is always 'i', regardless of size. 5052 if (!Enum->isFixed()) 5053 return 'i'; 5054 5055 // The encoding of a fixed enum type matches its fixed underlying type. 5056 const BuiltinType *BT = Enum->getIntegerType()->castAs<BuiltinType>(); 5057 return getObjCEncodingForPrimitiveKind(C, BT->getKind()); 5058} 5059 5060static void EncodeBitField(const ASTContext *Ctx, std::string& S, 5061 QualType T, const FieldDecl *FD) { 5062 assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl"); 5063 S += 'b'; 5064 // The NeXT runtime encodes bit fields as b followed by the number of bits. 5065 // The GNU runtime requires more information; bitfields are encoded as b, 5066 // then the offset (in bits) of the first element, then the type of the 5067 // bitfield, then the size in bits. For example, in this structure: 5068 // 5069 // struct 5070 // { 5071 // int integer; 5072 // int flags:2; 5073 // }; 5074 // On a 32-bit system, the encoding for flags would be b2 for the NeXT 5075 // runtime, but b32i2 for the GNU runtime. The reason for this extra 5076 // information is not especially sensible, but we're stuck with it for 5077 // compatibility with GCC, although providing it breaks anything that 5078 // actually uses runtime introspection and wants to work on both runtimes... 5079 if (Ctx->getLangOpts().ObjCRuntime.isGNUFamily()) { 5080 const RecordDecl *RD = FD->getParent(); 5081 const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD); 5082 S += llvm::utostr(RL.getFieldOffset(FD->getFieldIndex())); 5083 if (const EnumType *ET = T->getAs<EnumType>()) 5084 S += ObjCEncodingForEnumType(Ctx, ET); 5085 else { 5086 const BuiltinType *BT = T->castAs<BuiltinType>(); 5087 S += getObjCEncodingForPrimitiveKind(Ctx, BT->getKind()); 5088 } 5089 } 5090 S += llvm::utostr(FD->getBitWidthValue(*Ctx)); 5091} 5092 5093// FIXME: Use SmallString for accumulating string. 5094void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S, 5095 bool ExpandPointedToStructures, 5096 bool ExpandStructures, 5097 const FieldDecl *FD, 5098 bool OutermostType, 5099 bool EncodingProperty, 5100 bool StructField, 5101 bool EncodeBlockParameters, 5102 bool EncodeClassNames, 5103 bool EncodePointerToObjCTypedef) const { 5104 CanQualType CT = getCanonicalType(T); 5105 switch (CT->getTypeClass()) { 5106 case Type::Builtin: 5107 case Type::Enum: 5108 if (FD && FD->isBitField()) 5109 return EncodeBitField(this, S, T, FD); 5110 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CT)) 5111 S += getObjCEncodingForPrimitiveKind(this, BT->getKind()); 5112 else 5113 S += ObjCEncodingForEnumType(this, cast<EnumType>(CT)); 5114 return; 5115 5116 case Type::Complex: { 5117 const ComplexType *CT = T->castAs<ComplexType>(); 5118 S += 'j'; 5119 getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false, 5120 false); 5121 return; 5122 } 5123 5124 case Type::Atomic: { 5125 const AtomicType *AT = T->castAs<AtomicType>(); 5126 S += 'A'; 5127 getObjCEncodingForTypeImpl(AT->getValueType(), S, false, false, 0, 5128 false, false); 5129 return; 5130 } 5131 5132 // encoding for pointer or reference types. 5133 case Type::Pointer: 5134 case Type::LValueReference: 5135 case Type::RValueReference: { 5136 QualType PointeeTy; 5137 if (isa<PointerType>(CT)) { 5138 const PointerType *PT = T->castAs<PointerType>(); 5139 if (PT->isObjCSelType()) { 5140 S += ':'; 5141 return; 5142 } 5143 PointeeTy = PT->getPointeeType(); 5144 } else { 5145 PointeeTy = T->castAs<ReferenceType>()->getPointeeType(); 5146 } 5147 5148 bool isReadOnly = false; 5149 // For historical/compatibility reasons, the read-only qualifier of the 5150 // pointee gets emitted _before_ the '^'. The read-only qualifier of 5151 // the pointer itself gets ignored, _unless_ we are looking at a typedef! 5152 // Also, do not emit the 'r' for anything but the outermost type! 5153 if (isa<TypedefType>(T.getTypePtr())) { 5154 if (OutermostType && T.isConstQualified()) { 5155 isReadOnly = true; 5156 S += 'r'; 5157 } 5158 } else if (OutermostType) { 5159 QualType P = PointeeTy; 5160 while (P->getAs<PointerType>()) 5161 P = P->getAs<PointerType>()->getPointeeType(); 5162 if (P.isConstQualified()) { 5163 isReadOnly = true; 5164 S += 'r'; 5165 } 5166 } 5167 if (isReadOnly) { 5168 // Another legacy compatibility encoding. Some ObjC qualifier and type 5169 // combinations need to be rearranged. 5170 // Rewrite "in const" from "nr" to "rn" 5171 if (StringRef(S).endswith("nr")) 5172 S.replace(S.end()-2, S.end(), "rn"); 5173 } 5174 5175 if (PointeeTy->isCharType()) { 5176 // char pointer types should be encoded as '*' unless it is a 5177 // type that has been typedef'd to 'BOOL'. 5178 if (!isTypeTypedefedAsBOOL(PointeeTy)) { 5179 S += '*'; 5180 return; 5181 } 5182 } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) { 5183 // GCC binary compat: Need to convert "struct objc_class *" to "#". 5184 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) { 5185 S += '#'; 5186 return; 5187 } 5188 // GCC binary compat: Need to convert "struct objc_object *" to "@". 5189 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) { 5190 S += '@'; 5191 return; 5192 } 5193 // fall through... 5194 } 5195 S += '^'; 5196 getLegacyIntegralTypeEncoding(PointeeTy); 5197 5198 getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures, 5199 NULL); 5200 return; 5201 } 5202 5203 case Type::ConstantArray: 5204 case Type::IncompleteArray: 5205 case Type::VariableArray: { 5206 const ArrayType *AT = cast<ArrayType>(CT); 5207 5208 if (isa<IncompleteArrayType>(AT) && !StructField) { 5209 // Incomplete arrays are encoded as a pointer to the array element. 5210 S += '^'; 5211 5212 getObjCEncodingForTypeImpl(AT->getElementType(), S, 5213 false, ExpandStructures, FD); 5214 } else { 5215 S += '['; 5216 5217 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { 5218 if (getTypeSize(CAT->getElementType()) == 0) 5219 S += '0'; 5220 else 5221 S += llvm::utostr(CAT->getSize().getZExtValue()); 5222 } else { 5223 //Variable length arrays are encoded as a regular array with 0 elements. 5224 assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && 5225 "Unknown array type!"); 5226 S += '0'; 5227 } 5228 5229 getObjCEncodingForTypeImpl(AT->getElementType(), S, 5230 false, ExpandStructures, FD); 5231 S += ']'; 5232 } 5233 return; 5234 } 5235 5236 case Type::FunctionNoProto: 5237 case Type::FunctionProto: 5238 S += '?'; 5239 return; 5240 5241 case Type::Record: { 5242 RecordDecl *RDecl = cast<RecordType>(CT)->getDecl(); 5243 S += RDecl->isUnion() ? '(' : '{'; 5244 // Anonymous structures print as '?' 5245 if (const IdentifierInfo *II = RDecl->getIdentifier()) { 5246 S += II->getName(); 5247 if (ClassTemplateSpecializationDecl *Spec 5248 = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) { 5249 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 5250 llvm::raw_string_ostream OS(S); 5251 TemplateSpecializationType::PrintTemplateArgumentList(OS, 5252 TemplateArgs.data(), 5253 TemplateArgs.size(), 5254 (*this).getPrintingPolicy()); 5255 } 5256 } else { 5257 S += '?'; 5258 } 5259 if (ExpandStructures) { 5260 S += '='; 5261 if (!RDecl->isUnion()) { 5262 getObjCEncodingForStructureImpl(RDecl, S, FD); 5263 } else { 5264 for (RecordDecl::field_iterator Field = RDecl->field_begin(), 5265 FieldEnd = RDecl->field_end(); 5266 Field != FieldEnd; ++Field) { 5267 if (FD) { 5268 S += '"'; 5269 S += Field->getNameAsString(); 5270 S += '"'; 5271 } 5272 5273 // Special case bit-fields. 5274 if (Field->isBitField()) { 5275 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, 5276 *Field); 5277 } else { 5278 QualType qt = Field->getType(); 5279 getLegacyIntegralTypeEncoding(qt); 5280 getObjCEncodingForTypeImpl(qt, S, false, true, 5281 FD, /*OutermostType*/false, 5282 /*EncodingProperty*/false, 5283 /*StructField*/true); 5284 } 5285 } 5286 } 5287 } 5288 S += RDecl->isUnion() ? ')' : '}'; 5289 return; 5290 } 5291 5292 case Type::BlockPointer: { 5293 const BlockPointerType *BT = T->castAs<BlockPointerType>(); 5294 S += "@?"; // Unlike a pointer-to-function, which is "^?". 5295 if (EncodeBlockParameters) { 5296 const FunctionType *FT = BT->getPointeeType()->castAs<FunctionType>(); 5297 5298 S += '<'; 5299 // Block return type 5300 getObjCEncodingForTypeImpl(FT->getResultType(), S, 5301 ExpandPointedToStructures, ExpandStructures, 5302 FD, 5303 false /* OutermostType */, 5304 EncodingProperty, 5305 false /* StructField */, 5306 EncodeBlockParameters, 5307 EncodeClassNames); 5308 // Block self 5309 S += "@?"; 5310 // Block parameters 5311 if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT)) { 5312 for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(), 5313 E = FPT->arg_type_end(); I && (I != E); ++I) { 5314 getObjCEncodingForTypeImpl(*I, S, 5315 ExpandPointedToStructures, 5316 ExpandStructures, 5317 FD, 5318 false /* OutermostType */, 5319 EncodingProperty, 5320 false /* StructField */, 5321 EncodeBlockParameters, 5322 EncodeClassNames); 5323 } 5324 } 5325 S += '>'; 5326 } 5327 return; 5328 } 5329 5330 case Type::ObjCObject: 5331 case Type::ObjCInterface: { 5332 // Ignore protocol qualifiers when mangling at this level. 5333 T = T->castAs<ObjCObjectType>()->getBaseType(); 5334 5335 // The assumption seems to be that this assert will succeed 5336 // because nested levels will have filtered out 'id' and 'Class'. 5337 const ObjCInterfaceType *OIT = T->castAs<ObjCInterfaceType>(); 5338 // @encode(class_name) 5339 ObjCInterfaceDecl *OI = OIT->getDecl(); 5340 S += '{'; 5341 const IdentifierInfo *II = OI->getIdentifier(); 5342 S += II->getName(); 5343 S += '='; 5344 SmallVector<const ObjCIvarDecl*, 32> Ivars; 5345 DeepCollectObjCIvars(OI, true, Ivars); 5346 for (unsigned i = 0, e = Ivars.size(); i != e; ++i) { 5347 const FieldDecl *Field = cast<FieldDecl>(Ivars[i]); 5348 if (Field->isBitField()) 5349 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field); 5350 else 5351 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD, 5352 false, false, false, false, false, 5353 EncodePointerToObjCTypedef); 5354 } 5355 S += '}'; 5356 return; 5357 } 5358 5359 case Type::ObjCObjectPointer: { 5360 const ObjCObjectPointerType *OPT = T->castAs<ObjCObjectPointerType>(); 5361 if (OPT->isObjCIdType()) { 5362 S += '@'; 5363 return; 5364 } 5365 5366 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) { 5367 // FIXME: Consider if we need to output qualifiers for 'Class<p>'. 5368 // Since this is a binary compatibility issue, need to consult with runtime 5369 // folks. Fortunately, this is a *very* obsure construct. 5370 S += '#'; 5371 return; 5372 } 5373 5374 if (OPT->isObjCQualifiedIdType()) { 5375 getObjCEncodingForTypeImpl(getObjCIdType(), S, 5376 ExpandPointedToStructures, 5377 ExpandStructures, FD); 5378 if (FD || EncodingProperty || EncodeClassNames) { 5379 // Note that we do extended encoding of protocol qualifer list 5380 // Only when doing ivar or property encoding. 5381 S += '"'; 5382 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 5383 E = OPT->qual_end(); I != E; ++I) { 5384 S += '<'; 5385 S += (*I)->getNameAsString(); 5386 S += '>'; 5387 } 5388 S += '"'; 5389 } 5390 return; 5391 } 5392 5393 QualType PointeeTy = OPT->getPointeeType(); 5394 if (!EncodingProperty && 5395 isa<TypedefType>(PointeeTy.getTypePtr()) && 5396 !EncodePointerToObjCTypedef) { 5397 // Another historical/compatibility reason. 5398 // We encode the underlying type which comes out as 5399 // {...}; 5400 S += '^'; 5401 getObjCEncodingForTypeImpl(PointeeTy, S, 5402 false, ExpandPointedToStructures, 5403 NULL, 5404 false, false, false, false, false, 5405 /*EncodePointerToObjCTypedef*/true); 5406 return; 5407 } 5408 5409 S += '@'; 5410 if (OPT->getInterfaceDecl() && 5411 (FD || EncodingProperty || EncodeClassNames)) { 5412 S += '"'; 5413 S += OPT->getInterfaceDecl()->getIdentifier()->getName(); 5414 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(), 5415 E = OPT->qual_end(); I != E; ++I) { 5416 S += '<'; 5417 S += (*I)->getNameAsString(); 5418 S += '>'; 5419 } 5420 S += '"'; 5421 } 5422 return; 5423 } 5424 5425 // gcc just blithely ignores member pointers. 5426 // FIXME: we shoul do better than that. 'M' is available. 5427 case Type::MemberPointer: 5428 return; 5429 5430 case Type::Vector: 5431 case Type::ExtVector: 5432 // This matches gcc's encoding, even though technically it is 5433 // insufficient. 5434 // FIXME. We should do a better job than gcc. 5435 return; 5436 5437 case Type::Auto: 5438 // We could see an undeduced auto type here during error recovery. 5439 // Just ignore it. 5440 return; 5441 5442#define ABSTRACT_TYPE(KIND, BASE) 5443#define TYPE(KIND, BASE) 5444#define DEPENDENT_TYPE(KIND, BASE) \ 5445 case Type::KIND: 5446#define NON_CANONICAL_TYPE(KIND, BASE) \ 5447 case Type::KIND: 5448#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \ 5449 case Type::KIND: 5450#include "clang/AST/TypeNodes.def" 5451 llvm_unreachable("@encode for dependent type!"); 5452 } 5453 llvm_unreachable("bad type kind!"); 5454} 5455 5456void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl, 5457 std::string &S, 5458 const FieldDecl *FD, 5459 bool includeVBases) const { 5460 assert(RDecl && "Expected non-null RecordDecl"); 5461 assert(!RDecl->isUnion() && "Should not be called for unions"); 5462 if (!RDecl->getDefinition()) 5463 return; 5464 5465 CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(RDecl); 5466 std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets; 5467 const ASTRecordLayout &layout = getASTRecordLayout(RDecl); 5468 5469 if (CXXRec) { 5470 for (CXXRecordDecl::base_class_iterator 5471 BI = CXXRec->bases_begin(), 5472 BE = CXXRec->bases_end(); BI != BE; ++BI) { 5473 if (!BI->isVirtual()) { 5474 CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 5475 if (base->isEmpty()) 5476 continue; 5477 uint64_t offs = toBits(layout.getBaseClassOffset(base)); 5478 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 5479 std::make_pair(offs, base)); 5480 } 5481 } 5482 } 5483 5484 unsigned i = 0; 5485 for (RecordDecl::field_iterator Field = RDecl->field_begin(), 5486 FieldEnd = RDecl->field_end(); 5487 Field != FieldEnd; ++Field, ++i) { 5488 uint64_t offs = layout.getFieldOffset(i); 5489 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 5490 std::make_pair(offs, *Field)); 5491 } 5492 5493 if (CXXRec && includeVBases) { 5494 for (CXXRecordDecl::base_class_iterator 5495 BI = CXXRec->vbases_begin(), 5496 BE = CXXRec->vbases_end(); BI != BE; ++BI) { 5497 CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl(); 5498 if (base->isEmpty()) 5499 continue; 5500 uint64_t offs = toBits(layout.getVBaseClassOffset(base)); 5501 if (FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end()) 5502 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(), 5503 std::make_pair(offs, base)); 5504 } 5505 } 5506 5507 CharUnits size; 5508 if (CXXRec) { 5509 size = includeVBases ? layout.getSize() : layout.getNonVirtualSize(); 5510 } else { 5511 size = layout.getSize(); 5512 } 5513 5514 uint64_t CurOffs = 0; 5515 std::multimap<uint64_t, NamedDecl *>::iterator 5516 CurLayObj = FieldOrBaseOffsets.begin(); 5517 5518 if (CXXRec && CXXRec->isDynamicClass() && 5519 (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) { 5520 if (FD) { 5521 S += "\"_vptr$"; 5522 std::string recname = CXXRec->getNameAsString(); 5523 if (recname.empty()) recname = "?"; 5524 S += recname; 5525 S += '"'; 5526 } 5527 S += "^^?"; 5528 CurOffs += getTypeSize(VoidPtrTy); 5529 } 5530 5531 if (!RDecl->hasFlexibleArrayMember()) { 5532 // Mark the end of the structure. 5533 uint64_t offs = toBits(size); 5534 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs), 5535 std::make_pair(offs, (NamedDecl*)0)); 5536 } 5537 5538 for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) { 5539 assert(CurOffs <= CurLayObj->first); 5540 5541 if (CurOffs < CurLayObj->first) { 5542 uint64_t padding = CurLayObj->first - CurOffs; 5543 // FIXME: There doesn't seem to be a way to indicate in the encoding that 5544 // packing/alignment of members is different that normal, in which case 5545 // the encoding will be out-of-sync with the real layout. 5546 // If the runtime switches to just consider the size of types without 5547 // taking into account alignment, we could make padding explicit in the 5548 // encoding (e.g. using arrays of chars). The encoding strings would be 5549 // longer then though. 5550 CurOffs += padding; 5551 } 5552 5553 NamedDecl *dcl = CurLayObj->second; 5554 if (dcl == 0) 5555 break; // reached end of structure. 5556 5557 if (CXXRecordDecl *base = dyn_cast<CXXRecordDecl>(dcl)) { 5558 // We expand the bases without their virtual bases since those are going 5559 // in the initial structure. Note that this differs from gcc which 5560 // expands virtual bases each time one is encountered in the hierarchy, 5561 // making the encoding type bigger than it really is. 5562 getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false); 5563 assert(!base->isEmpty()); 5564 CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize()); 5565 } else { 5566 FieldDecl *field = cast<FieldDecl>(dcl); 5567 if (FD) { 5568 S += '"'; 5569 S += field->getNameAsString(); 5570 S += '"'; 5571 } 5572 5573 if (field->isBitField()) { 5574 EncodeBitField(this, S, field->getType(), field); 5575 CurOffs += field->getBitWidthValue(*this); 5576 } else { 5577 QualType qt = field->getType(); 5578 getLegacyIntegralTypeEncoding(qt); 5579 getObjCEncodingForTypeImpl(qt, S, false, true, FD, 5580 /*OutermostType*/false, 5581 /*EncodingProperty*/false, 5582 /*StructField*/true); 5583 CurOffs += getTypeSize(field->getType()); 5584 } 5585 } 5586 } 5587} 5588 5589void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, 5590 std::string& S) const { 5591 if (QT & Decl::OBJC_TQ_In) 5592 S += 'n'; 5593 if (QT & Decl::OBJC_TQ_Inout) 5594 S += 'N'; 5595 if (QT & Decl::OBJC_TQ_Out) 5596 S += 'o'; 5597 if (QT & Decl::OBJC_TQ_Bycopy) 5598 S += 'O'; 5599 if (QT & Decl::OBJC_TQ_Byref) 5600 S += 'R'; 5601 if (QT & Decl::OBJC_TQ_Oneway) 5602 S += 'V'; 5603} 5604 5605TypedefDecl *ASTContext::getObjCIdDecl() const { 5606 if (!ObjCIdDecl) { 5607 QualType T = getObjCObjectType(ObjCBuiltinIdTy, 0, 0); 5608 T = getObjCObjectPointerType(T); 5609 TypeSourceInfo *IdInfo = getTrivialTypeSourceInfo(T); 5610 ObjCIdDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 5611 getTranslationUnitDecl(), 5612 SourceLocation(), SourceLocation(), 5613 &Idents.get("id"), IdInfo); 5614 } 5615 5616 return ObjCIdDecl; 5617} 5618 5619TypedefDecl *ASTContext::getObjCSelDecl() const { 5620 if (!ObjCSelDecl) { 5621 QualType SelT = getPointerType(ObjCBuiltinSelTy); 5622 TypeSourceInfo *SelInfo = getTrivialTypeSourceInfo(SelT); 5623 ObjCSelDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 5624 getTranslationUnitDecl(), 5625 SourceLocation(), SourceLocation(), 5626 &Idents.get("SEL"), SelInfo); 5627 } 5628 return ObjCSelDecl; 5629} 5630 5631TypedefDecl *ASTContext::getObjCClassDecl() const { 5632 if (!ObjCClassDecl) { 5633 QualType T = getObjCObjectType(ObjCBuiltinClassTy, 0, 0); 5634 T = getObjCObjectPointerType(T); 5635 TypeSourceInfo *ClassInfo = getTrivialTypeSourceInfo(T); 5636 ObjCClassDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this), 5637 getTranslationUnitDecl(), 5638 SourceLocation(), SourceLocation(), 5639 &Idents.get("Class"), ClassInfo); 5640 } 5641 5642 return ObjCClassDecl; 5643} 5644 5645ObjCInterfaceDecl *ASTContext::getObjCProtocolDecl() const { 5646 if (!ObjCProtocolClassDecl) { 5647 ObjCProtocolClassDecl 5648 = ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(), 5649 SourceLocation(), 5650 &Idents.get("Protocol"), 5651 /*PrevDecl=*/0, 5652 SourceLocation(), true); 5653 } 5654 5655 return ObjCProtocolClassDecl; 5656} 5657 5658//===----------------------------------------------------------------------===// 5659// __builtin_va_list Construction Functions 5660//===----------------------------------------------------------------------===// 5661 5662static TypedefDecl *CreateCharPtrBuiltinVaListDecl(const ASTContext *Context) { 5663 // typedef char* __builtin_va_list; 5664 QualType CharPtrType = Context->getPointerType(Context->CharTy); 5665 TypeSourceInfo *TInfo 5666 = Context->getTrivialTypeSourceInfo(CharPtrType); 5667 5668 TypedefDecl *VaListTypeDecl 5669 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5670 Context->getTranslationUnitDecl(), 5671 SourceLocation(), SourceLocation(), 5672 &Context->Idents.get("__builtin_va_list"), 5673 TInfo); 5674 return VaListTypeDecl; 5675} 5676 5677static TypedefDecl *CreateVoidPtrBuiltinVaListDecl(const ASTContext *Context) { 5678 // typedef void* __builtin_va_list; 5679 QualType VoidPtrType = Context->getPointerType(Context->VoidTy); 5680 TypeSourceInfo *TInfo 5681 = Context->getTrivialTypeSourceInfo(VoidPtrType); 5682 5683 TypedefDecl *VaListTypeDecl 5684 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5685 Context->getTranslationUnitDecl(), 5686 SourceLocation(), SourceLocation(), 5687 &Context->Idents.get("__builtin_va_list"), 5688 TInfo); 5689 return VaListTypeDecl; 5690} 5691 5692static TypedefDecl * 5693CreateAArch64ABIBuiltinVaListDecl(const ASTContext *Context) { 5694 RecordDecl *VaListTagDecl; 5695 if (Context->getLangOpts().CPlusPlus) { 5696 // namespace std { struct __va_list { 5697 NamespaceDecl *NS; 5698 NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context), 5699 Context->getTranslationUnitDecl(), 5700 /*Inline*/false, SourceLocation(), 5701 SourceLocation(), &Context->Idents.get("std"), 5702 /*PrevDecl*/0); 5703 5704 VaListTagDecl = CXXRecordDecl::Create(*Context, TTK_Struct, 5705 Context->getTranslationUnitDecl(), 5706 SourceLocation(), SourceLocation(), 5707 &Context->Idents.get("__va_list")); 5708 VaListTagDecl->setDeclContext(NS); 5709 } else { 5710 // struct __va_list 5711 VaListTagDecl = CreateRecordDecl(*Context, TTK_Struct, 5712 Context->getTranslationUnitDecl(), 5713 &Context->Idents.get("__va_list")); 5714 } 5715 5716 VaListTagDecl->startDefinition(); 5717 5718 const size_t NumFields = 5; 5719 QualType FieldTypes[NumFields]; 5720 const char *FieldNames[NumFields]; 5721 5722 // void *__stack; 5723 FieldTypes[0] = Context->getPointerType(Context->VoidTy); 5724 FieldNames[0] = "__stack"; 5725 5726 // void *__gr_top; 5727 FieldTypes[1] = Context->getPointerType(Context->VoidTy); 5728 FieldNames[1] = "__gr_top"; 5729 5730 // void *__vr_top; 5731 FieldTypes[2] = Context->getPointerType(Context->VoidTy); 5732 FieldNames[2] = "__vr_top"; 5733 5734 // int __gr_offs; 5735 FieldTypes[3] = Context->IntTy; 5736 FieldNames[3] = "__gr_offs"; 5737 5738 // int __vr_offs; 5739 FieldTypes[4] = Context->IntTy; 5740 FieldNames[4] = "__vr_offs"; 5741 5742 // Create fields 5743 for (unsigned i = 0; i < NumFields; ++i) { 5744 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context), 5745 VaListTagDecl, 5746 SourceLocation(), 5747 SourceLocation(), 5748 &Context->Idents.get(FieldNames[i]), 5749 FieldTypes[i], /*TInfo=*/0, 5750 /*BitWidth=*/0, 5751 /*Mutable=*/false, 5752 ICIS_NoInit); 5753 Field->setAccess(AS_public); 5754 VaListTagDecl->addDecl(Field); 5755 } 5756 VaListTagDecl->completeDefinition(); 5757 QualType VaListTagType = Context->getRecordType(VaListTagDecl); 5758 Context->VaListTagTy = VaListTagType; 5759 5760 // } __builtin_va_list; 5761 TypedefDecl *VaListTypedefDecl 5762 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5763 Context->getTranslationUnitDecl(), 5764 SourceLocation(), SourceLocation(), 5765 &Context->Idents.get("__builtin_va_list"), 5766 Context->getTrivialTypeSourceInfo(VaListTagType)); 5767 5768 return VaListTypedefDecl; 5769} 5770 5771static TypedefDecl *CreatePowerABIBuiltinVaListDecl(const ASTContext *Context) { 5772 // typedef struct __va_list_tag { 5773 RecordDecl *VaListTagDecl; 5774 5775 VaListTagDecl = CreateRecordDecl(*Context, TTK_Struct, 5776 Context->getTranslationUnitDecl(), 5777 &Context->Idents.get("__va_list_tag")); 5778 VaListTagDecl->startDefinition(); 5779 5780 const size_t NumFields = 5; 5781 QualType FieldTypes[NumFields]; 5782 const char *FieldNames[NumFields]; 5783 5784 // unsigned char gpr; 5785 FieldTypes[0] = Context->UnsignedCharTy; 5786 FieldNames[0] = "gpr"; 5787 5788 // unsigned char fpr; 5789 FieldTypes[1] = Context->UnsignedCharTy; 5790 FieldNames[1] = "fpr"; 5791 5792 // unsigned short reserved; 5793 FieldTypes[2] = Context->UnsignedShortTy; 5794 FieldNames[2] = "reserved"; 5795 5796 // void* overflow_arg_area; 5797 FieldTypes[3] = Context->getPointerType(Context->VoidTy); 5798 FieldNames[3] = "overflow_arg_area"; 5799 5800 // void* reg_save_area; 5801 FieldTypes[4] = Context->getPointerType(Context->VoidTy); 5802 FieldNames[4] = "reg_save_area"; 5803 5804 // Create fields 5805 for (unsigned i = 0; i < NumFields; ++i) { 5806 FieldDecl *Field = FieldDecl::Create(*Context, VaListTagDecl, 5807 SourceLocation(), 5808 SourceLocation(), 5809 &Context->Idents.get(FieldNames[i]), 5810 FieldTypes[i], /*TInfo=*/0, 5811 /*BitWidth=*/0, 5812 /*Mutable=*/false, 5813 ICIS_NoInit); 5814 Field->setAccess(AS_public); 5815 VaListTagDecl->addDecl(Field); 5816 } 5817 VaListTagDecl->completeDefinition(); 5818 QualType VaListTagType = Context->getRecordType(VaListTagDecl); 5819 Context->VaListTagTy = VaListTagType; 5820 5821 // } __va_list_tag; 5822 TypedefDecl *VaListTagTypedefDecl 5823 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5824 Context->getTranslationUnitDecl(), 5825 SourceLocation(), SourceLocation(), 5826 &Context->Idents.get("__va_list_tag"), 5827 Context->getTrivialTypeSourceInfo(VaListTagType)); 5828 QualType VaListTagTypedefType = 5829 Context->getTypedefType(VaListTagTypedefDecl); 5830 5831 // typedef __va_list_tag __builtin_va_list[1]; 5832 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1); 5833 QualType VaListTagArrayType 5834 = Context->getConstantArrayType(VaListTagTypedefType, 5835 Size, ArrayType::Normal, 0); 5836 TypeSourceInfo *TInfo 5837 = Context->getTrivialTypeSourceInfo(VaListTagArrayType); 5838 TypedefDecl *VaListTypedefDecl 5839 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5840 Context->getTranslationUnitDecl(), 5841 SourceLocation(), SourceLocation(), 5842 &Context->Idents.get("__builtin_va_list"), 5843 TInfo); 5844 5845 return VaListTypedefDecl; 5846} 5847 5848static TypedefDecl * 5849CreateX86_64ABIBuiltinVaListDecl(const ASTContext *Context) { 5850 // typedef struct __va_list_tag { 5851 RecordDecl *VaListTagDecl; 5852 VaListTagDecl = CreateRecordDecl(*Context, TTK_Struct, 5853 Context->getTranslationUnitDecl(), 5854 &Context->Idents.get("__va_list_tag")); 5855 VaListTagDecl->startDefinition(); 5856 5857 const size_t NumFields = 4; 5858 QualType FieldTypes[NumFields]; 5859 const char *FieldNames[NumFields]; 5860 5861 // unsigned gp_offset; 5862 FieldTypes[0] = Context->UnsignedIntTy; 5863 FieldNames[0] = "gp_offset"; 5864 5865 // unsigned fp_offset; 5866 FieldTypes[1] = Context->UnsignedIntTy; 5867 FieldNames[1] = "fp_offset"; 5868 5869 // void* overflow_arg_area; 5870 FieldTypes[2] = Context->getPointerType(Context->VoidTy); 5871 FieldNames[2] = "overflow_arg_area"; 5872 5873 // void* reg_save_area; 5874 FieldTypes[3] = Context->getPointerType(Context->VoidTy); 5875 FieldNames[3] = "reg_save_area"; 5876 5877 // Create fields 5878 for (unsigned i = 0; i < NumFields; ++i) { 5879 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context), 5880 VaListTagDecl, 5881 SourceLocation(), 5882 SourceLocation(), 5883 &Context->Idents.get(FieldNames[i]), 5884 FieldTypes[i], /*TInfo=*/0, 5885 /*BitWidth=*/0, 5886 /*Mutable=*/false, 5887 ICIS_NoInit); 5888 Field->setAccess(AS_public); 5889 VaListTagDecl->addDecl(Field); 5890 } 5891 VaListTagDecl->completeDefinition(); 5892 QualType VaListTagType = Context->getRecordType(VaListTagDecl); 5893 Context->VaListTagTy = VaListTagType; 5894 5895 // } __va_list_tag; 5896 TypedefDecl *VaListTagTypedefDecl 5897 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5898 Context->getTranslationUnitDecl(), 5899 SourceLocation(), SourceLocation(), 5900 &Context->Idents.get("__va_list_tag"), 5901 Context->getTrivialTypeSourceInfo(VaListTagType)); 5902 QualType VaListTagTypedefType = 5903 Context->getTypedefType(VaListTagTypedefDecl); 5904 5905 // typedef __va_list_tag __builtin_va_list[1]; 5906 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1); 5907 QualType VaListTagArrayType 5908 = Context->getConstantArrayType(VaListTagTypedefType, 5909 Size, ArrayType::Normal,0); 5910 TypeSourceInfo *TInfo 5911 = Context->getTrivialTypeSourceInfo(VaListTagArrayType); 5912 TypedefDecl *VaListTypedefDecl 5913 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5914 Context->getTranslationUnitDecl(), 5915 SourceLocation(), SourceLocation(), 5916 &Context->Idents.get("__builtin_va_list"), 5917 TInfo); 5918 5919 return VaListTypedefDecl; 5920} 5921 5922static TypedefDecl *CreatePNaClABIBuiltinVaListDecl(const ASTContext *Context) { 5923 // typedef int __builtin_va_list[4]; 5924 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 4); 5925 QualType IntArrayType 5926 = Context->getConstantArrayType(Context->IntTy, 5927 Size, ArrayType::Normal, 0); 5928 TypedefDecl *VaListTypedefDecl 5929 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5930 Context->getTranslationUnitDecl(), 5931 SourceLocation(), SourceLocation(), 5932 &Context->Idents.get("__builtin_va_list"), 5933 Context->getTrivialTypeSourceInfo(IntArrayType)); 5934 5935 return VaListTypedefDecl; 5936} 5937 5938static TypedefDecl * 5939CreateAAPCSABIBuiltinVaListDecl(const ASTContext *Context) { 5940 RecordDecl *VaListDecl; 5941 if (Context->getLangOpts().CPlusPlus) { 5942 // namespace std { struct __va_list { 5943 NamespaceDecl *NS; 5944 NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context), 5945 Context->getTranslationUnitDecl(), 5946 /*Inline*/false, SourceLocation(), 5947 SourceLocation(), &Context->Idents.get("std"), 5948 /*PrevDecl*/0); 5949 5950 VaListDecl = CXXRecordDecl::Create(*Context, TTK_Struct, 5951 Context->getTranslationUnitDecl(), 5952 SourceLocation(), SourceLocation(), 5953 &Context->Idents.get("__va_list")); 5954 5955 VaListDecl->setDeclContext(NS); 5956 5957 } else { 5958 // struct __va_list { 5959 VaListDecl = CreateRecordDecl(*Context, TTK_Struct, 5960 Context->getTranslationUnitDecl(), 5961 &Context->Idents.get("__va_list")); 5962 } 5963 5964 VaListDecl->startDefinition(); 5965 5966 // void * __ap; 5967 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context), 5968 VaListDecl, 5969 SourceLocation(), 5970 SourceLocation(), 5971 &Context->Idents.get("__ap"), 5972 Context->getPointerType(Context->VoidTy), 5973 /*TInfo=*/0, 5974 /*BitWidth=*/0, 5975 /*Mutable=*/false, 5976 ICIS_NoInit); 5977 Field->setAccess(AS_public); 5978 VaListDecl->addDecl(Field); 5979 5980 // }; 5981 VaListDecl->completeDefinition(); 5982 5983 // typedef struct __va_list __builtin_va_list; 5984 TypeSourceInfo *TInfo 5985 = Context->getTrivialTypeSourceInfo(Context->getRecordType(VaListDecl)); 5986 5987 TypedefDecl *VaListTypeDecl 5988 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 5989 Context->getTranslationUnitDecl(), 5990 SourceLocation(), SourceLocation(), 5991 &Context->Idents.get("__builtin_va_list"), 5992 TInfo); 5993 5994 return VaListTypeDecl; 5995} 5996 5997static TypedefDecl * 5998CreateSystemZBuiltinVaListDecl(const ASTContext *Context) { 5999 // typedef struct __va_list_tag { 6000 RecordDecl *VaListTagDecl; 6001 VaListTagDecl = CreateRecordDecl(*Context, TTK_Struct, 6002 Context->getTranslationUnitDecl(), 6003 &Context->Idents.get("__va_list_tag")); 6004 VaListTagDecl->startDefinition(); 6005 6006 const size_t NumFields = 4; 6007 QualType FieldTypes[NumFields]; 6008 const char *FieldNames[NumFields]; 6009 6010 // long __gpr; 6011 FieldTypes[0] = Context->LongTy; 6012 FieldNames[0] = "__gpr"; 6013 6014 // long __fpr; 6015 FieldTypes[1] = Context->LongTy; 6016 FieldNames[1] = "__fpr"; 6017 6018 // void *__overflow_arg_area; 6019 FieldTypes[2] = Context->getPointerType(Context->VoidTy); 6020 FieldNames[2] = "__overflow_arg_area"; 6021 6022 // void *__reg_save_area; 6023 FieldTypes[3] = Context->getPointerType(Context->VoidTy); 6024 FieldNames[3] = "__reg_save_area"; 6025 6026 // Create fields 6027 for (unsigned i = 0; i < NumFields; ++i) { 6028 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context), 6029 VaListTagDecl, 6030 SourceLocation(), 6031 SourceLocation(), 6032 &Context->Idents.get(FieldNames[i]), 6033 FieldTypes[i], /*TInfo=*/0, 6034 /*BitWidth=*/0, 6035 /*Mutable=*/false, 6036 ICIS_NoInit); 6037 Field->setAccess(AS_public); 6038 VaListTagDecl->addDecl(Field); 6039 } 6040 VaListTagDecl->completeDefinition(); 6041 QualType VaListTagType = Context->getRecordType(VaListTagDecl); 6042 Context->VaListTagTy = VaListTagType; 6043 6044 // } __va_list_tag; 6045 TypedefDecl *VaListTagTypedefDecl 6046 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 6047 Context->getTranslationUnitDecl(), 6048 SourceLocation(), SourceLocation(), 6049 &Context->Idents.get("__va_list_tag"), 6050 Context->getTrivialTypeSourceInfo(VaListTagType)); 6051 QualType VaListTagTypedefType = 6052 Context->getTypedefType(VaListTagTypedefDecl); 6053 6054 // typedef __va_list_tag __builtin_va_list[1]; 6055 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1); 6056 QualType VaListTagArrayType 6057 = Context->getConstantArrayType(VaListTagTypedefType, 6058 Size, ArrayType::Normal,0); 6059 TypeSourceInfo *TInfo 6060 = Context->getTrivialTypeSourceInfo(VaListTagArrayType); 6061 TypedefDecl *VaListTypedefDecl 6062 = TypedefDecl::Create(const_cast<ASTContext &>(*Context), 6063 Context->getTranslationUnitDecl(), 6064 SourceLocation(), SourceLocation(), 6065 &Context->Idents.get("__builtin_va_list"), 6066 TInfo); 6067 6068 return VaListTypedefDecl; 6069} 6070 6071static TypedefDecl *CreateVaListDecl(const ASTContext *Context, 6072 TargetInfo::BuiltinVaListKind Kind) { 6073 switch (Kind) { 6074 case TargetInfo::CharPtrBuiltinVaList: 6075 return CreateCharPtrBuiltinVaListDecl(Context); 6076 case TargetInfo::VoidPtrBuiltinVaList: 6077 return CreateVoidPtrBuiltinVaListDecl(Context); 6078 case TargetInfo::AArch64ABIBuiltinVaList: 6079 return CreateAArch64ABIBuiltinVaListDecl(Context); 6080 case TargetInfo::PowerABIBuiltinVaList: 6081 return CreatePowerABIBuiltinVaListDecl(Context); 6082 case TargetInfo::X86_64ABIBuiltinVaList: 6083 return CreateX86_64ABIBuiltinVaListDecl(Context); 6084 case TargetInfo::PNaClABIBuiltinVaList: 6085 return CreatePNaClABIBuiltinVaListDecl(Context); 6086 case TargetInfo::AAPCSABIBuiltinVaList: 6087 return CreateAAPCSABIBuiltinVaListDecl(Context); 6088 case TargetInfo::SystemZBuiltinVaList: 6089 return CreateSystemZBuiltinVaListDecl(Context); 6090 } 6091 6092 llvm_unreachable("Unhandled __builtin_va_list type kind"); 6093} 6094 6095TypedefDecl *ASTContext::getBuiltinVaListDecl() const { 6096 if (!BuiltinVaListDecl) 6097 BuiltinVaListDecl = CreateVaListDecl(this, Target->getBuiltinVaListKind()); 6098 6099 return BuiltinVaListDecl; 6100} 6101 6102QualType ASTContext::getVaListTagType() const { 6103 // Force the creation of VaListTagTy by building the __builtin_va_list 6104 // declaration. 6105 if (VaListTagTy.isNull()) 6106 (void) getBuiltinVaListDecl(); 6107 6108 return VaListTagTy; 6109} 6110 6111void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) { 6112 assert(ObjCConstantStringType.isNull() && 6113 "'NSConstantString' type already set!"); 6114 6115 ObjCConstantStringType = getObjCInterfaceType(Decl); 6116} 6117 6118/// \brief Retrieve the template name that corresponds to a non-empty 6119/// lookup. 6120TemplateName 6121ASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin, 6122 UnresolvedSetIterator End) const { 6123 unsigned size = End - Begin; 6124 assert(size > 1 && "set is not overloaded!"); 6125 6126 void *memory = Allocate(sizeof(OverloadedTemplateStorage) + 6127 size * sizeof(FunctionTemplateDecl*)); 6128 OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size); 6129 6130 NamedDecl **Storage = OT->getStorage(); 6131 for (UnresolvedSetIterator I = Begin; I != End; ++I) { 6132 NamedDecl *D = *I; 6133 assert(isa<FunctionTemplateDecl>(D) || 6134 (isa<UsingShadowDecl>(D) && 6135 isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))); 6136 *Storage++ = D; 6137 } 6138 6139 return TemplateName(OT); 6140} 6141 6142/// \brief Retrieve the template name that represents a qualified 6143/// template name such as \c std::vector. 6144TemplateName 6145ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS, 6146 bool TemplateKeyword, 6147 TemplateDecl *Template) const { 6148 assert(NNS && "Missing nested-name-specifier in qualified template name"); 6149 6150 // FIXME: Canonicalization? 6151 llvm::FoldingSetNodeID ID; 6152 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template); 6153 6154 void *InsertPos = 0; 6155 QualifiedTemplateName *QTN = 6156 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 6157 if (!QTN) { 6158 QTN = new (*this, llvm::alignOf<QualifiedTemplateName>()) 6159 QualifiedTemplateName(NNS, TemplateKeyword, Template); 6160 QualifiedTemplateNames.InsertNode(QTN, InsertPos); 6161 } 6162 6163 return TemplateName(QTN); 6164} 6165 6166/// \brief Retrieve the template name that represents a dependent 6167/// template name such as \c MetaFun::template apply. 6168TemplateName 6169ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 6170 const IdentifierInfo *Name) const { 6171 assert((!NNS || NNS->isDependent()) && 6172 "Nested name specifier must be dependent"); 6173 6174 llvm::FoldingSetNodeID ID; 6175 DependentTemplateName::Profile(ID, NNS, Name); 6176 6177 void *InsertPos = 0; 6178 DependentTemplateName *QTN = 6179 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 6180 6181 if (QTN) 6182 return TemplateName(QTN); 6183 6184 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 6185 if (CanonNNS == NNS) { 6186 QTN = new (*this, llvm::alignOf<DependentTemplateName>()) 6187 DependentTemplateName(NNS, Name); 6188 } else { 6189 TemplateName Canon = getDependentTemplateName(CanonNNS, Name); 6190 QTN = new (*this, llvm::alignOf<DependentTemplateName>()) 6191 DependentTemplateName(NNS, Name, Canon); 6192 DependentTemplateName *CheckQTN = 6193 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 6194 assert(!CheckQTN && "Dependent type name canonicalization broken"); 6195 (void)CheckQTN; 6196 } 6197 6198 DependentTemplateNames.InsertNode(QTN, InsertPos); 6199 return TemplateName(QTN); 6200} 6201 6202/// \brief Retrieve the template name that represents a dependent 6203/// template name such as \c MetaFun::template operator+. 6204TemplateName 6205ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS, 6206 OverloadedOperatorKind Operator) const { 6207 assert((!NNS || NNS->isDependent()) && 6208 "Nested name specifier must be dependent"); 6209 6210 llvm::FoldingSetNodeID ID; 6211 DependentTemplateName::Profile(ID, NNS, Operator); 6212 6213 void *InsertPos = 0; 6214 DependentTemplateName *QTN 6215 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 6216 6217 if (QTN) 6218 return TemplateName(QTN); 6219 6220 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS); 6221 if (CanonNNS == NNS) { 6222 QTN = new (*this, llvm::alignOf<DependentTemplateName>()) 6223 DependentTemplateName(NNS, Operator); 6224 } else { 6225 TemplateName Canon = getDependentTemplateName(CanonNNS, Operator); 6226 QTN = new (*this, llvm::alignOf<DependentTemplateName>()) 6227 DependentTemplateName(NNS, Operator, Canon); 6228 6229 DependentTemplateName *CheckQTN 6230 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos); 6231 assert(!CheckQTN && "Dependent template name canonicalization broken"); 6232 (void)CheckQTN; 6233 } 6234 6235 DependentTemplateNames.InsertNode(QTN, InsertPos); 6236 return TemplateName(QTN); 6237} 6238 6239TemplateName 6240ASTContext::getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, 6241 TemplateName replacement) const { 6242 llvm::FoldingSetNodeID ID; 6243 SubstTemplateTemplateParmStorage::Profile(ID, param, replacement); 6244 6245 void *insertPos = 0; 6246 SubstTemplateTemplateParmStorage *subst 6247 = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos); 6248 6249 if (!subst) { 6250 subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement); 6251 SubstTemplateTemplateParms.InsertNode(subst, insertPos); 6252 } 6253 6254 return TemplateName(subst); 6255} 6256 6257TemplateName 6258ASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, 6259 const TemplateArgument &ArgPack) const { 6260 ASTContext &Self = const_cast<ASTContext &>(*this); 6261 llvm::FoldingSetNodeID ID; 6262 SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack); 6263 6264 void *InsertPos = 0; 6265 SubstTemplateTemplateParmPackStorage *Subst 6266 = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos); 6267 6268 if (!Subst) { 6269 Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param, 6270 ArgPack.pack_size(), 6271 ArgPack.pack_begin()); 6272 SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos); 6273 } 6274 6275 return TemplateName(Subst); 6276} 6277 6278/// getFromTargetType - Given one of the integer types provided by 6279/// TargetInfo, produce the corresponding type. The unsigned @p Type 6280/// is actually a value of type @c TargetInfo::IntType. 6281CanQualType ASTContext::getFromTargetType(unsigned Type) const { 6282 switch (Type) { 6283 case TargetInfo::NoInt: return CanQualType(); 6284 case TargetInfo::SignedShort: return ShortTy; 6285 case TargetInfo::UnsignedShort: return UnsignedShortTy; 6286 case TargetInfo::SignedInt: return IntTy; 6287 case TargetInfo::UnsignedInt: return UnsignedIntTy; 6288 case TargetInfo::SignedLong: return LongTy; 6289 case TargetInfo::UnsignedLong: return UnsignedLongTy; 6290 case TargetInfo::SignedLongLong: return LongLongTy; 6291 case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy; 6292 } 6293 6294 llvm_unreachable("Unhandled TargetInfo::IntType value"); 6295} 6296 6297//===----------------------------------------------------------------------===// 6298// Type Predicates. 6299//===----------------------------------------------------------------------===// 6300 6301/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's 6302/// garbage collection attribute. 6303/// 6304Qualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const { 6305 if (getLangOpts().getGC() == LangOptions::NonGC) 6306 return Qualifiers::GCNone; 6307 6308 assert(getLangOpts().ObjC1); 6309 Qualifiers::GC GCAttrs = Ty.getObjCGCAttr(); 6310 6311 // Default behaviour under objective-C's gc is for ObjC pointers 6312 // (or pointers to them) be treated as though they were declared 6313 // as __strong. 6314 if (GCAttrs == Qualifiers::GCNone) { 6315 if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) 6316 return Qualifiers::Strong; 6317 else if (Ty->isPointerType()) 6318 return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType()); 6319 } else { 6320 // It's not valid to set GC attributes on anything that isn't a 6321 // pointer. 6322#ifndef NDEBUG 6323 QualType CT = Ty->getCanonicalTypeInternal(); 6324 while (const ArrayType *AT = dyn_cast<ArrayType>(CT)) 6325 CT = AT->getElementType(); 6326 assert(CT->isAnyPointerType() || CT->isBlockPointerType()); 6327#endif 6328 } 6329 return GCAttrs; 6330} 6331 6332//===----------------------------------------------------------------------===// 6333// Type Compatibility Testing 6334//===----------------------------------------------------------------------===// 6335 6336/// areCompatVectorTypes - Return true if the two specified vector types are 6337/// compatible. 6338static bool areCompatVectorTypes(const VectorType *LHS, 6339 const VectorType *RHS) { 6340 assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified()); 6341 return LHS->getElementType() == RHS->getElementType() && 6342 LHS->getNumElements() == RHS->getNumElements(); 6343} 6344 6345bool ASTContext::areCompatibleVectorTypes(QualType FirstVec, 6346 QualType SecondVec) { 6347 assert(FirstVec->isVectorType() && "FirstVec should be a vector type"); 6348 assert(SecondVec->isVectorType() && "SecondVec should be a vector type"); 6349 6350 if (hasSameUnqualifiedType(FirstVec, SecondVec)) 6351 return true; 6352 6353 // Treat Neon vector types and most AltiVec vector types as if they are the 6354 // equivalent GCC vector types. 6355 const VectorType *First = FirstVec->getAs<VectorType>(); 6356 const VectorType *Second = SecondVec->getAs<VectorType>(); 6357 if (First->getNumElements() == Second->getNumElements() && 6358 hasSameType(First->getElementType(), Second->getElementType()) && 6359 First->getVectorKind() != VectorType::AltiVecPixel && 6360 First->getVectorKind() != VectorType::AltiVecBool && 6361 Second->getVectorKind() != VectorType::AltiVecPixel && 6362 Second->getVectorKind() != VectorType::AltiVecBool) 6363 return true; 6364 6365 return false; 6366} 6367 6368//===----------------------------------------------------------------------===// 6369// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's. 6370//===----------------------------------------------------------------------===// 6371 6372/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the 6373/// inheritance hierarchy of 'rProto'. 6374bool 6375ASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, 6376 ObjCProtocolDecl *rProto) const { 6377 if (declaresSameEntity(lProto, rProto)) 6378 return true; 6379 for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(), 6380 E = rProto->protocol_end(); PI != E; ++PI) 6381 if (ProtocolCompatibleWithProtocol(lProto, *PI)) 6382 return true; 6383 return false; 6384} 6385 6386/// QualifiedIdConformsQualifiedId - compare id<pr,...> with id<pr1,...> 6387/// return true if lhs's protocols conform to rhs's protocol; false 6388/// otherwise. 6389bool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) { 6390 if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType()) 6391 return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false); 6392 return false; 6393} 6394 6395/// ObjCQualifiedClassTypesAreCompatible - compare Class<pr,...> and 6396/// Class<pr1, ...>. 6397bool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs, 6398 QualType rhs) { 6399 const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>(); 6400 const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 6401 assert ((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible"); 6402 6403 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 6404 E = lhsQID->qual_end(); I != E; ++I) { 6405 bool match = false; 6406 ObjCProtocolDecl *lhsProto = *I; 6407 for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 6408 E = rhsOPT->qual_end(); J != E; ++J) { 6409 ObjCProtocolDecl *rhsProto = *J; 6410 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) { 6411 match = true; 6412 break; 6413 } 6414 } 6415 if (!match) 6416 return false; 6417 } 6418 return true; 6419} 6420 6421/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an 6422/// ObjCQualifiedIDType. 6423bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs, 6424 bool compare) { 6425 // Allow id<P..> and an 'id' or void* type in all cases. 6426 if (lhs->isVoidPointerType() || 6427 lhs->isObjCIdType() || lhs->isObjCClassType()) 6428 return true; 6429 else if (rhs->isVoidPointerType() || 6430 rhs->isObjCIdType() || rhs->isObjCClassType()) 6431 return true; 6432 6433 if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) { 6434 const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>(); 6435 6436 if (!rhsOPT) return false; 6437 6438 if (rhsOPT->qual_empty()) { 6439 // If the RHS is a unqualified interface pointer "NSString*", 6440 // make sure we check the class hierarchy. 6441 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 6442 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 6443 E = lhsQID->qual_end(); I != E; ++I) { 6444 // when comparing an id<P> on lhs with a static type on rhs, 6445 // see if static class implements all of id's protocols, directly or 6446 // through its super class and categories. 6447 if (!rhsID->ClassImplementsProtocol(*I, true)) 6448 return false; 6449 } 6450 } 6451 // If there are no qualifiers and no interface, we have an 'id'. 6452 return true; 6453 } 6454 // Both the right and left sides have qualifiers. 6455 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 6456 E = lhsQID->qual_end(); I != E; ++I) { 6457 ObjCProtocolDecl *lhsProto = *I; 6458 bool match = false; 6459 6460 // when comparing an id<P> on lhs with a static type on rhs, 6461 // see if static class implements all of id's protocols, directly or 6462 // through its super class and categories. 6463 for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(), 6464 E = rhsOPT->qual_end(); J != E; ++J) { 6465 ObjCProtocolDecl *rhsProto = *J; 6466 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 6467 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 6468 match = true; 6469 break; 6470 } 6471 } 6472 // If the RHS is a qualified interface pointer "NSString<P>*", 6473 // make sure we check the class hierarchy. 6474 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) { 6475 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(), 6476 E = lhsQID->qual_end(); I != E; ++I) { 6477 // when comparing an id<P> on lhs with a static type on rhs, 6478 // see if static class implements all of id's protocols, directly or 6479 // through its super class and categories. 6480 if (rhsID->ClassImplementsProtocol(*I, true)) { 6481 match = true; 6482 break; 6483 } 6484 } 6485 } 6486 if (!match) 6487 return false; 6488 } 6489 6490 return true; 6491 } 6492 6493 const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType(); 6494 assert(rhsQID && "One of the LHS/RHS should be id<x>"); 6495 6496 if (const ObjCObjectPointerType *lhsOPT = 6497 lhs->getAsObjCInterfacePointerType()) { 6498 // If both the right and left sides have qualifiers. 6499 for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(), 6500 E = lhsOPT->qual_end(); I != E; ++I) { 6501 ObjCProtocolDecl *lhsProto = *I; 6502 bool match = false; 6503 6504 // when comparing an id<P> on rhs with a static type on lhs, 6505 // see if static class implements all of id's protocols, directly or 6506 // through its super class and categories. 6507 // First, lhs protocols in the qualifier list must be found, direct 6508 // or indirect in rhs's qualifier list or it is a mismatch. 6509 for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 6510 E = rhsQID->qual_end(); J != E; ++J) { 6511 ObjCProtocolDecl *rhsProto = *J; 6512 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 6513 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 6514 match = true; 6515 break; 6516 } 6517 } 6518 if (!match) 6519 return false; 6520 } 6521 6522 // Static class's protocols, or its super class or category protocols 6523 // must be found, direct or indirect in rhs's qualifier list or it is a mismatch. 6524 if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) { 6525 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 6526 CollectInheritedProtocols(lhsID, LHSInheritedProtocols); 6527 // This is rather dubious but matches gcc's behavior. If lhs has 6528 // no type qualifier and its class has no static protocol(s) 6529 // assume that it is mismatch. 6530 if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty()) 6531 return false; 6532 for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 6533 LHSInheritedProtocols.begin(), 6534 E = LHSInheritedProtocols.end(); I != E; ++I) { 6535 bool match = false; 6536 ObjCProtocolDecl *lhsProto = (*I); 6537 for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(), 6538 E = rhsQID->qual_end(); J != E; ++J) { 6539 ObjCProtocolDecl *rhsProto = *J; 6540 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) || 6541 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) { 6542 match = true; 6543 break; 6544 } 6545 } 6546 if (!match) 6547 return false; 6548 } 6549 } 6550 return true; 6551 } 6552 return false; 6553} 6554 6555/// canAssignObjCInterfaces - Return true if the two interface types are 6556/// compatible for assignment from RHS to LHS. This handles validation of any 6557/// protocol qualifiers on the LHS or RHS. 6558/// 6559bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, 6560 const ObjCObjectPointerType *RHSOPT) { 6561 const ObjCObjectType* LHS = LHSOPT->getObjectType(); 6562 const ObjCObjectType* RHS = RHSOPT->getObjectType(); 6563 6564 // If either type represents the built-in 'id' or 'Class' types, return true. 6565 if (LHS->isObjCUnqualifiedIdOrClass() || 6566 RHS->isObjCUnqualifiedIdOrClass()) 6567 return true; 6568 6569 if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) 6570 return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 6571 QualType(RHSOPT,0), 6572 false); 6573 6574 if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) 6575 return ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0), 6576 QualType(RHSOPT,0)); 6577 6578 // If we have 2 user-defined types, fall into that path. 6579 if (LHS->getInterface() && RHS->getInterface()) 6580 return canAssignObjCInterfaces(LHS, RHS); 6581 6582 return false; 6583} 6584 6585/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written 6586/// for providing type-safety for objective-c pointers used to pass/return 6587/// arguments in block literals. When passed as arguments, passing 'A*' where 6588/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is 6589/// not OK. For the return type, the opposite is not OK. 6590bool ASTContext::canAssignObjCInterfacesInBlockPointer( 6591 const ObjCObjectPointerType *LHSOPT, 6592 const ObjCObjectPointerType *RHSOPT, 6593 bool BlockReturnType) { 6594 if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType()) 6595 return true; 6596 6597 if (LHSOPT->isObjCBuiltinType()) { 6598 return RHSOPT->isObjCBuiltinType() || RHSOPT->isObjCQualifiedIdType(); 6599 } 6600 6601 if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType()) 6602 return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0), 6603 QualType(RHSOPT,0), 6604 false); 6605 6606 const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType(); 6607 const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType(); 6608 if (LHS && RHS) { // We have 2 user-defined types. 6609 if (LHS != RHS) { 6610 if (LHS->getDecl()->isSuperClassOf(RHS->getDecl())) 6611 return BlockReturnType; 6612 if (RHS->getDecl()->isSuperClassOf(LHS->getDecl())) 6613 return !BlockReturnType; 6614 } 6615 else 6616 return true; 6617 } 6618 return false; 6619} 6620 6621/// getIntersectionOfProtocols - This routine finds the intersection of set 6622/// of protocols inherited from two distinct objective-c pointer objects. 6623/// It is used to build composite qualifier list of the composite type of 6624/// the conditional expression involving two objective-c pointer objects. 6625static 6626void getIntersectionOfProtocols(ASTContext &Context, 6627 const ObjCObjectPointerType *LHSOPT, 6628 const ObjCObjectPointerType *RHSOPT, 6629 SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) { 6630 6631 const ObjCObjectType* LHS = LHSOPT->getObjectType(); 6632 const ObjCObjectType* RHS = RHSOPT->getObjectType(); 6633 assert(LHS->getInterface() && "LHS must have an interface base"); 6634 assert(RHS->getInterface() && "RHS must have an interface base"); 6635 6636 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet; 6637 unsigned LHSNumProtocols = LHS->getNumProtocols(); 6638 if (LHSNumProtocols > 0) 6639 InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end()); 6640 else { 6641 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols; 6642 Context.CollectInheritedProtocols(LHS->getInterface(), 6643 LHSInheritedProtocols); 6644 InheritedProtocolSet.insert(LHSInheritedProtocols.begin(), 6645 LHSInheritedProtocols.end()); 6646 } 6647 6648 unsigned RHSNumProtocols = RHS->getNumProtocols(); 6649 if (RHSNumProtocols > 0) { 6650 ObjCProtocolDecl **RHSProtocols = 6651 const_cast<ObjCProtocolDecl **>(RHS->qual_begin()); 6652 for (unsigned i = 0; i < RHSNumProtocols; ++i) 6653 if (InheritedProtocolSet.count(RHSProtocols[i])) 6654 IntersectionOfProtocols.push_back(RHSProtocols[i]); 6655 } else { 6656 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSInheritedProtocols; 6657 Context.CollectInheritedProtocols(RHS->getInterface(), 6658 RHSInheritedProtocols); 6659 for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 6660 RHSInheritedProtocols.begin(), 6661 E = RHSInheritedProtocols.end(); I != E; ++I) 6662 if (InheritedProtocolSet.count((*I))) 6663 IntersectionOfProtocols.push_back((*I)); 6664 } 6665} 6666 6667/// areCommonBaseCompatible - Returns common base class of the two classes if 6668/// one found. Note that this is O'2 algorithm. But it will be called as the 6669/// last type comparison in a ?-exp of ObjC pointer types before a 6670/// warning is issued. So, its invokation is extremely rare. 6671QualType ASTContext::areCommonBaseCompatible( 6672 const ObjCObjectPointerType *Lptr, 6673 const ObjCObjectPointerType *Rptr) { 6674 const ObjCObjectType *LHS = Lptr->getObjectType(); 6675 const ObjCObjectType *RHS = Rptr->getObjectType(); 6676 const ObjCInterfaceDecl* LDecl = LHS->getInterface(); 6677 const ObjCInterfaceDecl* RDecl = RHS->getInterface(); 6678 if (!LDecl || !RDecl || (declaresSameEntity(LDecl, RDecl))) 6679 return QualType(); 6680 6681 do { 6682 LHS = cast<ObjCInterfaceType>(getObjCInterfaceType(LDecl)); 6683 if (canAssignObjCInterfaces(LHS, RHS)) { 6684 SmallVector<ObjCProtocolDecl *, 8> Protocols; 6685 getIntersectionOfProtocols(*this, Lptr, Rptr, Protocols); 6686 6687 QualType Result = QualType(LHS, 0); 6688 if (!Protocols.empty()) 6689 Result = getObjCObjectType(Result, Protocols.data(), Protocols.size()); 6690 Result = getObjCObjectPointerType(Result); 6691 return Result; 6692 } 6693 } while ((LDecl = LDecl->getSuperClass())); 6694 6695 return QualType(); 6696} 6697 6698bool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS, 6699 const ObjCObjectType *RHS) { 6700 assert(LHS->getInterface() && "LHS is not an interface type"); 6701 assert(RHS->getInterface() && "RHS is not an interface type"); 6702 6703 // Verify that the base decls are compatible: the RHS must be a subclass of 6704 // the LHS. 6705 if (!LHS->getInterface()->isSuperClassOf(RHS->getInterface())) 6706 return false; 6707 6708 // RHS must have a superset of the protocols in the LHS. If the LHS is not 6709 // protocol qualified at all, then we are good. 6710 if (LHS->getNumProtocols() == 0) 6711 return true; 6712 6713 // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, 6714 // more detailed analysis is required. 6715 if (RHS->getNumProtocols() == 0) { 6716 // OK, if LHS is a superclass of RHS *and* 6717 // this superclass is assignment compatible with LHS. 6718 // false otherwise. 6719 bool IsSuperClass = 6720 LHS->getInterface()->isSuperClassOf(RHS->getInterface()); 6721 if (IsSuperClass) { 6722 // OK if conversion of LHS to SuperClass results in narrowing of types 6723 // ; i.e., SuperClass may implement at least one of the protocols 6724 // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok. 6725 // But not SuperObj<P1,P2,P3> = lhs<P1,P2>. 6726 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols; 6727 CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols); 6728 // If super class has no protocols, it is not a match. 6729 if (SuperClassInheritedProtocols.empty()) 6730 return false; 6731 6732 for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 6733 LHSPE = LHS->qual_end(); 6734 LHSPI != LHSPE; LHSPI++) { 6735 bool SuperImplementsProtocol = false; 6736 ObjCProtocolDecl *LHSProto = (*LHSPI); 6737 6738 for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I = 6739 SuperClassInheritedProtocols.begin(), 6740 E = SuperClassInheritedProtocols.end(); I != E; ++I) { 6741 ObjCProtocolDecl *SuperClassProto = (*I); 6742 if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) { 6743 SuperImplementsProtocol = true; 6744 break; 6745 } 6746 } 6747 if (!SuperImplementsProtocol) 6748 return false; 6749 } 6750 return true; 6751 } 6752 return false; 6753 } 6754 6755 for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(), 6756 LHSPE = LHS->qual_end(); 6757 LHSPI != LHSPE; LHSPI++) { 6758 bool RHSImplementsProtocol = false; 6759 6760 // If the RHS doesn't implement the protocol on the left, the types 6761 // are incompatible. 6762 for (ObjCObjectType::qual_iterator RHSPI = RHS->qual_begin(), 6763 RHSPE = RHS->qual_end(); 6764 RHSPI != RHSPE; RHSPI++) { 6765 if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) { 6766 RHSImplementsProtocol = true; 6767 break; 6768 } 6769 } 6770 // FIXME: For better diagnostics, consider passing back the protocol name. 6771 if (!RHSImplementsProtocol) 6772 return false; 6773 } 6774 // The RHS implements all protocols listed on the LHS. 6775 return true; 6776} 6777 6778bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) { 6779 // get the "pointed to" types 6780 const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>(); 6781 const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>(); 6782 6783 if (!LHSOPT || !RHSOPT) 6784 return false; 6785 6786 return canAssignObjCInterfaces(LHSOPT, RHSOPT) || 6787 canAssignObjCInterfaces(RHSOPT, LHSOPT); 6788} 6789 6790bool ASTContext::canBindObjCObjectType(QualType To, QualType From) { 6791 return canAssignObjCInterfaces( 6792 getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(), 6793 getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>()); 6794} 6795 6796/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible, 6797/// both shall have the identically qualified version of a compatible type. 6798/// C99 6.2.7p1: Two types have compatible types if their types are the 6799/// same. See 6.7.[2,3,5] for additional rules. 6800bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS, 6801 bool CompareUnqualified) { 6802 if (getLangOpts().CPlusPlus) 6803 return hasSameType(LHS, RHS); 6804 6805 return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull(); 6806} 6807 6808bool ASTContext::propertyTypesAreCompatible(QualType LHS, QualType RHS) { 6809 return typesAreCompatible(LHS, RHS); 6810} 6811 6812bool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) { 6813 return !mergeTypes(LHS, RHS, true).isNull(); 6814} 6815 6816/// mergeTransparentUnionType - if T is a transparent union type and a member 6817/// of T is compatible with SubType, return the merged type, else return 6818/// QualType() 6819QualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType, 6820 bool OfBlockPointer, 6821 bool Unqualified) { 6822 if (const RecordType *UT = T->getAsUnionType()) { 6823 RecordDecl *UD = UT->getDecl(); 6824 if (UD->hasAttr<TransparentUnionAttr>()) { 6825 for (RecordDecl::field_iterator it = UD->field_begin(), 6826 itend = UD->field_end(); it != itend; ++it) { 6827 QualType ET = it->getType().getUnqualifiedType(); 6828 QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified); 6829 if (!MT.isNull()) 6830 return MT; 6831 } 6832 } 6833 } 6834 6835 return QualType(); 6836} 6837 6838/// mergeFunctionArgumentTypes - merge two types which appear as function 6839/// argument types 6840QualType ASTContext::mergeFunctionArgumentTypes(QualType lhs, QualType rhs, 6841 bool OfBlockPointer, 6842 bool Unqualified) { 6843 // GNU extension: two types are compatible if they appear as a function 6844 // argument, one of the types is a transparent union type and the other 6845 // type is compatible with a union member 6846 QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer, 6847 Unqualified); 6848 if (!lmerge.isNull()) 6849 return lmerge; 6850 6851 QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer, 6852 Unqualified); 6853 if (!rmerge.isNull()) 6854 return rmerge; 6855 6856 return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified); 6857} 6858 6859QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs, 6860 bool OfBlockPointer, 6861 bool Unqualified) { 6862 const FunctionType *lbase = lhs->getAs<FunctionType>(); 6863 const FunctionType *rbase = rhs->getAs<FunctionType>(); 6864 const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase); 6865 const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase); 6866 bool allLTypes = true; 6867 bool allRTypes = true; 6868 6869 // Check return type 6870 QualType retType; 6871 if (OfBlockPointer) { 6872 QualType RHS = rbase->getResultType(); 6873 QualType LHS = lbase->getResultType(); 6874 bool UnqualifiedResult = Unqualified; 6875 if (!UnqualifiedResult) 6876 UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers()); 6877 retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true); 6878 } 6879 else 6880 retType = mergeTypes(lbase->getResultType(), rbase->getResultType(), false, 6881 Unqualified); 6882 if (retType.isNull()) return QualType(); 6883 6884 if (Unqualified) 6885 retType = retType.getUnqualifiedType(); 6886 6887 CanQualType LRetType = getCanonicalType(lbase->getResultType()); 6888 CanQualType RRetType = getCanonicalType(rbase->getResultType()); 6889 if (Unqualified) { 6890 LRetType = LRetType.getUnqualifiedType(); 6891 RRetType = RRetType.getUnqualifiedType(); 6892 } 6893 6894 if (getCanonicalType(retType) != LRetType) 6895 allLTypes = false; 6896 if (getCanonicalType(retType) != RRetType) 6897 allRTypes = false; 6898 6899 // FIXME: double check this 6900 // FIXME: should we error if lbase->getRegParmAttr() != 0 && 6901 // rbase->getRegParmAttr() != 0 && 6902 // lbase->getRegParmAttr() != rbase->getRegParmAttr()? 6903 FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo(); 6904 FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo(); 6905 6906 // Compatible functions must have compatible calling conventions 6907 if (!isSameCallConv(lbaseInfo.getCC(), rbaseInfo.getCC())) 6908 return QualType(); 6909 6910 // Regparm is part of the calling convention. 6911 if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm()) 6912 return QualType(); 6913 if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm()) 6914 return QualType(); 6915 6916 if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult()) 6917 return QualType(); 6918 6919 // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'. 6920 bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn(); 6921 6922 if (lbaseInfo.getNoReturn() != NoReturn) 6923 allLTypes = false; 6924 if (rbaseInfo.getNoReturn() != NoReturn) 6925 allRTypes = false; 6926 6927 FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn); 6928 6929 if (lproto && rproto) { // two C99 style function prototypes 6930 assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && 6931 "C++ shouldn't be here"); 6932 unsigned lproto_nargs = lproto->getNumArgs(); 6933 unsigned rproto_nargs = rproto->getNumArgs(); 6934 6935 // Compatible functions must have the same number of arguments 6936 if (lproto_nargs != rproto_nargs) 6937 return QualType(); 6938 6939 // Variadic and non-variadic functions aren't compatible 6940 if (lproto->isVariadic() != rproto->isVariadic()) 6941 return QualType(); 6942 6943 if (lproto->getTypeQuals() != rproto->getTypeQuals()) 6944 return QualType(); 6945 6946 if (LangOpts.ObjCAutoRefCount && 6947 !FunctionTypesMatchOnNSConsumedAttrs(rproto, lproto)) 6948 return QualType(); 6949 6950 // Check argument compatibility 6951 SmallVector<QualType, 10> types; 6952 for (unsigned i = 0; i < lproto_nargs; i++) { 6953 QualType largtype = lproto->getArgType(i).getUnqualifiedType(); 6954 QualType rargtype = rproto->getArgType(i).getUnqualifiedType(); 6955 QualType argtype = mergeFunctionArgumentTypes(largtype, rargtype, 6956 OfBlockPointer, 6957 Unqualified); 6958 if (argtype.isNull()) return QualType(); 6959 6960 if (Unqualified) 6961 argtype = argtype.getUnqualifiedType(); 6962 6963 types.push_back(argtype); 6964 if (Unqualified) { 6965 largtype = largtype.getUnqualifiedType(); 6966 rargtype = rargtype.getUnqualifiedType(); 6967 } 6968 6969 if (getCanonicalType(argtype) != getCanonicalType(largtype)) 6970 allLTypes = false; 6971 if (getCanonicalType(argtype) != getCanonicalType(rargtype)) 6972 allRTypes = false; 6973 } 6974 6975 if (allLTypes) return lhs; 6976 if (allRTypes) return rhs; 6977 6978 FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo(); 6979 EPI.ExtInfo = einfo; 6980 return getFunctionType(retType, types, EPI); 6981 } 6982 6983 if (lproto) allRTypes = false; 6984 if (rproto) allLTypes = false; 6985 6986 const FunctionProtoType *proto = lproto ? lproto : rproto; 6987 if (proto) { 6988 assert(!proto->hasExceptionSpec() && "C++ shouldn't be here"); 6989 if (proto->isVariadic()) return QualType(); 6990 // Check that the types are compatible with the types that 6991 // would result from default argument promotions (C99 6.7.5.3p15). 6992 // The only types actually affected are promotable integer 6993 // types and floats, which would be passed as a different 6994 // type depending on whether the prototype is visible. 6995 unsigned proto_nargs = proto->getNumArgs(); 6996 for (unsigned i = 0; i < proto_nargs; ++i) { 6997 QualType argTy = proto->getArgType(i); 6998 6999 // Look at the converted type of enum types, since that is the type used 7000 // to pass enum values. 7001 if (const EnumType *Enum = argTy->getAs<EnumType>()) { 7002 argTy = Enum->getDecl()->getIntegerType(); 7003 if (argTy.isNull()) 7004 return QualType(); 7005 } 7006 7007 if (argTy->isPromotableIntegerType() || 7008 getCanonicalType(argTy).getUnqualifiedType() == FloatTy) 7009 return QualType(); 7010 } 7011 7012 if (allLTypes) return lhs; 7013 if (allRTypes) return rhs; 7014 7015 FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo(); 7016 EPI.ExtInfo = einfo; 7017 return getFunctionType(retType, 7018 ArrayRef<QualType>(proto->arg_type_begin(), 7019 proto->getNumArgs()), 7020 EPI); 7021 } 7022 7023 if (allLTypes) return lhs; 7024 if (allRTypes) return rhs; 7025 return getFunctionNoProtoType(retType, einfo); 7026} 7027 7028/// Given that we have an enum type and a non-enum type, try to merge them. 7029static QualType mergeEnumWithInteger(ASTContext &Context, const EnumType *ET, 7030 QualType other, bool isBlockReturnType) { 7031 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char, 7032 // a signed integer type, or an unsigned integer type. 7033 // Compatibility is based on the underlying type, not the promotion 7034 // type. 7035 QualType underlyingType = ET->getDecl()->getIntegerType(); 7036 if (underlyingType.isNull()) return QualType(); 7037 if (Context.hasSameType(underlyingType, other)) 7038 return other; 7039 7040 // In block return types, we're more permissive and accept any 7041 // integral type of the same size. 7042 if (isBlockReturnType && other->isIntegerType() && 7043 Context.getTypeSize(underlyingType) == Context.getTypeSize(other)) 7044 return other; 7045 7046 return QualType(); 7047} 7048 7049QualType ASTContext::mergeTypes(QualType LHS, QualType RHS, 7050 bool OfBlockPointer, 7051 bool Unqualified, bool BlockReturnType) { 7052 // C++ [expr]: If an expression initially has the type "reference to T", the 7053 // type is adjusted to "T" prior to any further analysis, the expression 7054 // designates the object or function denoted by the reference, and the 7055 // expression is an lvalue unless the reference is an rvalue reference and 7056 // the expression is a function call (possibly inside parentheses). 7057 assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?"); 7058 assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?"); 7059 7060 if (Unqualified) { 7061 LHS = LHS.getUnqualifiedType(); 7062 RHS = RHS.getUnqualifiedType(); 7063 } 7064 7065 QualType LHSCan = getCanonicalType(LHS), 7066 RHSCan = getCanonicalType(RHS); 7067 7068 // If two types are identical, they are compatible. 7069 if (LHSCan == RHSCan) 7070 return LHS; 7071 7072 // If the qualifiers are different, the types aren't compatible... mostly. 7073 Qualifiers LQuals = LHSCan.getLocalQualifiers(); 7074 Qualifiers RQuals = RHSCan.getLocalQualifiers(); 7075 if (LQuals != RQuals) { 7076 // If any of these qualifiers are different, we have a type 7077 // mismatch. 7078 if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 7079 LQuals.getAddressSpace() != RQuals.getAddressSpace() || 7080 LQuals.getObjCLifetime() != RQuals.getObjCLifetime()) 7081 return QualType(); 7082 7083 // Exactly one GC qualifier difference is allowed: __strong is 7084 // okay if the other type has no GC qualifier but is an Objective 7085 // C object pointer (i.e. implicitly strong by default). We fix 7086 // this by pretending that the unqualified type was actually 7087 // qualified __strong. 7088 Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 7089 Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 7090 assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 7091 7092 if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 7093 return QualType(); 7094 7095 if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) { 7096 return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong)); 7097 } 7098 if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) { 7099 return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS); 7100 } 7101 return QualType(); 7102 } 7103 7104 // Okay, qualifiers are equal. 7105 7106 Type::TypeClass LHSClass = LHSCan->getTypeClass(); 7107 Type::TypeClass RHSClass = RHSCan->getTypeClass(); 7108 7109 // We want to consider the two function types to be the same for these 7110 // comparisons, just force one to the other. 7111 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto; 7112 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto; 7113 7114 // Same as above for arrays 7115 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray) 7116 LHSClass = Type::ConstantArray; 7117 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray) 7118 RHSClass = Type::ConstantArray; 7119 7120 // ObjCInterfaces are just specialized ObjCObjects. 7121 if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject; 7122 if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject; 7123 7124 // Canonicalize ExtVector -> Vector. 7125 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector; 7126 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector; 7127 7128 // If the canonical type classes don't match. 7129 if (LHSClass != RHSClass) { 7130 // Note that we only have special rules for turning block enum 7131 // returns into block int returns, not vice-versa. 7132 if (const EnumType* ETy = LHS->getAs<EnumType>()) { 7133 return mergeEnumWithInteger(*this, ETy, RHS, false); 7134 } 7135 if (const EnumType* ETy = RHS->getAs<EnumType>()) { 7136 return mergeEnumWithInteger(*this, ETy, LHS, BlockReturnType); 7137 } 7138 // allow block pointer type to match an 'id' type. 7139 if (OfBlockPointer && !BlockReturnType) { 7140 if (LHS->isObjCIdType() && RHS->isBlockPointerType()) 7141 return LHS; 7142 if (RHS->isObjCIdType() && LHS->isBlockPointerType()) 7143 return RHS; 7144 } 7145 7146 return QualType(); 7147 } 7148 7149 // The canonical type classes match. 7150 switch (LHSClass) { 7151#define TYPE(Class, Base) 7152#define ABSTRACT_TYPE(Class, Base) 7153#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class: 7154#define NON_CANONICAL_TYPE(Class, Base) case Type::Class: 7155#define DEPENDENT_TYPE(Class, Base) case Type::Class: 7156#include "clang/AST/TypeNodes.def" 7157 llvm_unreachable("Non-canonical and dependent types shouldn't get here"); 7158 7159 case Type::Auto: 7160 case Type::LValueReference: 7161 case Type::RValueReference: 7162 case Type::MemberPointer: 7163 llvm_unreachable("C++ should never be in mergeTypes"); 7164 7165 case Type::ObjCInterface: 7166 case Type::IncompleteArray: 7167 case Type::VariableArray: 7168 case Type::FunctionProto: 7169 case Type::ExtVector: 7170 llvm_unreachable("Types are eliminated above"); 7171 7172 case Type::Pointer: 7173 { 7174 // Merge two pointer types, while trying to preserve typedef info 7175 QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType(); 7176 QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType(); 7177 if (Unqualified) { 7178 LHSPointee = LHSPointee.getUnqualifiedType(); 7179 RHSPointee = RHSPointee.getUnqualifiedType(); 7180 } 7181 QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false, 7182 Unqualified); 7183 if (ResultType.isNull()) return QualType(); 7184 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 7185 return LHS; 7186 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 7187 return RHS; 7188 return getPointerType(ResultType); 7189 } 7190 case Type::BlockPointer: 7191 { 7192 // Merge two block pointer types, while trying to preserve typedef info 7193 QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType(); 7194 QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType(); 7195 if (Unqualified) { 7196 LHSPointee = LHSPointee.getUnqualifiedType(); 7197 RHSPointee = RHSPointee.getUnqualifiedType(); 7198 } 7199 QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer, 7200 Unqualified); 7201 if (ResultType.isNull()) return QualType(); 7202 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType)) 7203 return LHS; 7204 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType)) 7205 return RHS; 7206 return getBlockPointerType(ResultType); 7207 } 7208 case Type::Atomic: 7209 { 7210 // Merge two pointer types, while trying to preserve typedef info 7211 QualType LHSValue = LHS->getAs<AtomicType>()->getValueType(); 7212 QualType RHSValue = RHS->getAs<AtomicType>()->getValueType(); 7213 if (Unqualified) { 7214 LHSValue = LHSValue.getUnqualifiedType(); 7215 RHSValue = RHSValue.getUnqualifiedType(); 7216 } 7217 QualType ResultType = mergeTypes(LHSValue, RHSValue, false, 7218 Unqualified); 7219 if (ResultType.isNull()) return QualType(); 7220 if (getCanonicalType(LHSValue) == getCanonicalType(ResultType)) 7221 return LHS; 7222 if (getCanonicalType(RHSValue) == getCanonicalType(ResultType)) 7223 return RHS; 7224 return getAtomicType(ResultType); 7225 } 7226 case Type::ConstantArray: 7227 { 7228 const ConstantArrayType* LCAT = getAsConstantArrayType(LHS); 7229 const ConstantArrayType* RCAT = getAsConstantArrayType(RHS); 7230 if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize()) 7231 return QualType(); 7232 7233 QualType LHSElem = getAsArrayType(LHS)->getElementType(); 7234 QualType RHSElem = getAsArrayType(RHS)->getElementType(); 7235 if (Unqualified) { 7236 LHSElem = LHSElem.getUnqualifiedType(); 7237 RHSElem = RHSElem.getUnqualifiedType(); 7238 } 7239 7240 QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified); 7241 if (ResultType.isNull()) return QualType(); 7242 if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 7243 return LHS; 7244 if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 7245 return RHS; 7246 if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(), 7247 ArrayType::ArraySizeModifier(), 0); 7248 if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(), 7249 ArrayType::ArraySizeModifier(), 0); 7250 const VariableArrayType* LVAT = getAsVariableArrayType(LHS); 7251 const VariableArrayType* RVAT = getAsVariableArrayType(RHS); 7252 if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType)) 7253 return LHS; 7254 if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType)) 7255 return RHS; 7256 if (LVAT) { 7257 // FIXME: This isn't correct! But tricky to implement because 7258 // the array's size has to be the size of LHS, but the type 7259 // has to be different. 7260 return LHS; 7261 } 7262 if (RVAT) { 7263 // FIXME: This isn't correct! But tricky to implement because 7264 // the array's size has to be the size of RHS, but the type 7265 // has to be different. 7266 return RHS; 7267 } 7268 if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS; 7269 if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS; 7270 return getIncompleteArrayType(ResultType, 7271 ArrayType::ArraySizeModifier(), 0); 7272 } 7273 case Type::FunctionNoProto: 7274 return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified); 7275 case Type::Record: 7276 case Type::Enum: 7277 return QualType(); 7278 case Type::Builtin: 7279 // Only exactly equal builtin types are compatible, which is tested above. 7280 return QualType(); 7281 case Type::Complex: 7282 // Distinct complex types are incompatible. 7283 return QualType(); 7284 case Type::Vector: 7285 // FIXME: The merged type should be an ExtVector! 7286 if (areCompatVectorTypes(LHSCan->getAs<VectorType>(), 7287 RHSCan->getAs<VectorType>())) 7288 return LHS; 7289 return QualType(); 7290 case Type::ObjCObject: { 7291 // Check if the types are assignment compatible. 7292 // FIXME: This should be type compatibility, e.g. whether 7293 // "LHS x; RHS x;" at global scope is legal. 7294 const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>(); 7295 const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>(); 7296 if (canAssignObjCInterfaces(LHSIface, RHSIface)) 7297 return LHS; 7298 7299 return QualType(); 7300 } 7301 case Type::ObjCObjectPointer: { 7302 if (OfBlockPointer) { 7303 if (canAssignObjCInterfacesInBlockPointer( 7304 LHS->getAs<ObjCObjectPointerType>(), 7305 RHS->getAs<ObjCObjectPointerType>(), 7306 BlockReturnType)) 7307 return LHS; 7308 return QualType(); 7309 } 7310 if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(), 7311 RHS->getAs<ObjCObjectPointerType>())) 7312 return LHS; 7313 7314 return QualType(); 7315 } 7316 } 7317 7318 llvm_unreachable("Invalid Type::Class!"); 7319} 7320 7321bool ASTContext::FunctionTypesMatchOnNSConsumedAttrs( 7322 const FunctionProtoType *FromFunctionType, 7323 const FunctionProtoType *ToFunctionType) { 7324 if (FromFunctionType->hasAnyConsumedArgs() != 7325 ToFunctionType->hasAnyConsumedArgs()) 7326 return false; 7327 FunctionProtoType::ExtProtoInfo FromEPI = 7328 FromFunctionType->getExtProtoInfo(); 7329 FunctionProtoType::ExtProtoInfo ToEPI = 7330 ToFunctionType->getExtProtoInfo(); 7331 if (FromEPI.ConsumedArguments && ToEPI.ConsumedArguments) 7332 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 7333 ArgIdx != NumArgs; ++ArgIdx) { 7334 if (FromEPI.ConsumedArguments[ArgIdx] != 7335 ToEPI.ConsumedArguments[ArgIdx]) 7336 return false; 7337 } 7338 return true; 7339} 7340 7341/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and 7342/// 'RHS' attributes and returns the merged version; including for function 7343/// return types. 7344QualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) { 7345 QualType LHSCan = getCanonicalType(LHS), 7346 RHSCan = getCanonicalType(RHS); 7347 // If two types are identical, they are compatible. 7348 if (LHSCan == RHSCan) 7349 return LHS; 7350 if (RHSCan->isFunctionType()) { 7351 if (!LHSCan->isFunctionType()) 7352 return QualType(); 7353 QualType OldReturnType = 7354 cast<FunctionType>(RHSCan.getTypePtr())->getResultType(); 7355 QualType NewReturnType = 7356 cast<FunctionType>(LHSCan.getTypePtr())->getResultType(); 7357 QualType ResReturnType = 7358 mergeObjCGCQualifiers(NewReturnType, OldReturnType); 7359 if (ResReturnType.isNull()) 7360 return QualType(); 7361 if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) { 7362 // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo(); 7363 // In either case, use OldReturnType to build the new function type. 7364 const FunctionType *F = LHS->getAs<FunctionType>(); 7365 if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) { 7366 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo(); 7367 EPI.ExtInfo = getFunctionExtInfo(LHS); 7368 QualType ResultType 7369 = getFunctionType(OldReturnType, 7370 ArrayRef<QualType>(FPT->arg_type_begin(), 7371 FPT->getNumArgs()), 7372 EPI); 7373 return ResultType; 7374 } 7375 } 7376 return QualType(); 7377 } 7378 7379 // If the qualifiers are different, the types can still be merged. 7380 Qualifiers LQuals = LHSCan.getLocalQualifiers(); 7381 Qualifiers RQuals = RHSCan.getLocalQualifiers(); 7382 if (LQuals != RQuals) { 7383 // If any of these qualifiers are different, we have a type mismatch. 7384 if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() || 7385 LQuals.getAddressSpace() != RQuals.getAddressSpace()) 7386 return QualType(); 7387 7388 // Exactly one GC qualifier difference is allowed: __strong is 7389 // okay if the other type has no GC qualifier but is an Objective 7390 // C object pointer (i.e. implicitly strong by default). We fix 7391 // this by pretending that the unqualified type was actually 7392 // qualified __strong. 7393 Qualifiers::GC GC_L = LQuals.getObjCGCAttr(); 7394 Qualifiers::GC GC_R = RQuals.getObjCGCAttr(); 7395 assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements"); 7396 7397 if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak) 7398 return QualType(); 7399 7400 if (GC_L == Qualifiers::Strong) 7401 return LHS; 7402 if (GC_R == Qualifiers::Strong) 7403 return RHS; 7404 return QualType(); 7405 } 7406 7407 if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) { 7408 QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 7409 QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType(); 7410 QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT); 7411 if (ResQT == LHSBaseQT) 7412 return LHS; 7413 if (ResQT == RHSBaseQT) 7414 return RHS; 7415 } 7416 return QualType(); 7417} 7418 7419//===----------------------------------------------------------------------===// 7420// Integer Predicates 7421//===----------------------------------------------------------------------===// 7422 7423unsigned ASTContext::getIntWidth(QualType T) const { 7424 if (const EnumType *ET = dyn_cast<EnumType>(T)) 7425 T = ET->getDecl()->getIntegerType(); 7426 if (T->isBooleanType()) 7427 return 1; 7428 // For builtin types, just use the standard type sizing method 7429 return (unsigned)getTypeSize(T); 7430} 7431 7432QualType ASTContext::getCorrespondingUnsignedType(QualType T) const { 7433 assert(T->hasSignedIntegerRepresentation() && "Unexpected type"); 7434 7435 // Turn <4 x signed int> -> <4 x unsigned int> 7436 if (const VectorType *VTy = T->getAs<VectorType>()) 7437 return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()), 7438 VTy->getNumElements(), VTy->getVectorKind()); 7439 7440 // For enums, we return the unsigned version of the base type. 7441 if (const EnumType *ETy = T->getAs<EnumType>()) 7442 T = ETy->getDecl()->getIntegerType(); 7443 7444 const BuiltinType *BTy = T->getAs<BuiltinType>(); 7445 assert(BTy && "Unexpected signed integer type"); 7446 switch (BTy->getKind()) { 7447 case BuiltinType::Char_S: 7448 case BuiltinType::SChar: 7449 return UnsignedCharTy; 7450 case BuiltinType::Short: 7451 return UnsignedShortTy; 7452 case BuiltinType::Int: 7453 return UnsignedIntTy; 7454 case BuiltinType::Long: 7455 return UnsignedLongTy; 7456 case BuiltinType::LongLong: 7457 return UnsignedLongLongTy; 7458 case BuiltinType::Int128: 7459 return UnsignedInt128Ty; 7460 default: 7461 llvm_unreachable("Unexpected signed integer type"); 7462 } 7463} 7464 7465ASTMutationListener::~ASTMutationListener() { } 7466 7467void ASTMutationListener::DeducedReturnType(const FunctionDecl *FD, 7468 QualType ReturnType) {} 7469 7470//===----------------------------------------------------------------------===// 7471// Builtin Type Computation 7472//===----------------------------------------------------------------------===// 7473 7474/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the 7475/// pointer over the consumed characters. This returns the resultant type. If 7476/// AllowTypeModifiers is false then modifier like * are not parsed, just basic 7477/// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of 7478/// a vector of "i*". 7479/// 7480/// RequiresICE is filled in on return to indicate whether the value is required 7481/// to be an Integer Constant Expression. 7482static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context, 7483 ASTContext::GetBuiltinTypeError &Error, 7484 bool &RequiresICE, 7485 bool AllowTypeModifiers) { 7486 // Modifiers. 7487 int HowLong = 0; 7488 bool Signed = false, Unsigned = false; 7489 RequiresICE = false; 7490 7491 // Read the prefixed modifiers first. 7492 bool Done = false; 7493 while (!Done) { 7494 switch (*Str++) { 7495 default: Done = true; --Str; break; 7496 case 'I': 7497 RequiresICE = true; 7498 break; 7499 case 'S': 7500 assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!"); 7501 assert(!Signed && "Can't use 'S' modifier multiple times!"); 7502 Signed = true; 7503 break; 7504 case 'U': 7505 assert(!Signed && "Can't use both 'S' and 'U' modifiers!"); 7506 assert(!Unsigned && "Can't use 'S' modifier multiple times!"); 7507 Unsigned = true; 7508 break; 7509 case 'L': 7510 assert(HowLong <= 2 && "Can't have LLLL modifier"); 7511 ++HowLong; 7512 break; 7513 } 7514 } 7515 7516 QualType Type; 7517 7518 // Read the base type. 7519 switch (*Str++) { 7520 default: llvm_unreachable("Unknown builtin type letter!"); 7521 case 'v': 7522 assert(HowLong == 0 && !Signed && !Unsigned && 7523 "Bad modifiers used with 'v'!"); 7524 Type = Context.VoidTy; 7525 break; 7526 case 'f': 7527 assert(HowLong == 0 && !Signed && !Unsigned && 7528 "Bad modifiers used with 'f'!"); 7529 Type = Context.FloatTy; 7530 break; 7531 case 'd': 7532 assert(HowLong < 2 && !Signed && !Unsigned && 7533 "Bad modifiers used with 'd'!"); 7534 if (HowLong) 7535 Type = Context.LongDoubleTy; 7536 else 7537 Type = Context.DoubleTy; 7538 break; 7539 case 's': 7540 assert(HowLong == 0 && "Bad modifiers used with 's'!"); 7541 if (Unsigned) 7542 Type = Context.UnsignedShortTy; 7543 else 7544 Type = Context.ShortTy; 7545 break; 7546 case 'i': 7547 if (HowLong == 3) 7548 Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty; 7549 else if (HowLong == 2) 7550 Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy; 7551 else if (HowLong == 1) 7552 Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy; 7553 else 7554 Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy; 7555 break; 7556 case 'c': 7557 assert(HowLong == 0 && "Bad modifiers used with 'c'!"); 7558 if (Signed) 7559 Type = Context.SignedCharTy; 7560 else if (Unsigned) 7561 Type = Context.UnsignedCharTy; 7562 else 7563 Type = Context.CharTy; 7564 break; 7565 case 'b': // boolean 7566 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!"); 7567 Type = Context.BoolTy; 7568 break; 7569 case 'z': // size_t. 7570 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!"); 7571 Type = Context.getSizeType(); 7572 break; 7573 case 'F': 7574 Type = Context.getCFConstantStringType(); 7575 break; 7576 case 'G': 7577 Type = Context.getObjCIdType(); 7578 break; 7579 case 'H': 7580 Type = Context.getObjCSelType(); 7581 break; 7582 case 'M': 7583 Type = Context.getObjCSuperType(); 7584 break; 7585 case 'a': 7586 Type = Context.getBuiltinVaListType(); 7587 assert(!Type.isNull() && "builtin va list type not initialized!"); 7588 break; 7589 case 'A': 7590 // This is a "reference" to a va_list; however, what exactly 7591 // this means depends on how va_list is defined. There are two 7592 // different kinds of va_list: ones passed by value, and ones 7593 // passed by reference. An example of a by-value va_list is 7594 // x86, where va_list is a char*. An example of by-ref va_list 7595 // is x86-64, where va_list is a __va_list_tag[1]. For x86, 7596 // we want this argument to be a char*&; for x86-64, we want 7597 // it to be a __va_list_tag*. 7598 Type = Context.getBuiltinVaListType(); 7599 assert(!Type.isNull() && "builtin va list type not initialized!"); 7600 if (Type->isArrayType()) 7601 Type = Context.getArrayDecayedType(Type); 7602 else 7603 Type = Context.getLValueReferenceType(Type); 7604 break; 7605 case 'V': { 7606 char *End; 7607 unsigned NumElements = strtoul(Str, &End, 10); 7608 assert(End != Str && "Missing vector size"); 7609 Str = End; 7610 7611 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, 7612 RequiresICE, false); 7613 assert(!RequiresICE && "Can't require vector ICE"); 7614 7615 // TODO: No way to make AltiVec vectors in builtins yet. 7616 Type = Context.getVectorType(ElementType, NumElements, 7617 VectorType::GenericVector); 7618 break; 7619 } 7620 case 'E': { 7621 char *End; 7622 7623 unsigned NumElements = strtoul(Str, &End, 10); 7624 assert(End != Str && "Missing vector size"); 7625 7626 Str = End; 7627 7628 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE, 7629 false); 7630 Type = Context.getExtVectorType(ElementType, NumElements); 7631 break; 7632 } 7633 case 'X': { 7634 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE, 7635 false); 7636 assert(!RequiresICE && "Can't require complex ICE"); 7637 Type = Context.getComplexType(ElementType); 7638 break; 7639 } 7640 case 'Y' : { 7641 Type = Context.getPointerDiffType(); 7642 break; 7643 } 7644 case 'P': 7645 Type = Context.getFILEType(); 7646 if (Type.isNull()) { 7647 Error = ASTContext::GE_Missing_stdio; 7648 return QualType(); 7649 } 7650 break; 7651 case 'J': 7652 if (Signed) 7653 Type = Context.getsigjmp_bufType(); 7654 else 7655 Type = Context.getjmp_bufType(); 7656 7657 if (Type.isNull()) { 7658 Error = ASTContext::GE_Missing_setjmp; 7659 return QualType(); 7660 } 7661 break; 7662 case 'K': 7663 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!"); 7664 Type = Context.getucontext_tType(); 7665 7666 if (Type.isNull()) { 7667 Error = ASTContext::GE_Missing_ucontext; 7668 return QualType(); 7669 } 7670 break; 7671 case 'p': 7672 Type = Context.getProcessIDType(); 7673 break; 7674 } 7675 7676 // If there are modifiers and if we're allowed to parse them, go for it. 7677 Done = !AllowTypeModifiers; 7678 while (!Done) { 7679 switch (char c = *Str++) { 7680 default: Done = true; --Str; break; 7681 case '*': 7682 case '&': { 7683 // Both pointers and references can have their pointee types 7684 // qualified with an address space. 7685 char *End; 7686 unsigned AddrSpace = strtoul(Str, &End, 10); 7687 if (End != Str && AddrSpace != 0) { 7688 Type = Context.getAddrSpaceQualType(Type, AddrSpace); 7689 Str = End; 7690 } 7691 if (c == '*') 7692 Type = Context.getPointerType(Type); 7693 else 7694 Type = Context.getLValueReferenceType(Type); 7695 break; 7696 } 7697 // FIXME: There's no way to have a built-in with an rvalue ref arg. 7698 case 'C': 7699 Type = Type.withConst(); 7700 break; 7701 case 'D': 7702 Type = Context.getVolatileType(Type); 7703 break; 7704 case 'R': 7705 Type = Type.withRestrict(); 7706 break; 7707 } 7708 } 7709 7710 assert((!RequiresICE || Type->isIntegralOrEnumerationType()) && 7711 "Integer constant 'I' type must be an integer"); 7712 7713 return Type; 7714} 7715 7716/// GetBuiltinType - Return the type for the specified builtin. 7717QualType ASTContext::GetBuiltinType(unsigned Id, 7718 GetBuiltinTypeError &Error, 7719 unsigned *IntegerConstantArgs) const { 7720 const char *TypeStr = BuiltinInfo.GetTypeString(Id); 7721 7722 SmallVector<QualType, 8> ArgTypes; 7723 7724 bool RequiresICE = false; 7725 Error = GE_None; 7726 QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error, 7727 RequiresICE, true); 7728 if (Error != GE_None) 7729 return QualType(); 7730 7731 assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE"); 7732 7733 while (TypeStr[0] && TypeStr[0] != '.') { 7734 QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true); 7735 if (Error != GE_None) 7736 return QualType(); 7737 7738 // If this argument is required to be an IntegerConstantExpression and the 7739 // caller cares, fill in the bitmask we return. 7740 if (RequiresICE && IntegerConstantArgs) 7741 *IntegerConstantArgs |= 1 << ArgTypes.size(); 7742 7743 // Do array -> pointer decay. The builtin should use the decayed type. 7744 if (Ty->isArrayType()) 7745 Ty = getArrayDecayedType(Ty); 7746 7747 ArgTypes.push_back(Ty); 7748 } 7749 7750 assert((TypeStr[0] != '.' || TypeStr[1] == 0) && 7751 "'.' should only occur at end of builtin type list!"); 7752 7753 FunctionType::ExtInfo EI; 7754 if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true); 7755 7756 bool Variadic = (TypeStr[0] == '.'); 7757 7758 // We really shouldn't be making a no-proto type here, especially in C++. 7759 if (ArgTypes.empty() && Variadic) 7760 return getFunctionNoProtoType(ResType, EI); 7761 7762 FunctionProtoType::ExtProtoInfo EPI; 7763 EPI.ExtInfo = EI; 7764 EPI.Variadic = Variadic; 7765 7766 return getFunctionType(ResType, ArgTypes, EPI); 7767} 7768 7769GVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) { 7770 if (!FD->isExternallyVisible()) 7771 return GVA_Internal; 7772 7773 GVALinkage External = GVA_StrongExternal; 7774 switch (FD->getTemplateSpecializationKind()) { 7775 case TSK_Undeclared: 7776 case TSK_ExplicitSpecialization: 7777 External = GVA_StrongExternal; 7778 break; 7779 7780 case TSK_ExplicitInstantiationDefinition: 7781 return GVA_ExplicitTemplateInstantiation; 7782 7783 case TSK_ExplicitInstantiationDeclaration: 7784 case TSK_ImplicitInstantiation: 7785 External = GVA_TemplateInstantiation; 7786 break; 7787 } 7788 7789 if (!FD->isInlined()) 7790 return External; 7791 7792 if (!getLangOpts().CPlusPlus || FD->hasAttr<GNUInlineAttr>()) { 7793 // GNU or C99 inline semantics. Determine whether this symbol should be 7794 // externally visible. 7795 if (FD->isInlineDefinitionExternallyVisible()) 7796 return External; 7797 7798 // C99 inline semantics, where the symbol is not externally visible. 7799 return GVA_C99Inline; 7800 } 7801 7802 // C++0x [temp.explicit]p9: 7803 // [ Note: The intent is that an inline function that is the subject of 7804 // an explicit instantiation declaration will still be implicitly 7805 // instantiated when used so that the body can be considered for 7806 // inlining, but that no out-of-line copy of the inline function would be 7807 // generated in the translation unit. -- end note ] 7808 if (FD->getTemplateSpecializationKind() 7809 == TSK_ExplicitInstantiationDeclaration) 7810 return GVA_C99Inline; 7811 7812 return GVA_CXXInline; 7813} 7814 7815GVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) { 7816 if (!VD->isExternallyVisible()) 7817 return GVA_Internal; 7818 7819 // If this is a static data member, compute the kind of template 7820 // specialization. Otherwise, this variable is not part of a 7821 // template. 7822 TemplateSpecializationKind TSK = TSK_Undeclared; 7823 if (VD->isStaticDataMember()) 7824 TSK = VD->getTemplateSpecializationKind(); 7825 7826 switch (TSK) { 7827 case TSK_Undeclared: 7828 case TSK_ExplicitSpecialization: 7829 return GVA_StrongExternal; 7830 7831 case TSK_ExplicitInstantiationDeclaration: 7832 llvm_unreachable("Variable should not be instantiated"); 7833 // Fall through to treat this like any other instantiation. 7834 7835 case TSK_ExplicitInstantiationDefinition: 7836 return GVA_ExplicitTemplateInstantiation; 7837 7838 case TSK_ImplicitInstantiation: 7839 return GVA_TemplateInstantiation; 7840 } 7841} 7842 7843bool ASTContext::DeclMustBeEmitted(const Decl *D) { 7844 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 7845 if (!VD->isFileVarDecl()) 7846 return false; 7847 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 7848 // We never need to emit an uninstantiated function template. 7849 if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate) 7850 return false; 7851 } else 7852 return false; 7853 7854 // If this is a member of a class template, we do not need to emit it. 7855 if (D->getDeclContext()->isDependentContext()) 7856 return false; 7857 7858 // Weak references don't produce any output by themselves. 7859 if (D->hasAttr<WeakRefAttr>()) 7860 return false; 7861 7862 // Aliases and used decls are required. 7863 if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>()) 7864 return true; 7865 7866 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 7867 // Forward declarations aren't required. 7868 if (!FD->doesThisDeclarationHaveABody()) 7869 return FD->doesDeclarationForceExternallyVisibleDefinition(); 7870 7871 // Constructors and destructors are required. 7872 if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>()) 7873 return true; 7874 7875 // The key function for a class is required. This rule only comes 7876 // into play when inline functions can be key functions, though. 7877 if (getTargetInfo().getCXXABI().canKeyFunctionBeInline()) { 7878 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 7879 const CXXRecordDecl *RD = MD->getParent(); 7880 if (MD->isOutOfLine() && RD->isDynamicClass()) { 7881 const CXXMethodDecl *KeyFunc = getCurrentKeyFunction(RD); 7882 if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl()) 7883 return true; 7884 } 7885 } 7886 } 7887 7888 GVALinkage Linkage = GetGVALinkageForFunction(FD); 7889 7890 // static, static inline, always_inline, and extern inline functions can 7891 // always be deferred. Normal inline functions can be deferred in C99/C++. 7892 // Implicit template instantiations can also be deferred in C++. 7893 if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 7894 Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) 7895 return false; 7896 return true; 7897 } 7898 7899 const VarDecl *VD = cast<VarDecl>(D); 7900 assert(VD->isFileVarDecl() && "Expected file scoped var"); 7901 7902 if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) 7903 return false; 7904 7905 // Variables that can be needed in other TUs are required. 7906 GVALinkage L = GetGVALinkageForVariable(VD); 7907 if (L != GVA_Internal && L != GVA_TemplateInstantiation) 7908 return true; 7909 7910 // Variables that have destruction with side-effects are required. 7911 if (VD->getType().isDestructedType()) 7912 return true; 7913 7914 // Variables that have initialization with side-effects are required. 7915 if (VD->getInit() && VD->getInit()->HasSideEffects(*this)) 7916 return true; 7917 7918 return false; 7919} 7920 7921CallingConv ASTContext::getDefaultCXXMethodCallConv(bool isVariadic) { 7922 // Pass through to the C++ ABI object 7923 return ABI->getDefaultMethodCallConv(isVariadic); 7924} 7925 7926CallingConv ASTContext::getCanonicalCallConv(CallingConv CC) const { 7927 if (CC == CC_C && !LangOpts.MRTD && 7928 getTargetInfo().getCXXABI().isMemberFunctionCCDefault()) 7929 return CC_Default; 7930 return CC; 7931} 7932 7933bool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const { 7934 // Pass through to the C++ ABI object 7935 return ABI->isNearlyEmpty(RD); 7936} 7937 7938MangleContext *ASTContext::createMangleContext() { 7939 switch (Target->getCXXABI().getKind()) { 7940 case TargetCXXABI::GenericAArch64: 7941 case TargetCXXABI::GenericItanium: 7942 case TargetCXXABI::GenericARM: 7943 case TargetCXXABI::iOS: 7944 return createItaniumMangleContext(*this, getDiagnostics()); 7945 case TargetCXXABI::Microsoft: 7946 return createMicrosoftMangleContext(*this, getDiagnostics()); 7947 } 7948 llvm_unreachable("Unsupported ABI"); 7949} 7950 7951CXXABI::~CXXABI() {} 7952 7953size_t ASTContext::getSideTableAllocatedMemory() const { 7954 return ASTRecordLayouts.getMemorySize() 7955 + llvm::capacity_in_bytes(ObjCLayouts) 7956 + llvm::capacity_in_bytes(KeyFunctions) 7957 + llvm::capacity_in_bytes(ObjCImpls) 7958 + llvm::capacity_in_bytes(BlockVarCopyInits) 7959 + llvm::capacity_in_bytes(DeclAttrs) 7960 + llvm::capacity_in_bytes(InstantiatedFromStaticDataMember) 7961 + llvm::capacity_in_bytes(InstantiatedFromUsingDecl) 7962 + llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) 7963 + llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) 7964 + llvm::capacity_in_bytes(OverriddenMethods) 7965 + llvm::capacity_in_bytes(Types) 7966 + llvm::capacity_in_bytes(VariableArrayTypes) 7967 + llvm::capacity_in_bytes(ClassScopeSpecializationPattern); 7968} 7969 7970void ASTContext::addUnnamedTag(const TagDecl *Tag) { 7971 // FIXME: This mangling should be applied to function local classes too 7972 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl() || 7973 !isa<CXXRecordDecl>(Tag->getParent()) || 7974 !Tag->isExternallyVisible()) 7975 return; 7976 7977 std::pair<llvm::DenseMap<const DeclContext *, unsigned>::iterator, bool> P = 7978 UnnamedMangleContexts.insert(std::make_pair(Tag->getParent(), 0)); 7979 UnnamedMangleNumbers.insert(std::make_pair(Tag, P.first->second++)); 7980} 7981 7982int ASTContext::getUnnamedTagManglingNumber(const TagDecl *Tag) const { 7983 llvm::DenseMap<const TagDecl *, unsigned>::const_iterator I = 7984 UnnamedMangleNumbers.find(Tag); 7985 return I != UnnamedMangleNumbers.end() ? I->second : -1; 7986} 7987 7988unsigned ASTContext::getLambdaManglingNumber(CXXMethodDecl *CallOperator) { 7989 CXXRecordDecl *Lambda = CallOperator->getParent(); 7990 return LambdaMangleContexts[Lambda->getDeclContext()] 7991 .getManglingNumber(CallOperator); 7992} 7993 7994 7995void ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) { 7996 ParamIndices[D] = index; 7997} 7998 7999unsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const { 8000 ParameterIndexTable::const_iterator I = ParamIndices.find(D); 8001 assert(I != ParamIndices.end() && 8002 "ParmIndices lacks entry set by ParmVarDecl"); 8003 return I->second; 8004} 8005