blob: f4e53e6105856ec61953addd46467f59e473088d [file] [log] [blame]
Chris Lattnerddc135e2006-11-10 06:34:16 +00001//===--- ASTContext.cpp - Context to hold long-lived AST nodes ------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerddc135e2006-11-10 06:34:16 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the ASTContext interface.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ASTContext.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000015#include "CXXABI.h"
Benjamin Kramerea70eb32012-12-01 15:09:41 +000016#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/Attr.h"
Ken Dyck8c89d592009-12-22 14:23:30 +000018#include "clang/AST/CharUnits.h"
Benjamin Kramerea70eb32012-12-01 15:09:41 +000019#include "clang/AST/Comment.h"
Dmitri Gribenkoca7f80a2012-08-09 00:03:17 +000020#include "clang/AST/CommentCommandTraits.h"
Argyrios Kyrtzidisfaf08762008-08-07 20:55:28 +000021#include "clang/AST/DeclCXX.h"
Steve Naroff67391b82007-10-01 19:00:59 +000022#include "clang/AST/DeclObjC.h"
Douglas Gregorded2d7b2009-02-04 19:02:06 +000023#include "clang/AST/DeclTemplate.h"
Daniel Dunbar221fa942008-08-11 04:54:23 +000024#include "clang/AST/Expr.h"
John McCall87fe5d52010-05-20 01:18:31 +000025#include "clang/AST/ExprCXX.h"
Douglas Gregoref84c4b2009-04-09 22:27:44 +000026#include "clang/AST/ExternalASTSource.h"
Peter Collingbourne0ff0b372011-01-13 18:57:25 +000027#include "clang/AST/Mangle.h"
Benjamin Kramerea70eb32012-12-01 15:09:41 +000028#include "clang/AST/RecordLayout.h"
29#include "clang/AST/TypeLoc.h"
Chris Lattner15ba9492009-06-14 01:54:56 +000030#include "clang/Basic/Builtins.h"
Chris Lattnerd2868512009-03-28 03:45:20 +000031#include "clang/Basic/SourceManager.h"
Chris Lattner4dc8a6f2007-05-20 23:50:58 +000032#include "clang/Basic/TargetInfo.h"
Benjamin Kramer1402ce32009-10-24 09:57:09 +000033#include "llvm/ADT/SmallString.h"
Anders Carlssond8499822007-10-29 05:01:08 +000034#include "llvm/ADT/StringExtras.h"
Benjamin Kramerea70eb32012-12-01 15:09:41 +000035#include "llvm/Support/Capacity.h"
Nate Begemanb699c9b2009-01-18 06:42:49 +000036#include "llvm/Support/MathExtras.h"
Benjamin Kramer1402ce32009-10-24 09:57:09 +000037#include "llvm/Support/raw_ostream.h"
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +000038#include <map>
Anders Carlssona4267a62009-07-18 21:19:52 +000039
Chris Lattnerddc135e2006-11-10 06:34:16 +000040using namespace clang;
41
Douglas Gregor9672f922010-07-03 00:47:00 +000042unsigned ASTContext::NumImplicitDefaultConstructors;
43unsigned ASTContext::NumImplicitDefaultConstructorsDeclared;
Douglas Gregora6d69502010-07-02 23:41:54 +000044unsigned ASTContext::NumImplicitCopyConstructors;
45unsigned ASTContext::NumImplicitCopyConstructorsDeclared;
Alexis Huntfcaeae42011-05-25 20:50:04 +000046unsigned ASTContext::NumImplicitMoveConstructors;
47unsigned ASTContext::NumImplicitMoveConstructorsDeclared;
Douglas Gregor330b9cf2010-07-02 21:50:04 +000048unsigned ASTContext::NumImplicitCopyAssignmentOperators;
49unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
Alexis Huntfcaeae42011-05-25 20:50:04 +000050unsigned ASTContext::NumImplicitMoveAssignmentOperators;
51unsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
Douglas Gregor7454c562010-07-02 20:37:36 +000052unsigned ASTContext::NumImplicitDestructors;
53unsigned ASTContext::NumImplicitDestructorsDeclared;
54
Steve Naroff0af91202007-04-27 21:51:21 +000055enum FloatingRank {
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +000056 HalfRank, FloatRank, DoubleRank, LongDoubleRank
Steve Naroff0af91202007-04-27 21:51:21 +000057};
58
Dmitri Gribenkof26054f2012-07-11 21:38:39 +000059RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
Dmitri Gribenkoaab83832012-06-20 00:34:58 +000060 if (!CommentsLoaded && ExternalSource) {
61 ExternalSource->ReadComments();
62 CommentsLoaded = true;
63 }
64
65 assert(D);
66
Dmitri Gribenkodf17d642012-06-28 16:19:39 +000067 // User can not attach documentation to implicit declarations.
68 if (D->isImplicit())
69 return NULL;
70
Dmitri Gribenkob2610882012-08-14 17:17:18 +000071 // User can not attach documentation to implicit instantiations.
72 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
73 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
74 return NULL;
75 }
76
Dmitri Gribenkob1ad9932012-08-20 22:36:31 +000077 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
78 if (VD->isStaticDataMember() &&
79 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
80 return NULL;
81 }
82
83 if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) {
84 if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
85 return NULL;
86 }
87
Dmitri Gribenko01b06512013-01-27 21:18:39 +000088 if (const ClassTemplateSpecializationDecl *CTSD =
89 dyn_cast<ClassTemplateSpecializationDecl>(D)) {
90 TemplateSpecializationKind TSK = CTSD->getSpecializationKind();
91 if (TSK == TSK_ImplicitInstantiation ||
92 TSK == TSK_Undeclared)
93 return NULL;
94 }
95
Dmitri Gribenkob1ad9932012-08-20 22:36:31 +000096 if (const EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
97 if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
98 return NULL;
99 }
Fariborz Jahanian799a4032013-04-17 21:05:20 +0000100 if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
101 // When tag declaration (but not definition!) is part of the
102 // decl-specifier-seq of some other declaration, it doesn't get comment
103 if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
104 return NULL;
105 }
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000106 // TODO: handle comments for function parameters properly.
107 if (isa<ParmVarDecl>(D))
108 return NULL;
109
Dmitri Gribenko34df2202012-07-31 22:37:06 +0000110 // TODO: we could look up template parameter documentation in the template
111 // documentation.
112 if (isa<TemplateTypeParmDecl>(D) ||
113 isa<NonTypeTemplateParmDecl>(D) ||
114 isa<TemplateTemplateParmDecl>(D))
115 return NULL;
116
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +0000117 ArrayRef<RawComment *> RawComments = Comments.getComments();
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000118
119 // If there are no comments anywhere, we won't find anything.
120 if (RawComments.empty())
121 return NULL;
122
Dmitri Gribenkoe7bb9442012-07-13 01:06:46 +0000123 // Find declaration location.
124 // For Objective-C declarations we generally don't expect to have multiple
125 // declarators, thus use declaration starting location as the "declaration
126 // location".
127 // For all other declarations multiple declarators are used quite frequently,
128 // so we use the location of the identifier as the "declaration location".
129 SourceLocation DeclLoc;
130 if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) ||
Dmitri Gribenko34df2202012-07-31 22:37:06 +0000131 isa<ObjCPropertyDecl>(D) ||
Dmitri Gribenko7f4b3772012-08-02 20:49:51 +0000132 isa<RedeclarableTemplateDecl>(D) ||
133 isa<ClassTemplateSpecializationDecl>(D))
Dmitri Gribenkoe7bb9442012-07-13 01:06:46 +0000134 DeclLoc = D->getLocStart();
135 else
136 DeclLoc = D->getLocation();
137
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000138 // If the declaration doesn't map directly to a location in a file, we
139 // can't find the comment.
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000140 if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
141 return NULL;
142
143 // Find the comment that occurs just after this declaration.
Dmitri Gribenko82ea9472012-07-17 22:01:09 +0000144 ArrayRef<RawComment *>::iterator Comment;
145 {
146 // When searching for comments during parsing, the comment we are looking
147 // for is usually among the last two comments we parsed -- check them
148 // first.
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +0000149 RawComment CommentAtDeclLoc(
150 SourceMgr, SourceRange(DeclLoc), false,
151 LangOpts.CommentOpts.ParseAllComments);
Dmitri Gribenko82ea9472012-07-17 22:01:09 +0000152 BeforeThanCompare<RawComment> Compare(SourceMgr);
153 ArrayRef<RawComment *>::iterator MaybeBeforeDecl = RawComments.end() - 1;
154 bool Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
155 if (!Found && RawComments.size() >= 2) {
156 MaybeBeforeDecl--;
157 Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
158 }
159
160 if (Found) {
161 Comment = MaybeBeforeDecl + 1;
162 assert(Comment == std::lower_bound(RawComments.begin(), RawComments.end(),
163 &CommentAtDeclLoc, Compare));
164 } else {
165 // Slow path.
166 Comment = std::lower_bound(RawComments.begin(), RawComments.end(),
167 &CommentAtDeclLoc, Compare);
168 }
169 }
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000170
171 // Decompose the location for the declaration and find the beginning of the
172 // file buffer.
173 std::pair<FileID, unsigned> DeclLocDecomp = SourceMgr.getDecomposedLoc(DeclLoc);
174
175 // First check whether we have a trailing comment.
176 if (Comment != RawComments.end() &&
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +0000177 (*Comment)->isDocumentation() && (*Comment)->isTrailingComment() &&
Dmitri Gribenko44cd7e62012-07-06 23:27:33 +0000178 (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D))) {
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000179 std::pair<FileID, unsigned> CommentBeginDecomp
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +0000180 = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getBegin());
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000181 // Check that Doxygen trailing comment comes after the declaration, starts
182 // on the same line and in the same file as the declaration.
183 if (DeclLocDecomp.first == CommentBeginDecomp.first &&
184 SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second)
185 == SourceMgr.getLineNumber(CommentBeginDecomp.first,
186 CommentBeginDecomp.second)) {
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +0000187 return *Comment;
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000188 }
189 }
190
191 // The comment just after the declaration was not a trailing comment.
192 // Let's look at the previous comment.
193 if (Comment == RawComments.begin())
194 return NULL;
195 --Comment;
196
197 // Check that we actually have a non-member Doxygen comment.
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +0000198 if (!(*Comment)->isDocumentation() || (*Comment)->isTrailingComment())
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000199 return NULL;
200
201 // Decompose the end of the comment.
202 std::pair<FileID, unsigned> CommentEndDecomp
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +0000203 = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getEnd());
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000204
205 // If the comment and the declaration aren't in the same file, then they
206 // aren't related.
207 if (DeclLocDecomp.first != CommentEndDecomp.first)
208 return NULL;
209
210 // Get the corresponding buffer.
211 bool Invalid = false;
212 const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,
213 &Invalid).data();
214 if (Invalid)
215 return NULL;
216
217 // Extract text between the comment and declaration.
218 StringRef Text(Buffer + CommentEndDecomp.second,
219 DeclLocDecomp.second - CommentEndDecomp.second);
220
Dmitri Gribenko7e8729b2012-06-27 23:43:37 +0000221 // There should be no other declarations or preprocessor directives between
222 // comment and declaration.
Dmitri Gribenkoe7bb9442012-07-13 01:06:46 +0000223 if (Text.find_first_of(",;{}#@") != StringRef::npos)
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000224 return NULL;
225
Dmitri Gribenko7dd29d42012-07-06 18:19:34 +0000226 return *Comment;
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000227}
228
Dmitri Gribenkob2610882012-08-14 17:17:18 +0000229namespace {
230/// If we have a 'templated' declaration for a template, adjust 'D' to
231/// refer to the actual template.
Dmitri Gribenko90631802012-08-22 17:44:32 +0000232/// If we have an implicit instantiation, adjust 'D' to refer to template.
Dmitri Gribenkob2610882012-08-14 17:17:18 +0000233const Decl *adjustDeclToTemplate(const Decl *D) {
Douglas Gregor35ceb272012-08-13 16:37:30 +0000234 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Dmitri Gribenko90631802012-08-22 17:44:32 +0000235 // Is this function declaration part of a function template?
Douglas Gregor35ceb272012-08-13 16:37:30 +0000236 if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
Dmitri Gribenko90631802012-08-22 17:44:32 +0000237 return FTD;
238
239 // Nothing to do if function is not an implicit instantiation.
240 if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
241 return D;
242
243 // Function is an implicit instantiation of a function template?
244 if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())
245 return FTD;
246
247 // Function is instantiated from a member definition of a class template?
248 if (const FunctionDecl *MemberDecl =
249 FD->getInstantiatedFromMemberFunction())
250 return MemberDecl;
251
252 return D;
Douglas Gregor35ceb272012-08-13 16:37:30 +0000253 }
Dmitri Gribenko90631802012-08-22 17:44:32 +0000254 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
255 // Static data member is instantiated from a member definition of a class
256 // template?
257 if (VD->isStaticDataMember())
258 if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember())
259 return MemberDecl;
260
261 return D;
262 }
263 if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) {
264 // Is this class declaration part of a class template?
265 if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate())
266 return CTD;
267
268 // Class is an implicit instantiation of a class template or partial
269 // specialization?
270 if (const ClassTemplateSpecializationDecl *CTSD =
271 dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
272 if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation)
273 return D;
274 llvm::PointerUnion<ClassTemplateDecl *,
275 ClassTemplatePartialSpecializationDecl *>
276 PU = CTSD->getSpecializedTemplateOrPartial();
277 return PU.is<ClassTemplateDecl*>() ?
278 static_cast<const Decl*>(PU.get<ClassTemplateDecl *>()) :
279 static_cast<const Decl*>(
280 PU.get<ClassTemplatePartialSpecializationDecl *>());
281 }
282
283 // Class is instantiated from a member definition of a class template?
284 if (const MemberSpecializationInfo *Info =
285 CRD->getMemberSpecializationInfo())
286 return Info->getInstantiatedFrom();
287
288 return D;
289 }
290 if (const EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
291 // Enum is instantiated from a member definition of a class template?
292 if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum())
293 return MemberDecl;
294
295 return D;
296 }
297 // FIXME: Adjust alias templates?
Dmitri Gribenkob2610882012-08-14 17:17:18 +0000298 return D;
299}
300} // unnamed namespace
301
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000302const RawComment *ASTContext::getRawCommentForAnyRedecl(
303 const Decl *D,
304 const Decl **OriginalDecl) const {
Dmitri Gribenkob2610882012-08-14 17:17:18 +0000305 D = adjustDeclToTemplate(D);
Douglas Gregor35ceb272012-08-13 16:37:30 +0000306
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000307 // Check whether we have cached a comment for this declaration already.
308 {
309 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
310 RedeclComments.find(D);
311 if (Pos != RedeclComments.end()) {
312 const RawCommentAndCacheFlags &Raw = Pos->second;
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000313 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) {
314 if (OriginalDecl)
315 *OriginalDecl = Raw.getOriginalDecl();
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000316 return Raw.getRaw();
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000317 }
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000318 }
Dmitri Gribenkoec925312012-07-06 00:28:32 +0000319 }
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000320
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000321 // Search for comments attached to declarations in the redeclaration chain.
322 const RawComment *RC = NULL;
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000323 const Decl *OriginalDeclForRC = NULL;
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000324 for (Decl::redecl_iterator I = D->redecls_begin(),
325 E = D->redecls_end();
326 I != E; ++I) {
327 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
328 RedeclComments.find(*I);
329 if (Pos != RedeclComments.end()) {
330 const RawCommentAndCacheFlags &Raw = Pos->second;
331 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) {
332 RC = Raw.getRaw();
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000333 OriginalDeclForRC = Raw.getOriginalDecl();
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000334 break;
335 }
336 } else {
337 RC = getRawCommentForDeclNoCache(*I);
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000338 OriginalDeclForRC = *I;
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000339 RawCommentAndCacheFlags Raw;
340 if (RC) {
341 Raw.setRaw(RC);
342 Raw.setKind(RawCommentAndCacheFlags::FromDecl);
343 } else
344 Raw.setKind(RawCommentAndCacheFlags::NoCommentInDecl);
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000345 Raw.setOriginalDecl(*I);
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000346 RedeclComments[*I] = Raw;
347 if (RC)
348 break;
349 }
350 }
351
Dmitri Gribenko5c8897d2012-06-28 16:25:36 +0000352 // If we found a comment, it should be a documentation comment.
353 assert(!RC || RC->isDocumentation());
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000354
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000355 if (OriginalDecl)
356 *OriginalDecl = OriginalDeclForRC;
357
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000358 // Update cache for every declaration in the redeclaration chain.
359 RawCommentAndCacheFlags Raw;
360 Raw.setRaw(RC);
361 Raw.setKind(RawCommentAndCacheFlags::FromRedecl);
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000362 Raw.setOriginalDecl(OriginalDeclForRC);
Dmitri Gribenkoa43ec182012-08-11 00:51:43 +0000363
364 for (Decl::redecl_iterator I = D->redecls_begin(),
365 E = D->redecls_end();
366 I != E; ++I) {
367 RawCommentAndCacheFlags &R = RedeclComments[*I];
368 if (R.getKind() == RawCommentAndCacheFlags::NoCommentInDecl)
369 R = Raw;
370 }
371
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000372 return RC;
373}
374
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000375static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod,
376 SmallVectorImpl<const NamedDecl *> &Redeclared) {
377 const DeclContext *DC = ObjCMethod->getDeclContext();
378 if (const ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(DC)) {
379 const ObjCInterfaceDecl *ID = IMD->getClassInterface();
380 if (!ID)
381 return;
382 // Add redeclared method here.
Douglas Gregor048fbfa2013-01-16 23:00:23 +0000383 for (ObjCInterfaceDecl::known_extensions_iterator
384 Ext = ID->known_extensions_begin(),
385 ExtEnd = ID->known_extensions_end();
386 Ext != ExtEnd; ++Ext) {
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000387 if (ObjCMethodDecl *RedeclaredMethod =
Douglas Gregor048fbfa2013-01-16 23:00:23 +0000388 Ext->getMethod(ObjCMethod->getSelector(),
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000389 ObjCMethod->isInstanceMethod()))
390 Redeclared.push_back(RedeclaredMethod);
391 }
392 }
393}
394
Fariborz Jahanian42e31322012-10-11 23:52:50 +0000395comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC,
396 const Decl *D) const {
397 comments::DeclInfo *ThisDeclInfo = new (*this) comments::DeclInfo;
398 ThisDeclInfo->CommentDecl = D;
399 ThisDeclInfo->IsFilled = false;
400 ThisDeclInfo->fill();
401 ThisDeclInfo->CommentDecl = FC->getDecl();
402 comments::FullComment *CFC =
403 new (*this) comments::FullComment(FC->getBlocks(),
404 ThisDeclInfo);
405 return CFC;
406
407}
408
Dmitri Gribenko6743e042012-09-29 11:40:46 +0000409comments::FullComment *ASTContext::getCommentForDecl(
410 const Decl *D,
411 const Preprocessor *PP) const {
Dmitri Gribenkob2610882012-08-14 17:17:18 +0000412 D = adjustDeclToTemplate(D);
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000413
Dmitri Gribenkob2610882012-08-14 17:17:18 +0000414 const Decl *Canonical = D->getCanonicalDecl();
415 llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
416 ParsedComments.find(Canonical);
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000417
418 if (Pos != ParsedComments.end()) {
Fariborz Jahanian42e31322012-10-11 23:52:50 +0000419 if (Canonical != D) {
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000420 comments::FullComment *FC = Pos->second;
Fariborz Jahanian42e31322012-10-11 23:52:50 +0000421 comments::FullComment *CFC = cloneFullComment(FC, D);
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000422 return CFC;
423 }
Dmitri Gribenkob2610882012-08-14 17:17:18 +0000424 return Pos->second;
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000425 }
426
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000427 const Decl *OriginalDecl;
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000428
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000429 const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000430 if (!RC) {
431 if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
Dmitri Gribenko941ab0f2012-11-03 14:24:57 +0000432 SmallVector<const NamedDecl*, 8> Overridden;
Fariborz Jahanian37494a12013-01-12 00:28:34 +0000433 const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D);
Fariborz Jahanian66024d02013-01-25 23:08:39 +0000434 if (OMD && OMD->isPropertyAccessor())
435 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
436 if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))
437 return cloneFullComment(FC, D);
Fariborz Jahanian37494a12013-01-12 00:28:34 +0000438 if (OMD)
Dmitri Gribenko941ab0f2012-11-03 14:24:57 +0000439 addRedeclaredMethods(OMD, Overridden);
440 getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden);
Fariborz Jahanian66024d02013-01-25 23:08:39 +0000441 for (unsigned i = 0, e = Overridden.size(); i < e; i++)
442 if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP))
443 return cloneFullComment(FC, D);
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000444 }
Fariborz Jahanian6384fbb2013-05-02 15:44:16 +0000445 else if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
Dmitri Gribenko01b06512013-01-27 21:18:39 +0000446 // Attach any tag type's documentation to its typedef if latter
Fariborz Jahanian66024d02013-01-25 23:08:39 +0000447 // does not have one of its own.
Fariborz Jahanian40abf342013-01-25 22:48:32 +0000448 QualType QT = TD->getUnderlyingType();
Dmitri Gribenko01b06512013-01-27 21:18:39 +0000449 if (const TagType *TT = QT->getAs<TagType>())
450 if (const Decl *TD = TT->getDecl())
451 if (comments::FullComment *FC = getCommentForDecl(TD, PP))
Fariborz Jahanian66024d02013-01-25 23:08:39 +0000452 return cloneFullComment(FC, D);
Fariborz Jahanian40abf342013-01-25 22:48:32 +0000453 }
Fariborz Jahaniane970c1b2013-04-26 20:55:38 +0000454 else if (const ObjCInterfaceDecl *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
455 while (IC->getSuperClass()) {
456 IC = IC->getSuperClass();
457 if (comments::FullComment *FC = getCommentForDecl(IC, PP))
458 return cloneFullComment(FC, D);
459 }
460 }
461 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) {
462 if (const ObjCInterfaceDecl *IC = CD->getClassInterface())
463 if (comments::FullComment *FC = getCommentForDecl(IC, PP))
464 return cloneFullComment(FC, D);
465 }
466 else if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
467 if (!(RD = RD->getDefinition()))
468 return NULL;
469 // Check non-virtual bases.
470 for (CXXRecordDecl::base_class_const_iterator I =
471 RD->bases_begin(), E = RD->bases_end(); I != E; ++I) {
Fariborz Jahanian5a2e4a22013-04-26 23:34:36 +0000472 if (I->isVirtual() || (I->getAccessSpecifier() != AS_public))
Fariborz Jahaniane970c1b2013-04-26 20:55:38 +0000473 continue;
474 QualType Ty = I->getType();
475 if (Ty.isNull())
476 continue;
477 if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) {
478 if (!(NonVirtualBase= NonVirtualBase->getDefinition()))
479 continue;
480
481 if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP))
482 return cloneFullComment(FC, D);
483 }
484 }
485 // Check virtual bases.
486 for (CXXRecordDecl::base_class_const_iterator I =
487 RD->vbases_begin(), E = RD->vbases_end(); I != E; ++I) {
Fariborz Jahanian5a2e4a22013-04-26 23:34:36 +0000488 if (I->getAccessSpecifier() != AS_public)
489 continue;
Fariborz Jahaniane970c1b2013-04-26 20:55:38 +0000490 QualType Ty = I->getType();
491 if (Ty.isNull())
492 continue;
493 if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) {
494 if (!(VirtualBase= VirtualBase->getDefinition()))
495 continue;
496 if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP))
497 return cloneFullComment(FC, D);
498 }
499 }
500 }
Dmitri Gribenkoec925312012-07-06 00:28:32 +0000501 return NULL;
Fariborz Jahanian1c883b92012-10-10 18:34:52 +0000502 }
503
Dmitri Gribenkobfda9f72012-08-22 18:12:19 +0000504 // If the RawComment was attached to other redeclaration of this Decl, we
505 // should parse the comment in context of that other Decl. This is important
506 // because comments can contain references to parameter names which can be
507 // different across redeclarations.
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000508 if (D != OriginalDecl)
Dmitri Gribenko6743e042012-09-29 11:40:46 +0000509 return getCommentForDecl(OriginalDecl, PP);
Dmitri Gribenko4ae66a32012-08-16 18:19:43 +0000510
Dmitri Gribenko6743e042012-09-29 11:40:46 +0000511 comments::FullComment *FC = RC->parse(*this, PP, D);
Dmitri Gribenkob2610882012-08-14 17:17:18 +0000512 ParsedComments[Canonical] = FC;
513 return FC;
Dmitri Gribenkoec925312012-07-06 00:28:32 +0000514}
515
Douglas Gregor7dbfb462010-06-16 21:09:37 +0000516void
517ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
518 TemplateTemplateParmDecl *Parm) {
519 ID.AddInteger(Parm->getDepth());
520 ID.AddInteger(Parm->getPosition());
Douglas Gregorf5500772011-01-05 15:48:55 +0000521 ID.AddBoolean(Parm->isParameterPack());
Douglas Gregor7dbfb462010-06-16 21:09:37 +0000522
523 TemplateParameterList *Params = Parm->getTemplateParameters();
524 ID.AddInteger(Params->size());
525 for (TemplateParameterList::const_iterator P = Params->begin(),
526 PEnd = Params->end();
527 P != PEnd; ++P) {
528 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
529 ID.AddInteger(0);
530 ID.AddBoolean(TTP->isParameterPack());
531 continue;
532 }
533
534 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
535 ID.AddInteger(1);
Douglas Gregorf5500772011-01-05 15:48:55 +0000536 ID.AddBoolean(NTTP->isParameterPack());
Eli Friedman205a4292012-03-07 01:09:33 +0000537 ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
Douglas Gregor0231d8d2011-01-19 20:10:05 +0000538 if (NTTP->isExpandedParameterPack()) {
539 ID.AddBoolean(true);
540 ID.AddInteger(NTTP->getNumExpansionTypes());
Eli Friedman205a4292012-03-07 01:09:33 +0000541 for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
542 QualType T = NTTP->getExpansionType(I);
543 ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
544 }
Douglas Gregor0231d8d2011-01-19 20:10:05 +0000545 } else
546 ID.AddBoolean(false);
Douglas Gregor7dbfb462010-06-16 21:09:37 +0000547 continue;
548 }
549
550 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
551 ID.AddInteger(2);
552 Profile(ID, TTP);
553 }
554}
555
556TemplateTemplateParmDecl *
557ASTContext::getCanonicalTemplateTemplateParmDecl(
Jay Foad39c79802011-01-12 09:06:06 +0000558 TemplateTemplateParmDecl *TTP) const {
Douglas Gregor7dbfb462010-06-16 21:09:37 +0000559 // Check if we already have a canonical template template parameter.
560 llvm::FoldingSetNodeID ID;
561 CanonicalTemplateTemplateParm::Profile(ID, TTP);
562 void *InsertPos = 0;
563 CanonicalTemplateTemplateParm *Canonical
564 = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
565 if (Canonical)
566 return Canonical->getParam();
567
568 // Build a canonical template parameter list.
569 TemplateParameterList *Params = TTP->getTemplateParameters();
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000570 SmallVector<NamedDecl *, 4> CanonParams;
Douglas Gregor7dbfb462010-06-16 21:09:37 +0000571 CanonParams.reserve(Params->size());
572 for (TemplateParameterList::const_iterator P = Params->begin(),
573 PEnd = Params->end();
574 P != PEnd; ++P) {
575 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P))
576 CanonParams.push_back(
577 TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(),
Abramo Bagnarab3185b02011-03-06 15:48:19 +0000578 SourceLocation(),
579 SourceLocation(),
580 TTP->getDepth(),
Douglas Gregor7dbfb462010-06-16 21:09:37 +0000581 TTP->getIndex(), 0, false,
582 TTP->isParameterPack()));
583 else if (NonTypeTemplateParmDecl *NTTP
Douglas Gregor0231d8d2011-01-19 20:10:05 +0000584 = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
585 QualType T = getCanonicalType(NTTP->getType());
586 TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
587 NonTypeTemplateParmDecl *Param;
588 if (NTTP->isExpandedParameterPack()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000589 SmallVector<QualType, 2> ExpandedTypes;
590 SmallVector<TypeSourceInfo *, 2> ExpandedTInfos;
Douglas Gregor0231d8d2011-01-19 20:10:05 +0000591 for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
592 ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I)));
593 ExpandedTInfos.push_back(
594 getTrivialTypeSourceInfo(ExpandedTypes.back()));
595 }
596
597 Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
Abramo Bagnaradff19302011-03-08 08:55:46 +0000598 SourceLocation(),
599 SourceLocation(),
Douglas Gregor0231d8d2011-01-19 20:10:05 +0000600 NTTP->getDepth(),
601 NTTP->getPosition(), 0,
602 T,
603 TInfo,
604 ExpandedTypes.data(),
605 ExpandedTypes.size(),
606 ExpandedTInfos.data());
607 } else {
608 Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
Abramo Bagnaradff19302011-03-08 08:55:46 +0000609 SourceLocation(),
610 SourceLocation(),
Douglas Gregor0231d8d2011-01-19 20:10:05 +0000611 NTTP->getDepth(),
612 NTTP->getPosition(), 0,
613 T,
614 NTTP->isParameterPack(),
615 TInfo);
616 }
617 CanonParams.push_back(Param);
618
619 } else
Douglas Gregor7dbfb462010-06-16 21:09:37 +0000620 CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
621 cast<TemplateTemplateParmDecl>(*P)));
622 }
623
624 TemplateTemplateParmDecl *CanonTTP
625 = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
626 SourceLocation(), TTP->getDepth(),
Douglas Gregorf5500772011-01-05 15:48:55 +0000627 TTP->getPosition(),
628 TTP->isParameterPack(),
629 0,
Douglas Gregor7dbfb462010-06-16 21:09:37 +0000630 TemplateParameterList::Create(*this, SourceLocation(),
631 SourceLocation(),
632 CanonParams.data(),
633 CanonParams.size(),
634 SourceLocation()));
635
636 // Get the new insert position for the node we care about.
637 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
638 assert(Canonical == 0 && "Shouldn't be in the map!");
639 (void)Canonical;
640
641 // Create the canonical template template parameter entry.
642 Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);
643 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
644 return CanonTTP;
645}
646
Charles Davis53c59df2010-08-16 03:33:14 +0000647CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
John McCall86353412010-08-21 22:46:04 +0000648 if (!LangOpts.CPlusPlus) return 0;
649
John McCall359b8852013-01-25 22:30:49 +0000650 switch (T.getCXXABI().getKind()) {
651 case TargetCXXABI::GenericARM:
652 case TargetCXXABI::iOS:
John McCall86353412010-08-21 22:46:04 +0000653 return CreateARMCXXABI(*this);
Tim Northover9bb857a2013-01-31 12:13:10 +0000654 case TargetCXXABI::GenericAArch64: // Same as Itanium at this level
John McCall359b8852013-01-25 22:30:49 +0000655 case TargetCXXABI::GenericItanium:
Charles Davis53c59df2010-08-16 03:33:14 +0000656 return CreateItaniumCXXABI(*this);
John McCall359b8852013-01-25 22:30:49 +0000657 case TargetCXXABI::Microsoft:
Charles Davis6bcb07a2010-08-19 02:18:14 +0000658 return CreateMicrosoftCXXABI(*this);
659 }
David Blaikie8a40f702012-01-17 06:56:22 +0000660 llvm_unreachable("Invalid CXXABI type!");
Charles Davis53c59df2010-08-16 03:33:14 +0000661}
662
Douglas Gregore8bbc122011-09-02 00:18:52 +0000663static const LangAS::Map *getAddressSpaceMap(const TargetInfo &T,
Peter Collingbourne599cb8e2011-03-18 22:38:29 +0000664 const LangOptions &LOpts) {
665 if (LOpts.FakeAddressSpaceMap) {
666 // The fake address space map must have a distinct entry for each
667 // language-specific address space.
668 static const unsigned FakeAddrSpaceMap[] = {
669 1, // opencl_global
670 2, // opencl_local
Peter Collingbournef44bdf92012-05-20 21:08:35 +0000671 3, // opencl_constant
672 4, // cuda_device
673 5, // cuda_constant
674 6 // cuda_shared
Peter Collingbourne599cb8e2011-03-18 22:38:29 +0000675 };
Douglas Gregore8bbc122011-09-02 00:18:52 +0000676 return &FakeAddrSpaceMap;
Peter Collingbourne599cb8e2011-03-18 22:38:29 +0000677 } else {
Douglas Gregore8bbc122011-09-02 00:18:52 +0000678 return &T.getAddressSpaceMap();
Peter Collingbourne599cb8e2011-03-18 22:38:29 +0000679 }
680}
681
Douglas Gregor7018d5b2011-09-01 20:23:19 +0000682ASTContext::ASTContext(LangOptions& LOpts, SourceManager &SM,
Douglas Gregore8bbc122011-09-02 00:18:52 +0000683 const TargetInfo *t,
Daniel Dunbar221fa942008-08-11 04:54:23 +0000684 IdentifierTable &idents, SelectorTable &sels,
Chris Lattner15ba9492009-06-14 01:54:56 +0000685 Builtin::Context &builtins,
Douglas Gregore8bbc122011-09-02 00:18:52 +0000686 unsigned size_reserve,
687 bool DelayInitialization)
688 : FunctionProtoTypes(this_()),
689 TemplateSpecializationTypes(this_()),
690 DependentTemplateSpecializationTypes(this_()),
691 SubstTemplateTemplateParmPacks(this_()),
692 GlobalNestedNameSpecifier(0),
693 Int128Decl(0), UInt128Decl(0),
Meador Inge5d3fb222012-06-16 03:34:49 +0000694 BuiltinVaListDecl(0),
Douglas Gregord53ae832012-01-17 18:09:05 +0000695 ObjCIdDecl(0), ObjCSelDecl(0), ObjCClassDecl(0), ObjCProtocolClassDecl(0),
Fariborz Jahanianf2578572012-08-30 18:49:41 +0000696 BOOLDecl(0),
Douglas Gregorbab8a962011-09-08 01:46:34 +0000697 CFConstantStringTypeDecl(0), ObjCInstanceTypeDecl(0),
Douglas Gregore8bbc122011-09-02 00:18:52 +0000698 FILEDecl(0),
Rafael Espindola6cfa82b2011-11-13 21:51:09 +0000699 jmp_bufDecl(0), sigjmp_bufDecl(0), ucontext_tDecl(0),
700 BlockDescriptorType(0), BlockDescriptorExtendedType(0),
701 cudaConfigureCallDecl(0),
Douglas Gregor0f2a3602011-12-03 00:30:27 +0000702 NullTypeSourceInfo(QualType()),
703 FirstLocalImport(), LastLocalImport(),
Douglas Gregore8bbc122011-09-02 00:18:52 +0000704 SourceMgr(SM), LangOpts(LOpts),
Douglas Gregorc0b07282011-09-27 22:38:19 +0000705 AddrSpaceMap(0), Target(t), PrintingPolicy(LOpts),
Douglas Gregore8bbc122011-09-02 00:18:52 +0000706 Idents(idents), Selectors(sels),
707 BuiltinInfo(builtins),
708 DeclarationNames(*this),
Douglas Gregorc0b07282011-09-27 22:38:19 +0000709 ExternalSource(0), Listener(0),
Dmitri Gribenkoaab83832012-06-20 00:34:58 +0000710 Comments(SM), CommentsLoaded(false),
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +0000711 CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
Douglas Gregore8bbc122011-09-02 00:18:52 +0000712 LastSDM(0, 0),
Fariborz Jahaniancb6c8672013-01-04 18:45:40 +0000713 UniqueBlockByRefTypeID(0)
Douglas Gregore8bbc122011-09-02 00:18:52 +0000714{
Mike Stump11289f42009-09-09 15:08:12 +0000715 if (size_reserve > 0) Types.reserve(size_reserve);
Daniel Dunbar221fa942008-08-11 04:54:23 +0000716 TUDecl = TranslationUnitDecl::Create(*this);
Douglas Gregore8bbc122011-09-02 00:18:52 +0000717
718 if (!DelayInitialization) {
719 assert(t && "No target supplied for ASTContext initialization");
720 InitBuiltinTypes(*t);
721 }
Daniel Dunbar221fa942008-08-11 04:54:23 +0000722}
723
Chris Lattnerd5973eb2006-11-12 00:53:46 +0000724ASTContext::~ASTContext() {
Ted Kremenekda4e0d32010-02-11 07:12:28 +0000725 // Release the DenseMaps associated with DeclContext objects.
726 // FIXME: Is this the ideal solution?
727 ReleaseDeclContextMaps();
Douglas Gregor832940b2010-03-02 23:58:15 +0000728
Douglas Gregor5b11d492010-07-25 17:53:33 +0000729 // Call all of the deallocation functions.
730 for (unsigned I = 0, N = Deallocations.size(); I != N; ++I)
731 Deallocations[I].first(Deallocations[I].second);
Douglas Gregor1a809332010-05-23 18:26:36 +0000732
Ted Kremenek076baeb2010-06-08 23:00:58 +0000733 // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed
Douglas Gregor5b11d492010-07-25 17:53:33 +0000734 // because they can contain DenseMaps.
735 for (llvm::DenseMap<const ObjCContainerDecl*,
736 const ASTRecordLayout*>::iterator
737 I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
738 // Increment in loop to prevent using deallocated memory.
739 if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second))
740 R->Destroy(*this);
741
Ted Kremenek076baeb2010-06-08 23:00:58 +0000742 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
743 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
744 // Increment in loop to prevent using deallocated memory.
745 if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second))
746 R->Destroy(*this);
747 }
Douglas Gregor561eceb2010-08-30 16:49:28 +0000748
749 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
750 AEnd = DeclAttrs.end();
751 A != AEnd; ++A)
752 A->second->~AttrVec();
753}
Douglas Gregorf21eb492009-03-26 23:50:42 +0000754
Douglas Gregor1a809332010-05-23 18:26:36 +0000755void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) {
756 Deallocations.push_back(std::make_pair(Callback, Data));
757}
758
Mike Stump11289f42009-09-09 15:08:12 +0000759void
Dylan Noblesmithe2778992012-02-05 02:12:40 +0000760ASTContext::setExternalSource(OwningPtr<ExternalASTSource> &Source) {
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000761 ExternalSource.reset(Source.take());
762}
763
Chris Lattner4eb445d2007-01-26 01:27:23 +0000764void ASTContext::PrintStats() const {
Chandler Carruth3c147a72011-07-04 05:32:14 +0000765 llvm::errs() << "\n*** AST Context Stats:\n";
766 llvm::errs() << " " << Types.size() << " types total.\n";
Sebastian Redl0f8b23f2009-03-16 23:22:08 +0000767
Douglas Gregora30d0462009-05-26 14:40:08 +0000768 unsigned counts[] = {
Mike Stump11289f42009-09-09 15:08:12 +0000769#define TYPE(Name, Parent) 0,
Douglas Gregora30d0462009-05-26 14:40:08 +0000770#define ABSTRACT_TYPE(Name, Parent)
771#include "clang/AST/TypeNodes.def"
772 0 // Extra
773 };
Douglas Gregorb1fe2c92009-04-07 17:20:56 +0000774
Chris Lattner4eb445d2007-01-26 01:27:23 +0000775 for (unsigned i = 0, e = Types.size(); i != e; ++i) {
776 Type *T = Types[i];
Douglas Gregora30d0462009-05-26 14:40:08 +0000777 counts[(unsigned)T->getTypeClass()]++;
Chris Lattner4eb445d2007-01-26 01:27:23 +0000778 }
779
Douglas Gregora30d0462009-05-26 14:40:08 +0000780 unsigned Idx = 0;
781 unsigned TotalBytes = 0;
782#define TYPE(Name, Parent) \
783 if (counts[Idx]) \
Chandler Carruth3c147a72011-07-04 05:32:14 +0000784 llvm::errs() << " " << counts[Idx] << " " << #Name \
785 << " types\n"; \
Douglas Gregora30d0462009-05-26 14:40:08 +0000786 TotalBytes += counts[Idx] * sizeof(Name##Type); \
787 ++Idx;
788#define ABSTRACT_TYPE(Name, Parent)
789#include "clang/AST/TypeNodes.def"
Mike Stump11289f42009-09-09 15:08:12 +0000790
Chandler Carruth3c147a72011-07-04 05:32:14 +0000791 llvm::errs() << "Total bytes = " << TotalBytes << "\n";
792
Douglas Gregor7454c562010-07-02 20:37:36 +0000793 // Implicit special member functions.
Chandler Carruth3c147a72011-07-04 05:32:14 +0000794 llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/"
795 << NumImplicitDefaultConstructors
796 << " implicit default constructors created\n";
797 llvm::errs() << NumImplicitCopyConstructorsDeclared << "/"
798 << NumImplicitCopyConstructors
799 << " implicit copy constructors created\n";
David Blaikiebbafb8a2012-03-11 07:00:24 +0000800 if (getLangOpts().CPlusPlus)
Chandler Carruth3c147a72011-07-04 05:32:14 +0000801 llvm::errs() << NumImplicitMoveConstructorsDeclared << "/"
802 << NumImplicitMoveConstructors
803 << " implicit move constructors created\n";
804 llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/"
805 << NumImplicitCopyAssignmentOperators
806 << " implicit copy assignment operators created\n";
David Blaikiebbafb8a2012-03-11 07:00:24 +0000807 if (getLangOpts().CPlusPlus)
Chandler Carruth3c147a72011-07-04 05:32:14 +0000808 llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/"
809 << NumImplicitMoveAssignmentOperators
810 << " implicit move assignment operators created\n";
811 llvm::errs() << NumImplicitDestructorsDeclared << "/"
812 << NumImplicitDestructors
813 << " implicit destructors created\n";
814
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000815 if (ExternalSource.get()) {
Chandler Carruth3c147a72011-07-04 05:32:14 +0000816 llvm::errs() << "\n";
Douglas Gregoref84c4b2009-04-09 22:27:44 +0000817 ExternalSource->PrintStats();
818 }
Chandler Carruth3c147a72011-07-04 05:32:14 +0000819
Douglas Gregor5b11d492010-07-25 17:53:33 +0000820 BumpAlloc.PrintStats();
Chris Lattner4eb445d2007-01-26 01:27:23 +0000821}
822
Douglas Gregor801c99d2011-08-12 06:49:56 +0000823TypedefDecl *ASTContext::getInt128Decl() const {
824 if (!Int128Decl) {
825 TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(Int128Ty);
826 Int128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this),
827 getTranslationUnitDecl(),
828 SourceLocation(),
829 SourceLocation(),
830 &Idents.get("__int128_t"),
831 TInfo);
832 }
833
834 return Int128Decl;
835}
836
837TypedefDecl *ASTContext::getUInt128Decl() const {
838 if (!UInt128Decl) {
839 TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(UnsignedInt128Ty);
840 UInt128Decl = TypedefDecl::Create(const_cast<ASTContext &>(*this),
841 getTranslationUnitDecl(),
842 SourceLocation(),
843 SourceLocation(),
844 &Idents.get("__uint128_t"),
845 TInfo);
846 }
847
848 return UInt128Decl;
849}
Chris Lattner4eb445d2007-01-26 01:27:23 +0000850
John McCall48f2d582009-10-23 23:03:21 +0000851void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
John McCall90d1c2d2009-09-24 23:30:46 +0000852 BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K);
John McCall48f2d582009-10-23 23:03:21 +0000853 R = CanQualType::CreateUnsafe(QualType(Ty, 0));
John McCall90d1c2d2009-09-24 23:30:46 +0000854 Types.push_back(Ty);
Chris Lattnerd5973eb2006-11-12 00:53:46 +0000855}
856
Douglas Gregore8bbc122011-09-02 00:18:52 +0000857void ASTContext::InitBuiltinTypes(const TargetInfo &Target) {
858 assert((!this->Target || this->Target == &Target) &&
859 "Incorrect target reinitialization");
Chris Lattner970e54e2006-11-12 00:37:36 +0000860 assert(VoidTy.isNull() && "Context reinitialized?");
Mike Stump11289f42009-09-09 15:08:12 +0000861
Douglas Gregore8bbc122011-09-02 00:18:52 +0000862 this->Target = &Target;
863
864 ABI.reset(createCXXABI(Target));
865 AddrSpaceMap = getAddressSpaceMap(Target, LangOpts);
866
Chris Lattner970e54e2006-11-12 00:37:36 +0000867 // C99 6.2.5p19.
Chris Lattner726f97b2006-12-03 02:57:32 +0000868 InitBuiltinType(VoidTy, BuiltinType::Void);
Mike Stump11289f42009-09-09 15:08:12 +0000869
Chris Lattner970e54e2006-11-12 00:37:36 +0000870 // C99 6.2.5p2.
Chris Lattner726f97b2006-12-03 02:57:32 +0000871 InitBuiltinType(BoolTy, BuiltinType::Bool);
Chris Lattner970e54e2006-11-12 00:37:36 +0000872 // C99 6.2.5p3.
Eli Friedman9ffd4a92009-06-05 07:05:05 +0000873 if (LangOpts.CharIsSigned)
Chris Lattnerb16f4552007-06-03 07:25:34 +0000874 InitBuiltinType(CharTy, BuiltinType::Char_S);
875 else
876 InitBuiltinType(CharTy, BuiltinType::Char_U);
Chris Lattner970e54e2006-11-12 00:37:36 +0000877 // C99 6.2.5p4.
Chris Lattner726f97b2006-12-03 02:57:32 +0000878 InitBuiltinType(SignedCharTy, BuiltinType::SChar);
879 InitBuiltinType(ShortTy, BuiltinType::Short);
880 InitBuiltinType(IntTy, BuiltinType::Int);
881 InitBuiltinType(LongTy, BuiltinType::Long);
882 InitBuiltinType(LongLongTy, BuiltinType::LongLong);
Mike Stump11289f42009-09-09 15:08:12 +0000883
Chris Lattner970e54e2006-11-12 00:37:36 +0000884 // C99 6.2.5p6.
Chris Lattner726f97b2006-12-03 02:57:32 +0000885 InitBuiltinType(UnsignedCharTy, BuiltinType::UChar);
886 InitBuiltinType(UnsignedShortTy, BuiltinType::UShort);
887 InitBuiltinType(UnsignedIntTy, BuiltinType::UInt);
888 InitBuiltinType(UnsignedLongTy, BuiltinType::ULong);
889 InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong);
Mike Stump11289f42009-09-09 15:08:12 +0000890
Chris Lattner970e54e2006-11-12 00:37:36 +0000891 // C99 6.2.5p10.
Chris Lattner726f97b2006-12-03 02:57:32 +0000892 InitBuiltinType(FloatTy, BuiltinType::Float);
893 InitBuiltinType(DoubleTy, BuiltinType::Double);
894 InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble);
Argyrios Kyrtzidis40e9e482008-08-09 16:51:54 +0000895
Chris Lattnerf122cef2009-04-30 02:43:43 +0000896 // GNU extension, 128-bit integers.
897 InitBuiltinType(Int128Ty, BuiltinType::Int128);
898 InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128);
899
Hans Wennborgcadd77c2013-05-03 09:10:16 +0000900 if ((LangOpts.CPlusPlus && LangOpts.WChar) || LangOpts.MicrosoftMode) {
901 // C++ 3.9.1p5 or -fms-compatibility.
Eli Friedman786d0872011-04-30 19:24:24 +0000902 if (TargetInfo::isTypeSigned(Target.getWCharType()))
Chris Lattnerad3467e2010-12-25 23:25:43 +0000903 InitBuiltinType(WCharTy, BuiltinType::WChar_S);
904 else // -fshort-wchar makes wchar_t be unsigned.
905 InitBuiltinType(WCharTy, BuiltinType::WChar_U);
Hans Wennborgcadd77c2013-05-03 09:10:16 +0000906 } else // C99 (or C++ using -fno-wchar) in non-MicrosoftMode.
Chris Lattner007cb022009-02-26 23:43:47 +0000907 WCharTy = getFromTargetType(Target.getWCharType());
Argyrios Kyrtzidis40e9e482008-08-09 16:51:54 +0000908
James Molloy36365542012-05-04 10:55:22 +0000909 WIntTy = getFromTargetType(Target.getWIntType());
910
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +0000911 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
912 InitBuiltinType(Char16Ty, BuiltinType::Char16);
913 else // C99
914 Char16Ty = getFromTargetType(Target.getChar16Type());
915
916 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
917 InitBuiltinType(Char32Ty, BuiltinType::Char32);
918 else // C99
919 Char32Ty = getFromTargetType(Target.getChar32Type());
920
Douglas Gregor4619e432008-12-05 23:32:09 +0000921 // Placeholder type for type-dependent expressions whose type is
922 // completely unknown. No code should ever check a type against
923 // DependentTy and users should never see it; however, it is here to
924 // help diagnose failures to properly check for type-dependent
925 // expressions.
926 InitBuiltinType(DependentTy, BuiltinType::Dependent);
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000927
John McCall36e7fe32010-10-12 00:20:44 +0000928 // Placeholder type for functions.
929 InitBuiltinType(OverloadTy, BuiltinType::Overload);
930
John McCall0009fcc2011-04-26 20:42:42 +0000931 // Placeholder type for bound members.
932 InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember);
933
John McCall526ab472011-10-25 17:37:35 +0000934 // Placeholder type for pseudo-objects.
935 InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject);
936
John McCall31996342011-04-07 08:22:57 +0000937 // "any" type; useful for debugger-like clients.
938 InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny);
939
John McCall8a6b59a2011-10-17 18:09:15 +0000940 // Placeholder type for unbridged ARC casts.
941 InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast);
942
Eli Friedman34866c72012-08-31 00:14:07 +0000943 // Placeholder type for builtin functions.
944 InitBuiltinType(BuiltinFnTy, BuiltinType::BuiltinFn);
945
Chris Lattner970e54e2006-11-12 00:37:36 +0000946 // C99 6.2.5p11.
Chris Lattnerc6395932007-06-22 20:56:16 +0000947 FloatComplexTy = getComplexType(FloatTy);
948 DoubleComplexTy = getComplexType(DoubleTy);
949 LongDoubleComplexTy = getComplexType(LongDoubleTy);
Douglas Gregor5251f1b2008-10-21 16:13:35 +0000950
Fariborz Jahanian252ba5f2009-11-21 19:53:08 +0000951 // Builtin types for 'id', 'Class', and 'SEL'.
Steve Naroff1329fa02009-07-15 18:40:39 +0000952 InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
953 InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
Fariborz Jahanian252ba5f2009-11-21 19:53:08 +0000954 InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);
Guy Benyeid8a08ea2012-12-18 14:38:23 +0000955
956 if (LangOpts.OpenCL) {
957 InitBuiltinType(OCLImage1dTy, BuiltinType::OCLImage1d);
958 InitBuiltinType(OCLImage1dArrayTy, BuiltinType::OCLImage1dArray);
959 InitBuiltinType(OCLImage1dBufferTy, BuiltinType::OCLImage1dBuffer);
960 InitBuiltinType(OCLImage2dTy, BuiltinType::OCLImage2d);
961 InitBuiltinType(OCLImage2dArrayTy, BuiltinType::OCLImage2dArray);
962 InitBuiltinType(OCLImage3dTy, BuiltinType::OCLImage3d);
Guy Benyei1b4fb3e2013-01-20 12:31:11 +0000963
Guy Benyei61054192013-02-07 10:55:47 +0000964 InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler);
Guy Benyei1b4fb3e2013-01-20 12:31:11 +0000965 InitBuiltinType(OCLEventTy, BuiltinType::OCLEvent);
Guy Benyeid8a08ea2012-12-18 14:38:23 +0000966 }
Ted Kremeneke65b0862012-03-06 20:05:56 +0000967
968 // Builtin type for __objc_yes and __objc_no
Fariborz Jahanian29898f42012-04-16 21:03:30 +0000969 ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ?
970 SignedCharTy : BoolTy);
Ted Kremeneke65b0862012-03-06 20:05:56 +0000971
Ted Kremenek1b0ea822008-01-07 19:49:32 +0000972 ObjCConstantStringType = QualType();
Fariborz Jahaniancb6c8672013-01-04 18:45:40 +0000973
974 ObjCSuperType = QualType();
Mike Stump11289f42009-09-09 15:08:12 +0000975
Fariborz Jahanian797f24c2007-10-29 22:57:28 +0000976 // void * type
977 VoidPtrTy = getPointerType(VoidTy);
Sebastian Redl576fd422009-05-10 18:38:11 +0000978
979 // nullptr type (C++0x 2.14.7)
980 InitBuiltinType(NullPtrTy, BuiltinType::NullPtr);
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +0000981
982 // half type (OpenCL 6.1.1.1) / ARM NEON __fp16
983 InitBuiltinType(HalfTy, BuiltinType::Half);
Meador Ingecfb60902012-07-01 15:57:25 +0000984
985 // Builtin type used to help define __builtin_va_list.
986 VaListTagTy = QualType();
Chris Lattner970e54e2006-11-12 00:37:36 +0000987}
988
David Blaikie9c902b52011-09-25 23:23:43 +0000989DiagnosticsEngine &ASTContext::getDiagnostics() const {
Argyrios Kyrtzidisca0d0cd2010-09-22 14:32:24 +0000990 return SourceMgr.getDiagnostics();
991}
992
Douglas Gregor561eceb2010-08-30 16:49:28 +0000993AttrVec& ASTContext::getDeclAttrs(const Decl *D) {
994 AttrVec *&Result = DeclAttrs[D];
995 if (!Result) {
996 void *Mem = Allocate(sizeof(AttrVec));
997 Result = new (Mem) AttrVec;
998 }
999
1000 return *Result;
1001}
1002
1003/// \brief Erase the attributes corresponding to the given declaration.
1004void ASTContext::eraseDeclAttrs(const Decl *D) {
1005 llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
1006 if (Pos != DeclAttrs.end()) {
1007 Pos->second->~AttrVec();
1008 DeclAttrs.erase(Pos);
1009 }
1010}
1011
Douglas Gregor86d142a2009-10-08 07:24:58 +00001012MemberSpecializationInfo *
Douglas Gregor3c74d412009-10-14 20:14:33 +00001013ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) {
Douglas Gregora6ef8f02009-07-24 20:34:43 +00001014 assert(Var->isStaticDataMember() && "Not a static data member");
Douglas Gregor3c74d412009-10-14 20:14:33 +00001015 llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>::iterator Pos
Douglas Gregora6ef8f02009-07-24 20:34:43 +00001016 = InstantiatedFromStaticDataMember.find(Var);
1017 if (Pos == InstantiatedFromStaticDataMember.end())
1018 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00001019
Douglas Gregora6ef8f02009-07-24 20:34:43 +00001020 return Pos->second;
1021}
1022
Mike Stump11289f42009-09-09 15:08:12 +00001023void
Douglas Gregor86d142a2009-10-08 07:24:58 +00001024ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
Argyrios Kyrtzidiscdb8b3f2010-07-04 21:44:00 +00001025 TemplateSpecializationKind TSK,
1026 SourceLocation PointOfInstantiation) {
Douglas Gregora6ef8f02009-07-24 20:34:43 +00001027 assert(Inst->isStaticDataMember() && "Not a static data member");
1028 assert(Tmpl->isStaticDataMember() && "Not a static data member");
1029 assert(!InstantiatedFromStaticDataMember[Inst] &&
1030 "Already noted what static data member was instantiated from");
Douglas Gregor86d142a2009-10-08 07:24:58 +00001031 InstantiatedFromStaticDataMember[Inst]
Argyrios Kyrtzidiscdb8b3f2010-07-04 21:44:00 +00001032 = new (*this) MemberSpecializationInfo(Tmpl, TSK, PointOfInstantiation);
Douglas Gregora6ef8f02009-07-24 20:34:43 +00001033}
1034
Francois Pichet00c7e6c2011-08-14 03:52:19 +00001035FunctionDecl *ASTContext::getClassScopeSpecializationPattern(
1036 const FunctionDecl *FD){
1037 assert(FD && "Specialization is 0");
1038 llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos
Francois Pichet57928252011-08-14 14:28:49 +00001039 = ClassScopeSpecializationPattern.find(FD);
1040 if (Pos == ClassScopeSpecializationPattern.end())
Francois Pichet00c7e6c2011-08-14 03:52:19 +00001041 return 0;
1042
1043 return Pos->second;
1044}
1045
1046void ASTContext::setClassScopeSpecializationPattern(FunctionDecl *FD,
1047 FunctionDecl *Pattern) {
1048 assert(FD && "Specialization is 0");
1049 assert(Pattern && "Class scope specialization pattern is 0");
Francois Pichet57928252011-08-14 14:28:49 +00001050 ClassScopeSpecializationPattern[FD] = Pattern;
Francois Pichet00c7e6c2011-08-14 03:52:19 +00001051}
1052
John McCalle61f2ba2009-11-18 02:36:19 +00001053NamedDecl *
John McCallb96ec562009-12-04 22:46:56 +00001054ASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) {
John McCalle61f2ba2009-11-18 02:36:19 +00001055 llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos
John McCallb96ec562009-12-04 22:46:56 +00001056 = InstantiatedFromUsingDecl.find(UUD);
1057 if (Pos == InstantiatedFromUsingDecl.end())
Anders Carlsson4bb87ce2009-08-29 19:37:28 +00001058 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00001059
Anders Carlsson4bb87ce2009-08-29 19:37:28 +00001060 return Pos->second;
1061}
1062
1063void
John McCallb96ec562009-12-04 22:46:56 +00001064ASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) {
1065 assert((isa<UsingDecl>(Pattern) ||
1066 isa<UnresolvedUsingValueDecl>(Pattern) ||
1067 isa<UnresolvedUsingTypenameDecl>(Pattern)) &&
1068 "pattern decl is not a using decl");
1069 assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists");
1070 InstantiatedFromUsingDecl[Inst] = Pattern;
1071}
1072
1073UsingShadowDecl *
1074ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) {
1075 llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
1076 = InstantiatedFromUsingShadowDecl.find(Inst);
1077 if (Pos == InstantiatedFromUsingShadowDecl.end())
1078 return 0;
1079
1080 return Pos->second;
1081}
1082
1083void
1084ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
1085 UsingShadowDecl *Pattern) {
1086 assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists");
1087 InstantiatedFromUsingShadowDecl[Inst] = Pattern;
Anders Carlsson4bb87ce2009-08-29 19:37:28 +00001088}
1089
Anders Carlsson5da84842009-09-01 04:26:58 +00001090FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) {
1091 llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
1092 = InstantiatedFromUnnamedFieldDecl.find(Field);
1093 if (Pos == InstantiatedFromUnnamedFieldDecl.end())
1094 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00001095
Anders Carlsson5da84842009-09-01 04:26:58 +00001096 return Pos->second;
1097}
1098
1099void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst,
1100 FieldDecl *Tmpl) {
1101 assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed");
1102 assert(!Tmpl->getDeclName() && "Template field decl is not unnamed");
1103 assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
1104 "Already noted what unnamed field was instantiated from");
Mike Stump11289f42009-09-09 15:08:12 +00001105
Anders Carlsson5da84842009-09-01 04:26:58 +00001106 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1107}
1108
Fariborz Jahanian595ec5d2011-04-27 17:14:21 +00001109bool ASTContext::ZeroBitfieldFollowsNonBitfield(const FieldDecl *FD,
1110 const FieldDecl *LastFD) const {
1111 return (FD->isBitField() && LastFD && !LastFD->isBitField() &&
Richard Smithcaf33902011-10-10 18:28:20 +00001112 FD->getBitWidthValue(*this) == 0);
Fariborz Jahanian595ec5d2011-04-27 17:14:21 +00001113}
1114
Fariborz Jahanianeb397412011-05-02 17:20:56 +00001115bool ASTContext::ZeroBitfieldFollowsBitfield(const FieldDecl *FD,
1116 const FieldDecl *LastFD) const {
1117 return (FD->isBitField() && LastFD && LastFD->isBitField() &&
Richard Smithcaf33902011-10-10 18:28:20 +00001118 FD->getBitWidthValue(*this) == 0 &&
1119 LastFD->getBitWidthValue(*this) != 0);
Fariborz Jahanianeb397412011-05-02 17:20:56 +00001120}
1121
Fariborz Jahanian84335f72011-05-04 18:51:37 +00001122bool ASTContext::BitfieldFollowsBitfield(const FieldDecl *FD,
1123 const FieldDecl *LastFD) const {
1124 return (FD->isBitField() && LastFD && LastFD->isBitField() &&
Richard Smithcaf33902011-10-10 18:28:20 +00001125 FD->getBitWidthValue(*this) &&
1126 LastFD->getBitWidthValue(*this));
Fariborz Jahanian84335f72011-05-04 18:51:37 +00001127}
1128
Chad Rosierf01a7dd2011-08-04 23:34:15 +00001129bool ASTContext::NonBitfieldFollowsBitfield(const FieldDecl *FD,
Fariborz Jahanianb7a28792011-05-06 21:56:12 +00001130 const FieldDecl *LastFD) const {
1131 return (!FD->isBitField() && LastFD && LastFD->isBitField() &&
Richard Smithcaf33902011-10-10 18:28:20 +00001132 LastFD->getBitWidthValue(*this));
Fariborz Jahanianb7a28792011-05-06 21:56:12 +00001133}
1134
Chad Rosierf01a7dd2011-08-04 23:34:15 +00001135bool ASTContext::BitfieldFollowsNonBitfield(const FieldDecl *FD,
Fariborz Jahanianb7a28792011-05-06 21:56:12 +00001136 const FieldDecl *LastFD) const {
1137 return (FD->isBitField() && LastFD && !LastFD->isBitField() &&
Richard Smithcaf33902011-10-10 18:28:20 +00001138 FD->getBitWidthValue(*this));
Fariborz Jahanianb7a28792011-05-06 21:56:12 +00001139}
1140
Douglas Gregor832940b2010-03-02 23:58:15 +00001141ASTContext::overridden_cxx_method_iterator
1142ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const {
1143 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos
Argyrios Kyrtzidiscc4ca0a2012-10-09 01:23:45 +00001144 = OverriddenMethods.find(Method->getCanonicalDecl());
Douglas Gregor832940b2010-03-02 23:58:15 +00001145 if (Pos == OverriddenMethods.end())
1146 return 0;
1147
1148 return Pos->second.begin();
1149}
1150
1151ASTContext::overridden_cxx_method_iterator
1152ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const {
1153 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos
Argyrios Kyrtzidiscc4ca0a2012-10-09 01:23:45 +00001154 = OverriddenMethods.find(Method->getCanonicalDecl());
Douglas Gregor832940b2010-03-02 23:58:15 +00001155 if (Pos == OverriddenMethods.end())
1156 return 0;
1157
1158 return Pos->second.end();
1159}
1160
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +00001161unsigned
1162ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const {
1163 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos
Argyrios Kyrtzidiscc4ca0a2012-10-09 01:23:45 +00001164 = OverriddenMethods.find(Method->getCanonicalDecl());
Argyrios Kyrtzidis6685e8a2010-07-04 21:44:35 +00001165 if (Pos == OverriddenMethods.end())
1166 return 0;
1167
1168 return Pos->second.size();
1169}
1170
Douglas Gregor832940b2010-03-02 23:58:15 +00001171void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method,
1172 const CXXMethodDecl *Overridden) {
Argyrios Kyrtzidiscc4ca0a2012-10-09 01:23:45 +00001173 assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl());
Douglas Gregor832940b2010-03-02 23:58:15 +00001174 OverriddenMethods[Method].push_back(Overridden);
1175}
1176
Dmitri Gribenko941ab0f2012-11-03 14:24:57 +00001177void ASTContext::getOverriddenMethods(
1178 const NamedDecl *D,
1179 SmallVectorImpl<const NamedDecl *> &Overridden) const {
Argyrios Kyrtzidisb9556e62012-10-09 01:23:50 +00001180 assert(D);
1181
1182 if (const CXXMethodDecl *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
Argyrios Kyrtzidisc8e70082013-04-17 00:09:03 +00001183 Overridden.append(overridden_methods_begin(CXXMethod),
1184 overridden_methods_end(CXXMethod));
Argyrios Kyrtzidisb9556e62012-10-09 01:23:50 +00001185 return;
1186 }
1187
1188 const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D);
1189 if (!Method)
1190 return;
1191
Argyrios Kyrtzidis353f6a42012-10-09 18:19:01 +00001192 SmallVector<const ObjCMethodDecl *, 8> OverDecls;
1193 Method->getOverriddenMethods(OverDecls);
Argyrios Kyrtzidisa7a10812012-10-09 20:08:43 +00001194 Overridden.append(OverDecls.begin(), OverDecls.end());
Argyrios Kyrtzidisb9556e62012-10-09 01:23:50 +00001195}
1196
Douglas Gregor0f2a3602011-12-03 00:30:27 +00001197void ASTContext::addedLocalImportDecl(ImportDecl *Import) {
1198 assert(!Import->NextLocalImport && "Import declaration already in the chain");
1199 assert(!Import->isFromASTFile() && "Non-local import declaration");
1200 if (!FirstLocalImport) {
1201 FirstLocalImport = Import;
1202 LastLocalImport = Import;
1203 return;
1204 }
1205
1206 LastLocalImport->NextLocalImport = Import;
1207 LastLocalImport = Import;
1208}
1209
Chris Lattner53cfe802007-07-18 17:52:12 +00001210//===----------------------------------------------------------------------===//
1211// Type Sizing and Analysis
1212//===----------------------------------------------------------------------===//
Chris Lattner983a8bb2007-07-13 22:13:22 +00001213
Chris Lattner9a8d1d92008-06-30 18:32:54 +00001214/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
1215/// scalar floating point type.
1216const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
John McCall9dd450b2009-09-21 23:43:11 +00001217 const BuiltinType *BT = T->getAs<BuiltinType>();
Chris Lattner9a8d1d92008-06-30 18:32:54 +00001218 assert(BT && "Not a floating point type!");
1219 switch (BT->getKind()) {
David Blaikie83d382b2011-09-23 05:06:16 +00001220 default: llvm_unreachable("Not a floating point type!");
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00001221 case BuiltinType::Half: return Target->getHalfFormat();
Douglas Gregore8bbc122011-09-02 00:18:52 +00001222 case BuiltinType::Float: return Target->getFloatFormat();
1223 case BuiltinType::Double: return Target->getDoubleFormat();
1224 case BuiltinType::LongDouble: return Target->getLongDoubleFormat();
Chris Lattner9a8d1d92008-06-30 18:32:54 +00001225 }
1226}
1227
Ken Dyck160146e2010-01-27 17:10:57 +00001228/// getDeclAlign - Return a conservative estimate of the alignment of the
Chris Lattner68061312009-01-24 21:53:27 +00001229/// specified decl. Note that bitfields do not have a valid alignment, so
1230/// this method will assert on them.
Sebastian Redl22e2e5c2009-11-23 17:18:46 +00001231/// If @p RefAsPointee, references are treated like their underlying type
1232/// (for alignof), else they're treated like pointers (for CodeGen).
Jay Foad39c79802011-01-12 09:06:06 +00001233CharUnits ASTContext::getDeclAlign(const Decl *D, bool RefAsPointee) const {
Douglas Gregore8bbc122011-09-02 00:18:52 +00001234 unsigned Align = Target->getCharWidth();
Eli Friedman19a546c2009-02-22 02:56:25 +00001235
John McCall94268702010-10-08 18:24:19 +00001236 bool UseAlignAttrOnly = false;
1237 if (unsigned AlignFromAttr = D->getMaxAlignment()) {
1238 Align = AlignFromAttr;
Eli Friedman19a546c2009-02-22 02:56:25 +00001239
John McCall94268702010-10-08 18:24:19 +00001240 // __attribute__((aligned)) can increase or decrease alignment
1241 // *except* on a struct or struct member, where it only increases
1242 // alignment unless 'packed' is also specified.
1243 //
Peter Collingbourne2f3cf4b2011-09-29 18:04:28 +00001244 // It is an error for alignas to decrease alignment, so we can
John McCall94268702010-10-08 18:24:19 +00001245 // ignore that possibility; Sema should diagnose it.
1246 if (isa<FieldDecl>(D)) {
1247 UseAlignAttrOnly = D->hasAttr<PackedAttr>() ||
1248 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1249 } else {
1250 UseAlignAttrOnly = true;
1251 }
1252 }
Fariborz Jahanian9f107182011-05-05 21:19:14 +00001253 else if (isa<FieldDecl>(D))
1254 UseAlignAttrOnly =
1255 D->hasAttr<PackedAttr>() ||
1256 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
John McCall94268702010-10-08 18:24:19 +00001257
John McCall4e819612011-01-20 07:57:12 +00001258 // If we're using the align attribute only, just ignore everything
1259 // else about the declaration and its type.
John McCall94268702010-10-08 18:24:19 +00001260 if (UseAlignAttrOnly) {
John McCall4e819612011-01-20 07:57:12 +00001261 // do nothing
1262
John McCall94268702010-10-08 18:24:19 +00001263 } else if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
Chris Lattner68061312009-01-24 21:53:27 +00001264 QualType T = VD->getType();
Ted Kremenekc23c7e62009-07-29 21:53:49 +00001265 if (const ReferenceType* RT = T->getAs<ReferenceType>()) {
Sebastian Redl22e2e5c2009-11-23 17:18:46 +00001266 if (RefAsPointee)
1267 T = RT->getPointeeType();
1268 else
1269 T = getPointerType(RT->getPointeeType());
1270 }
1271 if (!T->isIncompleteType() && !T->isFunctionType()) {
John McCall33ddac02011-01-19 10:06:00 +00001272 // Adjust alignments of declarations with array type by the
1273 // large-array alignment on the target.
Douglas Gregore8bbc122011-09-02 00:18:52 +00001274 unsigned MinWidth = Target->getLargeArrayMinWidth();
John McCall33ddac02011-01-19 10:06:00 +00001275 const ArrayType *arrayType;
1276 if (MinWidth && (arrayType = getAsArrayType(T))) {
1277 if (isa<VariableArrayType>(arrayType))
Douglas Gregore8bbc122011-09-02 00:18:52 +00001278 Align = std::max(Align, Target->getLargeArrayAlign());
John McCall33ddac02011-01-19 10:06:00 +00001279 else if (isa<ConstantArrayType>(arrayType) &&
1280 MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType)))
Douglas Gregore8bbc122011-09-02 00:18:52 +00001281 Align = std::max(Align, Target->getLargeArrayAlign());
Eli Friedman19a546c2009-02-22 02:56:25 +00001282
John McCall33ddac02011-01-19 10:06:00 +00001283 // Walk through any array types while we're at it.
1284 T = getBaseElementType(arrayType);
1285 }
Chad Rosier99ee7822011-07-26 07:03:04 +00001286 Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
Eli Friedman19a546c2009-02-22 02:56:25 +00001287 }
John McCall4e819612011-01-20 07:57:12 +00001288
1289 // Fields can be subject to extra alignment constraints, like if
1290 // the field is packed, the struct is packed, or the struct has a
1291 // a max-field-alignment constraint (#pragma pack). So calculate
1292 // the actual alignment of the field within the struct, and then
1293 // (as we're expected to) constrain that by the alignment of the type.
1294 if (const FieldDecl *field = dyn_cast<FieldDecl>(VD)) {
1295 // So calculate the alignment of the field.
1296 const ASTRecordLayout &layout = getASTRecordLayout(field->getParent());
1297
1298 // Start with the record's overall alignment.
Ken Dyck7ad11e72011-02-15 02:32:40 +00001299 unsigned fieldAlign = toBits(layout.getAlignment());
John McCall4e819612011-01-20 07:57:12 +00001300
1301 // Use the GCD of that and the offset within the record.
1302 uint64_t offset = layout.getFieldOffset(field->getFieldIndex());
1303 if (offset > 0) {
1304 // Alignment is always a power of 2, so the GCD will be a power of 2,
1305 // which means we get to do this crazy thing instead of Euclid's.
1306 uint64_t lowBitOfOffset = offset & (~offset + 1);
1307 if (lowBitOfOffset < fieldAlign)
1308 fieldAlign = static_cast<unsigned>(lowBitOfOffset);
1309 }
1310
1311 Align = std::min(Align, fieldAlign);
Charles Davis3fc51072010-02-23 04:52:00 +00001312 }
Chris Lattner68061312009-01-24 21:53:27 +00001313 }
Eli Friedman19a546c2009-02-22 02:56:25 +00001314
Ken Dyckcc56c542011-01-15 18:38:59 +00001315 return toCharUnitsFromBits(Align);
Chris Lattner68061312009-01-24 21:53:27 +00001316}
Chris Lattner9a8d1d92008-06-30 18:32:54 +00001317
John McCallf1249922012-08-21 04:10:00 +00001318// getTypeInfoDataSizeInChars - Return the size of a type, in
1319// chars. If the type is a record, its data size is returned. This is
1320// the size of the memcpy that's performed when assigning this type
1321// using a trivial copy/move assignment operator.
1322std::pair<CharUnits, CharUnits>
1323ASTContext::getTypeInfoDataSizeInChars(QualType T) const {
1324 std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T);
1325
1326 // In C++, objects can sometimes be allocated into the tail padding
1327 // of a base-class subobject. We decide whether that's possible
1328 // during class layout, so here we can just trust the layout results.
1329 if (getLangOpts().CPlusPlus) {
1330 if (const RecordType *RT = T->getAs<RecordType>()) {
1331 const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl());
1332 sizeAndAlign.first = layout.getDataSize();
1333 }
1334 }
1335
1336 return sizeAndAlign;
1337}
1338
John McCall87fe5d52010-05-20 01:18:31 +00001339std::pair<CharUnits, CharUnits>
Ken Dyckd24099d2011-02-20 01:55:18 +00001340ASTContext::getTypeInfoInChars(const Type *T) const {
John McCall87fe5d52010-05-20 01:18:31 +00001341 std::pair<uint64_t, unsigned> Info = getTypeInfo(T);
Ken Dyckcc56c542011-01-15 18:38:59 +00001342 return std::make_pair(toCharUnitsFromBits(Info.first),
1343 toCharUnitsFromBits(Info.second));
John McCall87fe5d52010-05-20 01:18:31 +00001344}
1345
1346std::pair<CharUnits, CharUnits>
Ken Dyckd24099d2011-02-20 01:55:18 +00001347ASTContext::getTypeInfoInChars(QualType T) const {
John McCall87fe5d52010-05-20 01:18:31 +00001348 return getTypeInfoInChars(T.getTypePtr());
1349}
1350
Daniel Dunbarc6475872012-03-09 04:12:54 +00001351std::pair<uint64_t, unsigned> ASTContext::getTypeInfo(const Type *T) const {
1352 TypeInfoMap::iterator it = MemoizedTypeInfo.find(T);
1353 if (it != MemoizedTypeInfo.end())
1354 return it->second;
1355
1356 std::pair<uint64_t, unsigned> Info = getTypeInfoImpl(T);
1357 MemoizedTypeInfo.insert(std::make_pair(T, Info));
1358 return Info;
1359}
1360
1361/// getTypeInfoImpl - Return the size of the specified type, in bits. This
1362/// method does not work on incomplete types.
John McCall8ccfcb52009-09-24 19:53:00 +00001363///
1364/// FIXME: Pointers into different addr spaces could have different sizes and
1365/// alignment requirements: getPointerInfo should take an AddrSpace, this
1366/// should take a QualType, &c.
Chris Lattner4481b422007-07-14 01:29:45 +00001367std::pair<uint64_t, unsigned>
Daniel Dunbarc6475872012-03-09 04:12:54 +00001368ASTContext::getTypeInfoImpl(const Type *T) const {
Mike Stump5b9a3d52009-02-27 18:32:39 +00001369 uint64_t Width=0;
1370 unsigned Align=8;
Chris Lattner983a8bb2007-07-13 22:13:22 +00001371 switch (T->getTypeClass()) {
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001372#define TYPE(Class, Base)
1373#define ABSTRACT_TYPE(Class, Base)
Douglas Gregoref462e62009-04-30 17:32:17 +00001374#define NON_CANONICAL_TYPE(Class, Base)
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001375#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1376#include "clang/AST/TypeNodes.def"
John McCall15547bb2011-06-28 16:49:23 +00001377 llvm_unreachable("Should not see dependent types");
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001378
Chris Lattner355332d2007-07-13 22:27:08 +00001379 case Type::FunctionNoProto:
1380 case Type::FunctionProto:
Douglas Gregoref462e62009-04-30 17:32:17 +00001381 // GCC extension: alignof(function) = 32 bits
1382 Width = 0;
1383 Align = 32;
1384 break;
1385
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001386 case Type::IncompleteArray:
Steve Naroff5c131802007-08-30 01:06:46 +00001387 case Type::VariableArray:
Douglas Gregoref462e62009-04-30 17:32:17 +00001388 Width = 0;
1389 Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
1390 break;
1391
Steve Naroff5c131802007-08-30 01:06:46 +00001392 case Type::ConstantArray: {
Daniel Dunbarbbc0af72008-11-08 05:48:37 +00001393 const ConstantArrayType *CAT = cast<ConstantArrayType>(T);
Mike Stump11289f42009-09-09 15:08:12 +00001394
Chris Lattner37e05872008-03-05 18:54:05 +00001395 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType());
Abramo Bagnarad541a4c2011-12-13 11:23:52 +00001396 uint64_t Size = CAT->getSize().getZExtValue();
Daniel Dunbarc6475872012-03-09 04:12:54 +00001397 assert((Size == 0 || EltInfo.first <= (uint64_t)(-1)/Size) &&
1398 "Overflow in array type bit size evaluation");
Abramo Bagnarad541a4c2011-12-13 11:23:52 +00001399 Width = EltInfo.first*Size;
Chris Lattnerf2e101f2007-07-19 22:06:24 +00001400 Align = EltInfo.second;
Argyrios Kyrtzidisae40e4e2011-04-26 21:05:39 +00001401 Width = llvm::RoundUpToAlignment(Width, Align);
Chris Lattnerf2e101f2007-07-19 22:06:24 +00001402 break;
Christopher Lambc5fafa22007-12-29 05:10:55 +00001403 }
Nate Begemance4d7fc2008-04-18 23:10:10 +00001404 case Type::ExtVector:
Chris Lattnerf2e101f2007-07-19 22:06:24 +00001405 case Type::Vector: {
Chris Lattner63d2b362009-10-22 05:17:15 +00001406 const VectorType *VT = cast<VectorType>(T);
1407 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType());
1408 Width = EltInfo.first*VT->getNumElements();
Eli Friedman3df5efe2008-05-30 09:31:38 +00001409 Align = Width;
Nate Begemanb699c9b2009-01-18 06:42:49 +00001410 // If the alignment is not a power of 2, round up to the next power of 2.
1411 // This happens for non-power-of-2 length vectors.
Dan Gohmanef78c8e2010-04-21 23:32:43 +00001412 if (Align & (Align-1)) {
Chris Lattner63d2b362009-10-22 05:17:15 +00001413 Align = llvm::NextPowerOf2(Align);
1414 Width = llvm::RoundUpToAlignment(Width, Align);
1415 }
Chad Rosiercc40ea72012-07-13 23:57:43 +00001416 // Adjust the alignment based on the target max.
1417 uint64_t TargetVectorAlign = Target->getMaxVectorAlign();
1418 if (TargetVectorAlign && TargetVectorAlign < Align)
1419 Align = TargetVectorAlign;
Chris Lattnerf2e101f2007-07-19 22:06:24 +00001420 break;
1421 }
Chris Lattner647fb222007-07-18 18:26:58 +00001422
Chris Lattner7570e9c2008-03-08 08:52:55 +00001423 case Type::Builtin:
Chris Lattner983a8bb2007-07-13 22:13:22 +00001424 switch (cast<BuiltinType>(T)->getKind()) {
David Blaikie83d382b2011-09-23 05:06:16 +00001425 default: llvm_unreachable("Unknown builtin type!");
Chris Lattner4481b422007-07-14 01:29:45 +00001426 case BuiltinType::Void:
Douglas Gregoref462e62009-04-30 17:32:17 +00001427 // GCC extension: alignof(void) = 8 bits.
1428 Width = 0;
1429 Align = 8;
1430 break;
1431
Chris Lattner6a4f7452007-12-19 19:23:28 +00001432 case BuiltinType::Bool:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001433 Width = Target->getBoolWidth();
1434 Align = Target->getBoolAlign();
Chris Lattner6a4f7452007-12-19 19:23:28 +00001435 break;
Chris Lattner355332d2007-07-13 22:27:08 +00001436 case BuiltinType::Char_S:
1437 case BuiltinType::Char_U:
1438 case BuiltinType::UChar:
Chris Lattner6a4f7452007-12-19 19:23:28 +00001439 case BuiltinType::SChar:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001440 Width = Target->getCharWidth();
1441 Align = Target->getCharAlign();
Chris Lattner6a4f7452007-12-19 19:23:28 +00001442 break;
Chris Lattnerad3467e2010-12-25 23:25:43 +00001443 case BuiltinType::WChar_S:
1444 case BuiltinType::WChar_U:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001445 Width = Target->getWCharWidth();
1446 Align = Target->getWCharAlign();
Argyrios Kyrtzidis40e9e482008-08-09 16:51:54 +00001447 break;
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001448 case BuiltinType::Char16:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001449 Width = Target->getChar16Width();
1450 Align = Target->getChar16Align();
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001451 break;
1452 case BuiltinType::Char32:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001453 Width = Target->getChar32Width();
1454 Align = Target->getChar32Align();
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00001455 break;
Chris Lattner355332d2007-07-13 22:27:08 +00001456 case BuiltinType::UShort:
Chris Lattner6a4f7452007-12-19 19:23:28 +00001457 case BuiltinType::Short:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001458 Width = Target->getShortWidth();
1459 Align = Target->getShortAlign();
Chris Lattner6a4f7452007-12-19 19:23:28 +00001460 break;
Chris Lattner355332d2007-07-13 22:27:08 +00001461 case BuiltinType::UInt:
Chris Lattner6a4f7452007-12-19 19:23:28 +00001462 case BuiltinType::Int:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001463 Width = Target->getIntWidth();
1464 Align = Target->getIntAlign();
Chris Lattner6a4f7452007-12-19 19:23:28 +00001465 break;
Chris Lattner355332d2007-07-13 22:27:08 +00001466 case BuiltinType::ULong:
Chris Lattner6a4f7452007-12-19 19:23:28 +00001467 case BuiltinType::Long:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001468 Width = Target->getLongWidth();
1469 Align = Target->getLongAlign();
Chris Lattner6a4f7452007-12-19 19:23:28 +00001470 break;
Chris Lattner355332d2007-07-13 22:27:08 +00001471 case BuiltinType::ULongLong:
Chris Lattner6a4f7452007-12-19 19:23:28 +00001472 case BuiltinType::LongLong:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001473 Width = Target->getLongLongWidth();
1474 Align = Target->getLongLongAlign();
Chris Lattner6a4f7452007-12-19 19:23:28 +00001475 break;
Chris Lattner0a415ec2009-04-30 02:55:13 +00001476 case BuiltinType::Int128:
1477 case BuiltinType::UInt128:
1478 Width = 128;
1479 Align = 128; // int128_t is 128-bit aligned on all targets.
1480 break;
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00001481 case BuiltinType::Half:
1482 Width = Target->getHalfWidth();
1483 Align = Target->getHalfAlign();
1484 break;
Chris Lattner6a4f7452007-12-19 19:23:28 +00001485 case BuiltinType::Float:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001486 Width = Target->getFloatWidth();
1487 Align = Target->getFloatAlign();
Chris Lattner6a4f7452007-12-19 19:23:28 +00001488 break;
1489 case BuiltinType::Double:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001490 Width = Target->getDoubleWidth();
1491 Align = Target->getDoubleAlign();
Chris Lattner6a4f7452007-12-19 19:23:28 +00001492 break;
1493 case BuiltinType::LongDouble:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001494 Width = Target->getLongDoubleWidth();
1495 Align = Target->getLongDoubleAlign();
Chris Lattner6a4f7452007-12-19 19:23:28 +00001496 break;
Sebastian Redl576fd422009-05-10 18:38:11 +00001497 case BuiltinType::NullPtr:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001498 Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
1499 Align = Target->getPointerAlign(0); // == sizeof(void*)
Sebastian Redla81b0b72009-05-27 19:34:06 +00001500 break;
Fariborz Jahanian9c6a39e2010-08-02 18:03:20 +00001501 case BuiltinType::ObjCId:
1502 case BuiltinType::ObjCClass:
1503 case BuiltinType::ObjCSel:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001504 Width = Target->getPointerWidth(0);
1505 Align = Target->getPointerAlign(0);
Fariborz Jahanian9c6a39e2010-08-02 18:03:20 +00001506 break;
Guy Benyei61054192013-02-07 10:55:47 +00001507 case BuiltinType::OCLSampler:
1508 // Samplers are modeled as integers.
1509 Width = Target->getIntWidth();
1510 Align = Target->getIntAlign();
1511 break;
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00001512 case BuiltinType::OCLEvent:
Guy Benyeid8a08ea2012-12-18 14:38:23 +00001513 case BuiltinType::OCLImage1d:
1514 case BuiltinType::OCLImage1dArray:
1515 case BuiltinType::OCLImage1dBuffer:
1516 case BuiltinType::OCLImage2d:
1517 case BuiltinType::OCLImage2dArray:
1518 case BuiltinType::OCLImage3d:
1519 // Currently these types are pointers to opaque types.
1520 Width = Target->getPointerWidth(0);
1521 Align = Target->getPointerAlign(0);
1522 break;
Chris Lattner983a8bb2007-07-13 22:13:22 +00001523 }
Chris Lattner48f84b82007-07-15 23:46:53 +00001524 break;
Steve Narofffb4330f2009-06-17 22:40:22 +00001525 case Type::ObjCObjectPointer:
Douglas Gregore8bbc122011-09-02 00:18:52 +00001526 Width = Target->getPointerWidth(0);
1527 Align = Target->getPointerAlign(0);
Chris Lattner6a4f7452007-12-19 19:23:28 +00001528 break;
Steve Naroff921a45c2008-09-24 15:05:44 +00001529 case Type::BlockPointer: {
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00001530 unsigned AS = getTargetAddressSpace(
1531 cast<BlockPointerType>(T)->getPointeeType());
Douglas Gregore8bbc122011-09-02 00:18:52 +00001532 Width = Target->getPointerWidth(AS);
1533 Align = Target->getPointerAlign(AS);
Steve Naroff921a45c2008-09-24 15:05:44 +00001534 break;
1535 }
Sebastian Redl22e2e5c2009-11-23 17:18:46 +00001536 case Type::LValueReference:
1537 case Type::RValueReference: {
1538 // alignof and sizeof should never enter this code path here, so we go
1539 // the pointer route.
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00001540 unsigned AS = getTargetAddressSpace(
1541 cast<ReferenceType>(T)->getPointeeType());
Douglas Gregore8bbc122011-09-02 00:18:52 +00001542 Width = Target->getPointerWidth(AS);
1543 Align = Target->getPointerAlign(AS);
Sebastian Redl22e2e5c2009-11-23 17:18:46 +00001544 break;
1545 }
Chris Lattner2dca6ff2008-03-08 08:34:58 +00001546 case Type::Pointer: {
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00001547 unsigned AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType());
Douglas Gregore8bbc122011-09-02 00:18:52 +00001548 Width = Target->getPointerWidth(AS);
1549 Align = Target->getPointerAlign(AS);
Chris Lattner2dca6ff2008-03-08 08:34:58 +00001550 break;
1551 }
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00001552 case Type::MemberPointer: {
Charles Davis53c59df2010-08-16 03:33:14 +00001553 const MemberPointerType *MPT = cast<MemberPointerType>(T);
Reid Kleckner3a52abf2013-03-28 20:02:56 +00001554 llvm::tie(Width, Align) = ABI->getMemberPointerWidthAndAlign(MPT);
Anders Carlsson32440a02009-05-17 02:06:04 +00001555 break;
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00001556 }
Chris Lattner647fb222007-07-18 18:26:58 +00001557 case Type::Complex: {
1558 // Complex types have the same alignment as their elements, but twice the
1559 // size.
Mike Stump11289f42009-09-09 15:08:12 +00001560 std::pair<uint64_t, unsigned> EltInfo =
Chris Lattner37e05872008-03-05 18:54:05 +00001561 getTypeInfo(cast<ComplexType>(T)->getElementType());
Chris Lattner7570e9c2008-03-08 08:52:55 +00001562 Width = EltInfo.first*2;
Chris Lattner647fb222007-07-18 18:26:58 +00001563 Align = EltInfo.second;
1564 break;
1565 }
John McCall8b07ec22010-05-15 11:32:37 +00001566 case Type::ObjCObject:
1567 return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr());
Devang Pateldbb72632008-06-04 21:54:36 +00001568 case Type::ObjCInterface: {
Daniel Dunbarbbc0af72008-11-08 05:48:37 +00001569 const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T);
Devang Pateldbb72632008-06-04 21:54:36 +00001570 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
Ken Dyckb0fcc592011-02-11 01:54:29 +00001571 Width = toBits(Layout.getSize());
Ken Dyck7ad11e72011-02-15 02:32:40 +00001572 Align = toBits(Layout.getAlignment());
Devang Pateldbb72632008-06-04 21:54:36 +00001573 break;
1574 }
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001575 case Type::Record:
Douglas Gregordeaad8c2009-02-26 23:50:07 +00001576 case Type::Enum: {
Daniel Dunbarbbc0af72008-11-08 05:48:37 +00001577 const TagType *TT = cast<TagType>(T);
1578
1579 if (TT->getDecl()->isInvalidDecl()) {
Douglas Gregor7f971892011-04-20 17:29:44 +00001580 Width = 8;
1581 Align = 8;
Chris Lattner572100b2008-08-09 21:35:13 +00001582 break;
1583 }
Mike Stump11289f42009-09-09 15:08:12 +00001584
Daniel Dunbarbbc0af72008-11-08 05:48:37 +00001585 if (const EnumType *ET = dyn_cast<EnumType>(TT))
Chris Lattner8b23c252008-04-06 22:05:18 +00001586 return getTypeInfo(ET->getDecl()->getIntegerType());
1587
Daniel Dunbarbbc0af72008-11-08 05:48:37 +00001588 const RecordType *RT = cast<RecordType>(TT);
Chris Lattner8b23c252008-04-06 22:05:18 +00001589 const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl());
Ken Dyckb0fcc592011-02-11 01:54:29 +00001590 Width = toBits(Layout.getSize());
Ken Dyck7ad11e72011-02-15 02:32:40 +00001591 Align = toBits(Layout.getAlignment());
Chris Lattner49a953a2007-07-23 22:46:22 +00001592 break;
Chris Lattner983a8bb2007-07-13 22:13:22 +00001593 }
Douglas Gregordc572a32009-03-30 22:58:21 +00001594
Chris Lattner63d2b362009-10-22 05:17:15 +00001595 case Type::SubstTemplateTypeParm:
John McCallcebee162009-10-18 09:09:24 +00001596 return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
1597 getReplacementType().getTypePtr());
John McCallcebee162009-10-18 09:09:24 +00001598
Richard Smith30482bc2011-02-20 03:19:35 +00001599 case Type::Auto: {
1600 const AutoType *A = cast<AutoType>(T);
Richard Smith27d807c2013-04-30 13:56:41 +00001601 assert(!A->getDeducedType().isNull() &&
1602 "cannot request the size of an undeduced or dependent auto type");
Matt Beaumont-Gay7a24210e2011-02-22 20:00:16 +00001603 return getTypeInfo(A->getDeducedType().getTypePtr());
Richard Smith30482bc2011-02-20 03:19:35 +00001604 }
1605
Abramo Bagnara924a8f32010-12-10 16:29:40 +00001606 case Type::Paren:
1607 return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr());
1608
Douglas Gregoref462e62009-04-30 17:32:17 +00001609 case Type::Typedef: {
Richard Smithdda56e42011-04-15 14:24:37 +00001610 const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl();
Douglas Gregorf5bae222010-08-27 00:11:28 +00001611 std::pair<uint64_t, unsigned> Info
1612 = getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
Chris Lattner29eb47b2011-02-19 22:55:41 +00001613 // If the typedef has an aligned attribute on it, it overrides any computed
1614 // alignment we have. This violates the GCC documentation (which says that
1615 // attribute(aligned) can only round up) but matches its implementation.
1616 if (unsigned AttrAlign = Typedef->getMaxAlignment())
1617 Align = AttrAlign;
1618 else
1619 Align = Info.second;
Douglas Gregorf5bae222010-08-27 00:11:28 +00001620 Width = Info.first;
Douglas Gregordc572a32009-03-30 22:58:21 +00001621 break;
Chris Lattner8b23c252008-04-06 22:05:18 +00001622 }
Douglas Gregoref462e62009-04-30 17:32:17 +00001623
1624 case Type::TypeOfExpr:
1625 return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType()
1626 .getTypePtr());
1627
1628 case Type::TypeOf:
1629 return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr());
1630
Anders Carlsson81df7b82009-06-24 19:06:50 +00001631 case Type::Decltype:
1632 return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType()
1633 .getTypePtr());
1634
Alexis Hunte852b102011-05-24 22:41:36 +00001635 case Type::UnaryTransform:
1636 return getTypeInfo(cast<UnaryTransformType>(T)->getUnderlyingType());
1637
Abramo Bagnara6150c882010-05-11 21:36:43 +00001638 case Type::Elaborated:
1639 return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr());
Mike Stump11289f42009-09-09 15:08:12 +00001640
John McCall81904512011-01-06 01:58:22 +00001641 case Type::Attributed:
1642 return getTypeInfo(
1643 cast<AttributedType>(T)->getEquivalentType().getTypePtr());
1644
Richard Smith3f1b5d02011-05-05 21:57:07 +00001645 case Type::TemplateSpecialization: {
Mike Stump11289f42009-09-09 15:08:12 +00001646 assert(getCanonicalType(T) != T &&
Douglas Gregoref462e62009-04-30 17:32:17 +00001647 "Cannot request the size of a dependent type");
Richard Smith3f1b5d02011-05-05 21:57:07 +00001648 const TemplateSpecializationType *TST = cast<TemplateSpecializationType>(T);
1649 // A type alias template specialization may refer to a typedef with the
1650 // aligned attribute on it.
1651 if (TST->isTypeAlias())
1652 return getTypeInfo(TST->getAliasedType().getTypePtr());
1653 else
1654 return getTypeInfo(getCanonicalType(T));
1655 }
1656
Eli Friedman0dfb8892011-10-06 23:00:33 +00001657 case Type::Atomic: {
John McCalla8ec7eb2013-03-07 21:37:17 +00001658 // Start with the base type information.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00001659 std::pair<uint64_t, unsigned> Info
1660 = getTypeInfo(cast<AtomicType>(T)->getValueType());
1661 Width = Info.first;
1662 Align = Info.second;
John McCalla8ec7eb2013-03-07 21:37:17 +00001663
1664 // If the size of the type doesn't exceed the platform's max
1665 // atomic promotion width, make the size and alignment more
1666 // favorable to atomic operations:
1667 if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth()) {
1668 // Round the size up to a power of 2.
1669 if (!llvm::isPowerOf2_64(Width))
1670 Width = llvm::NextPowerOf2(Width);
1671
1672 // Set the alignment equal to the size.
Eli Friedman4b72fdd2011-10-14 20:59:01 +00001673 Align = static_cast<unsigned>(Width);
1674 }
Eli Friedman0dfb8892011-10-06 23:00:33 +00001675 }
1676
Douglas Gregoref462e62009-04-30 17:32:17 +00001677 }
Mike Stump11289f42009-09-09 15:08:12 +00001678
Eli Friedman4b72fdd2011-10-14 20:59:01 +00001679 assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2");
Chris Lattner7570e9c2008-03-08 08:52:55 +00001680 return std::make_pair(Width, Align);
Chris Lattner983a8bb2007-07-13 22:13:22 +00001681}
1682
Ken Dyckcc56c542011-01-15 18:38:59 +00001683/// toCharUnitsFromBits - Convert a size in bits to a size in characters.
1684CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const {
1685 return CharUnits::fromQuantity(BitSize / getCharWidth());
1686}
1687
Ken Dyckb0fcc592011-02-11 01:54:29 +00001688/// toBits - Convert a size in characters to a size in characters.
1689int64_t ASTContext::toBits(CharUnits CharSize) const {
1690 return CharSize.getQuantity() * getCharWidth();
1691}
1692
Ken Dyck8c89d592009-12-22 14:23:30 +00001693/// getTypeSizeInChars - Return the size of the specified type, in characters.
1694/// This method does not work on incomplete types.
Jay Foad39c79802011-01-12 09:06:06 +00001695CharUnits ASTContext::getTypeSizeInChars(QualType T) const {
Ken Dyckcc56c542011-01-15 18:38:59 +00001696 return toCharUnitsFromBits(getTypeSize(T));
Ken Dyck8c89d592009-12-22 14:23:30 +00001697}
Jay Foad39c79802011-01-12 09:06:06 +00001698CharUnits ASTContext::getTypeSizeInChars(const Type *T) const {
Ken Dyckcc56c542011-01-15 18:38:59 +00001699 return toCharUnitsFromBits(getTypeSize(T));
Ken Dyck8c89d592009-12-22 14:23:30 +00001700}
1701
Ken Dycka6046ab2010-01-26 17:25:18 +00001702/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in
Ken Dyck24d28d62010-01-26 17:22:55 +00001703/// characters. This method does not work on incomplete types.
Jay Foad39c79802011-01-12 09:06:06 +00001704CharUnits ASTContext::getTypeAlignInChars(QualType T) const {
Ken Dyckcc56c542011-01-15 18:38:59 +00001705 return toCharUnitsFromBits(getTypeAlign(T));
Ken Dyck24d28d62010-01-26 17:22:55 +00001706}
Jay Foad39c79802011-01-12 09:06:06 +00001707CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
Ken Dyckcc56c542011-01-15 18:38:59 +00001708 return toCharUnitsFromBits(getTypeAlign(T));
Ken Dyck24d28d62010-01-26 17:22:55 +00001709}
1710
Chris Lattnera3402cd2009-01-27 18:08:34 +00001711/// getPreferredTypeAlign - Return the "preferred" alignment of the specified
1712/// type for the current target in bits. This can be different than the ABI
1713/// alignment in cases where it is beneficial for performance to overalign
1714/// a data type.
Jay Foad39c79802011-01-12 09:06:06 +00001715unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
Chris Lattnera3402cd2009-01-27 18:08:34 +00001716 unsigned ABIAlign = getTypeAlign(T);
Eli Friedman7ab09572009-05-25 21:27:19 +00001717
1718 // Double and long long should be naturally aligned if possible.
John McCall9dd450b2009-09-21 23:43:11 +00001719 if (const ComplexType* CT = T->getAs<ComplexType>())
Eli Friedman7ab09572009-05-25 21:27:19 +00001720 T = CT->getElementType().getTypePtr();
1721 if (T->isSpecificBuiltinType(BuiltinType::Double) ||
Chad Rosierb57321a2012-03-21 20:20:47 +00001722 T->isSpecificBuiltinType(BuiltinType::LongLong) ||
1723 T->isSpecificBuiltinType(BuiltinType::ULongLong))
Eli Friedman7ab09572009-05-25 21:27:19 +00001724 return std::max(ABIAlign, (unsigned)getTypeSize(T));
1725
Chris Lattnera3402cd2009-01-27 18:08:34 +00001726 return ABIAlign;
1727}
1728
Fariborz Jahaniana50b3a22010-08-20 21:21:08 +00001729/// DeepCollectObjCIvars -
1730/// This routine first collects all declared, but not synthesized, ivars in
1731/// super class and then collects all ivars, including those synthesized for
1732/// current class. This routine is used for implementation of current class
1733/// when all ivars, declared and synthesized are known.
Fariborz Jahanian0f44d812009-05-12 18:14:29 +00001734///
Fariborz Jahaniana50b3a22010-08-20 21:21:08 +00001735void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI,
1736 bool leafClass,
Jordy Rosea91768e2011-07-22 02:08:32 +00001737 SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const {
Fariborz Jahaniana50b3a22010-08-20 21:21:08 +00001738 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
1739 DeepCollectObjCIvars(SuperClass, false, Ivars);
1740 if (!leafClass) {
1741 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(),
1742 E = OI->ivar_end(); I != E; ++I)
David Blaikie40ed2972012-06-06 20:45:41 +00001743 Ivars.push_back(*I);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00001744 } else {
Fariborz Jahanianb26d5782011-06-28 18:05:25 +00001745 ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI);
Jordy Rosea91768e2011-07-22 02:08:32 +00001746 for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
Fariborz Jahanianb26d5782011-06-28 18:05:25 +00001747 Iv= Iv->getNextIvar())
1748 Ivars.push_back(Iv);
1749 }
Fariborz Jahanian0f44d812009-05-12 18:14:29 +00001750}
1751
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001752/// CollectInheritedProtocols - Collect all protocols in current class and
1753/// those inherited by it.
1754void ASTContext::CollectInheritedProtocols(const Decl *CDecl,
Fariborz Jahaniandc68f952010-02-12 19:27:33 +00001755 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001756 if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
Ted Kremenek0ef508d2010-09-01 01:21:15 +00001757 // We can use protocol_iterator here instead of
1758 // all_referenced_protocol_iterator since we are walking all categories.
1759 for (ObjCInterfaceDecl::all_protocol_iterator P = OI->all_referenced_protocol_begin(),
1760 PE = OI->all_referenced_protocol_end(); P != PE; ++P) {
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001761 ObjCProtocolDecl *Proto = (*P);
Douglas Gregor33b24292012-01-01 18:09:12 +00001762 Protocols.insert(Proto->getCanonicalDecl());
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001763 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
Fariborz Jahanian8e3b9db2010-02-25 18:24:33 +00001764 PE = Proto->protocol_end(); P != PE; ++P) {
Douglas Gregor33b24292012-01-01 18:09:12 +00001765 Protocols.insert((*P)->getCanonicalDecl());
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001766 CollectInheritedProtocols(*P, Protocols);
1767 }
Fariborz Jahanian8e3b9db2010-02-25 18:24:33 +00001768 }
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001769
1770 // Categories of this Interface.
Douglas Gregor048fbfa2013-01-16 23:00:23 +00001771 for (ObjCInterfaceDecl::visible_categories_iterator
1772 Cat = OI->visible_categories_begin(),
1773 CatEnd = OI->visible_categories_end();
1774 Cat != CatEnd; ++Cat) {
1775 CollectInheritedProtocols(*Cat, Protocols);
1776 }
1777
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001778 if (ObjCInterfaceDecl *SD = OI->getSuperClass())
1779 while (SD) {
1780 CollectInheritedProtocols(SD, Protocols);
1781 SD = SD->getSuperClass();
1782 }
Benjamin Kramer0a3fe042010-04-27 17:47:25 +00001783 } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
Ted Kremenek0ef508d2010-09-01 01:21:15 +00001784 for (ObjCCategoryDecl::protocol_iterator P = OC->protocol_begin(),
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001785 PE = OC->protocol_end(); P != PE; ++P) {
1786 ObjCProtocolDecl *Proto = (*P);
Douglas Gregor33b24292012-01-01 18:09:12 +00001787 Protocols.insert(Proto->getCanonicalDecl());
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001788 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
1789 PE = Proto->protocol_end(); P != PE; ++P)
1790 CollectInheritedProtocols(*P, Protocols);
1791 }
Benjamin Kramer0a3fe042010-04-27 17:47:25 +00001792 } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001793 for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(),
1794 PE = OP->protocol_end(); P != PE; ++P) {
1795 ObjCProtocolDecl *Proto = (*P);
Douglas Gregor33b24292012-01-01 18:09:12 +00001796 Protocols.insert(Proto->getCanonicalDecl());
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001797 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
1798 PE = Proto->protocol_end(); P != PE; ++P)
1799 CollectInheritedProtocols(*P, Protocols);
1800 }
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00001801 }
1802}
1803
Jay Foad39c79802011-01-12 09:06:06 +00001804unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const {
Fariborz Jahaniand2ae2d02010-03-22 18:25:57 +00001805 unsigned count = 0;
1806 // Count ivars declared in class extension.
Douglas Gregor048fbfa2013-01-16 23:00:23 +00001807 for (ObjCInterfaceDecl::known_extensions_iterator
1808 Ext = OI->known_extensions_begin(),
1809 ExtEnd = OI->known_extensions_end();
1810 Ext != ExtEnd; ++Ext) {
1811 count += Ext->ivar_size();
1812 }
1813
Fariborz Jahaniand2ae2d02010-03-22 18:25:57 +00001814 // Count ivar defined in this class's implementation. This
1815 // includes synthesized ivars.
1816 if (ObjCImplementationDecl *ImplDecl = OI->getImplementation())
Benjamin Kramer0a3fe042010-04-27 17:47:25 +00001817 count += ImplDecl->ivar_size();
1818
Fariborz Jahanian7c809592009-06-04 01:19:09 +00001819 return count;
1820}
1821
Argyrios Kyrtzidis2e809ce2012-02-03 05:58:16 +00001822bool ASTContext::isSentinelNullExpr(const Expr *E) {
1823 if (!E)
1824 return false;
1825
1826 // nullptr_t is always treated as null.
1827 if (E->getType()->isNullPtrType()) return true;
1828
1829 if (E->getType()->isAnyPointerType() &&
1830 E->IgnoreParenCasts()->isNullPointerConstant(*this,
1831 Expr::NPC_ValueDependentIsNull))
1832 return true;
1833
1834 // Unfortunately, __null has type 'int'.
1835 if (isa<GNUNullExpr>(E)) return true;
1836
1837 return false;
1838}
1839
Argyrios Kyrtzidis6d9fab72009-07-21 00:05:53 +00001840/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists.
1841ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
1842 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
1843 I = ObjCImpls.find(D);
1844 if (I != ObjCImpls.end())
1845 return cast<ObjCImplementationDecl>(I->second);
1846 return 0;
1847}
1848/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists.
1849ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) {
1850 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
1851 I = ObjCImpls.find(D);
1852 if (I != ObjCImpls.end())
1853 return cast<ObjCCategoryImplDecl>(I->second);
1854 return 0;
1855}
1856
1857/// \brief Set the implementation of ObjCInterfaceDecl.
1858void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD,
1859 ObjCImplementationDecl *ImplD) {
1860 assert(IFaceD && ImplD && "Passed null params");
1861 ObjCImpls[IFaceD] = ImplD;
1862}
1863/// \brief Set the implementation of ObjCCategoryDecl.
1864void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD,
1865 ObjCCategoryImplDecl *ImplD) {
1866 assert(CatD && ImplD && "Passed null params");
1867 ObjCImpls[CatD] = ImplD;
1868}
1869
Dmitri Gribenko37527c22013-02-03 13:23:21 +00001870const ObjCInterfaceDecl *ASTContext::getObjContainingInterface(
1871 const NamedDecl *ND) const {
1872 if (const ObjCInterfaceDecl *ID =
1873 dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext()))
Argyrios Kyrtzidisb9689bb2011-11-01 17:14:12 +00001874 return ID;
Dmitri Gribenko37527c22013-02-03 13:23:21 +00001875 if (const ObjCCategoryDecl *CD =
1876 dyn_cast<ObjCCategoryDecl>(ND->getDeclContext()))
Argyrios Kyrtzidisb9689bb2011-11-01 17:14:12 +00001877 return CD->getClassInterface();
Dmitri Gribenko37527c22013-02-03 13:23:21 +00001878 if (const ObjCImplDecl *IMD =
1879 dyn_cast<ObjCImplDecl>(ND->getDeclContext()))
Argyrios Kyrtzidisb9689bb2011-11-01 17:14:12 +00001880 return IMD->getClassInterface();
1881
1882 return 0;
1883}
1884
Fariborz Jahanian7cfe7672010-12-01 22:29:46 +00001885/// \brief Get the copy initialization expression of VarDecl,or NULL if
1886/// none exists.
Fariborz Jahanian50198092010-12-02 17:02:11 +00001887Expr *ASTContext::getBlockVarCopyInits(const VarDecl*VD) {
Fariborz Jahanian1321cbb2010-12-06 17:28:17 +00001888 assert(VD && "Passed null params");
1889 assert(VD->hasAttr<BlocksAttr>() &&
1890 "getBlockVarCopyInits - not __block var");
Fariborz Jahanian50198092010-12-02 17:02:11 +00001891 llvm::DenseMap<const VarDecl*, Expr*>::iterator
Fariborz Jahanian1321cbb2010-12-06 17:28:17 +00001892 I = BlockVarCopyInits.find(VD);
Fariborz Jahanian7cfe7672010-12-01 22:29:46 +00001893 return (I != BlockVarCopyInits.end()) ? cast<Expr>(I->second) : 0;
1894}
1895
1896/// \brief Set the copy inialization expression of a block var decl.
1897void ASTContext::setBlockVarCopyInits(VarDecl*VD, Expr* Init) {
1898 assert(VD && Init && "Passed null params");
Fariborz Jahanian1321cbb2010-12-06 17:28:17 +00001899 assert(VD->hasAttr<BlocksAttr>() &&
1900 "setBlockVarCopyInits - not __block var");
Fariborz Jahanian7cfe7672010-12-01 22:29:46 +00001901 BlockVarCopyInits[VD] = Init;
1902}
1903
John McCallbcd03502009-12-07 02:54:59 +00001904TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T,
Jay Foad39c79802011-01-12 09:06:06 +00001905 unsigned DataSize) const {
John McCall26fe7e02009-10-21 00:23:54 +00001906 if (!DataSize)
1907 DataSize = TypeLoc::getFullDataSizeForType(T);
1908 else
1909 assert(DataSize == TypeLoc::getFullDataSizeForType(T) &&
John McCallbcd03502009-12-07 02:54:59 +00001910 "incorrect data size provided to CreateTypeSourceInfo!");
John McCall26fe7e02009-10-21 00:23:54 +00001911
John McCallbcd03502009-12-07 02:54:59 +00001912 TypeSourceInfo *TInfo =
1913 (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
1914 new (TInfo) TypeSourceInfo(T);
1915 return TInfo;
Argyrios Kyrtzidis3f79ad72009-08-19 01:27:32 +00001916}
1917
John McCallbcd03502009-12-07 02:54:59 +00001918TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T,
Douglas Gregor0231d8d2011-01-19 20:10:05 +00001919 SourceLocation L) const {
John McCallbcd03502009-12-07 02:54:59 +00001920 TypeSourceInfo *DI = CreateTypeSourceInfo(T);
Douglas Gregor2d525f02011-01-25 19:13:18 +00001921 DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L);
John McCall3665e002009-10-23 21:14:09 +00001922 return DI;
1923}
1924
Daniel Dunbar02f7f5f2009-05-03 10:38:35 +00001925const ASTRecordLayout &
Jay Foad39c79802011-01-12 09:06:06 +00001926ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const {
Daniel Dunbar02f7f5f2009-05-03 10:38:35 +00001927 return getObjCLayout(D, 0);
1928}
1929
1930const ASTRecordLayout &
Jay Foad39c79802011-01-12 09:06:06 +00001931ASTContext::getASTObjCImplementationLayout(
1932 const ObjCImplementationDecl *D) const {
Daniel Dunbar02f7f5f2009-05-03 10:38:35 +00001933 return getObjCLayout(D->getClassInterface(), D);
1934}
1935
Chris Lattner983a8bb2007-07-13 22:13:22 +00001936//===----------------------------------------------------------------------===//
1937// Type creation/memoization methods
1938//===----------------------------------------------------------------------===//
1939
Jay Foad39c79802011-01-12 09:06:06 +00001940QualType
John McCall33ddac02011-01-19 10:06:00 +00001941ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
1942 unsigned fastQuals = quals.getFastQualifiers();
1943 quals.removeFastQualifiers();
John McCall8ccfcb52009-09-24 19:53:00 +00001944
1945 // Check if we've already instantiated this type.
1946 llvm::FoldingSetNodeID ID;
John McCall33ddac02011-01-19 10:06:00 +00001947 ExtQuals::Profile(ID, baseType, quals);
1948 void *insertPos = 0;
1949 if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
1950 assert(eq->getQualifiers() == quals);
1951 return QualType(eq, fastQuals);
John McCall8ccfcb52009-09-24 19:53:00 +00001952 }
1953
John McCall33ddac02011-01-19 10:06:00 +00001954 // If the base type is not canonical, make the appropriate canonical type.
1955 QualType canon;
1956 if (!baseType->isCanonicalUnqualified()) {
1957 SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split();
John McCall18ce25e2012-02-08 00:46:36 +00001958 canonSplit.Quals.addConsistentQualifiers(quals);
1959 canon = getExtQualType(canonSplit.Ty, canonSplit.Quals);
John McCall33ddac02011-01-19 10:06:00 +00001960
1961 // Re-find the insert position.
1962 (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
1963 }
1964
1965 ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
1966 ExtQualNodes.InsertNode(eq, insertPos);
1967 return QualType(eq, fastQuals);
John McCall8ccfcb52009-09-24 19:53:00 +00001968}
1969
Jay Foad39c79802011-01-12 09:06:06 +00001970QualType
1971ASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) const {
Chris Lattner76a00cf2008-04-06 22:59:24 +00001972 QualType CanT = getCanonicalType(T);
1973 if (CanT.getAddressSpace() == AddressSpace)
Chris Lattner445fcab2008-02-20 20:55:12 +00001974 return T;
Chris Lattnerd60183d2009-02-18 22:53:11 +00001975
John McCall8ccfcb52009-09-24 19:53:00 +00001976 // If we are composing extended qualifiers together, merge together
1977 // into one ExtQuals node.
1978 QualifierCollector Quals;
1979 const Type *TypeNode = Quals.strip(T);
Mike Stump11289f42009-09-09 15:08:12 +00001980
John McCall8ccfcb52009-09-24 19:53:00 +00001981 // If this type already has an address space specified, it cannot get
1982 // another one.
1983 assert(!Quals.hasAddressSpace() &&
1984 "Type cannot be in multiple addr spaces!");
1985 Quals.addAddressSpace(AddressSpace);
Mike Stump11289f42009-09-09 15:08:12 +00001986
John McCall8ccfcb52009-09-24 19:53:00 +00001987 return getExtQualType(TypeNode, Quals);
Christopher Lamb025b5fb2008-02-04 02:31:56 +00001988}
1989
Chris Lattnerd60183d2009-02-18 22:53:11 +00001990QualType ASTContext::getObjCGCQualType(QualType T,
Jay Foad39c79802011-01-12 09:06:06 +00001991 Qualifiers::GC GCAttr) const {
Fariborz Jahaniane27e9342009-02-18 05:09:49 +00001992 QualType CanT = getCanonicalType(T);
Chris Lattnerd60183d2009-02-18 22:53:11 +00001993 if (CanT.getObjCGCAttr() == GCAttr)
Fariborz Jahaniane27e9342009-02-18 05:09:49 +00001994 return T;
Mike Stump11289f42009-09-09 15:08:12 +00001995
John McCall53fa7142010-12-24 02:08:15 +00001996 if (const PointerType *ptr = T->getAs<PointerType>()) {
1997 QualType Pointee = ptr->getPointeeType();
Steve Naroff6b712a72009-07-14 18:25:06 +00001998 if (Pointee->isAnyPointerType()) {
Fariborz Jahanianb68215c2009-06-03 17:15:17 +00001999 QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
2000 return getPointerType(ResultType);
2001 }
2002 }
Mike Stump11289f42009-09-09 15:08:12 +00002003
John McCall8ccfcb52009-09-24 19:53:00 +00002004 // If we are composing extended qualifiers together, merge together
2005 // into one ExtQuals node.
2006 QualifierCollector Quals;
2007 const Type *TypeNode = Quals.strip(T);
Mike Stump11289f42009-09-09 15:08:12 +00002008
John McCall8ccfcb52009-09-24 19:53:00 +00002009 // If this type already has an ObjCGC specified, it cannot get
2010 // another one.
2011 assert(!Quals.hasObjCGCAttr() &&
2012 "Type cannot have multiple ObjCGCs!");
2013 Quals.addObjCGCAttr(GCAttr);
Mike Stump11289f42009-09-09 15:08:12 +00002014
John McCall8ccfcb52009-09-24 19:53:00 +00002015 return getExtQualType(TypeNode, Quals);
Fariborz Jahaniane27e9342009-02-18 05:09:49 +00002016}
Chris Lattner983a8bb2007-07-13 22:13:22 +00002017
John McCall4f5019e2010-12-19 02:44:49 +00002018const FunctionType *ASTContext::adjustFunctionType(const FunctionType *T,
2019 FunctionType::ExtInfo Info) {
2020 if (T->getExtInfo() == Info)
2021 return T;
2022
2023 QualType Result;
2024 if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
2025 Result = getFunctionNoProtoType(FNPT->getResultType(), Info);
2026 } else {
2027 const FunctionProtoType *FPT = cast<FunctionProtoType>(T);
2028 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
2029 EPI.ExtInfo = Info;
Jordan Rose5c382722013-03-08 21:51:21 +00002030 Result = getFunctionType(FPT->getResultType(),
2031 ArrayRef<QualType>(FPT->arg_type_begin(),
2032 FPT->getNumArgs()),
2033 EPI);
John McCall4f5019e2010-12-19 02:44:49 +00002034 }
2035
2036 return cast<FunctionType>(Result.getTypePtr());
2037}
2038
Chris Lattnerc6395932007-06-22 20:56:16 +00002039/// getComplexType - Return the uniqued reference to the type for a complex
2040/// number with the specified element type.
Jay Foad39c79802011-01-12 09:06:06 +00002041QualType ASTContext::getComplexType(QualType T) const {
Chris Lattnerc6395932007-06-22 20:56:16 +00002042 // Unique pointers, to guarantee there is only one pointer of a particular
2043 // structure.
2044 llvm::FoldingSetNodeID ID;
2045 ComplexType::Profile(ID, T);
Mike Stump11289f42009-09-09 15:08:12 +00002046
Chris Lattnerc6395932007-06-22 20:56:16 +00002047 void *InsertPos = 0;
2048 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
2049 return QualType(CT, 0);
Mike Stump11289f42009-09-09 15:08:12 +00002050
Chris Lattnerc6395932007-06-22 20:56:16 +00002051 // If the pointee type isn't canonical, this won't be a canonical type either,
2052 // so fill in the canonical type field.
2053 QualType Canonical;
John McCallb692a092009-10-22 20:10:53 +00002054 if (!T.isCanonical()) {
Chris Lattner76a00cf2008-04-06 22:59:24 +00002055 Canonical = getComplexType(getCanonicalType(T));
Mike Stump11289f42009-09-09 15:08:12 +00002056
Chris Lattnerc6395932007-06-22 20:56:16 +00002057 // Get the new insert position for the node we care about.
2058 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002059 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Chris Lattnerc6395932007-06-22 20:56:16 +00002060 }
John McCall90d1c2d2009-09-24 23:30:46 +00002061 ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
Chris Lattnerc6395932007-06-22 20:56:16 +00002062 Types.push_back(New);
2063 ComplexTypes.InsertNode(New, InsertPos);
2064 return QualType(New, 0);
2065}
2066
Chris Lattner970e54e2006-11-12 00:37:36 +00002067/// getPointerType - Return the uniqued reference to the type for a pointer to
2068/// the specified type.
Jay Foad39c79802011-01-12 09:06:06 +00002069QualType ASTContext::getPointerType(QualType T) const {
Chris Lattnerd5973eb2006-11-12 00:53:46 +00002070 // Unique pointers, to guarantee there is only one pointer of a particular
2071 // structure.
Chris Lattner23b7eb62007-06-15 23:05:46 +00002072 llvm::FoldingSetNodeID ID;
Chris Lattner67521df2007-01-27 01:29:36 +00002073 PointerType::Profile(ID, T);
Mike Stump11289f42009-09-09 15:08:12 +00002074
Chris Lattner67521df2007-01-27 01:29:36 +00002075 void *InsertPos = 0;
2076 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002077 return QualType(PT, 0);
Mike Stump11289f42009-09-09 15:08:12 +00002078
Chris Lattner7ccecb92006-11-12 08:50:50 +00002079 // If the pointee type isn't canonical, this won't be a canonical type either,
2080 // so fill in the canonical type field.
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002081 QualType Canonical;
Bob Wilsonc8541f22013-03-15 17:12:43 +00002082 if (!T.isCanonical()) {
Chris Lattner76a00cf2008-04-06 22:59:24 +00002083 Canonical = getPointerType(getCanonicalType(T));
Mike Stump11289f42009-09-09 15:08:12 +00002084
Bob Wilsonc8541f22013-03-15 17:12:43 +00002085 // Get the new insert position for the node we care about.
2086 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2087 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
2088 }
John McCall90d1c2d2009-09-24 23:30:46 +00002089 PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical);
Chris Lattner67521df2007-01-27 01:29:36 +00002090 Types.push_back(New);
2091 PointerTypes.InsertNode(New, InsertPos);
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002092 return QualType(New, 0);
Chris Lattnerddc135e2006-11-10 06:34:16 +00002093}
2094
Mike Stump11289f42009-09-09 15:08:12 +00002095/// getBlockPointerType - Return the uniqued reference to the type for
Steve Naroffec33ed92008-08-27 16:04:49 +00002096/// a pointer to the specified block.
Jay Foad39c79802011-01-12 09:06:06 +00002097QualType ASTContext::getBlockPointerType(QualType T) const {
Steve Naroff0ac012832008-08-28 19:20:44 +00002098 assert(T->isFunctionType() && "block of function types only");
2099 // Unique pointers, to guarantee there is only one block of a particular
Steve Naroffec33ed92008-08-27 16:04:49 +00002100 // structure.
2101 llvm::FoldingSetNodeID ID;
2102 BlockPointerType::Profile(ID, T);
Mike Stump11289f42009-09-09 15:08:12 +00002103
Steve Naroffec33ed92008-08-27 16:04:49 +00002104 void *InsertPos = 0;
2105 if (BlockPointerType *PT =
2106 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2107 return QualType(PT, 0);
Mike Stump11289f42009-09-09 15:08:12 +00002108
2109 // If the block pointee type isn't canonical, this won't be a canonical
Steve Naroffec33ed92008-08-27 16:04:49 +00002110 // type either so fill in the canonical type field.
2111 QualType Canonical;
John McCallb692a092009-10-22 20:10:53 +00002112 if (!T.isCanonical()) {
Steve Naroffec33ed92008-08-27 16:04:49 +00002113 Canonical = getBlockPointerType(getCanonicalType(T));
Mike Stump11289f42009-09-09 15:08:12 +00002114
Steve Naroffec33ed92008-08-27 16:04:49 +00002115 // Get the new insert position for the node we care about.
2116 BlockPointerType *NewIP =
2117 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002118 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Steve Naroffec33ed92008-08-27 16:04:49 +00002119 }
John McCall90d1c2d2009-09-24 23:30:46 +00002120 BlockPointerType *New
2121 = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
Steve Naroffec33ed92008-08-27 16:04:49 +00002122 Types.push_back(New);
2123 BlockPointerTypes.InsertNode(New, InsertPos);
2124 return QualType(New, 0);
2125}
2126
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002127/// getLValueReferenceType - Return the uniqued reference to the type for an
2128/// lvalue reference to the specified type.
Jay Foad39c79802011-01-12 09:06:06 +00002129QualType
2130ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const {
Douglas Gregor291e8ee2011-05-21 22:16:50 +00002131 assert(getCanonicalType(T) != OverloadTy &&
2132 "Unresolved overloaded function type");
2133
Bill Wendling3708c182007-05-27 10:15:43 +00002134 // Unique pointers, to guarantee there is only one pointer of a particular
2135 // structure.
Chris Lattner23b7eb62007-06-15 23:05:46 +00002136 llvm::FoldingSetNodeID ID;
John McCallfc93cf92009-10-22 22:37:11 +00002137 ReferenceType::Profile(ID, T, SpelledAsLValue);
Bill Wendling3708c182007-05-27 10:15:43 +00002138
2139 void *InsertPos = 0;
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002140 if (LValueReferenceType *RT =
2141 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
Bill Wendling3708c182007-05-27 10:15:43 +00002142 return QualType(RT, 0);
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002143
John McCallfc93cf92009-10-22 22:37:11 +00002144 const ReferenceType *InnerRef = T->getAs<ReferenceType>();
2145
Bill Wendling3708c182007-05-27 10:15:43 +00002146 // If the referencee type isn't canonical, this won't be a canonical type
2147 // either, so fill in the canonical type field.
2148 QualType Canonical;
John McCallfc93cf92009-10-22 22:37:11 +00002149 if (!SpelledAsLValue || InnerRef || !T.isCanonical()) {
2150 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2151 Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002152
Bill Wendling3708c182007-05-27 10:15:43 +00002153 // Get the new insert position for the node we care about.
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002154 LValueReferenceType *NewIP =
2155 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002156 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Bill Wendling3708c182007-05-27 10:15:43 +00002157 }
2158
John McCall90d1c2d2009-09-24 23:30:46 +00002159 LValueReferenceType *New
John McCallfc93cf92009-10-22 22:37:11 +00002160 = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
2161 SpelledAsLValue);
Bill Wendling3708c182007-05-27 10:15:43 +00002162 Types.push_back(New);
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002163 LValueReferenceTypes.InsertNode(New, InsertPos);
John McCallfc93cf92009-10-22 22:37:11 +00002164
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002165 return QualType(New, 0);
2166}
2167
2168/// getRValueReferenceType - Return the uniqued reference to the type for an
2169/// rvalue reference to the specified type.
Jay Foad39c79802011-01-12 09:06:06 +00002170QualType ASTContext::getRValueReferenceType(QualType T) const {
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002171 // Unique pointers, to guarantee there is only one pointer of a particular
2172 // structure.
2173 llvm::FoldingSetNodeID ID;
John McCallfc93cf92009-10-22 22:37:11 +00002174 ReferenceType::Profile(ID, T, false);
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002175
2176 void *InsertPos = 0;
2177 if (RValueReferenceType *RT =
2178 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2179 return QualType(RT, 0);
2180
John McCallfc93cf92009-10-22 22:37:11 +00002181 const ReferenceType *InnerRef = T->getAs<ReferenceType>();
2182
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002183 // If the referencee type isn't canonical, this won't be a canonical type
2184 // either, so fill in the canonical type field.
2185 QualType Canonical;
John McCallfc93cf92009-10-22 22:37:11 +00002186 if (InnerRef || !T.isCanonical()) {
2187 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2188 Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002189
2190 // Get the new insert position for the node we care about.
2191 RValueReferenceType *NewIP =
2192 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002193 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002194 }
2195
John McCall90d1c2d2009-09-24 23:30:46 +00002196 RValueReferenceType *New
2197 = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00002198 Types.push_back(New);
2199 RValueReferenceTypes.InsertNode(New, InsertPos);
Bill Wendling3708c182007-05-27 10:15:43 +00002200 return QualType(New, 0);
2201}
2202
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002203/// getMemberPointerType - Return the uniqued reference to the type for a
2204/// member pointer to the specified type, in the specified class.
Jay Foad39c79802011-01-12 09:06:06 +00002205QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const {
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002206 // Unique pointers, to guarantee there is only one pointer of a particular
2207 // structure.
2208 llvm::FoldingSetNodeID ID;
2209 MemberPointerType::Profile(ID, T, Cls);
2210
2211 void *InsertPos = 0;
2212 if (MemberPointerType *PT =
2213 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2214 return QualType(PT, 0);
2215
2216 // If the pointee or class type isn't canonical, this won't be a canonical
2217 // type either, so fill in the canonical type field.
2218 QualType Canonical;
Douglas Gregor615ac672009-11-04 16:49:01 +00002219 if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002220 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
2221
2222 // Get the new insert position for the node we care about.
2223 MemberPointerType *NewIP =
2224 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002225 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002226 }
John McCall90d1c2d2009-09-24 23:30:46 +00002227 MemberPointerType *New
2228 = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
Sebastian Redl9ed6efd2009-01-24 21:16:55 +00002229 Types.push_back(New);
2230 MemberPointerTypes.InsertNode(New, InsertPos);
2231 return QualType(New, 0);
2232}
2233
Mike Stump11289f42009-09-09 15:08:12 +00002234/// getConstantArrayType - Return the unique reference to the type for an
Steve Naroff5c131802007-08-30 01:06:46 +00002235/// array of the specified element type.
Mike Stump11289f42009-09-09 15:08:12 +00002236QualType ASTContext::getConstantArrayType(QualType EltTy,
Chris Lattnere2df3f92009-05-13 04:12:56 +00002237 const llvm::APInt &ArySizeIn,
Steve Naroff90dfdd52007-08-30 18:10:14 +00002238 ArrayType::ArraySizeModifier ASM,
Abramo Bagnara92141d22011-01-27 19:55:10 +00002239 unsigned IndexTypeQuals) const {
Sebastian Redl2dfdb822009-11-05 15:52:31 +00002240 assert((EltTy->isDependentType() ||
2241 EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&
Eli Friedmanbe7e42b2009-05-29 20:17:55 +00002242 "Constant array of VLAs is illegal!");
2243
Chris Lattnere2df3f92009-05-13 04:12:56 +00002244 // Convert the array size into a canonical width matching the pointer size for
2245 // the target.
2246 llvm::APInt ArySize(ArySizeIn);
Jay Foad6d4db0c2010-12-07 08:25:34 +00002247 ArySize =
Douglas Gregore8bbc122011-09-02 00:18:52 +00002248 ArySize.zextOrTrunc(Target->getPointerWidth(getTargetAddressSpace(EltTy)));
Mike Stump11289f42009-09-09 15:08:12 +00002249
Chris Lattner23b7eb62007-06-15 23:05:46 +00002250 llvm::FoldingSetNodeID ID;
Abramo Bagnara92141d22011-01-27 19:55:10 +00002251 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals);
Mike Stump11289f42009-09-09 15:08:12 +00002252
Chris Lattner36f8e652007-01-27 08:31:04 +00002253 void *InsertPos = 0;
Mike Stump11289f42009-09-09 15:08:12 +00002254 if (ConstantArrayType *ATP =
Ted Kremenekfc581a92007-10-31 17:10:13 +00002255 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002256 return QualType(ATP, 0);
Mike Stump11289f42009-09-09 15:08:12 +00002257
John McCall33ddac02011-01-19 10:06:00 +00002258 // If the element type isn't canonical or has qualifiers, this won't
2259 // be a canonical type either, so fill in the canonical type field.
2260 QualType Canon;
2261 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
2262 SplitQualType canonSplit = getCanonicalType(EltTy).split();
John McCall18ce25e2012-02-08 00:46:36 +00002263 Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize,
Abramo Bagnara92141d22011-01-27 19:55:10 +00002264 ASM, IndexTypeQuals);
John McCall18ce25e2012-02-08 00:46:36 +00002265 Canon = getQualifiedType(Canon, canonSplit.Quals);
John McCall33ddac02011-01-19 10:06:00 +00002266
Chris Lattner36f8e652007-01-27 08:31:04 +00002267 // Get the new insert position for the node we care about.
Mike Stump11289f42009-09-09 15:08:12 +00002268 ConstantArrayType *NewIP =
Ted Kremenekfc581a92007-10-31 17:10:13 +00002269 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002270 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Chris Lattner36f8e652007-01-27 08:31:04 +00002271 }
Mike Stump11289f42009-09-09 15:08:12 +00002272
John McCall90d1c2d2009-09-24 23:30:46 +00002273 ConstantArrayType *New = new(*this,TypeAlignment)
Abramo Bagnara92141d22011-01-27 19:55:10 +00002274 ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals);
Ted Kremenekfc581a92007-10-31 17:10:13 +00002275 ConstantArrayTypes.InsertNode(New, InsertPos);
Chris Lattner36f8e652007-01-27 08:31:04 +00002276 Types.push_back(New);
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002277 return QualType(New, 0);
Chris Lattner7ccecb92006-11-12 08:50:50 +00002278}
2279
John McCall06549462011-01-18 08:40:38 +00002280/// getVariableArrayDecayedType - Turns the given type, which may be
2281/// variably-modified, into the corresponding type with all the known
2282/// sizes replaced with [*].
2283QualType ASTContext::getVariableArrayDecayedType(QualType type) const {
2284 // Vastly most common case.
2285 if (!type->isVariablyModifiedType()) return type;
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00002286
John McCall06549462011-01-18 08:40:38 +00002287 QualType result;
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00002288
John McCall06549462011-01-18 08:40:38 +00002289 SplitQualType split = type.getSplitDesugaredType();
John McCall18ce25e2012-02-08 00:46:36 +00002290 const Type *ty = split.Ty;
John McCall06549462011-01-18 08:40:38 +00002291 switch (ty->getTypeClass()) {
2292#define TYPE(Class, Base)
2293#define ABSTRACT_TYPE(Class, Base)
2294#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2295#include "clang/AST/TypeNodes.def"
2296 llvm_unreachable("didn't desugar past all non-canonical types?");
2297
2298 // These types should never be variably-modified.
2299 case Type::Builtin:
2300 case Type::Complex:
2301 case Type::Vector:
2302 case Type::ExtVector:
2303 case Type::DependentSizedExtVector:
2304 case Type::ObjCObject:
2305 case Type::ObjCInterface:
2306 case Type::ObjCObjectPointer:
2307 case Type::Record:
2308 case Type::Enum:
2309 case Type::UnresolvedUsing:
2310 case Type::TypeOfExpr:
2311 case Type::TypeOf:
2312 case Type::Decltype:
Alexis Hunte852b102011-05-24 22:41:36 +00002313 case Type::UnaryTransform:
John McCall06549462011-01-18 08:40:38 +00002314 case Type::DependentName:
2315 case Type::InjectedClassName:
2316 case Type::TemplateSpecialization:
2317 case Type::DependentTemplateSpecialization:
2318 case Type::TemplateTypeParm:
2319 case Type::SubstTemplateTypeParmPack:
Richard Smith30482bc2011-02-20 03:19:35 +00002320 case Type::Auto:
John McCall06549462011-01-18 08:40:38 +00002321 case Type::PackExpansion:
2322 llvm_unreachable("type should never be variably-modified");
2323
2324 // These types can be variably-modified but should never need to
2325 // further decay.
2326 case Type::FunctionNoProto:
2327 case Type::FunctionProto:
2328 case Type::BlockPointer:
2329 case Type::MemberPointer:
2330 return type;
2331
2332 // These types can be variably-modified. All these modifications
2333 // preserve structure except as noted by comments.
2334 // TODO: if we ever care about optimizing VLAs, there are no-op
2335 // optimizations available here.
2336 case Type::Pointer:
2337 result = getPointerType(getVariableArrayDecayedType(
2338 cast<PointerType>(ty)->getPointeeType()));
2339 break;
2340
2341 case Type::LValueReference: {
2342 const LValueReferenceType *lv = cast<LValueReferenceType>(ty);
2343 result = getLValueReferenceType(
2344 getVariableArrayDecayedType(lv->getPointeeType()),
2345 lv->isSpelledAsLValue());
2346 break;
2347 }
2348
2349 case Type::RValueReference: {
2350 const RValueReferenceType *lv = cast<RValueReferenceType>(ty);
2351 result = getRValueReferenceType(
2352 getVariableArrayDecayedType(lv->getPointeeType()));
2353 break;
2354 }
2355
Eli Friedman0dfb8892011-10-06 23:00:33 +00002356 case Type::Atomic: {
2357 const AtomicType *at = cast<AtomicType>(ty);
2358 result = getAtomicType(getVariableArrayDecayedType(at->getValueType()));
2359 break;
2360 }
2361
John McCall06549462011-01-18 08:40:38 +00002362 case Type::ConstantArray: {
2363 const ConstantArrayType *cat = cast<ConstantArrayType>(ty);
2364 result = getConstantArrayType(
2365 getVariableArrayDecayedType(cat->getElementType()),
2366 cat->getSize(),
2367 cat->getSizeModifier(),
2368 cat->getIndexTypeCVRQualifiers());
2369 break;
2370 }
2371
2372 case Type::DependentSizedArray: {
2373 const DependentSizedArrayType *dat = cast<DependentSizedArrayType>(ty);
2374 result = getDependentSizedArrayType(
2375 getVariableArrayDecayedType(dat->getElementType()),
2376 dat->getSizeExpr(),
2377 dat->getSizeModifier(),
2378 dat->getIndexTypeCVRQualifiers(),
2379 dat->getBracketsRange());
2380 break;
2381 }
2382
2383 // Turn incomplete types into [*] types.
2384 case Type::IncompleteArray: {
2385 const IncompleteArrayType *iat = cast<IncompleteArrayType>(ty);
2386 result = getVariableArrayType(
2387 getVariableArrayDecayedType(iat->getElementType()),
2388 /*size*/ 0,
2389 ArrayType::Normal,
2390 iat->getIndexTypeCVRQualifiers(),
2391 SourceRange());
2392 break;
2393 }
2394
2395 // Turn VLA types into [*] types.
2396 case Type::VariableArray: {
2397 const VariableArrayType *vat = cast<VariableArrayType>(ty);
2398 result = getVariableArrayType(
2399 getVariableArrayDecayedType(vat->getElementType()),
2400 /*size*/ 0,
2401 ArrayType::Star,
2402 vat->getIndexTypeCVRQualifiers(),
2403 vat->getBracketsRange());
2404 break;
2405 }
2406 }
2407
2408 // Apply the top-level qualifiers from the original.
John McCall18ce25e2012-02-08 00:46:36 +00002409 return getQualifiedType(result, split.Quals);
John McCall06549462011-01-18 08:40:38 +00002410}
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00002411
Steve Naroffcadebd02007-08-30 18:14:25 +00002412/// getVariableArrayType - Returns a non-unique reference to the type for a
2413/// variable array of the specified element type.
Douglas Gregor04318252009-07-06 15:59:29 +00002414QualType ASTContext::getVariableArrayType(QualType EltTy,
2415 Expr *NumElts,
Steve Naroff90dfdd52007-08-30 18:10:14 +00002416 ArrayType::ArraySizeModifier ASM,
Abramo Bagnara92141d22011-01-27 19:55:10 +00002417 unsigned IndexTypeQuals,
Jay Foad39c79802011-01-12 09:06:06 +00002418 SourceRange Brackets) const {
Eli Friedmanbd258282008-02-15 18:16:39 +00002419 // Since we don't unique expressions, it isn't possible to unique VLA's
2420 // that have an expression provided for their size.
John McCall33ddac02011-01-19 10:06:00 +00002421 QualType Canon;
Douglas Gregor5e8c8c02010-05-23 16:10:32 +00002422
John McCall33ddac02011-01-19 10:06:00 +00002423 // Be sure to pull qualifiers off the element type.
2424 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
2425 SplitQualType canonSplit = getCanonicalType(EltTy).split();
John McCall18ce25e2012-02-08 00:46:36 +00002426 Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM,
Abramo Bagnara92141d22011-01-27 19:55:10 +00002427 IndexTypeQuals, Brackets);
John McCall18ce25e2012-02-08 00:46:36 +00002428 Canon = getQualifiedType(Canon, canonSplit.Quals);
Douglas Gregor5e8c8c02010-05-23 16:10:32 +00002429 }
2430
John McCall90d1c2d2009-09-24 23:30:46 +00002431 VariableArrayType *New = new(*this, TypeAlignment)
Abramo Bagnara92141d22011-01-27 19:55:10 +00002432 VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);
Eli Friedmanbd258282008-02-15 18:16:39 +00002433
2434 VariableArrayTypes.push_back(New);
2435 Types.push_back(New);
2436 return QualType(New, 0);
2437}
2438
Douglas Gregor4619e432008-12-05 23:32:09 +00002439/// getDependentSizedArrayType - Returns a non-unique reference to
2440/// the type for a dependently-sized array of the specified element
Douglas Gregorf3f95522009-07-31 00:23:35 +00002441/// type.
John McCall33ddac02011-01-19 10:06:00 +00002442QualType ASTContext::getDependentSizedArrayType(QualType elementType,
2443 Expr *numElements,
Douglas Gregor4619e432008-12-05 23:32:09 +00002444 ArrayType::ArraySizeModifier ASM,
John McCall33ddac02011-01-19 10:06:00 +00002445 unsigned elementTypeQuals,
2446 SourceRange brackets) const {
2447 assert((!numElements || numElements->isTypeDependent() ||
2448 numElements->isValueDependent()) &&
Douglas Gregor4619e432008-12-05 23:32:09 +00002449 "Size must be type- or value-dependent!");
2450
John McCall33ddac02011-01-19 10:06:00 +00002451 // Dependently-sized array types that do not have a specified number
2452 // of elements will have their sizes deduced from a dependent
2453 // initializer. We do no canonicalization here at all, which is okay
2454 // because they can't be used in most locations.
2455 if (!numElements) {
2456 DependentSizedArrayType *newType
2457 = new (*this, TypeAlignment)
2458 DependentSizedArrayType(*this, elementType, QualType(),
2459 numElements, ASM, elementTypeQuals,
2460 brackets);
2461 Types.push_back(newType);
2462 return QualType(newType, 0);
2463 }
2464
2465 // Otherwise, we actually build a new type every time, but we
2466 // also build a canonical type.
2467
2468 SplitQualType canonElementType = getCanonicalType(elementType).split();
2469
2470 void *insertPos = 0;
Douglas Gregorc42075a2010-02-04 18:10:26 +00002471 llvm::FoldingSetNodeID ID;
John McCall33ddac02011-01-19 10:06:00 +00002472 DependentSizedArrayType::Profile(ID, *this,
John McCall18ce25e2012-02-08 00:46:36 +00002473 QualType(canonElementType.Ty, 0),
John McCall33ddac02011-01-19 10:06:00 +00002474 ASM, elementTypeQuals, numElements);
Douglas Gregorad2956c2009-11-19 18:03:26 +00002475
John McCall33ddac02011-01-19 10:06:00 +00002476 // Look for an existing type with these properties.
2477 DependentSizedArrayType *canonTy =
2478 DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
Douglas Gregorad2956c2009-11-19 18:03:26 +00002479
John McCall33ddac02011-01-19 10:06:00 +00002480 // If we don't have one, build one.
2481 if (!canonTy) {
2482 canonTy = new (*this, TypeAlignment)
John McCall18ce25e2012-02-08 00:46:36 +00002483 DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0),
John McCall33ddac02011-01-19 10:06:00 +00002484 QualType(), numElements, ASM, elementTypeQuals,
2485 brackets);
2486 DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
2487 Types.push_back(canonTy);
Douglas Gregorad2956c2009-11-19 18:03:26 +00002488 }
2489
John McCall33ddac02011-01-19 10:06:00 +00002490 // Apply qualifiers from the element type to the array.
2491 QualType canon = getQualifiedType(QualType(canonTy,0),
John McCall18ce25e2012-02-08 00:46:36 +00002492 canonElementType.Quals);
Mike Stump11289f42009-09-09 15:08:12 +00002493
John McCall33ddac02011-01-19 10:06:00 +00002494 // If we didn't need extra canonicalization for the element type,
2495 // then just use that as our result.
John McCall18ce25e2012-02-08 00:46:36 +00002496 if (QualType(canonElementType.Ty, 0) == elementType)
John McCall33ddac02011-01-19 10:06:00 +00002497 return canon;
2498
2499 // Otherwise, we need to build a type which follows the spelling
2500 // of the element type.
2501 DependentSizedArrayType *sugaredType
2502 = new (*this, TypeAlignment)
2503 DependentSizedArrayType(*this, elementType, canon, numElements,
2504 ASM, elementTypeQuals, brackets);
2505 Types.push_back(sugaredType);
2506 return QualType(sugaredType, 0);
Douglas Gregor4619e432008-12-05 23:32:09 +00002507}
2508
John McCall33ddac02011-01-19 10:06:00 +00002509QualType ASTContext::getIncompleteArrayType(QualType elementType,
Eli Friedmanbd258282008-02-15 18:16:39 +00002510 ArrayType::ArraySizeModifier ASM,
John McCall33ddac02011-01-19 10:06:00 +00002511 unsigned elementTypeQuals) const {
Eli Friedmanbd258282008-02-15 18:16:39 +00002512 llvm::FoldingSetNodeID ID;
John McCall33ddac02011-01-19 10:06:00 +00002513 IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals);
Eli Friedmanbd258282008-02-15 18:16:39 +00002514
John McCall33ddac02011-01-19 10:06:00 +00002515 void *insertPos = 0;
2516 if (IncompleteArrayType *iat =
2517 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
2518 return QualType(iat, 0);
Eli Friedmanbd258282008-02-15 18:16:39 +00002519
2520 // If the element type isn't canonical, this won't be a canonical type
John McCall33ddac02011-01-19 10:06:00 +00002521 // either, so fill in the canonical type field. We also have to pull
2522 // qualifiers off the element type.
2523 QualType canon;
Eli Friedmanbd258282008-02-15 18:16:39 +00002524
John McCall33ddac02011-01-19 10:06:00 +00002525 if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) {
2526 SplitQualType canonSplit = getCanonicalType(elementType).split();
John McCall18ce25e2012-02-08 00:46:36 +00002527 canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0),
John McCall33ddac02011-01-19 10:06:00 +00002528 ASM, elementTypeQuals);
John McCall18ce25e2012-02-08 00:46:36 +00002529 canon = getQualifiedType(canon, canonSplit.Quals);
Eli Friedmanbd258282008-02-15 18:16:39 +00002530
2531 // Get the new insert position for the node we care about.
John McCall33ddac02011-01-19 10:06:00 +00002532 IncompleteArrayType *existing =
2533 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
2534 assert(!existing && "Shouldn't be in the map!"); (void) existing;
Ted Kremenek843ebedd2007-10-29 23:37:31 +00002535 }
Eli Friedmanbd258282008-02-15 18:16:39 +00002536
John McCall33ddac02011-01-19 10:06:00 +00002537 IncompleteArrayType *newType = new (*this, TypeAlignment)
2538 IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);
Eli Friedmanbd258282008-02-15 18:16:39 +00002539
John McCall33ddac02011-01-19 10:06:00 +00002540 IncompleteArrayTypes.InsertNode(newType, insertPos);
2541 Types.push_back(newType);
2542 return QualType(newType, 0);
Steve Naroff5c131802007-08-30 01:06:46 +00002543}
2544
Steve Naroff91fcddb2007-07-18 18:00:27 +00002545/// getVectorType - Return the unique reference to a vector type of
2546/// the specified element type and size. VectorType must be a built-in type.
John Thompson22334602010-02-05 00:12:22 +00002547QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts,
Jay Foad39c79802011-01-12 09:06:06 +00002548 VectorType::VectorKind VecKind) const {
John McCall33ddac02011-01-19 10:06:00 +00002549 assert(vecType->isBuiltinType());
Mike Stump11289f42009-09-09 15:08:12 +00002550
Steve Naroff4ae0ac62007-07-06 23:09:18 +00002551 // Check if we've already instantiated a vector of this type.
2552 llvm::FoldingSetNodeID ID;
Bob Wilsonaeb56442010-11-10 21:56:12 +00002553 VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind);
Chris Lattner37141f42010-06-23 06:00:24 +00002554
Steve Naroff4ae0ac62007-07-06 23:09:18 +00002555 void *InsertPos = 0;
2556 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
2557 return QualType(VTP, 0);
2558
2559 // If the element type isn't canonical, this won't be a canonical type either,
2560 // so fill in the canonical type field.
2561 QualType Canonical;
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00002562 if (!vecType.isCanonical()) {
Bob Wilson77954802010-11-16 00:32:20 +00002563 Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind);
Mike Stump11289f42009-09-09 15:08:12 +00002564
Steve Naroff4ae0ac62007-07-06 23:09:18 +00002565 // Get the new insert position for the node we care about.
2566 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002567 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Steve Naroff4ae0ac62007-07-06 23:09:18 +00002568 }
John McCall90d1c2d2009-09-24 23:30:46 +00002569 VectorType *New = new (*this, TypeAlignment)
Bob Wilsonaeb56442010-11-10 21:56:12 +00002570 VectorType(vecType, NumElts, Canonical, VecKind);
Steve Naroff4ae0ac62007-07-06 23:09:18 +00002571 VectorTypes.InsertNode(New, InsertPos);
2572 Types.push_back(New);
2573 return QualType(New, 0);
2574}
2575
Nate Begemance4d7fc2008-04-18 23:10:10 +00002576/// getExtVectorType - Return the unique reference to an extended vector type of
Steve Naroff91fcddb2007-07-18 18:00:27 +00002577/// the specified element type and size. VectorType must be a built-in type.
Jay Foad39c79802011-01-12 09:06:06 +00002578QualType
2579ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const {
Douglas Gregor39c02722011-06-15 16:02:29 +00002580 assert(vecType->isBuiltinType() || vecType->isDependentType());
Mike Stump11289f42009-09-09 15:08:12 +00002581
Steve Naroff91fcddb2007-07-18 18:00:27 +00002582 // Check if we've already instantiated a vector of this type.
2583 llvm::FoldingSetNodeID ID;
Chris Lattner37141f42010-06-23 06:00:24 +00002584 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
Bob Wilsonaeb56442010-11-10 21:56:12 +00002585 VectorType::GenericVector);
Steve Naroff91fcddb2007-07-18 18:00:27 +00002586 void *InsertPos = 0;
2587 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
2588 return QualType(VTP, 0);
2589
2590 // If the element type isn't canonical, this won't be a canonical type either,
2591 // so fill in the canonical type field.
2592 QualType Canonical;
John McCallb692a092009-10-22 20:10:53 +00002593 if (!vecType.isCanonical()) {
Nate Begemance4d7fc2008-04-18 23:10:10 +00002594 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
Mike Stump11289f42009-09-09 15:08:12 +00002595
Steve Naroff91fcddb2007-07-18 18:00:27 +00002596 // Get the new insert position for the node we care about.
2597 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002598 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Steve Naroff91fcddb2007-07-18 18:00:27 +00002599 }
John McCall90d1c2d2009-09-24 23:30:46 +00002600 ExtVectorType *New = new (*this, TypeAlignment)
2601 ExtVectorType(vecType, NumElts, Canonical);
Steve Naroff91fcddb2007-07-18 18:00:27 +00002602 VectorTypes.InsertNode(New, InsertPos);
2603 Types.push_back(New);
2604 return QualType(New, 0);
2605}
2606
Jay Foad39c79802011-01-12 09:06:06 +00002607QualType
2608ASTContext::getDependentSizedExtVectorType(QualType vecType,
2609 Expr *SizeExpr,
2610 SourceLocation AttrLoc) const {
Douglas Gregor352169a2009-07-31 03:54:25 +00002611 llvm::FoldingSetNodeID ID;
Mike Stump11289f42009-09-09 15:08:12 +00002612 DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType),
Douglas Gregor352169a2009-07-31 03:54:25 +00002613 SizeExpr);
Mike Stump11289f42009-09-09 15:08:12 +00002614
Douglas Gregor352169a2009-07-31 03:54:25 +00002615 void *InsertPos = 0;
2616 DependentSizedExtVectorType *Canon
2617 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
2618 DependentSizedExtVectorType *New;
2619 if (Canon) {
2620 // We already have a canonical version of this array type; use it as
2621 // the canonical type for a newly-built type.
John McCall90d1c2d2009-09-24 23:30:46 +00002622 New = new (*this, TypeAlignment)
2623 DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
2624 SizeExpr, AttrLoc);
Douglas Gregor352169a2009-07-31 03:54:25 +00002625 } else {
2626 QualType CanonVecTy = getCanonicalType(vecType);
2627 if (CanonVecTy == vecType) {
John McCall90d1c2d2009-09-24 23:30:46 +00002628 New = new (*this, TypeAlignment)
2629 DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
2630 AttrLoc);
Douglas Gregorc42075a2010-02-04 18:10:26 +00002631
2632 DependentSizedExtVectorType *CanonCheck
2633 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
2634 assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken");
2635 (void)CanonCheck;
Douglas Gregor352169a2009-07-31 03:54:25 +00002636 DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
2637 } else {
2638 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
2639 SourceLocation());
John McCall90d1c2d2009-09-24 23:30:46 +00002640 New = new (*this, TypeAlignment)
2641 DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc);
Douglas Gregor352169a2009-07-31 03:54:25 +00002642 }
2643 }
Mike Stump11289f42009-09-09 15:08:12 +00002644
Douglas Gregor758a8692009-06-17 21:51:59 +00002645 Types.push_back(New);
2646 return QualType(New, 0);
2647}
2648
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002649/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002650///
Jay Foad39c79802011-01-12 09:06:06 +00002651QualType
2652ASTContext::getFunctionNoProtoType(QualType ResultTy,
2653 const FunctionType::ExtInfo &Info) const {
Roman Divacky65b88cd2011-03-01 17:40:53 +00002654 const CallingConv DefaultCC = Info.getCC();
2655 const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ?
2656 CC_X86StdCall : DefaultCC;
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002657 // Unique functions, to guarantee there is only one function of a particular
2658 // structure.
Chris Lattner23b7eb62007-06-15 23:05:46 +00002659 llvm::FoldingSetNodeID ID;
Rafael Espindolac50c27c2010-03-30 20:24:48 +00002660 FunctionNoProtoType::Profile(ID, ResultTy, Info);
Mike Stump11289f42009-09-09 15:08:12 +00002661
Chris Lattner47955de2007-01-27 08:37:20 +00002662 void *InsertPos = 0;
Mike Stump11289f42009-09-09 15:08:12 +00002663 if (FunctionNoProtoType *FT =
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002664 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002665 return QualType(FT, 0);
Mike Stump11289f42009-09-09 15:08:12 +00002666
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002667 QualType Canonical;
Douglas Gregor8c940862010-01-18 17:14:39 +00002668 if (!ResultTy.isCanonical() ||
John McCallab26cfa2010-02-05 21:31:56 +00002669 getCanonicalCallConv(CallConv) != CallConv) {
Rafael Espindolac50c27c2010-03-30 20:24:48 +00002670 Canonical =
2671 getFunctionNoProtoType(getCanonicalType(ResultTy),
2672 Info.withCallingConv(getCanonicalCallConv(CallConv)));
Mike Stump11289f42009-09-09 15:08:12 +00002673
Chris Lattner47955de2007-01-27 08:37:20 +00002674 // Get the new insert position for the node we care about.
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002675 FunctionNoProtoType *NewIP =
2676 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002677 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Chris Lattner47955de2007-01-27 08:37:20 +00002678 }
Mike Stump11289f42009-09-09 15:08:12 +00002679
Roman Divacky65b88cd2011-03-01 17:40:53 +00002680 FunctionProtoType::ExtInfo newInfo = Info.withCallingConv(CallConv);
John McCall90d1c2d2009-09-24 23:30:46 +00002681 FunctionNoProtoType *New = new (*this, TypeAlignment)
Roman Divacky65b88cd2011-03-01 17:40:53 +00002682 FunctionNoProtoType(ResultTy, Canonical, newInfo);
Chris Lattner47955de2007-01-27 08:37:20 +00002683 Types.push_back(New);
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002684 FunctionNoProtoTypes.InsertNode(New, InsertPos);
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002685 return QualType(New, 0);
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002686}
2687
Douglas Gregorcd780372013-01-17 23:36:45 +00002688/// \brief Determine whether \p T is canonical as the result type of a function.
2689static bool isCanonicalResultType(QualType T) {
2690 return T.isCanonical() &&
2691 (T.getObjCLifetime() == Qualifiers::OCL_None ||
2692 T.getObjCLifetime() == Qualifiers::OCL_ExplicitNone);
2693}
2694
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002695/// getFunctionType - Return a normal function type with a typed argument
2696/// list. isVariadic indicates whether the argument list includes '...'.
Jay Foad39c79802011-01-12 09:06:06 +00002697QualType
Jordan Rose5c382722013-03-08 21:51:21 +00002698ASTContext::getFunctionType(QualType ResultTy, ArrayRef<QualType> ArgArray,
Jay Foad39c79802011-01-12 09:06:06 +00002699 const FunctionProtoType::ExtProtoInfo &EPI) const {
Jordan Rose5c382722013-03-08 21:51:21 +00002700 size_t NumArgs = ArgArray.size();
2701
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002702 // Unique functions, to guarantee there is only one function of a particular
2703 // structure.
Chris Lattner23b7eb62007-06-15 23:05:46 +00002704 llvm::FoldingSetNodeID ID;
Jordan Rose5c382722013-03-08 21:51:21 +00002705 FunctionProtoType::Profile(ID, ResultTy, ArgArray.begin(), NumArgs, EPI,
2706 *this);
Chris Lattnerfd4de792007-01-27 01:15:32 +00002707
2708 void *InsertPos = 0;
Mike Stump11289f42009-09-09 15:08:12 +00002709 if (FunctionProtoType *FTP =
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002710 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002711 return QualType(FTP, 0);
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00002712
2713 // Determine whether the type being created is already canonical or not.
Richard Smith5e580292012-02-10 09:58:53 +00002714 bool isCanonical =
Douglas Gregorcd780372013-01-17 23:36:45 +00002715 EPI.ExceptionSpecType == EST_None && isCanonicalResultType(ResultTy) &&
Richard Smith5e580292012-02-10 09:58:53 +00002716 !EPI.HasTrailingReturn;
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002717 for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
John McCallfc93cf92009-10-22 22:37:11 +00002718 if (!ArgArray[i].isCanonicalAsParam())
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002719 isCanonical = false;
2720
Roman Divacky65b88cd2011-03-01 17:40:53 +00002721 const CallingConv DefaultCC = EPI.ExtInfo.getCC();
2722 const CallingConv CallConv = (LangOpts.MRTD && DefaultCC == CC_Default) ?
2723 CC_X86StdCall : DefaultCC;
John McCalldb40c7f2010-12-14 08:05:40 +00002724
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002725 // If this type isn't canonical, get the canonical version of it.
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00002726 // The exception spec is not part of the canonical type.
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002727 QualType Canonical;
John McCallab26cfa2010-02-05 21:31:56 +00002728 if (!isCanonical || getCanonicalCallConv(CallConv) != CallConv) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002729 SmallVector<QualType, 16> CanonicalArgs;
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002730 CanonicalArgs.reserve(NumArgs);
2731 for (unsigned i = 0; i != NumArgs; ++i)
John McCallfc93cf92009-10-22 22:37:11 +00002732 CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00002733
John McCalldb40c7f2010-12-14 08:05:40 +00002734 FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
Richard Smith5e580292012-02-10 09:58:53 +00002735 CanonicalEPI.HasTrailingReturn = false;
Sebastian Redl7c6c9e92011-03-06 10:52:04 +00002736 CanonicalEPI.ExceptionSpecType = EST_None;
2737 CanonicalEPI.NumExceptions = 0;
John McCalldb40c7f2010-12-14 08:05:40 +00002738 CanonicalEPI.ExtInfo
2739 = CanonicalEPI.ExtInfo.withCallingConv(getCanonicalCallConv(CallConv));
2740
Douglas Gregorcd780372013-01-17 23:36:45 +00002741 // Result types do not have ARC lifetime qualifiers.
2742 QualType CanResultTy = getCanonicalType(ResultTy);
2743 if (ResultTy.getQualifiers().hasObjCLifetime()) {
2744 Qualifiers Qs = CanResultTy.getQualifiers();
2745 Qs.removeObjCLifetime();
2746 CanResultTy = getQualifiedType(CanResultTy.getUnqualifiedType(), Qs);
2747 }
2748
Jordan Rose5c382722013-03-08 21:51:21 +00002749 Canonical = getFunctionType(CanResultTy, CanonicalArgs, CanonicalEPI);
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00002750
Chris Lattnerfd4de792007-01-27 01:15:32 +00002751 // Get the new insert position for the node we care about.
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002752 FunctionProtoType *NewIP =
2753 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
Jeffrey Yasskinb3321532010-12-23 01:01:28 +00002754 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002755 }
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00002756
John McCall31168b02011-06-15 23:02:42 +00002757 // FunctionProtoType objects are allocated with extra bytes after
2758 // them for three variable size arrays at the end:
2759 // - parameter types
2760 // - exception types
2761 // - consumed-arguments flags
2762 // Instead of the exception types, there could be a noexcept
Richard Smithd3b5c9082012-07-27 04:22:15 +00002763 // expression, or information used to resolve the exception
2764 // specification.
John McCalldb40c7f2010-12-14 08:05:40 +00002765 size_t Size = sizeof(FunctionProtoType) +
Sebastian Redlfa453cf2011-03-12 11:50:43 +00002766 NumArgs * sizeof(QualType);
Richard Smithd3b5c9082012-07-27 04:22:15 +00002767 if (EPI.ExceptionSpecType == EST_Dynamic) {
Sebastian Redlfa453cf2011-03-12 11:50:43 +00002768 Size += EPI.NumExceptions * sizeof(QualType);
Richard Smithd3b5c9082012-07-27 04:22:15 +00002769 } else if (EPI.ExceptionSpecType == EST_ComputedNoexcept) {
Sebastian Redl31ad7542011-03-13 17:09:40 +00002770 Size += sizeof(Expr*);
Richard Smithf623c962012-04-17 00:58:00 +00002771 } else if (EPI.ExceptionSpecType == EST_Uninstantiated) {
Richard Smithd3729422012-04-19 00:08:28 +00002772 Size += 2 * sizeof(FunctionDecl*);
Richard Smithd3b5c9082012-07-27 04:22:15 +00002773 } else if (EPI.ExceptionSpecType == EST_Unevaluated) {
2774 Size += sizeof(FunctionDecl*);
Sebastian Redlfa453cf2011-03-12 11:50:43 +00002775 }
John McCall31168b02011-06-15 23:02:42 +00002776 if (EPI.ConsumedArguments)
2777 Size += NumArgs * sizeof(bool);
2778
John McCalldb40c7f2010-12-14 08:05:40 +00002779 FunctionProtoType *FTP = (FunctionProtoType*) Allocate(Size, TypeAlignment);
Roman Divacky65b88cd2011-03-01 17:40:53 +00002780 FunctionProtoType::ExtProtoInfo newEPI = EPI;
2781 newEPI.ExtInfo = EPI.ExtInfo.withCallingConv(CallConv);
Jordan Rose5c382722013-03-08 21:51:21 +00002782 new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002783 Types.push_back(FTP);
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002784 FunctionProtoTypes.InsertNode(FTP, InsertPos);
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002785 return QualType(FTP, 0);
Chris Lattnerc6ad8132006-12-02 07:52:18 +00002786}
Chris Lattneref51c202006-11-10 07:17:23 +00002787
John McCalle78aac42010-03-10 03:28:59 +00002788#ifndef NDEBUG
2789static bool NeedsInjectedClassNameType(const RecordDecl *D) {
2790 if (!isa<CXXRecordDecl>(D)) return false;
2791 const CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
2792 if (isa<ClassTemplatePartialSpecializationDecl>(RD))
2793 return true;
2794 if (RD->getDescribedClassTemplate() &&
2795 !isa<ClassTemplateSpecializationDecl>(RD))
2796 return true;
2797 return false;
2798}
2799#endif
2800
2801/// getInjectedClassNameType - Return the unique reference to the
2802/// injected class name type for the specified templated declaration.
2803QualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl,
Jay Foad39c79802011-01-12 09:06:06 +00002804 QualType TST) const {
John McCalle78aac42010-03-10 03:28:59 +00002805 assert(NeedsInjectedClassNameType(Decl));
2806 if (Decl->TypeForDecl) {
2807 assert(isa<InjectedClassNameType>(Decl->TypeForDecl));
Douglas Gregorec9fd132012-01-14 16:38:05 +00002808 } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) {
John McCalle78aac42010-03-10 03:28:59 +00002809 assert(PrevDecl->TypeForDecl && "previous declaration has no type");
2810 Decl->TypeForDecl = PrevDecl->TypeForDecl;
2811 assert(isa<InjectedClassNameType>(Decl->TypeForDecl));
2812 } else {
John McCall424cec92011-01-19 06:33:43 +00002813 Type *newType =
John McCall2408e322010-04-27 00:57:59 +00002814 new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
John McCall424cec92011-01-19 06:33:43 +00002815 Decl->TypeForDecl = newType;
2816 Types.push_back(newType);
John McCalle78aac42010-03-10 03:28:59 +00002817 }
2818 return QualType(Decl->TypeForDecl, 0);
2819}
2820
Douglas Gregor83a586e2008-04-13 21:07:44 +00002821/// getTypeDeclType - Return the unique reference to the type for the
2822/// specified type declaration.
Jay Foad39c79802011-01-12 09:06:06 +00002823QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const {
Argyrios Kyrtzidis89656d22008-10-16 16:50:47 +00002824 assert(Decl && "Passed null for Decl param");
John McCall96f0b5f2010-03-10 06:48:02 +00002825 assert(!Decl->TypeForDecl && "TypeForDecl present in slow case");
Mike Stump11289f42009-09-09 15:08:12 +00002826
Richard Smithdda56e42011-04-15 14:24:37 +00002827 if (const TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Decl))
Douglas Gregor83a586e2008-04-13 21:07:44 +00002828 return getTypedefType(Typedef);
John McCall96f0b5f2010-03-10 06:48:02 +00002829
John McCall96f0b5f2010-03-10 06:48:02 +00002830 assert(!isa<TemplateTypeParmDecl>(Decl) &&
2831 "Template type parameter types are always available.");
2832
John McCall81e38502010-02-16 03:57:14 +00002833 if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) {
Douglas Gregorec9fd132012-01-14 16:38:05 +00002834 assert(!Record->getPreviousDecl() &&
John McCall96f0b5f2010-03-10 06:48:02 +00002835 "struct/union has previous declaration");
2836 assert(!NeedsInjectedClassNameType(Record));
Argyrios Kyrtzidisb5fcdc22010-07-04 21:44:47 +00002837 return getRecordType(Record);
John McCall81e38502010-02-16 03:57:14 +00002838 } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) {
Douglas Gregorec9fd132012-01-14 16:38:05 +00002839 assert(!Enum->getPreviousDecl() &&
John McCall96f0b5f2010-03-10 06:48:02 +00002840 "enum has previous declaration");
Argyrios Kyrtzidisb5fcdc22010-07-04 21:44:47 +00002841 return getEnumType(Enum);
John McCall81e38502010-02-16 03:57:14 +00002842 } else if (const UnresolvedUsingTypenameDecl *Using =
John McCallb96ec562009-12-04 22:46:56 +00002843 dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
John McCall424cec92011-01-19 06:33:43 +00002844 Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using);
2845 Decl->TypeForDecl = newType;
2846 Types.push_back(newType);
Mike Stumpe9c6ffc2009-07-31 02:02:20 +00002847 } else
John McCall96f0b5f2010-03-10 06:48:02 +00002848 llvm_unreachable("TypeDecl without a type?");
Argyrios Kyrtzidisfaf08762008-08-07 20:55:28 +00002849
Argyrios Kyrtzidisfaf08762008-08-07 20:55:28 +00002850 return QualType(Decl->TypeForDecl, 0);
Douglas Gregor83a586e2008-04-13 21:07:44 +00002851}
2852
Chris Lattner32d920b2007-01-26 02:01:53 +00002853/// getTypedefType - Return the unique reference to the type for the
Richard Smithdda56e42011-04-15 14:24:37 +00002854/// specified typedef name decl.
Argyrios Kyrtzidis45a83f92010-07-02 11:55:11 +00002855QualType
Richard Smithdda56e42011-04-15 14:24:37 +00002856ASTContext::getTypedefType(const TypedefNameDecl *Decl,
2857 QualType Canonical) const {
Steve Naroffe5aa9be2007-04-05 22:36:20 +00002858 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
Mike Stump11289f42009-09-09 15:08:12 +00002859
Argyrios Kyrtzidis45a83f92010-07-02 11:55:11 +00002860 if (Canonical.isNull())
2861 Canonical = getCanonicalType(Decl->getUnderlyingType());
John McCall424cec92011-01-19 06:33:43 +00002862 TypedefType *newType = new(*this, TypeAlignment)
John McCall90d1c2d2009-09-24 23:30:46 +00002863 TypedefType(Type::Typedef, Decl, Canonical);
John McCall424cec92011-01-19 06:33:43 +00002864 Decl->TypeForDecl = newType;
2865 Types.push_back(newType);
2866 return QualType(newType, 0);
Chris Lattnerd0342e52006-11-20 04:02:15 +00002867}
2868
Jay Foad39c79802011-01-12 09:06:06 +00002869QualType ASTContext::getRecordType(const RecordDecl *Decl) const {
Argyrios Kyrtzidisb5fcdc22010-07-04 21:44:47 +00002870 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
2871
Douglas Gregorec9fd132012-01-14 16:38:05 +00002872 if (const RecordDecl *PrevDecl = Decl->getPreviousDecl())
Argyrios Kyrtzidisb5fcdc22010-07-04 21:44:47 +00002873 if (PrevDecl->TypeForDecl)
2874 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
2875
John McCall424cec92011-01-19 06:33:43 +00002876 RecordType *newType = new (*this, TypeAlignment) RecordType(Decl);
2877 Decl->TypeForDecl = newType;
2878 Types.push_back(newType);
2879 return QualType(newType, 0);
Argyrios Kyrtzidisb5fcdc22010-07-04 21:44:47 +00002880}
2881
Jay Foad39c79802011-01-12 09:06:06 +00002882QualType ASTContext::getEnumType(const EnumDecl *Decl) const {
Argyrios Kyrtzidisb5fcdc22010-07-04 21:44:47 +00002883 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
2884
Douglas Gregorec9fd132012-01-14 16:38:05 +00002885 if (const EnumDecl *PrevDecl = Decl->getPreviousDecl())
Argyrios Kyrtzidisb5fcdc22010-07-04 21:44:47 +00002886 if (PrevDecl->TypeForDecl)
2887 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
2888
John McCall424cec92011-01-19 06:33:43 +00002889 EnumType *newType = new (*this, TypeAlignment) EnumType(Decl);
2890 Decl->TypeForDecl = newType;
2891 Types.push_back(newType);
2892 return QualType(newType, 0);
Argyrios Kyrtzidisb5fcdc22010-07-04 21:44:47 +00002893}
2894
John McCall81904512011-01-06 01:58:22 +00002895QualType ASTContext::getAttributedType(AttributedType::Kind attrKind,
2896 QualType modifiedType,
2897 QualType equivalentType) {
2898 llvm::FoldingSetNodeID id;
2899 AttributedType::Profile(id, attrKind, modifiedType, equivalentType);
2900
2901 void *insertPos = 0;
2902 AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos);
2903 if (type) return QualType(type, 0);
2904
2905 QualType canon = getCanonicalType(equivalentType);
2906 type = new (*this, TypeAlignment)
2907 AttributedType(canon, attrKind, modifiedType, equivalentType);
2908
2909 Types.push_back(type);
2910 AttributedTypes.InsertNode(type, insertPos);
2911
2912 return QualType(type, 0);
2913}
2914
2915
John McCallcebee162009-10-18 09:09:24 +00002916/// \brief Retrieve a substitution-result type.
2917QualType
2918ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
Jay Foad39c79802011-01-12 09:06:06 +00002919 QualType Replacement) const {
John McCallb692a092009-10-22 20:10:53 +00002920 assert(Replacement.isCanonical()
John McCallcebee162009-10-18 09:09:24 +00002921 && "replacement types must always be canonical");
2922
2923 llvm::FoldingSetNodeID ID;
2924 SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
2925 void *InsertPos = 0;
2926 SubstTemplateTypeParmType *SubstParm
2927 = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
2928
2929 if (!SubstParm) {
2930 SubstParm = new (*this, TypeAlignment)
2931 SubstTemplateTypeParmType(Parm, Replacement);
2932 Types.push_back(SubstParm);
2933 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
2934 }
2935
2936 return QualType(SubstParm, 0);
2937}
2938
Douglas Gregorada4b792011-01-14 02:55:32 +00002939/// \brief Retrieve a
2940QualType ASTContext::getSubstTemplateTypeParmPackType(
2941 const TemplateTypeParmType *Parm,
2942 const TemplateArgument &ArgPack) {
2943#ifndef NDEBUG
2944 for (TemplateArgument::pack_iterator P = ArgPack.pack_begin(),
2945 PEnd = ArgPack.pack_end();
2946 P != PEnd; ++P) {
2947 assert(P->getKind() == TemplateArgument::Type &&"Pack contains a non-type");
2948 assert(P->getAsType().isCanonical() && "Pack contains non-canonical type");
2949 }
2950#endif
2951
2952 llvm::FoldingSetNodeID ID;
2953 SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack);
2954 void *InsertPos = 0;
2955 if (SubstTemplateTypeParmPackType *SubstParm
2956 = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
2957 return QualType(SubstParm, 0);
2958
2959 QualType Canon;
2960 if (!Parm->isCanonicalUnqualified()) {
2961 Canon = getCanonicalType(QualType(Parm, 0));
2962 Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon),
2963 ArgPack);
2964 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
2965 }
2966
2967 SubstTemplateTypeParmPackType *SubstParm
2968 = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon,
2969 ArgPack);
2970 Types.push_back(SubstParm);
2971 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
2972 return QualType(SubstParm, 0);
2973}
2974
Douglas Gregoreff93e02009-02-05 23:33:38 +00002975/// \brief Retrieve the template type parameter type for a template
Mike Stump11289f42009-09-09 15:08:12 +00002976/// parameter or parameter pack with the given depth, index, and (optionally)
Anders Carlsson90036dc2009-06-16 00:30:48 +00002977/// name.
Mike Stump11289f42009-09-09 15:08:12 +00002978QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
Anders Carlsson90036dc2009-06-16 00:30:48 +00002979 bool ParameterPack,
Chandler Carruth08836322011-05-01 00:51:33 +00002980 TemplateTypeParmDecl *TTPDecl) const {
Douglas Gregoreff93e02009-02-05 23:33:38 +00002981 llvm::FoldingSetNodeID ID;
Chandler Carruth08836322011-05-01 00:51:33 +00002982 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
Douglas Gregoreff93e02009-02-05 23:33:38 +00002983 void *InsertPos = 0;
Mike Stump11289f42009-09-09 15:08:12 +00002984 TemplateTypeParmType *TypeParm
Douglas Gregoreff93e02009-02-05 23:33:38 +00002985 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
2986
2987 if (TypeParm)
2988 return QualType(TypeParm, 0);
Mike Stump11289f42009-09-09 15:08:12 +00002989
Chandler Carruth08836322011-05-01 00:51:33 +00002990 if (TTPDecl) {
Anders Carlsson90036dc2009-06-16 00:30:48 +00002991 QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
Chandler Carruth08836322011-05-01 00:51:33 +00002992 TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon);
Douglas Gregorc42075a2010-02-04 18:10:26 +00002993
2994 TemplateTypeParmType *TypeCheck
2995 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
2996 assert(!TypeCheck && "Template type parameter canonical type broken");
2997 (void)TypeCheck;
Anders Carlsson90036dc2009-06-16 00:30:48 +00002998 } else
John McCall90d1c2d2009-09-24 23:30:46 +00002999 TypeParm = new (*this, TypeAlignment)
3000 TemplateTypeParmType(Depth, Index, ParameterPack);
Douglas Gregoreff93e02009-02-05 23:33:38 +00003001
3002 Types.push_back(TypeParm);
3003 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
3004
3005 return QualType(TypeParm, 0);
3006}
3007
John McCalle78aac42010-03-10 03:28:59 +00003008TypeSourceInfo *
3009ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name,
3010 SourceLocation NameLoc,
3011 const TemplateArgumentListInfo &Args,
Richard Smith3f1b5d02011-05-05 21:57:07 +00003012 QualType Underlying) const {
Douglas Gregore16af532011-02-28 18:50:33 +00003013 assert(!Name.getAsDependentTemplateName() &&
3014 "No dependent template names here!");
Richard Smith3f1b5d02011-05-05 21:57:07 +00003015 QualType TST = getTemplateSpecializationType(Name, Args, Underlying);
John McCalle78aac42010-03-10 03:28:59 +00003016
3017 TypeSourceInfo *DI = CreateTypeSourceInfo(TST);
David Blaikie6adc78e2013-02-18 22:06:02 +00003018 TemplateSpecializationTypeLoc TL =
3019 DI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>();
Abramo Bagnara48c05be2012-02-06 14:41:24 +00003020 TL.setTemplateKeywordLoc(SourceLocation());
John McCalle78aac42010-03-10 03:28:59 +00003021 TL.setTemplateNameLoc(NameLoc);
3022 TL.setLAngleLoc(Args.getLAngleLoc());
3023 TL.setRAngleLoc(Args.getRAngleLoc());
3024 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3025 TL.setArgLocInfo(i, Args[i].getLocInfo());
3026 return DI;
3027}
3028
Mike Stump11289f42009-09-09 15:08:12 +00003029QualType
Douglas Gregordc572a32009-03-30 22:58:21 +00003030ASTContext::getTemplateSpecializationType(TemplateName Template,
John McCall6b51f282009-11-23 01:53:49 +00003031 const TemplateArgumentListInfo &Args,
Richard Smith3f1b5d02011-05-05 21:57:07 +00003032 QualType Underlying) const {
Douglas Gregore16af532011-02-28 18:50:33 +00003033 assert(!Template.getAsDependentTemplateName() &&
3034 "No dependent template names here!");
3035
John McCall6b51f282009-11-23 01:53:49 +00003036 unsigned NumArgs = Args.size();
3037
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003038 SmallVector<TemplateArgument, 4> ArgVec;
John McCall0ad16662009-10-29 08:12:44 +00003039 ArgVec.reserve(NumArgs);
3040 for (unsigned i = 0; i != NumArgs; ++i)
3041 ArgVec.push_back(Args[i].getArgument());
3042
John McCall2408e322010-04-27 00:57:59 +00003043 return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs,
Richard Smith3f1b5d02011-05-05 21:57:07 +00003044 Underlying);
John McCall0ad16662009-10-29 08:12:44 +00003045}
3046
Douglas Gregor1f79ca82012-02-03 17:16:23 +00003047#ifndef NDEBUG
3048static bool hasAnyPackExpansions(const TemplateArgument *Args,
3049 unsigned NumArgs) {
3050 for (unsigned I = 0; I != NumArgs; ++I)
3051 if (Args[I].isPackExpansion())
3052 return true;
3053
3054 return true;
3055}
3056#endif
3057
John McCall0ad16662009-10-29 08:12:44 +00003058QualType
3059ASTContext::getTemplateSpecializationType(TemplateName Template,
Douglas Gregordc572a32009-03-30 22:58:21 +00003060 const TemplateArgument *Args,
3061 unsigned NumArgs,
Richard Smith3f1b5d02011-05-05 21:57:07 +00003062 QualType Underlying) const {
Douglas Gregore16af532011-02-28 18:50:33 +00003063 assert(!Template.getAsDependentTemplateName() &&
3064 "No dependent template names here!");
Douglas Gregore29139c2011-03-03 17:04:51 +00003065 // Look through qualified template names.
3066 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
3067 Template = TemplateName(QTN->getTemplateDecl());
Douglas Gregore16af532011-02-28 18:50:33 +00003068
Douglas Gregor1f79ca82012-02-03 17:16:23 +00003069 bool IsTypeAlias =
Richard Smith3f1b5d02011-05-05 21:57:07 +00003070 Template.getAsTemplateDecl() &&
3071 isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
Richard Smith3f1b5d02011-05-05 21:57:07 +00003072 QualType CanonType;
3073 if (!Underlying.isNull())
3074 CanonType = getCanonicalType(Underlying);
3075 else {
Douglas Gregor1f79ca82012-02-03 17:16:23 +00003076 // We can get here with an alias template when the specialization contains
3077 // a pack expansion that does not match up with a parameter pack.
3078 assert((!IsTypeAlias || hasAnyPackExpansions(Args, NumArgs)) &&
3079 "Caller must compute aliased type");
3080 IsTypeAlias = false;
Richard Smith3f1b5d02011-05-05 21:57:07 +00003081 CanonType = getCanonicalTemplateSpecializationType(Template, Args,
3082 NumArgs);
3083 }
Douglas Gregord56a91e2009-02-26 22:19:44 +00003084
Douglas Gregora8e02e72009-07-28 23:00:59 +00003085 // Allocate the (non-canonical) template specialization type, but don't
3086 // try to unique it: these types typically have location information that
3087 // we don't unique and don't want to lose.
Richard Smith3f1b5d02011-05-05 21:57:07 +00003088 void *Mem = Allocate(sizeof(TemplateSpecializationType) +
3089 sizeof(TemplateArgument) * NumArgs +
Douglas Gregor1f79ca82012-02-03 17:16:23 +00003090 (IsTypeAlias? sizeof(QualType) : 0),
John McCall90d1c2d2009-09-24 23:30:46 +00003091 TypeAlignment);
Mike Stump11289f42009-09-09 15:08:12 +00003092 TemplateSpecializationType *Spec
Douglas Gregor1f79ca82012-02-03 17:16:23 +00003093 = new (Mem) TemplateSpecializationType(Template, Args, NumArgs, CanonType,
3094 IsTypeAlias ? Underlying : QualType());
Mike Stump11289f42009-09-09 15:08:12 +00003095
Douglas Gregor8bf42052009-02-09 18:46:07 +00003096 Types.push_back(Spec);
Mike Stump11289f42009-09-09 15:08:12 +00003097 return QualType(Spec, 0);
Douglas Gregor8bf42052009-02-09 18:46:07 +00003098}
3099
Mike Stump11289f42009-09-09 15:08:12 +00003100QualType
Argyrios Kyrtzidis45a83f92010-07-02 11:55:11 +00003101ASTContext::getCanonicalTemplateSpecializationType(TemplateName Template,
3102 const TemplateArgument *Args,
Jay Foad39c79802011-01-12 09:06:06 +00003103 unsigned NumArgs) const {
Douglas Gregore16af532011-02-28 18:50:33 +00003104 assert(!Template.getAsDependentTemplateName() &&
3105 "No dependent template names here!");
Richard Smith3f1b5d02011-05-05 21:57:07 +00003106
Douglas Gregore29139c2011-03-03 17:04:51 +00003107 // Look through qualified template names.
3108 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
3109 Template = TemplateName(QTN->getTemplateDecl());
Douglas Gregore16af532011-02-28 18:50:33 +00003110
Argyrios Kyrtzidis45a83f92010-07-02 11:55:11 +00003111 // Build the canonical template specialization type.
3112 TemplateName CanonTemplate = getCanonicalTemplateName(Template);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003113 SmallVector<TemplateArgument, 4> CanonArgs;
Argyrios Kyrtzidis45a83f92010-07-02 11:55:11 +00003114 CanonArgs.reserve(NumArgs);
3115 for (unsigned I = 0; I != NumArgs; ++I)
3116 CanonArgs.push_back(getCanonicalTemplateArgument(Args[I]));
3117
3118 // Determine whether this canonical template specialization type already
3119 // exists.
3120 llvm::FoldingSetNodeID ID;
3121 TemplateSpecializationType::Profile(ID, CanonTemplate,
3122 CanonArgs.data(), NumArgs, *this);
3123
3124 void *InsertPos = 0;
3125 TemplateSpecializationType *Spec
3126 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
3127
3128 if (!Spec) {
3129 // Allocate a new canonical template specialization type.
3130 void *Mem = Allocate((sizeof(TemplateSpecializationType) +
3131 sizeof(TemplateArgument) * NumArgs),
3132 TypeAlignment);
3133 Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
3134 CanonArgs.data(), NumArgs,
Richard Smith3f1b5d02011-05-05 21:57:07 +00003135 QualType(), QualType());
Argyrios Kyrtzidis45a83f92010-07-02 11:55:11 +00003136 Types.push_back(Spec);
3137 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
3138 }
3139
3140 assert(Spec->isDependentType() &&
3141 "Non-dependent template-id type must have a canonical type");
3142 return QualType(Spec, 0);
3143}
3144
3145QualType
Abramo Bagnara6150c882010-05-11 21:36:43 +00003146ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
3147 NestedNameSpecifier *NNS,
Jay Foad39c79802011-01-12 09:06:06 +00003148 QualType NamedType) const {
Douglas Gregor52537682009-03-19 00:18:19 +00003149 llvm::FoldingSetNodeID ID;
Abramo Bagnara6150c882010-05-11 21:36:43 +00003150 ElaboratedType::Profile(ID, Keyword, NNS, NamedType);
Douglas Gregor52537682009-03-19 00:18:19 +00003151
3152 void *InsertPos = 0;
Abramo Bagnara6150c882010-05-11 21:36:43 +00003153 ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
Douglas Gregor52537682009-03-19 00:18:19 +00003154 if (T)
3155 return QualType(T, 0);
3156
Douglas Gregorc42075a2010-02-04 18:10:26 +00003157 QualType Canon = NamedType;
3158 if (!Canon.isCanonical()) {
3159 Canon = getCanonicalType(NamedType);
Abramo Bagnara6150c882010-05-11 21:36:43 +00003160 ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
3161 assert(!CheckT && "Elaborated canonical type broken");
Douglas Gregorc42075a2010-02-04 18:10:26 +00003162 (void)CheckT;
3163 }
3164
Abramo Bagnara6150c882010-05-11 21:36:43 +00003165 T = new (*this) ElaboratedType(Keyword, NNS, NamedType, Canon);
Douglas Gregor52537682009-03-19 00:18:19 +00003166 Types.push_back(T);
Abramo Bagnara6150c882010-05-11 21:36:43 +00003167 ElaboratedTypes.InsertNode(T, InsertPos);
Douglas Gregor52537682009-03-19 00:18:19 +00003168 return QualType(T, 0);
3169}
3170
Abramo Bagnara924a8f32010-12-10 16:29:40 +00003171QualType
Jay Foad39c79802011-01-12 09:06:06 +00003172ASTContext::getParenType(QualType InnerType) const {
Abramo Bagnara924a8f32010-12-10 16:29:40 +00003173 llvm::FoldingSetNodeID ID;
3174 ParenType::Profile(ID, InnerType);
3175
3176 void *InsertPos = 0;
3177 ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
3178 if (T)
3179 return QualType(T, 0);
3180
3181 QualType Canon = InnerType;
3182 if (!Canon.isCanonical()) {
3183 Canon = getCanonicalType(InnerType);
3184 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
3185 assert(!CheckT && "Paren canonical type broken");
3186 (void)CheckT;
3187 }
3188
3189 T = new (*this) ParenType(InnerType, Canon);
3190 Types.push_back(T);
3191 ParenTypes.InsertNode(T, InsertPos);
3192 return QualType(T, 0);
3193}
3194
Douglas Gregor02085352010-03-31 20:19:30 +00003195QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
3196 NestedNameSpecifier *NNS,
3197 const IdentifierInfo *Name,
Jay Foad39c79802011-01-12 09:06:06 +00003198 QualType Canon) const {
Douglas Gregor333489b2009-03-27 23:10:48 +00003199 assert(NNS->isDependent() && "nested-name-specifier must be dependent");
3200
3201 if (Canon.isNull()) {
3202 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
Douglas Gregor02085352010-03-31 20:19:30 +00003203 ElaboratedTypeKeyword CanonKeyword = Keyword;
3204 if (Keyword == ETK_None)
3205 CanonKeyword = ETK_Typename;
3206
3207 if (CanonNNS != NNS || CanonKeyword != Keyword)
3208 Canon = getDependentNameType(CanonKeyword, CanonNNS, Name);
Douglas Gregor333489b2009-03-27 23:10:48 +00003209 }
3210
3211 llvm::FoldingSetNodeID ID;
Douglas Gregor02085352010-03-31 20:19:30 +00003212 DependentNameType::Profile(ID, Keyword, NNS, Name);
Douglas Gregor333489b2009-03-27 23:10:48 +00003213
3214 void *InsertPos = 0;
Douglas Gregorc1d2d8a2010-03-31 17:34:00 +00003215 DependentNameType *T
3216 = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
Douglas Gregor333489b2009-03-27 23:10:48 +00003217 if (T)
3218 return QualType(T, 0);
3219
Douglas Gregor02085352010-03-31 20:19:30 +00003220 T = new (*this) DependentNameType(Keyword, NNS, Name, Canon);
Douglas Gregor333489b2009-03-27 23:10:48 +00003221 Types.push_back(T);
Douglas Gregorc1d2d8a2010-03-31 17:34:00 +00003222 DependentNameTypes.InsertNode(T, InsertPos);
Mike Stump11289f42009-09-09 15:08:12 +00003223 return QualType(T, 0);
Douglas Gregor333489b2009-03-27 23:10:48 +00003224}
3225
Mike Stump11289f42009-09-09 15:08:12 +00003226QualType
John McCallc392f372010-06-11 00:33:02 +00003227ASTContext::getDependentTemplateSpecializationType(
3228 ElaboratedTypeKeyword Keyword,
Douglas Gregor02085352010-03-31 20:19:30 +00003229 NestedNameSpecifier *NNS,
John McCallc392f372010-06-11 00:33:02 +00003230 const IdentifierInfo *Name,
Jay Foad39c79802011-01-12 09:06:06 +00003231 const TemplateArgumentListInfo &Args) const {
John McCallc392f372010-06-11 00:33:02 +00003232 // TODO: avoid this copy
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003233 SmallVector<TemplateArgument, 16> ArgCopy;
John McCallc392f372010-06-11 00:33:02 +00003234 for (unsigned I = 0, E = Args.size(); I != E; ++I)
3235 ArgCopy.push_back(Args[I].getArgument());
3236 return getDependentTemplateSpecializationType(Keyword, NNS, Name,
3237 ArgCopy.size(),
3238 ArgCopy.data());
3239}
3240
3241QualType
3242ASTContext::getDependentTemplateSpecializationType(
3243 ElaboratedTypeKeyword Keyword,
3244 NestedNameSpecifier *NNS,
3245 const IdentifierInfo *Name,
3246 unsigned NumArgs,
Jay Foad39c79802011-01-12 09:06:06 +00003247 const TemplateArgument *Args) const {
Douglas Gregor6e068012011-02-28 00:04:36 +00003248 assert((!NNS || NNS->isDependent()) &&
3249 "nested-name-specifier must be dependent");
Douglas Gregordce2b622009-04-01 00:28:59 +00003250
Douglas Gregorc42075a2010-02-04 18:10:26 +00003251 llvm::FoldingSetNodeID ID;
John McCallc392f372010-06-11 00:33:02 +00003252 DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
3253 Name, NumArgs, Args);
Douglas Gregorc42075a2010-02-04 18:10:26 +00003254
3255 void *InsertPos = 0;
John McCallc392f372010-06-11 00:33:02 +00003256 DependentTemplateSpecializationType *T
3257 = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
Douglas Gregorc42075a2010-02-04 18:10:26 +00003258 if (T)
3259 return QualType(T, 0);
3260
John McCallc392f372010-06-11 00:33:02 +00003261 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
Douglas Gregorc42075a2010-02-04 18:10:26 +00003262
John McCallc392f372010-06-11 00:33:02 +00003263 ElaboratedTypeKeyword CanonKeyword = Keyword;
3264 if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
3265
3266 bool AnyNonCanonArgs = false;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003267 SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
John McCallc392f372010-06-11 00:33:02 +00003268 for (unsigned I = 0; I != NumArgs; ++I) {
3269 CanonArgs[I] = getCanonicalTemplateArgument(Args[I]);
3270 if (!CanonArgs[I].structurallyEquals(Args[I]))
3271 AnyNonCanonArgs = true;
Douglas Gregordce2b622009-04-01 00:28:59 +00003272 }
3273
John McCallc392f372010-06-11 00:33:02 +00003274 QualType Canon;
3275 if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
3276 Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
3277 Name, NumArgs,
3278 CanonArgs.data());
3279
3280 // Find the insert position again.
3281 DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
3282 }
3283
3284 void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
3285 sizeof(TemplateArgument) * NumArgs),
3286 TypeAlignment);
John McCall773cc982010-06-11 11:07:21 +00003287 T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
John McCallc392f372010-06-11 00:33:02 +00003288 Name, NumArgs, Args, Canon);
Douglas Gregordce2b622009-04-01 00:28:59 +00003289 Types.push_back(T);
John McCallc392f372010-06-11 00:33:02 +00003290 DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
Mike Stump11289f42009-09-09 15:08:12 +00003291 return QualType(T, 0);
Douglas Gregordce2b622009-04-01 00:28:59 +00003292}
3293
Douglas Gregor0dca5fd2011-01-14 17:04:44 +00003294QualType ASTContext::getPackExpansionType(QualType Pattern,
David Blaikie05785d12013-02-20 22:23:23 +00003295 Optional<unsigned> NumExpansions) {
Douglas Gregord2fa7662010-12-20 02:24:11 +00003296 llvm::FoldingSetNodeID ID;
Douglas Gregor0dca5fd2011-01-14 17:04:44 +00003297 PackExpansionType::Profile(ID, Pattern, NumExpansions);
Douglas Gregord2fa7662010-12-20 02:24:11 +00003298
3299 assert(Pattern->containsUnexpandedParameterPack() &&
3300 "Pack expansions must expand one or more parameter packs");
3301 void *InsertPos = 0;
3302 PackExpansionType *T
3303 = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
3304 if (T)
3305 return QualType(T, 0);
3306
3307 QualType Canon;
3308 if (!Pattern.isCanonical()) {
Richard Smith68eea502012-07-16 00:20:35 +00003309 Canon = getCanonicalType(Pattern);
3310 // The canonical type might not contain an unexpanded parameter pack, if it
3311 // contains an alias template specialization which ignores one of its
3312 // parameters.
3313 if (Canon->containsUnexpandedParameterPack()) {
3314 Canon = getPackExpansionType(getCanonicalType(Pattern), NumExpansions);
Douglas Gregord2fa7662010-12-20 02:24:11 +00003315
Richard Smith68eea502012-07-16 00:20:35 +00003316 // Find the insert position again, in case we inserted an element into
3317 // PackExpansionTypes and invalidated our insert position.
3318 PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
3319 }
Douglas Gregord2fa7662010-12-20 02:24:11 +00003320 }
3321
Douglas Gregor0dca5fd2011-01-14 17:04:44 +00003322 T = new (*this) PackExpansionType(Pattern, Canon, NumExpansions);
Douglas Gregord2fa7662010-12-20 02:24:11 +00003323 Types.push_back(T);
3324 PackExpansionTypes.InsertNode(T, InsertPos);
3325 return QualType(T, 0);
3326}
3327
Chris Lattnere0ea37a2008-04-07 04:56:42 +00003328/// CmpProtocolNames - Comparison predicate for sorting protocols
3329/// alphabetically.
3330static bool CmpProtocolNames(const ObjCProtocolDecl *LHS,
3331 const ObjCProtocolDecl *RHS) {
Douglas Gregor77324f32008-11-17 14:58:09 +00003332 return LHS->getDeclName() < RHS->getDeclName();
Chris Lattnere0ea37a2008-04-07 04:56:42 +00003333}
3334
John McCall8b07ec22010-05-15 11:32:37 +00003335static bool areSortedAndUniqued(ObjCProtocolDecl * const *Protocols,
John McCallfc93cf92009-10-22 22:37:11 +00003336 unsigned NumProtocols) {
3337 if (NumProtocols == 0) return true;
3338
Douglas Gregorcf9f3ea2012-01-02 02:00:30 +00003339 if (Protocols[0]->getCanonicalDecl() != Protocols[0])
3340 return false;
3341
John McCallfc93cf92009-10-22 22:37:11 +00003342 for (unsigned i = 1; i != NumProtocols; ++i)
Douglas Gregorcf9f3ea2012-01-02 02:00:30 +00003343 if (!CmpProtocolNames(Protocols[i-1], Protocols[i]) ||
3344 Protocols[i]->getCanonicalDecl() != Protocols[i])
John McCallfc93cf92009-10-22 22:37:11 +00003345 return false;
3346 return true;
3347}
3348
3349static void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols,
Chris Lattnere0ea37a2008-04-07 04:56:42 +00003350 unsigned &NumProtocols) {
3351 ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols;
Mike Stump11289f42009-09-09 15:08:12 +00003352
Chris Lattnere0ea37a2008-04-07 04:56:42 +00003353 // Sort protocols, keyed by name.
3354 std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames);
3355
Douglas Gregorcf9f3ea2012-01-02 02:00:30 +00003356 // Canonicalize.
3357 for (unsigned I = 0, N = NumProtocols; I != N; ++I)
3358 Protocols[I] = Protocols[I]->getCanonicalDecl();
3359
Chris Lattnere0ea37a2008-04-07 04:56:42 +00003360 // Remove duplicates.
3361 ProtocolsEnd = std::unique(Protocols, ProtocolsEnd);
3362 NumProtocols = ProtocolsEnd-Protocols;
3363}
3364
John McCall8b07ec22010-05-15 11:32:37 +00003365QualType ASTContext::getObjCObjectType(QualType BaseType,
3366 ObjCProtocolDecl * const *Protocols,
Jay Foad39c79802011-01-12 09:06:06 +00003367 unsigned NumProtocols) const {
John McCall8b07ec22010-05-15 11:32:37 +00003368 // If the base type is an interface and there aren't any protocols
3369 // to add, then the interface type will do just fine.
3370 if (!NumProtocols && isa<ObjCInterfaceType>(BaseType))
3371 return BaseType;
3372
3373 // Look in the folding set for an existing type.
Steve Narofffb4330f2009-06-17 22:40:22 +00003374 llvm::FoldingSetNodeID ID;
John McCall8b07ec22010-05-15 11:32:37 +00003375 ObjCObjectTypeImpl::Profile(ID, BaseType, Protocols, NumProtocols);
Steve Narofffb4330f2009-06-17 22:40:22 +00003376 void *InsertPos = 0;
John McCall8b07ec22010-05-15 11:32:37 +00003377 if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
3378 return QualType(QT, 0);
Steve Narofffb4330f2009-06-17 22:40:22 +00003379
John McCall8b07ec22010-05-15 11:32:37 +00003380 // Build the canonical type, which has the canonical base type and
3381 // a sorted-and-uniqued list of protocols.
John McCallfc93cf92009-10-22 22:37:11 +00003382 QualType Canonical;
John McCall8b07ec22010-05-15 11:32:37 +00003383 bool ProtocolsSorted = areSortedAndUniqued(Protocols, NumProtocols);
3384 if (!ProtocolsSorted || !BaseType.isCanonical()) {
3385 if (!ProtocolsSorted) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003386 SmallVector<ObjCProtocolDecl*, 8> Sorted(Protocols,
Benjamin Kramer2e3197e2010-04-27 17:12:11 +00003387 Protocols + NumProtocols);
John McCallfc93cf92009-10-22 22:37:11 +00003388 unsigned UniqueCount = NumProtocols;
3389
John McCallfc93cf92009-10-22 22:37:11 +00003390 SortAndUniqueProtocols(&Sorted[0], UniqueCount);
John McCall8b07ec22010-05-15 11:32:37 +00003391 Canonical = getObjCObjectType(getCanonicalType(BaseType),
3392 &Sorted[0], UniqueCount);
John McCallfc93cf92009-10-22 22:37:11 +00003393 } else {
John McCall8b07ec22010-05-15 11:32:37 +00003394 Canonical = getObjCObjectType(getCanonicalType(BaseType),
3395 Protocols, NumProtocols);
John McCallfc93cf92009-10-22 22:37:11 +00003396 }
3397
3398 // Regenerate InsertPos.
John McCall8b07ec22010-05-15 11:32:37 +00003399 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
3400 }
3401
3402 unsigned Size = sizeof(ObjCObjectTypeImpl);
3403 Size += NumProtocols * sizeof(ObjCProtocolDecl *);
3404 void *Mem = Allocate(Size, TypeAlignment);
3405 ObjCObjectTypeImpl *T =
3406 new (Mem) ObjCObjectTypeImpl(Canonical, BaseType, Protocols, NumProtocols);
3407
3408 Types.push_back(T);
3409 ObjCObjectTypes.InsertNode(T, InsertPos);
3410 return QualType(T, 0);
3411}
3412
3413/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
3414/// the given object type.
Jay Foad39c79802011-01-12 09:06:06 +00003415QualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const {
John McCall8b07ec22010-05-15 11:32:37 +00003416 llvm::FoldingSetNodeID ID;
3417 ObjCObjectPointerType::Profile(ID, ObjectT);
3418
3419 void *InsertPos = 0;
3420 if (ObjCObjectPointerType *QT =
3421 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
3422 return QualType(QT, 0);
3423
3424 // Find the canonical object type.
3425 QualType Canonical;
3426 if (!ObjectT.isCanonical()) {
3427 Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));
3428
3429 // Regenerate InsertPos.
John McCallfc93cf92009-10-22 22:37:11 +00003430 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
3431 }
3432
Douglas Gregorf85bee62010-02-08 22:59:26 +00003433 // No match.
John McCall8b07ec22010-05-15 11:32:37 +00003434 void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
3435 ObjCObjectPointerType *QType =
3436 new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
Mike Stump11289f42009-09-09 15:08:12 +00003437
Steve Narofffb4330f2009-06-17 22:40:22 +00003438 Types.push_back(QType);
3439 ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
John McCall8b07ec22010-05-15 11:32:37 +00003440 return QualType(QType, 0);
Steve Narofffb4330f2009-06-17 22:40:22 +00003441}
Chris Lattnere0ea37a2008-04-07 04:56:42 +00003442
Douglas Gregor1c283312010-08-11 12:19:30 +00003443/// getObjCInterfaceType - Return the unique reference to the type for the
3444/// specified ObjC interface decl. The list of protocols is optional.
Douglas Gregorab1ec82e2011-12-16 03:12:41 +00003445QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
3446 ObjCInterfaceDecl *PrevDecl) const {
Douglas Gregor1c283312010-08-11 12:19:30 +00003447 if (Decl->TypeForDecl)
3448 return QualType(Decl->TypeForDecl, 0);
Mike Stump11289f42009-09-09 15:08:12 +00003449
Douglas Gregorab1ec82e2011-12-16 03:12:41 +00003450 if (PrevDecl) {
3451 assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl");
3452 Decl->TypeForDecl = PrevDecl->TypeForDecl;
3453 return QualType(PrevDecl->TypeForDecl, 0);
3454 }
3455
Douglas Gregor7671e532011-12-16 16:34:57 +00003456 // Prefer the definition, if there is one.
3457 if (const ObjCInterfaceDecl *Def = Decl->getDefinition())
3458 Decl = Def;
3459
Douglas Gregor1c283312010-08-11 12:19:30 +00003460 void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
3461 ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl);
3462 Decl->TypeForDecl = T;
3463 Types.push_back(T);
3464 return QualType(T, 0);
Fariborz Jahanian70e8f102007-10-11 00:55:41 +00003465}
3466
Douglas Gregordeaad8c2009-02-26 23:50:07 +00003467/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
3468/// TypeOfExprType AST's (since expression's are never shared). For example,
Steve Naroffa773cd52007-08-01 18:02:17 +00003469/// multiple declarations that refer to "typeof(x)" all contain different
Mike Stump11289f42009-09-09 15:08:12 +00003470/// DeclRefExpr's. This doesn't effect the type checker, since it operates
Steve Naroffa773cd52007-08-01 18:02:17 +00003471/// on canonical type's (which are always unique).
Jay Foad39c79802011-01-12 09:06:06 +00003472QualType ASTContext::getTypeOfExprType(Expr *tofExpr) const {
Douglas Gregorabd68132009-07-08 00:03:05 +00003473 TypeOfExprType *toe;
Douglas Gregora5dd9f82009-07-30 23:18:24 +00003474 if (tofExpr->isTypeDependent()) {
3475 llvm::FoldingSetNodeID ID;
3476 DependentTypeOfExprType::Profile(ID, *this, tofExpr);
Mike Stump11289f42009-09-09 15:08:12 +00003477
Douglas Gregora5dd9f82009-07-30 23:18:24 +00003478 void *InsertPos = 0;
3479 DependentTypeOfExprType *Canon
3480 = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
3481 if (Canon) {
3482 // We already have a "canonical" version of an identical, dependent
3483 // typeof(expr) type. Use that as our canonical type.
John McCall90d1c2d2009-09-24 23:30:46 +00003484 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
Douglas Gregora5dd9f82009-07-30 23:18:24 +00003485 QualType((TypeOfExprType*)Canon, 0));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003486 } else {
Douglas Gregora5dd9f82009-07-30 23:18:24 +00003487 // Build a new, canonical typeof(expr) type.
John McCall90d1c2d2009-09-24 23:30:46 +00003488 Canon
3489 = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
Douglas Gregora5dd9f82009-07-30 23:18:24 +00003490 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
3491 toe = Canon;
3492 }
3493 } else {
Douglas Gregorabd68132009-07-08 00:03:05 +00003494 QualType Canonical = getCanonicalType(tofExpr->getType());
John McCall90d1c2d2009-09-24 23:30:46 +00003495 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
Douglas Gregorabd68132009-07-08 00:03:05 +00003496 }
Steve Naroffa773cd52007-08-01 18:02:17 +00003497 Types.push_back(toe);
3498 return QualType(toe, 0);
Steve Naroffad373bd2007-07-31 12:34:36 +00003499}
3500
Steve Naroffa773cd52007-08-01 18:02:17 +00003501/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique
3502/// TypeOfType AST's. The only motivation to unique these nodes would be
3503/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
Mike Stump11289f42009-09-09 15:08:12 +00003504/// an issue. This doesn't effect the type checker, since it operates
Steve Naroffa773cd52007-08-01 18:02:17 +00003505/// on canonical type's (which are always unique).
Jay Foad39c79802011-01-12 09:06:06 +00003506QualType ASTContext::getTypeOfType(QualType tofType) const {
Chris Lattner76a00cf2008-04-06 22:59:24 +00003507 QualType Canonical = getCanonicalType(tofType);
John McCall90d1c2d2009-09-24 23:30:46 +00003508 TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
Steve Naroffa773cd52007-08-01 18:02:17 +00003509 Types.push_back(tot);
3510 return QualType(tot, 0);
Steve Naroffad373bd2007-07-31 12:34:36 +00003511}
3512
Anders Carlssonad6bd352009-06-24 21:24:56 +00003513
Anders Carlsson81df7b82009-06-24 19:06:50 +00003514/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique
3515/// DecltypeType AST's. The only motivation to unique these nodes would be
3516/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be
Mike Stump11289f42009-09-09 15:08:12 +00003517/// an issue. This doesn't effect the type checker, since it operates
David Blaikie876657b2011-11-06 22:28:03 +00003518/// on canonical types (which are always unique).
Douglas Gregor81495f32012-02-12 18:42:33 +00003519QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const {
Douglas Gregorabd68132009-07-08 00:03:05 +00003520 DecltypeType *dt;
Douglas Gregor678d76c2011-07-01 01:22:09 +00003521
3522 // C++0x [temp.type]p2:
3523 // If an expression e involves a template parameter, decltype(e) denotes a
3524 // unique dependent type. Two such decltype-specifiers refer to the same
3525 // type only if their expressions are equivalent (14.5.6.1).
3526 if (e->isInstantiationDependent()) {
Douglas Gregora21f6c32009-07-30 23:36:40 +00003527 llvm::FoldingSetNodeID ID;
3528 DependentDecltypeType::Profile(ID, *this, e);
Mike Stump11289f42009-09-09 15:08:12 +00003529
Douglas Gregora21f6c32009-07-30 23:36:40 +00003530 void *InsertPos = 0;
3531 DependentDecltypeType *Canon
3532 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
3533 if (Canon) {
3534 // We already have a "canonical" version of an equivalent, dependent
3535 // decltype type. Use that as our canonical type.
Richard Smithef8bf432012-08-13 20:08:14 +00003536 dt = new (*this, TypeAlignment) DecltypeType(e, UnderlyingType,
Douglas Gregora21f6c32009-07-30 23:36:40 +00003537 QualType((DecltypeType*)Canon, 0));
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003538 } else {
Douglas Gregora21f6c32009-07-30 23:36:40 +00003539 // Build a new, canonical typeof(expr) type.
John McCall90d1c2d2009-09-24 23:30:46 +00003540 Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
Douglas Gregora21f6c32009-07-30 23:36:40 +00003541 DependentDecltypeTypes.InsertNode(Canon, InsertPos);
3542 dt = Canon;
3543 }
3544 } else {
Douglas Gregor81495f32012-02-12 18:42:33 +00003545 dt = new (*this, TypeAlignment) DecltypeType(e, UnderlyingType,
3546 getCanonicalType(UnderlyingType));
Douglas Gregorabd68132009-07-08 00:03:05 +00003547 }
Anders Carlsson81df7b82009-06-24 19:06:50 +00003548 Types.push_back(dt);
3549 return QualType(dt, 0);
3550}
3551
Alexis Hunte852b102011-05-24 22:41:36 +00003552/// getUnaryTransformationType - We don't unique these, since the memory
3553/// savings are minimal and these are rare.
3554QualType ASTContext::getUnaryTransformType(QualType BaseType,
3555 QualType UnderlyingType,
3556 UnaryTransformType::UTTKind Kind)
3557 const {
3558 UnaryTransformType *Ty =
Douglas Gregor6c6e6762011-05-25 17:51:54 +00003559 new (*this, TypeAlignment) UnaryTransformType (BaseType, UnderlyingType,
3560 Kind,
3561 UnderlyingType->isDependentType() ?
Peter Collingbourne15d48ec2012-03-05 16:02:06 +00003562 QualType() : getCanonicalType(UnderlyingType));
Alexis Hunte852b102011-05-24 22:41:36 +00003563 Types.push_back(Ty);
3564 return QualType(Ty, 0);
3565}
3566
Richard Smithb2bc2e62011-02-21 20:05:19 +00003567/// getAutoType - We only unique auto types after they've been deduced.
Richard Smith74aeef52013-04-26 16:15:35 +00003568QualType ASTContext::getAutoType(QualType DeducedType,
Richard Smith27d807c2013-04-30 13:56:41 +00003569 bool IsDecltypeAuto,
3570 bool IsDependent) const {
Richard Smithb2bc2e62011-02-21 20:05:19 +00003571 void *InsertPos = 0;
3572 if (!DeducedType.isNull()) {
3573 // Look in the folding set for an existing type.
3574 llvm::FoldingSetNodeID ID;
Richard Smith27d807c2013-04-30 13:56:41 +00003575 AutoType::Profile(ID, DeducedType, IsDecltypeAuto, IsDependent);
Richard Smithb2bc2e62011-02-21 20:05:19 +00003576 if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
3577 return QualType(AT, 0);
3578 }
3579
Richard Smith74aeef52013-04-26 16:15:35 +00003580 AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType,
Richard Smith27d807c2013-04-30 13:56:41 +00003581 IsDecltypeAuto,
3582 IsDependent);
Richard Smithb2bc2e62011-02-21 20:05:19 +00003583 Types.push_back(AT);
3584 if (InsertPos)
3585 AutoTypes.InsertNode(AT, InsertPos);
3586 return QualType(AT, 0);
Richard Smith30482bc2011-02-20 03:19:35 +00003587}
3588
Eli Friedman0dfb8892011-10-06 23:00:33 +00003589/// getAtomicType - Return the uniqued reference to the atomic type for
3590/// the given value type.
3591QualType ASTContext::getAtomicType(QualType T) const {
3592 // Unique pointers, to guarantee there is only one pointer of a particular
3593 // structure.
3594 llvm::FoldingSetNodeID ID;
3595 AtomicType::Profile(ID, T);
3596
3597 void *InsertPos = 0;
3598 if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
3599 return QualType(AT, 0);
3600
3601 // If the atomic value type isn't canonical, this won't be a canonical type
3602 // either, so fill in the canonical type field.
3603 QualType Canonical;
3604 if (!T.isCanonical()) {
3605 Canonical = getAtomicType(getCanonicalType(T));
3606
3607 // Get the new insert position for the node we care about.
3608 AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
3609 assert(NewIP == 0 && "Shouldn't be in the map!"); (void)NewIP;
3610 }
3611 AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
3612 Types.push_back(New);
3613 AtomicTypes.InsertNode(New, InsertPos);
3614 return QualType(New, 0);
3615}
3616
Richard Smith02e85f32011-04-14 22:09:26 +00003617/// getAutoDeductType - Get type pattern for deducing against 'auto'.
3618QualType ASTContext::getAutoDeductType() const {
3619 if (AutoDeductTy.isNull())
Richard Smith74aeef52013-04-26 16:15:35 +00003620 AutoDeductTy = getAutoType(QualType(), false);
Richard Smith02e85f32011-04-14 22:09:26 +00003621 assert(!AutoDeductTy.isNull() && "can't build 'auto' pattern");
3622 return AutoDeductTy;
3623}
3624
3625/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'.
3626QualType ASTContext::getAutoRRefDeductType() const {
3627 if (AutoRRefDeductTy.isNull())
3628 AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType());
3629 assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern");
3630 return AutoRRefDeductTy;
3631}
3632
Chris Lattnerfb072462007-01-23 05:45:31 +00003633/// getTagDeclType - Return the unique reference to the type for the
3634/// specified TagDecl (struct/union/class/enum) decl.
Jay Foad39c79802011-01-12 09:06:06 +00003635QualType ASTContext::getTagDeclType(const TagDecl *Decl) const {
Ted Kremenek2b0ce112007-11-26 21:16:01 +00003636 assert (Decl);
Mike Stumpb93185d2009-08-07 18:05:12 +00003637 // FIXME: What is the design on getTagDeclType when it requires casting
3638 // away const? mutable?
3639 return getTypeDeclType(const_cast<TagDecl*>(Decl));
Chris Lattnerfb072462007-01-23 05:45:31 +00003640}
3641
Mike Stump11289f42009-09-09 15:08:12 +00003642/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
3643/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
3644/// needs to agree with the definition in <stddef.h>.
Anders Carlsson22f443f2009-12-12 00:26:23 +00003645CanQualType ASTContext::getSizeType() const {
Douglas Gregore8bbc122011-09-02 00:18:52 +00003646 return getFromTargetType(Target->getSizeType());
Steve Naroff92e30f82007-04-02 22:35:25 +00003647}
Chris Lattnerfb072462007-01-23 05:45:31 +00003648
Hans Wennborg27541db2011-10-27 08:29:09 +00003649/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5).
3650CanQualType ASTContext::getIntMaxType() const {
3651 return getFromTargetType(Target->getIntMaxType());
3652}
3653
3654/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5).
3655CanQualType ASTContext::getUIntMaxType() const {
3656 return getFromTargetType(Target->getUIntMaxType());
3657}
3658
Argyrios Kyrtzidis40e9e482008-08-09 16:51:54 +00003659/// getSignedWCharType - Return the type of "signed wchar_t".
3660/// Used when in C++, as a GCC extension.
3661QualType ASTContext::getSignedWCharType() const {
3662 // FIXME: derive from "Target" ?
3663 return WCharTy;
3664}
3665
3666/// getUnsignedWCharType - Return the type of "unsigned wchar_t".
3667/// Used when in C++, as a GCC extension.
3668QualType ASTContext::getUnsignedWCharType() const {
3669 // FIXME: derive from "Target" ?
3670 return UnsignedIntTy;
3671}
3672
Enea Zaffanellaf11ceb62013-01-26 17:08:37 +00003673QualType ASTContext::getIntPtrType() const {
3674 return getFromTargetType(Target->getIntPtrType());
3675}
3676
3677QualType ASTContext::getUIntPtrType() const {
3678 return getCorrespondingUnsignedType(getIntPtrType());
3679}
3680
Hans Wennborg27541db2011-10-27 08:29:09 +00003681/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17)
Chris Lattnerd2b88ab2007-07-13 03:05:23 +00003682/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
3683QualType ASTContext::getPointerDiffType() const {
Douglas Gregore8bbc122011-09-02 00:18:52 +00003684 return getFromTargetType(Target->getPtrDiffType(0));
Chris Lattnerd2b88ab2007-07-13 03:05:23 +00003685}
3686
Eli Friedman4e91899e2012-11-27 02:58:24 +00003687/// \brief Return the unique type for "pid_t" defined in
3688/// <sys/types.h>. We need this to compute the correct type for vfork().
3689QualType ASTContext::getProcessIDType() const {
3690 return getFromTargetType(Target->getProcessIDType());
3691}
3692
Chris Lattnera21ad802008-04-02 05:18:44 +00003693//===----------------------------------------------------------------------===//
3694// Type Operators
3695//===----------------------------------------------------------------------===//
3696
Jay Foad39c79802011-01-12 09:06:06 +00003697CanQualType ASTContext::getCanonicalParamType(QualType T) const {
John McCallfc93cf92009-10-22 22:37:11 +00003698 // Push qualifiers into arrays, and then discard any remaining
3699 // qualifiers.
3700 T = getCanonicalType(T);
Fariborz Jahanian8fb87ae2010-09-24 17:30:16 +00003701 T = getVariableArrayDecayedType(T);
John McCallfc93cf92009-10-22 22:37:11 +00003702 const Type *Ty = T.getTypePtr();
John McCallfc93cf92009-10-22 22:37:11 +00003703 QualType Result;
3704 if (isa<ArrayType>(Ty)) {
3705 Result = getArrayDecayedType(QualType(Ty,0));
3706 } else if (isa<FunctionType>(Ty)) {
3707 Result = getPointerType(QualType(Ty, 0));
3708 } else {
3709 Result = QualType(Ty, 0);
3710 }
3711
3712 return CanQualType::CreateUnsafe(Result);
3713}
3714
John McCall6c9dd522011-01-18 07:41:22 +00003715QualType ASTContext::getUnqualifiedArrayType(QualType type,
3716 Qualifiers &quals) {
3717 SplitQualType splitType = type.getSplitUnqualifiedType();
3718
3719 // FIXME: getSplitUnqualifiedType() actually walks all the way to
3720 // the unqualified desugared type and then drops it on the floor.
3721 // We then have to strip that sugar back off with
3722 // getUnqualifiedDesugaredType(), which is silly.
3723 const ArrayType *AT =
John McCall18ce25e2012-02-08 00:46:36 +00003724 dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType());
John McCall6c9dd522011-01-18 07:41:22 +00003725
3726 // If we don't have an array, just use the results in splitType.
Douglas Gregor3b05bdb2010-05-17 18:45:21 +00003727 if (!AT) {
John McCall18ce25e2012-02-08 00:46:36 +00003728 quals = splitType.Quals;
3729 return QualType(splitType.Ty, 0);
Chandler Carruth607f38e2009-12-29 07:16:59 +00003730 }
3731
John McCall6c9dd522011-01-18 07:41:22 +00003732 // Otherwise, recurse on the array's element type.
3733 QualType elementType = AT->getElementType();
3734 QualType unqualElementType = getUnqualifiedArrayType(elementType, quals);
3735
3736 // If that didn't change the element type, AT has no qualifiers, so we
3737 // can just use the results in splitType.
3738 if (elementType == unqualElementType) {
3739 assert(quals.empty()); // from the recursive call
John McCall18ce25e2012-02-08 00:46:36 +00003740 quals = splitType.Quals;
3741 return QualType(splitType.Ty, 0);
John McCall6c9dd522011-01-18 07:41:22 +00003742 }
3743
3744 // Otherwise, add in the qualifiers from the outermost type, then
3745 // build the type back up.
John McCall18ce25e2012-02-08 00:46:36 +00003746 quals.addConsistentQualifiers(splitType.Quals);
Chandler Carruth607f38e2009-12-29 07:16:59 +00003747
Douglas Gregor3b05bdb2010-05-17 18:45:21 +00003748 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) {
John McCall6c9dd522011-01-18 07:41:22 +00003749 return getConstantArrayType(unqualElementType, CAT->getSize(),
Chandler Carruth607f38e2009-12-29 07:16:59 +00003750 CAT->getSizeModifier(), 0);
3751 }
3752
Douglas Gregor3b05bdb2010-05-17 18:45:21 +00003753 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
John McCall6c9dd522011-01-18 07:41:22 +00003754 return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0);
Chandler Carruth607f38e2009-12-29 07:16:59 +00003755 }
3756
Douglas Gregor3b05bdb2010-05-17 18:45:21 +00003757 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) {
John McCall6c9dd522011-01-18 07:41:22 +00003758 return getVariableArrayType(unqualElementType,
John McCallc3007a22010-10-26 07:05:15 +00003759 VAT->getSizeExpr(),
Douglas Gregor3b05bdb2010-05-17 18:45:21 +00003760 VAT->getSizeModifier(),
3761 VAT->getIndexTypeCVRQualifiers(),
3762 VAT->getBracketsRange());
3763 }
3764
3765 const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT);
John McCall6c9dd522011-01-18 07:41:22 +00003766 return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(),
Chandler Carruth607f38e2009-12-29 07:16:59 +00003767 DSAT->getSizeModifier(), 0,
3768 SourceRange());
3769}
3770
Douglas Gregor1fc3d662010-06-09 03:53:18 +00003771/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that
3772/// may be similar (C++ 4.4), replaces T1 and T2 with the type that
3773/// they point to and return true. If T1 and T2 aren't pointer types
3774/// or pointer-to-member types, or if they are not similar at this
3775/// level, returns false and leaves T1 and T2 unchanged. Top-level
3776/// qualifiers on T1 and T2 are ignored. This function will typically
3777/// be called in a loop that successively "unwraps" pointer and
3778/// pointer-to-member types to compare them at each level.
3779bool ASTContext::UnwrapSimilarPointerTypes(QualType &T1, QualType &T2) {
3780 const PointerType *T1PtrType = T1->getAs<PointerType>(),
3781 *T2PtrType = T2->getAs<PointerType>();
3782 if (T1PtrType && T2PtrType) {
3783 T1 = T1PtrType->getPointeeType();
3784 T2 = T2PtrType->getPointeeType();
3785 return true;
3786 }
3787
3788 const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(),
3789 *T2MPType = T2->getAs<MemberPointerType>();
3790 if (T1MPType && T2MPType &&
3791 hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
3792 QualType(T2MPType->getClass(), 0))) {
3793 T1 = T1MPType->getPointeeType();
3794 T2 = T2MPType->getPointeeType();
3795 return true;
3796 }
3797
David Blaikiebbafb8a2012-03-11 07:00:24 +00003798 if (getLangOpts().ObjC1) {
Douglas Gregor1fc3d662010-06-09 03:53:18 +00003799 const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(),
3800 *T2OPType = T2->getAs<ObjCObjectPointerType>();
3801 if (T1OPType && T2OPType) {
3802 T1 = T1OPType->getPointeeType();
3803 T2 = T2OPType->getPointeeType();
3804 return true;
3805 }
3806 }
3807
3808 // FIXME: Block pointers, too?
3809
3810 return false;
3811}
3812
Jay Foad39c79802011-01-12 09:06:06 +00003813DeclarationNameInfo
3814ASTContext::getNameForTemplate(TemplateName Name,
3815 SourceLocation NameLoc) const {
John McCalld9dfe3a2011-06-30 08:33:18 +00003816 switch (Name.getKind()) {
3817 case TemplateName::QualifiedTemplate:
3818 case TemplateName::Template:
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003819 // DNInfo work in progress: CHECKME: what about DNLoc?
John McCalld9dfe3a2011-06-30 08:33:18 +00003820 return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(),
3821 NameLoc);
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003822
John McCalld9dfe3a2011-06-30 08:33:18 +00003823 case TemplateName::OverloadedTemplate: {
3824 OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate();
3825 // DNInfo work in progress: CHECKME: what about DNLoc?
3826 return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc);
3827 }
3828
3829 case TemplateName::DependentTemplate: {
3830 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003831 DeclarationName DName;
John McCall847e2a12009-11-24 18:42:40 +00003832 if (DTN->isIdentifier()) {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003833 DName = DeclarationNames.getIdentifier(DTN->getIdentifier());
3834 return DeclarationNameInfo(DName, NameLoc);
John McCall847e2a12009-11-24 18:42:40 +00003835 } else {
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003836 DName = DeclarationNames.getCXXOperatorName(DTN->getOperator());
3837 // DNInfo work in progress: FIXME: source locations?
3838 DeclarationNameLoc DNLoc;
3839 DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
3840 DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
3841 return DeclarationNameInfo(DName, NameLoc, DNLoc);
John McCall847e2a12009-11-24 18:42:40 +00003842 }
3843 }
3844
John McCalld9dfe3a2011-06-30 08:33:18 +00003845 case TemplateName::SubstTemplateTemplateParm: {
3846 SubstTemplateTemplateParmStorage *subst
3847 = Name.getAsSubstTemplateTemplateParm();
3848 return DeclarationNameInfo(subst->getParameter()->getDeclName(),
3849 NameLoc);
3850 }
3851
3852 case TemplateName::SubstTemplateTemplateParmPack: {
3853 SubstTemplateTemplateParmPackStorage *subst
3854 = Name.getAsSubstTemplateTemplateParmPack();
3855 return DeclarationNameInfo(subst->getParameterPack()->getDeclName(),
3856 NameLoc);
3857 }
3858 }
3859
3860 llvm_unreachable("bad template name kind!");
John McCall847e2a12009-11-24 18:42:40 +00003861}
3862
Jay Foad39c79802011-01-12 09:06:06 +00003863TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const {
John McCalld9dfe3a2011-06-30 08:33:18 +00003864 switch (Name.getKind()) {
3865 case TemplateName::QualifiedTemplate:
3866 case TemplateName::Template: {
3867 TemplateDecl *Template = Name.getAsTemplateDecl();
Douglas Gregor7dbfb462010-06-16 21:09:37 +00003868 if (TemplateTemplateParmDecl *TTP
John McCalld9dfe3a2011-06-30 08:33:18 +00003869 = dyn_cast<TemplateTemplateParmDecl>(Template))
Douglas Gregor7dbfb462010-06-16 21:09:37 +00003870 Template = getCanonicalTemplateTemplateParmDecl(TTP);
3871
3872 // The canonical template name is the canonical template declaration.
Argyrios Kyrtzidis6b7e3762009-07-18 00:34:25 +00003873 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
Douglas Gregor7dbfb462010-06-16 21:09:37 +00003874 }
Douglas Gregor6bc50582009-05-07 06:41:52 +00003875
John McCalld9dfe3a2011-06-30 08:33:18 +00003876 case TemplateName::OverloadedTemplate:
3877 llvm_unreachable("cannot canonicalize overloaded template");
Mike Stump11289f42009-09-09 15:08:12 +00003878
John McCalld9dfe3a2011-06-30 08:33:18 +00003879 case TemplateName::DependentTemplate: {
3880 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
3881 assert(DTN && "Non-dependent template names must refer to template decls.");
3882 return DTN->CanonicalTemplateName;
3883 }
3884
3885 case TemplateName::SubstTemplateTemplateParm: {
3886 SubstTemplateTemplateParmStorage *subst
3887 = Name.getAsSubstTemplateTemplateParm();
3888 return getCanonicalTemplateName(subst->getReplacement());
3889 }
3890
3891 case TemplateName::SubstTemplateTemplateParmPack: {
3892 SubstTemplateTemplateParmPackStorage *subst
3893 = Name.getAsSubstTemplateTemplateParmPack();
3894 TemplateTemplateParmDecl *canonParameter
3895 = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
3896 TemplateArgument canonArgPack
3897 = getCanonicalTemplateArgument(subst->getArgumentPack());
3898 return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
3899 }
3900 }
3901
3902 llvm_unreachable("bad template name!");
Douglas Gregor6bc50582009-05-07 06:41:52 +00003903}
3904
Douglas Gregoradee3e32009-11-11 23:06:43 +00003905bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) {
3906 X = getCanonicalTemplateName(X);
3907 Y = getCanonicalTemplateName(Y);
3908 return X.getAsVoidPointer() == Y.getAsVoidPointer();
3909}
3910
Mike Stump11289f42009-09-09 15:08:12 +00003911TemplateArgument
Jay Foad39c79802011-01-12 09:06:06 +00003912ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
Douglas Gregora8e02e72009-07-28 23:00:59 +00003913 switch (Arg.getKind()) {
3914 case TemplateArgument::Null:
3915 return Arg;
Mike Stump11289f42009-09-09 15:08:12 +00003916
Douglas Gregora8e02e72009-07-28 23:00:59 +00003917 case TemplateArgument::Expression:
Douglas Gregora8e02e72009-07-28 23:00:59 +00003918 return Arg;
Mike Stump11289f42009-09-09 15:08:12 +00003919
Douglas Gregor31f55dc2012-04-06 22:40:38 +00003920 case TemplateArgument::Declaration: {
Eli Friedmanb826a002012-09-26 02:36:12 +00003921 ValueDecl *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
3922 return TemplateArgument(D, Arg.isDeclForReferenceParam());
Douglas Gregor31f55dc2012-04-06 22:40:38 +00003923 }
Mike Stump11289f42009-09-09 15:08:12 +00003924
Eli Friedmanb826a002012-09-26 02:36:12 +00003925 case TemplateArgument::NullPtr:
3926 return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),
3927 /*isNullPtr*/true);
3928
Douglas Gregor9167f8b2009-11-11 01:00:40 +00003929 case TemplateArgument::Template:
3930 return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));
Douglas Gregore4ff4b52011-01-05 18:58:31 +00003931
3932 case TemplateArgument::TemplateExpansion:
3933 return TemplateArgument(getCanonicalTemplateName(
3934 Arg.getAsTemplateOrTemplatePattern()),
Douglas Gregore1d60df2011-01-14 23:41:42 +00003935 Arg.getNumTemplateExpansions());
Douglas Gregore4ff4b52011-01-05 18:58:31 +00003936
Douglas Gregora8e02e72009-07-28 23:00:59 +00003937 case TemplateArgument::Integral:
Benjamin Kramer6003ad52012-06-07 15:09:51 +00003938 return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType()));
Mike Stump11289f42009-09-09 15:08:12 +00003939
Douglas Gregora8e02e72009-07-28 23:00:59 +00003940 case TemplateArgument::Type:
John McCall0ad16662009-10-29 08:12:44 +00003941 return TemplateArgument(getCanonicalType(Arg.getAsType()));
Mike Stump11289f42009-09-09 15:08:12 +00003942
Douglas Gregora8e02e72009-07-28 23:00:59 +00003943 case TemplateArgument::Pack: {
Douglas Gregor0192c232010-12-20 16:52:59 +00003944 if (Arg.pack_size() == 0)
3945 return Arg;
3946
Douglas Gregor1ccc8412010-11-07 23:05:16 +00003947 TemplateArgument *CanonArgs
3948 = new (*this) TemplateArgument[Arg.pack_size()];
Douglas Gregora8e02e72009-07-28 23:00:59 +00003949 unsigned Idx = 0;
Mike Stump11289f42009-09-09 15:08:12 +00003950 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
Douglas Gregora8e02e72009-07-28 23:00:59 +00003951 AEnd = Arg.pack_end();
3952 A != AEnd; (void)++A, ++Idx)
3953 CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
Mike Stump11289f42009-09-09 15:08:12 +00003954
Douglas Gregor1ccc8412010-11-07 23:05:16 +00003955 return TemplateArgument(CanonArgs, Arg.pack_size());
Douglas Gregora8e02e72009-07-28 23:00:59 +00003956 }
3957 }
3958
3959 // Silence GCC warning
David Blaikie83d382b2011-09-23 05:06:16 +00003960 llvm_unreachable("Unhandled template argument kind");
Douglas Gregora8e02e72009-07-28 23:00:59 +00003961}
3962
Douglas Gregor333489b2009-03-27 23:10:48 +00003963NestedNameSpecifier *
Jay Foad39c79802011-01-12 09:06:06 +00003964ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const {
Mike Stump11289f42009-09-09 15:08:12 +00003965 if (!NNS)
Douglas Gregor333489b2009-03-27 23:10:48 +00003966 return 0;
3967
3968 switch (NNS->getKind()) {
3969 case NestedNameSpecifier::Identifier:
3970 // Canonicalize the prefix but keep the identifier the same.
Mike Stump11289f42009-09-09 15:08:12 +00003971 return NestedNameSpecifier::Create(*this,
Douglas Gregor333489b2009-03-27 23:10:48 +00003972 getCanonicalNestedNameSpecifier(NNS->getPrefix()),
3973 NNS->getAsIdentifier());
3974
3975 case NestedNameSpecifier::Namespace:
3976 // A namespace is canonical; build a nested-name-specifier with
3977 // this namespace and no prefix.
Douglas Gregor7b26ff92011-02-24 02:36:08 +00003978 return NestedNameSpecifier::Create(*this, 0,
3979 NNS->getAsNamespace()->getOriginalNamespace());
3980
3981 case NestedNameSpecifier::NamespaceAlias:
3982 // A namespace is canonical; build a nested-name-specifier with
3983 // this namespace and no prefix.
3984 return NestedNameSpecifier::Create(*this, 0,
3985 NNS->getAsNamespaceAlias()->getNamespace()
3986 ->getOriginalNamespace());
Douglas Gregor333489b2009-03-27 23:10:48 +00003987
3988 case NestedNameSpecifier::TypeSpec:
3989 case NestedNameSpecifier::TypeSpecWithTemplate: {
3990 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
Douglas Gregor3ade5702010-11-04 00:09:33 +00003991
3992 // If we have some kind of dependent-named type (e.g., "typename T::type"),
3993 // break it apart into its prefix and identifier, then reconsititute those
3994 // as the canonical nested-name-specifier. This is required to canonicalize
3995 // a dependent nested-name-specifier involving typedefs of dependent-name
3996 // types, e.g.,
3997 // typedef typename T::type T1;
3998 // typedef typename T1::type T2;
Eli Friedman5358a0a2012-03-03 04:09:56 +00003999 if (const DependentNameType *DNT = T->getAs<DependentNameType>())
4000 return NestedNameSpecifier::Create(*this, DNT->getQualifier(),
Douglas Gregor3ade5702010-11-04 00:09:33 +00004001 const_cast<IdentifierInfo *>(DNT->getIdentifier()));
Douglas Gregor3ade5702010-11-04 00:09:33 +00004002
Eli Friedman5358a0a2012-03-03 04:09:56 +00004003 // Otherwise, just canonicalize the type, and force it to be a TypeSpec.
4004 // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the
4005 // first place?
John McCall33ddac02011-01-19 10:06:00 +00004006 return NestedNameSpecifier::Create(*this, 0, false,
4007 const_cast<Type*>(T.getTypePtr()));
Douglas Gregor333489b2009-03-27 23:10:48 +00004008 }
4009
4010 case NestedNameSpecifier::Global:
4011 // The global specifier is canonical and unique.
4012 return NNS;
4013 }
4014
David Blaikie8a40f702012-01-17 06:56:22 +00004015 llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
Douglas Gregor333489b2009-03-27 23:10:48 +00004016}
4017
Chris Lattner7adf0762008-08-04 07:31:14 +00004018
Jay Foad39c79802011-01-12 09:06:06 +00004019const ArrayType *ASTContext::getAsArrayType(QualType T) const {
Chris Lattner7adf0762008-08-04 07:31:14 +00004020 // Handle the non-qualified case efficiently.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00004021 if (!T.hasLocalQualifiers()) {
Chris Lattner7adf0762008-08-04 07:31:14 +00004022 // Handle the common positive case fast.
4023 if (const ArrayType *AT = dyn_cast<ArrayType>(T))
4024 return AT;
4025 }
Mike Stump11289f42009-09-09 15:08:12 +00004026
John McCall8ccfcb52009-09-24 19:53:00 +00004027 // Handle the common negative case fast.
John McCall33ddac02011-01-19 10:06:00 +00004028 if (!isa<ArrayType>(T.getCanonicalType()))
Chris Lattner7adf0762008-08-04 07:31:14 +00004029 return 0;
Mike Stump11289f42009-09-09 15:08:12 +00004030
John McCall8ccfcb52009-09-24 19:53:00 +00004031 // Apply any qualifiers from the array type to the element type. This
Chris Lattner7adf0762008-08-04 07:31:14 +00004032 // implements C99 6.7.3p8: "If the specification of an array type includes
4033 // any type qualifiers, the element type is so qualified, not the array type."
Mike Stump11289f42009-09-09 15:08:12 +00004034
Chris Lattner7adf0762008-08-04 07:31:14 +00004035 // If we get here, we either have type qualifiers on the type, or we have
4036 // sugar such as a typedef in the way. If we have type qualifiers on the type
Douglas Gregor2211d342009-08-05 05:36:45 +00004037 // we must propagate them down into the element type.
Mike Stump11289f42009-09-09 15:08:12 +00004038
John McCall33ddac02011-01-19 10:06:00 +00004039 SplitQualType split = T.getSplitDesugaredType();
John McCall18ce25e2012-02-08 00:46:36 +00004040 Qualifiers qs = split.Quals;
Mike Stump11289f42009-09-09 15:08:12 +00004041
Chris Lattner7adf0762008-08-04 07:31:14 +00004042 // If we have a simple case, just return now.
John McCall18ce25e2012-02-08 00:46:36 +00004043 const ArrayType *ATy = dyn_cast<ArrayType>(split.Ty);
John McCall33ddac02011-01-19 10:06:00 +00004044 if (ATy == 0 || qs.empty())
Chris Lattner7adf0762008-08-04 07:31:14 +00004045 return ATy;
Mike Stump11289f42009-09-09 15:08:12 +00004046
Chris Lattner7adf0762008-08-04 07:31:14 +00004047 // Otherwise, we have an array and we have qualifiers on it. Push the
4048 // qualifiers into the array element type and return a new array type.
John McCall33ddac02011-01-19 10:06:00 +00004049 QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs);
Mike Stump11289f42009-09-09 15:08:12 +00004050
Chris Lattner7adf0762008-08-04 07:31:14 +00004051 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy))
4052 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
4053 CAT->getSizeModifier(),
John McCall8ccfcb52009-09-24 19:53:00 +00004054 CAT->getIndexTypeCVRQualifiers()));
Chris Lattner7adf0762008-08-04 07:31:14 +00004055 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy))
4056 return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
4057 IAT->getSizeModifier(),
John McCall8ccfcb52009-09-24 19:53:00 +00004058 IAT->getIndexTypeCVRQualifiers()));
Douglas Gregor4619e432008-12-05 23:32:09 +00004059
Mike Stump11289f42009-09-09 15:08:12 +00004060 if (const DependentSizedArrayType *DSAT
Douglas Gregor4619e432008-12-05 23:32:09 +00004061 = dyn_cast<DependentSizedArrayType>(ATy))
4062 return cast<ArrayType>(
Mike Stump11289f42009-09-09 15:08:12 +00004063 getDependentSizedArrayType(NewEltTy,
John McCallc3007a22010-10-26 07:05:15 +00004064 DSAT->getSizeExpr(),
Douglas Gregor4619e432008-12-05 23:32:09 +00004065 DSAT->getSizeModifier(),
John McCall8ccfcb52009-09-24 19:53:00 +00004066 DSAT->getIndexTypeCVRQualifiers(),
Douglas Gregor04318252009-07-06 15:59:29 +00004067 DSAT->getBracketsRange()));
Mike Stump11289f42009-09-09 15:08:12 +00004068
Chris Lattner7adf0762008-08-04 07:31:14 +00004069 const VariableArrayType *VAT = cast<VariableArrayType>(ATy);
Douglas Gregor04318252009-07-06 15:59:29 +00004070 return cast<ArrayType>(getVariableArrayType(NewEltTy,
John McCallc3007a22010-10-26 07:05:15 +00004071 VAT->getSizeExpr(),
Chris Lattner7adf0762008-08-04 07:31:14 +00004072 VAT->getSizeModifier(),
John McCall8ccfcb52009-09-24 19:53:00 +00004073 VAT->getIndexTypeCVRQualifiers(),
Douglas Gregor04318252009-07-06 15:59:29 +00004074 VAT->getBracketsRange()));
Chris Lattnered0d0792008-04-06 22:41:35 +00004075}
4076
Abramo Bagnarae1decdf2012-05-17 12:44:05 +00004077QualType ASTContext::getAdjustedParameterType(QualType T) const {
Douglas Gregor84280642011-07-12 04:42:08 +00004078 // C99 6.7.5.3p7:
4079 // A declaration of a parameter as "array of type" shall be
4080 // adjusted to "qualified pointer to type", where the type
4081 // qualifiers (if any) are those specified within the [ and ] of
4082 // the array type derivation.
4083 if (T->isArrayType())
4084 return getArrayDecayedType(T);
4085
4086 // C99 6.7.5.3p8:
4087 // A declaration of a parameter as "function returning type"
4088 // shall be adjusted to "pointer to function returning type", as
4089 // in 6.3.2.1.
4090 if (T->isFunctionType())
4091 return getPointerType(T);
4092
4093 return T;
4094}
4095
Abramo Bagnarae1decdf2012-05-17 12:44:05 +00004096QualType ASTContext::getSignatureParameterType(QualType T) const {
Douglas Gregor84280642011-07-12 04:42:08 +00004097 T = getVariableArrayDecayedType(T);
4098 T = getAdjustedParameterType(T);
4099 return T.getUnqualifiedType();
4100}
4101
Chris Lattnera21ad802008-04-02 05:18:44 +00004102/// getArrayDecayedType - Return the properly qualified result of decaying the
4103/// specified array type to a pointer. This operation is non-trivial when
4104/// handling typedefs etc. The canonical type of "T" must be an array type,
4105/// this returns a pointer to a properly qualified element of the array.
4106///
4107/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
Jay Foad39c79802011-01-12 09:06:06 +00004108QualType ASTContext::getArrayDecayedType(QualType Ty) const {
Chris Lattner7adf0762008-08-04 07:31:14 +00004109 // Get the element type with 'getAsArrayType' so that we don't lose any
4110 // typedefs in the element type of the array. This also handles propagation
4111 // of type qualifiers from the array type into the element type if present
4112 // (C99 6.7.3p8).
4113 const ArrayType *PrettyArrayType = getAsArrayType(Ty);
4114 assert(PrettyArrayType && "Not an array type!");
Mike Stump11289f42009-09-09 15:08:12 +00004115
Chris Lattner7adf0762008-08-04 07:31:14 +00004116 QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
Chris Lattnera21ad802008-04-02 05:18:44 +00004117
4118 // int x[restrict 4] -> int *restrict
John McCall8ccfcb52009-09-24 19:53:00 +00004119 return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers());
Chris Lattnera21ad802008-04-02 05:18:44 +00004120}
4121
John McCall33ddac02011-01-19 10:06:00 +00004122QualType ASTContext::getBaseElementType(const ArrayType *array) const {
4123 return getBaseElementType(array->getElementType());
Douglas Gregor79f83ed2009-07-23 23:49:00 +00004124}
4125
John McCall33ddac02011-01-19 10:06:00 +00004126QualType ASTContext::getBaseElementType(QualType type) const {
4127 Qualifiers qs;
4128 while (true) {
4129 SplitQualType split = type.getSplitDesugaredType();
John McCall18ce25e2012-02-08 00:46:36 +00004130 const ArrayType *array = split.Ty->getAsArrayTypeUnsafe();
John McCall33ddac02011-01-19 10:06:00 +00004131 if (!array) break;
Mike Stump11289f42009-09-09 15:08:12 +00004132
John McCall33ddac02011-01-19 10:06:00 +00004133 type = array->getElementType();
John McCall18ce25e2012-02-08 00:46:36 +00004134 qs.addConsistentQualifiers(split.Quals);
John McCall33ddac02011-01-19 10:06:00 +00004135 }
Mike Stump11289f42009-09-09 15:08:12 +00004136
John McCall33ddac02011-01-19 10:06:00 +00004137 return getQualifiedType(type, qs);
Anders Carlssone0808df2008-12-21 03:44:36 +00004138}
4139
Fariborz Jahanian6c9e5a22009-08-21 16:31:06 +00004140/// getConstantArrayElementCount - Returns number of constant array elements.
Mike Stump11289f42009-09-09 15:08:12 +00004141uint64_t
Fariborz Jahanian6c9e5a22009-08-21 16:31:06 +00004142ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const {
4143 uint64_t ElementCount = 1;
4144 do {
4145 ElementCount *= CA->getSize().getZExtValue();
Richard Smith7808c6a2012-12-06 03:04:50 +00004146 CA = dyn_cast_or_null<ConstantArrayType>(
4147 CA->getElementType()->getAsArrayTypeUnsafe());
Fariborz Jahanian6c9e5a22009-08-21 16:31:06 +00004148 } while (CA);
4149 return ElementCount;
4150}
4151
Steve Naroff0af91202007-04-27 21:51:21 +00004152/// getFloatingRank - Return a relative rank for floating point types.
4153/// This routine will assert if passed a built-in type that isn't a float.
Chris Lattnerb90739d2008-04-06 23:38:49 +00004154static FloatingRank getFloatingRank(QualType T) {
John McCall9dd450b2009-09-21 23:43:11 +00004155 if (const ComplexType *CT = T->getAs<ComplexType>())
Chris Lattnerc6395932007-06-22 20:56:16 +00004156 return getFloatingRank(CT->getElementType());
Chris Lattnerb90739d2008-04-06 23:38:49 +00004157
John McCall9dd450b2009-09-21 23:43:11 +00004158 assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type");
4159 switch (T->getAs<BuiltinType>()->getKind()) {
David Blaikie83d382b2011-09-23 05:06:16 +00004160 default: llvm_unreachable("getFloatingRank(): not a floating type");
Anton Korobeynikovf0c267e2011-10-14 23:23:15 +00004161 case BuiltinType::Half: return HalfRank;
Chris Lattnerc6395932007-06-22 20:56:16 +00004162 case BuiltinType::Float: return FloatRank;
4163 case BuiltinType::Double: return DoubleRank;
4164 case BuiltinType::LongDouble: return LongDoubleRank;
Steve Naroffe4718892007-04-27 18:30:00 +00004165 }
4166}
4167
Mike Stump11289f42009-09-09 15:08:12 +00004168/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
4169/// point or a complex type (based on typeDomain/typeSize).
Steve Narofffc6ffa22007-08-27 01:41:48 +00004170/// 'typeDomain' is a real floating point or complex type.
4171/// 'typeSize' is a real floating point or complex type.
Chris Lattnerb9dfb032008-04-06 23:58:54 +00004172QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
4173 QualType Domain) const {
4174 FloatingRank EltRank = getFloatingRank(Size);
4175 if (Domain->isComplexType()) {
4176 switch (EltRank) {
David Blaikief47fa302012-01-17 02:30:50 +00004177 case HalfRank: llvm_unreachable("Complex half is not supported");
Steve Naroff9091ef72007-08-27 01:27:54 +00004178 case FloatRank: return FloatComplexTy;
4179 case DoubleRank: return DoubleComplexTy;
4180 case LongDoubleRank: return LongDoubleComplexTy;
4181 }
Steve Naroff0af91202007-04-27 21:51:21 +00004182 }
Chris Lattnerb9dfb032008-04-06 23:58:54 +00004183
4184 assert(Domain->isRealFloatingType() && "Unknown domain!");
4185 switch (EltRank) {
Joey Goulydd7f4562013-01-23 11:56:20 +00004186 case HalfRank: return HalfTy;
Chris Lattnerb9dfb032008-04-06 23:58:54 +00004187 case FloatRank: return FloatTy;
4188 case DoubleRank: return DoubleTy;
4189 case LongDoubleRank: return LongDoubleTy;
Steve Naroff9091ef72007-08-27 01:27:54 +00004190 }
David Blaikief47fa302012-01-17 02:30:50 +00004191 llvm_unreachable("getFloatingRank(): illegal value for rank");
Steve Naroffe4718892007-04-27 18:30:00 +00004192}
4193
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004194/// getFloatingTypeOrder - Compare the rank of the two specified floating
4195/// point types, ignoring the domain of the type (i.e. 'double' ==
4196/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
Mike Stump11289f42009-09-09 15:08:12 +00004197/// LHS < RHS, return -1.
Jay Foad39c79802011-01-12 09:06:06 +00004198int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
Chris Lattnerb90739d2008-04-06 23:38:49 +00004199 FloatingRank LHSR = getFloatingRank(LHS);
4200 FloatingRank RHSR = getFloatingRank(RHS);
Mike Stump11289f42009-09-09 15:08:12 +00004201
Chris Lattnerb90739d2008-04-06 23:38:49 +00004202 if (LHSR == RHSR)
Steve Naroff7af82d42007-08-27 15:30:22 +00004203 return 0;
Chris Lattnerb90739d2008-04-06 23:38:49 +00004204 if (LHSR > RHSR)
Steve Naroff7af82d42007-08-27 15:30:22 +00004205 return 1;
4206 return -1;
Steve Naroffe4718892007-04-27 18:30:00 +00004207}
4208
Chris Lattner76a00cf2008-04-06 22:59:24 +00004209/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
4210/// routine will assert if passed a built-in type that isn't an integer or enum,
4211/// or if it is not canonicalized.
John McCall424cec92011-01-19 06:33:43 +00004212unsigned ASTContext::getIntegerRank(const Type *T) const {
John McCallb692a092009-10-22 20:10:53 +00004213 assert(T->isCanonicalUnqualified() && "T should be canonicalized");
Alisdair Mereditha9ad47d2009-07-14 06:30:34 +00004214
Chris Lattner76a00cf2008-04-06 22:59:24 +00004215 switch (cast<BuiltinType>(T)->getKind()) {
David Blaikie83d382b2011-09-23 05:06:16 +00004216 default: llvm_unreachable("getIntegerRank(): not a built-in integer");
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004217 case BuiltinType::Bool:
Eli Friedman1efaaea2009-02-13 02:31:07 +00004218 return 1 + (getIntWidth(BoolTy) << 3);
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004219 case BuiltinType::Char_S:
4220 case BuiltinType::Char_U:
4221 case BuiltinType::SChar:
4222 case BuiltinType::UChar:
Eli Friedman1efaaea2009-02-13 02:31:07 +00004223 return 2 + (getIntWidth(CharTy) << 3);
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004224 case BuiltinType::Short:
4225 case BuiltinType::UShort:
Eli Friedman1efaaea2009-02-13 02:31:07 +00004226 return 3 + (getIntWidth(ShortTy) << 3);
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004227 case BuiltinType::Int:
4228 case BuiltinType::UInt:
Eli Friedman1efaaea2009-02-13 02:31:07 +00004229 return 4 + (getIntWidth(IntTy) << 3);
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004230 case BuiltinType::Long:
4231 case BuiltinType::ULong:
Eli Friedman1efaaea2009-02-13 02:31:07 +00004232 return 5 + (getIntWidth(LongTy) << 3);
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004233 case BuiltinType::LongLong:
4234 case BuiltinType::ULongLong:
Eli Friedman1efaaea2009-02-13 02:31:07 +00004235 return 6 + (getIntWidth(LongLongTy) << 3);
Chris Lattnerf122cef2009-04-30 02:43:43 +00004236 case BuiltinType::Int128:
4237 case BuiltinType::UInt128:
4238 return 7 + (getIntWidth(Int128Ty) << 3);
Chris Lattner76a00cf2008-04-06 22:59:24 +00004239 }
4240}
4241
Eli Friedman629ffb92009-08-20 04:21:42 +00004242/// \brief Whether this is a promotable bitfield reference according
4243/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
4244///
4245/// \returns the type this bit-field will promote to, or NULL if no
4246/// promotion occurs.
Jay Foad39c79802011-01-12 09:06:06 +00004247QualType ASTContext::isPromotableBitField(Expr *E) const {
Douglas Gregore05d3cb2010-05-24 20:13:53 +00004248 if (E->isTypeDependent() || E->isValueDependent())
4249 return QualType();
4250
Eli Friedman629ffb92009-08-20 04:21:42 +00004251 FieldDecl *Field = E->getBitField();
4252 if (!Field)
4253 return QualType();
4254
4255 QualType FT = Field->getType();
4256
Richard Smithcaf33902011-10-10 18:28:20 +00004257 uint64_t BitWidth = Field->getBitWidthValue(*this);
Eli Friedman629ffb92009-08-20 04:21:42 +00004258 uint64_t IntSize = getTypeSize(IntTy);
4259 // GCC extension compatibility: if the bit-field size is less than or equal
4260 // to the size of int, it gets promoted no matter what its type is.
4261 // For instance, unsigned long bf : 4 gets promoted to signed int.
4262 if (BitWidth < IntSize)
4263 return IntTy;
4264
4265 if (BitWidth == IntSize)
4266 return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy;
4267
4268 // Types bigger than int are not subject to promotions, and therefore act
4269 // like the base type.
4270 // FIXME: This doesn't quite match what gcc does, but what gcc does here
4271 // is ridiculous.
4272 return QualType();
4273}
4274
Eli Friedman5ae98ee2009-08-19 07:44:53 +00004275/// getPromotedIntegerType - Returns the type that Promotable will
4276/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
4277/// integer type.
Jay Foad39c79802011-01-12 09:06:06 +00004278QualType ASTContext::getPromotedIntegerType(QualType Promotable) const {
Eli Friedman5ae98ee2009-08-19 07:44:53 +00004279 assert(!Promotable.isNull());
4280 assert(Promotable->isPromotableIntegerType());
John McCall56774992009-12-09 09:09:27 +00004281 if (const EnumType *ET = Promotable->getAs<EnumType>())
4282 return ET->getDecl()->getPromotionType();
Eli Friedman3f37c1c2011-10-26 07:22:48 +00004283
4284 if (const BuiltinType *BT = Promotable->getAs<BuiltinType>()) {
4285 // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t
4286 // (3.9.1) can be converted to a prvalue of the first of the following
4287 // types that can represent all the values of its underlying type:
4288 // int, unsigned int, long int, unsigned long int, long long int, or
4289 // unsigned long long int [...]
4290 // FIXME: Is there some better way to compute this?
4291 if (BT->getKind() == BuiltinType::WChar_S ||
4292 BT->getKind() == BuiltinType::WChar_U ||
4293 BT->getKind() == BuiltinType::Char16 ||
4294 BT->getKind() == BuiltinType::Char32) {
4295 bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
4296 uint64_t FromSize = getTypeSize(BT);
4297 QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy,
4298 LongLongTy, UnsignedLongLongTy };
4299 for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) {
4300 uint64_t ToSize = getTypeSize(PromoteTypes[Idx]);
4301 if (FromSize < ToSize ||
4302 (FromSize == ToSize &&
4303 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType()))
4304 return PromoteTypes[Idx];
4305 }
4306 llvm_unreachable("char type should fit into long long");
4307 }
4308 }
4309
4310 // At this point, we should have a signed or unsigned integer type.
Eli Friedman5ae98ee2009-08-19 07:44:53 +00004311 if (Promotable->isSignedIntegerType())
4312 return IntTy;
Eli Friedman6745c3b2012-11-15 01:21:59 +00004313 uint64_t PromotableSize = getIntWidth(Promotable);
4314 uint64_t IntSize = getIntWidth(IntTy);
Eli Friedman5ae98ee2009-08-19 07:44:53 +00004315 assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize);
4316 return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
4317}
4318
Argyrios Kyrtzidis7451d1c2011-07-01 22:22:50 +00004319/// \brief Recurses in pointer/array types until it finds an objc retainable
4320/// type and returns its ownership.
4321Qualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const {
4322 while (!T.isNull()) {
4323 if (T.getObjCLifetime() != Qualifiers::OCL_None)
4324 return T.getObjCLifetime();
4325 if (T->isArrayType())
4326 T = getBaseElementType(T);
4327 else if (const PointerType *PT = T->getAs<PointerType>())
4328 T = PT->getPointeeType();
4329 else if (const ReferenceType *RT = T->getAs<ReferenceType>())
Argyrios Kyrtzidis8e252532011-07-01 23:01:46 +00004330 T = RT->getPointeeType();
Argyrios Kyrtzidis7451d1c2011-07-01 22:22:50 +00004331 else
4332 break;
4333 }
4334
4335 return Qualifiers::OCL_None;
4336}
4337
Mike Stump11289f42009-09-09 15:08:12 +00004338/// getIntegerTypeOrder - Returns the highest ranked integer type:
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004339/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
Mike Stump11289f42009-09-09 15:08:12 +00004340/// LHS < RHS, return -1.
Jay Foad39c79802011-01-12 09:06:06 +00004341int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const {
John McCall424cec92011-01-19 06:33:43 +00004342 const Type *LHSC = getCanonicalType(LHS).getTypePtr();
4343 const Type *RHSC = getCanonicalType(RHS).getTypePtr();
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004344 if (LHSC == RHSC) return 0;
Mike Stump11289f42009-09-09 15:08:12 +00004345
Chris Lattner76a00cf2008-04-06 22:59:24 +00004346 bool LHSUnsigned = LHSC->isUnsignedIntegerType();
4347 bool RHSUnsigned = RHSC->isUnsignedIntegerType();
Mike Stump11289f42009-09-09 15:08:12 +00004348
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004349 unsigned LHSRank = getIntegerRank(LHSC);
4350 unsigned RHSRank = getIntegerRank(RHSC);
Mike Stump11289f42009-09-09 15:08:12 +00004351
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004352 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
4353 if (LHSRank == RHSRank) return 0;
4354 return LHSRank > RHSRank ? 1 : -1;
4355 }
Mike Stump11289f42009-09-09 15:08:12 +00004356
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004357 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
4358 if (LHSUnsigned) {
4359 // If the unsigned [LHS] type is larger, return it.
4360 if (LHSRank >= RHSRank)
4361 return 1;
Mike Stump11289f42009-09-09 15:08:12 +00004362
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004363 // If the signed type can represent all values of the unsigned type, it
4364 // wins. Because we are dealing with 2's complement and types that are
Mike Stump11289f42009-09-09 15:08:12 +00004365 // powers of two larger than each other, this is always safe.
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004366 return -1;
4367 }
Chris Lattner76a00cf2008-04-06 22:59:24 +00004368
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004369 // If the unsigned [RHS] type is larger, return it.
4370 if (RHSRank >= LHSRank)
4371 return -1;
Mike Stump11289f42009-09-09 15:08:12 +00004372
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004373 // If the signed type can represent all values of the unsigned type, it
4374 // wins. Because we are dealing with 2's complement and types that are
Mike Stump11289f42009-09-09 15:08:12 +00004375 // powers of two larger than each other, this is always safe.
Chris Lattnerd4bacd62008-04-06 23:55:33 +00004376 return 1;
Steve Naroffe4718892007-04-27 18:30:00 +00004377}
Anders Carlsson98f07902007-08-17 05:31:46 +00004378
Anders Carlsson6d417272009-11-14 21:45:58 +00004379static RecordDecl *
Abramo Bagnara29c2d462011-03-09 14:09:51 +00004380CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK,
4381 DeclContext *DC, IdentifierInfo *Id) {
4382 SourceLocation Loc;
David Blaikiebbafb8a2012-03-11 07:00:24 +00004383 if (Ctx.getLangOpts().CPlusPlus)
Abramo Bagnara29c2d462011-03-09 14:09:51 +00004384 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
Anders Carlsson6d417272009-11-14 21:45:58 +00004385 else
Abramo Bagnara29c2d462011-03-09 14:09:51 +00004386 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
Anders Carlsson6d417272009-11-14 21:45:58 +00004387}
Abramo Bagnara29c2d462011-03-09 14:09:51 +00004388
Mike Stump11289f42009-09-09 15:08:12 +00004389// getCFConstantStringType - Return the type used for constant CFStrings.
Jay Foad39c79802011-01-12 09:06:06 +00004390QualType ASTContext::getCFConstantStringType() const {
Anders Carlsson98f07902007-08-17 05:31:46 +00004391 if (!CFConstantStringTypeDecl) {
Mike Stump11289f42009-09-09 15:08:12 +00004392 CFConstantStringTypeDecl =
Abramo Bagnara29c2d462011-03-09 14:09:51 +00004393 CreateRecordDecl(*this, TTK_Struct, TUDecl,
Anders Carlsson6d417272009-11-14 21:45:58 +00004394 &Idents.get("NSConstantString"));
John McCallae580fe2010-02-05 01:33:36 +00004395 CFConstantStringTypeDecl->startDefinition();
Anders Carlsson6d417272009-11-14 21:45:58 +00004396
Anders Carlsson9c1011c2007-11-19 00:25:30 +00004397 QualType FieldTypes[4];
Mike Stump11289f42009-09-09 15:08:12 +00004398
Anders Carlsson98f07902007-08-17 05:31:46 +00004399 // const int *isa;
John McCall8ccfcb52009-09-24 19:53:00 +00004400 FieldTypes[0] = getPointerType(IntTy.withConst());
Anders Carlsson9c1011c2007-11-19 00:25:30 +00004401 // int flags;
4402 FieldTypes[1] = IntTy;
Anders Carlsson98f07902007-08-17 05:31:46 +00004403 // const char *str;
John McCall8ccfcb52009-09-24 19:53:00 +00004404 FieldTypes[2] = getPointerType(CharTy.withConst());
Anders Carlsson98f07902007-08-17 05:31:46 +00004405 // long length;
Mike Stump11289f42009-09-09 15:08:12 +00004406 FieldTypes[3] = LongTy;
4407
Anders Carlsson98f07902007-08-17 05:31:46 +00004408 // Create fields
Douglas Gregor91f84212008-12-11 16:49:14 +00004409 for (unsigned i = 0; i < 4; ++i) {
Mike Stump11289f42009-09-09 15:08:12 +00004410 FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl,
Abramo Bagnaradff19302011-03-08 08:55:46 +00004411 SourceLocation(),
Douglas Gregor91f84212008-12-11 16:49:14 +00004412 SourceLocation(), 0,
John McCallbcd03502009-12-07 02:54:59 +00004413 FieldTypes[i], /*TInfo=*/0,
Mike Stump11289f42009-09-09 15:08:12 +00004414 /*BitWidth=*/0,
Richard Smith938f40b2011-06-11 17:19:42 +00004415 /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00004416 ICIS_NoInit);
John McCall4d4dcc82010-04-30 21:35:41 +00004417 Field->setAccess(AS_public);
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004418 CFConstantStringTypeDecl->addDecl(Field);
Douglas Gregor91f84212008-12-11 16:49:14 +00004419 }
4420
Douglas Gregord5058122010-02-11 01:19:42 +00004421 CFConstantStringTypeDecl->completeDefinition();
Anders Carlsson98f07902007-08-17 05:31:46 +00004422 }
Mike Stump11289f42009-09-09 15:08:12 +00004423
Anders Carlsson98f07902007-08-17 05:31:46 +00004424 return getTagDeclType(CFConstantStringTypeDecl);
Gabor Greif412af032007-09-11 15:32:40 +00004425}
Anders Carlsson87c149b2007-10-11 01:00:40 +00004426
Fariborz Jahaniancb6c8672013-01-04 18:45:40 +00004427QualType ASTContext::getObjCSuperType() const {
4428 if (ObjCSuperType.isNull()) {
4429 RecordDecl *ObjCSuperTypeDecl =
4430 CreateRecordDecl(*this, TTK_Struct, TUDecl, &Idents.get("objc_super"));
4431 TUDecl->addDecl(ObjCSuperTypeDecl);
4432 ObjCSuperType = getTagDeclType(ObjCSuperTypeDecl);
4433 }
4434 return ObjCSuperType;
4435}
4436
Douglas Gregor512b0772009-04-23 22:29:11 +00004437void ASTContext::setCFConstantStringType(QualType T) {
Ted Kremenekc23c7e62009-07-29 21:53:49 +00004438 const RecordType *Rec = T->getAs<RecordType>();
Douglas Gregor512b0772009-04-23 22:29:11 +00004439 assert(Rec && "Invalid CFConstantStringType");
4440 CFConstantStringTypeDecl = Rec->getDecl();
4441}
4442
Jay Foad39c79802011-01-12 09:06:06 +00004443QualType ASTContext::getBlockDescriptorType() const {
Mike Stumpd0153282009-10-20 02:12:22 +00004444 if (BlockDescriptorType)
4445 return getTagDeclType(BlockDescriptorType);
4446
4447 RecordDecl *T;
4448 // FIXME: Needs the FlagAppleBlock bit.
Abramo Bagnara29c2d462011-03-09 14:09:51 +00004449 T = CreateRecordDecl(*this, TTK_Struct, TUDecl,
Anders Carlsson6d417272009-11-14 21:45:58 +00004450 &Idents.get("__block_descriptor"));
John McCallae580fe2010-02-05 01:33:36 +00004451 T->startDefinition();
Mike Stumpd0153282009-10-20 02:12:22 +00004452
4453 QualType FieldTypes[] = {
4454 UnsignedLongTy,
4455 UnsignedLongTy,
4456 };
4457
4458 const char *FieldNames[] = {
4459 "reserved",
Mike Stumpe1b19ba2009-10-22 00:49:09 +00004460 "Size"
Mike Stumpd0153282009-10-20 02:12:22 +00004461 };
4462
4463 for (size_t i = 0; i < 2; ++i) {
Abramo Bagnaradff19302011-03-08 08:55:46 +00004464 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(),
Mike Stumpd0153282009-10-20 02:12:22 +00004465 SourceLocation(),
4466 &Idents.get(FieldNames[i]),
John McCallbcd03502009-12-07 02:54:59 +00004467 FieldTypes[i], /*TInfo=*/0,
Mike Stumpd0153282009-10-20 02:12:22 +00004468 /*BitWidth=*/0,
Richard Smith938f40b2011-06-11 17:19:42 +00004469 /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00004470 ICIS_NoInit);
John McCall4d4dcc82010-04-30 21:35:41 +00004471 Field->setAccess(AS_public);
Mike Stumpd0153282009-10-20 02:12:22 +00004472 T->addDecl(Field);
4473 }
4474
Douglas Gregord5058122010-02-11 01:19:42 +00004475 T->completeDefinition();
Mike Stumpd0153282009-10-20 02:12:22 +00004476
4477 BlockDescriptorType = T;
4478
4479 return getTagDeclType(BlockDescriptorType);
4480}
4481
Jay Foad39c79802011-01-12 09:06:06 +00004482QualType ASTContext::getBlockDescriptorExtendedType() const {
Mike Stumpe1b19ba2009-10-22 00:49:09 +00004483 if (BlockDescriptorExtendedType)
4484 return getTagDeclType(BlockDescriptorExtendedType);
4485
4486 RecordDecl *T;
4487 // FIXME: Needs the FlagAppleBlock bit.
Abramo Bagnara29c2d462011-03-09 14:09:51 +00004488 T = CreateRecordDecl(*this, TTK_Struct, TUDecl,
Anders Carlsson6d417272009-11-14 21:45:58 +00004489 &Idents.get("__block_descriptor_withcopydispose"));
John McCallae580fe2010-02-05 01:33:36 +00004490 T->startDefinition();
Mike Stumpe1b19ba2009-10-22 00:49:09 +00004491
4492 QualType FieldTypes[] = {
4493 UnsignedLongTy,
4494 UnsignedLongTy,
4495 getPointerType(VoidPtrTy),
4496 getPointerType(VoidPtrTy)
4497 };
4498
4499 const char *FieldNames[] = {
4500 "reserved",
4501 "Size",
4502 "CopyFuncPtr",
4503 "DestroyFuncPtr"
4504 };
4505
4506 for (size_t i = 0; i < 4; ++i) {
Abramo Bagnaradff19302011-03-08 08:55:46 +00004507 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(),
Mike Stumpe1b19ba2009-10-22 00:49:09 +00004508 SourceLocation(),
4509 &Idents.get(FieldNames[i]),
John McCallbcd03502009-12-07 02:54:59 +00004510 FieldTypes[i], /*TInfo=*/0,
Mike Stumpe1b19ba2009-10-22 00:49:09 +00004511 /*BitWidth=*/0,
Richard Smith938f40b2011-06-11 17:19:42 +00004512 /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00004513 ICIS_NoInit);
John McCall4d4dcc82010-04-30 21:35:41 +00004514 Field->setAccess(AS_public);
Mike Stumpe1b19ba2009-10-22 00:49:09 +00004515 T->addDecl(Field);
4516 }
4517
Douglas Gregord5058122010-02-11 01:19:42 +00004518 T->completeDefinition();
Mike Stumpe1b19ba2009-10-22 00:49:09 +00004519
4520 BlockDescriptorExtendedType = T;
4521
4522 return getTagDeclType(BlockDescriptorExtendedType);
4523}
4524
Fariborz Jahanian998f0a32012-11-28 23:12:17 +00004525/// BlockRequiresCopying - Returns true if byref variable "D" of type "Ty"
4526/// requires copy/dispose. Note that this must match the logic
4527/// in buildByrefHelpers.
4528bool ASTContext::BlockRequiresCopying(QualType Ty,
4529 const VarDecl *D) {
4530 if (const CXXRecordDecl *record = Ty->getAsCXXRecordDecl()) {
4531 const Expr *copyExpr = getBlockVarCopyInits(D);
4532 if (!copyExpr && record->hasTrivialDestructor()) return false;
4533
Mike Stump94967902009-10-21 18:16:27 +00004534 return true;
Fariborz Jahaniana00076c2010-11-17 00:21:28 +00004535 }
Fariborz Jahanian998f0a32012-11-28 23:12:17 +00004536
4537 if (!Ty->isObjCRetainableType()) return false;
4538
4539 Qualifiers qs = Ty.getQualifiers();
4540
4541 // If we have lifetime, that dominates.
4542 if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) {
4543 assert(getLangOpts().ObjCAutoRefCount);
4544
4545 switch (lifetime) {
4546 case Qualifiers::OCL_None: llvm_unreachable("impossible");
4547
4548 // These are just bits as far as the runtime is concerned.
4549 case Qualifiers::OCL_ExplicitNone:
4550 case Qualifiers::OCL_Autoreleasing:
4551 return false;
4552
4553 // Tell the runtime that this is ARC __weak, called by the
4554 // byref routines.
4555 case Qualifiers::OCL_Weak:
4556 // ARC __strong __block variables need to be retained.
4557 case Qualifiers::OCL_Strong:
4558 return true;
4559 }
4560 llvm_unreachable("fell out of lifetime switch!");
4561 }
4562 return (Ty->isBlockPointerType() || isObjCNSObjectType(Ty) ||
4563 Ty->isObjCObjectPointerType());
Mike Stump94967902009-10-21 18:16:27 +00004564}
4565
Fariborz Jahaniana9d44642012-11-14 17:15:51 +00004566bool ASTContext::getByrefLifetime(QualType Ty,
4567 Qualifiers::ObjCLifetime &LifeTime,
4568 bool &HasByrefExtendedLayout) const {
4569
4570 if (!getLangOpts().ObjC1 ||
4571 getLangOpts().getGC() != LangOptions::NonGC)
4572 return false;
4573
4574 HasByrefExtendedLayout = false;
Fariborz Jahanianf762b722012-12-11 19:58:01 +00004575 if (Ty->isRecordType()) {
Fariborz Jahaniana9d44642012-11-14 17:15:51 +00004576 HasByrefExtendedLayout = true;
4577 LifeTime = Qualifiers::OCL_None;
4578 }
4579 else if (getLangOpts().ObjCAutoRefCount)
4580 LifeTime = Ty.getObjCLifetime();
4581 // MRR.
4582 else if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType())
4583 LifeTime = Qualifiers::OCL_ExplicitNone;
4584 else
4585 LifeTime = Qualifiers::OCL_None;
4586 return true;
4587}
4588
Douglas Gregorbab8a962011-09-08 01:46:34 +00004589TypedefDecl *ASTContext::getObjCInstanceTypeDecl() {
4590 if (!ObjCInstanceTypeDecl)
4591 ObjCInstanceTypeDecl = TypedefDecl::Create(*this,
4592 getTranslationUnitDecl(),
4593 SourceLocation(),
4594 SourceLocation(),
4595 &Idents.get("instancetype"),
4596 getTrivialTypeSourceInfo(getObjCIdType()));
4597 return ObjCInstanceTypeDecl;
4598}
4599
Anders Carlsson18acd442007-10-29 06:33:42 +00004600// This returns true if a type has been typedefed to BOOL:
4601// typedef <type> BOOL;
Chris Lattnere0218992007-10-30 20:27:44 +00004602static bool isTypeTypedefedAsBOOL(QualType T) {
Anders Carlsson18acd442007-10-29 06:33:42 +00004603 if (const TypedefType *TT = dyn_cast<TypedefType>(T))
Chris Lattner9b1f2792008-11-24 03:52:59 +00004604 if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
4605 return II->isStr("BOOL");
Mike Stump11289f42009-09-09 15:08:12 +00004606
Anders Carlssond8499822007-10-29 05:01:08 +00004607 return false;
4608}
4609
Ted Kremenek1b0ea822008-01-07 19:49:32 +00004610/// getObjCEncodingTypeSize returns size of type for objective-c encoding
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004611/// purpose.
Jay Foad39c79802011-01-12 09:06:06 +00004612CharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const {
Douglas Gregora9d84932011-05-27 01:19:52 +00004613 if (!type->isIncompleteArrayType() && type->isIncompleteType())
4614 return CharUnits::Zero();
4615
Ken Dyck40775002010-01-11 17:06:35 +00004616 CharUnits sz = getTypeSizeInChars(type);
Mike Stump11289f42009-09-09 15:08:12 +00004617
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004618 // Make all integer and enum types at least as large as an int
Douglas Gregorb90df602010-06-16 00:17:44 +00004619 if (sz.isPositive() && type->isIntegralOrEnumerationType())
Ken Dyck40775002010-01-11 17:06:35 +00004620 sz = std::max(sz, getTypeSizeInChars(IntTy));
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004621 // Treat arrays as pointers, since that's how they're passed in.
4622 else if (type->isArrayType())
Ken Dyck40775002010-01-11 17:06:35 +00004623 sz = getTypeSizeInChars(VoidPtrTy);
Ken Dyckde37a672010-01-11 19:19:56 +00004624 return sz;
Ken Dyck40775002010-01-11 17:06:35 +00004625}
4626
4627static inline
4628std::string charUnitsToString(const CharUnits &CU) {
4629 return llvm::itostr(CU.getQuantity());
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004630}
4631
John McCall351762c2011-02-07 10:33:21 +00004632/// getObjCEncodingForBlock - Return the encoded type for this block
David Chisnall950a9512009-11-17 19:33:30 +00004633/// declaration.
John McCall351762c2011-02-07 10:33:21 +00004634std::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const {
4635 std::string S;
4636
David Chisnall950a9512009-11-17 19:33:30 +00004637 const BlockDecl *Decl = Expr->getBlockDecl();
4638 QualType BlockTy =
4639 Expr->getType()->getAs<BlockPointerType>()->getPointeeType();
4640 // Encode result type.
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004641 if (getLangOpts().EncodeExtendedBlockSig)
Fariborz Jahanian64223e62012-11-14 23:11:38 +00004642 getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None,
4643 BlockTy->getAs<FunctionType>()->getResultType(),
4644 S, true /*Extended*/);
4645 else
4646 getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getResultType(),
4647 S);
David Chisnall950a9512009-11-17 19:33:30 +00004648 // Compute size of all parameters.
4649 // Start with computing size of a pointer in number of bytes.
4650 // FIXME: There might(should) be a better way of doing this computation!
4651 SourceLocation Loc;
Ken Dyck40775002010-01-11 17:06:35 +00004652 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
4653 CharUnits ParmOffset = PtrSize;
Fariborz Jahanian590c3522010-04-08 18:06:22 +00004654 for (BlockDecl::param_const_iterator PI = Decl->param_begin(),
David Chisnall950a9512009-11-17 19:33:30 +00004655 E = Decl->param_end(); PI != E; ++PI) {
4656 QualType PType = (*PI)->getType();
Ken Dyckde37a672010-01-11 19:19:56 +00004657 CharUnits sz = getObjCEncodingTypeSize(PType);
Fariborz Jahaniand4879412012-06-30 00:48:59 +00004658 if (sz.isZero())
4659 continue;
Ken Dyck40775002010-01-11 17:06:35 +00004660 assert (sz.isPositive() && "BlockExpr - Incomplete param type");
David Chisnall950a9512009-11-17 19:33:30 +00004661 ParmOffset += sz;
4662 }
4663 // Size of the argument frame
Ken Dyck40775002010-01-11 17:06:35 +00004664 S += charUnitsToString(ParmOffset);
David Chisnall950a9512009-11-17 19:33:30 +00004665 // Block pointer and offset.
4666 S += "@?0";
David Chisnall950a9512009-11-17 19:33:30 +00004667
4668 // Argument types.
4669 ParmOffset = PtrSize;
4670 for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E =
4671 Decl->param_end(); PI != E; ++PI) {
4672 ParmVarDecl *PVDecl = *PI;
4673 QualType PType = PVDecl->getOriginalType();
4674 if (const ArrayType *AT =
4675 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
4676 // Use array's original type only if it has known number of
4677 // elements.
4678 if (!isa<ConstantArrayType>(AT))
4679 PType = PVDecl->getType();
4680 } else if (PType->isFunctionType())
4681 PType = PVDecl->getType();
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00004682 if (getLangOpts().EncodeExtendedBlockSig)
Fariborz Jahanian64223e62012-11-14 23:11:38 +00004683 getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, PType,
4684 S, true /*Extended*/);
4685 else
4686 getObjCEncodingForType(PType, S);
Ken Dyck40775002010-01-11 17:06:35 +00004687 S += charUnitsToString(ParmOffset);
Ken Dyckde37a672010-01-11 19:19:56 +00004688 ParmOffset += getObjCEncodingTypeSize(PType);
David Chisnall950a9512009-11-17 19:33:30 +00004689 }
John McCall351762c2011-02-07 10:33:21 +00004690
4691 return S;
David Chisnall950a9512009-11-17 19:33:30 +00004692}
4693
Douglas Gregora9d84932011-05-27 01:19:52 +00004694bool ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl,
David Chisnall50e4eba2010-12-30 14:05:53 +00004695 std::string& S) {
4696 // Encode result type.
4697 getObjCEncodingForType(Decl->getResultType(), S);
4698 CharUnits ParmOffset;
4699 // Compute size of all parameters.
4700 for (FunctionDecl::param_const_iterator PI = Decl->param_begin(),
4701 E = Decl->param_end(); PI != E; ++PI) {
4702 QualType PType = (*PI)->getType();
4703 CharUnits sz = getObjCEncodingTypeSize(PType);
Douglas Gregora9d84932011-05-27 01:19:52 +00004704 if (sz.isZero())
Fariborz Jahanian271b8d42012-06-29 22:54:56 +00004705 continue;
4706
David Chisnall50e4eba2010-12-30 14:05:53 +00004707 assert (sz.isPositive() &&
Douglas Gregora9d84932011-05-27 01:19:52 +00004708 "getObjCEncodingForFunctionDecl - Incomplete param type");
David Chisnall50e4eba2010-12-30 14:05:53 +00004709 ParmOffset += sz;
4710 }
4711 S += charUnitsToString(ParmOffset);
4712 ParmOffset = CharUnits::Zero();
4713
4714 // Argument types.
4715 for (FunctionDecl::param_const_iterator PI = Decl->param_begin(),
4716 E = Decl->param_end(); PI != E; ++PI) {
4717 ParmVarDecl *PVDecl = *PI;
4718 QualType PType = PVDecl->getOriginalType();
4719 if (const ArrayType *AT =
4720 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
4721 // Use array's original type only if it has known number of
4722 // elements.
4723 if (!isa<ConstantArrayType>(AT))
4724 PType = PVDecl->getType();
4725 } else if (PType->isFunctionType())
4726 PType = PVDecl->getType();
4727 getObjCEncodingForType(PType, S);
4728 S += charUnitsToString(ParmOffset);
4729 ParmOffset += getObjCEncodingTypeSize(PType);
4730 }
Douglas Gregora9d84932011-05-27 01:19:52 +00004731
4732 return false;
David Chisnall50e4eba2010-12-30 14:05:53 +00004733}
4734
Bob Wilson5f4e3a72011-11-30 01:57:58 +00004735/// getObjCEncodingForMethodParameter - Return the encoded type for a single
4736/// method parameter or return type. If Extended, include class names and
4737/// block object types.
4738void ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT,
4739 QualType T, std::string& S,
4740 bool Extended) const {
4741 // Encode type qualifer, 'in', 'inout', etc. for the parameter.
4742 getObjCEncodingForTypeQualifier(QT, S);
4743 // Encode parameter type.
4744 getObjCEncodingForTypeImpl(T, S, true, true, 0,
4745 true /*OutermostType*/,
4746 false /*EncodingProperty*/,
4747 false /*StructField*/,
4748 Extended /*EncodeBlockParameters*/,
4749 Extended /*EncodeClassNames*/);
4750}
4751
Ted Kremenek1b0ea822008-01-07 19:49:32 +00004752/// getObjCEncodingForMethodDecl - Return the encoded type for this method
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004753/// declaration.
Douglas Gregora9d84932011-05-27 01:19:52 +00004754bool ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
Bob Wilson5f4e3a72011-11-30 01:57:58 +00004755 std::string& S,
4756 bool Extended) const {
Daniel Dunbar4932b362008-08-28 04:38:10 +00004757 // FIXME: This is not very efficient.
Bob Wilson5f4e3a72011-11-30 01:57:58 +00004758 // Encode return type.
4759 getObjCEncodingForMethodParameter(Decl->getObjCDeclQualifier(),
4760 Decl->getResultType(), S, Extended);
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004761 // Compute size of all parameters.
4762 // Start with computing size of a pointer in number of bytes.
4763 // FIXME: There might(should) be a better way of doing this computation!
4764 SourceLocation Loc;
Ken Dyck40775002010-01-11 17:06:35 +00004765 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004766 // The first two arguments (self and _cmd) are pointers; account for
4767 // their size.
Ken Dyck40775002010-01-11 17:06:35 +00004768 CharUnits ParmOffset = 2 * PtrSize;
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +00004769 for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(),
Fariborz Jahaniand9235db2010-04-08 21:29:11 +00004770 E = Decl->sel_param_end(); PI != E; ++PI) {
Chris Lattnera4997152009-02-20 18:43:26 +00004771 QualType PType = (*PI)->getType();
Ken Dyckde37a672010-01-11 19:19:56 +00004772 CharUnits sz = getObjCEncodingTypeSize(PType);
Douglas Gregora9d84932011-05-27 01:19:52 +00004773 if (sz.isZero())
Fariborz Jahanian271b8d42012-06-29 22:54:56 +00004774 continue;
4775
Ken Dyck40775002010-01-11 17:06:35 +00004776 assert (sz.isPositive() &&
4777 "getObjCEncodingForMethodDecl - Incomplete param type");
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004778 ParmOffset += sz;
4779 }
Ken Dyck40775002010-01-11 17:06:35 +00004780 S += charUnitsToString(ParmOffset);
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004781 S += "@0:";
Ken Dyck40775002010-01-11 17:06:35 +00004782 S += charUnitsToString(PtrSize);
Mike Stump11289f42009-09-09 15:08:12 +00004783
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004784 // Argument types.
4785 ParmOffset = 2 * PtrSize;
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +00004786 for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(),
Fariborz Jahaniand9235db2010-04-08 21:29:11 +00004787 E = Decl->sel_param_end(); PI != E; ++PI) {
Argyrios Kyrtzidisb8c3aaf2011-10-03 06:37:04 +00004788 const ParmVarDecl *PVDecl = *PI;
Mike Stump11289f42009-09-09 15:08:12 +00004789 QualType PType = PVDecl->getOriginalType();
Fariborz Jahaniana0befc02008-12-20 23:29:59 +00004790 if (const ArrayType *AT =
Steve Naroffe4e55d22009-04-14 00:03:58 +00004791 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
4792 // Use array's original type only if it has known number of
4793 // elements.
Steve Naroff323827e2009-04-14 00:40:09 +00004794 if (!isa<ConstantArrayType>(AT))
Steve Naroffe4e55d22009-04-14 00:03:58 +00004795 PType = PVDecl->getType();
4796 } else if (PType->isFunctionType())
4797 PType = PVDecl->getType();
Bob Wilson5f4e3a72011-11-30 01:57:58 +00004798 getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(),
4799 PType, S, Extended);
Ken Dyck40775002010-01-11 17:06:35 +00004800 S += charUnitsToString(ParmOffset);
Ken Dyckde37a672010-01-11 19:19:56 +00004801 ParmOffset += getObjCEncodingTypeSize(PType);
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004802 }
Douglas Gregora9d84932011-05-27 01:19:52 +00004803
4804 return false;
Fariborz Jahanian797f24c2007-10-29 22:57:28 +00004805}
4806
Daniel Dunbar4932b362008-08-28 04:38:10 +00004807/// getObjCEncodingForPropertyDecl - Return the encoded type for this
Fariborz Jahanian2f85a642009-01-20 20:04:12 +00004808/// property declaration. If non-NULL, Container must be either an
Daniel Dunbar4932b362008-08-28 04:38:10 +00004809/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be
4810/// NULL when getting encodings for protocol properties.
Mike Stump11289f42009-09-09 15:08:12 +00004811/// Property attributes are stored as a comma-delimited C string. The simple
4812/// attributes readonly and bycopy are encoded as single characters. The
4813/// parametrized attributes, getter=name, setter=name, and ivar=name, are
4814/// encoded as single characters, followed by an identifier. Property types
4815/// are also encoded as a parametrized attribute. The characters used to encode
Fariborz Jahanian2f85a642009-01-20 20:04:12 +00004816/// these attributes are defined by the following enumeration:
4817/// @code
4818/// enum PropertyAttributes {
4819/// kPropertyReadOnly = 'R', // property is read-only.
4820/// kPropertyBycopy = 'C', // property is a copy of the value last assigned
4821/// kPropertyByref = '&', // property is a reference to the value last assigned
4822/// kPropertyDynamic = 'D', // property is dynamic
4823/// kPropertyGetter = 'G', // followed by getter selector name
4824/// kPropertySetter = 'S', // followed by setter selector name
4825/// kPropertyInstanceVariable = 'V' // followed by instance variable name
Bob Wilson8cf61852012-03-22 17:48:02 +00004826/// kPropertyType = 'T' // followed by old-style type encoding.
Fariborz Jahanian2f85a642009-01-20 20:04:12 +00004827/// kPropertyWeak = 'W' // 'weak' property
4828/// kPropertyStrong = 'P' // property GC'able
4829/// kPropertyNonAtomic = 'N' // property non-atomic
4830/// };
4831/// @endcode
Mike Stump11289f42009-09-09 15:08:12 +00004832void ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
Daniel Dunbar4932b362008-08-28 04:38:10 +00004833 const Decl *Container,
Jay Foad39c79802011-01-12 09:06:06 +00004834 std::string& S) const {
Daniel Dunbar4932b362008-08-28 04:38:10 +00004835 // Collect information from the property implementation decl(s).
4836 bool Dynamic = false;
4837 ObjCPropertyImplDecl *SynthesizePID = 0;
4838
4839 // FIXME: Duplicated code due to poor abstraction.
4840 if (Container) {
Mike Stump11289f42009-09-09 15:08:12 +00004841 if (const ObjCCategoryImplDecl *CID =
Daniel Dunbar4932b362008-08-28 04:38:10 +00004842 dyn_cast<ObjCCategoryImplDecl>(Container)) {
4843 for (ObjCCategoryImplDecl::propimpl_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004844 i = CID->propimpl_begin(), e = CID->propimpl_end();
Douglas Gregor29bd76f2009-04-23 01:02:12 +00004845 i != e; ++i) {
David Blaikie40ed2972012-06-06 20:45:41 +00004846 ObjCPropertyImplDecl *PID = *i;
Daniel Dunbar4932b362008-08-28 04:38:10 +00004847 if (PID->getPropertyDecl() == PD) {
4848 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
4849 Dynamic = true;
4850 } else {
4851 SynthesizePID = PID;
4852 }
4853 }
4854 }
4855 } else {
Chris Lattner465fa322008-10-05 17:34:18 +00004856 const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container);
Daniel Dunbar4932b362008-08-28 04:38:10 +00004857 for (ObjCCategoryImplDecl::propimpl_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00004858 i = OID->propimpl_begin(), e = OID->propimpl_end();
Douglas Gregor29bd76f2009-04-23 01:02:12 +00004859 i != e; ++i) {
David Blaikie40ed2972012-06-06 20:45:41 +00004860 ObjCPropertyImplDecl *PID = *i;
Daniel Dunbar4932b362008-08-28 04:38:10 +00004861 if (PID->getPropertyDecl() == PD) {
4862 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
4863 Dynamic = true;
4864 } else {
4865 SynthesizePID = PID;
4866 }
4867 }
Mike Stump11289f42009-09-09 15:08:12 +00004868 }
Daniel Dunbar4932b362008-08-28 04:38:10 +00004869 }
4870 }
4871
4872 // FIXME: This is not very efficient.
4873 S = "T";
4874
4875 // Encode result type.
Fariborz Jahanian218c6302009-01-20 19:14:18 +00004876 // GCC has some special rules regarding encoding of properties which
4877 // closely resembles encoding of ivars.
Mike Stump11289f42009-09-09 15:08:12 +00004878 getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0,
Fariborz Jahanian218c6302009-01-20 19:14:18 +00004879 true /* outermost type */,
4880 true /* encoding for property */);
Daniel Dunbar4932b362008-08-28 04:38:10 +00004881
4882 if (PD->isReadOnly()) {
4883 S += ",R";
4884 } else {
4885 switch (PD->getSetterKind()) {
4886 case ObjCPropertyDecl::Assign: break;
4887 case ObjCPropertyDecl::Copy: S += ",C"; break;
Mike Stump11289f42009-09-09 15:08:12 +00004888 case ObjCPropertyDecl::Retain: S += ",&"; break;
Fariborz Jahanian70a315c2011-08-12 20:47:08 +00004889 case ObjCPropertyDecl::Weak: S += ",W"; break;
Daniel Dunbar4932b362008-08-28 04:38:10 +00004890 }
4891 }
4892
4893 // It really isn't clear at all what this means, since properties
4894 // are "dynamic by default".
4895 if (Dynamic)
4896 S += ",D";
4897
Fariborz Jahanian218c6302009-01-20 19:14:18 +00004898 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
4899 S += ",N";
Mike Stump11289f42009-09-09 15:08:12 +00004900
Daniel Dunbar4932b362008-08-28 04:38:10 +00004901 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
4902 S += ",G";
Chris Lattnere4b95692008-11-24 03:33:13 +00004903 S += PD->getGetterName().getAsString();
Daniel Dunbar4932b362008-08-28 04:38:10 +00004904 }
4905
4906 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
4907 S += ",S";
Chris Lattnere4b95692008-11-24 03:33:13 +00004908 S += PD->getSetterName().getAsString();
Daniel Dunbar4932b362008-08-28 04:38:10 +00004909 }
4910
4911 if (SynthesizePID) {
4912 const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
4913 S += ",V";
Chris Lattner1cbaacc2008-11-24 04:00:27 +00004914 S += OID->getNameAsString();
Daniel Dunbar4932b362008-08-28 04:38:10 +00004915 }
4916
4917 // FIXME: OBJCGC: weak & strong
4918}
4919
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00004920/// getLegacyIntegralTypeEncoding -
Mike Stump11289f42009-09-09 15:08:12 +00004921/// Another legacy compatibility encoding: 32-bit longs are encoded as
4922/// 'l' or 'L' , but not always. For typedefs, we need to use
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00004923/// 'i' or 'I' instead if encoding a struct field, or a pointer!
4924///
4925void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const {
Mike Stump212005c2009-07-22 18:58:19 +00004926 if (isa<TypedefType>(PointeeTy.getTypePtr())) {
John McCall9dd450b2009-09-21 23:43:11 +00004927 if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) {
Jay Foad39c79802011-01-12 09:06:06 +00004928 if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32)
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00004929 PointeeTy = UnsignedIntTy;
Mike Stump11289f42009-09-09 15:08:12 +00004930 else
Jay Foad39c79802011-01-12 09:06:06 +00004931 if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32)
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00004932 PointeeTy = IntTy;
4933 }
4934 }
4935}
4936
Fariborz Jahanian0a71ad22008-01-22 22:44:46 +00004937void ASTContext::getObjCEncodingForType(QualType T, std::string& S,
Jay Foad39c79802011-01-12 09:06:06 +00004938 const FieldDecl *Field) const {
Daniel Dunbar3cd9a292008-10-17 07:30:50 +00004939 // We follow the behavior of gcc, expanding structures which are
4940 // directly pointed to, and expanding embedded structures. Note that
4941 // these rules are sufficient to prevent recursive encoding of the
4942 // same type.
Mike Stump11289f42009-09-09 15:08:12 +00004943 getObjCEncodingForTypeImpl(T, S, true, true, Field,
Fariborz Jahaniandaef00b2008-12-22 23:22:27 +00004944 true /* outermost type */);
Daniel Dunbar3cd9a292008-10-17 07:30:50 +00004945}
4946
John McCall393a78d2012-12-20 02:45:14 +00004947static char getObjCEncodingForPrimitiveKind(const ASTContext *C,
4948 BuiltinType::Kind kind) {
4949 switch (kind) {
David Chisnallb190a2c2010-06-04 01:10:52 +00004950 case BuiltinType::Void: return 'v';
4951 case BuiltinType::Bool: return 'B';
4952 case BuiltinType::Char_U:
4953 case BuiltinType::UChar: return 'C';
John McCall393a78d2012-12-20 02:45:14 +00004954 case BuiltinType::Char16:
David Chisnallb190a2c2010-06-04 01:10:52 +00004955 case BuiltinType::UShort: return 'S';
John McCall393a78d2012-12-20 02:45:14 +00004956 case BuiltinType::Char32:
David Chisnallb190a2c2010-06-04 01:10:52 +00004957 case BuiltinType::UInt: return 'I';
4958 case BuiltinType::ULong:
John McCall393a78d2012-12-20 02:45:14 +00004959 return C->getTargetInfo().getLongWidth() == 32 ? 'L' : 'Q';
David Chisnallb190a2c2010-06-04 01:10:52 +00004960 case BuiltinType::UInt128: return 'T';
4961 case BuiltinType::ULongLong: return 'Q';
4962 case BuiltinType::Char_S:
4963 case BuiltinType::SChar: return 'c';
4964 case BuiltinType::Short: return 's';
Chris Lattnerad3467e2010-12-25 23:25:43 +00004965 case BuiltinType::WChar_S:
4966 case BuiltinType::WChar_U:
David Chisnallb190a2c2010-06-04 01:10:52 +00004967 case BuiltinType::Int: return 'i';
4968 case BuiltinType::Long:
John McCall393a78d2012-12-20 02:45:14 +00004969 return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
David Chisnallb190a2c2010-06-04 01:10:52 +00004970 case BuiltinType::LongLong: return 'q';
4971 case BuiltinType::Int128: return 't';
4972 case BuiltinType::Float: return 'f';
4973 case BuiltinType::Double: return 'd';
Daniel Dunbar7cba5a72010-10-11 21:13:48 +00004974 case BuiltinType::LongDouble: return 'D';
John McCall393a78d2012-12-20 02:45:14 +00004975 case BuiltinType::NullPtr: return '*'; // like char*
4976
4977 case BuiltinType::Half:
4978 // FIXME: potentially need @encodes for these!
4979 return ' ';
4980
4981 case BuiltinType::ObjCId:
4982 case BuiltinType::ObjCClass:
4983 case BuiltinType::ObjCSel:
4984 llvm_unreachable("@encoding ObjC primitive type");
4985
4986 // OpenCL and placeholder types don't need @encodings.
4987 case BuiltinType::OCLImage1d:
4988 case BuiltinType::OCLImage1dArray:
4989 case BuiltinType::OCLImage1dBuffer:
4990 case BuiltinType::OCLImage2d:
4991 case BuiltinType::OCLImage2dArray:
4992 case BuiltinType::OCLImage3d:
Guy Benyei1b4fb3e2013-01-20 12:31:11 +00004993 case BuiltinType::OCLEvent:
Guy Benyei61054192013-02-07 10:55:47 +00004994 case BuiltinType::OCLSampler:
John McCall393a78d2012-12-20 02:45:14 +00004995 case BuiltinType::Dependent:
4996#define BUILTIN_TYPE(KIND, ID)
4997#define PLACEHOLDER_TYPE(KIND, ID) \
4998 case BuiltinType::KIND:
4999#include "clang/AST/BuiltinTypes.def"
5000 llvm_unreachable("invalid builtin type for @encode");
David Chisnallb190a2c2010-06-04 01:10:52 +00005001 }
David Blaikie5a6a0202013-01-09 17:48:41 +00005002 llvm_unreachable("invalid BuiltinType::Kind value");
David Chisnallb190a2c2010-06-04 01:10:52 +00005003}
5004
Douglas Gregor8b7d4032011-09-08 17:18:35 +00005005static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) {
5006 EnumDecl *Enum = ET->getDecl();
5007
5008 // The encoding of an non-fixed enum type is always 'i', regardless of size.
5009 if (!Enum->isFixed())
5010 return 'i';
5011
5012 // The encoding of a fixed enum type matches its fixed underlying type.
John McCall393a78d2012-12-20 02:45:14 +00005013 const BuiltinType *BT = Enum->getIntegerType()->castAs<BuiltinType>();
5014 return getObjCEncodingForPrimitiveKind(C, BT->getKind());
Douglas Gregor8b7d4032011-09-08 17:18:35 +00005015}
5016
Jay Foad39c79802011-01-12 09:06:06 +00005017static void EncodeBitField(const ASTContext *Ctx, std::string& S,
David Chisnallb190a2c2010-06-04 01:10:52 +00005018 QualType T, const FieldDecl *FD) {
Richard Smithcaf33902011-10-10 18:28:20 +00005019 assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl");
Fariborz Jahanian5c767722009-01-13 01:18:13 +00005020 S += 'b';
David Chisnallb190a2c2010-06-04 01:10:52 +00005021 // The NeXT runtime encodes bit fields as b followed by the number of bits.
5022 // The GNU runtime requires more information; bitfields are encoded as b,
5023 // then the offset (in bits) of the first element, then the type of the
5024 // bitfield, then the size in bits. For example, in this structure:
5025 //
5026 // struct
5027 // {
5028 // int integer;
5029 // int flags:2;
5030 // };
5031 // On a 32-bit system, the encoding for flags would be b2 for the NeXT
5032 // runtime, but b32i2 for the GNU runtime. The reason for this extra
5033 // information is not especially sensible, but we're stuck with it for
5034 // compatibility with GCC, although providing it breaks anything that
5035 // actually uses runtime introspection and wants to work on both runtimes...
John McCall5fb5df92012-06-20 06:18:46 +00005036 if (Ctx->getLangOpts().ObjCRuntime.isGNUFamily()) {
David Chisnallb190a2c2010-06-04 01:10:52 +00005037 const RecordDecl *RD = FD->getParent();
5038 const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD);
Eli Friedmana3c122d2011-07-07 01:54:01 +00005039 S += llvm::utostr(RL.getFieldOffset(FD->getFieldIndex()));
Douglas Gregor8b7d4032011-09-08 17:18:35 +00005040 if (const EnumType *ET = T->getAs<EnumType>())
5041 S += ObjCEncodingForEnumType(Ctx, ET);
John McCall393a78d2012-12-20 02:45:14 +00005042 else {
5043 const BuiltinType *BT = T->castAs<BuiltinType>();
5044 S += getObjCEncodingForPrimitiveKind(Ctx, BT->getKind());
5045 }
David Chisnallb190a2c2010-06-04 01:10:52 +00005046 }
Richard Smithcaf33902011-10-10 18:28:20 +00005047 S += llvm::utostr(FD->getBitWidthValue(*Ctx));
Fariborz Jahanian5c767722009-01-13 01:18:13 +00005048}
5049
Daniel Dunbar07d07852009-10-18 21:17:35 +00005050// FIXME: Use SmallString for accumulating string.
Daniel Dunbar3cd9a292008-10-17 07:30:50 +00005051void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S,
5052 bool ExpandPointedToStructures,
5053 bool ExpandStructures,
Daniel Dunbarc040ce42009-04-20 06:37:24 +00005054 const FieldDecl *FD,
Fariborz Jahanian218c6302009-01-20 19:14:18 +00005055 bool OutermostType,
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005056 bool EncodingProperty,
Bob Wilson5f4e3a72011-11-30 01:57:58 +00005057 bool StructField,
5058 bool EncodeBlockParameters,
Fariborz Jahaniand4c1a202013-02-15 21:14:50 +00005059 bool EncodeClassNames,
5060 bool EncodePointerToObjCTypedef) const {
John McCall393a78d2012-12-20 02:45:14 +00005061 CanQualType CT = getCanonicalType(T);
5062 switch (CT->getTypeClass()) {
5063 case Type::Builtin:
5064 case Type::Enum:
Chris Lattnere7cabb92009-07-13 00:10:46 +00005065 if (FD && FD->isBitField())
David Chisnallb190a2c2010-06-04 01:10:52 +00005066 return EncodeBitField(this, S, T, FD);
John McCall393a78d2012-12-20 02:45:14 +00005067 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CT))
5068 S += getObjCEncodingForPrimitiveKind(this, BT->getKind());
5069 else
5070 S += ObjCEncodingForEnumType(this, cast<EnumType>(CT));
Chris Lattnere7cabb92009-07-13 00:10:46 +00005071 return;
Mike Stump11289f42009-09-09 15:08:12 +00005072
John McCall393a78d2012-12-20 02:45:14 +00005073 case Type::Complex: {
5074 const ComplexType *CT = T->castAs<ComplexType>();
Anders Carlsson39b2e132009-04-09 21:55:45 +00005075 S += 'j';
Mike Stump11289f42009-09-09 15:08:12 +00005076 getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false,
Anders Carlsson39b2e132009-04-09 21:55:45 +00005077 false);
Chris Lattnere7cabb92009-07-13 00:10:46 +00005078 return;
5079 }
John McCall393a78d2012-12-20 02:45:14 +00005080
5081 case Type::Atomic: {
5082 const AtomicType *AT = T->castAs<AtomicType>();
5083 S += 'A';
5084 getObjCEncodingForTypeImpl(AT->getValueType(), S, false, false, 0,
5085 false, false);
5086 return;
Fariborz Jahanian9ffd7062010-04-13 23:45:47 +00005087 }
John McCall393a78d2012-12-20 02:45:14 +00005088
5089 // encoding for pointer or reference types.
5090 case Type::Pointer:
5091 case Type::LValueReference:
5092 case Type::RValueReference: {
5093 QualType PointeeTy;
5094 if (isa<PointerType>(CT)) {
5095 const PointerType *PT = T->castAs<PointerType>();
5096 if (PT->isObjCSelType()) {
5097 S += ':';
5098 return;
5099 }
5100 PointeeTy = PT->getPointeeType();
5101 } else {
5102 PointeeTy = T->castAs<ReferenceType>()->getPointeeType();
5103 }
5104
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00005105 bool isReadOnly = false;
5106 // For historical/compatibility reasons, the read-only qualifier of the
5107 // pointee gets emitted _before_ the '^'. The read-only qualifier of
5108 // the pointer itself gets ignored, _unless_ we are looking at a typedef!
Mike Stump11289f42009-09-09 15:08:12 +00005109 // Also, do not emit the 'r' for anything but the outermost type!
Mike Stump212005c2009-07-22 18:58:19 +00005110 if (isa<TypedefType>(T.getTypePtr())) {
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00005111 if (OutermostType && T.isConstQualified()) {
5112 isReadOnly = true;
5113 S += 'r';
5114 }
Mike Stumpe9c6ffc2009-07-31 02:02:20 +00005115 } else if (OutermostType) {
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00005116 QualType P = PointeeTy;
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005117 while (P->getAs<PointerType>())
5118 P = P->getAs<PointerType>()->getPointeeType();
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00005119 if (P.isConstQualified()) {
5120 isReadOnly = true;
5121 S += 'r';
5122 }
5123 }
5124 if (isReadOnly) {
5125 // Another legacy compatibility encoding. Some ObjC qualifier and type
5126 // combinations need to be rearranged.
5127 // Rewrite "in const" from "nr" to "rn"
Chris Lattner0e62c1c2011-07-23 10:55:15 +00005128 if (StringRef(S).endswith("nr"))
Benjamin Kramer2e3197e2010-04-27 17:12:11 +00005129 S.replace(S.end()-2, S.end(), "rn");
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00005130 }
Mike Stump11289f42009-09-09 15:08:12 +00005131
Anders Carlssond8499822007-10-29 05:01:08 +00005132 if (PointeeTy->isCharType()) {
5133 // char pointer types should be encoded as '*' unless it is a
5134 // type that has been typedef'd to 'BOOL'.
Anders Carlsson18acd442007-10-29 06:33:42 +00005135 if (!isTypeTypedefedAsBOOL(PointeeTy)) {
Anders Carlssond8499822007-10-29 05:01:08 +00005136 S += '*';
5137 return;
5138 }
Ted Kremenekc23c7e62009-07-29 21:53:49 +00005139 } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) {
Steve Naroff3de6b702009-07-22 17:14:51 +00005140 // GCC binary compat: Need to convert "struct objc_class *" to "#".
5141 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
5142 S += '#';
5143 return;
5144 }
5145 // GCC binary compat: Need to convert "struct objc_object *" to "@".
5146 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
5147 S += '@';
5148 return;
5149 }
5150 // fall through...
Anders Carlssond8499822007-10-29 05:01:08 +00005151 }
Anders Carlssond8499822007-10-29 05:01:08 +00005152 S += '^';
Fariborz Jahanian0f66a6c2008-12-23 19:56:47 +00005153 getLegacyIntegralTypeEncoding(PointeeTy);
5154
Mike Stump11289f42009-09-09 15:08:12 +00005155 getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures,
Fariborz Jahanian1d35f122008-12-19 23:34:38 +00005156 NULL);
Chris Lattnere7cabb92009-07-13 00:10:46 +00005157 return;
5158 }
John McCall393a78d2012-12-20 02:45:14 +00005159
5160 case Type::ConstantArray:
5161 case Type::IncompleteArray:
5162 case Type::VariableArray: {
5163 const ArrayType *AT = cast<ArrayType>(CT);
5164
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005165 if (isa<IncompleteArrayType>(AT) && !StructField) {
Anders Carlssond05f44b2009-02-22 01:38:57 +00005166 // Incomplete arrays are encoded as a pointer to the array element.
5167 S += '^';
5168
Mike Stump11289f42009-09-09 15:08:12 +00005169 getObjCEncodingForTypeImpl(AT->getElementType(), S,
Anders Carlssond05f44b2009-02-22 01:38:57 +00005170 false, ExpandStructures, FD);
5171 } else {
5172 S += '[';
Mike Stump11289f42009-09-09 15:08:12 +00005173
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005174 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) {
5175 if (getTypeSize(CAT->getElementType()) == 0)
5176 S += '0';
5177 else
5178 S += llvm::utostr(CAT->getSize().getZExtValue());
5179 } else {
Anders Carlssond05f44b2009-02-22 01:38:57 +00005180 //Variable length arrays are encoded as a regular array with 0 elements.
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005181 assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) &&
5182 "Unknown array type!");
Anders Carlssond05f44b2009-02-22 01:38:57 +00005183 S += '0';
5184 }
Mike Stump11289f42009-09-09 15:08:12 +00005185
5186 getObjCEncodingForTypeImpl(AT->getElementType(), S,
Anders Carlssond05f44b2009-02-22 01:38:57 +00005187 false, ExpandStructures, FD);
5188 S += ']';
5189 }
Chris Lattnere7cabb92009-07-13 00:10:46 +00005190 return;
5191 }
Mike Stump11289f42009-09-09 15:08:12 +00005192
John McCall393a78d2012-12-20 02:45:14 +00005193 case Type::FunctionNoProto:
5194 case Type::FunctionProto:
Anders Carlssondf4cc612007-10-30 00:06:20 +00005195 S += '?';
Chris Lattnere7cabb92009-07-13 00:10:46 +00005196 return;
Mike Stump11289f42009-09-09 15:08:12 +00005197
John McCall393a78d2012-12-20 02:45:14 +00005198 case Type::Record: {
5199 RecordDecl *RDecl = cast<RecordType>(CT)->getDecl();
Daniel Dunbarff3c6742008-10-17 16:17:37 +00005200 S += RDecl->isUnion() ? '(' : '{';
Daniel Dunbar40cac772008-10-17 06:22:57 +00005201 // Anonymous structures print as '?'
5202 if (const IdentifierInfo *II = RDecl->getIdentifier()) {
5203 S += II->getName();
Fariborz Jahanianc5158202010-05-07 00:28:49 +00005204 if (ClassTemplateSpecializationDecl *Spec
5205 = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
5206 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
Benjamin Kramer9170e912013-02-22 15:46:01 +00005207 llvm::raw_string_ostream OS(S);
5208 TemplateSpecializationType::PrintTemplateArgumentList(OS,
Douglas Gregor1ccc8412010-11-07 23:05:16 +00005209 TemplateArgs.data(),
5210 TemplateArgs.size(),
Douglas Gregorc0b07282011-09-27 22:38:19 +00005211 (*this).getPrintingPolicy());
Fariborz Jahanianc5158202010-05-07 00:28:49 +00005212 }
Daniel Dunbar40cac772008-10-17 06:22:57 +00005213 } else {
5214 S += '?';
5215 }
Daniel Dunbarfc1066d2008-10-17 20:21:44 +00005216 if (ExpandStructures) {
Fariborz Jahanian0a71ad22008-01-22 22:44:46 +00005217 S += '=';
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005218 if (!RDecl->isUnion()) {
5219 getObjCEncodingForStructureImpl(RDecl, S, FD);
5220 } else {
5221 for (RecordDecl::field_iterator Field = RDecl->field_begin(),
5222 FieldEnd = RDecl->field_end();
5223 Field != FieldEnd; ++Field) {
5224 if (FD) {
5225 S += '"';
5226 S += Field->getNameAsString();
5227 S += '"';
5228 }
Mike Stump11289f42009-09-09 15:08:12 +00005229
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005230 // Special case bit-fields.
5231 if (Field->isBitField()) {
5232 getObjCEncodingForTypeImpl(Field->getType(), S, false, true,
David Blaikie40ed2972012-06-06 20:45:41 +00005233 *Field);
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005234 } else {
5235 QualType qt = Field->getType();
5236 getLegacyIntegralTypeEncoding(qt);
5237 getObjCEncodingForTypeImpl(qt, S, false, true,
5238 FD, /*OutermostType*/false,
5239 /*EncodingProperty*/false,
5240 /*StructField*/true);
5241 }
Daniel Dunbarff3c6742008-10-17 16:17:37 +00005242 }
Fariborz Jahanian0a71ad22008-01-22 22:44:46 +00005243 }
Fariborz Jahanianbc92fd72007-11-13 23:21:38 +00005244 }
Daniel Dunbarff3c6742008-10-17 16:17:37 +00005245 S += RDecl->isUnion() ? ')' : '}';
Chris Lattnere7cabb92009-07-13 00:10:46 +00005246 return;
5247 }
Mike Stump11289f42009-09-09 15:08:12 +00005248
John McCall393a78d2012-12-20 02:45:14 +00005249 case Type::BlockPointer: {
5250 const BlockPointerType *BT = T->castAs<BlockPointerType>();
Steve Naroff49140cb2009-02-02 18:24:29 +00005251 S += "@?"; // Unlike a pointer-to-function, which is "^?".
Bob Wilson5f4e3a72011-11-30 01:57:58 +00005252 if (EncodeBlockParameters) {
John McCall393a78d2012-12-20 02:45:14 +00005253 const FunctionType *FT = BT->getPointeeType()->castAs<FunctionType>();
Bob Wilson5f4e3a72011-11-30 01:57:58 +00005254
5255 S += '<';
5256 // Block return type
5257 getObjCEncodingForTypeImpl(FT->getResultType(), S,
5258 ExpandPointedToStructures, ExpandStructures,
5259 FD,
5260 false /* OutermostType */,
5261 EncodingProperty,
5262 false /* StructField */,
5263 EncodeBlockParameters,
5264 EncodeClassNames);
5265 // Block self
5266 S += "@?";
5267 // Block parameters
5268 if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT)) {
5269 for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(),
5270 E = FPT->arg_type_end(); I && (I != E); ++I) {
5271 getObjCEncodingForTypeImpl(*I, S,
5272 ExpandPointedToStructures,
5273 ExpandStructures,
5274 FD,
5275 false /* OutermostType */,
5276 EncodingProperty,
5277 false /* StructField */,
5278 EncodeBlockParameters,
5279 EncodeClassNames);
5280 }
5281 }
5282 S += '>';
5283 }
Chris Lattnere7cabb92009-07-13 00:10:46 +00005284 return;
5285 }
Mike Stump11289f42009-09-09 15:08:12 +00005286
John McCall393a78d2012-12-20 02:45:14 +00005287 case Type::ObjCObject:
5288 case Type::ObjCInterface: {
5289 // Ignore protocol qualifiers when mangling at this level.
5290 T = T->castAs<ObjCObjectType>()->getBaseType();
John McCall8b07ec22010-05-15 11:32:37 +00005291
John McCall393a78d2012-12-20 02:45:14 +00005292 // The assumption seems to be that this assert will succeed
5293 // because nested levels will have filtered out 'id' and 'Class'.
5294 const ObjCInterfaceType *OIT = T->castAs<ObjCInterfaceType>();
Fariborz Jahanian1d35f122008-12-19 23:34:38 +00005295 // @encode(class_name)
John McCall8ccfcb52009-09-24 19:53:00 +00005296 ObjCInterfaceDecl *OI = OIT->getDecl();
Fariborz Jahanian1d35f122008-12-19 23:34:38 +00005297 S += '{';
5298 const IdentifierInfo *II = OI->getIdentifier();
5299 S += II->getName();
5300 S += '=';
Jordy Rosea91768e2011-07-22 02:08:32 +00005301 SmallVector<const ObjCIvarDecl*, 32> Ivars;
Fariborz Jahaniana50b3a22010-08-20 21:21:08 +00005302 DeepCollectObjCIvars(OI, true, Ivars);
5303 for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
Jordy Rosea91768e2011-07-22 02:08:32 +00005304 const FieldDecl *Field = cast<FieldDecl>(Ivars[i]);
Fariborz Jahaniana50b3a22010-08-20 21:21:08 +00005305 if (Field->isBitField())
5306 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field);
Fariborz Jahanian1d35f122008-12-19 23:34:38 +00005307 else
Fariborz Jahaniand4c1a202013-02-15 21:14:50 +00005308 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD,
5309 false, false, false, false, false,
5310 EncodePointerToObjCTypedef);
Fariborz Jahanian1d35f122008-12-19 23:34:38 +00005311 }
5312 S += '}';
Chris Lattnere7cabb92009-07-13 00:10:46 +00005313 return;
Fariborz Jahanian1d35f122008-12-19 23:34:38 +00005314 }
Mike Stump11289f42009-09-09 15:08:12 +00005315
John McCall393a78d2012-12-20 02:45:14 +00005316 case Type::ObjCObjectPointer: {
5317 const ObjCObjectPointerType *OPT = T->castAs<ObjCObjectPointerType>();
Steve Naroff7cae42b2009-07-10 23:34:53 +00005318 if (OPT->isObjCIdType()) {
5319 S += '@';
5320 return;
Chris Lattnere7cabb92009-07-13 00:10:46 +00005321 }
Mike Stump11289f42009-09-09 15:08:12 +00005322
Steve Narofff0c86112009-10-28 22:03:49 +00005323 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
5324 // FIXME: Consider if we need to output qualifiers for 'Class<p>'.
5325 // Since this is a binary compatibility issue, need to consult with runtime
5326 // folks. Fortunately, this is a *very* obsure construct.
Steve Naroff7cae42b2009-07-10 23:34:53 +00005327 S += '#';
5328 return;
Chris Lattnere7cabb92009-07-13 00:10:46 +00005329 }
Mike Stump11289f42009-09-09 15:08:12 +00005330
Chris Lattnere7cabb92009-07-13 00:10:46 +00005331 if (OPT->isObjCQualifiedIdType()) {
Mike Stump11289f42009-09-09 15:08:12 +00005332 getObjCEncodingForTypeImpl(getObjCIdType(), S,
Steve Naroff7cae42b2009-07-10 23:34:53 +00005333 ExpandPointedToStructures,
5334 ExpandStructures, FD);
Bob Wilson5f4e3a72011-11-30 01:57:58 +00005335 if (FD || EncodingProperty || EncodeClassNames) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00005336 // Note that we do extended encoding of protocol qualifer list
5337 // Only when doing ivar or property encoding.
Steve Naroff7cae42b2009-07-10 23:34:53 +00005338 S += '"';
Steve Naroffaccc4882009-07-20 17:56:53 +00005339 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
5340 E = OPT->qual_end(); I != E; ++I) {
Steve Naroff7cae42b2009-07-10 23:34:53 +00005341 S += '<';
5342 S += (*I)->getNameAsString();
5343 S += '>';
5344 }
5345 S += '"';
5346 }
5347 return;
Chris Lattnere7cabb92009-07-13 00:10:46 +00005348 }
Mike Stump11289f42009-09-09 15:08:12 +00005349
Chris Lattnere7cabb92009-07-13 00:10:46 +00005350 QualType PointeeTy = OPT->getPointeeType();
5351 if (!EncodingProperty &&
Fariborz Jahaniand4c1a202013-02-15 21:14:50 +00005352 isa<TypedefType>(PointeeTy.getTypePtr()) &&
5353 !EncodePointerToObjCTypedef) {
Chris Lattnere7cabb92009-07-13 00:10:46 +00005354 // Another historical/compatibility reason.
Mike Stump11289f42009-09-09 15:08:12 +00005355 // We encode the underlying type which comes out as
Chris Lattnere7cabb92009-07-13 00:10:46 +00005356 // {...};
5357 S += '^';
Mike Stump11289f42009-09-09 15:08:12 +00005358 getObjCEncodingForTypeImpl(PointeeTy, S,
5359 false, ExpandPointedToStructures,
Fariborz Jahaniand4c1a202013-02-15 21:14:50 +00005360 NULL,
5361 false, false, false, false, false,
5362 /*EncodePointerToObjCTypedef*/true);
Steve Naroff7cae42b2009-07-10 23:34:53 +00005363 return;
5364 }
Chris Lattnere7cabb92009-07-13 00:10:46 +00005365
5366 S += '@';
Bob Wilson5f4e3a72011-11-30 01:57:58 +00005367 if (OPT->getInterfaceDecl() &&
5368 (FD || EncodingProperty || EncodeClassNames)) {
Chris Lattnere7cabb92009-07-13 00:10:46 +00005369 S += '"';
Steve Narofff0c86112009-10-28 22:03:49 +00005370 S += OPT->getInterfaceDecl()->getIdentifier()->getName();
Steve Naroffaccc4882009-07-20 17:56:53 +00005371 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
5372 E = OPT->qual_end(); I != E; ++I) {
Chris Lattnere7cabb92009-07-13 00:10:46 +00005373 S += '<';
5374 S += (*I)->getNameAsString();
5375 S += '>';
Mike Stump11289f42009-09-09 15:08:12 +00005376 }
Chris Lattnere7cabb92009-07-13 00:10:46 +00005377 S += '"';
5378 }
5379 return;
5380 }
Mike Stump11289f42009-09-09 15:08:12 +00005381
John McCalla9e6e8d2010-05-17 23:56:34 +00005382 // gcc just blithely ignores member pointers.
John McCall393a78d2012-12-20 02:45:14 +00005383 // FIXME: we shoul do better than that. 'M' is available.
5384 case Type::MemberPointer:
John McCalla9e6e8d2010-05-17 23:56:34 +00005385 return;
Fariborz Jahaniane0587be2010-10-07 21:25:25 +00005386
John McCall393a78d2012-12-20 02:45:14 +00005387 case Type::Vector:
5388 case Type::ExtVector:
Fariborz Jahaniane0587be2010-10-07 21:25:25 +00005389 // This matches gcc's encoding, even though technically it is
5390 // insufficient.
5391 // FIXME. We should do a better job than gcc.
5392 return;
John McCall393a78d2012-12-20 02:45:14 +00005393
Richard Smith27d807c2013-04-30 13:56:41 +00005394 case Type::Auto:
5395 // We could see an undeduced auto type here during error recovery.
5396 // Just ignore it.
5397 return;
5398
John McCall393a78d2012-12-20 02:45:14 +00005399#define ABSTRACT_TYPE(KIND, BASE)
5400#define TYPE(KIND, BASE)
5401#define DEPENDENT_TYPE(KIND, BASE) \
5402 case Type::KIND:
5403#define NON_CANONICAL_TYPE(KIND, BASE) \
5404 case Type::KIND:
5405#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \
5406 case Type::KIND:
5407#include "clang/AST/TypeNodes.def"
5408 llvm_unreachable("@encode for dependent type!");
Fariborz Jahaniane0587be2010-10-07 21:25:25 +00005409 }
John McCall393a78d2012-12-20 02:45:14 +00005410 llvm_unreachable("bad type kind!");
Anders Carlssond8499822007-10-29 05:01:08 +00005411}
5412
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005413void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl,
5414 std::string &S,
5415 const FieldDecl *FD,
5416 bool includeVBases) const {
5417 assert(RDecl && "Expected non-null RecordDecl");
5418 assert(!RDecl->isUnion() && "Should not be called for unions");
5419 if (!RDecl->getDefinition())
5420 return;
5421
5422 CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
5423 std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;
5424 const ASTRecordLayout &layout = getASTRecordLayout(RDecl);
5425
5426 if (CXXRec) {
5427 for (CXXRecordDecl::base_class_iterator
5428 BI = CXXRec->bases_begin(),
5429 BE = CXXRec->bases_end(); BI != BE; ++BI) {
5430 if (!BI->isVirtual()) {
5431 CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl();
Argyrios Kyrtzidis95a76f32011-06-17 23:19:38 +00005432 if (base->isEmpty())
5433 continue;
Benjamin Kramer2ef30312012-07-04 18:45:14 +00005434 uint64_t offs = toBits(layout.getBaseClassOffset(base));
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005435 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
5436 std::make_pair(offs, base));
5437 }
5438 }
5439 }
5440
5441 unsigned i = 0;
5442 for (RecordDecl::field_iterator Field = RDecl->field_begin(),
5443 FieldEnd = RDecl->field_end();
5444 Field != FieldEnd; ++Field, ++i) {
5445 uint64_t offs = layout.getFieldOffset(i);
5446 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
David Blaikie40ed2972012-06-06 20:45:41 +00005447 std::make_pair(offs, *Field));
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005448 }
5449
5450 if (CXXRec && includeVBases) {
5451 for (CXXRecordDecl::base_class_iterator
5452 BI = CXXRec->vbases_begin(),
5453 BE = CXXRec->vbases_end(); BI != BE; ++BI) {
5454 CXXRecordDecl *base = BI->getType()->getAsCXXRecordDecl();
Argyrios Kyrtzidis95a76f32011-06-17 23:19:38 +00005455 if (base->isEmpty())
5456 continue;
Benjamin Kramer2ef30312012-07-04 18:45:14 +00005457 uint64_t offs = toBits(layout.getVBaseClassOffset(base));
Argyrios Kyrtzidis81c0b5c2011-09-26 18:14:24 +00005458 if (FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end())
5459 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(),
5460 std::make_pair(offs, base));
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005461 }
5462 }
5463
5464 CharUnits size;
5465 if (CXXRec) {
5466 size = includeVBases ? layout.getSize() : layout.getNonVirtualSize();
5467 } else {
5468 size = layout.getSize();
5469 }
5470
5471 uint64_t CurOffs = 0;
5472 std::multimap<uint64_t, NamedDecl *>::iterator
5473 CurLayObj = FieldOrBaseOffsets.begin();
5474
Douglas Gregorf5d6c742012-04-27 22:30:01 +00005475 if (CXXRec && CXXRec->isDynamicClass() &&
5476 (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005477 if (FD) {
5478 S += "\"_vptr$";
5479 std::string recname = CXXRec->getNameAsString();
5480 if (recname.empty()) recname = "?";
5481 S += recname;
5482 S += '"';
5483 }
5484 S += "^^?";
5485 CurOffs += getTypeSize(VoidPtrTy);
5486 }
5487
5488 if (!RDecl->hasFlexibleArrayMember()) {
5489 // Mark the end of the structure.
5490 uint64_t offs = toBits(size);
5491 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
5492 std::make_pair(offs, (NamedDecl*)0));
5493 }
5494
5495 for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {
5496 assert(CurOffs <= CurLayObj->first);
5497
5498 if (CurOffs < CurLayObj->first) {
5499 uint64_t padding = CurLayObj->first - CurOffs;
5500 // FIXME: There doesn't seem to be a way to indicate in the encoding that
5501 // packing/alignment of members is different that normal, in which case
5502 // the encoding will be out-of-sync with the real layout.
5503 // If the runtime switches to just consider the size of types without
5504 // taking into account alignment, we could make padding explicit in the
5505 // encoding (e.g. using arrays of chars). The encoding strings would be
5506 // longer then though.
5507 CurOffs += padding;
5508 }
5509
5510 NamedDecl *dcl = CurLayObj->second;
5511 if (dcl == 0)
5512 break; // reached end of structure.
5513
5514 if (CXXRecordDecl *base = dyn_cast<CXXRecordDecl>(dcl)) {
5515 // We expand the bases without their virtual bases since those are going
5516 // in the initial structure. Note that this differs from gcc which
5517 // expands virtual bases each time one is encountered in the hierarchy,
5518 // making the encoding type bigger than it really is.
5519 getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false);
Argyrios Kyrtzidis95a76f32011-06-17 23:19:38 +00005520 assert(!base->isEmpty());
5521 CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize());
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005522 } else {
5523 FieldDecl *field = cast<FieldDecl>(dcl);
5524 if (FD) {
5525 S += '"';
5526 S += field->getNameAsString();
5527 S += '"';
5528 }
5529
5530 if (field->isBitField()) {
5531 EncodeBitField(this, S, field->getType(), field);
Richard Smithcaf33902011-10-10 18:28:20 +00005532 CurOffs += field->getBitWidthValue(*this);
Argyrios Kyrtzidis49b35de2011-05-17 00:46:38 +00005533 } else {
5534 QualType qt = field->getType();
5535 getLegacyIntegralTypeEncoding(qt);
5536 getObjCEncodingForTypeImpl(qt, S, false, true, FD,
5537 /*OutermostType*/false,
5538 /*EncodingProperty*/false,
5539 /*StructField*/true);
5540 CurOffs += getTypeSize(field->getType());
5541 }
5542 }
5543 }
5544}
5545
Mike Stump11289f42009-09-09 15:08:12 +00005546void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
Fariborz Jahanianac73ff82007-11-01 17:18:37 +00005547 std::string& S) const {
5548 if (QT & Decl::OBJC_TQ_In)
5549 S += 'n';
5550 if (QT & Decl::OBJC_TQ_Inout)
5551 S += 'N';
5552 if (QT & Decl::OBJC_TQ_Out)
5553 S += 'o';
5554 if (QT & Decl::OBJC_TQ_Bycopy)
5555 S += 'O';
5556 if (QT & Decl::OBJC_TQ_Byref)
5557 S += 'R';
5558 if (QT & Decl::OBJC_TQ_Oneway)
5559 S += 'V';
5560}
5561
Douglas Gregor3ea72692011-08-12 05:46:01 +00005562TypedefDecl *ASTContext::getObjCIdDecl() const {
5563 if (!ObjCIdDecl) {
5564 QualType T = getObjCObjectType(ObjCBuiltinIdTy, 0, 0);
5565 T = getObjCObjectPointerType(T);
5566 TypeSourceInfo *IdInfo = getTrivialTypeSourceInfo(T);
5567 ObjCIdDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this),
5568 getTranslationUnitDecl(),
5569 SourceLocation(), SourceLocation(),
5570 &Idents.get("id"), IdInfo);
5571 }
5572
5573 return ObjCIdDecl;
Steve Naroff66e9f332007-10-15 14:41:52 +00005574}
5575
Douglas Gregor52e02802011-08-12 06:17:30 +00005576TypedefDecl *ASTContext::getObjCSelDecl() const {
5577 if (!ObjCSelDecl) {
5578 QualType SelT = getPointerType(ObjCBuiltinSelTy);
5579 TypeSourceInfo *SelInfo = getTrivialTypeSourceInfo(SelT);
5580 ObjCSelDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this),
5581 getTranslationUnitDecl(),
5582 SourceLocation(), SourceLocation(),
5583 &Idents.get("SEL"), SelInfo);
5584 }
5585 return ObjCSelDecl;
Fariborz Jahanian4bef4622007-10-16 20:40:23 +00005586}
5587
Douglas Gregor0a586182011-08-12 05:59:41 +00005588TypedefDecl *ASTContext::getObjCClassDecl() const {
5589 if (!ObjCClassDecl) {
5590 QualType T = getObjCObjectType(ObjCBuiltinClassTy, 0, 0);
5591 T = getObjCObjectPointerType(T);
5592 TypeSourceInfo *ClassInfo = getTrivialTypeSourceInfo(T);
5593 ObjCClassDecl = TypedefDecl::Create(const_cast<ASTContext &>(*this),
5594 getTranslationUnitDecl(),
5595 SourceLocation(), SourceLocation(),
5596 &Idents.get("Class"), ClassInfo);
5597 }
5598
5599 return ObjCClassDecl;
Anders Carlssonf56a7ae2007-10-31 02:53:19 +00005600}
5601
Douglas Gregord53ae832012-01-17 18:09:05 +00005602ObjCInterfaceDecl *ASTContext::getObjCProtocolDecl() const {
5603 if (!ObjCProtocolClassDecl) {
5604 ObjCProtocolClassDecl
5605 = ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(),
5606 SourceLocation(),
5607 &Idents.get("Protocol"),
5608 /*PrevDecl=*/0,
5609 SourceLocation(), true);
5610 }
5611
5612 return ObjCProtocolClassDecl;
5613}
5614
Meador Inge5d3fb222012-06-16 03:34:49 +00005615//===----------------------------------------------------------------------===//
5616// __builtin_va_list Construction Functions
5617//===----------------------------------------------------------------------===//
5618
5619static TypedefDecl *CreateCharPtrBuiltinVaListDecl(const ASTContext *Context) {
5620 // typedef char* __builtin_va_list;
5621 QualType CharPtrType = Context->getPointerType(Context->CharTy);
5622 TypeSourceInfo *TInfo
5623 = Context->getTrivialTypeSourceInfo(CharPtrType);
5624
5625 TypedefDecl *VaListTypeDecl
5626 = TypedefDecl::Create(const_cast<ASTContext &>(*Context),
5627 Context->getTranslationUnitDecl(),
5628 SourceLocation(), SourceLocation(),
5629 &Context->Idents.get("__builtin_va_list"),
5630 TInfo);
5631 return VaListTypeDecl;
5632}
5633
5634static TypedefDecl *CreateVoidPtrBuiltinVaListDecl(const ASTContext *Context) {
5635 // typedef void* __builtin_va_list;
5636 QualType VoidPtrType = Context->getPointerType(Context->VoidTy);
5637 TypeSourceInfo *TInfo
5638 = Context->getTrivialTypeSourceInfo(VoidPtrType);
5639
5640 TypedefDecl *VaListTypeDecl
5641 = TypedefDecl::Create(const_cast<ASTContext &>(*Context),
5642 Context->getTranslationUnitDecl(),
5643 SourceLocation(), SourceLocation(),
5644 &Context->Idents.get("__builtin_va_list"),
5645 TInfo);
5646 return VaListTypeDecl;
5647}
5648
Tim Northover9bb857a2013-01-31 12:13:10 +00005649static TypedefDecl *
5650CreateAArch64ABIBuiltinVaListDecl(const ASTContext *Context) {
5651 RecordDecl *VaListTagDecl;
5652 if (Context->getLangOpts().CPlusPlus) {
5653 // namespace std { struct __va_list {
5654 NamespaceDecl *NS;
5655 NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
5656 Context->getTranslationUnitDecl(),
5657 /*Inline*/false, SourceLocation(),
5658 SourceLocation(), &Context->Idents.get("std"),
5659 /*PrevDecl*/0);
5660
5661 VaListTagDecl = CXXRecordDecl::Create(*Context, TTK_Struct,
5662 Context->getTranslationUnitDecl(),
5663 SourceLocation(), SourceLocation(),
5664 &Context->Idents.get("__va_list"));
5665 VaListTagDecl->setDeclContext(NS);
5666 } else {
5667 // struct __va_list
5668 VaListTagDecl = CreateRecordDecl(*Context, TTK_Struct,
5669 Context->getTranslationUnitDecl(),
5670 &Context->Idents.get("__va_list"));
5671 }
5672
5673 VaListTagDecl->startDefinition();
5674
5675 const size_t NumFields = 5;
5676 QualType FieldTypes[NumFields];
5677 const char *FieldNames[NumFields];
5678
5679 // void *__stack;
5680 FieldTypes[0] = Context->getPointerType(Context->VoidTy);
5681 FieldNames[0] = "__stack";
5682
5683 // void *__gr_top;
5684 FieldTypes[1] = Context->getPointerType(Context->VoidTy);
5685 FieldNames[1] = "__gr_top";
5686
5687 // void *__vr_top;
5688 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
5689 FieldNames[2] = "__vr_top";
5690
5691 // int __gr_offs;
5692 FieldTypes[3] = Context->IntTy;
5693 FieldNames[3] = "__gr_offs";
5694
5695 // int __vr_offs;
5696 FieldTypes[4] = Context->IntTy;
5697 FieldNames[4] = "__vr_offs";
5698
5699 // Create fields
5700 for (unsigned i = 0; i < NumFields; ++i) {
5701 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
5702 VaListTagDecl,
5703 SourceLocation(),
5704 SourceLocation(),
5705 &Context->Idents.get(FieldNames[i]),
5706 FieldTypes[i], /*TInfo=*/0,
5707 /*BitWidth=*/0,
5708 /*Mutable=*/false,
5709 ICIS_NoInit);
5710 Field->setAccess(AS_public);
5711 VaListTagDecl->addDecl(Field);
5712 }
5713 VaListTagDecl->completeDefinition();
5714 QualType VaListTagType = Context->getRecordType(VaListTagDecl);
5715 Context->VaListTagTy = VaListTagType;
5716
5717 // } __builtin_va_list;
5718 TypedefDecl *VaListTypedefDecl
5719 = TypedefDecl::Create(const_cast<ASTContext &>(*Context),
5720 Context->getTranslationUnitDecl(),
5721 SourceLocation(), SourceLocation(),
5722 &Context->Idents.get("__builtin_va_list"),
5723 Context->getTrivialTypeSourceInfo(VaListTagType));
5724
5725 return VaListTypedefDecl;
5726}
5727
Meador Inge5d3fb222012-06-16 03:34:49 +00005728static TypedefDecl *CreatePowerABIBuiltinVaListDecl(const ASTContext *Context) {
5729 // typedef struct __va_list_tag {
5730 RecordDecl *VaListTagDecl;
5731
5732 VaListTagDecl = CreateRecordDecl(*Context, TTK_Struct,
5733 Context->getTranslationUnitDecl(),
5734 &Context->Idents.get("__va_list_tag"));
5735 VaListTagDecl->startDefinition();
5736
5737 const size_t NumFields = 5;
5738 QualType FieldTypes[NumFields];
5739 const char *FieldNames[NumFields];
5740
5741 // unsigned char gpr;
5742 FieldTypes[0] = Context->UnsignedCharTy;
5743 FieldNames[0] = "gpr";
5744
5745 // unsigned char fpr;
5746 FieldTypes[1] = Context->UnsignedCharTy;
5747 FieldNames[1] = "fpr";
5748
5749 // unsigned short reserved;
5750 FieldTypes[2] = Context->UnsignedShortTy;
5751 FieldNames[2] = "reserved";
5752
5753 // void* overflow_arg_area;
5754 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
5755 FieldNames[3] = "overflow_arg_area";
5756
5757 // void* reg_save_area;
5758 FieldTypes[4] = Context->getPointerType(Context->VoidTy);
5759 FieldNames[4] = "reg_save_area";
5760
5761 // Create fields
5762 for (unsigned i = 0; i < NumFields; ++i) {
5763 FieldDecl *Field = FieldDecl::Create(*Context, VaListTagDecl,
5764 SourceLocation(),
5765 SourceLocation(),
5766 &Context->Idents.get(FieldNames[i]),
5767 FieldTypes[i], /*TInfo=*/0,
5768 /*BitWidth=*/0,
5769 /*Mutable=*/false,
5770 ICIS_NoInit);
5771 Field->setAccess(AS_public);
5772 VaListTagDecl->addDecl(Field);
5773 }
5774 VaListTagDecl->completeDefinition();
5775 QualType VaListTagType = Context->getRecordType(VaListTagDecl);
Meador Ingecfb60902012-07-01 15:57:25 +00005776 Context->VaListTagTy = VaListTagType;
Meador Inge5d3fb222012-06-16 03:34:49 +00005777
5778 // } __va_list_tag;
5779 TypedefDecl *VaListTagTypedefDecl
5780 = TypedefDecl::Create(const_cast<ASTContext &>(*Context),
5781 Context->getTranslationUnitDecl(),
5782 SourceLocation(), SourceLocation(),
5783 &Context->Idents.get("__va_list_tag"),
5784 Context->getTrivialTypeSourceInfo(VaListTagType));
5785 QualType VaListTagTypedefType =
5786 Context->getTypedefType(VaListTagTypedefDecl);
5787
5788 // typedef __va_list_tag __builtin_va_list[1];
5789 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
5790 QualType VaListTagArrayType
5791 = Context->getConstantArrayType(VaListTagTypedefType,
5792 Size, ArrayType::Normal, 0);
5793 TypeSourceInfo *TInfo
5794 = Context->getTrivialTypeSourceInfo(VaListTagArrayType);
5795 TypedefDecl *VaListTypedefDecl
5796 = TypedefDecl::Create(const_cast<ASTContext &>(*Context),
5797 Context->getTranslationUnitDecl(),
5798 SourceLocation(), SourceLocation(),
5799 &Context->Idents.get("__builtin_va_list"),
5800 TInfo);
5801
5802 return VaListTypedefDecl;
5803}
5804
5805static TypedefDecl *
5806CreateX86_64ABIBuiltinVaListDecl(const ASTContext *Context) {
5807 // typedef struct __va_list_tag {
5808 RecordDecl *VaListTagDecl;
5809 VaListTagDecl = CreateRecordDecl(*Context, TTK_Struct,
5810 Context->getTranslationUnitDecl(),
5811 &Context->Idents.get("__va_list_tag"));
5812 VaListTagDecl->startDefinition();
5813
5814 const size_t NumFields = 4;
5815 QualType FieldTypes[NumFields];
5816 const char *FieldNames[NumFields];
5817
5818 // unsigned gp_offset;
5819 FieldTypes[0] = Context->UnsignedIntTy;
5820 FieldNames[0] = "gp_offset";
5821
5822 // unsigned fp_offset;
5823 FieldTypes[1] = Context->UnsignedIntTy;
5824 FieldNames[1] = "fp_offset";
5825
5826 // void* overflow_arg_area;
5827 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
5828 FieldNames[2] = "overflow_arg_area";
5829
5830 // void* reg_save_area;
5831 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
5832 FieldNames[3] = "reg_save_area";
5833
5834 // Create fields
5835 for (unsigned i = 0; i < NumFields; ++i) {
5836 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
5837 VaListTagDecl,
5838 SourceLocation(),
5839 SourceLocation(),
5840 &Context->Idents.get(FieldNames[i]),
5841 FieldTypes[i], /*TInfo=*/0,
5842 /*BitWidth=*/0,
5843 /*Mutable=*/false,
5844 ICIS_NoInit);
5845 Field->setAccess(AS_public);
5846 VaListTagDecl->addDecl(Field);
5847 }
5848 VaListTagDecl->completeDefinition();
5849 QualType VaListTagType = Context->getRecordType(VaListTagDecl);
Meador Ingecfb60902012-07-01 15:57:25 +00005850 Context->VaListTagTy = VaListTagType;
Meador Inge5d3fb222012-06-16 03:34:49 +00005851
5852 // } __va_list_tag;
5853 TypedefDecl *VaListTagTypedefDecl
5854 = TypedefDecl::Create(const_cast<ASTContext &>(*Context),
5855 Context->getTranslationUnitDecl(),
5856 SourceLocation(), SourceLocation(),
5857 &Context->Idents.get("__va_list_tag"),
5858 Context->getTrivialTypeSourceInfo(VaListTagType));
5859 QualType VaListTagTypedefType =
5860 Context->getTypedefType(VaListTagTypedefDecl);
5861
5862 // typedef __va_list_tag __builtin_va_list[1];
5863 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
5864 QualType VaListTagArrayType
5865 = Context->getConstantArrayType(VaListTagTypedefType,
5866 Size, ArrayType::Normal,0);
5867 TypeSourceInfo *TInfo
5868 = Context->getTrivialTypeSourceInfo(VaListTagArrayType);
5869 TypedefDecl *VaListTypedefDecl
5870 = TypedefDecl::Create(const_cast<ASTContext &>(*Context),
5871 Context->getTranslationUnitDecl(),
5872 SourceLocation(), SourceLocation(),
5873 &Context->Idents.get("__builtin_va_list"),
5874 TInfo);
5875
5876 return VaListTypedefDecl;
5877}
5878
5879static TypedefDecl *CreatePNaClABIBuiltinVaListDecl(const ASTContext *Context) {
5880 // typedef int __builtin_va_list[4];
5881 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 4);
5882 QualType IntArrayType
5883 = Context->getConstantArrayType(Context->IntTy,
5884 Size, ArrayType::Normal, 0);
5885 TypedefDecl *VaListTypedefDecl
5886 = TypedefDecl::Create(const_cast<ASTContext &>(*Context),
5887 Context->getTranslationUnitDecl(),
5888 SourceLocation(), SourceLocation(),
5889 &Context->Idents.get("__builtin_va_list"),
5890 Context->getTrivialTypeSourceInfo(IntArrayType));
5891
5892 return VaListTypedefDecl;
5893}
5894
Logan Chien57086ce2012-10-10 06:56:20 +00005895static TypedefDecl *
5896CreateAAPCSABIBuiltinVaListDecl(const ASTContext *Context) {
5897 RecordDecl *VaListDecl;
5898 if (Context->getLangOpts().CPlusPlus) {
5899 // namespace std { struct __va_list {
5900 NamespaceDecl *NS;
5901 NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
5902 Context->getTranslationUnitDecl(),
5903 /*Inline*/false, SourceLocation(),
5904 SourceLocation(), &Context->Idents.get("std"),
5905 /*PrevDecl*/0);
5906
5907 VaListDecl = CXXRecordDecl::Create(*Context, TTK_Struct,
5908 Context->getTranslationUnitDecl(),
5909 SourceLocation(), SourceLocation(),
5910 &Context->Idents.get("__va_list"));
5911
5912 VaListDecl->setDeclContext(NS);
5913
5914 } else {
5915 // struct __va_list {
5916 VaListDecl = CreateRecordDecl(*Context, TTK_Struct,
5917 Context->getTranslationUnitDecl(),
5918 &Context->Idents.get("__va_list"));
5919 }
5920
5921 VaListDecl->startDefinition();
5922
5923 // void * __ap;
5924 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
5925 VaListDecl,
5926 SourceLocation(),
5927 SourceLocation(),
5928 &Context->Idents.get("__ap"),
5929 Context->getPointerType(Context->VoidTy),
5930 /*TInfo=*/0,
5931 /*BitWidth=*/0,
5932 /*Mutable=*/false,
5933 ICIS_NoInit);
5934 Field->setAccess(AS_public);
5935 VaListDecl->addDecl(Field);
5936
5937 // };
5938 VaListDecl->completeDefinition();
5939
5940 // typedef struct __va_list __builtin_va_list;
5941 TypeSourceInfo *TInfo
5942 = Context->getTrivialTypeSourceInfo(Context->getRecordType(VaListDecl));
5943
5944 TypedefDecl *VaListTypeDecl
5945 = TypedefDecl::Create(const_cast<ASTContext &>(*Context),
5946 Context->getTranslationUnitDecl(),
5947 SourceLocation(), SourceLocation(),
5948 &Context->Idents.get("__builtin_va_list"),
5949 TInfo);
5950
5951 return VaListTypeDecl;
5952}
5953
Meador Inge5d3fb222012-06-16 03:34:49 +00005954static TypedefDecl *CreateVaListDecl(const ASTContext *Context,
5955 TargetInfo::BuiltinVaListKind Kind) {
5956 switch (Kind) {
5957 case TargetInfo::CharPtrBuiltinVaList:
5958 return CreateCharPtrBuiltinVaListDecl(Context);
5959 case TargetInfo::VoidPtrBuiltinVaList:
5960 return CreateVoidPtrBuiltinVaListDecl(Context);
Tim Northover9bb857a2013-01-31 12:13:10 +00005961 case TargetInfo::AArch64ABIBuiltinVaList:
5962 return CreateAArch64ABIBuiltinVaListDecl(Context);
Meador Inge5d3fb222012-06-16 03:34:49 +00005963 case TargetInfo::PowerABIBuiltinVaList:
5964 return CreatePowerABIBuiltinVaListDecl(Context);
5965 case TargetInfo::X86_64ABIBuiltinVaList:
5966 return CreateX86_64ABIBuiltinVaListDecl(Context);
5967 case TargetInfo::PNaClABIBuiltinVaList:
5968 return CreatePNaClABIBuiltinVaListDecl(Context);
Logan Chien57086ce2012-10-10 06:56:20 +00005969 case TargetInfo::AAPCSABIBuiltinVaList:
5970 return CreateAAPCSABIBuiltinVaListDecl(Context);
Meador Inge5d3fb222012-06-16 03:34:49 +00005971 }
5972
5973 llvm_unreachable("Unhandled __builtin_va_list type kind");
5974}
5975
5976TypedefDecl *ASTContext::getBuiltinVaListDecl() const {
5977 if (!BuiltinVaListDecl)
5978 BuiltinVaListDecl = CreateVaListDecl(this, Target->getBuiltinVaListKind());
5979
5980 return BuiltinVaListDecl;
5981}
5982
Meador Ingecfb60902012-07-01 15:57:25 +00005983QualType ASTContext::getVaListTagType() const {
5984 // Force the creation of VaListTagTy by building the __builtin_va_list
5985 // declaration.
5986 if (VaListTagTy.isNull())
5987 (void) getBuiltinVaListDecl();
5988
5989 return VaListTagTy;
5990}
5991
Ted Kremenek1b0ea822008-01-07 19:49:32 +00005992void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) {
Mike Stump11289f42009-09-09 15:08:12 +00005993 assert(ObjCConstantStringType.isNull() &&
Steve Narofff73b7842007-10-15 23:35:17 +00005994 "'NSConstantString' type already set!");
Mike Stump11289f42009-09-09 15:08:12 +00005995
Ted Kremenek1b0ea822008-01-07 19:49:32 +00005996 ObjCConstantStringType = getObjCInterfaceType(Decl);
Steve Narofff73b7842007-10-15 23:35:17 +00005997}
5998
John McCalld28ae272009-12-02 08:04:21 +00005999/// \brief Retrieve the template name that corresponds to a non-empty
6000/// lookup.
Jay Foad39c79802011-01-12 09:06:06 +00006001TemplateName
6002ASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin,
6003 UnresolvedSetIterator End) const {
John McCalld28ae272009-12-02 08:04:21 +00006004 unsigned size = End - Begin;
6005 assert(size > 1 && "set is not overloaded!");
6006
6007 void *memory = Allocate(sizeof(OverloadedTemplateStorage) +
6008 size * sizeof(FunctionTemplateDecl*));
6009 OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size);
6010
6011 NamedDecl **Storage = OT->getStorage();
John McCallad371252010-01-20 00:46:10 +00006012 for (UnresolvedSetIterator I = Begin; I != End; ++I) {
John McCalld28ae272009-12-02 08:04:21 +00006013 NamedDecl *D = *I;
6014 assert(isa<FunctionTemplateDecl>(D) ||
6015 (isa<UsingShadowDecl>(D) &&
6016 isa<FunctionTemplateDecl>(D->getUnderlyingDecl())));
6017 *Storage++ = D;
6018 }
6019
6020 return TemplateName(OT);
6021}
6022
Douglas Gregordc572a32009-03-30 22:58:21 +00006023/// \brief Retrieve the template name that represents a qualified
6024/// template name such as \c std::vector.
Jay Foad39c79802011-01-12 09:06:06 +00006025TemplateName
6026ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
6027 bool TemplateKeyword,
6028 TemplateDecl *Template) const {
Douglas Gregore29139c2011-03-03 17:04:51 +00006029 assert(NNS && "Missing nested-name-specifier in qualified template name");
6030
Douglas Gregorc42075a2010-02-04 18:10:26 +00006031 // FIXME: Canonicalization?
Douglas Gregordc572a32009-03-30 22:58:21 +00006032 llvm::FoldingSetNodeID ID;
6033 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
6034
6035 void *InsertPos = 0;
6036 QualifiedTemplateName *QTN =
6037 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
6038 if (!QTN) {
Richard Smitha5e69762012-08-16 01:19:31 +00006039 QTN = new (*this, llvm::alignOf<QualifiedTemplateName>())
6040 QualifiedTemplateName(NNS, TemplateKeyword, Template);
Douglas Gregordc572a32009-03-30 22:58:21 +00006041 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
6042 }
6043
6044 return TemplateName(QTN);
6045}
6046
6047/// \brief Retrieve the template name that represents a dependent
6048/// template name such as \c MetaFun::template apply.
Jay Foad39c79802011-01-12 09:06:06 +00006049TemplateName
6050ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
6051 const IdentifierInfo *Name) const {
Mike Stump11289f42009-09-09 15:08:12 +00006052 assert((!NNS || NNS->isDependent()) &&
Douglas Gregor308047d2009-09-09 00:23:06 +00006053 "Nested name specifier must be dependent");
Douglas Gregordc572a32009-03-30 22:58:21 +00006054
6055 llvm::FoldingSetNodeID ID;
6056 DependentTemplateName::Profile(ID, NNS, Name);
6057
6058 void *InsertPos = 0;
6059 DependentTemplateName *QTN =
6060 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
6061
6062 if (QTN)
6063 return TemplateName(QTN);
6064
6065 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
6066 if (CanonNNS == NNS) {
Richard Smitha5e69762012-08-16 01:19:31 +00006067 QTN = new (*this, llvm::alignOf<DependentTemplateName>())
6068 DependentTemplateName(NNS, Name);
Douglas Gregordc572a32009-03-30 22:58:21 +00006069 } else {
6070 TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
Richard Smitha5e69762012-08-16 01:19:31 +00006071 QTN = new (*this, llvm::alignOf<DependentTemplateName>())
6072 DependentTemplateName(NNS, Name, Canon);
Douglas Gregorc42075a2010-02-04 18:10:26 +00006073 DependentTemplateName *CheckQTN =
6074 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
6075 assert(!CheckQTN && "Dependent type name canonicalization broken");
6076 (void)CheckQTN;
Douglas Gregordc572a32009-03-30 22:58:21 +00006077 }
6078
6079 DependentTemplateNames.InsertNode(QTN, InsertPos);
6080 return TemplateName(QTN);
6081}
6082
Douglas Gregor71395fa2009-11-04 00:56:37 +00006083/// \brief Retrieve the template name that represents a dependent
6084/// template name such as \c MetaFun::template operator+.
6085TemplateName
6086ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
Jay Foad39c79802011-01-12 09:06:06 +00006087 OverloadedOperatorKind Operator) const {
Douglas Gregor71395fa2009-11-04 00:56:37 +00006088 assert((!NNS || NNS->isDependent()) &&
6089 "Nested name specifier must be dependent");
6090
6091 llvm::FoldingSetNodeID ID;
6092 DependentTemplateName::Profile(ID, NNS, Operator);
6093
6094 void *InsertPos = 0;
Douglas Gregorc42075a2010-02-04 18:10:26 +00006095 DependentTemplateName *QTN
6096 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
Douglas Gregor71395fa2009-11-04 00:56:37 +00006097
6098 if (QTN)
6099 return TemplateName(QTN);
6100
6101 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
6102 if (CanonNNS == NNS) {
Richard Smitha5e69762012-08-16 01:19:31 +00006103 QTN = new (*this, llvm::alignOf<DependentTemplateName>())
6104 DependentTemplateName(NNS, Operator);
Douglas Gregor71395fa2009-11-04 00:56:37 +00006105 } else {
6106 TemplateName Canon = getDependentTemplateName(CanonNNS, Operator);
Richard Smitha5e69762012-08-16 01:19:31 +00006107 QTN = new (*this, llvm::alignOf<DependentTemplateName>())
6108 DependentTemplateName(NNS, Operator, Canon);
Douglas Gregorc42075a2010-02-04 18:10:26 +00006109
6110 DependentTemplateName *CheckQTN
6111 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
6112 assert(!CheckQTN && "Dependent template name canonicalization broken");
6113 (void)CheckQTN;
Douglas Gregor71395fa2009-11-04 00:56:37 +00006114 }
6115
6116 DependentTemplateNames.InsertNode(QTN, InsertPos);
6117 return TemplateName(QTN);
6118}
6119
Douglas Gregor5590be02011-01-15 06:45:20 +00006120TemplateName
John McCalld9dfe3a2011-06-30 08:33:18 +00006121ASTContext::getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param,
6122 TemplateName replacement) const {
6123 llvm::FoldingSetNodeID ID;
6124 SubstTemplateTemplateParmStorage::Profile(ID, param, replacement);
6125
6126 void *insertPos = 0;
6127 SubstTemplateTemplateParmStorage *subst
6128 = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);
6129
6130 if (!subst) {
6131 subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement);
6132 SubstTemplateTemplateParms.InsertNode(subst, insertPos);
6133 }
6134
6135 return TemplateName(subst);
6136}
6137
6138TemplateName
Douglas Gregor5590be02011-01-15 06:45:20 +00006139ASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param,
6140 const TemplateArgument &ArgPack) const {
6141 ASTContext &Self = const_cast<ASTContext &>(*this);
6142 llvm::FoldingSetNodeID ID;
6143 SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack);
6144
6145 void *InsertPos = 0;
6146 SubstTemplateTemplateParmPackStorage *Subst
6147 = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);
6148
6149 if (!Subst) {
John McCalld9dfe3a2011-06-30 08:33:18 +00006150 Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param,
Douglas Gregor5590be02011-01-15 06:45:20 +00006151 ArgPack.pack_size(),
6152 ArgPack.pack_begin());
6153 SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
6154 }
6155
6156 return TemplateName(Subst);
6157}
6158
Douglas Gregor8af6e6d2008-11-03 14:12:49 +00006159/// getFromTargetType - Given one of the integer types provided by
Douglas Gregorab138572008-11-03 15:57:00 +00006160/// TargetInfo, produce the corresponding type. The unsigned @p Type
6161/// is actually a value of type @c TargetInfo::IntType.
John McCall48f2d582009-10-23 23:03:21 +00006162CanQualType ASTContext::getFromTargetType(unsigned Type) const {
Douglas Gregor8af6e6d2008-11-03 14:12:49 +00006163 switch (Type) {
John McCall48f2d582009-10-23 23:03:21 +00006164 case TargetInfo::NoInt: return CanQualType();
Douglas Gregor8af6e6d2008-11-03 14:12:49 +00006165 case TargetInfo::SignedShort: return ShortTy;
6166 case TargetInfo::UnsignedShort: return UnsignedShortTy;
6167 case TargetInfo::SignedInt: return IntTy;
6168 case TargetInfo::UnsignedInt: return UnsignedIntTy;
6169 case TargetInfo::SignedLong: return LongTy;
6170 case TargetInfo::UnsignedLong: return UnsignedLongTy;
6171 case TargetInfo::SignedLongLong: return LongLongTy;
6172 case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy;
6173 }
6174
David Blaikie83d382b2011-09-23 05:06:16 +00006175 llvm_unreachable("Unhandled TargetInfo::IntType value");
Douglas Gregor8af6e6d2008-11-03 14:12:49 +00006176}
Ted Kremenek77c51b22008-07-24 23:58:27 +00006177
6178//===----------------------------------------------------------------------===//
6179// Type Predicates.
6180//===----------------------------------------------------------------------===//
6181
Fariborz Jahanian96207692009-02-18 21:49:28 +00006182/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
6183/// garbage collection attribute.
6184///
John McCall553d45a2011-01-12 00:34:59 +00006185Qualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const {
David Blaikiebbafb8a2012-03-11 07:00:24 +00006186 if (getLangOpts().getGC() == LangOptions::NonGC)
John McCall553d45a2011-01-12 00:34:59 +00006187 return Qualifiers::GCNone;
6188
David Blaikiebbafb8a2012-03-11 07:00:24 +00006189 assert(getLangOpts().ObjC1);
John McCall553d45a2011-01-12 00:34:59 +00006190 Qualifiers::GC GCAttrs = Ty.getObjCGCAttr();
6191
6192 // Default behaviour under objective-C's gc is for ObjC pointers
6193 // (or pointers to them) be treated as though they were declared
6194 // as __strong.
6195 if (GCAttrs == Qualifiers::GCNone) {
6196 if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType())
6197 return Qualifiers::Strong;
6198 else if (Ty->isPointerType())
6199 return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType());
6200 } else {
6201 // It's not valid to set GC attributes on anything that isn't a
6202 // pointer.
6203#ifndef NDEBUG
6204 QualType CT = Ty->getCanonicalTypeInternal();
6205 while (const ArrayType *AT = dyn_cast<ArrayType>(CT))
6206 CT = AT->getElementType();
6207 assert(CT->isAnyPointerType() || CT->isBlockPointerType());
6208#endif
Fariborz Jahanian96207692009-02-18 21:49:28 +00006209 }
Chris Lattnerd60183d2009-02-18 22:53:11 +00006210 return GCAttrs;
Fariborz Jahanian96207692009-02-18 21:49:28 +00006211}
6212
Chris Lattner49af6a42008-04-07 06:51:04 +00006213//===----------------------------------------------------------------------===//
6214// Type Compatibility Testing
6215//===----------------------------------------------------------------------===//
Chris Lattnerb338a6b2007-11-01 05:03:41 +00006216
Mike Stump11289f42009-09-09 15:08:12 +00006217/// areCompatVectorTypes - Return true if the two specified vector types are
Chris Lattner49af6a42008-04-07 06:51:04 +00006218/// compatible.
6219static bool areCompatVectorTypes(const VectorType *LHS,
6220 const VectorType *RHS) {
John McCallb692a092009-10-22 20:10:53 +00006221 assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified());
Chris Lattner49af6a42008-04-07 06:51:04 +00006222 return LHS->getElementType() == RHS->getElementType() &&
Chris Lattner465fa322008-10-05 17:34:18 +00006223 LHS->getNumElements() == RHS->getNumElements();
Chris Lattner49af6a42008-04-07 06:51:04 +00006224}
6225
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00006226bool ASTContext::areCompatibleVectorTypes(QualType FirstVec,
6227 QualType SecondVec) {
6228 assert(FirstVec->isVectorType() && "FirstVec should be a vector type");
6229 assert(SecondVec->isVectorType() && "SecondVec should be a vector type");
6230
6231 if (hasSameUnqualifiedType(FirstVec, SecondVec))
6232 return true;
6233
Bob Wilsone6aeebb2010-11-12 17:24:54 +00006234 // Treat Neon vector types and most AltiVec vector types as if they are the
6235 // equivalent GCC vector types.
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00006236 const VectorType *First = FirstVec->getAs<VectorType>();
6237 const VectorType *Second = SecondVec->getAs<VectorType>();
Bob Wilsone6aeebb2010-11-12 17:24:54 +00006238 if (First->getNumElements() == Second->getNumElements() &&
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00006239 hasSameType(First->getElementType(), Second->getElementType()) &&
Bob Wilsone6aeebb2010-11-12 17:24:54 +00006240 First->getVectorKind() != VectorType::AltiVecPixel &&
6241 First->getVectorKind() != VectorType::AltiVecBool &&
6242 Second->getVectorKind() != VectorType::AltiVecPixel &&
6243 Second->getVectorKind() != VectorType::AltiVecBool)
Douglas Gregor59e8b3b2010-08-06 10:14:59 +00006244 return true;
6245
6246 return false;
6247}
6248
Steve Naroff8e6aee52009-07-23 01:01:38 +00006249//===----------------------------------------------------------------------===//
6250// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
6251//===----------------------------------------------------------------------===//
6252
6253/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
6254/// inheritance hierarchy of 'rProto'.
Jay Foad39c79802011-01-12 09:06:06 +00006255bool
6256ASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
6257 ObjCProtocolDecl *rProto) const {
Douglas Gregor33b24292012-01-01 18:09:12 +00006258 if (declaresSameEntity(lProto, rProto))
Steve Naroff8e6aee52009-07-23 01:01:38 +00006259 return true;
6260 for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(),
6261 E = rProto->protocol_end(); PI != E; ++PI)
6262 if (ProtocolCompatibleWithProtocol(lProto, *PI))
6263 return true;
6264 return false;
6265}
6266
Dmitri Gribenko4364fcf2012-08-28 02:49:14 +00006267/// QualifiedIdConformsQualifiedId - compare id<pr,...> with id<pr1,...>
Steve Naroff8e6aee52009-07-23 01:01:38 +00006268/// return true if lhs's protocols conform to rhs's protocol; false
6269/// otherwise.
6270bool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) {
6271 if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType())
6272 return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false);
6273 return false;
6274}
6275
Dmitri Gribenko4364fcf2012-08-28 02:49:14 +00006276/// ObjCQualifiedClassTypesAreCompatible - compare Class<pr,...> and
6277/// Class<pr1, ...>.
Fariborz Jahanian3c7ebc32010-07-19 22:02:22 +00006278bool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs,
6279 QualType rhs) {
6280 const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>();
6281 const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
6282 assert ((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible");
6283
6284 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
6285 E = lhsQID->qual_end(); I != E; ++I) {
6286 bool match = false;
6287 ObjCProtocolDecl *lhsProto = *I;
6288 for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(),
6289 E = rhsOPT->qual_end(); J != E; ++J) {
6290 ObjCProtocolDecl *rhsProto = *J;
6291 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) {
6292 match = true;
6293 break;
6294 }
6295 }
6296 if (!match)
6297 return false;
6298 }
6299 return true;
6300}
6301
Steve Naroff8e6aee52009-07-23 01:01:38 +00006302/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
6303/// ObjCQualifiedIDType.
6304bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs,
6305 bool compare) {
6306 // Allow id<P..> and an 'id' or void* type in all cases.
Mike Stump11289f42009-09-09 15:08:12 +00006307 if (lhs->isVoidPointerType() ||
Steve Naroff8e6aee52009-07-23 01:01:38 +00006308 lhs->isObjCIdType() || lhs->isObjCClassType())
6309 return true;
Mike Stump11289f42009-09-09 15:08:12 +00006310 else if (rhs->isVoidPointerType() ||
Steve Naroff8e6aee52009-07-23 01:01:38 +00006311 rhs->isObjCIdType() || rhs->isObjCClassType())
6312 return true;
6313
6314 if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) {
John McCall9dd450b2009-09-21 23:43:11 +00006315 const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
Mike Stump11289f42009-09-09 15:08:12 +00006316
Steve Naroff8e6aee52009-07-23 01:01:38 +00006317 if (!rhsOPT) return false;
Mike Stump11289f42009-09-09 15:08:12 +00006318
Steve Naroff8e6aee52009-07-23 01:01:38 +00006319 if (rhsOPT->qual_empty()) {
Mike Stump11289f42009-09-09 15:08:12 +00006320 // If the RHS is a unqualified interface pointer "NSString*",
Steve Naroff8e6aee52009-07-23 01:01:38 +00006321 // make sure we check the class hierarchy.
6322 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
6323 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
6324 E = lhsQID->qual_end(); I != E; ++I) {
6325 // when comparing an id<P> on lhs with a static type on rhs,
6326 // see if static class implements all of id's protocols, directly or
6327 // through its super class and categories.
Fariborz Jahanian3f8917a2009-08-11 22:02:25 +00006328 if (!rhsID->ClassImplementsProtocol(*I, true))
Steve Naroff8e6aee52009-07-23 01:01:38 +00006329 return false;
6330 }
6331 }
6332 // If there are no qualifiers and no interface, we have an 'id'.
6333 return true;
6334 }
Mike Stump11289f42009-09-09 15:08:12 +00006335 // Both the right and left sides have qualifiers.
Steve Naroff8e6aee52009-07-23 01:01:38 +00006336 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
6337 E = lhsQID->qual_end(); I != E; ++I) {
6338 ObjCProtocolDecl *lhsProto = *I;
6339 bool match = false;
6340
6341 // when comparing an id<P> on lhs with a static type on rhs,
6342 // see if static class implements all of id's protocols, directly or
6343 // through its super class and categories.
6344 for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(),
6345 E = rhsOPT->qual_end(); J != E; ++J) {
6346 ObjCProtocolDecl *rhsProto = *J;
6347 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
6348 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
6349 match = true;
6350 break;
6351 }
6352 }
Mike Stump11289f42009-09-09 15:08:12 +00006353 // If the RHS is a qualified interface pointer "NSString<P>*",
Steve Naroff8e6aee52009-07-23 01:01:38 +00006354 // make sure we check the class hierarchy.
6355 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
6356 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
6357 E = lhsQID->qual_end(); I != E; ++I) {
6358 // when comparing an id<P> on lhs with a static type on rhs,
6359 // see if static class implements all of id's protocols, directly or
6360 // through its super class and categories.
Fariborz Jahanian3f8917a2009-08-11 22:02:25 +00006361 if (rhsID->ClassImplementsProtocol(*I, true)) {
Steve Naroff8e6aee52009-07-23 01:01:38 +00006362 match = true;
6363 break;
6364 }
6365 }
6366 }
6367 if (!match)
6368 return false;
6369 }
Mike Stump11289f42009-09-09 15:08:12 +00006370
Steve Naroff8e6aee52009-07-23 01:01:38 +00006371 return true;
6372 }
Mike Stump11289f42009-09-09 15:08:12 +00006373
Steve Naroff8e6aee52009-07-23 01:01:38 +00006374 const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType();
6375 assert(rhsQID && "One of the LHS/RHS should be id<x>");
6376
Mike Stump11289f42009-09-09 15:08:12 +00006377 if (const ObjCObjectPointerType *lhsOPT =
Steve Naroff8e6aee52009-07-23 01:01:38 +00006378 lhs->getAsObjCInterfacePointerType()) {
Fariborz Jahanianeb7714c2010-11-01 20:47:16 +00006379 // If both the right and left sides have qualifiers.
Steve Naroff8e6aee52009-07-23 01:01:38 +00006380 for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(),
6381 E = lhsOPT->qual_end(); I != E; ++I) {
6382 ObjCProtocolDecl *lhsProto = *I;
6383 bool match = false;
6384
Fariborz Jahanianeb7714c2010-11-01 20:47:16 +00006385 // when comparing an id<P> on rhs with a static type on lhs,
Steve Naroff8e6aee52009-07-23 01:01:38 +00006386 // see if static class implements all of id's protocols, directly or
6387 // through its super class and categories.
Fariborz Jahanianeb7714c2010-11-01 20:47:16 +00006388 // First, lhs protocols in the qualifier list must be found, direct
6389 // or indirect in rhs's qualifier list or it is a mismatch.
Steve Naroff8e6aee52009-07-23 01:01:38 +00006390 for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(),
6391 E = rhsQID->qual_end(); J != E; ++J) {
6392 ObjCProtocolDecl *rhsProto = *J;
6393 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
6394 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
6395 match = true;
6396 break;
6397 }
6398 }
6399 if (!match)
6400 return false;
6401 }
Fariborz Jahanianeb7714c2010-11-01 20:47:16 +00006402
6403 // Static class's protocols, or its super class or category protocols
6404 // must be found, direct or indirect in rhs's qualifier list or it is a mismatch.
6405 if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) {
6406 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
6407 CollectInheritedProtocols(lhsID, LHSInheritedProtocols);
6408 // This is rather dubious but matches gcc's behavior. If lhs has
6409 // no type qualifier and its class has no static protocol(s)
6410 // assume that it is mismatch.
6411 if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty())
6412 return false;
6413 for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I =
6414 LHSInheritedProtocols.begin(),
6415 E = LHSInheritedProtocols.end(); I != E; ++I) {
6416 bool match = false;
6417 ObjCProtocolDecl *lhsProto = (*I);
6418 for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(),
6419 E = rhsQID->qual_end(); J != E; ++J) {
6420 ObjCProtocolDecl *rhsProto = *J;
6421 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
6422 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
6423 match = true;
6424 break;
6425 }
6426 }
6427 if (!match)
6428 return false;
6429 }
6430 }
Steve Naroff8e6aee52009-07-23 01:01:38 +00006431 return true;
6432 }
6433 return false;
6434}
6435
Eli Friedman47f77112008-08-22 00:56:42 +00006436/// canAssignObjCInterfaces - Return true if the two interface types are
Chris Lattner49af6a42008-04-07 06:51:04 +00006437/// compatible for assignment from RHS to LHS. This handles validation of any
6438/// protocol qualifiers on the LHS or RHS.
6439///
Steve Naroff7cae42b2009-07-10 23:34:53 +00006440bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
6441 const ObjCObjectPointerType *RHSOPT) {
John McCall8b07ec22010-05-15 11:32:37 +00006442 const ObjCObjectType* LHS = LHSOPT->getObjectType();
6443 const ObjCObjectType* RHS = RHSOPT->getObjectType();
6444
Steve Naroff1329fa02009-07-15 18:40:39 +00006445 // If either type represents the built-in 'id' or 'Class' types, return true.
John McCall8b07ec22010-05-15 11:32:37 +00006446 if (LHS->isObjCUnqualifiedIdOrClass() ||
6447 RHS->isObjCUnqualifiedIdOrClass())
Steve Naroff7cae42b2009-07-10 23:34:53 +00006448 return true;
6449
John McCall8b07ec22010-05-15 11:32:37 +00006450 if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId())
Mike Stump11289f42009-09-09 15:08:12 +00006451 return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
6452 QualType(RHSOPT,0),
Steve Naroff8e6aee52009-07-23 01:01:38 +00006453 false);
Fariborz Jahanian3c7ebc32010-07-19 22:02:22 +00006454
6455 if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass())
6456 return ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0),
6457 QualType(RHSOPT,0));
6458
John McCall8b07ec22010-05-15 11:32:37 +00006459 // If we have 2 user-defined types, fall into that path.
6460 if (LHS->getInterface() && RHS->getInterface())
Steve Naroff8e6aee52009-07-23 01:01:38 +00006461 return canAssignObjCInterfaces(LHS, RHS);
Mike Stump11289f42009-09-09 15:08:12 +00006462
Steve Naroff8e6aee52009-07-23 01:01:38 +00006463 return false;
Steve Naroff7cae42b2009-07-10 23:34:53 +00006464}
6465
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006466/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written
Chris Lattner57540c52011-04-15 05:22:18 +00006467/// for providing type-safety for objective-c pointers used to pass/return
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006468/// arguments in block literals. When passed as arguments, passing 'A*' where
6469/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is
6470/// not OK. For the return type, the opposite is not OK.
6471bool ASTContext::canAssignObjCInterfacesInBlockPointer(
6472 const ObjCObjectPointerType *LHSOPT,
Fariborz Jahanian90186f82011-03-14 16:07:00 +00006473 const ObjCObjectPointerType *RHSOPT,
6474 bool BlockReturnType) {
Fariborz Jahanian440a6832010-04-06 17:23:39 +00006475 if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType())
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006476 return true;
6477
6478 if (LHSOPT->isObjCBuiltinType()) {
6479 return RHSOPT->isObjCBuiltinType() || RHSOPT->isObjCQualifiedIdType();
6480 }
6481
Fariborz Jahanian440a6832010-04-06 17:23:39 +00006482 if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006483 return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
6484 QualType(RHSOPT,0),
6485 false);
6486
6487 const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
6488 const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
6489 if (LHS && RHS) { // We have 2 user-defined types.
6490 if (LHS != RHS) {
6491 if (LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
Fariborz Jahanian90186f82011-03-14 16:07:00 +00006492 return BlockReturnType;
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006493 if (RHS->getDecl()->isSuperClassOf(LHS->getDecl()))
Fariborz Jahanian90186f82011-03-14 16:07:00 +00006494 return !BlockReturnType;
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006495 }
6496 else
6497 return true;
6498 }
6499 return false;
6500}
6501
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00006502/// getIntersectionOfProtocols - This routine finds the intersection of set
6503/// of protocols inherited from two distinct objective-c pointer objects.
6504/// It is used to build composite qualifier list of the composite type of
6505/// the conditional expression involving two objective-c pointer objects.
6506static
6507void getIntersectionOfProtocols(ASTContext &Context,
6508 const ObjCObjectPointerType *LHSOPT,
6509 const ObjCObjectPointerType *RHSOPT,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006510 SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) {
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00006511
John McCall8b07ec22010-05-15 11:32:37 +00006512 const ObjCObjectType* LHS = LHSOPT->getObjectType();
6513 const ObjCObjectType* RHS = RHSOPT->getObjectType();
6514 assert(LHS->getInterface() && "LHS must have an interface base");
6515 assert(RHS->getInterface() && "RHS must have an interface base");
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00006516
6517 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet;
6518 unsigned LHSNumProtocols = LHS->getNumProtocols();
6519 if (LHSNumProtocols > 0)
6520 InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end());
6521 else {
Fariborz Jahaniandc68f952010-02-12 19:27:33 +00006522 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
John McCall8b07ec22010-05-15 11:32:37 +00006523 Context.CollectInheritedProtocols(LHS->getInterface(),
6524 LHSInheritedProtocols);
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00006525 InheritedProtocolSet.insert(LHSInheritedProtocols.begin(),
6526 LHSInheritedProtocols.end());
6527 }
6528
6529 unsigned RHSNumProtocols = RHS->getNumProtocols();
6530 if (RHSNumProtocols > 0) {
Dan Gohman145f3f12010-04-19 16:39:44 +00006531 ObjCProtocolDecl **RHSProtocols =
6532 const_cast<ObjCProtocolDecl **>(RHS->qual_begin());
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00006533 for (unsigned i = 0; i < RHSNumProtocols; ++i)
6534 if (InheritedProtocolSet.count(RHSProtocols[i]))
6535 IntersectionOfProtocols.push_back(RHSProtocols[i]);
Chad Rosier6fdf38b2011-08-17 23:08:45 +00006536 } else {
Fariborz Jahaniandc68f952010-02-12 19:27:33 +00006537 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSInheritedProtocols;
John McCall8b07ec22010-05-15 11:32:37 +00006538 Context.CollectInheritedProtocols(RHS->getInterface(),
6539 RHSInheritedProtocols);
Fariborz Jahaniandc68f952010-02-12 19:27:33 +00006540 for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I =
6541 RHSInheritedProtocols.begin(),
6542 E = RHSInheritedProtocols.end(); I != E; ++I)
6543 if (InheritedProtocolSet.count((*I)))
6544 IntersectionOfProtocols.push_back((*I));
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00006545 }
6546}
6547
Fariborz Jahanianef8b8ce2009-10-27 23:02:38 +00006548/// areCommonBaseCompatible - Returns common base class of the two classes if
6549/// one found. Note that this is O'2 algorithm. But it will be called as the
6550/// last type comparison in a ?-exp of ObjC pointer types before a
6551/// warning is issued. So, its invokation is extremely rare.
6552QualType ASTContext::areCommonBaseCompatible(
John McCall8b07ec22010-05-15 11:32:37 +00006553 const ObjCObjectPointerType *Lptr,
6554 const ObjCObjectPointerType *Rptr) {
6555 const ObjCObjectType *LHS = Lptr->getObjectType();
6556 const ObjCObjectType *RHS = Rptr->getObjectType();
6557 const ObjCInterfaceDecl* LDecl = LHS->getInterface();
6558 const ObjCInterfaceDecl* RDecl = RHS->getInterface();
Douglas Gregor0b144e12011-12-15 00:29:59 +00006559 if (!LDecl || !RDecl || (declaresSameEntity(LDecl, RDecl)))
Fariborz Jahanianef8b8ce2009-10-27 23:02:38 +00006560 return QualType();
6561
Fariborz Jahanianb1071432011-04-18 21:16:59 +00006562 do {
John McCall8b07ec22010-05-15 11:32:37 +00006563 LHS = cast<ObjCInterfaceType>(getObjCInterfaceType(LDecl));
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00006564 if (canAssignObjCInterfaces(LHS, RHS)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006565 SmallVector<ObjCProtocolDecl *, 8> Protocols;
John McCall8b07ec22010-05-15 11:32:37 +00006566 getIntersectionOfProtocols(*this, Lptr, Rptr, Protocols);
6567
6568 QualType Result = QualType(LHS, 0);
6569 if (!Protocols.empty())
6570 Result = getObjCObjectType(Result, Protocols.data(), Protocols.size());
6571 Result = getObjCObjectPointerType(Result);
6572 return Result;
Fariborz Jahanian6c5a8e22009-10-30 01:13:23 +00006573 }
Fariborz Jahanianb1071432011-04-18 21:16:59 +00006574 } while ((LDecl = LDecl->getSuperClass()));
Fariborz Jahanianef8b8ce2009-10-27 23:02:38 +00006575
6576 return QualType();
6577}
6578
John McCall8b07ec22010-05-15 11:32:37 +00006579bool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS,
6580 const ObjCObjectType *RHS) {
6581 assert(LHS->getInterface() && "LHS is not an interface type");
6582 assert(RHS->getInterface() && "RHS is not an interface type");
6583
Chris Lattner49af6a42008-04-07 06:51:04 +00006584 // Verify that the base decls are compatible: the RHS must be a subclass of
6585 // the LHS.
John McCall8b07ec22010-05-15 11:32:37 +00006586 if (!LHS->getInterface()->isSuperClassOf(RHS->getInterface()))
Chris Lattner49af6a42008-04-07 06:51:04 +00006587 return false;
Mike Stump11289f42009-09-09 15:08:12 +00006588
Chris Lattner49af6a42008-04-07 06:51:04 +00006589 // RHS must have a superset of the protocols in the LHS. If the LHS is not
6590 // protocol qualified at all, then we are good.
Steve Naroffc277ad12009-07-18 15:33:26 +00006591 if (LHS->getNumProtocols() == 0)
Chris Lattner49af6a42008-04-07 06:51:04 +00006592 return true;
Mike Stump11289f42009-09-09 15:08:12 +00006593
Fariborz Jahanian4806ff82011-04-08 18:25:29 +00006594 // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't,
6595 // more detailed analysis is required.
6596 if (RHS->getNumProtocols() == 0) {
6597 // OK, if LHS is a superclass of RHS *and*
6598 // this superclass is assignment compatible with LHS.
6599 // false otherwise.
Fariborz Jahanian240400b2011-04-12 16:34:14 +00006600 bool IsSuperClass =
6601 LHS->getInterface()->isSuperClassOf(RHS->getInterface());
6602 if (IsSuperClass) {
Fariborz Jahanian4806ff82011-04-08 18:25:29 +00006603 // OK if conversion of LHS to SuperClass results in narrowing of types
6604 // ; i.e., SuperClass may implement at least one of the protocols
6605 // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok.
6606 // But not SuperObj<P1,P2,P3> = lhs<P1,P2>.
6607 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols;
Fariborz Jahanian240400b2011-04-12 16:34:14 +00006608 CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols);
Fariborz Jahanian4806ff82011-04-08 18:25:29 +00006609 // If super class has no protocols, it is not a match.
6610 if (SuperClassInheritedProtocols.empty())
6611 return false;
6612
6613 for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(),
6614 LHSPE = LHS->qual_end();
6615 LHSPI != LHSPE; LHSPI++) {
6616 bool SuperImplementsProtocol = false;
6617 ObjCProtocolDecl *LHSProto = (*LHSPI);
6618
6619 for (llvm::SmallPtrSet<ObjCProtocolDecl*,8>::iterator I =
6620 SuperClassInheritedProtocols.begin(),
6621 E = SuperClassInheritedProtocols.end(); I != E; ++I) {
6622 ObjCProtocolDecl *SuperClassProto = (*I);
6623 if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {
6624 SuperImplementsProtocol = true;
6625 break;
6626 }
6627 }
6628 if (!SuperImplementsProtocol)
6629 return false;
6630 }
6631 return true;
6632 }
6633 return false;
6634 }
Mike Stump11289f42009-09-09 15:08:12 +00006635
John McCall8b07ec22010-05-15 11:32:37 +00006636 for (ObjCObjectType::qual_iterator LHSPI = LHS->qual_begin(),
6637 LHSPE = LHS->qual_end();
Steve Naroff114aecb2009-03-01 16:12:44 +00006638 LHSPI != LHSPE; LHSPI++) {
6639 bool RHSImplementsProtocol = false;
6640
6641 // If the RHS doesn't implement the protocol on the left, the types
6642 // are incompatible.
John McCall8b07ec22010-05-15 11:32:37 +00006643 for (ObjCObjectType::qual_iterator RHSPI = RHS->qual_begin(),
6644 RHSPE = RHS->qual_end();
Steve Narofffac5bc92009-07-16 16:21:02 +00006645 RHSPI != RHSPE; RHSPI++) {
6646 if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) {
Steve Naroff114aecb2009-03-01 16:12:44 +00006647 RHSImplementsProtocol = true;
Steve Narofffac5bc92009-07-16 16:21:02 +00006648 break;
6649 }
Steve Naroff114aecb2009-03-01 16:12:44 +00006650 }
6651 // FIXME: For better diagnostics, consider passing back the protocol name.
6652 if (!RHSImplementsProtocol)
6653 return false;
Chris Lattner49af6a42008-04-07 06:51:04 +00006654 }
Steve Naroff114aecb2009-03-01 16:12:44 +00006655 // The RHS implements all protocols listed on the LHS.
6656 return true;
Chris Lattner49af6a42008-04-07 06:51:04 +00006657}
6658
Steve Naroffb7605152009-02-12 17:52:19 +00006659bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) {
6660 // get the "pointed to" types
John McCall9dd450b2009-09-21 23:43:11 +00006661 const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
6662 const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>();
Mike Stump11289f42009-09-09 15:08:12 +00006663
Steve Naroff7cae42b2009-07-10 23:34:53 +00006664 if (!LHSOPT || !RHSOPT)
Steve Naroffb7605152009-02-12 17:52:19 +00006665 return false;
Steve Naroff7cae42b2009-07-10 23:34:53 +00006666
6667 return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
6668 canAssignObjCInterfaces(RHSOPT, LHSOPT);
Steve Naroffb7605152009-02-12 17:52:19 +00006669}
6670
Douglas Gregor8b2d2fe2010-08-07 11:51:51 +00006671bool ASTContext::canBindObjCObjectType(QualType To, QualType From) {
6672 return canAssignObjCInterfaces(
6673 getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(),
6674 getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>());
6675}
6676
Mike Stump11289f42009-09-09 15:08:12 +00006677/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,
Steve Naroff32e44c02007-10-15 20:41:53 +00006678/// both shall have the identically qualified version of a compatible type.
Mike Stump11289f42009-09-09 15:08:12 +00006679/// C99 6.2.7p1: Two types have compatible types if their types are the
Steve Naroff32e44c02007-10-15 20:41:53 +00006680/// same. See 6.7.[2,3,5] for additional rules.
Douglas Gregor17ea3f52010-07-29 15:18:02 +00006681bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS,
6682 bool CompareUnqualified) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00006683 if (getLangOpts().CPlusPlus)
Douglas Gregor21e771e2010-02-03 21:02:30 +00006684 return hasSameType(LHS, RHS);
6685
Douglas Gregor17ea3f52010-07-29 15:18:02 +00006686 return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull();
Eli Friedman47f77112008-08-22 00:56:42 +00006687}
6688
Fariborz Jahanianc0f6af22011-07-12 22:05:16 +00006689bool ASTContext::propertyTypesAreCompatible(QualType LHS, QualType RHS) {
Fariborz Jahanianc87c8792011-07-12 23:20:13 +00006690 return typesAreCompatible(LHS, RHS);
Fariborz Jahanianc0f6af22011-07-12 22:05:16 +00006691}
6692
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006693bool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) {
6694 return !mergeTypes(LHS, RHS, true).isNull();
6695}
6696
Peter Collingbournea99fdcf2010-10-24 18:30:18 +00006697/// mergeTransparentUnionType - if T is a transparent union type and a member
6698/// of T is compatible with SubType, return the merged type, else return
6699/// QualType()
6700QualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType,
6701 bool OfBlockPointer,
6702 bool Unqualified) {
6703 if (const RecordType *UT = T->getAsUnionType()) {
6704 RecordDecl *UD = UT->getDecl();
6705 if (UD->hasAttr<TransparentUnionAttr>()) {
6706 for (RecordDecl::field_iterator it = UD->field_begin(),
6707 itend = UD->field_end(); it != itend; ++it) {
Peter Collingbourne19b961d2010-12-02 21:00:06 +00006708 QualType ET = it->getType().getUnqualifiedType();
Peter Collingbournea99fdcf2010-10-24 18:30:18 +00006709 QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified);
6710 if (!MT.isNull())
6711 return MT;
6712 }
6713 }
6714 }
6715
6716 return QualType();
6717}
6718
6719/// mergeFunctionArgumentTypes - merge two types which appear as function
6720/// argument types
6721QualType ASTContext::mergeFunctionArgumentTypes(QualType lhs, QualType rhs,
6722 bool OfBlockPointer,
6723 bool Unqualified) {
6724 // GNU extension: two types are compatible if they appear as a function
6725 // argument, one of the types is a transparent union type and the other
6726 // type is compatible with a union member
6727 QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer,
6728 Unqualified);
6729 if (!lmerge.isNull())
6730 return lmerge;
6731
6732 QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer,
6733 Unqualified);
6734 if (!rmerge.isNull())
6735 return rmerge;
6736
6737 return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified);
6738}
6739
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006740QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs,
Douglas Gregor17ea3f52010-07-29 15:18:02 +00006741 bool OfBlockPointer,
6742 bool Unqualified) {
John McCall9dd450b2009-09-21 23:43:11 +00006743 const FunctionType *lbase = lhs->getAs<FunctionType>();
6744 const FunctionType *rbase = rhs->getAs<FunctionType>();
Douglas Gregordeaad8c2009-02-26 23:50:07 +00006745 const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
6746 const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
Eli Friedman47f77112008-08-22 00:56:42 +00006747 bool allLTypes = true;
6748 bool allRTypes = true;
6749
6750 // Check return type
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006751 QualType retType;
Fariborz Jahanian17825972011-02-11 18:46:17 +00006752 if (OfBlockPointer) {
6753 QualType RHS = rbase->getResultType();
6754 QualType LHS = lbase->getResultType();
6755 bool UnqualifiedResult = Unqualified;
6756 if (!UnqualifiedResult)
6757 UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers());
Fariborz Jahanian90186f82011-03-14 16:07:00 +00006758 retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true);
Fariborz Jahanian17825972011-02-11 18:46:17 +00006759 }
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006760 else
John McCall8c6b56f2010-12-15 01:06:38 +00006761 retType = mergeTypes(lbase->getResultType(), rbase->getResultType(), false,
6762 Unqualified);
Eli Friedman47f77112008-08-22 00:56:42 +00006763 if (retType.isNull()) return QualType();
Douglas Gregor17ea3f52010-07-29 15:18:02 +00006764
6765 if (Unqualified)
6766 retType = retType.getUnqualifiedType();
6767
6768 CanQualType LRetType = getCanonicalType(lbase->getResultType());
6769 CanQualType RRetType = getCanonicalType(rbase->getResultType());
6770 if (Unqualified) {
6771 LRetType = LRetType.getUnqualifiedType();
6772 RRetType = RRetType.getUnqualifiedType();
6773 }
6774
6775 if (getCanonicalType(retType) != LRetType)
Chris Lattner465fa322008-10-05 17:34:18 +00006776 allLTypes = false;
Douglas Gregor17ea3f52010-07-29 15:18:02 +00006777 if (getCanonicalType(retType) != RRetType)
Chris Lattner465fa322008-10-05 17:34:18 +00006778 allRTypes = false;
John McCall8c6b56f2010-12-15 01:06:38 +00006779
Daniel Dunbaredd5bae2010-04-28 16:20:58 +00006780 // FIXME: double check this
6781 // FIXME: should we error if lbase->getRegParmAttr() != 0 &&
6782 // rbase->getRegParmAttr() != 0 &&
6783 // lbase->getRegParmAttr() != rbase->getRegParmAttr()?
Rafael Espindolac50c27c2010-03-30 20:24:48 +00006784 FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo();
6785 FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo();
John McCall8c6b56f2010-12-15 01:06:38 +00006786
Douglas Gregor8c940862010-01-18 17:14:39 +00006787 // Compatible functions must have compatible calling conventions
John McCall8c6b56f2010-12-15 01:06:38 +00006788 if (!isSameCallConv(lbaseInfo.getCC(), rbaseInfo.getCC()))
Douglas Gregor8c940862010-01-18 17:14:39 +00006789 return QualType();
Mike Stump11289f42009-09-09 15:08:12 +00006790
John McCall8c6b56f2010-12-15 01:06:38 +00006791 // Regparm is part of the calling convention.
Eli Friedmanc5b20b52011-04-09 08:18:08 +00006792 if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm())
6793 return QualType();
John McCall8c6b56f2010-12-15 01:06:38 +00006794 if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm())
6795 return QualType();
6796
John McCall31168b02011-06-15 23:02:42 +00006797 if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult())
6798 return QualType();
6799
John McCall8c6b56f2010-12-15 01:06:38 +00006800 // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'.
6801 bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn();
John McCall8c6b56f2010-12-15 01:06:38 +00006802
Rafael Espindola8778c282012-11-29 16:09:03 +00006803 if (lbaseInfo.getNoReturn() != NoReturn)
6804 allLTypes = false;
6805 if (rbaseInfo.getNoReturn() != NoReturn)
6806 allRTypes = false;
6807
John McCall31168b02011-06-15 23:02:42 +00006808 FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn);
John McCalldb40c7f2010-12-14 08:05:40 +00006809
Eli Friedman47f77112008-08-22 00:56:42 +00006810 if (lproto && rproto) { // two C99 style function prototypes
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00006811 assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&
6812 "C++ shouldn't be here");
Eli Friedman47f77112008-08-22 00:56:42 +00006813 unsigned lproto_nargs = lproto->getNumArgs();
6814 unsigned rproto_nargs = rproto->getNumArgs();
6815
6816 // Compatible functions must have the same number of arguments
6817 if (lproto_nargs != rproto_nargs)
6818 return QualType();
6819
6820 // Variadic and non-variadic functions aren't compatible
6821 if (lproto->isVariadic() != rproto->isVariadic())
6822 return QualType();
6823
Argyrios Kyrtzidis22a37352008-10-26 16:43:14 +00006824 if (lproto->getTypeQuals() != rproto->getTypeQuals())
6825 return QualType();
6826
Fariborz Jahanian97676972011-09-28 21:52:05 +00006827 if (LangOpts.ObjCAutoRefCount &&
6828 !FunctionTypesMatchOnNSConsumedAttrs(rproto, lproto))
6829 return QualType();
6830
Eli Friedman47f77112008-08-22 00:56:42 +00006831 // Check argument compatibility
Chris Lattner0e62c1c2011-07-23 10:55:15 +00006832 SmallVector<QualType, 10> types;
Eli Friedman47f77112008-08-22 00:56:42 +00006833 for (unsigned i = 0; i < lproto_nargs; i++) {
6834 QualType largtype = lproto->getArgType(i).getUnqualifiedType();
6835 QualType rargtype = rproto->getArgType(i).getUnqualifiedType();
Peter Collingbournea99fdcf2010-10-24 18:30:18 +00006836 QualType argtype = mergeFunctionArgumentTypes(largtype, rargtype,
6837 OfBlockPointer,
6838 Unqualified);
Eli Friedman47f77112008-08-22 00:56:42 +00006839 if (argtype.isNull()) return QualType();
Douglas Gregor17ea3f52010-07-29 15:18:02 +00006840
6841 if (Unqualified)
6842 argtype = argtype.getUnqualifiedType();
6843
Eli Friedman47f77112008-08-22 00:56:42 +00006844 types.push_back(argtype);
Douglas Gregor17ea3f52010-07-29 15:18:02 +00006845 if (Unqualified) {
6846 largtype = largtype.getUnqualifiedType();
6847 rargtype = rargtype.getUnqualifiedType();
6848 }
6849
Chris Lattner465fa322008-10-05 17:34:18 +00006850 if (getCanonicalType(argtype) != getCanonicalType(largtype))
6851 allLTypes = false;
6852 if (getCanonicalType(argtype) != getCanonicalType(rargtype))
6853 allRTypes = false;
Eli Friedman47f77112008-08-22 00:56:42 +00006854 }
Fariborz Jahanian97676972011-09-28 21:52:05 +00006855
Eli Friedman47f77112008-08-22 00:56:42 +00006856 if (allLTypes) return lhs;
6857 if (allRTypes) return rhs;
John McCalldb40c7f2010-12-14 08:05:40 +00006858
6859 FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo();
6860 EPI.ExtInfo = einfo;
Jordan Rose5c382722013-03-08 21:51:21 +00006861 return getFunctionType(retType, types, EPI);
Eli Friedman47f77112008-08-22 00:56:42 +00006862 }
6863
6864 if (lproto) allRTypes = false;
6865 if (rproto) allLTypes = false;
6866
Douglas Gregordeaad8c2009-02-26 23:50:07 +00006867 const FunctionProtoType *proto = lproto ? lproto : rproto;
Eli Friedman47f77112008-08-22 00:56:42 +00006868 if (proto) {
Sebastian Redl5068f77ac2009-05-27 22:11:52 +00006869 assert(!proto->hasExceptionSpec() && "C++ shouldn't be here");
Eli Friedman47f77112008-08-22 00:56:42 +00006870 if (proto->isVariadic()) return QualType();
6871 // Check that the types are compatible with the types that
6872 // would result from default argument promotions (C99 6.7.5.3p15).
6873 // The only types actually affected are promotable integer
6874 // types and floats, which would be passed as a different
6875 // type depending on whether the prototype is visible.
6876 unsigned proto_nargs = proto->getNumArgs();
6877 for (unsigned i = 0; i < proto_nargs; ++i) {
6878 QualType argTy = proto->getArgType(i);
Douglas Gregor2973d402010-02-03 19:27:29 +00006879
Eli Friedman448ce402012-08-30 00:44:15 +00006880 // Look at the converted type of enum types, since that is the type used
Douglas Gregor2973d402010-02-03 19:27:29 +00006881 // to pass enum values.
Eli Friedman448ce402012-08-30 00:44:15 +00006882 if (const EnumType *Enum = argTy->getAs<EnumType>()) {
6883 argTy = Enum->getDecl()->getIntegerType();
6884 if (argTy.isNull())
6885 return QualType();
6886 }
Douglas Gregor2973d402010-02-03 19:27:29 +00006887
Eli Friedman47f77112008-08-22 00:56:42 +00006888 if (argTy->isPromotableIntegerType() ||
6889 getCanonicalType(argTy).getUnqualifiedType() == FloatTy)
6890 return QualType();
6891 }
6892
6893 if (allLTypes) return lhs;
6894 if (allRTypes) return rhs;
John McCalldb40c7f2010-12-14 08:05:40 +00006895
6896 FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo();
6897 EPI.ExtInfo = einfo;
Jordan Rose5c382722013-03-08 21:51:21 +00006898 return getFunctionType(retType,
6899 ArrayRef<QualType>(proto->arg_type_begin(),
6900 proto->getNumArgs()),
6901 EPI);
Eli Friedman47f77112008-08-22 00:56:42 +00006902 }
6903
6904 if (allLTypes) return lhs;
6905 if (allRTypes) return rhs;
John McCall8c6b56f2010-12-15 01:06:38 +00006906 return getFunctionNoProtoType(retType, einfo);
Eli Friedman47f77112008-08-22 00:56:42 +00006907}
6908
John McCall433c2e62013-03-21 00:10:07 +00006909/// Given that we have an enum type and a non-enum type, try to merge them.
6910static QualType mergeEnumWithInteger(ASTContext &Context, const EnumType *ET,
6911 QualType other, bool isBlockReturnType) {
6912 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
6913 // a signed integer type, or an unsigned integer type.
6914 // Compatibility is based on the underlying type, not the promotion
6915 // type.
6916 QualType underlyingType = ET->getDecl()->getIntegerType();
6917 if (underlyingType.isNull()) return QualType();
6918 if (Context.hasSameType(underlyingType, other))
6919 return other;
6920
6921 // In block return types, we're more permissive and accept any
6922 // integral type of the same size.
6923 if (isBlockReturnType && other->isIntegerType() &&
6924 Context.getTypeSize(underlyingType) == Context.getTypeSize(other))
6925 return other;
6926
6927 return QualType();
6928}
6929
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00006930QualType ASTContext::mergeTypes(QualType LHS, QualType RHS,
Douglas Gregor17ea3f52010-07-29 15:18:02 +00006931 bool OfBlockPointer,
Fariborz Jahanian90186f82011-03-14 16:07:00 +00006932 bool Unqualified, bool BlockReturnType) {
Bill Wendlingdb4e3492007-12-03 07:33:35 +00006933 // C++ [expr]: If an expression initially has the type "reference to T", the
6934 // type is adjusted to "T" prior to any further analysis, the expression
6935 // designates the object or function denoted by the reference, and the
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00006936 // expression is an lvalue unless the reference is an rvalue reference and
6937 // the expression is a function call (possibly inside parentheses).
Douglas Gregor21e771e2010-02-03 21:02:30 +00006938 assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?");
6939 assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?");
Douglas Gregor17ea3f52010-07-29 15:18:02 +00006940
6941 if (Unqualified) {
6942 LHS = LHS.getUnqualifiedType();
6943 RHS = RHS.getUnqualifiedType();
6944 }
Douglas Gregor21e771e2010-02-03 21:02:30 +00006945
Eli Friedman47f77112008-08-22 00:56:42 +00006946 QualType LHSCan = getCanonicalType(LHS),
6947 RHSCan = getCanonicalType(RHS);
6948
6949 // If two types are identical, they are compatible.
6950 if (LHSCan == RHSCan)
6951 return LHS;
6952
John McCall8ccfcb52009-09-24 19:53:00 +00006953 // If the qualifiers are different, the types aren't compatible... mostly.
Douglas Gregor1b8fe5b72009-11-16 21:35:15 +00006954 Qualifiers LQuals = LHSCan.getLocalQualifiers();
6955 Qualifiers RQuals = RHSCan.getLocalQualifiers();
John McCall8ccfcb52009-09-24 19:53:00 +00006956 if (LQuals != RQuals) {
6957 // If any of these qualifiers are different, we have a type
6958 // mismatch.
6959 if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
John McCall31168b02011-06-15 23:02:42 +00006960 LQuals.getAddressSpace() != RQuals.getAddressSpace() ||
6961 LQuals.getObjCLifetime() != RQuals.getObjCLifetime())
John McCall8ccfcb52009-09-24 19:53:00 +00006962 return QualType();
6963
6964 // Exactly one GC qualifier difference is allowed: __strong is
6965 // okay if the other type has no GC qualifier but is an Objective
6966 // C object pointer (i.e. implicitly strong by default). We fix
6967 // this by pretending that the unqualified type was actually
6968 // qualified __strong.
6969 Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
6970 Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
6971 assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements");
6972
6973 if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
6974 return QualType();
6975
6976 if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) {
6977 return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong));
6978 }
6979 if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) {
6980 return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS);
6981 }
Eli Friedman47f77112008-08-22 00:56:42 +00006982 return QualType();
John McCall8ccfcb52009-09-24 19:53:00 +00006983 }
6984
6985 // Okay, qualifiers are equal.
Eli Friedman47f77112008-08-22 00:56:42 +00006986
Eli Friedmandcca6332009-06-01 01:22:52 +00006987 Type::TypeClass LHSClass = LHSCan->getTypeClass();
6988 Type::TypeClass RHSClass = RHSCan->getTypeClass();
Eli Friedman47f77112008-08-22 00:56:42 +00006989
Chris Lattnerfd652912008-01-14 05:45:46 +00006990 // We want to consider the two function types to be the same for these
6991 // comparisons, just force one to the other.
6992 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
6993 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
Eli Friedman16f90962008-02-12 08:23:06 +00006994
6995 // Same as above for arrays
Chris Lattner95554662008-04-07 05:43:21 +00006996 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
6997 LHSClass = Type::ConstantArray;
6998 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
6999 RHSClass = Type::ConstantArray;
Mike Stump11289f42009-09-09 15:08:12 +00007000
John McCall8b07ec22010-05-15 11:32:37 +00007001 // ObjCInterfaces are just specialized ObjCObjects.
7002 if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
7003 if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
7004
Nate Begemance4d7fc2008-04-18 23:10:10 +00007005 // Canonicalize ExtVector -> Vector.
7006 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
7007 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
Mike Stump11289f42009-09-09 15:08:12 +00007008
Chris Lattner95554662008-04-07 05:43:21 +00007009 // If the canonical type classes don't match.
Chris Lattnerfd652912008-01-14 05:45:46 +00007010 if (LHSClass != RHSClass) {
John McCall433c2e62013-03-21 00:10:07 +00007011 // Note that we only have special rules for turning block enum
7012 // returns into block int returns, not vice-versa.
John McCall9dd450b2009-09-21 23:43:11 +00007013 if (const EnumType* ETy = LHS->getAs<EnumType>()) {
John McCall433c2e62013-03-21 00:10:07 +00007014 return mergeEnumWithInteger(*this, ETy, RHS, false);
Eli Friedmana7bf7ed2008-02-12 08:46:17 +00007015 }
John McCall9dd450b2009-09-21 23:43:11 +00007016 if (const EnumType* ETy = RHS->getAs<EnumType>()) {
John McCall433c2e62013-03-21 00:10:07 +00007017 return mergeEnumWithInteger(*this, ETy, LHS, BlockReturnType);
Eli Friedmana7bf7ed2008-02-12 08:46:17 +00007018 }
Fariborz Jahanian26d83712012-01-26 00:45:38 +00007019 // allow block pointer type to match an 'id' type.
Fariborz Jahanian194904e2012-01-26 17:08:50 +00007020 if (OfBlockPointer && !BlockReturnType) {
7021 if (LHS->isObjCIdType() && RHS->isBlockPointerType())
7022 return LHS;
7023 if (RHS->isObjCIdType() && LHS->isBlockPointerType())
7024 return RHS;
7025 }
Fariborz Jahanian26d83712012-01-26 00:45:38 +00007026
Eli Friedman47f77112008-08-22 00:56:42 +00007027 return QualType();
Steve Naroff32e44c02007-10-15 20:41:53 +00007028 }
Eli Friedman47f77112008-08-22 00:56:42 +00007029
Steve Naroffc6edcbd2008-01-09 22:43:08 +00007030 // The canonical type classes match.
Chris Lattnerfd652912008-01-14 05:45:46 +00007031 switch (LHSClass) {
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007032#define TYPE(Class, Base)
7033#define ABSTRACT_TYPE(Class, Base)
John McCallbd8d9bd2010-03-01 23:49:17 +00007034#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007035#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
7036#define DEPENDENT_TYPE(Class, Base) case Type::Class:
7037#include "clang/AST/TypeNodes.def"
David Blaikie83d382b2011-09-23 05:06:16 +00007038 llvm_unreachable("Non-canonical and dependent types shouldn't get here");
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007039
Richard Smith27d807c2013-04-30 13:56:41 +00007040 case Type::Auto:
Sebastian Redl0f8b23f2009-03-16 23:22:08 +00007041 case Type::LValueReference:
7042 case Type::RValueReference:
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007043 case Type::MemberPointer:
David Blaikie83d382b2011-09-23 05:06:16 +00007044 llvm_unreachable("C++ should never be in mergeTypes");
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007045
John McCall8b07ec22010-05-15 11:32:37 +00007046 case Type::ObjCInterface:
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007047 case Type::IncompleteArray:
7048 case Type::VariableArray:
7049 case Type::FunctionProto:
7050 case Type::ExtVector:
David Blaikie83d382b2011-09-23 05:06:16 +00007051 llvm_unreachable("Types are eliminated above");
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007052
Chris Lattnerfd652912008-01-14 05:45:46 +00007053 case Type::Pointer:
Eli Friedman47f77112008-08-22 00:56:42 +00007054 {
7055 // Merge two pointer types, while trying to preserve typedef info
Ted Kremenekc23c7e62009-07-29 21:53:49 +00007056 QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType();
7057 QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType();
Douglas Gregor17ea3f52010-07-29 15:18:02 +00007058 if (Unqualified) {
7059 LHSPointee = LHSPointee.getUnqualifiedType();
7060 RHSPointee = RHSPointee.getUnqualifiedType();
7061 }
7062 QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false,
7063 Unqualified);
Eli Friedman47f77112008-08-22 00:56:42 +00007064 if (ResultType.isNull()) return QualType();
Eli Friedman091a9ac2009-06-02 05:28:56 +00007065 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
Chris Lattner465fa322008-10-05 17:34:18 +00007066 return LHS;
Eli Friedman091a9ac2009-06-02 05:28:56 +00007067 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
Chris Lattner465fa322008-10-05 17:34:18 +00007068 return RHS;
Eli Friedman47f77112008-08-22 00:56:42 +00007069 return getPointerType(ResultType);
7070 }
Steve Naroff68e167d2008-12-10 17:49:55 +00007071 case Type::BlockPointer:
7072 {
7073 // Merge two block pointer types, while trying to preserve typedef info
Ted Kremenekc23c7e62009-07-29 21:53:49 +00007074 QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType();
7075 QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType();
Douglas Gregor17ea3f52010-07-29 15:18:02 +00007076 if (Unqualified) {
7077 LHSPointee = LHSPointee.getUnqualifiedType();
7078 RHSPointee = RHSPointee.getUnqualifiedType();
7079 }
7080 QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer,
7081 Unqualified);
Steve Naroff68e167d2008-12-10 17:49:55 +00007082 if (ResultType.isNull()) return QualType();
7083 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
7084 return LHS;
7085 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
7086 return RHS;
7087 return getBlockPointerType(ResultType);
7088 }
Eli Friedman0dfb8892011-10-06 23:00:33 +00007089 case Type::Atomic:
7090 {
7091 // Merge two pointer types, while trying to preserve typedef info
7092 QualType LHSValue = LHS->getAs<AtomicType>()->getValueType();
7093 QualType RHSValue = RHS->getAs<AtomicType>()->getValueType();
7094 if (Unqualified) {
7095 LHSValue = LHSValue.getUnqualifiedType();
7096 RHSValue = RHSValue.getUnqualifiedType();
7097 }
7098 QualType ResultType = mergeTypes(LHSValue, RHSValue, false,
7099 Unqualified);
7100 if (ResultType.isNull()) return QualType();
7101 if (getCanonicalType(LHSValue) == getCanonicalType(ResultType))
7102 return LHS;
7103 if (getCanonicalType(RHSValue) == getCanonicalType(ResultType))
7104 return RHS;
7105 return getAtomicType(ResultType);
7106 }
Chris Lattnerfd652912008-01-14 05:45:46 +00007107 case Type::ConstantArray:
Eli Friedman47f77112008-08-22 00:56:42 +00007108 {
7109 const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
7110 const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
7111 if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
7112 return QualType();
7113
7114 QualType LHSElem = getAsArrayType(LHS)->getElementType();
7115 QualType RHSElem = getAsArrayType(RHS)->getElementType();
Douglas Gregor17ea3f52010-07-29 15:18:02 +00007116 if (Unqualified) {
7117 LHSElem = LHSElem.getUnqualifiedType();
7118 RHSElem = RHSElem.getUnqualifiedType();
7119 }
7120
7121 QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified);
Eli Friedman47f77112008-08-22 00:56:42 +00007122 if (ResultType.isNull()) return QualType();
Chris Lattner465fa322008-10-05 17:34:18 +00007123 if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
7124 return LHS;
7125 if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
7126 return RHS;
Eli Friedman3e62c212008-08-22 01:48:21 +00007127 if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(),
7128 ArrayType::ArraySizeModifier(), 0);
7129 if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(),
7130 ArrayType::ArraySizeModifier(), 0);
Eli Friedman47f77112008-08-22 00:56:42 +00007131 const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
7132 const VariableArrayType* RVAT = getAsVariableArrayType(RHS);
Chris Lattner465fa322008-10-05 17:34:18 +00007133 if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
7134 return LHS;
7135 if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
7136 return RHS;
Eli Friedman47f77112008-08-22 00:56:42 +00007137 if (LVAT) {
7138 // FIXME: This isn't correct! But tricky to implement because
7139 // the array's size has to be the size of LHS, but the type
7140 // has to be different.
7141 return LHS;
7142 }
7143 if (RVAT) {
7144 // FIXME: This isn't correct! But tricky to implement because
7145 // the array's size has to be the size of RHS, but the type
7146 // has to be different.
7147 return RHS;
7148 }
Eli Friedman3e62c212008-08-22 01:48:21 +00007149 if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
7150 if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
Douglas Gregor04318252009-07-06 15:59:29 +00007151 return getIncompleteArrayType(ResultType,
7152 ArrayType::ArraySizeModifier(), 0);
Eli Friedman47f77112008-08-22 00:56:42 +00007153 }
Chris Lattnerfd652912008-01-14 05:45:46 +00007154 case Type::FunctionNoProto:
Douglas Gregor17ea3f52010-07-29 15:18:02 +00007155 return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified);
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007156 case Type::Record:
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007157 case Type::Enum:
Eli Friedman47f77112008-08-22 00:56:42 +00007158 return QualType();
Chris Lattnerfd652912008-01-14 05:45:46 +00007159 case Type::Builtin:
Chris Lattner7bbd3d72008-04-07 05:55:38 +00007160 // Only exactly equal builtin types are compatible, which is tested above.
Eli Friedman47f77112008-08-22 00:56:42 +00007161 return QualType();
Daniel Dunbar804c0442009-01-28 21:22:12 +00007162 case Type::Complex:
7163 // Distinct complex types are incompatible.
7164 return QualType();
Chris Lattner7bbd3d72008-04-07 05:55:38 +00007165 case Type::Vector:
Eli Friedmancad96382009-02-27 23:04:43 +00007166 // FIXME: The merged type should be an ExtVector!
John McCall44c064b2010-03-12 23:14:13 +00007167 if (areCompatVectorTypes(LHSCan->getAs<VectorType>(),
7168 RHSCan->getAs<VectorType>()))
Eli Friedman47f77112008-08-22 00:56:42 +00007169 return LHS;
Chris Lattner465fa322008-10-05 17:34:18 +00007170 return QualType();
John McCall8b07ec22010-05-15 11:32:37 +00007171 case Type::ObjCObject: {
7172 // Check if the types are assignment compatible.
Eli Friedmancad96382009-02-27 23:04:43 +00007173 // FIXME: This should be type compatibility, e.g. whether
7174 // "LHS x; RHS x;" at global scope is legal.
John McCall8b07ec22010-05-15 11:32:37 +00007175 const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>();
7176 const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>();
7177 if (canAssignObjCInterfaces(LHSIface, RHSIface))
Steve Naroff7a7814c2009-02-21 16:18:07 +00007178 return LHS;
7179
Eli Friedman47f77112008-08-22 00:56:42 +00007180 return QualType();
Cedric Venet4fc88b72009-02-21 17:14:49 +00007181 }
Steve Naroff7cae42b2009-07-10 23:34:53 +00007182 case Type::ObjCObjectPointer: {
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00007183 if (OfBlockPointer) {
7184 if (canAssignObjCInterfacesInBlockPointer(
7185 LHS->getAs<ObjCObjectPointerType>(),
Fariborz Jahanian90186f82011-03-14 16:07:00 +00007186 RHS->getAs<ObjCObjectPointerType>(),
7187 BlockReturnType))
David Blaikie8a40f702012-01-17 06:56:22 +00007188 return LHS;
Fariborz Jahanianb8b0ea32010-03-17 00:20:01 +00007189 return QualType();
7190 }
John McCall9dd450b2009-09-21 23:43:11 +00007191 if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(),
7192 RHS->getAs<ObjCObjectPointerType>()))
Steve Naroff7cae42b2009-07-10 23:34:53 +00007193 return LHS;
7194
Steve Naroffc68cfcf2008-12-10 22:14:21 +00007195 return QualType();
David Blaikie8a40f702012-01-17 06:56:22 +00007196 }
Steve Naroff32e44c02007-10-15 20:41:53 +00007197 }
Douglas Gregordeaad8c2009-02-26 23:50:07 +00007198
David Blaikie8a40f702012-01-17 06:56:22 +00007199 llvm_unreachable("Invalid Type::Class!");
Steve Naroff32e44c02007-10-15 20:41:53 +00007200}
Ted Kremenekfc581a92007-10-31 17:10:13 +00007201
Fariborz Jahanian97676972011-09-28 21:52:05 +00007202bool ASTContext::FunctionTypesMatchOnNSConsumedAttrs(
7203 const FunctionProtoType *FromFunctionType,
7204 const FunctionProtoType *ToFunctionType) {
7205 if (FromFunctionType->hasAnyConsumedArgs() !=
7206 ToFunctionType->hasAnyConsumedArgs())
7207 return false;
7208 FunctionProtoType::ExtProtoInfo FromEPI =
7209 FromFunctionType->getExtProtoInfo();
7210 FunctionProtoType::ExtProtoInfo ToEPI =
7211 ToFunctionType->getExtProtoInfo();
7212 if (FromEPI.ConsumedArguments && ToEPI.ConsumedArguments)
7213 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs();
7214 ArgIdx != NumArgs; ++ArgIdx) {
7215 if (FromEPI.ConsumedArguments[ArgIdx] !=
7216 ToEPI.ConsumedArguments[ArgIdx])
7217 return false;
7218 }
7219 return true;
7220}
7221
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00007222/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and
7223/// 'RHS' attributes and returns the merged version; including for function
7224/// return types.
7225QualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) {
7226 QualType LHSCan = getCanonicalType(LHS),
7227 RHSCan = getCanonicalType(RHS);
7228 // If two types are identical, they are compatible.
7229 if (LHSCan == RHSCan)
7230 return LHS;
7231 if (RHSCan->isFunctionType()) {
7232 if (!LHSCan->isFunctionType())
7233 return QualType();
7234 QualType OldReturnType =
7235 cast<FunctionType>(RHSCan.getTypePtr())->getResultType();
7236 QualType NewReturnType =
7237 cast<FunctionType>(LHSCan.getTypePtr())->getResultType();
7238 QualType ResReturnType =
7239 mergeObjCGCQualifiers(NewReturnType, OldReturnType);
7240 if (ResReturnType.isNull())
7241 return QualType();
7242 if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
7243 // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo();
7244 // In either case, use OldReturnType to build the new function type.
7245 const FunctionType *F = LHS->getAs<FunctionType>();
7246 if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) {
John McCalldb40c7f2010-12-14 08:05:40 +00007247 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
7248 EPI.ExtInfo = getFunctionExtInfo(LHS);
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00007249 QualType ResultType
Jordan Rose5c382722013-03-08 21:51:21 +00007250 = getFunctionType(OldReturnType,
7251 ArrayRef<QualType>(FPT->arg_type_begin(),
7252 FPT->getNumArgs()),
7253 EPI);
Fariborz Jahanianf633ebd2010-05-19 21:37:30 +00007254 return ResultType;
7255 }
7256 }
7257 return QualType();
7258 }
7259
7260 // If the qualifiers are different, the types can still be merged.
7261 Qualifiers LQuals = LHSCan.getLocalQualifiers();
7262 Qualifiers RQuals = RHSCan.getLocalQualifiers();
7263 if (LQuals != RQuals) {
7264 // If any of these qualifiers are different, we have a type mismatch.
7265 if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
7266 LQuals.getAddressSpace() != RQuals.getAddressSpace())
7267 return QualType();
7268
7269 // Exactly one GC qualifier difference is allowed: __strong is
7270 // okay if the other type has no GC qualifier but is an Objective
7271 // C object pointer (i.e. implicitly strong by default). We fix
7272 // this by pretending that the unqualified type was actually
7273 // qualified __strong.
7274 Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
7275 Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
7276 assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements");
7277
7278 if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
7279 return QualType();
7280
7281 if (GC_L == Qualifiers::Strong)
7282 return LHS;
7283 if (GC_R == Qualifiers::Strong)
7284 return RHS;
7285 return QualType();
7286 }
7287
7288 if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) {
7289 QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType();
7290 QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType();
7291 QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT);
7292 if (ResQT == LHSBaseQT)
7293 return LHS;
7294 if (ResQT == RHSBaseQT)
7295 return RHS;
7296 }
7297 return QualType();
7298}
7299
Chris Lattner4ba0cef2008-04-07 07:01:58 +00007300//===----------------------------------------------------------------------===//
Eli Friedman4f89ccb2008-06-28 06:23:08 +00007301// Integer Predicates
7302//===----------------------------------------------------------------------===//
Chris Lattner3c919712009-01-16 07:15:35 +00007303
Jay Foad39c79802011-01-12 09:06:06 +00007304unsigned ASTContext::getIntWidth(QualType T) const {
John McCall424cec92011-01-19 06:33:43 +00007305 if (const EnumType *ET = dyn_cast<EnumType>(T))
Eli Friedmanee275c82009-12-10 22:29:29 +00007306 T = ET->getDecl()->getIntegerType();
Douglas Gregor0bf31402010-10-08 23:50:27 +00007307 if (T->isBooleanType())
7308 return 1;
Eli Friedman1efaaea2009-02-13 02:31:07 +00007309 // For builtin types, just use the standard type sizing method
Eli Friedman4f89ccb2008-06-28 06:23:08 +00007310 return (unsigned)getTypeSize(T);
7311}
7312
Abramo Bagnara13640492012-09-09 10:21:24 +00007313QualType ASTContext::getCorrespondingUnsignedType(QualType T) const {
Douglas Gregor5cc2c8b2010-07-23 15:58:24 +00007314 assert(T->hasSignedIntegerRepresentation() && "Unexpected type");
Chris Lattnerec3a1562009-10-17 20:33:28 +00007315
7316 // Turn <4 x signed int> -> <4 x unsigned int>
7317 if (const VectorType *VTy = T->getAs<VectorType>())
7318 return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()),
Bob Wilsonaeb56442010-11-10 21:56:12 +00007319 VTy->getNumElements(), VTy->getVectorKind());
Chris Lattnerec3a1562009-10-17 20:33:28 +00007320
7321 // For enums, we return the unsigned version of the base type.
7322 if (const EnumType *ETy = T->getAs<EnumType>())
Eli Friedman4f89ccb2008-06-28 06:23:08 +00007323 T = ETy->getDecl()->getIntegerType();
Chris Lattnerec3a1562009-10-17 20:33:28 +00007324
7325 const BuiltinType *BTy = T->getAs<BuiltinType>();
7326 assert(BTy && "Unexpected signed integer type");
Eli Friedman4f89ccb2008-06-28 06:23:08 +00007327 switch (BTy->getKind()) {
7328 case BuiltinType::Char_S:
7329 case BuiltinType::SChar:
7330 return UnsignedCharTy;
7331 case BuiltinType::Short:
7332 return UnsignedShortTy;
7333 case BuiltinType::Int:
7334 return UnsignedIntTy;
7335 case BuiltinType::Long:
7336 return UnsignedLongTy;
7337 case BuiltinType::LongLong:
7338 return UnsignedLongLongTy;
Chris Lattnerf122cef2009-04-30 02:43:43 +00007339 case BuiltinType::Int128:
7340 return UnsignedInt128Ty;
Eli Friedman4f89ccb2008-06-28 06:23:08 +00007341 default:
David Blaikie83d382b2011-09-23 05:06:16 +00007342 llvm_unreachable("Unexpected signed integer type");
Eli Friedman4f89ccb2008-06-28 06:23:08 +00007343 }
7344}
7345
Argyrios Kyrtzidis65ad5692010-10-24 17:26:36 +00007346ASTMutationListener::~ASTMutationListener() { }
7347
Chris Lattnerecd79c62009-06-14 00:45:47 +00007348
7349//===----------------------------------------------------------------------===//
7350// Builtin Type Computation
7351//===----------------------------------------------------------------------===//
7352
7353/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
Chris Lattnerdc226c22010-10-01 22:42:38 +00007354/// pointer over the consumed characters. This returns the resultant type. If
7355/// AllowTypeModifiers is false then modifier like * are not parsed, just basic
7356/// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of
7357/// a vector of "i*".
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007358///
7359/// RequiresICE is filled in on return to indicate whether the value is required
7360/// to be an Integer Constant Expression.
Jay Foad39c79802011-01-12 09:06:06 +00007361static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context,
Chris Lattnerecd79c62009-06-14 00:45:47 +00007362 ASTContext::GetBuiltinTypeError &Error,
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007363 bool &RequiresICE,
Chris Lattnerdc226c22010-10-01 22:42:38 +00007364 bool AllowTypeModifiers) {
Chris Lattnerecd79c62009-06-14 00:45:47 +00007365 // Modifiers.
7366 int HowLong = 0;
7367 bool Signed = false, Unsigned = false;
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007368 RequiresICE = false;
Chris Lattner84733392010-10-01 07:13:18 +00007369
Chris Lattnerdc226c22010-10-01 22:42:38 +00007370 // Read the prefixed modifiers first.
Chris Lattnerecd79c62009-06-14 00:45:47 +00007371 bool Done = false;
7372 while (!Done) {
7373 switch (*Str++) {
Mike Stump11289f42009-09-09 15:08:12 +00007374 default: Done = true; --Str; break;
Chris Lattner84733392010-10-01 07:13:18 +00007375 case 'I':
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007376 RequiresICE = true;
Chris Lattner84733392010-10-01 07:13:18 +00007377 break;
Chris Lattnerecd79c62009-06-14 00:45:47 +00007378 case 'S':
7379 assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!");
7380 assert(!Signed && "Can't use 'S' modifier multiple times!");
7381 Signed = true;
7382 break;
7383 case 'U':
7384 assert(!Signed && "Can't use both 'S' and 'U' modifiers!");
7385 assert(!Unsigned && "Can't use 'S' modifier multiple times!");
7386 Unsigned = true;
7387 break;
7388 case 'L':
7389 assert(HowLong <= 2 && "Can't have LLLL modifier");
7390 ++HowLong;
7391 break;
7392 }
7393 }
7394
7395 QualType Type;
Mike Stump11289f42009-09-09 15:08:12 +00007396
Chris Lattnerecd79c62009-06-14 00:45:47 +00007397 // Read the base type.
7398 switch (*Str++) {
David Blaikie83d382b2011-09-23 05:06:16 +00007399 default: llvm_unreachable("Unknown builtin type letter!");
Chris Lattnerecd79c62009-06-14 00:45:47 +00007400 case 'v':
7401 assert(HowLong == 0 && !Signed && !Unsigned &&
7402 "Bad modifiers used with 'v'!");
7403 Type = Context.VoidTy;
7404 break;
7405 case 'f':
7406 assert(HowLong == 0 && !Signed && !Unsigned &&
7407 "Bad modifiers used with 'f'!");
7408 Type = Context.FloatTy;
7409 break;
7410 case 'd':
7411 assert(HowLong < 2 && !Signed && !Unsigned &&
7412 "Bad modifiers used with 'd'!");
7413 if (HowLong)
7414 Type = Context.LongDoubleTy;
7415 else
7416 Type = Context.DoubleTy;
7417 break;
7418 case 's':
7419 assert(HowLong == 0 && "Bad modifiers used with 's'!");
7420 if (Unsigned)
7421 Type = Context.UnsignedShortTy;
7422 else
7423 Type = Context.ShortTy;
7424 break;
7425 case 'i':
7426 if (HowLong == 3)
7427 Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
7428 else if (HowLong == 2)
7429 Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
7430 else if (HowLong == 1)
7431 Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
7432 else
7433 Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
7434 break;
7435 case 'c':
7436 assert(HowLong == 0 && "Bad modifiers used with 'c'!");
7437 if (Signed)
7438 Type = Context.SignedCharTy;
7439 else if (Unsigned)
7440 Type = Context.UnsignedCharTy;
7441 else
7442 Type = Context.CharTy;
7443 break;
7444 case 'b': // boolean
7445 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!");
7446 Type = Context.BoolTy;
7447 break;
7448 case 'z': // size_t.
7449 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!");
7450 Type = Context.getSizeType();
7451 break;
7452 case 'F':
7453 Type = Context.getCFConstantStringType();
7454 break;
Fariborz Jahaniand11da7e2010-11-09 21:38:20 +00007455 case 'G':
7456 Type = Context.getObjCIdType();
7457 break;
7458 case 'H':
7459 Type = Context.getObjCSelType();
7460 break;
Fariborz Jahaniancb6c8672013-01-04 18:45:40 +00007461 case 'M':
7462 Type = Context.getObjCSuperType();
7463 break;
Chris Lattnerecd79c62009-06-14 00:45:47 +00007464 case 'a':
7465 Type = Context.getBuiltinVaListType();
7466 assert(!Type.isNull() && "builtin va list type not initialized!");
7467 break;
7468 case 'A':
7469 // This is a "reference" to a va_list; however, what exactly
7470 // this means depends on how va_list is defined. There are two
7471 // different kinds of va_list: ones passed by value, and ones
7472 // passed by reference. An example of a by-value va_list is
7473 // x86, where va_list is a char*. An example of by-ref va_list
7474 // is x86-64, where va_list is a __va_list_tag[1]. For x86,
7475 // we want this argument to be a char*&; for x86-64, we want
7476 // it to be a __va_list_tag*.
7477 Type = Context.getBuiltinVaListType();
7478 assert(!Type.isNull() && "builtin va list type not initialized!");
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007479 if (Type->isArrayType())
Chris Lattnerecd79c62009-06-14 00:45:47 +00007480 Type = Context.getArrayDecayedType(Type);
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007481 else
Chris Lattnerecd79c62009-06-14 00:45:47 +00007482 Type = Context.getLValueReferenceType(Type);
Chris Lattnerecd79c62009-06-14 00:45:47 +00007483 break;
7484 case 'V': {
7485 char *End;
Chris Lattnerecd79c62009-06-14 00:45:47 +00007486 unsigned NumElements = strtoul(Str, &End, 10);
7487 assert(End != Str && "Missing vector size");
Chris Lattnerecd79c62009-06-14 00:45:47 +00007488 Str = End;
Mike Stump11289f42009-09-09 15:08:12 +00007489
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007490 QualType ElementType = DecodeTypeFromStr(Str, Context, Error,
7491 RequiresICE, false);
7492 assert(!RequiresICE && "Can't require vector ICE");
Chris Lattnerdc226c22010-10-01 22:42:38 +00007493
7494 // TODO: No way to make AltiVec vectors in builtins yet.
Chris Lattner37141f42010-06-23 06:00:24 +00007495 Type = Context.getVectorType(ElementType, NumElements,
Bob Wilsonaeb56442010-11-10 21:56:12 +00007496 VectorType::GenericVector);
Chris Lattnerecd79c62009-06-14 00:45:47 +00007497 break;
7498 }
Douglas Gregorfed66992012-06-07 18:08:25 +00007499 case 'E': {
7500 char *End;
7501
7502 unsigned NumElements = strtoul(Str, &End, 10);
7503 assert(End != Str && "Missing vector size");
7504
7505 Str = End;
7506
7507 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
7508 false);
7509 Type = Context.getExtVectorType(ElementType, NumElements);
7510 break;
7511 }
Douglas Gregor40ef7c52009-09-28 21:45:01 +00007512 case 'X': {
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007513 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
7514 false);
7515 assert(!RequiresICE && "Can't require complex ICE");
Douglas Gregor40ef7c52009-09-28 21:45:01 +00007516 Type = Context.getComplexType(ElementType);
7517 break;
Fariborz Jahanian73952fc2011-08-23 23:33:09 +00007518 }
7519 case 'Y' : {
7520 Type = Context.getPointerDiffType();
7521 break;
7522 }
Chris Lattnera58b3af2009-07-28 22:49:34 +00007523 case 'P':
Douglas Gregor27821ce2009-07-07 16:35:42 +00007524 Type = Context.getFILEType();
7525 if (Type.isNull()) {
Mike Stump93246cc2009-07-28 23:57:15 +00007526 Error = ASTContext::GE_Missing_stdio;
Chris Lattnerecd79c62009-06-14 00:45:47 +00007527 return QualType();
7528 }
Mike Stump2adb4da2009-07-28 23:47:15 +00007529 break;
Chris Lattnera58b3af2009-07-28 22:49:34 +00007530 case 'J':
Mike Stump93246cc2009-07-28 23:57:15 +00007531 if (Signed)
Mike Stumpa4de80b2009-07-28 02:25:19 +00007532 Type = Context.getsigjmp_bufType();
Mike Stump93246cc2009-07-28 23:57:15 +00007533 else
7534 Type = Context.getjmp_bufType();
7535
Mike Stump2adb4da2009-07-28 23:47:15 +00007536 if (Type.isNull()) {
Mike Stump93246cc2009-07-28 23:57:15 +00007537 Error = ASTContext::GE_Missing_setjmp;
Mike Stump2adb4da2009-07-28 23:47:15 +00007538 return QualType();
7539 }
7540 break;
Rafael Espindola6cfa82b2011-11-13 21:51:09 +00007541 case 'K':
7542 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!");
7543 Type = Context.getucontext_tType();
7544
7545 if (Type.isNull()) {
7546 Error = ASTContext::GE_Missing_ucontext;
7547 return QualType();
7548 }
7549 break;
Eli Friedman4e91899e2012-11-27 02:58:24 +00007550 case 'p':
7551 Type = Context.getProcessIDType();
7552 break;
Mike Stumpa4de80b2009-07-28 02:25:19 +00007553 }
Mike Stump11289f42009-09-09 15:08:12 +00007554
Chris Lattnerdc226c22010-10-01 22:42:38 +00007555 // If there are modifiers and if we're allowed to parse them, go for it.
7556 Done = !AllowTypeModifiers;
Chris Lattnerecd79c62009-06-14 00:45:47 +00007557 while (!Done) {
John McCallb8b94662010-03-12 04:21:28 +00007558 switch (char c = *Str++) {
Chris Lattnerdc226c22010-10-01 22:42:38 +00007559 default: Done = true; --Str; break;
7560 case '*':
7561 case '&': {
7562 // Both pointers and references can have their pointee types
7563 // qualified with an address space.
7564 char *End;
7565 unsigned AddrSpace = strtoul(Str, &End, 10);
7566 if (End != Str && AddrSpace != 0) {
7567 Type = Context.getAddrSpaceQualType(Type, AddrSpace);
7568 Str = End;
7569 }
7570 if (c == '*')
7571 Type = Context.getPointerType(Type);
7572 else
7573 Type = Context.getLValueReferenceType(Type);
7574 break;
7575 }
7576 // FIXME: There's no way to have a built-in with an rvalue ref arg.
7577 case 'C':
7578 Type = Type.withConst();
7579 break;
7580 case 'D':
7581 Type = Context.getVolatileType(Type);
7582 break;
Ted Kremenekf2a2f5f2012-01-20 21:40:12 +00007583 case 'R':
7584 Type = Type.withRestrict();
7585 break;
Chris Lattnerecd79c62009-06-14 00:45:47 +00007586 }
7587 }
Chris Lattner84733392010-10-01 07:13:18 +00007588
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007589 assert((!RequiresICE || Type->isIntegralOrEnumerationType()) &&
Chris Lattner84733392010-10-01 07:13:18 +00007590 "Integer constant 'I' type must be an integer");
Mike Stump11289f42009-09-09 15:08:12 +00007591
Chris Lattnerecd79c62009-06-14 00:45:47 +00007592 return Type;
7593}
7594
7595/// GetBuiltinType - Return the type for the specified builtin.
Chris Lattnerdc226c22010-10-01 22:42:38 +00007596QualType ASTContext::GetBuiltinType(unsigned Id,
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007597 GetBuiltinTypeError &Error,
Jay Foad39c79802011-01-12 09:06:06 +00007598 unsigned *IntegerConstantArgs) const {
Chris Lattnerdc226c22010-10-01 22:42:38 +00007599 const char *TypeStr = BuiltinInfo.GetTypeString(Id);
Mike Stump11289f42009-09-09 15:08:12 +00007600
Chris Lattner0e62c1c2011-07-23 10:55:15 +00007601 SmallVector<QualType, 8> ArgTypes;
Mike Stump11289f42009-09-09 15:08:12 +00007602
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007603 bool RequiresICE = false;
Chris Lattnerecd79c62009-06-14 00:45:47 +00007604 Error = GE_None;
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007605 QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error,
7606 RequiresICE, true);
Chris Lattnerecd79c62009-06-14 00:45:47 +00007607 if (Error != GE_None)
7608 return QualType();
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007609
7610 assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE");
7611
Chris Lattnerecd79c62009-06-14 00:45:47 +00007612 while (TypeStr[0] && TypeStr[0] != '.') {
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007613 QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true);
Chris Lattnerecd79c62009-06-14 00:45:47 +00007614 if (Error != GE_None)
7615 return QualType();
7616
Chris Lattnerbd6e6932010-10-01 22:53:11 +00007617 // If this argument is required to be an IntegerConstantExpression and the
7618 // caller cares, fill in the bitmask we return.
7619 if (RequiresICE && IntegerConstantArgs)
7620 *IntegerConstantArgs |= 1 << ArgTypes.size();
7621
Chris Lattnerecd79c62009-06-14 00:45:47 +00007622 // Do array -> pointer decay. The builtin should use the decayed type.
7623 if (Ty->isArrayType())
7624 Ty = getArrayDecayedType(Ty);
Mike Stump11289f42009-09-09 15:08:12 +00007625
Chris Lattnerecd79c62009-06-14 00:45:47 +00007626 ArgTypes.push_back(Ty);
7627 }
7628
7629 assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&
7630 "'.' should only occur at end of builtin type list!");
7631
John McCall991eb4b2010-12-21 00:44:39 +00007632 FunctionType::ExtInfo EI;
7633 if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true);
7634
7635 bool Variadic = (TypeStr[0] == '.');
7636
7637 // We really shouldn't be making a no-proto type here, especially in C++.
7638 if (ArgTypes.empty() && Variadic)
7639 return getFunctionNoProtoType(ResType, EI);
Douglas Gregor36c569f2010-02-21 22:15:06 +00007640
John McCalldb40c7f2010-12-14 08:05:40 +00007641 FunctionProtoType::ExtProtoInfo EPI;
John McCall991eb4b2010-12-21 00:44:39 +00007642 EPI.ExtInfo = EI;
7643 EPI.Variadic = Variadic;
John McCalldb40c7f2010-12-14 08:05:40 +00007644
Jordan Rose5c382722013-03-08 21:51:21 +00007645 return getFunctionType(ResType, ArgTypes, EPI);
Chris Lattnerecd79c62009-06-14 00:45:47 +00007646}
Eli Friedman5ae98ee2009-08-19 07:44:53 +00007647
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007648GVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) {
7649 GVALinkage External = GVA_StrongExternal;
7650
7651 Linkage L = FD->getLinkage();
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007652 switch (L) {
7653 case NoLinkage:
7654 case InternalLinkage:
7655 case UniqueExternalLinkage:
7656 return GVA_Internal;
7657
7658 case ExternalLinkage:
7659 switch (FD->getTemplateSpecializationKind()) {
7660 case TSK_Undeclared:
7661 case TSK_ExplicitSpecialization:
7662 External = GVA_StrongExternal;
7663 break;
7664
7665 case TSK_ExplicitInstantiationDefinition:
7666 return GVA_ExplicitTemplateInstantiation;
7667
7668 case TSK_ExplicitInstantiationDeclaration:
7669 case TSK_ImplicitInstantiation:
7670 External = GVA_TemplateInstantiation;
7671 break;
7672 }
7673 }
7674
7675 if (!FD->isInlined())
7676 return External;
7677
David Blaikiebbafb8a2012-03-11 07:00:24 +00007678 if (!getLangOpts().CPlusPlus || FD->hasAttr<GNUInlineAttr>()) {
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007679 // GNU or C99 inline semantics. Determine whether this symbol should be
7680 // externally visible.
7681 if (FD->isInlineDefinitionExternallyVisible())
7682 return External;
7683
7684 // C99 inline semantics, where the symbol is not externally visible.
7685 return GVA_C99Inline;
7686 }
7687
7688 // C++0x [temp.explicit]p9:
7689 // [ Note: The intent is that an inline function that is the subject of
7690 // an explicit instantiation declaration will still be implicitly
7691 // instantiated when used so that the body can be considered for
7692 // inlining, but that no out-of-line copy of the inline function would be
7693 // generated in the translation unit. -- end note ]
7694 if (FD->getTemplateSpecializationKind()
7695 == TSK_ExplicitInstantiationDeclaration)
7696 return GVA_C99Inline;
7697
7698 return GVA_CXXInline;
7699}
7700
7701GVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) {
7702 // If this is a static data member, compute the kind of template
7703 // specialization. Otherwise, this variable is not part of a
7704 // template.
7705 TemplateSpecializationKind TSK = TSK_Undeclared;
7706 if (VD->isStaticDataMember())
7707 TSK = VD->getTemplateSpecializationKind();
7708
7709 Linkage L = VD->getLinkage();
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007710
7711 switch (L) {
7712 case NoLinkage:
7713 case InternalLinkage:
7714 case UniqueExternalLinkage:
7715 return GVA_Internal;
7716
7717 case ExternalLinkage:
7718 switch (TSK) {
7719 case TSK_Undeclared:
7720 case TSK_ExplicitSpecialization:
7721 return GVA_StrongExternal;
7722
7723 case TSK_ExplicitInstantiationDeclaration:
7724 llvm_unreachable("Variable should not be instantiated");
7725 // Fall through to treat this like any other instantiation.
7726
7727 case TSK_ExplicitInstantiationDefinition:
7728 return GVA_ExplicitTemplateInstantiation;
7729
7730 case TSK_ImplicitInstantiation:
7731 return GVA_TemplateInstantiation;
7732 }
7733 }
7734
David Blaikie8a40f702012-01-17 06:56:22 +00007735 llvm_unreachable("Invalid Linkage!");
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007736}
7737
Argyrios Kyrtzidisc9049332010-07-29 20:08:05 +00007738bool ASTContext::DeclMustBeEmitted(const Decl *D) {
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007739 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
7740 if (!VD->isFileVarDecl())
7741 return false;
Richard Smith5205a8c2013-04-01 20:22:16 +00007742 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
7743 // We never need to emit an uninstantiated function template.
7744 if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
7745 return false;
7746 } else
7747 return false;
7748
7749 // If this is a member of a class template, we do not need to emit it.
7750 if (D->getDeclContext()->isDependentContext())
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007751 return false;
7752
Argyrios Kyrtzidis6e03a742010-07-29 20:07:52 +00007753 // Weak references don't produce any output by themselves.
7754 if (D->hasAttr<WeakRefAttr>())
7755 return false;
7756
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007757 // Aliases and used decls are required.
7758 if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>())
7759 return true;
7760
7761 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
7762 // Forward declarations aren't required.
Alexis Hunt4a8ea102011-05-06 20:44:56 +00007763 if (!FD->doesThisDeclarationHaveABody())
Nick Lewycky26da4dd2011-07-18 05:26:13 +00007764 return FD->doesDeclarationForceExternallyVisibleDefinition();
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007765
7766 // Constructors and destructors are required.
7767 if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>())
7768 return true;
7769
John McCall6bd2a892013-01-25 22:31:03 +00007770 // The key function for a class is required. This rule only comes
7771 // into play when inline functions can be key functions, though.
7772 if (getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
7773 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
7774 const CXXRecordDecl *RD = MD->getParent();
7775 if (MD->isOutOfLine() && RD->isDynamicClass()) {
7776 const CXXMethodDecl *KeyFunc = getCurrentKeyFunction(RD);
7777 if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl())
7778 return true;
7779 }
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007780 }
7781 }
7782
7783 GVALinkage Linkage = GetGVALinkageForFunction(FD);
7784
7785 // static, static inline, always_inline, and extern inline functions can
7786 // always be deferred. Normal inline functions can be deferred in C99/C++.
7787 // Implicit template instantiations can also be deferred in C++.
7788 if (Linkage == GVA_Internal || Linkage == GVA_C99Inline ||
Anton Yartsev79de4d42012-02-02 06:06:34 +00007789 Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007790 return false;
7791 return true;
7792 }
Douglas Gregor87d81242011-09-10 00:22:34 +00007793
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007794 const VarDecl *VD = cast<VarDecl>(D);
7795 assert(VD->isFileVarDecl() && "Expected file scoped var");
7796
Argyrios Kyrtzidis6e03a742010-07-29 20:07:52 +00007797 if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly)
7798 return false;
7799
Richard Smitha0e5e542012-11-12 21:38:00 +00007800 // Variables that can be needed in other TUs are required.
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007801 GVALinkage L = GetGVALinkageForVariable(VD);
Richard Smitha0e5e542012-11-12 21:38:00 +00007802 if (L != GVA_Internal && L != GVA_TemplateInstantiation)
7803 return true;
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007804
Richard Smitha0e5e542012-11-12 21:38:00 +00007805 // Variables that have destruction with side-effects are required.
7806 if (VD->getType().isDestructedType())
7807 return true;
7808
7809 // Variables that have initialization with side-effects are required.
7810 if (VD->getInit() && VD->getInit()->HasSideEffects(*this))
7811 return true;
7812
7813 return false;
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +00007814}
Charles Davis53c59df2010-08-16 03:33:14 +00007815
Timur Iskhodzhanovc5098ad2012-07-12 09:50:54 +00007816CallingConv ASTContext::getDefaultCXXMethodCallConv(bool isVariadic) {
Charles Davis99202b32010-11-09 18:04:24 +00007817 // Pass through to the C++ ABI object
Timur Iskhodzhanovc5098ad2012-07-12 09:50:54 +00007818 return ABI->getDefaultMethodCallConv(isVariadic);
7819}
7820
7821CallingConv ASTContext::getCanonicalCallConv(CallingConv CC) const {
John McCall359b8852013-01-25 22:30:49 +00007822 if (CC == CC_C && !LangOpts.MRTD &&
7823 getTargetInfo().getCXXABI().isMemberFunctionCCDefault())
Timur Iskhodzhanovc5098ad2012-07-12 09:50:54 +00007824 return CC_Default;
7825 return CC;
Charles Davis99202b32010-11-09 18:04:24 +00007826}
7827
Jay Foad39c79802011-01-12 09:06:06 +00007828bool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const {
Anders Carlsson60a62632010-11-25 01:51:53 +00007829 // Pass through to the C++ ABI object
7830 return ABI->isNearlyEmpty(RD);
7831}
7832
Peter Collingbourne0ff0b372011-01-13 18:57:25 +00007833MangleContext *ASTContext::createMangleContext() {
John McCall359b8852013-01-25 22:30:49 +00007834 switch (Target->getCXXABI().getKind()) {
Tim Northover9bb857a2013-01-31 12:13:10 +00007835 case TargetCXXABI::GenericAArch64:
John McCall359b8852013-01-25 22:30:49 +00007836 case TargetCXXABI::GenericItanium:
7837 case TargetCXXABI::GenericARM:
7838 case TargetCXXABI::iOS:
Peter Collingbourne0ff0b372011-01-13 18:57:25 +00007839 return createItaniumMangleContext(*this, getDiagnostics());
John McCall359b8852013-01-25 22:30:49 +00007840 case TargetCXXABI::Microsoft:
Peter Collingbourne0ff0b372011-01-13 18:57:25 +00007841 return createMicrosoftMangleContext(*this, getDiagnostics());
7842 }
David Blaikie83d382b2011-09-23 05:06:16 +00007843 llvm_unreachable("Unsupported ABI");
Peter Collingbourne0ff0b372011-01-13 18:57:25 +00007844}
7845
Charles Davis53c59df2010-08-16 03:33:14 +00007846CXXABI::~CXXABI() {}
Ted Kremenekf5df0ce2011-04-28 04:53:38 +00007847
7848size_t ASTContext::getSideTableAllocatedMemory() const {
Ted Kremenek7d39c9a2011-07-27 18:41:12 +00007849 return ASTRecordLayouts.getMemorySize()
7850 + llvm::capacity_in_bytes(ObjCLayouts)
7851 + llvm::capacity_in_bytes(KeyFunctions)
7852 + llvm::capacity_in_bytes(ObjCImpls)
7853 + llvm::capacity_in_bytes(BlockVarCopyInits)
7854 + llvm::capacity_in_bytes(DeclAttrs)
7855 + llvm::capacity_in_bytes(InstantiatedFromStaticDataMember)
7856 + llvm::capacity_in_bytes(InstantiatedFromUsingDecl)
7857 + llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl)
7858 + llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl)
7859 + llvm::capacity_in_bytes(OverriddenMethods)
7860 + llvm::capacity_in_bytes(Types)
Francois Pichet00c7e6c2011-08-14 03:52:19 +00007861 + llvm::capacity_in_bytes(VariableArrayTypes)
Francois Pichet57928252011-08-14 14:28:49 +00007862 + llvm::capacity_in_bytes(ClassScopeSpecializationPattern);
Ted Kremenekf5df0ce2011-04-28 04:53:38 +00007863}
Ted Kremenek540017e2011-10-06 05:00:56 +00007864
David Blaikie095deba2012-11-14 01:52:05 +00007865void ASTContext::addUnnamedTag(const TagDecl *Tag) {
7866 // FIXME: This mangling should be applied to function local classes too
7867 if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl() ||
7868 !isa<CXXRecordDecl>(Tag->getParent()) || Tag->getLinkage() != ExternalLinkage)
7869 return;
7870
7871 std::pair<llvm::DenseMap<const DeclContext *, unsigned>::iterator, bool> P =
7872 UnnamedMangleContexts.insert(std::make_pair(Tag->getParent(), 0));
7873 UnnamedMangleNumbers.insert(std::make_pair(Tag, P.first->second++));
7874}
7875
7876int ASTContext::getUnnamedTagManglingNumber(const TagDecl *Tag) const {
7877 llvm::DenseMap<const TagDecl *, unsigned>::const_iterator I =
7878 UnnamedMangleNumbers.find(Tag);
7879 return I != UnnamedMangleNumbers.end() ? I->second : -1;
7880}
7881
Douglas Gregor63798542012-02-20 19:44:39 +00007882unsigned ASTContext::getLambdaManglingNumber(CXXMethodDecl *CallOperator) {
7883 CXXRecordDecl *Lambda = CallOperator->getParent();
7884 return LambdaMangleContexts[Lambda->getDeclContext()]
7885 .getManglingNumber(CallOperator);
7886}
7887
7888
Ted Kremenek540017e2011-10-06 05:00:56 +00007889void ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) {
7890 ParamIndices[D] = index;
7891}
7892
7893unsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const {
7894 ParameterIndexTable::const_iterator I = ParamIndices.find(D);
7895 assert(I != ParamIndices.end() &&
7896 "ParmIndices lacks entry set by ParmVarDecl");
7897 return I->second;
7898}