blob: ad46bcdca7e49ea44ddc2241d3f530bc2f6e79af [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- ASTContext.cpp - Context to hold long-lived AST nodes ------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the ASTContext interface.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ASTContext.h"
Argyrios Kyrtzidis49aa7ff2008-08-07 20:55:28 +000015#include "clang/AST/DeclCXX.h"
Steve Naroff980e5082007-10-01 19:00:59 +000016#include "clang/AST/DeclObjC.h"
Douglas Gregoraaba5e32009-02-04 19:02:06 +000017#include "clang/AST/DeclTemplate.h"
Daniel Dunbare91593e2008-08-11 04:54:23 +000018#include "clang/AST/Expr.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000019#include "clang/AST/ExternalASTSource.h"
Anders Carlsson19cc4ab2009-07-18 19:43:29 +000020#include "clang/AST/RecordLayout.h"
Chris Lattner1b63e4f2009-06-14 01:54:56 +000021#include "clang/Basic/Builtins.h"
Chris Lattnera9376d42009-03-28 03:45:20 +000022#include "clang/Basic/SourceManager.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000023#include "clang/Basic/TargetInfo.h"
Anders Carlsson85f9bce2007-10-29 05:01:08 +000024#include "llvm/ADT/StringExtras.h"
Nate Begeman6fe7c8a2009-01-18 06:42:49 +000025#include "llvm/Support/MathExtras.h"
Chris Lattner557c5b12009-03-28 04:27:18 +000026#include "llvm/Support/MemoryBuffer.h"
Anders Carlsson29445a02009-07-18 21:19:52 +000027#include "RecordLayoutBuilder.h"
28
Reid Spencer5f016e22007-07-11 17:01:13 +000029using namespace clang;
30
31enum FloatingRank {
32 FloatRank, DoubleRank, LongDoubleRank
33};
34
Chris Lattner61710852008-10-05 17:34:18 +000035ASTContext::ASTContext(const LangOptions& LOpts, SourceManager &SM,
36 TargetInfo &t,
Daniel Dunbare91593e2008-08-11 04:54:23 +000037 IdentifierTable &idents, SelectorTable &sels,
Chris Lattner1b63e4f2009-06-14 01:54:56 +000038 Builtin::Context &builtins,
39 bool FreeMem, unsigned size_reserve) :
Douglas Gregorab452ba2009-03-26 23:50:42 +000040 GlobalNestedNameSpecifier(0), CFConstantStringTypeDecl(0),
Mike Stump782fa302009-07-28 02:25:19 +000041 ObjCFastEnumerationStateTypeDecl(0), FILEDecl(0), jmp_bufDecl(0),
42 sigjmp_bufDecl(0), SourceMgr(SM), LangOpts(LOpts),
Douglas Gregor2e222532009-07-02 17:08:52 +000043 LoadedExternalComments(false), FreeMemory(FreeMem), Target(t),
44 Idents(idents), Selectors(sels),
Chris Lattnere4f21422009-06-30 01:26:17 +000045 BuiltinInfo(builtins), ExternalSource(0), PrintingPolicy(LOpts) {
Daniel Dunbare91593e2008-08-11 04:54:23 +000046 if (size_reserve > 0) Types.reserve(size_reserve);
Daniel Dunbare91593e2008-08-11 04:54:23 +000047 TUDecl = TranslationUnitDecl::Create(*this);
Steve Naroff14108da2009-07-10 23:34:53 +000048 InitBuiltinTypes();
Daniel Dunbare91593e2008-08-11 04:54:23 +000049}
50
Reid Spencer5f016e22007-07-11 17:01:13 +000051ASTContext::~ASTContext() {
52 // Deallocate all the types.
53 while (!Types.empty()) {
Ted Kremenek4b05b1d2008-05-21 16:38:54 +000054 Types.back()->Destroy(*this);
Reid Spencer5f016e22007-07-11 17:01:13 +000055 Types.pop_back();
56 }
Eli Friedmanb26153c2008-05-27 03:08:09 +000057
Nuno Lopesb74668e2008-12-17 22:30:25 +000058 {
59 llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
60 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end();
61 while (I != E) {
62 ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second);
63 delete R;
64 }
65 }
66
67 {
Daniel Dunbarb2dbbb92009-05-03 10:38:35 +000068 llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*>::iterator
69 I = ObjCLayouts.begin(), E = ObjCLayouts.end();
Nuno Lopesb74668e2008-12-17 22:30:25 +000070 while (I != E) {
71 ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second);
72 delete R;
73 }
74 }
75
Douglas Gregorab452ba2009-03-26 23:50:42 +000076 // Destroy nested-name-specifiers.
Douglas Gregor1ae0afa2009-03-27 23:54:10 +000077 for (llvm::FoldingSet<NestedNameSpecifier>::iterator
78 NNS = NestedNameSpecifiers.begin(),
79 NNSEnd = NestedNameSpecifiers.end();
Douglas Gregore7dcd782009-03-27 23:25:45 +000080 NNS != NNSEnd;
Douglas Gregor1ae0afa2009-03-27 23:54:10 +000081 /* Increment in loop */)
82 (*NNS++).Destroy(*this);
Douglas Gregorab452ba2009-03-26 23:50:42 +000083
84 if (GlobalNestedNameSpecifier)
85 GlobalNestedNameSpecifier->Destroy(*this);
86
Eli Friedmanb26153c2008-05-27 03:08:09 +000087 TUDecl->Destroy(*this);
Reid Spencer5f016e22007-07-11 17:01:13 +000088}
89
Douglas Gregor2cf26342009-04-09 22:27:44 +000090void
91ASTContext::setExternalSource(llvm::OwningPtr<ExternalASTSource> &Source) {
92 ExternalSource.reset(Source.take());
93}
94
Reid Spencer5f016e22007-07-11 17:01:13 +000095void ASTContext::PrintStats() const {
96 fprintf(stderr, "*** AST Context Stats:\n");
97 fprintf(stderr, " %d types total.\n", (int)Types.size());
Sebastian Redl7c80bd62009-03-16 23:22:08 +000098
Douglas Gregordbe833d2009-05-26 14:40:08 +000099 unsigned counts[] = {
100#define TYPE(Name, Parent) 0,
101#define ABSTRACT_TYPE(Name, Parent)
102#include "clang/AST/TypeNodes.def"
103 0 // Extra
104 };
Douglas Gregorc2ee10d2009-04-07 17:20:56 +0000105
Reid Spencer5f016e22007-07-11 17:01:13 +0000106 for (unsigned i = 0, e = Types.size(); i != e; ++i) {
107 Type *T = Types[i];
Douglas Gregordbe833d2009-05-26 14:40:08 +0000108 counts[(unsigned)T->getTypeClass()]++;
Reid Spencer5f016e22007-07-11 17:01:13 +0000109 }
110
Douglas Gregordbe833d2009-05-26 14:40:08 +0000111 unsigned Idx = 0;
112 unsigned TotalBytes = 0;
113#define TYPE(Name, Parent) \
114 if (counts[Idx]) \
115 fprintf(stderr, " %d %s types\n", (int)counts[Idx], #Name); \
116 TotalBytes += counts[Idx] * sizeof(Name##Type); \
117 ++Idx;
118#define ABSTRACT_TYPE(Name, Parent)
119#include "clang/AST/TypeNodes.def"
120
121 fprintf(stderr, "Total bytes = %d\n", int(TotalBytes));
Douglas Gregor2cf26342009-04-09 22:27:44 +0000122
123 if (ExternalSource.get()) {
124 fprintf(stderr, "\n");
125 ExternalSource->PrintStats();
126 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000127}
128
129
130void ASTContext::InitBuiltinType(QualType &R, BuiltinType::Kind K) {
Steve Narofff83820b2009-01-27 22:08:43 +0000131 Types.push_back((R = QualType(new (*this,8) BuiltinType(K),0)).getTypePtr());
Reid Spencer5f016e22007-07-11 17:01:13 +0000132}
133
Reid Spencer5f016e22007-07-11 17:01:13 +0000134void ASTContext::InitBuiltinTypes() {
135 assert(VoidTy.isNull() && "Context reinitialized?");
136
137 // C99 6.2.5p19.
138 InitBuiltinType(VoidTy, BuiltinType::Void);
139
140 // C99 6.2.5p2.
141 InitBuiltinType(BoolTy, BuiltinType::Bool);
142 // C99 6.2.5p3.
Eli Friedman15b91762009-06-05 07:05:05 +0000143 if (LangOpts.CharIsSigned)
Reid Spencer5f016e22007-07-11 17:01:13 +0000144 InitBuiltinType(CharTy, BuiltinType::Char_S);
145 else
146 InitBuiltinType(CharTy, BuiltinType::Char_U);
147 // C99 6.2.5p4.
148 InitBuiltinType(SignedCharTy, BuiltinType::SChar);
149 InitBuiltinType(ShortTy, BuiltinType::Short);
150 InitBuiltinType(IntTy, BuiltinType::Int);
151 InitBuiltinType(LongTy, BuiltinType::Long);
152 InitBuiltinType(LongLongTy, BuiltinType::LongLong);
153
154 // C99 6.2.5p6.
155 InitBuiltinType(UnsignedCharTy, BuiltinType::UChar);
156 InitBuiltinType(UnsignedShortTy, BuiltinType::UShort);
157 InitBuiltinType(UnsignedIntTy, BuiltinType::UInt);
158 InitBuiltinType(UnsignedLongTy, BuiltinType::ULong);
159 InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong);
160
161 // C99 6.2.5p10.
162 InitBuiltinType(FloatTy, BuiltinType::Float);
163 InitBuiltinType(DoubleTy, BuiltinType::Double);
164 InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble);
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +0000165
Chris Lattner2df9ced2009-04-30 02:43:43 +0000166 // GNU extension, 128-bit integers.
167 InitBuiltinType(Int128Ty, BuiltinType::Int128);
168 InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128);
169
Chris Lattner3a250322009-02-26 23:43:47 +0000170 if (LangOpts.CPlusPlus) // C++ 3.9.1p5
171 InitBuiltinType(WCharTy, BuiltinType::WChar);
172 else // C99
173 WCharTy = getFromTargetType(Target.getWCharType());
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +0000174
Alisdair Meredithf5c209d2009-07-14 06:30:34 +0000175 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
176 InitBuiltinType(Char16Ty, BuiltinType::Char16);
177 else // C99
178 Char16Ty = getFromTargetType(Target.getChar16Type());
179
180 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
181 InitBuiltinType(Char32Ty, BuiltinType::Char32);
182 else // C99
183 Char32Ty = getFromTargetType(Target.getChar32Type());
184
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000185 // Placeholder type for functions.
Douglas Gregor898574e2008-12-05 23:32:09 +0000186 InitBuiltinType(OverloadTy, BuiltinType::Overload);
187
188 // Placeholder type for type-dependent expressions whose type is
189 // completely unknown. No code should ever check a type against
190 // DependentTy and users should never see it; however, it is here to
191 // help diagnose failures to properly check for type-dependent
192 // expressions.
193 InitBuiltinType(DependentTy, BuiltinType::Dependent);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000194
Anders Carlssone89d1592009-06-26 18:41:36 +0000195 // Placeholder type for C++0x auto declarations whose real type has
196 // not yet been deduced.
197 InitBuiltinType(UndeducedAutoTy, BuiltinType::UndeducedAuto);
198
Reid Spencer5f016e22007-07-11 17:01:13 +0000199 // C99 6.2.5p11.
200 FloatComplexTy = getComplexType(FloatTy);
201 DoubleComplexTy = getComplexType(DoubleTy);
202 LongDoubleComplexTy = getComplexType(LongDoubleTy);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000203
Steve Naroff7e219e42007-10-15 14:41:52 +0000204 BuiltinVaListType = QualType();
Anders Carlsson8baaca52007-10-31 02:53:19 +0000205
Steve Naroffde2e22d2009-07-15 18:40:39 +0000206 // "Builtin" typedefs set by Sema::ActOnTranslationUnitScope().
207 ObjCIdTypedefType = QualType();
208 ObjCClassTypedefType = QualType();
209
210 // Builtin types for 'id' and 'Class'.
211 InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
212 InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
Steve Naroff14108da2009-07-10 23:34:53 +0000213
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000214 ObjCConstantStringType = QualType();
Fariborz Jahanian33e1d642007-10-29 22:57:28 +0000215
216 // void * type
217 VoidPtrTy = getPointerType(VoidTy);
Sebastian Redl6e8ed162009-05-10 18:38:11 +0000218
219 // nullptr type (C++0x 2.14.7)
220 InitBuiltinType(NullPtrTy, BuiltinType::NullPtr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000221}
222
Douglas Gregor7caa6822009-07-24 20:34:43 +0000223VarDecl *ASTContext::getInstantiatedFromStaticDataMember(VarDecl *Var) {
224 assert(Var->isStaticDataMember() && "Not a static data member");
225 llvm::DenseMap<VarDecl *, VarDecl *>::iterator Pos
226 = InstantiatedFromStaticDataMember.find(Var);
227 if (Pos == InstantiatedFromStaticDataMember.end())
228 return 0;
229
230 return Pos->second;
231}
232
233void
234ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl) {
235 assert(Inst->isStaticDataMember() && "Not a static data member");
236 assert(Tmpl->isStaticDataMember() && "Not a static data member");
237 assert(!InstantiatedFromStaticDataMember[Inst] &&
238 "Already noted what static data member was instantiated from");
239 InstantiatedFromStaticDataMember[Inst] = Tmpl;
240}
241
Douglas Gregor2e222532009-07-02 17:08:52 +0000242namespace {
243 class BeforeInTranslationUnit
244 : std::binary_function<SourceRange, SourceRange, bool> {
245 SourceManager *SourceMgr;
246
247 public:
248 explicit BeforeInTranslationUnit(SourceManager *SM) : SourceMgr(SM) { }
249
250 bool operator()(SourceRange X, SourceRange Y) {
251 return SourceMgr->isBeforeInTranslationUnit(X.getBegin(), Y.getBegin());
252 }
253 };
254}
255
256/// \brief Determine whether the given comment is a Doxygen-style comment.
257///
258/// \param Start the start of the comment text.
259///
260/// \param End the end of the comment text.
261///
262/// \param Member whether we want to check whether this is a member comment
263/// (which requires a < after the Doxygen-comment delimiter). Otherwise,
264/// we only return true when we find a non-member comment.
265static bool
266isDoxygenComment(SourceManager &SourceMgr, SourceRange Comment,
267 bool Member = false) {
268 const char *BufferStart
269 = SourceMgr.getBufferData(SourceMgr.getFileID(Comment.getBegin())).first;
270 const char *Start = BufferStart + SourceMgr.getFileOffset(Comment.getBegin());
271 const char* End = BufferStart + SourceMgr.getFileOffset(Comment.getEnd());
272
273 if (End - Start < 4)
274 return false;
275
276 assert(Start[0] == '/' && "Not a comment?");
277 if (Start[1] == '*' && !(Start[2] == '!' || Start[2] == '*'))
278 return false;
279 if (Start[1] == '/' && !(Start[2] == '!' || Start[2] == '/'))
280 return false;
281
282 return (Start[3] == '<') == Member;
283}
284
285/// \brief Retrieve the comment associated with the given declaration, if
286/// it has one.
287const char *ASTContext::getCommentForDecl(const Decl *D) {
288 if (!D)
289 return 0;
290
291 // Check whether we have cached a comment string for this declaration
292 // already.
293 llvm::DenseMap<const Decl *, std::string>::iterator Pos
294 = DeclComments.find(D);
295 if (Pos != DeclComments.end())
296 return Pos->second.c_str();
297
298 // If we have an external AST source and have not yet loaded comments from
299 // that source, do so now.
300 if (ExternalSource && !LoadedExternalComments) {
301 std::vector<SourceRange> LoadedComments;
302 ExternalSource->ReadComments(LoadedComments);
303
304 if (!LoadedComments.empty())
305 Comments.insert(Comments.begin(), LoadedComments.begin(),
306 LoadedComments.end());
307
308 LoadedExternalComments = true;
309 }
310
311 // If there are no comments anywhere, we won't find anything.
312 if (Comments.empty())
313 return 0;
314
315 // If the declaration doesn't map directly to a location in a file, we
316 // can't find the comment.
317 SourceLocation DeclStartLoc = D->getLocStart();
318 if (DeclStartLoc.isInvalid() || !DeclStartLoc.isFileID())
319 return 0;
320
321 // Find the comment that occurs just before this declaration.
322 std::vector<SourceRange>::iterator LastComment
323 = std::lower_bound(Comments.begin(), Comments.end(),
324 SourceRange(DeclStartLoc),
325 BeforeInTranslationUnit(&SourceMgr));
326
327 // Decompose the location for the start of the declaration and find the
328 // beginning of the file buffer.
329 std::pair<FileID, unsigned> DeclStartDecomp
330 = SourceMgr.getDecomposedLoc(DeclStartLoc);
331 const char *FileBufferStart
332 = SourceMgr.getBufferData(DeclStartDecomp.first).first;
333
334 // First check whether we have a comment for a member.
335 if (LastComment != Comments.end() &&
336 !isa<TagDecl>(D) && !isa<NamespaceDecl>(D) &&
337 isDoxygenComment(SourceMgr, *LastComment, true)) {
338 std::pair<FileID, unsigned> LastCommentEndDecomp
339 = SourceMgr.getDecomposedLoc(LastComment->getEnd());
340 if (DeclStartDecomp.first == LastCommentEndDecomp.first &&
341 SourceMgr.getLineNumber(DeclStartDecomp.first, DeclStartDecomp.second)
342 == SourceMgr.getLineNumber(LastCommentEndDecomp.first,
343 LastCommentEndDecomp.second)) {
344 // The Doxygen member comment comes after the declaration starts and
345 // is on the same line and in the same file as the declaration. This
346 // is the comment we want.
347 std::string &Result = DeclComments[D];
348 Result.append(FileBufferStart +
349 SourceMgr.getFileOffset(LastComment->getBegin()),
350 FileBufferStart + LastCommentEndDecomp.second + 1);
351 return Result.c_str();
352 }
353 }
354
355 if (LastComment == Comments.begin())
356 return 0;
357 --LastComment;
358
359 // Decompose the end of the comment.
360 std::pair<FileID, unsigned> LastCommentEndDecomp
361 = SourceMgr.getDecomposedLoc(LastComment->getEnd());
362
363 // If the comment and the declaration aren't in the same file, then they
364 // aren't related.
365 if (DeclStartDecomp.first != LastCommentEndDecomp.first)
366 return 0;
367
368 // Check that we actually have a Doxygen comment.
369 if (!isDoxygenComment(SourceMgr, *LastComment))
370 return 0;
371
372 // Compute the starting line for the declaration and for the end of the
373 // comment (this is expensive).
374 unsigned DeclStartLine
375 = SourceMgr.getLineNumber(DeclStartDecomp.first, DeclStartDecomp.second);
376 unsigned CommentEndLine
377 = SourceMgr.getLineNumber(LastCommentEndDecomp.first,
378 LastCommentEndDecomp.second);
379
380 // If the comment does not end on the line prior to the declaration, then
381 // the comment is not associated with the declaration at all.
382 if (CommentEndLine + 1 != DeclStartLine)
383 return 0;
384
385 // We have a comment, but there may be more comments on the previous lines.
386 // Keep looking so long as the comments are still Doxygen comments and are
387 // still adjacent.
388 unsigned ExpectedLine
389 = SourceMgr.getSpellingLineNumber(LastComment->getBegin()) - 1;
390 std::vector<SourceRange>::iterator FirstComment = LastComment;
391 while (FirstComment != Comments.begin()) {
392 // Look at the previous comment
393 --FirstComment;
394 std::pair<FileID, unsigned> Decomp
395 = SourceMgr.getDecomposedLoc(FirstComment->getEnd());
396
397 // If this previous comment is in a different file, we're done.
398 if (Decomp.first != DeclStartDecomp.first) {
399 ++FirstComment;
400 break;
401 }
402
403 // If this comment is not a Doxygen comment, we're done.
404 if (!isDoxygenComment(SourceMgr, *FirstComment)) {
405 ++FirstComment;
406 break;
407 }
408
409 // If the line number is not what we expected, we're done.
410 unsigned Line = SourceMgr.getLineNumber(Decomp.first, Decomp.second);
411 if (Line != ExpectedLine) {
412 ++FirstComment;
413 break;
414 }
415
416 // Set the next expected line number.
417 ExpectedLine
418 = SourceMgr.getSpellingLineNumber(FirstComment->getBegin()) - 1;
419 }
420
421 // The iterator range [FirstComment, LastComment] contains all of the
422 // BCPL comments that, together, are associated with this declaration.
423 // Form a single comment block string for this declaration that concatenates
424 // all of these comments.
425 std::string &Result = DeclComments[D];
426 while (FirstComment != LastComment) {
427 std::pair<FileID, unsigned> DecompStart
428 = SourceMgr.getDecomposedLoc(FirstComment->getBegin());
429 std::pair<FileID, unsigned> DecompEnd
430 = SourceMgr.getDecomposedLoc(FirstComment->getEnd());
431 Result.append(FileBufferStart + DecompStart.second,
432 FileBufferStart + DecompEnd.second + 1);
433 ++FirstComment;
434 }
435
436 // Append the last comment line.
437 Result.append(FileBufferStart +
438 SourceMgr.getFileOffset(LastComment->getBegin()),
439 FileBufferStart + LastCommentEndDecomp.second + 1);
440 return Result.c_str();
441}
442
Chris Lattner464175b2007-07-18 17:52:12 +0000443//===----------------------------------------------------------------------===//
444// Type Sizing and Analysis
445//===----------------------------------------------------------------------===//
Chris Lattnera7674d82007-07-13 22:13:22 +0000446
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000447/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
448/// scalar floating point type.
449const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
450 const BuiltinType *BT = T->getAsBuiltinType();
451 assert(BT && "Not a floating point type!");
452 switch (BT->getKind()) {
453 default: assert(0 && "Not a floating point type!");
454 case BuiltinType::Float: return Target.getFloatFormat();
455 case BuiltinType::Double: return Target.getDoubleFormat();
456 case BuiltinType::LongDouble: return Target.getLongDoubleFormat();
457 }
458}
459
Chris Lattneraf707ab2009-01-24 21:53:27 +0000460/// getDeclAlign - Return a conservative estimate of the alignment of the
461/// specified decl. Note that bitfields do not have a valid alignment, so
462/// this method will assert on them.
Daniel Dunbarb7d08442009-02-17 22:16:19 +0000463unsigned ASTContext::getDeclAlignInBytes(const Decl *D) {
Eli Friedmandcdafb62009-02-22 02:56:25 +0000464 unsigned Align = Target.getCharWidth();
465
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000466 if (const AlignedAttr* AA = D->getAttr<AlignedAttr>())
Eli Friedmandcdafb62009-02-22 02:56:25 +0000467 Align = std::max(Align, AA->getAlignment());
468
Chris Lattneraf707ab2009-01-24 21:53:27 +0000469 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
470 QualType T = VD->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +0000471 if (const ReferenceType* RT = T->getAs<ReferenceType>()) {
Anders Carlsson4cc2cfd2009-04-10 04:47:03 +0000472 unsigned AS = RT->getPointeeType().getAddressSpace();
Anders Carlssonf0930232009-04-10 04:52:36 +0000473 Align = Target.getPointerAlign(AS);
Anders Carlsson4cc2cfd2009-04-10 04:47:03 +0000474 } else if (!T->isIncompleteType() && !T->isFunctionType()) {
475 // Incomplete or function types default to 1.
Eli Friedmandcdafb62009-02-22 02:56:25 +0000476 while (isa<VariableArrayType>(T) || isa<IncompleteArrayType>(T))
477 T = cast<ArrayType>(T)->getElementType();
478
479 Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
480 }
Chris Lattneraf707ab2009-01-24 21:53:27 +0000481 }
Eli Friedmandcdafb62009-02-22 02:56:25 +0000482
483 return Align / Target.getCharWidth();
Chris Lattneraf707ab2009-01-24 21:53:27 +0000484}
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000485
Chris Lattnera7674d82007-07-13 22:13:22 +0000486/// getTypeSize - Return the size of the specified type, in bits. This method
487/// does not work on incomplete types.
Chris Lattnerd2d2a112007-07-14 01:29:45 +0000488std::pair<uint64_t, unsigned>
Daniel Dunbar1d751182008-11-08 05:48:37 +0000489ASTContext::getTypeInfo(const Type *T) {
Mike Stump5e301002009-02-27 18:32:39 +0000490 uint64_t Width=0;
491 unsigned Align=8;
Chris Lattnera7674d82007-07-13 22:13:22 +0000492 switch (T->getTypeClass()) {
Douglas Gregor72564e72009-02-26 23:50:07 +0000493#define TYPE(Class, Base)
494#define ABSTRACT_TYPE(Class, Base)
Douglas Gregor18857642009-04-30 17:32:17 +0000495#define NON_CANONICAL_TYPE(Class, Base)
Douglas Gregor72564e72009-02-26 23:50:07 +0000496#define DEPENDENT_TYPE(Class, Base) case Type::Class:
497#include "clang/AST/TypeNodes.def"
Douglas Gregor18857642009-04-30 17:32:17 +0000498 assert(false && "Should not see dependent types");
Douglas Gregor72564e72009-02-26 23:50:07 +0000499 break;
500
Chris Lattner692233e2007-07-13 22:27:08 +0000501 case Type::FunctionNoProto:
502 case Type::FunctionProto:
Douglas Gregor18857642009-04-30 17:32:17 +0000503 // GCC extension: alignof(function) = 32 bits
504 Width = 0;
505 Align = 32;
506 break;
507
Douglas Gregor72564e72009-02-26 23:50:07 +0000508 case Type::IncompleteArray:
Steve Narofffb22d962007-08-30 01:06:46 +0000509 case Type::VariableArray:
Douglas Gregor18857642009-04-30 17:32:17 +0000510 Width = 0;
511 Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
512 break;
513
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +0000514 case Type::ConstantArrayWithExpr:
515 case Type::ConstantArrayWithoutExpr:
Steve Narofffb22d962007-08-30 01:06:46 +0000516 case Type::ConstantArray: {
Daniel Dunbar1d751182008-11-08 05:48:37 +0000517 const ConstantArrayType *CAT = cast<ConstantArrayType>(T);
Steve Narofffb22d962007-08-30 01:06:46 +0000518
Chris Lattner98be4942008-03-05 18:54:05 +0000519 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType());
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000520 Width = EltInfo.first*CAT->getSize().getZExtValue();
Chris Lattner030d8842007-07-19 22:06:24 +0000521 Align = EltInfo.second;
522 break;
Christopher Lamb5c09a022007-12-29 05:10:55 +0000523 }
Nate Begeman213541a2008-04-18 23:10:10 +0000524 case Type::ExtVector:
Chris Lattner030d8842007-07-19 22:06:24 +0000525 case Type::Vector: {
526 std::pair<uint64_t, unsigned> EltInfo =
Chris Lattner98be4942008-03-05 18:54:05 +0000527 getTypeInfo(cast<VectorType>(T)->getElementType());
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000528 Width = EltInfo.first*cast<VectorType>(T)->getNumElements();
Eli Friedman4bd998b2008-05-30 09:31:38 +0000529 Align = Width;
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000530 // If the alignment is not a power of 2, round up to the next power of 2.
531 // This happens for non-power-of-2 length vectors.
532 // FIXME: this should probably be a target property.
533 Align = 1 << llvm::Log2_32_Ceil(Align);
Chris Lattner030d8842007-07-19 22:06:24 +0000534 break;
535 }
Chris Lattner5d2a6302007-07-18 18:26:58 +0000536
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000537 case Type::Builtin:
Chris Lattnera7674d82007-07-13 22:13:22 +0000538 switch (cast<BuiltinType>(T)->getKind()) {
Chris Lattner692233e2007-07-13 22:27:08 +0000539 default: assert(0 && "Unknown builtin type!");
Chris Lattnerd2d2a112007-07-14 01:29:45 +0000540 case BuiltinType::Void:
Douglas Gregor18857642009-04-30 17:32:17 +0000541 // GCC extension: alignof(void) = 8 bits.
542 Width = 0;
543 Align = 8;
544 break;
545
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000546 case BuiltinType::Bool:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000547 Width = Target.getBoolWidth();
548 Align = Target.getBoolAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000549 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000550 case BuiltinType::Char_S:
551 case BuiltinType::Char_U:
552 case BuiltinType::UChar:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000553 case BuiltinType::SChar:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000554 Width = Target.getCharWidth();
555 Align = Target.getCharAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000556 break;
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +0000557 case BuiltinType::WChar:
558 Width = Target.getWCharWidth();
559 Align = Target.getWCharAlign();
560 break;
Alisdair Meredithf5c209d2009-07-14 06:30:34 +0000561 case BuiltinType::Char16:
562 Width = Target.getChar16Width();
563 Align = Target.getChar16Align();
564 break;
565 case BuiltinType::Char32:
566 Width = Target.getChar32Width();
567 Align = Target.getChar32Align();
568 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000569 case BuiltinType::UShort:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000570 case BuiltinType::Short:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000571 Width = Target.getShortWidth();
572 Align = Target.getShortAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000573 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000574 case BuiltinType::UInt:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000575 case BuiltinType::Int:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000576 Width = Target.getIntWidth();
577 Align = Target.getIntAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000578 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000579 case BuiltinType::ULong:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000580 case BuiltinType::Long:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000581 Width = Target.getLongWidth();
582 Align = Target.getLongAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000583 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000584 case BuiltinType::ULongLong:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000585 case BuiltinType::LongLong:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000586 Width = Target.getLongLongWidth();
587 Align = Target.getLongLongAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000588 break;
Chris Lattnerec16cb92009-04-30 02:55:13 +0000589 case BuiltinType::Int128:
590 case BuiltinType::UInt128:
591 Width = 128;
592 Align = 128; // int128_t is 128-bit aligned on all targets.
593 break;
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000594 case BuiltinType::Float:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000595 Width = Target.getFloatWidth();
596 Align = Target.getFloatAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000597 break;
598 case BuiltinType::Double:
Chris Lattner5426bf62008-04-07 07:01:58 +0000599 Width = Target.getDoubleWidth();
600 Align = Target.getDoubleAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000601 break;
602 case BuiltinType::LongDouble:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000603 Width = Target.getLongDoubleWidth();
604 Align = Target.getLongDoubleAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000605 break;
Sebastian Redl6e8ed162009-05-10 18:38:11 +0000606 case BuiltinType::NullPtr:
607 Width = Target.getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
608 Align = Target.getPointerAlign(0); // == sizeof(void*)
Sebastian Redl1590d9c2009-05-27 19:34:06 +0000609 break;
Chris Lattnera7674d82007-07-13 22:13:22 +0000610 }
Chris Lattnerbfef6d72007-07-15 23:46:53 +0000611 break;
Eli Friedmanf98aba32009-02-13 02:31:07 +0000612 case Type::FixedWidthInt:
613 // FIXME: This isn't precisely correct; the width/alignment should depend
614 // on the available types for the target
615 Width = cast<FixedWidthIntType>(T)->getWidth();
Chris Lattner736166b2009-02-15 21:20:13 +0000616 Width = std::max(llvm::NextPowerOf2(Width - 1), (uint64_t)8);
Eli Friedmanf98aba32009-02-13 02:31:07 +0000617 Align = Width;
618 break;
Fariborz Jahanianf11284a2009-02-17 18:27:45 +0000619 case Type::ExtQual:
Chris Lattner98be4942008-03-05 18:54:05 +0000620 // FIXME: Pointers into different addr spaces could have different sizes and
621 // alignment requirements: getPointerInfo should take an AddrSpace.
Fariborz Jahanianf11284a2009-02-17 18:27:45 +0000622 return getTypeInfo(QualType(cast<ExtQualType>(T)->getBaseType(), 0));
Steve Naroffd1b3c2d2009-06-17 22:40:22 +0000623 case Type::ObjCObjectPointer:
Chris Lattner5426bf62008-04-07 07:01:58 +0000624 Width = Target.getPointerWidth(0);
Chris Lattnerf72a4432008-03-08 08:34:58 +0000625 Align = Target.getPointerAlign(0);
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000626 break;
Steve Naroff485eeff2008-09-24 15:05:44 +0000627 case Type::BlockPointer: {
628 unsigned AS = cast<BlockPointerType>(T)->getPointeeType().getAddressSpace();
629 Width = Target.getPointerWidth(AS);
630 Align = Target.getPointerAlign(AS);
631 break;
632 }
Chris Lattnerf72a4432008-03-08 08:34:58 +0000633 case Type::Pointer: {
634 unsigned AS = cast<PointerType>(T)->getPointeeType().getAddressSpace();
Chris Lattner5426bf62008-04-07 07:01:58 +0000635 Width = Target.getPointerWidth(AS);
Chris Lattnerf72a4432008-03-08 08:34:58 +0000636 Align = Target.getPointerAlign(AS);
637 break;
638 }
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000639 case Type::LValueReference:
640 case Type::RValueReference:
Chris Lattner7ab2ed82007-07-13 22:16:13 +0000641 // "When applied to a reference or a reference type, the result is the size
Chris Lattner5d2a6302007-07-18 18:26:58 +0000642 // of the referenced type." C++98 5.3.3p2: expr.sizeof.
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000643 // FIXME: This is wrong for struct layout: a reference in a struct has
644 // pointer size.
Chris Lattnerbdcd6372008-04-02 17:35:06 +0000645 return getTypeInfo(cast<ReferenceType>(T)->getPointeeType());
Sebastian Redlf30208a2009-01-24 21:16:55 +0000646 case Type::MemberPointer: {
Anders Carlsson1cca74e2009-05-17 02:06:04 +0000647 // FIXME: This is ABI dependent. We use the Itanium C++ ABI.
648 // http://www.codesourcery.com/public/cxx-abi/abi.html#member-pointers
649 // If we ever want to support other ABIs this needs to be abstracted.
650
Sebastian Redlf30208a2009-01-24 21:16:55 +0000651 QualType Pointee = cast<MemberPointerType>(T)->getPointeeType();
Anders Carlsson1cca74e2009-05-17 02:06:04 +0000652 std::pair<uint64_t, unsigned> PtrDiffInfo =
653 getTypeInfo(getPointerDiffType());
654 Width = PtrDiffInfo.first;
Sebastian Redlf30208a2009-01-24 21:16:55 +0000655 if (Pointee->isFunctionType())
656 Width *= 2;
Anders Carlsson1cca74e2009-05-17 02:06:04 +0000657 Align = PtrDiffInfo.second;
658 break;
Sebastian Redlf30208a2009-01-24 21:16:55 +0000659 }
Chris Lattner5d2a6302007-07-18 18:26:58 +0000660 case Type::Complex: {
661 // Complex types have the same alignment as their elements, but twice the
662 // size.
663 std::pair<uint64_t, unsigned> EltInfo =
Chris Lattner98be4942008-03-05 18:54:05 +0000664 getTypeInfo(cast<ComplexType>(T)->getElementType());
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000665 Width = EltInfo.first*2;
Chris Lattner5d2a6302007-07-18 18:26:58 +0000666 Align = EltInfo.second;
667 break;
668 }
Devang Patel44a3dde2008-06-04 21:54:36 +0000669 case Type::ObjCInterface: {
Daniel Dunbar1d751182008-11-08 05:48:37 +0000670 const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T);
Devang Patel44a3dde2008-06-04 21:54:36 +0000671 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
672 Width = Layout.getSize();
673 Align = Layout.getAlignment();
674 break;
675 }
Douglas Gregor72564e72009-02-26 23:50:07 +0000676 case Type::Record:
Douglas Gregor72564e72009-02-26 23:50:07 +0000677 case Type::Enum: {
Daniel Dunbar1d751182008-11-08 05:48:37 +0000678 const TagType *TT = cast<TagType>(T);
679
680 if (TT->getDecl()->isInvalidDecl()) {
Chris Lattner8389eab2008-08-09 21:35:13 +0000681 Width = 1;
682 Align = 1;
683 break;
684 }
685
Daniel Dunbar1d751182008-11-08 05:48:37 +0000686 if (const EnumType *ET = dyn_cast<EnumType>(TT))
Chris Lattner71763312008-04-06 22:05:18 +0000687 return getTypeInfo(ET->getDecl()->getIntegerType());
688
Daniel Dunbar1d751182008-11-08 05:48:37 +0000689 const RecordType *RT = cast<RecordType>(TT);
Chris Lattner71763312008-04-06 22:05:18 +0000690 const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl());
691 Width = Layout.getSize();
692 Align = Layout.getAlignment();
Chris Lattnerdc0d73e2007-07-23 22:46:22 +0000693 break;
Chris Lattnera7674d82007-07-13 22:13:22 +0000694 }
Douglas Gregor7532dc62009-03-30 22:58:21 +0000695
Douglas Gregor18857642009-04-30 17:32:17 +0000696 case Type::Typedef: {
697 const TypedefDecl *Typedef = cast<TypedefType>(T)->getDecl();
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000698 if (const AlignedAttr *Aligned = Typedef->getAttr<AlignedAttr>()) {
Douglas Gregor18857642009-04-30 17:32:17 +0000699 Align = Aligned->getAlignment();
700 Width = getTypeSize(Typedef->getUnderlyingType().getTypePtr());
701 } else
702 return getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
Douglas Gregor7532dc62009-03-30 22:58:21 +0000703 break;
Chris Lattner71763312008-04-06 22:05:18 +0000704 }
Douglas Gregor18857642009-04-30 17:32:17 +0000705
706 case Type::TypeOfExpr:
707 return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType()
708 .getTypePtr());
709
710 case Type::TypeOf:
711 return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr());
712
Anders Carlsson395b4752009-06-24 19:06:50 +0000713 case Type::Decltype:
714 return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType()
715 .getTypePtr());
716
Douglas Gregor18857642009-04-30 17:32:17 +0000717 case Type::QualifiedName:
718 return getTypeInfo(cast<QualifiedNameType>(T)->getNamedType().getTypePtr());
719
720 case Type::TemplateSpecialization:
721 assert(getCanonicalType(T) != T &&
722 "Cannot request the size of a dependent type");
723 // FIXME: this is likely to be wrong once we support template
724 // aliases, since a template alias could refer to a typedef that
725 // has an __aligned__ attribute on it.
726 return getTypeInfo(getCanonicalType(T));
727 }
Chris Lattnerd2d2a112007-07-14 01:29:45 +0000728
Chris Lattner464175b2007-07-18 17:52:12 +0000729 assert(Align && (Align & (Align-1)) == 0 && "Alignment must be power of 2");
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000730 return std::make_pair(Width, Align);
Chris Lattnera7674d82007-07-13 22:13:22 +0000731}
732
Chris Lattner34ebde42009-01-27 18:08:34 +0000733/// getPreferredTypeAlign - Return the "preferred" alignment of the specified
734/// type for the current target in bits. This can be different than the ABI
735/// alignment in cases where it is beneficial for performance to overalign
736/// a data type.
737unsigned ASTContext::getPreferredTypeAlign(const Type *T) {
738 unsigned ABIAlign = getTypeAlign(T);
Eli Friedman1eed6022009-05-25 21:27:19 +0000739
740 // Double and long long should be naturally aligned if possible.
741 if (const ComplexType* CT = T->getAsComplexType())
742 T = CT->getElementType().getTypePtr();
743 if (T->isSpecificBuiltinType(BuiltinType::Double) ||
744 T->isSpecificBuiltinType(BuiltinType::LongLong))
745 return std::max(ABIAlign, (unsigned)getTypeSize(T));
746
Chris Lattner34ebde42009-01-27 18:08:34 +0000747 return ABIAlign;
748}
749
Daniel Dunbara80a0f62009-04-22 17:43:55 +0000750static void CollectLocalObjCIvars(ASTContext *Ctx,
751 const ObjCInterfaceDecl *OI,
752 llvm::SmallVectorImpl<FieldDecl*> &Fields) {
Fariborz Jahaniana769c002008-12-17 21:40:49 +0000753 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(),
754 E = OI->ivar_end(); I != E; ++I) {
Chris Lattnerf1690852009-03-31 08:48:01 +0000755 ObjCIvarDecl *IVDecl = *I;
Fariborz Jahaniana769c002008-12-17 21:40:49 +0000756 if (!IVDecl->isInvalidDecl())
757 Fields.push_back(cast<FieldDecl>(IVDecl));
758 }
759}
760
Daniel Dunbara80a0f62009-04-22 17:43:55 +0000761void ASTContext::CollectObjCIvars(const ObjCInterfaceDecl *OI,
762 llvm::SmallVectorImpl<FieldDecl*> &Fields) {
763 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
764 CollectObjCIvars(SuperClass, Fields);
765 CollectLocalObjCIvars(this, OI, Fields);
766}
767
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000768/// ShallowCollectObjCIvars -
769/// Collect all ivars, including those synthesized, in the current class.
770///
771void ASTContext::ShallowCollectObjCIvars(const ObjCInterfaceDecl *OI,
772 llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars,
773 bool CollectSynthesized) {
774 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(),
775 E = OI->ivar_end(); I != E; ++I) {
776 Ivars.push_back(*I);
777 }
778 if (CollectSynthesized)
779 CollectSynthesizedIvars(OI, Ivars);
780}
781
Fariborz Jahanian98200742009-05-12 18:14:29 +0000782void ASTContext::CollectProtocolSynthesizedIvars(const ObjCProtocolDecl *PD,
783 llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000784 for (ObjCContainerDecl::prop_iterator I = PD->prop_begin(),
785 E = PD->prop_end(); I != E; ++I)
Fariborz Jahanian98200742009-05-12 18:14:29 +0000786 if (ObjCIvarDecl *Ivar = (*I)->getPropertyIvarDecl())
787 Ivars.push_back(Ivar);
788
789 // Also look into nested protocols.
790 for (ObjCProtocolDecl::protocol_iterator P = PD->protocol_begin(),
791 E = PD->protocol_end(); P != E; ++P)
792 CollectProtocolSynthesizedIvars(*P, Ivars);
793}
794
795/// CollectSynthesizedIvars -
796/// This routine collect synthesized ivars for the designated class.
797///
798void ASTContext::CollectSynthesizedIvars(const ObjCInterfaceDecl *OI,
799 llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000800 for (ObjCInterfaceDecl::prop_iterator I = OI->prop_begin(),
801 E = OI->prop_end(); I != E; ++I) {
Fariborz Jahanian98200742009-05-12 18:14:29 +0000802 if (ObjCIvarDecl *Ivar = (*I)->getPropertyIvarDecl())
803 Ivars.push_back(Ivar);
804 }
805 // Also look into interface's protocol list for properties declared
806 // in the protocol and whose ivars are synthesized.
807 for (ObjCInterfaceDecl::protocol_iterator P = OI->protocol_begin(),
808 PE = OI->protocol_end(); P != PE; ++P) {
809 ObjCProtocolDecl *PD = (*P);
810 CollectProtocolSynthesizedIvars(PD, Ivars);
811 }
812}
813
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000814unsigned ASTContext::CountProtocolSynthesizedIvars(const ObjCProtocolDecl *PD) {
815 unsigned count = 0;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000816 for (ObjCContainerDecl::prop_iterator I = PD->prop_begin(),
817 E = PD->prop_end(); I != E; ++I)
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000818 if ((*I)->getPropertyIvarDecl())
819 ++count;
820
821 // Also look into nested protocols.
822 for (ObjCProtocolDecl::protocol_iterator P = PD->protocol_begin(),
823 E = PD->protocol_end(); P != E; ++P)
824 count += CountProtocolSynthesizedIvars(*P);
825 return count;
826}
827
828unsigned ASTContext::CountSynthesizedIvars(const ObjCInterfaceDecl *OI)
829{
830 unsigned count = 0;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000831 for (ObjCInterfaceDecl::prop_iterator I = OI->prop_begin(),
832 E = OI->prop_end(); I != E; ++I) {
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000833 if ((*I)->getPropertyIvarDecl())
834 ++count;
835 }
836 // Also look into interface's protocol list for properties declared
837 // in the protocol and whose ivars are synthesized.
838 for (ObjCInterfaceDecl::protocol_iterator P = OI->protocol_begin(),
839 PE = OI->protocol_end(); P != PE; ++P) {
840 ObjCProtocolDecl *PD = (*P);
841 count += CountProtocolSynthesizedIvars(PD);
842 }
843 return count;
844}
845
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +0000846/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists.
847ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
848 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
849 I = ObjCImpls.find(D);
850 if (I != ObjCImpls.end())
851 return cast<ObjCImplementationDecl>(I->second);
852 return 0;
853}
854/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists.
855ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) {
856 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
857 I = ObjCImpls.find(D);
858 if (I != ObjCImpls.end())
859 return cast<ObjCCategoryImplDecl>(I->second);
860 return 0;
861}
862
863/// \brief Set the implementation of ObjCInterfaceDecl.
864void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD,
865 ObjCImplementationDecl *ImplD) {
866 assert(IFaceD && ImplD && "Passed null params");
867 ObjCImpls[IFaceD] = ImplD;
868}
869/// \brief Set the implementation of ObjCCategoryDecl.
870void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD,
871 ObjCCategoryImplDecl *ImplD) {
872 assert(CatD && ImplD && "Passed null params");
873 ObjCImpls[CatD] = ImplD;
874}
875
Daniel Dunbarb2dbbb92009-05-03 10:38:35 +0000876/// getInterfaceLayoutImpl - Get or compute information about the
877/// layout of the given interface.
878///
879/// \param Impl - If given, also include the layout of the interface's
880/// implementation. This may differ by including synthesized ivars.
Devang Patel44a3dde2008-06-04 21:54:36 +0000881const ASTRecordLayout &
Daniel Dunbarb2dbbb92009-05-03 10:38:35 +0000882ASTContext::getObjCLayout(const ObjCInterfaceDecl *D,
883 const ObjCImplementationDecl *Impl) {
Daniel Dunbar532d4da2009-05-03 13:15:50 +0000884 assert(!D->isForwardDecl() && "Invalid interface decl!");
885
Devang Patel44a3dde2008-06-04 21:54:36 +0000886 // Look up this layout, if already laid out, return what we have.
Daniel Dunbard8fd6ff2009-05-03 11:41:43 +0000887 ObjCContainerDecl *Key =
888 Impl ? (ObjCContainerDecl*) Impl : (ObjCContainerDecl*) D;
889 if (const ASTRecordLayout *Entry = ObjCLayouts[Key])
890 return *Entry;
Devang Patel44a3dde2008-06-04 21:54:36 +0000891
Daniel Dunbar453addb2009-05-03 11:16:44 +0000892 // Add in synthesized ivar count if laying out an implementation.
893 if (Impl) {
Anders Carlsson29445a02009-07-18 21:19:52 +0000894 unsigned FieldCount = D->ivar_size();
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000895 unsigned SynthCount = CountSynthesizedIvars(D);
896 FieldCount += SynthCount;
Daniel Dunbard8fd6ff2009-05-03 11:41:43 +0000897 // If there aren't any sythesized ivars then reuse the interface
Daniel Dunbar453addb2009-05-03 11:16:44 +0000898 // entry. Note we can't cache this because we simply free all
899 // entries later; however we shouldn't look up implementations
900 // frequently.
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000901 if (SynthCount == 0)
Daniel Dunbar453addb2009-05-03 11:16:44 +0000902 return getObjCLayout(D, 0);
903 }
904
Anders Carlsson29445a02009-07-18 21:19:52 +0000905 const ASTRecordLayout *NewEntry =
906 ASTRecordLayoutBuilder::ComputeLayout(*this, D, Impl);
907 ObjCLayouts[Key] = NewEntry;
908
Devang Patel44a3dde2008-06-04 21:54:36 +0000909 return *NewEntry;
910}
911
Daniel Dunbarb2dbbb92009-05-03 10:38:35 +0000912const ASTRecordLayout &
913ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) {
914 return getObjCLayout(D, 0);
915}
916
917const ASTRecordLayout &
918ASTContext::getASTObjCImplementationLayout(const ObjCImplementationDecl *D) {
919 return getObjCLayout(D->getClassInterface(), D);
920}
921
Devang Patel88a981b2007-11-01 19:11:01 +0000922/// getASTRecordLayout - Get or compute information about the layout of the
Chris Lattner464175b2007-07-18 17:52:12 +0000923/// specified record (struct/union/class), which indicates its size and field
924/// position information.
Chris Lattner98be4942008-03-05 18:54:05 +0000925const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D) {
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000926 D = D->getDefinition(*this);
927 assert(D && "Cannot get layout of forward declarations!");
Eli Friedman4bd998b2008-05-30 09:31:38 +0000928
Chris Lattner464175b2007-07-18 17:52:12 +0000929 // Look up this layout, if already laid out, return what we have.
Eli Friedmanab22c432009-07-22 20:29:16 +0000930 // Note that we can't save a reference to the entry because this function
931 // is recursive.
932 const ASTRecordLayout *Entry = ASTRecordLayouts[D];
Chris Lattner464175b2007-07-18 17:52:12 +0000933 if (Entry) return *Entry;
Eli Friedman4bd998b2008-05-30 09:31:38 +0000934
Anders Carlsson29445a02009-07-18 21:19:52 +0000935 const ASTRecordLayout *NewEntry =
936 ASTRecordLayoutBuilder::ComputeLayout(*this, D);
Eli Friedmanab22c432009-07-22 20:29:16 +0000937 ASTRecordLayouts[D] = NewEntry;
Anders Carlsson29445a02009-07-18 21:19:52 +0000938
Chris Lattner5d2a6302007-07-18 18:26:58 +0000939 return *NewEntry;
Chris Lattner464175b2007-07-18 17:52:12 +0000940}
941
Chris Lattnera7674d82007-07-13 22:13:22 +0000942//===----------------------------------------------------------------------===//
943// Type creation/memoization methods
944//===----------------------------------------------------------------------===//
945
Fariborz Jahanianf11284a2009-02-17 18:27:45 +0000946QualType ASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) {
Chris Lattnerf52ab252008-04-06 22:59:24 +0000947 QualType CanT = getCanonicalType(T);
948 if (CanT.getAddressSpace() == AddressSpace)
Chris Lattnerf46699c2008-02-20 20:55:12 +0000949 return T;
Chris Lattnerb7d25532009-02-18 22:53:11 +0000950
951 // If we are composing extended qualifiers together, merge together into one
952 // ExtQualType node.
953 unsigned CVRQuals = T.getCVRQualifiers();
954 QualType::GCAttrTypes GCAttr = QualType::GCNone;
955 Type *TypeNode = T.getTypePtr();
Chris Lattnerf46699c2008-02-20 20:55:12 +0000956
Chris Lattnerb7d25532009-02-18 22:53:11 +0000957 if (ExtQualType *EQT = dyn_cast<ExtQualType>(TypeNode)) {
958 // If this type already has an address space specified, it cannot get
959 // another one.
960 assert(EQT->getAddressSpace() == 0 &&
961 "Type cannot be in multiple addr spaces!");
962 GCAttr = EQT->getObjCGCAttr();
963 TypeNode = EQT->getBaseType();
964 }
Chris Lattnerf46699c2008-02-20 20:55:12 +0000965
Chris Lattnerb7d25532009-02-18 22:53:11 +0000966 // Check if we've already instantiated this type.
Christopher Lambebb97e92008-02-04 02:31:56 +0000967 llvm::FoldingSetNodeID ID;
Mike Stump24556362009-07-25 21:26:53 +0000968 ExtQualType::Profile(ID, TypeNode, AddressSpace, GCAttr);
Christopher Lambebb97e92008-02-04 02:31:56 +0000969 void *InsertPos = 0;
Fariborz Jahanianf11284a2009-02-17 18:27:45 +0000970 if (ExtQualType *EXTQy = ExtQualTypes.FindNodeOrInsertPos(ID, InsertPos))
Chris Lattnerb7d25532009-02-18 22:53:11 +0000971 return QualType(EXTQy, CVRQuals);
972
Christopher Lambebb97e92008-02-04 02:31:56 +0000973 // If the base type isn't canonical, this won't be a canonical type either,
974 // so fill in the canonical type field.
975 QualType Canonical;
Chris Lattnerb7d25532009-02-18 22:53:11 +0000976 if (!TypeNode->isCanonical()) {
Fariborz Jahanianf11284a2009-02-17 18:27:45 +0000977 Canonical = getAddrSpaceQualType(CanT, AddressSpace);
Christopher Lambebb97e92008-02-04 02:31:56 +0000978
Chris Lattnerb7d25532009-02-18 22:53:11 +0000979 // Update InsertPos, the previous call could have invalidated it.
Fariborz Jahanianf11284a2009-02-17 18:27:45 +0000980 ExtQualType *NewIP = ExtQualTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +0000981 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Christopher Lambebb97e92008-02-04 02:31:56 +0000982 }
Chris Lattnerb7d25532009-02-18 22:53:11 +0000983 ExtQualType *New =
984 new (*this, 8) ExtQualType(TypeNode, Canonical, AddressSpace, GCAttr);
Fariborz Jahanianf11284a2009-02-17 18:27:45 +0000985 ExtQualTypes.InsertNode(New, InsertPos);
Christopher Lambebb97e92008-02-04 02:31:56 +0000986 Types.push_back(New);
Chris Lattnerb7d25532009-02-18 22:53:11 +0000987 return QualType(New, CVRQuals);
Christopher Lambebb97e92008-02-04 02:31:56 +0000988}
989
Chris Lattnerb7d25532009-02-18 22:53:11 +0000990QualType ASTContext::getObjCGCQualType(QualType T,
991 QualType::GCAttrTypes GCAttr) {
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +0000992 QualType CanT = getCanonicalType(T);
Chris Lattnerb7d25532009-02-18 22:53:11 +0000993 if (CanT.getObjCGCAttr() == GCAttr)
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +0000994 return T;
995
Fariborz Jahanian4027cd12009-06-03 17:15:17 +0000996 if (T->isPointerType()) {
Ted Kremenek6217b802009-07-29 21:53:49 +0000997 QualType Pointee = T->getAs<PointerType>()->getPointeeType();
Steve Naroff58f9f2c2009-07-14 18:25:06 +0000998 if (Pointee->isAnyPointerType()) {
Fariborz Jahanian4027cd12009-06-03 17:15:17 +0000999 QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
1000 return getPointerType(ResultType);
1001 }
1002 }
Chris Lattnerb7d25532009-02-18 22:53:11 +00001003 // If we are composing extended qualifiers together, merge together into one
1004 // ExtQualType node.
1005 unsigned CVRQuals = T.getCVRQualifiers();
1006 Type *TypeNode = T.getTypePtr();
1007 unsigned AddressSpace = 0;
1008
1009 if (ExtQualType *EQT = dyn_cast<ExtQualType>(TypeNode)) {
Mike Stump24556362009-07-25 21:26:53 +00001010 // If this type already has an ObjCGC specified, it cannot get
Chris Lattnerb7d25532009-02-18 22:53:11 +00001011 // another one.
1012 assert(EQT->getObjCGCAttr() == QualType::GCNone &&
Mike Stump24556362009-07-25 21:26:53 +00001013 "Type cannot have multiple ObjCGCs!");
Chris Lattnerb7d25532009-02-18 22:53:11 +00001014 AddressSpace = EQT->getAddressSpace();
1015 TypeNode = EQT->getBaseType();
1016 }
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001017
1018 // Check if we've already instantiated an gc qual'd type of this type.
1019 llvm::FoldingSetNodeID ID;
Mike Stump24556362009-07-25 21:26:53 +00001020 ExtQualType::Profile(ID, TypeNode, AddressSpace, GCAttr);
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001021 void *InsertPos = 0;
1022 if (ExtQualType *EXTQy = ExtQualTypes.FindNodeOrInsertPos(ID, InsertPos))
Chris Lattnerb7d25532009-02-18 22:53:11 +00001023 return QualType(EXTQy, CVRQuals);
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001024
1025 // If the base type isn't canonical, this won't be a canonical type either,
1026 // so fill in the canonical type field.
Eli Friedman5a61f0e2009-02-27 23:04:43 +00001027 // FIXME: Isn't this also not canonical if the base type is a array
1028 // or pointer type? I can't find any documentation for objc_gc, though...
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001029 QualType Canonical;
1030 if (!T->isCanonical()) {
Chris Lattnerb7d25532009-02-18 22:53:11 +00001031 Canonical = getObjCGCQualType(CanT, GCAttr);
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001032
Chris Lattnerb7d25532009-02-18 22:53:11 +00001033 // Update InsertPos, the previous call could have invalidated it.
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001034 ExtQualType *NewIP = ExtQualTypes.FindNodeOrInsertPos(ID, InsertPos);
1035 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
1036 }
Chris Lattnerb7d25532009-02-18 22:53:11 +00001037 ExtQualType *New =
1038 new (*this, 8) ExtQualType(TypeNode, Canonical, AddressSpace, GCAttr);
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001039 ExtQualTypes.InsertNode(New, InsertPos);
1040 Types.push_back(New);
Chris Lattnerb7d25532009-02-18 22:53:11 +00001041 return QualType(New, CVRQuals);
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001042}
Chris Lattnera7674d82007-07-13 22:13:22 +00001043
Mike Stump24556362009-07-25 21:26:53 +00001044QualType ASTContext::getNoReturnType(QualType T) {
Mike Stump6dcbc292009-07-25 23:24:03 +00001045 QualifierSet qs;
1046 qs.strip(T);
Mike Stump24556362009-07-25 21:26:53 +00001047 if (T->isPointerType()) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001048 QualType Pointee = T->getAs<PointerType>()->getPointeeType();
Mike Stump24556362009-07-25 21:26:53 +00001049 QualType ResultType = getNoReturnType(Pointee);
Mike Stump6dcbc292009-07-25 23:24:03 +00001050 ResultType = getPointerType(ResultType);
1051 ResultType.setCVRQualifiers(T.getCVRQualifiers());
1052 return qs.apply(ResultType, *this);
Mike Stump24556362009-07-25 21:26:53 +00001053 }
1054 if (T->isBlockPointerType()) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001055 QualType Pointee = T->getAs<BlockPointerType>()->getPointeeType();
Mike Stump24556362009-07-25 21:26:53 +00001056 QualType ResultType = getNoReturnType(Pointee);
Mike Stump6dcbc292009-07-25 23:24:03 +00001057 ResultType = getBlockPointerType(ResultType);
1058 ResultType.setCVRQualifiers(T.getCVRQualifiers());
1059 return qs.apply(ResultType, *this);
Mike Stump24556362009-07-25 21:26:53 +00001060 }
1061 if (!T->isFunctionType())
1062 assert(0 && "can't noreturn qualify non-pointer to function or block type");
1063
Mike Stumpe24aea22009-07-27 22:25:19 +00001064 if (const FunctionNoProtoType *F = T->getAsFunctionNoProtoType()) {
Mike Stump24556362009-07-25 21:26:53 +00001065 return getFunctionNoProtoType(F->getResultType(), true);
1066 }
Mike Stumpe24aea22009-07-27 22:25:19 +00001067 const FunctionProtoType *F = T->getAsFunctionProtoType();
Mike Stump24556362009-07-25 21:26:53 +00001068 return getFunctionType(F->getResultType(), F->arg_type_begin(),
1069 F->getNumArgs(), F->isVariadic(), F->getTypeQuals(),
1070 F->hasExceptionSpec(), F->hasAnyExceptionSpec(),
1071 F->getNumExceptions(), F->exception_begin(), true);
1072}
1073
Reid Spencer5f016e22007-07-11 17:01:13 +00001074/// getComplexType - Return the uniqued reference to the type for a complex
1075/// number with the specified element type.
1076QualType ASTContext::getComplexType(QualType T) {
1077 // Unique pointers, to guarantee there is only one pointer of a particular
1078 // structure.
1079 llvm::FoldingSetNodeID ID;
1080 ComplexType::Profile(ID, T);
1081
1082 void *InsertPos = 0;
1083 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
1084 return QualType(CT, 0);
1085
1086 // If the pointee type isn't canonical, this won't be a canonical type either,
1087 // so fill in the canonical type field.
1088 QualType Canonical;
1089 if (!T->isCanonical()) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001090 Canonical = getComplexType(getCanonicalType(T));
Reid Spencer5f016e22007-07-11 17:01:13 +00001091
1092 // Get the new insert position for the node we care about.
1093 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001094 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001095 }
Steve Narofff83820b2009-01-27 22:08:43 +00001096 ComplexType *New = new (*this,8) ComplexType(T, Canonical);
Reid Spencer5f016e22007-07-11 17:01:13 +00001097 Types.push_back(New);
1098 ComplexTypes.InsertNode(New, InsertPos);
1099 return QualType(New, 0);
1100}
1101
Eli Friedmanf98aba32009-02-13 02:31:07 +00001102QualType ASTContext::getFixedWidthIntType(unsigned Width, bool Signed) {
1103 llvm::DenseMap<unsigned, FixedWidthIntType*> &Map = Signed ?
1104 SignedFixedWidthIntTypes : UnsignedFixedWidthIntTypes;
1105 FixedWidthIntType *&Entry = Map[Width];
1106 if (!Entry)
1107 Entry = new FixedWidthIntType(Width, Signed);
1108 return QualType(Entry, 0);
1109}
Reid Spencer5f016e22007-07-11 17:01:13 +00001110
1111/// getPointerType - Return the uniqued reference to the type for a pointer to
1112/// the specified type.
1113QualType ASTContext::getPointerType(QualType T) {
1114 // Unique pointers, to guarantee there is only one pointer of a particular
1115 // structure.
1116 llvm::FoldingSetNodeID ID;
1117 PointerType::Profile(ID, T);
1118
1119 void *InsertPos = 0;
1120 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
1121 return QualType(PT, 0);
1122
1123 // If the pointee type isn't canonical, this won't be a canonical type either,
1124 // so fill in the canonical type field.
1125 QualType Canonical;
1126 if (!T->isCanonical()) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001127 Canonical = getPointerType(getCanonicalType(T));
Reid Spencer5f016e22007-07-11 17:01:13 +00001128
1129 // Get the new insert position for the node we care about.
1130 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001131 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001132 }
Steve Narofff83820b2009-01-27 22:08:43 +00001133 PointerType *New = new (*this,8) PointerType(T, Canonical);
Reid Spencer5f016e22007-07-11 17:01:13 +00001134 Types.push_back(New);
1135 PointerTypes.InsertNode(New, InsertPos);
1136 return QualType(New, 0);
1137}
1138
Steve Naroff5618bd42008-08-27 16:04:49 +00001139/// getBlockPointerType - Return the uniqued reference to the type for
1140/// a pointer to the specified block.
1141QualType ASTContext::getBlockPointerType(QualType T) {
Steve Naroff296e8d52008-08-28 19:20:44 +00001142 assert(T->isFunctionType() && "block of function types only");
1143 // Unique pointers, to guarantee there is only one block of a particular
Steve Naroff5618bd42008-08-27 16:04:49 +00001144 // structure.
1145 llvm::FoldingSetNodeID ID;
1146 BlockPointerType::Profile(ID, T);
1147
1148 void *InsertPos = 0;
1149 if (BlockPointerType *PT =
1150 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
1151 return QualType(PT, 0);
1152
Steve Naroff296e8d52008-08-28 19:20:44 +00001153 // If the block pointee type isn't canonical, this won't be a canonical
Steve Naroff5618bd42008-08-27 16:04:49 +00001154 // type either so fill in the canonical type field.
1155 QualType Canonical;
1156 if (!T->isCanonical()) {
1157 Canonical = getBlockPointerType(getCanonicalType(T));
1158
1159 // Get the new insert position for the node we care about.
1160 BlockPointerType *NewIP =
1161 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001162 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Steve Naroff5618bd42008-08-27 16:04:49 +00001163 }
Steve Narofff83820b2009-01-27 22:08:43 +00001164 BlockPointerType *New = new (*this,8) BlockPointerType(T, Canonical);
Steve Naroff5618bd42008-08-27 16:04:49 +00001165 Types.push_back(New);
1166 BlockPointerTypes.InsertNode(New, InsertPos);
1167 return QualType(New, 0);
1168}
1169
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001170/// getLValueReferenceType - Return the uniqued reference to the type for an
1171/// lvalue reference to the specified type.
1172QualType ASTContext::getLValueReferenceType(QualType T) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001173 // Unique pointers, to guarantee there is only one pointer of a particular
1174 // structure.
1175 llvm::FoldingSetNodeID ID;
1176 ReferenceType::Profile(ID, T);
1177
1178 void *InsertPos = 0;
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001179 if (LValueReferenceType *RT =
1180 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
Reid Spencer5f016e22007-07-11 17:01:13 +00001181 return QualType(RT, 0);
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001182
Reid Spencer5f016e22007-07-11 17:01:13 +00001183 // If the referencee type isn't canonical, this won't be a canonical type
1184 // either, so fill in the canonical type field.
1185 QualType Canonical;
1186 if (!T->isCanonical()) {
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001187 Canonical = getLValueReferenceType(getCanonicalType(T));
1188
Reid Spencer5f016e22007-07-11 17:01:13 +00001189 // Get the new insert position for the node we care about.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001190 LValueReferenceType *NewIP =
1191 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001192 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001193 }
1194
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001195 LValueReferenceType *New = new (*this,8) LValueReferenceType(T, Canonical);
Reid Spencer5f016e22007-07-11 17:01:13 +00001196 Types.push_back(New);
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001197 LValueReferenceTypes.InsertNode(New, InsertPos);
1198 return QualType(New, 0);
1199}
1200
1201/// getRValueReferenceType - Return the uniqued reference to the type for an
1202/// rvalue reference to the specified type.
1203QualType ASTContext::getRValueReferenceType(QualType T) {
1204 // Unique pointers, to guarantee there is only one pointer of a particular
1205 // structure.
1206 llvm::FoldingSetNodeID ID;
1207 ReferenceType::Profile(ID, T);
1208
1209 void *InsertPos = 0;
1210 if (RValueReferenceType *RT =
1211 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
1212 return QualType(RT, 0);
1213
1214 // If the referencee type isn't canonical, this won't be a canonical type
1215 // either, so fill in the canonical type field.
1216 QualType Canonical;
1217 if (!T->isCanonical()) {
1218 Canonical = getRValueReferenceType(getCanonicalType(T));
1219
1220 // Get the new insert position for the node we care about.
1221 RValueReferenceType *NewIP =
1222 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
1223 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
1224 }
1225
1226 RValueReferenceType *New = new (*this,8) RValueReferenceType(T, Canonical);
1227 Types.push_back(New);
1228 RValueReferenceTypes.InsertNode(New, InsertPos);
Reid Spencer5f016e22007-07-11 17:01:13 +00001229 return QualType(New, 0);
1230}
1231
Sebastian Redlf30208a2009-01-24 21:16:55 +00001232/// getMemberPointerType - Return the uniqued reference to the type for a
1233/// member pointer to the specified type, in the specified class.
1234QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls)
1235{
1236 // Unique pointers, to guarantee there is only one pointer of a particular
1237 // structure.
1238 llvm::FoldingSetNodeID ID;
1239 MemberPointerType::Profile(ID, T, Cls);
1240
1241 void *InsertPos = 0;
1242 if (MemberPointerType *PT =
1243 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
1244 return QualType(PT, 0);
1245
1246 // If the pointee or class type isn't canonical, this won't be a canonical
1247 // type either, so fill in the canonical type field.
1248 QualType Canonical;
1249 if (!T->isCanonical()) {
1250 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
1251
1252 // Get the new insert position for the node we care about.
1253 MemberPointerType *NewIP =
1254 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
1255 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
1256 }
Steve Narofff83820b2009-01-27 22:08:43 +00001257 MemberPointerType *New = new (*this,8) MemberPointerType(T, Cls, Canonical);
Sebastian Redlf30208a2009-01-24 21:16:55 +00001258 Types.push_back(New);
1259 MemberPointerTypes.InsertNode(New, InsertPos);
1260 return QualType(New, 0);
1261}
1262
Steve Narofffb22d962007-08-30 01:06:46 +00001263/// getConstantArrayType - Return the unique reference to the type for an
1264/// array of the specified element type.
1265QualType ASTContext::getConstantArrayType(QualType EltTy,
Chris Lattner38aeec72009-05-13 04:12:56 +00001266 const llvm::APInt &ArySizeIn,
Steve Naroffc9406122007-08-30 18:10:14 +00001267 ArrayType::ArraySizeModifier ASM,
1268 unsigned EltTypeQuals) {
Eli Friedman587cbdf2009-05-29 20:17:55 +00001269 assert((EltTy->isDependentType() || EltTy->isConstantSizeType()) &&
1270 "Constant array of VLAs is illegal!");
1271
Chris Lattner38aeec72009-05-13 04:12:56 +00001272 // Convert the array size into a canonical width matching the pointer size for
1273 // the target.
1274 llvm::APInt ArySize(ArySizeIn);
1275 ArySize.zextOrTrunc(Target.getPointerWidth(EltTy.getAddressSpace()));
1276
Reid Spencer5f016e22007-07-11 17:01:13 +00001277 llvm::FoldingSetNodeID ID;
Chris Lattner0be2ef22009-02-19 17:31:02 +00001278 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, EltTypeQuals);
Reid Spencer5f016e22007-07-11 17:01:13 +00001279
1280 void *InsertPos = 0;
Ted Kremenek7192f8e2007-10-31 17:10:13 +00001281 if (ConstantArrayType *ATP =
1282 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
Reid Spencer5f016e22007-07-11 17:01:13 +00001283 return QualType(ATP, 0);
1284
1285 // If the element type isn't canonical, this won't be a canonical type either,
1286 // so fill in the canonical type field.
1287 QualType Canonical;
1288 if (!EltTy->isCanonical()) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001289 Canonical = getConstantArrayType(getCanonicalType(EltTy), ArySize,
Steve Naroffc9406122007-08-30 18:10:14 +00001290 ASM, EltTypeQuals);
Reid Spencer5f016e22007-07-11 17:01:13 +00001291 // Get the new insert position for the node we care about.
Ted Kremenek7192f8e2007-10-31 17:10:13 +00001292 ConstantArrayType *NewIP =
1293 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001294 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001295 }
1296
Ted Kremenek566c2ba2009-01-19 21:31:22 +00001297 ConstantArrayType *New =
Steve Narofff83820b2009-01-27 22:08:43 +00001298 new(*this,8)ConstantArrayType(EltTy, Canonical, ArySize, ASM, EltTypeQuals);
Ted Kremenek7192f8e2007-10-31 17:10:13 +00001299 ConstantArrayTypes.InsertNode(New, InsertPos);
Reid Spencer5f016e22007-07-11 17:01:13 +00001300 Types.push_back(New);
1301 return QualType(New, 0);
1302}
1303
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001304/// getConstantArrayWithExprType - Return a reference to the type for
1305/// an array of the specified element type.
1306QualType
1307ASTContext::getConstantArrayWithExprType(QualType EltTy,
1308 const llvm::APInt &ArySizeIn,
1309 Expr *ArySizeExpr,
1310 ArrayType::ArraySizeModifier ASM,
1311 unsigned EltTypeQuals,
1312 SourceRange Brackets) {
1313 // Convert the array size into a canonical width matching the pointer
1314 // size for the target.
1315 llvm::APInt ArySize(ArySizeIn);
1316 ArySize.zextOrTrunc(Target.getPointerWidth(EltTy.getAddressSpace()));
1317
1318 // Compute the canonical ConstantArrayType.
1319 QualType Canonical = getConstantArrayType(getCanonicalType(EltTy),
1320 ArySize, ASM, EltTypeQuals);
1321 // Since we don't unique expressions, it isn't possible to unique VLA's
1322 // that have an expression provided for their size.
1323 ConstantArrayWithExprType *New =
1324 new(*this,8)ConstantArrayWithExprType(EltTy, Canonical,
1325 ArySize, ArySizeExpr,
1326 ASM, EltTypeQuals, Brackets);
1327 Types.push_back(New);
1328 return QualType(New, 0);
1329}
1330
1331/// getConstantArrayWithoutExprType - Return a reference to the type for
1332/// an array of the specified element type.
1333QualType
1334ASTContext::getConstantArrayWithoutExprType(QualType EltTy,
1335 const llvm::APInt &ArySizeIn,
1336 ArrayType::ArraySizeModifier ASM,
1337 unsigned EltTypeQuals) {
1338 // Convert the array size into a canonical width matching the pointer
1339 // size for the target.
1340 llvm::APInt ArySize(ArySizeIn);
1341 ArySize.zextOrTrunc(Target.getPointerWidth(EltTy.getAddressSpace()));
1342
1343 // Compute the canonical ConstantArrayType.
1344 QualType Canonical = getConstantArrayType(getCanonicalType(EltTy),
1345 ArySize, ASM, EltTypeQuals);
1346 ConstantArrayWithoutExprType *New =
1347 new(*this,8)ConstantArrayWithoutExprType(EltTy, Canonical,
1348 ArySize, ASM, EltTypeQuals);
1349 Types.push_back(New);
1350 return QualType(New, 0);
1351}
1352
Steve Naroffbdbf7b02007-08-30 18:14:25 +00001353/// getVariableArrayType - Returns a non-unique reference to the type for a
1354/// variable array of the specified element type.
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001355QualType ASTContext::getVariableArrayType(QualType EltTy,
1356 Expr *NumElts,
Steve Naroffc9406122007-08-30 18:10:14 +00001357 ArrayType::ArraySizeModifier ASM,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001358 unsigned EltTypeQuals,
1359 SourceRange Brackets) {
Eli Friedmanc5773c42008-02-15 18:16:39 +00001360 // Since we don't unique expressions, it isn't possible to unique VLA's
1361 // that have an expression provided for their size.
1362
Ted Kremenek566c2ba2009-01-19 21:31:22 +00001363 VariableArrayType *New =
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001364 new(*this,8)VariableArrayType(EltTy, QualType(),
1365 NumElts, ASM, EltTypeQuals, Brackets);
Eli Friedmanc5773c42008-02-15 18:16:39 +00001366
1367 VariableArrayTypes.push_back(New);
1368 Types.push_back(New);
1369 return QualType(New, 0);
1370}
1371
Douglas Gregor898574e2008-12-05 23:32:09 +00001372/// getDependentSizedArrayType - Returns a non-unique reference to
1373/// the type for a dependently-sized array of the specified element
Douglas Gregor04d4bee2009-07-31 00:23:35 +00001374/// type.
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001375QualType ASTContext::getDependentSizedArrayType(QualType EltTy,
1376 Expr *NumElts,
Douglas Gregor898574e2008-12-05 23:32:09 +00001377 ArrayType::ArraySizeModifier ASM,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001378 unsigned EltTypeQuals,
1379 SourceRange Brackets) {
Douglas Gregor898574e2008-12-05 23:32:09 +00001380 assert((NumElts->isTypeDependent() || NumElts->isValueDependent()) &&
1381 "Size must be type- or value-dependent!");
1382
Douglas Gregor04d4bee2009-07-31 00:23:35 +00001383 llvm::FoldingSetNodeID ID;
1384 DependentSizedArrayType::Profile(ID, *this, getCanonicalType(EltTy), ASM,
1385 EltTypeQuals, NumElts);
Douglas Gregor898574e2008-12-05 23:32:09 +00001386
Douglas Gregor04d4bee2009-07-31 00:23:35 +00001387 void *InsertPos = 0;
1388 DependentSizedArrayType *Canon
1389 = DependentSizedArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
1390 DependentSizedArrayType *New;
1391 if (Canon) {
1392 // We already have a canonical version of this array type; use it as
1393 // the canonical type for a newly-built type.
1394 New = new (*this,8) DependentSizedArrayType(*this, EltTy,
1395 QualType(Canon, 0),
1396 NumElts, ASM, EltTypeQuals,
1397 Brackets);
1398 } else {
1399 QualType CanonEltTy = getCanonicalType(EltTy);
1400 if (CanonEltTy == EltTy) {
1401 New = new (*this,8) DependentSizedArrayType(*this, EltTy, QualType(),
1402 NumElts, ASM, EltTypeQuals,
1403 Brackets);
1404 DependentSizedArrayTypes.InsertNode(New, InsertPos);
1405 } else {
1406 QualType Canon = getDependentSizedArrayType(CanonEltTy, NumElts,
1407 ASM, EltTypeQuals,
1408 SourceRange());
1409 New = new (*this,8) DependentSizedArrayType(*this, EltTy, Canon,
1410 NumElts, ASM, EltTypeQuals,
1411 Brackets);
1412 }
1413 }
1414
Douglas Gregor898574e2008-12-05 23:32:09 +00001415 Types.push_back(New);
1416 return QualType(New, 0);
1417}
1418
Eli Friedmanc5773c42008-02-15 18:16:39 +00001419QualType ASTContext::getIncompleteArrayType(QualType EltTy,
1420 ArrayType::ArraySizeModifier ASM,
1421 unsigned EltTypeQuals) {
1422 llvm::FoldingSetNodeID ID;
Chris Lattner0be2ef22009-02-19 17:31:02 +00001423 IncompleteArrayType::Profile(ID, EltTy, ASM, EltTypeQuals);
Eli Friedmanc5773c42008-02-15 18:16:39 +00001424
1425 void *InsertPos = 0;
1426 if (IncompleteArrayType *ATP =
1427 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
1428 return QualType(ATP, 0);
1429
1430 // If the element type isn't canonical, this won't be a canonical type
1431 // either, so fill in the canonical type field.
1432 QualType Canonical;
1433
1434 if (!EltTy->isCanonical()) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001435 Canonical = getIncompleteArrayType(getCanonicalType(EltTy),
Ted Kremenek2bd24ba2007-10-29 23:37:31 +00001436 ASM, EltTypeQuals);
Eli Friedmanc5773c42008-02-15 18:16:39 +00001437
1438 // Get the new insert position for the node we care about.
1439 IncompleteArrayType *NewIP =
1440 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001441 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Ted Kremenek2bd24ba2007-10-29 23:37:31 +00001442 }
Eli Friedmanc5773c42008-02-15 18:16:39 +00001443
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001444 IncompleteArrayType *New
1445 = new (*this,8) IncompleteArrayType(EltTy, Canonical,
1446 ASM, EltTypeQuals);
Eli Friedmanc5773c42008-02-15 18:16:39 +00001447
1448 IncompleteArrayTypes.InsertNode(New, InsertPos);
1449 Types.push_back(New);
1450 return QualType(New, 0);
Steve Narofffb22d962007-08-30 01:06:46 +00001451}
1452
Steve Naroff73322922007-07-18 18:00:27 +00001453/// getVectorType - Return the unique reference to a vector type of
1454/// the specified element type and size. VectorType must be a built-in type.
1455QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001456 BuiltinType *baseType;
1457
Chris Lattnerf52ab252008-04-06 22:59:24 +00001458 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr());
Steve Naroff73322922007-07-18 18:00:27 +00001459 assert(baseType != 0 && "getVectorType(): Expecting a built-in type");
Reid Spencer5f016e22007-07-11 17:01:13 +00001460
1461 // Check if we've already instantiated a vector of this type.
1462 llvm::FoldingSetNodeID ID;
Steve Naroff73322922007-07-18 18:00:27 +00001463 VectorType::Profile(ID, vecType, NumElts, Type::Vector);
Reid Spencer5f016e22007-07-11 17:01:13 +00001464 void *InsertPos = 0;
1465 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
1466 return QualType(VTP, 0);
1467
1468 // If the element type isn't canonical, this won't be a canonical type either,
1469 // so fill in the canonical type field.
1470 QualType Canonical;
1471 if (!vecType->isCanonical()) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001472 Canonical = getVectorType(getCanonicalType(vecType), NumElts);
Reid Spencer5f016e22007-07-11 17:01:13 +00001473
1474 // Get the new insert position for the node we care about.
1475 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001476 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001477 }
Steve Narofff83820b2009-01-27 22:08:43 +00001478 VectorType *New = new (*this,8) VectorType(vecType, NumElts, Canonical);
Reid Spencer5f016e22007-07-11 17:01:13 +00001479 VectorTypes.InsertNode(New, InsertPos);
1480 Types.push_back(New);
1481 return QualType(New, 0);
1482}
1483
Nate Begeman213541a2008-04-18 23:10:10 +00001484/// getExtVectorType - Return the unique reference to an extended vector type of
Steve Naroff73322922007-07-18 18:00:27 +00001485/// the specified element type and size. VectorType must be a built-in type.
Nate Begeman213541a2008-04-18 23:10:10 +00001486QualType ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) {
Steve Naroff73322922007-07-18 18:00:27 +00001487 BuiltinType *baseType;
1488
Chris Lattnerf52ab252008-04-06 22:59:24 +00001489 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr());
Nate Begeman213541a2008-04-18 23:10:10 +00001490 assert(baseType != 0 && "getExtVectorType(): Expecting a built-in type");
Steve Naroff73322922007-07-18 18:00:27 +00001491
1492 // Check if we've already instantiated a vector of this type.
1493 llvm::FoldingSetNodeID ID;
Nate Begeman213541a2008-04-18 23:10:10 +00001494 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector);
Steve Naroff73322922007-07-18 18:00:27 +00001495 void *InsertPos = 0;
1496 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
1497 return QualType(VTP, 0);
1498
1499 // If the element type isn't canonical, this won't be a canonical type either,
1500 // so fill in the canonical type field.
1501 QualType Canonical;
1502 if (!vecType->isCanonical()) {
Nate Begeman213541a2008-04-18 23:10:10 +00001503 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
Steve Naroff73322922007-07-18 18:00:27 +00001504
1505 // Get the new insert position for the node we care about.
1506 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001507 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Steve Naroff73322922007-07-18 18:00:27 +00001508 }
Steve Narofff83820b2009-01-27 22:08:43 +00001509 ExtVectorType *New = new (*this,8) ExtVectorType(vecType, NumElts, Canonical);
Steve Naroff73322922007-07-18 18:00:27 +00001510 VectorTypes.InsertNode(New, InsertPos);
1511 Types.push_back(New);
1512 return QualType(New, 0);
1513}
1514
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00001515QualType ASTContext::getDependentSizedExtVectorType(QualType vecType,
1516 Expr *SizeExpr,
1517 SourceLocation AttrLoc) {
Douglas Gregor2ec09f12009-07-31 03:54:25 +00001518 llvm::FoldingSetNodeID ID;
1519 DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType),
1520 SizeExpr);
1521
1522 void *InsertPos = 0;
1523 DependentSizedExtVectorType *Canon
1524 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
1525 DependentSizedExtVectorType *New;
1526 if (Canon) {
1527 // We already have a canonical version of this array type; use it as
1528 // the canonical type for a newly-built type.
1529 New = new (*this,8) DependentSizedExtVectorType(*this, vecType,
1530 QualType(Canon, 0),
1531 SizeExpr, AttrLoc);
1532 } else {
1533 QualType CanonVecTy = getCanonicalType(vecType);
1534 if (CanonVecTy == vecType) {
1535 New = new (*this,8) DependentSizedExtVectorType(*this, vecType,
1536 QualType(), SizeExpr,
1537 AttrLoc);
1538 DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
1539 } else {
1540 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
1541 SourceLocation());
1542 New = new (*this,8) DependentSizedExtVectorType(*this, vecType, Canon,
1543 SizeExpr, AttrLoc);
1544 }
1545 }
1546
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00001547 Types.push_back(New);
1548 return QualType(New, 0);
1549}
1550
Douglas Gregor72564e72009-02-26 23:50:07 +00001551/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
Reid Spencer5f016e22007-07-11 17:01:13 +00001552///
Mike Stump24556362009-07-25 21:26:53 +00001553QualType ASTContext::getFunctionNoProtoType(QualType ResultTy, bool NoReturn) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001554 // Unique functions, to guarantee there is only one function of a particular
1555 // structure.
1556 llvm::FoldingSetNodeID ID;
Mike Stump24556362009-07-25 21:26:53 +00001557 FunctionNoProtoType::Profile(ID, ResultTy, NoReturn);
Reid Spencer5f016e22007-07-11 17:01:13 +00001558
1559 void *InsertPos = 0;
Douglas Gregor72564e72009-02-26 23:50:07 +00001560 if (FunctionNoProtoType *FT =
1561 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
Reid Spencer5f016e22007-07-11 17:01:13 +00001562 return QualType(FT, 0);
1563
1564 QualType Canonical;
1565 if (!ResultTy->isCanonical()) {
Mike Stump24556362009-07-25 21:26:53 +00001566 Canonical = getFunctionNoProtoType(getCanonicalType(ResultTy), NoReturn);
Reid Spencer5f016e22007-07-11 17:01:13 +00001567
1568 // Get the new insert position for the node we care about.
Douglas Gregor72564e72009-02-26 23:50:07 +00001569 FunctionNoProtoType *NewIP =
1570 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001571 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001572 }
1573
Mike Stump24556362009-07-25 21:26:53 +00001574 FunctionNoProtoType *New
1575 = new (*this,8) FunctionNoProtoType(ResultTy, Canonical, NoReturn);
Reid Spencer5f016e22007-07-11 17:01:13 +00001576 Types.push_back(New);
Douglas Gregor72564e72009-02-26 23:50:07 +00001577 FunctionNoProtoTypes.InsertNode(New, InsertPos);
Reid Spencer5f016e22007-07-11 17:01:13 +00001578 return QualType(New, 0);
1579}
1580
1581/// getFunctionType - Return a normal function type with a typed argument
1582/// list. isVariadic indicates whether the argument list includes '...'.
Chris Lattner61710852008-10-05 17:34:18 +00001583QualType ASTContext::getFunctionType(QualType ResultTy,const QualType *ArgArray,
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00001584 unsigned NumArgs, bool isVariadic,
Sebastian Redl465226e2009-05-27 22:11:52 +00001585 unsigned TypeQuals, bool hasExceptionSpec,
1586 bool hasAnyExceptionSpec, unsigned NumExs,
Mike Stump24556362009-07-25 21:26:53 +00001587 const QualType *ExArray, bool NoReturn) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001588 // Unique functions, to guarantee there is only one function of a particular
1589 // structure.
1590 llvm::FoldingSetNodeID ID;
Douglas Gregor72564e72009-02-26 23:50:07 +00001591 FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic,
Sebastian Redl465226e2009-05-27 22:11:52 +00001592 TypeQuals, hasExceptionSpec, hasAnyExceptionSpec,
Mike Stump24556362009-07-25 21:26:53 +00001593 NumExs, ExArray, NoReturn);
Reid Spencer5f016e22007-07-11 17:01:13 +00001594
1595 void *InsertPos = 0;
Douglas Gregor72564e72009-02-26 23:50:07 +00001596 if (FunctionProtoType *FTP =
1597 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
Reid Spencer5f016e22007-07-11 17:01:13 +00001598 return QualType(FTP, 0);
Sebastian Redl465226e2009-05-27 22:11:52 +00001599
1600 // Determine whether the type being created is already canonical or not.
Reid Spencer5f016e22007-07-11 17:01:13 +00001601 bool isCanonical = ResultTy->isCanonical();
Sebastian Redl465226e2009-05-27 22:11:52 +00001602 if (hasExceptionSpec)
1603 isCanonical = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00001604 for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
1605 if (!ArgArray[i]->isCanonical())
1606 isCanonical = false;
1607
1608 // If this type isn't canonical, get the canonical version of it.
Sebastian Redl465226e2009-05-27 22:11:52 +00001609 // The exception spec is not part of the canonical type.
Reid Spencer5f016e22007-07-11 17:01:13 +00001610 QualType Canonical;
1611 if (!isCanonical) {
1612 llvm::SmallVector<QualType, 16> CanonicalArgs;
1613 CanonicalArgs.reserve(NumArgs);
1614 for (unsigned i = 0; i != NumArgs; ++i)
Chris Lattnerf52ab252008-04-06 22:59:24 +00001615 CanonicalArgs.push_back(getCanonicalType(ArgArray[i]));
Sebastian Redl465226e2009-05-27 22:11:52 +00001616
Chris Lattnerf52ab252008-04-06 22:59:24 +00001617 Canonical = getFunctionType(getCanonicalType(ResultTy),
Jay Foadbeaaccd2009-05-21 09:52:38 +00001618 CanonicalArgs.data(), NumArgs,
Mike Stump24556362009-07-25 21:26:53 +00001619 isVariadic, TypeQuals, NoReturn);
Sebastian Redl465226e2009-05-27 22:11:52 +00001620
Reid Spencer5f016e22007-07-11 17:01:13 +00001621 // Get the new insert position for the node we care about.
Douglas Gregor72564e72009-02-26 23:50:07 +00001622 FunctionProtoType *NewIP =
1623 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001624 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001625 }
Sebastian Redl465226e2009-05-27 22:11:52 +00001626
Douglas Gregor72564e72009-02-26 23:50:07 +00001627 // FunctionProtoType objects are allocated with extra bytes after them
Sebastian Redl465226e2009-05-27 22:11:52 +00001628 // for two variable size arrays (for parameter and exception types) at the
1629 // end of them.
Douglas Gregor72564e72009-02-26 23:50:07 +00001630 FunctionProtoType *FTP =
Sebastian Redl465226e2009-05-27 22:11:52 +00001631 (FunctionProtoType*)Allocate(sizeof(FunctionProtoType) +
1632 NumArgs*sizeof(QualType) +
1633 NumExs*sizeof(QualType), 8);
Douglas Gregor72564e72009-02-26 23:50:07 +00001634 new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, isVariadic,
Sebastian Redl465226e2009-05-27 22:11:52 +00001635 TypeQuals, hasExceptionSpec, hasAnyExceptionSpec,
Mike Stump24556362009-07-25 21:26:53 +00001636 ExArray, NumExs, Canonical, NoReturn);
Reid Spencer5f016e22007-07-11 17:01:13 +00001637 Types.push_back(FTP);
Douglas Gregor72564e72009-02-26 23:50:07 +00001638 FunctionProtoTypes.InsertNode(FTP, InsertPos);
Reid Spencer5f016e22007-07-11 17:01:13 +00001639 return QualType(FTP, 0);
1640}
1641
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001642/// getTypeDeclType - Return the unique reference to the type for the
1643/// specified type declaration.
Ted Kremenek4b7c9832008-09-05 17:16:31 +00001644QualType ASTContext::getTypeDeclType(TypeDecl *Decl, TypeDecl* PrevDecl) {
Argyrios Kyrtzidis1e6759e2008-10-16 16:50:47 +00001645 assert(Decl && "Passed null for Decl param");
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001646 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
1647
Argyrios Kyrtzidis1e6759e2008-10-16 16:50:47 +00001648 if (TypedefDecl *Typedef = dyn_cast<TypedefDecl>(Decl))
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001649 return getTypedefType(Typedef);
Douglas Gregorfab9d672009-02-05 23:33:38 +00001650 else if (isa<TemplateTypeParmDecl>(Decl)) {
1651 assert(false && "Template type parameter types are always available.");
Mike Stump9fdbab32009-07-31 02:02:20 +00001652 } else if (ObjCInterfaceDecl *ObjCInterface
1653 = dyn_cast<ObjCInterfaceDecl>(Decl))
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001654 return getObjCInterfaceType(ObjCInterface);
Argyrios Kyrtzidis49aa7ff2008-08-07 20:55:28 +00001655
Douglas Gregorc1efaec2009-02-28 01:32:25 +00001656 if (RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) {
Ted Kremenek566c2ba2009-01-19 21:31:22 +00001657 if (PrevDecl)
1658 Decl->TypeForDecl = PrevDecl->TypeForDecl;
Steve Narofff83820b2009-01-27 22:08:43 +00001659 else
1660 Decl->TypeForDecl = new (*this,8) RecordType(Record);
Mike Stump9fdbab32009-07-31 02:02:20 +00001661 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) {
Ted Kremenek566c2ba2009-01-19 21:31:22 +00001662 if (PrevDecl)
1663 Decl->TypeForDecl = PrevDecl->TypeForDecl;
Steve Narofff83820b2009-01-27 22:08:43 +00001664 else
1665 Decl->TypeForDecl = new (*this,8) EnumType(Enum);
Mike Stump9fdbab32009-07-31 02:02:20 +00001666 } else
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001667 assert(false && "TypeDecl without a type?");
Argyrios Kyrtzidis49aa7ff2008-08-07 20:55:28 +00001668
Ted Kremenek4b7c9832008-09-05 17:16:31 +00001669 if (!PrevDecl) Types.push_back(Decl->TypeForDecl);
Argyrios Kyrtzidis49aa7ff2008-08-07 20:55:28 +00001670 return QualType(Decl->TypeForDecl, 0);
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001671}
1672
Reid Spencer5f016e22007-07-11 17:01:13 +00001673/// getTypedefType - Return the unique reference to the type for the
1674/// specified typename decl.
1675QualType ASTContext::getTypedefType(TypedefDecl *Decl) {
1676 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
1677
Chris Lattnerf52ab252008-04-06 22:59:24 +00001678 QualType Canonical = getCanonicalType(Decl->getUnderlyingType());
Douglas Gregor72564e72009-02-26 23:50:07 +00001679 Decl->TypeForDecl = new(*this,8) TypedefType(Type::Typedef, Decl, Canonical);
Reid Spencer5f016e22007-07-11 17:01:13 +00001680 Types.push_back(Decl->TypeForDecl);
1681 return QualType(Decl->TypeForDecl, 0);
1682}
1683
Douglas Gregorfab9d672009-02-05 23:33:38 +00001684/// \brief Retrieve the template type parameter type for a template
Anders Carlsson76e4ce42009-06-16 00:30:48 +00001685/// parameter or parameter pack with the given depth, index, and (optionally)
1686/// name.
Douglas Gregorfab9d672009-02-05 23:33:38 +00001687QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
Anders Carlsson76e4ce42009-06-16 00:30:48 +00001688 bool ParameterPack,
Douglas Gregorfab9d672009-02-05 23:33:38 +00001689 IdentifierInfo *Name) {
1690 llvm::FoldingSetNodeID ID;
Anders Carlsson76e4ce42009-06-16 00:30:48 +00001691 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, Name);
Douglas Gregorfab9d672009-02-05 23:33:38 +00001692 void *InsertPos = 0;
1693 TemplateTypeParmType *TypeParm
1694 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
1695
1696 if (TypeParm)
1697 return QualType(TypeParm, 0);
1698
Anders Carlsson76e4ce42009-06-16 00:30:48 +00001699 if (Name) {
1700 QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
1701 TypeParm = new (*this, 8) TemplateTypeParmType(Depth, Index, ParameterPack,
1702 Name, Canon);
1703 } else
1704 TypeParm = new (*this, 8) TemplateTypeParmType(Depth, Index, ParameterPack);
Douglas Gregorfab9d672009-02-05 23:33:38 +00001705
1706 Types.push_back(TypeParm);
1707 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
1708
1709 return QualType(TypeParm, 0);
1710}
1711
Douglas Gregor55f6b142009-02-09 18:46:07 +00001712QualType
Douglas Gregor7532dc62009-03-30 22:58:21 +00001713ASTContext::getTemplateSpecializationType(TemplateName Template,
1714 const TemplateArgument *Args,
1715 unsigned NumArgs,
1716 QualType Canon) {
Douglas Gregorb88e8882009-07-30 17:40:51 +00001717 if (!Canon.isNull())
1718 Canon = getCanonicalType(Canon);
1719 else {
1720 // Build the canonical template specialization type.
Douglas Gregor1275ae02009-07-28 23:00:59 +00001721 TemplateName CanonTemplate = getCanonicalTemplateName(Template);
1722 llvm::SmallVector<TemplateArgument, 4> CanonArgs;
1723 CanonArgs.reserve(NumArgs);
1724 for (unsigned I = 0; I != NumArgs; ++I)
1725 CanonArgs.push_back(getCanonicalTemplateArgument(Args[I]));
1726
1727 // Determine whether this canonical template specialization type already
1728 // exists.
1729 llvm::FoldingSetNodeID ID;
1730 TemplateSpecializationType::Profile(ID, CanonTemplate,
Douglas Gregor828e2262009-07-29 16:09:57 +00001731 CanonArgs.data(), NumArgs, *this);
Douglas Gregor1275ae02009-07-28 23:00:59 +00001732
1733 void *InsertPos = 0;
1734 TemplateSpecializationType *Spec
1735 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
1736
1737 if (!Spec) {
1738 // Allocate a new canonical template specialization type.
1739 void *Mem = Allocate((sizeof(TemplateSpecializationType) +
1740 sizeof(TemplateArgument) * NumArgs),
1741 8);
Douglas Gregor828e2262009-07-29 16:09:57 +00001742 Spec = new (Mem) TemplateSpecializationType(*this, CanonTemplate,
Douglas Gregor1275ae02009-07-28 23:00:59 +00001743 CanonArgs.data(), NumArgs,
Douglas Gregorb88e8882009-07-30 17:40:51 +00001744 Canon);
Douglas Gregor1275ae02009-07-28 23:00:59 +00001745 Types.push_back(Spec);
1746 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
1747 }
1748
Douglas Gregorb88e8882009-07-30 17:40:51 +00001749 if (Canon.isNull())
1750 Canon = QualType(Spec, 0);
Douglas Gregor1275ae02009-07-28 23:00:59 +00001751 assert(Canon->isDependentType() &&
1752 "Non-dependent template-id type must have a canonical type");
Douglas Gregorb88e8882009-07-30 17:40:51 +00001753 }
Douglas Gregorfc705b82009-02-26 22:19:44 +00001754
Douglas Gregor1275ae02009-07-28 23:00:59 +00001755 // Allocate the (non-canonical) template specialization type, but don't
1756 // try to unique it: these types typically have location information that
1757 // we don't unique and don't want to lose.
Douglas Gregor7532dc62009-03-30 22:58:21 +00001758 void *Mem = Allocate((sizeof(TemplateSpecializationType) +
Douglas Gregor40808ce2009-03-09 23:48:35 +00001759 sizeof(TemplateArgument) * NumArgs),
1760 8);
Douglas Gregor1275ae02009-07-28 23:00:59 +00001761 TemplateSpecializationType *Spec
Douglas Gregor828e2262009-07-29 16:09:57 +00001762 = new (Mem) TemplateSpecializationType(*this, Template, Args, NumArgs,
1763 Canon);
Douglas Gregor1275ae02009-07-28 23:00:59 +00001764
Douglas Gregor55f6b142009-02-09 18:46:07 +00001765 Types.push_back(Spec);
Douglas Gregor55f6b142009-02-09 18:46:07 +00001766 return QualType(Spec, 0);
1767}
1768
Douglas Gregore4e5b052009-03-19 00:18:19 +00001769QualType
Douglas Gregorab452ba2009-03-26 23:50:42 +00001770ASTContext::getQualifiedNameType(NestedNameSpecifier *NNS,
Douglas Gregore4e5b052009-03-19 00:18:19 +00001771 QualType NamedType) {
1772 llvm::FoldingSetNodeID ID;
Douglas Gregorab452ba2009-03-26 23:50:42 +00001773 QualifiedNameType::Profile(ID, NNS, NamedType);
Douglas Gregore4e5b052009-03-19 00:18:19 +00001774
1775 void *InsertPos = 0;
1776 QualifiedNameType *T
1777 = QualifiedNameTypes.FindNodeOrInsertPos(ID, InsertPos);
1778 if (T)
1779 return QualType(T, 0);
1780
Douglas Gregorab452ba2009-03-26 23:50:42 +00001781 T = new (*this) QualifiedNameType(NNS, NamedType,
1782 getCanonicalType(NamedType));
Douglas Gregore4e5b052009-03-19 00:18:19 +00001783 Types.push_back(T);
1784 QualifiedNameTypes.InsertNode(T, InsertPos);
1785 return QualType(T, 0);
1786}
1787
Douglas Gregord57959a2009-03-27 23:10:48 +00001788QualType ASTContext::getTypenameType(NestedNameSpecifier *NNS,
1789 const IdentifierInfo *Name,
1790 QualType Canon) {
1791 assert(NNS->isDependent() && "nested-name-specifier must be dependent");
1792
1793 if (Canon.isNull()) {
1794 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
1795 if (CanonNNS != NNS)
1796 Canon = getTypenameType(CanonNNS, Name);
1797 }
1798
1799 llvm::FoldingSetNodeID ID;
1800 TypenameType::Profile(ID, NNS, Name);
1801
1802 void *InsertPos = 0;
1803 TypenameType *T
1804 = TypenameTypes.FindNodeOrInsertPos(ID, InsertPos);
1805 if (T)
1806 return QualType(T, 0);
1807
1808 T = new (*this) TypenameType(NNS, Name, Canon);
1809 Types.push_back(T);
1810 TypenameTypes.InsertNode(T, InsertPos);
1811 return QualType(T, 0);
1812}
1813
Douglas Gregor17343172009-04-01 00:28:59 +00001814QualType
1815ASTContext::getTypenameType(NestedNameSpecifier *NNS,
1816 const TemplateSpecializationType *TemplateId,
1817 QualType Canon) {
1818 assert(NNS->isDependent() && "nested-name-specifier must be dependent");
1819
1820 if (Canon.isNull()) {
1821 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
1822 QualType CanonType = getCanonicalType(QualType(TemplateId, 0));
1823 if (CanonNNS != NNS || CanonType != QualType(TemplateId, 0)) {
1824 const TemplateSpecializationType *CanonTemplateId
1825 = CanonType->getAsTemplateSpecializationType();
1826 assert(CanonTemplateId &&
1827 "Canonical type must also be a template specialization type");
1828 Canon = getTypenameType(CanonNNS, CanonTemplateId);
1829 }
1830 }
1831
1832 llvm::FoldingSetNodeID ID;
1833 TypenameType::Profile(ID, NNS, TemplateId);
1834
1835 void *InsertPos = 0;
1836 TypenameType *T
1837 = TypenameTypes.FindNodeOrInsertPos(ID, InsertPos);
1838 if (T)
1839 return QualType(T, 0);
1840
1841 T = new (*this) TypenameType(NNS, TemplateId, Canon);
1842 Types.push_back(T);
1843 TypenameTypes.InsertNode(T, InsertPos);
1844 return QualType(T, 0);
1845}
1846
Chris Lattner88cb27a2008-04-07 04:56:42 +00001847/// CmpProtocolNames - Comparison predicate for sorting protocols
1848/// alphabetically.
1849static bool CmpProtocolNames(const ObjCProtocolDecl *LHS,
1850 const ObjCProtocolDecl *RHS) {
Douglas Gregor2e1cd422008-11-17 14:58:09 +00001851 return LHS->getDeclName() < RHS->getDeclName();
Chris Lattner88cb27a2008-04-07 04:56:42 +00001852}
1853
1854static void SortAndUniqueProtocols(ObjCProtocolDecl **&Protocols,
1855 unsigned &NumProtocols) {
1856 ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols;
1857
1858 // Sort protocols, keyed by name.
1859 std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames);
1860
1861 // Remove duplicates.
1862 ProtocolsEnd = std::unique(Protocols, ProtocolsEnd);
1863 NumProtocols = ProtocolsEnd-Protocols;
1864}
1865
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00001866/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
1867/// the given interface decl and the conforming protocol list.
Steve Naroff14108da2009-07-10 23:34:53 +00001868QualType ASTContext::getObjCObjectPointerType(QualType InterfaceT,
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00001869 ObjCProtocolDecl **Protocols,
1870 unsigned NumProtocols) {
1871 // Sort the protocol list alphabetically to canonicalize it.
1872 if (NumProtocols)
1873 SortAndUniqueProtocols(Protocols, NumProtocols);
1874
1875 llvm::FoldingSetNodeID ID;
Steve Naroff14108da2009-07-10 23:34:53 +00001876 ObjCObjectPointerType::Profile(ID, InterfaceT, Protocols, NumProtocols);
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00001877
1878 void *InsertPos = 0;
1879 if (ObjCObjectPointerType *QT =
1880 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
1881 return QualType(QT, 0);
1882
1883 // No Match;
1884 ObjCObjectPointerType *QType =
Steve Naroff14108da2009-07-10 23:34:53 +00001885 new (*this,8) ObjCObjectPointerType(InterfaceT, Protocols, NumProtocols);
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00001886
1887 Types.push_back(QType);
1888 ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
1889 return QualType(QType, 0);
1890}
Chris Lattner88cb27a2008-04-07 04:56:42 +00001891
Steve Naroffc15cb2a2009-07-18 15:33:26 +00001892/// getObjCInterfaceType - Return the unique reference to the type for the
1893/// specified ObjC interface decl. The list of protocols is optional.
1894QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001895 ObjCProtocolDecl **Protocols, unsigned NumProtocols) {
Steve Naroffc15cb2a2009-07-18 15:33:26 +00001896 if (NumProtocols)
1897 // Sort the protocol list alphabetically to canonicalize it.
1898 SortAndUniqueProtocols(Protocols, NumProtocols);
Chris Lattner88cb27a2008-04-07 04:56:42 +00001899
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00001900 llvm::FoldingSetNodeID ID;
Steve Naroffc15cb2a2009-07-18 15:33:26 +00001901 ObjCInterfaceType::Profile(ID, Decl, Protocols, NumProtocols);
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00001902
1903 void *InsertPos = 0;
Steve Naroffc15cb2a2009-07-18 15:33:26 +00001904 if (ObjCInterfaceType *QT =
1905 ObjCInterfaceTypes.FindNodeOrInsertPos(ID, InsertPos))
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00001906 return QualType(QT, 0);
1907
1908 // No Match;
Steve Naroffc15cb2a2009-07-18 15:33:26 +00001909 ObjCInterfaceType *QType =
1910 new (*this,8) ObjCInterfaceType(const_cast<ObjCInterfaceDecl*>(Decl),
1911 Protocols, NumProtocols);
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00001912 Types.push_back(QType);
Steve Naroffc15cb2a2009-07-18 15:33:26 +00001913 ObjCInterfaceTypes.InsertNode(QType, InsertPos);
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00001914 return QualType(QType, 0);
1915}
1916
Douglas Gregor72564e72009-02-26 23:50:07 +00001917/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
1918/// TypeOfExprType AST's (since expression's are never shared). For example,
Steve Naroff9752f252007-08-01 18:02:17 +00001919/// multiple declarations that refer to "typeof(x)" all contain different
1920/// DeclRefExpr's. This doesn't effect the type checker, since it operates
1921/// on canonical type's (which are always unique).
Douglas Gregor72564e72009-02-26 23:50:07 +00001922QualType ASTContext::getTypeOfExprType(Expr *tofExpr) {
Douglas Gregordd0257c2009-07-08 00:03:05 +00001923 TypeOfExprType *toe;
Douglas Gregorb1975722009-07-30 23:18:24 +00001924 if (tofExpr->isTypeDependent()) {
1925 llvm::FoldingSetNodeID ID;
1926 DependentTypeOfExprType::Profile(ID, *this, tofExpr);
1927
1928 void *InsertPos = 0;
1929 DependentTypeOfExprType *Canon
1930 = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
1931 if (Canon) {
1932 // We already have a "canonical" version of an identical, dependent
1933 // typeof(expr) type. Use that as our canonical type.
1934 toe = new (*this, 8) TypeOfExprType(tofExpr,
1935 QualType((TypeOfExprType*)Canon, 0));
1936 }
1937 else {
1938 // Build a new, canonical typeof(expr) type.
1939 Canon = new (*this, 8) DependentTypeOfExprType(*this, tofExpr);
1940 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
1941 toe = Canon;
1942 }
1943 } else {
Douglas Gregordd0257c2009-07-08 00:03:05 +00001944 QualType Canonical = getCanonicalType(tofExpr->getType());
1945 toe = new (*this,8) TypeOfExprType(tofExpr, Canonical);
1946 }
Steve Naroff9752f252007-08-01 18:02:17 +00001947 Types.push_back(toe);
1948 return QualType(toe, 0);
Steve Naroffd1861fd2007-07-31 12:34:36 +00001949}
1950
Steve Naroff9752f252007-08-01 18:02:17 +00001951/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique
1952/// TypeOfType AST's. The only motivation to unique these nodes would be
1953/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
1954/// an issue. This doesn't effect the type checker, since it operates
1955/// on canonical type's (which are always unique).
Steve Naroffd1861fd2007-07-31 12:34:36 +00001956QualType ASTContext::getTypeOfType(QualType tofType) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001957 QualType Canonical = getCanonicalType(tofType);
Steve Narofff83820b2009-01-27 22:08:43 +00001958 TypeOfType *tot = new (*this,8) TypeOfType(tofType, Canonical);
Steve Naroff9752f252007-08-01 18:02:17 +00001959 Types.push_back(tot);
1960 return QualType(tot, 0);
Steve Naroffd1861fd2007-07-31 12:34:36 +00001961}
1962
Anders Carlsson60a9a2a2009-06-24 21:24:56 +00001963/// getDecltypeForExpr - Given an expr, will return the decltype for that
1964/// expression, according to the rules in C++0x [dcl.type.simple]p4
1965static QualType getDecltypeForExpr(const Expr *e, ASTContext &Context) {
Anders Carlssona07c33e2009-06-25 15:00:34 +00001966 if (e->isTypeDependent())
1967 return Context.DependentTy;
1968
Anders Carlsson60a9a2a2009-06-24 21:24:56 +00001969 // If e is an id expression or a class member access, decltype(e) is defined
1970 // as the type of the entity named by e.
1971 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(e)) {
1972 if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl()))
1973 return VD->getType();
1974 }
1975 if (const MemberExpr *ME = dyn_cast<MemberExpr>(e)) {
1976 if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
1977 return FD->getType();
1978 }
1979 // If e is a function call or an invocation of an overloaded operator,
1980 // (parentheses around e are ignored), decltype(e) is defined as the
1981 // return type of that function.
1982 if (const CallExpr *CE = dyn_cast<CallExpr>(e->IgnoreParens()))
1983 return CE->getCallReturnType();
1984
1985 QualType T = e->getType();
1986
1987 // Otherwise, where T is the type of e, if e is an lvalue, decltype(e) is
1988 // defined as T&, otherwise decltype(e) is defined as T.
1989 if (e->isLvalue(Context) == Expr::LV_Valid)
1990 T = Context.getLValueReferenceType(T);
1991
1992 return T;
1993}
1994
Anders Carlsson395b4752009-06-24 19:06:50 +00001995/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique
1996/// DecltypeType AST's. The only motivation to unique these nodes would be
1997/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be
1998/// an issue. This doesn't effect the type checker, since it operates
1999/// on canonical type's (which are always unique).
2000QualType ASTContext::getDecltypeType(Expr *e) {
Douglas Gregordd0257c2009-07-08 00:03:05 +00002001 DecltypeType *dt;
Douglas Gregor9d702ae2009-07-30 23:36:40 +00002002 if (e->isTypeDependent()) {
2003 llvm::FoldingSetNodeID ID;
2004 DependentDecltypeType::Profile(ID, *this, e);
2005
2006 void *InsertPos = 0;
2007 DependentDecltypeType *Canon
2008 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
2009 if (Canon) {
2010 // We already have a "canonical" version of an equivalent, dependent
2011 // decltype type. Use that as our canonical type.
2012 dt = new (*this, 8) DecltypeType(e, DependentTy,
2013 QualType((DecltypeType*)Canon, 0));
2014 }
2015 else {
2016 // Build a new, canonical typeof(expr) type.
2017 Canon = new (*this, 8) DependentDecltypeType(*this, e);
2018 DependentDecltypeTypes.InsertNode(Canon, InsertPos);
2019 dt = Canon;
2020 }
2021 } else {
Douglas Gregordd0257c2009-07-08 00:03:05 +00002022 QualType T = getDecltypeForExpr(e, *this);
Anders Carlsson563a03b2009-07-10 19:20:26 +00002023 dt = new (*this, 8) DecltypeType(e, T, getCanonicalType(T));
Douglas Gregordd0257c2009-07-08 00:03:05 +00002024 }
Anders Carlsson395b4752009-06-24 19:06:50 +00002025 Types.push_back(dt);
2026 return QualType(dt, 0);
2027}
2028
Reid Spencer5f016e22007-07-11 17:01:13 +00002029/// getTagDeclType - Return the unique reference to the type for the
2030/// specified TagDecl (struct/union/class/enum) decl.
2031QualType ASTContext::getTagDeclType(TagDecl *Decl) {
Ted Kremenekd778f882007-11-26 21:16:01 +00002032 assert (Decl);
Douglas Gregor2ce52f32008-04-13 21:07:44 +00002033 return getTypeDeclType(Decl);
Reid Spencer5f016e22007-07-11 17:01:13 +00002034}
2035
2036/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
2037/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
2038/// needs to agree with the definition in <stddef.h>.
2039QualType ASTContext::getSizeType() const {
Douglas Gregorb4e66d52008-11-03 14:12:49 +00002040 return getFromTargetType(Target.getSizeType());
Reid Spencer5f016e22007-07-11 17:01:13 +00002041}
2042
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00002043/// getSignedWCharType - Return the type of "signed wchar_t".
2044/// Used when in C++, as a GCC extension.
2045QualType ASTContext::getSignedWCharType() const {
2046 // FIXME: derive from "Target" ?
2047 return WCharTy;
2048}
2049
2050/// getUnsignedWCharType - Return the type of "unsigned wchar_t".
2051/// Used when in C++, as a GCC extension.
2052QualType ASTContext::getUnsignedWCharType() const {
2053 // FIXME: derive from "Target" ?
2054 return UnsignedIntTy;
2055}
2056
Chris Lattner8b9023b2007-07-13 03:05:23 +00002057/// getPointerDiffType - Return the unique type for "ptrdiff_t" (ref?)
2058/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
2059QualType ASTContext::getPointerDiffType() const {
Douglas Gregorb4e66d52008-11-03 14:12:49 +00002060 return getFromTargetType(Target.getPtrDiffType(0));
Chris Lattner8b9023b2007-07-13 03:05:23 +00002061}
2062
Chris Lattnere6327742008-04-02 05:18:44 +00002063//===----------------------------------------------------------------------===//
2064// Type Operators
2065//===----------------------------------------------------------------------===//
2066
Chris Lattner77c96472008-04-06 22:41:35 +00002067/// getCanonicalType - Return the canonical (structural) type corresponding to
2068/// the specified potentially non-canonical type. The non-canonical version
2069/// of a type may have many "decorated" versions of types. Decorators can
2070/// include typedefs, 'typeof' operators, etc. The returned type is guaranteed
2071/// to be free of any of these, allowing two canonical types to be compared
2072/// for exact equality with a simple pointer comparison.
Douglas Gregor50d62d12009-08-05 05:36:45 +00002073CanQualType ASTContext::getCanonicalType(QualType T) {
Chris Lattner77c96472008-04-06 22:41:35 +00002074 QualType CanType = T.getTypePtr()->getCanonicalTypeInternal();
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002075
2076 // If the result has type qualifiers, make sure to canonicalize them as well.
2077 unsigned TypeQuals = T.getCVRQualifiers() | CanType.getCVRQualifiers();
Douglas Gregor50d62d12009-08-05 05:36:45 +00002078 if (TypeQuals == 0)
2079 return CanQualType::CreateUnsafe(CanType);
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002080
2081 // If the type qualifiers are on an array type, get the canonical type of the
2082 // array with the qualifiers applied to the element type.
2083 ArrayType *AT = dyn_cast<ArrayType>(CanType);
2084 if (!AT)
Douglas Gregor50d62d12009-08-05 05:36:45 +00002085 return CanQualType::CreateUnsafe(CanType.getQualifiedType(TypeQuals));
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002086
2087 // Get the canonical version of the element with the extra qualifiers on it.
2088 // This can recursively sink qualifiers through multiple levels of arrays.
2089 QualType NewEltTy=AT->getElementType().getWithAdditionalQualifiers(TypeQuals);
2090 NewEltTy = getCanonicalType(NewEltTy);
2091
2092 if (ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
Douglas Gregor50d62d12009-08-05 05:36:45 +00002093 return CanQualType::CreateUnsafe(
2094 getConstantArrayType(NewEltTy, CAT->getSize(),
2095 CAT->getSizeModifier(),
2096 CAT->getIndexTypeQualifier()));
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002097 if (IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT))
Douglas Gregor50d62d12009-08-05 05:36:45 +00002098 return CanQualType::CreateUnsafe(
2099 getIncompleteArrayType(NewEltTy, IAT->getSizeModifier(),
2100 IAT->getIndexTypeQualifier()));
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002101
Douglas Gregor898574e2008-12-05 23:32:09 +00002102 if (DependentSizedArrayType *DSAT = dyn_cast<DependentSizedArrayType>(AT))
Douglas Gregor50d62d12009-08-05 05:36:45 +00002103 return CanQualType::CreateUnsafe(
2104 getDependentSizedArrayType(NewEltTy,
2105 DSAT->getSizeExpr(),
2106 DSAT->getSizeModifier(),
2107 DSAT->getIndexTypeQualifier(),
2108 DSAT->getBracketsRange()));
Douglas Gregor898574e2008-12-05 23:32:09 +00002109
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002110 VariableArrayType *VAT = cast<VariableArrayType>(AT);
Douglas Gregor50d62d12009-08-05 05:36:45 +00002111 return CanQualType::CreateUnsafe(getVariableArrayType(NewEltTy,
2112 VAT->getSizeExpr(),
2113 VAT->getSizeModifier(),
2114 VAT->getIndexTypeQualifier(),
2115 VAT->getBracketsRange()));
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002116}
2117
Douglas Gregor25a3ef72009-05-07 06:41:52 +00002118TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) {
2119 // If this template name refers to a template, the canonical
2120 // template name merely stores the template itself.
2121 if (TemplateDecl *Template = Name.getAsTemplateDecl())
Argyrios Kyrtzidis97fbaa22009-07-18 00:34:25 +00002122 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
Douglas Gregor25a3ef72009-05-07 06:41:52 +00002123
Douglas Gregord99cbe62009-07-29 18:26:50 +00002124 // If this template name refers to a set of overloaded function templates,
2125 /// the canonical template name merely stores the set of function templates.
Douglas Gregor6ebd15e2009-07-31 05:24:01 +00002126 if (OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl()) {
2127 OverloadedFunctionDecl *CanonOvl = 0;
2128 for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(),
2129 FEnd = Ovl->function_end();
2130 F != FEnd; ++F) {
2131 Decl *Canon = F->get()->getCanonicalDecl();
2132 if (CanonOvl || Canon != F->get()) {
2133 if (!CanonOvl)
2134 CanonOvl = OverloadedFunctionDecl::Create(*this,
2135 Ovl->getDeclContext(),
2136 Ovl->getDeclName());
2137
2138 CanonOvl->addOverload(
2139 AnyFunctionDecl::getFromNamedDecl(cast<NamedDecl>(Canon)));
2140 }
2141 }
2142
2143 return TemplateName(CanonOvl? CanonOvl : Ovl);
2144 }
Douglas Gregord99cbe62009-07-29 18:26:50 +00002145
Douglas Gregor25a3ef72009-05-07 06:41:52 +00002146 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
2147 assert(DTN && "Non-dependent template names must refer to template decls.");
2148 return DTN->CanonicalTemplateName;
2149}
2150
Douglas Gregor1275ae02009-07-28 23:00:59 +00002151TemplateArgument
2152ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) {
2153 switch (Arg.getKind()) {
2154 case TemplateArgument::Null:
2155 return Arg;
2156
2157 case TemplateArgument::Expression:
2158 // FIXME: Build canonical expression?
2159 return Arg;
2160
2161 case TemplateArgument::Declaration:
2162 return TemplateArgument(SourceLocation(),
2163 Arg.getAsDecl()->getCanonicalDecl());
2164
2165 case TemplateArgument::Integral:
2166 return TemplateArgument(SourceLocation(),
2167 *Arg.getAsIntegral(),
2168 getCanonicalType(Arg.getIntegralType()));
2169
2170 case TemplateArgument::Type:
2171 return TemplateArgument(SourceLocation(),
2172 getCanonicalType(Arg.getAsType()));
2173
2174 case TemplateArgument::Pack: {
2175 // FIXME: Allocate in ASTContext
2176 TemplateArgument *CanonArgs = new TemplateArgument[Arg.pack_size()];
2177 unsigned Idx = 0;
2178 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
2179 AEnd = Arg.pack_end();
2180 A != AEnd; (void)++A, ++Idx)
2181 CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
2182
2183 TemplateArgument Result;
2184 Result.setArgumentPack(CanonArgs, Arg.pack_size(), false);
2185 return Result;
2186 }
2187 }
2188
2189 // Silence GCC warning
2190 assert(false && "Unhandled template argument kind");
2191 return TemplateArgument();
2192}
2193
Douglas Gregord57959a2009-03-27 23:10:48 +00002194NestedNameSpecifier *
2195ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) {
2196 if (!NNS)
2197 return 0;
2198
2199 switch (NNS->getKind()) {
2200 case NestedNameSpecifier::Identifier:
2201 // Canonicalize the prefix but keep the identifier the same.
2202 return NestedNameSpecifier::Create(*this,
2203 getCanonicalNestedNameSpecifier(NNS->getPrefix()),
2204 NNS->getAsIdentifier());
2205
2206 case NestedNameSpecifier::Namespace:
2207 // A namespace is canonical; build a nested-name-specifier with
2208 // this namespace and no prefix.
2209 return NestedNameSpecifier::Create(*this, 0, NNS->getAsNamespace());
2210
2211 case NestedNameSpecifier::TypeSpec:
2212 case NestedNameSpecifier::TypeSpecWithTemplate: {
2213 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
2214 NestedNameSpecifier *Prefix = 0;
2215
2216 // FIXME: This isn't the right check!
2217 if (T->isDependentType())
2218 Prefix = getCanonicalNestedNameSpecifier(NNS->getPrefix());
2219
2220 return NestedNameSpecifier::Create(*this, Prefix,
2221 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
2222 T.getTypePtr());
2223 }
2224
2225 case NestedNameSpecifier::Global:
2226 // The global specifier is canonical and unique.
2227 return NNS;
2228 }
2229
2230 // Required to silence a GCC warning
2231 return 0;
2232}
2233
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002234
2235const ArrayType *ASTContext::getAsArrayType(QualType T) {
2236 // Handle the non-qualified case efficiently.
2237 if (T.getCVRQualifiers() == 0) {
2238 // Handle the common positive case fast.
2239 if (const ArrayType *AT = dyn_cast<ArrayType>(T))
2240 return AT;
2241 }
2242
2243 // Handle the common negative case fast, ignoring CVR qualifiers.
2244 QualType CType = T->getCanonicalTypeInternal();
2245
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00002246 // Make sure to look through type qualifiers (like ExtQuals) for the negative
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002247 // test.
2248 if (!isa<ArrayType>(CType) &&
2249 !isa<ArrayType>(CType.getUnqualifiedType()))
2250 return 0;
2251
2252 // Apply any CVR qualifiers from the array type to the element type. This
2253 // implements C99 6.7.3p8: "If the specification of an array type includes
2254 // any type qualifiers, the element type is so qualified, not the array type."
2255
2256 // If we get here, we either have type qualifiers on the type, or we have
2257 // sugar such as a typedef in the way. If we have type qualifiers on the type
Douglas Gregor50d62d12009-08-05 05:36:45 +00002258 // we must propagate them down into the element type.
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002259 unsigned CVRQuals = T.getCVRQualifiers();
2260 unsigned AddrSpace = 0;
2261 Type *Ty = T.getTypePtr();
2262
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00002263 // Rip through ExtQualType's and typedefs to get to a concrete type.
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002264 while (1) {
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00002265 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(Ty)) {
2266 AddrSpace = EXTQT->getAddressSpace();
2267 Ty = EXTQT->getBaseType();
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002268 } else {
2269 T = Ty->getDesugaredType();
2270 if (T.getTypePtr() == Ty && T.getCVRQualifiers() == 0)
2271 break;
2272 CVRQuals |= T.getCVRQualifiers();
2273 Ty = T.getTypePtr();
2274 }
2275 }
2276
2277 // If we have a simple case, just return now.
2278 const ArrayType *ATy = dyn_cast<ArrayType>(Ty);
2279 if (ATy == 0 || (AddrSpace == 0 && CVRQuals == 0))
2280 return ATy;
2281
2282 // Otherwise, we have an array and we have qualifiers on it. Push the
2283 // qualifiers into the array element type and return a new array type.
2284 // Get the canonical version of the element with the extra qualifiers on it.
2285 // This can recursively sink qualifiers through multiple levels of arrays.
2286 QualType NewEltTy = ATy->getElementType();
2287 if (AddrSpace)
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00002288 NewEltTy = getAddrSpaceQualType(NewEltTy, AddrSpace);
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002289 NewEltTy = NewEltTy.getWithAdditionalQualifiers(CVRQuals);
2290
2291 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy))
2292 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
2293 CAT->getSizeModifier(),
2294 CAT->getIndexTypeQualifier()));
2295 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy))
2296 return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
2297 IAT->getSizeModifier(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002298 IAT->getIndexTypeQualifier()));
Douglas Gregor898574e2008-12-05 23:32:09 +00002299
Douglas Gregor898574e2008-12-05 23:32:09 +00002300 if (const DependentSizedArrayType *DSAT
2301 = dyn_cast<DependentSizedArrayType>(ATy))
2302 return cast<ArrayType>(
2303 getDependentSizedArrayType(NewEltTy,
2304 DSAT->getSizeExpr(),
2305 DSAT->getSizeModifier(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002306 DSAT->getIndexTypeQualifier(),
2307 DSAT->getBracketsRange()));
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002308
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002309 const VariableArrayType *VAT = cast<VariableArrayType>(ATy);
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002310 return cast<ArrayType>(getVariableArrayType(NewEltTy,
2311 VAT->getSizeExpr(),
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002312 VAT->getSizeModifier(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002313 VAT->getIndexTypeQualifier(),
2314 VAT->getBracketsRange()));
Chris Lattner77c96472008-04-06 22:41:35 +00002315}
2316
2317
Chris Lattnere6327742008-04-02 05:18:44 +00002318/// getArrayDecayedType - Return the properly qualified result of decaying the
2319/// specified array type to a pointer. This operation is non-trivial when
2320/// handling typedefs etc. The canonical type of "T" must be an array type,
2321/// this returns a pointer to a properly qualified element of the array.
2322///
2323/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
2324QualType ASTContext::getArrayDecayedType(QualType Ty) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002325 // Get the element type with 'getAsArrayType' so that we don't lose any
2326 // typedefs in the element type of the array. This also handles propagation
2327 // of type qualifiers from the array type into the element type if present
2328 // (C99 6.7.3p8).
2329 const ArrayType *PrettyArrayType = getAsArrayType(Ty);
2330 assert(PrettyArrayType && "Not an array type!");
Chris Lattnere6327742008-04-02 05:18:44 +00002331
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002332 QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
Chris Lattnere6327742008-04-02 05:18:44 +00002333
2334 // int x[restrict 4] -> int *restrict
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002335 return PtrTy.getQualifiedType(PrettyArrayType->getIndexTypeQualifier());
Chris Lattnere6327742008-04-02 05:18:44 +00002336}
2337
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00002338QualType ASTContext::getBaseElementType(QualType QT) {
2339 QualifierSet qualifiers;
2340 while (true) {
2341 const Type *UT = qualifiers.strip(QT);
2342 if (const ArrayType *AT = getAsArrayType(QualType(UT,0))) {
2343 QT = AT->getElementType();
Mike Stump6dcbc292009-07-25 23:24:03 +00002344 } else {
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00002345 return qualifiers.apply(QT, *this);
2346 }
2347 }
2348}
2349
Daniel Dunbard786f6a2009-01-05 22:14:37 +00002350QualType ASTContext::getBaseElementType(const VariableArrayType *VAT) {
Anders Carlsson6183a992008-12-21 03:44:36 +00002351 QualType ElemTy = VAT->getElementType();
2352
2353 if (const VariableArrayType *VAT = getAsVariableArrayType(ElemTy))
2354 return getBaseElementType(VAT);
2355
2356 return ElemTy;
2357}
2358
Reid Spencer5f016e22007-07-11 17:01:13 +00002359/// getFloatingRank - Return a relative rank for floating point types.
2360/// This routine will assert if passed a built-in type that isn't a float.
Chris Lattnera75cea32008-04-06 23:38:49 +00002361static FloatingRank getFloatingRank(QualType T) {
Christopher Lambebb97e92008-02-04 02:31:56 +00002362 if (const ComplexType *CT = T->getAsComplexType())
Reid Spencer5f016e22007-07-11 17:01:13 +00002363 return getFloatingRank(CT->getElementType());
Chris Lattnera75cea32008-04-06 23:38:49 +00002364
Daniel Dunbard786f6a2009-01-05 22:14:37 +00002365 assert(T->getAsBuiltinType() && "getFloatingRank(): not a floating type");
Christopher Lambebb97e92008-02-04 02:31:56 +00002366 switch (T->getAsBuiltinType()->getKind()) {
Chris Lattnera75cea32008-04-06 23:38:49 +00002367 default: assert(0 && "getFloatingRank(): not a floating type");
Reid Spencer5f016e22007-07-11 17:01:13 +00002368 case BuiltinType::Float: return FloatRank;
2369 case BuiltinType::Double: return DoubleRank;
2370 case BuiltinType::LongDouble: return LongDoubleRank;
2371 }
2372}
2373
Steve Naroff716c7302007-08-27 01:41:48 +00002374/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
2375/// point or a complex type (based on typeDomain/typeSize).
2376/// 'typeDomain' is a real floating point or complex type.
2377/// 'typeSize' is a real floating point or complex type.
Chris Lattner1361b112008-04-06 23:58:54 +00002378QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
2379 QualType Domain) const {
2380 FloatingRank EltRank = getFloatingRank(Size);
2381 if (Domain->isComplexType()) {
2382 switch (EltRank) {
Steve Naroff716c7302007-08-27 01:41:48 +00002383 default: assert(0 && "getFloatingRank(): illegal value for rank");
Steve Narofff1448a02007-08-27 01:27:54 +00002384 case FloatRank: return FloatComplexTy;
2385 case DoubleRank: return DoubleComplexTy;
2386 case LongDoubleRank: return LongDoubleComplexTy;
2387 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002388 }
Chris Lattner1361b112008-04-06 23:58:54 +00002389
2390 assert(Domain->isRealFloatingType() && "Unknown domain!");
2391 switch (EltRank) {
2392 default: assert(0 && "getFloatingRank(): illegal value for rank");
2393 case FloatRank: return FloatTy;
2394 case DoubleRank: return DoubleTy;
2395 case LongDoubleRank: return LongDoubleTy;
Steve Narofff1448a02007-08-27 01:27:54 +00002396 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002397}
2398
Chris Lattner7cfeb082008-04-06 23:55:33 +00002399/// getFloatingTypeOrder - Compare the rank of the two specified floating
2400/// point types, ignoring the domain of the type (i.e. 'double' ==
2401/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
2402/// LHS < RHS, return -1.
Chris Lattnera75cea32008-04-06 23:38:49 +00002403int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) {
2404 FloatingRank LHSR = getFloatingRank(LHS);
2405 FloatingRank RHSR = getFloatingRank(RHS);
2406
2407 if (LHSR == RHSR)
Steve Narofffb0d4962007-08-27 15:30:22 +00002408 return 0;
Chris Lattnera75cea32008-04-06 23:38:49 +00002409 if (LHSR > RHSR)
Steve Narofffb0d4962007-08-27 15:30:22 +00002410 return 1;
2411 return -1;
Reid Spencer5f016e22007-07-11 17:01:13 +00002412}
2413
Chris Lattnerf52ab252008-04-06 22:59:24 +00002414/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
2415/// routine will assert if passed a built-in type that isn't an integer or enum,
2416/// or if it is not canonicalized.
Eli Friedmanf98aba32009-02-13 02:31:07 +00002417unsigned ASTContext::getIntegerRank(Type *T) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00002418 assert(T->isCanonical() && "T should be canonicalized");
Eli Friedmanf98aba32009-02-13 02:31:07 +00002419 if (EnumType* ET = dyn_cast<EnumType>(T))
2420 T = ET->getDecl()->getIntegerType().getTypePtr();
2421
Eli Friedmana3426752009-07-05 23:44:27 +00002422 if (T->isSpecificBuiltinType(BuiltinType::WChar))
2423 T = getFromTargetType(Target.getWCharType()).getTypePtr();
2424
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002425 if (T->isSpecificBuiltinType(BuiltinType::Char16))
2426 T = getFromTargetType(Target.getChar16Type()).getTypePtr();
2427
2428 if (T->isSpecificBuiltinType(BuiltinType::Char32))
2429 T = getFromTargetType(Target.getChar32Type()).getTypePtr();
2430
Eli Friedmanf98aba32009-02-13 02:31:07 +00002431 // There are two things which impact the integer rank: the width, and
2432 // the ordering of builtins. The builtin ordering is encoded in the
2433 // bottom three bits; the width is encoded in the bits above that.
Chris Lattner1b63e4f2009-06-14 01:54:56 +00002434 if (FixedWidthIntType* FWIT = dyn_cast<FixedWidthIntType>(T))
Eli Friedmanf98aba32009-02-13 02:31:07 +00002435 return FWIT->getWidth() << 3;
Eli Friedmanf98aba32009-02-13 02:31:07 +00002436
Chris Lattnerf52ab252008-04-06 22:59:24 +00002437 switch (cast<BuiltinType>(T)->getKind()) {
Chris Lattner7cfeb082008-04-06 23:55:33 +00002438 default: assert(0 && "getIntegerRank(): not a built-in integer");
2439 case BuiltinType::Bool:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002440 return 1 + (getIntWidth(BoolTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002441 case BuiltinType::Char_S:
2442 case BuiltinType::Char_U:
2443 case BuiltinType::SChar:
2444 case BuiltinType::UChar:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002445 return 2 + (getIntWidth(CharTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002446 case BuiltinType::Short:
2447 case BuiltinType::UShort:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002448 return 3 + (getIntWidth(ShortTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002449 case BuiltinType::Int:
2450 case BuiltinType::UInt:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002451 return 4 + (getIntWidth(IntTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002452 case BuiltinType::Long:
2453 case BuiltinType::ULong:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002454 return 5 + (getIntWidth(LongTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002455 case BuiltinType::LongLong:
2456 case BuiltinType::ULongLong:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002457 return 6 + (getIntWidth(LongLongTy) << 3);
Chris Lattner2df9ced2009-04-30 02:43:43 +00002458 case BuiltinType::Int128:
2459 case BuiltinType::UInt128:
2460 return 7 + (getIntWidth(Int128Ty) << 3);
Chris Lattnerf52ab252008-04-06 22:59:24 +00002461 }
2462}
2463
Chris Lattner7cfeb082008-04-06 23:55:33 +00002464/// getIntegerTypeOrder - Returns the highest ranked integer type:
2465/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
2466/// LHS < RHS, return -1.
2467int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00002468 Type *LHSC = getCanonicalType(LHS).getTypePtr();
2469 Type *RHSC = getCanonicalType(RHS).getTypePtr();
Chris Lattner7cfeb082008-04-06 23:55:33 +00002470 if (LHSC == RHSC) return 0;
Reid Spencer5f016e22007-07-11 17:01:13 +00002471
Chris Lattnerf52ab252008-04-06 22:59:24 +00002472 bool LHSUnsigned = LHSC->isUnsignedIntegerType();
2473 bool RHSUnsigned = RHSC->isUnsignedIntegerType();
Reid Spencer5f016e22007-07-11 17:01:13 +00002474
Chris Lattner7cfeb082008-04-06 23:55:33 +00002475 unsigned LHSRank = getIntegerRank(LHSC);
2476 unsigned RHSRank = getIntegerRank(RHSC);
Reid Spencer5f016e22007-07-11 17:01:13 +00002477
Chris Lattner7cfeb082008-04-06 23:55:33 +00002478 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
2479 if (LHSRank == RHSRank) return 0;
2480 return LHSRank > RHSRank ? 1 : -1;
2481 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002482
Chris Lattner7cfeb082008-04-06 23:55:33 +00002483 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
2484 if (LHSUnsigned) {
2485 // If the unsigned [LHS] type is larger, return it.
2486 if (LHSRank >= RHSRank)
2487 return 1;
2488
2489 // If the signed type can represent all values of the unsigned type, it
2490 // wins. Because we are dealing with 2's complement and types that are
2491 // powers of two larger than each other, this is always safe.
2492 return -1;
2493 }
Chris Lattnerf52ab252008-04-06 22:59:24 +00002494
Chris Lattner7cfeb082008-04-06 23:55:33 +00002495 // If the unsigned [RHS] type is larger, return it.
2496 if (RHSRank >= LHSRank)
2497 return -1;
2498
2499 // If the signed type can represent all values of the unsigned type, it
2500 // wins. Because we are dealing with 2's complement and types that are
2501 // powers of two larger than each other, this is always safe.
2502 return 1;
Reid Spencer5f016e22007-07-11 17:01:13 +00002503}
Anders Carlsson71993dd2007-08-17 05:31:46 +00002504
2505// getCFConstantStringType - Return the type used for constant CFStrings.
2506QualType ASTContext::getCFConstantStringType() {
2507 if (!CFConstantStringTypeDecl) {
Chris Lattner6c2b6eb2008-03-15 06:12:44 +00002508 CFConstantStringTypeDecl =
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002509 RecordDecl::Create(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00002510 &Idents.get("NSConstantString"));
Anders Carlssonf06273f2007-11-19 00:25:30 +00002511 QualType FieldTypes[4];
Anders Carlsson71993dd2007-08-17 05:31:46 +00002512
2513 // const int *isa;
2514 FieldTypes[0] = getPointerType(IntTy.getQualifiedType(QualType::Const));
Anders Carlssonf06273f2007-11-19 00:25:30 +00002515 // int flags;
2516 FieldTypes[1] = IntTy;
Anders Carlsson71993dd2007-08-17 05:31:46 +00002517 // const char *str;
Anders Carlssonf06273f2007-11-19 00:25:30 +00002518 FieldTypes[2] = getPointerType(CharTy.getQualifiedType(QualType::Const));
Anders Carlsson71993dd2007-08-17 05:31:46 +00002519 // long length;
Anders Carlssonf06273f2007-11-19 00:25:30 +00002520 FieldTypes[3] = LongTy;
Douglas Gregor44b43212008-12-11 16:49:14 +00002521
Anders Carlsson71993dd2007-08-17 05:31:46 +00002522 // Create fields
Douglas Gregor44b43212008-12-11 16:49:14 +00002523 for (unsigned i = 0; i < 4; ++i) {
2524 FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl,
2525 SourceLocation(), 0,
2526 FieldTypes[i], /*BitWidth=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002527 /*Mutable=*/false);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002528 CFConstantStringTypeDecl->addDecl(Field);
Douglas Gregor44b43212008-12-11 16:49:14 +00002529 }
2530
2531 CFConstantStringTypeDecl->completeDefinition(*this);
Anders Carlsson71993dd2007-08-17 05:31:46 +00002532 }
2533
2534 return getTagDeclType(CFConstantStringTypeDecl);
Gabor Greif84675832007-09-11 15:32:40 +00002535}
Anders Carlssonb2cf3572007-10-11 01:00:40 +00002536
Douglas Gregor319ac892009-04-23 22:29:11 +00002537void ASTContext::setCFConstantStringType(QualType T) {
Ted Kremenek6217b802009-07-29 21:53:49 +00002538 const RecordType *Rec = T->getAs<RecordType>();
Douglas Gregor319ac892009-04-23 22:29:11 +00002539 assert(Rec && "Invalid CFConstantStringType");
2540 CFConstantStringTypeDecl = Rec->getDecl();
2541}
2542
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002543QualType ASTContext::getObjCFastEnumerationStateType()
2544{
2545 if (!ObjCFastEnumerationStateTypeDecl) {
Douglas Gregor44b43212008-12-11 16:49:14 +00002546 ObjCFastEnumerationStateTypeDecl =
2547 RecordDecl::Create(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
2548 &Idents.get("__objcFastEnumerationState"));
2549
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002550 QualType FieldTypes[] = {
2551 UnsignedLongTy,
Steve Naroffde2e22d2009-07-15 18:40:39 +00002552 getPointerType(ObjCIdTypedefType),
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002553 getPointerType(UnsignedLongTy),
2554 getConstantArrayType(UnsignedLongTy,
2555 llvm::APInt(32, 5), ArrayType::Normal, 0)
2556 };
2557
Douglas Gregor44b43212008-12-11 16:49:14 +00002558 for (size_t i = 0; i < 4; ++i) {
2559 FieldDecl *Field = FieldDecl::Create(*this,
2560 ObjCFastEnumerationStateTypeDecl,
2561 SourceLocation(), 0,
2562 FieldTypes[i], /*BitWidth=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002563 /*Mutable=*/false);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002564 ObjCFastEnumerationStateTypeDecl->addDecl(Field);
Douglas Gregor44b43212008-12-11 16:49:14 +00002565 }
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002566
Douglas Gregor44b43212008-12-11 16:49:14 +00002567 ObjCFastEnumerationStateTypeDecl->completeDefinition(*this);
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002568 }
2569
2570 return getTagDeclType(ObjCFastEnumerationStateTypeDecl);
2571}
2572
Douglas Gregor319ac892009-04-23 22:29:11 +00002573void ASTContext::setObjCFastEnumerationStateType(QualType T) {
Ted Kremenek6217b802009-07-29 21:53:49 +00002574 const RecordType *Rec = T->getAs<RecordType>();
Douglas Gregor319ac892009-04-23 22:29:11 +00002575 assert(Rec && "Invalid ObjCFAstEnumerationStateType");
2576 ObjCFastEnumerationStateTypeDecl = Rec->getDecl();
2577}
2578
Anders Carlssone8c49532007-10-29 06:33:42 +00002579// This returns true if a type has been typedefed to BOOL:
2580// typedef <type> BOOL;
Chris Lattner2d998332007-10-30 20:27:44 +00002581static bool isTypeTypedefedAsBOOL(QualType T) {
Anders Carlssone8c49532007-10-29 06:33:42 +00002582 if (const TypedefType *TT = dyn_cast<TypedefType>(T))
Chris Lattnerbb49c3e2008-11-24 03:52:59 +00002583 if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
2584 return II->isStr("BOOL");
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002585
2586 return false;
2587}
2588
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002589/// getObjCEncodingTypeSize returns size of type for objective-c encoding
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002590/// purpose.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002591int ASTContext::getObjCEncodingTypeSize(QualType type) {
Chris Lattner98be4942008-03-05 18:54:05 +00002592 uint64_t sz = getTypeSize(type);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002593
2594 // Make all integer and enum types at least as large as an int
2595 if (sz > 0 && type->isIntegralType())
Chris Lattner98be4942008-03-05 18:54:05 +00002596 sz = std::max(sz, getTypeSize(IntTy));
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002597 // Treat arrays as pointers, since that's how they're passed in.
2598 else if (type->isArrayType())
Chris Lattner98be4942008-03-05 18:54:05 +00002599 sz = getTypeSize(VoidPtrTy);
2600 return sz / getTypeSize(CharTy);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002601}
2602
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002603/// getObjCEncodingForMethodDecl - Return the encoded type for this method
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002604/// declaration.
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002605void ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
Chris Lattnere6db3b02008-11-19 07:24:05 +00002606 std::string& S) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002607 // FIXME: This is not very efficient.
Fariborz Jahanianecb01e62007-11-01 17:18:37 +00002608 // Encode type qualifer, 'in', 'inout', etc. for the return type.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002609 getObjCEncodingForTypeQualifier(Decl->getObjCDeclQualifier(), S);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002610 // Encode result type.
Daniel Dunbar0d504c12008-10-17 20:21:44 +00002611 getObjCEncodingForType(Decl->getResultType(), S);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002612 // Compute size of all parameters.
2613 // Start with computing size of a pointer in number of bytes.
2614 // FIXME: There might(should) be a better way of doing this computation!
2615 SourceLocation Loc;
Chris Lattner98be4942008-03-05 18:54:05 +00002616 int PtrSize = getTypeSize(VoidPtrTy) / getTypeSize(CharTy);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002617 // The first two arguments (self and _cmd) are pointers; account for
2618 // their size.
2619 int ParmOffset = 2 * PtrSize;
Chris Lattner89951a82009-02-20 18:43:26 +00002620 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(),
2621 E = Decl->param_end(); PI != E; ++PI) {
2622 QualType PType = (*PI)->getType();
2623 int sz = getObjCEncodingTypeSize(PType);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002624 assert (sz > 0 && "getObjCEncodingForMethodDecl - Incomplete param type");
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002625 ParmOffset += sz;
2626 }
2627 S += llvm::utostr(ParmOffset);
2628 S += "@0:";
2629 S += llvm::utostr(PtrSize);
2630
2631 // Argument types.
2632 ParmOffset = 2 * PtrSize;
Chris Lattner89951a82009-02-20 18:43:26 +00002633 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(),
2634 E = Decl->param_end(); PI != E; ++PI) {
2635 ParmVarDecl *PVDecl = *PI;
Fariborz Jahanian4306d3c2008-12-20 23:29:59 +00002636 QualType PType = PVDecl->getOriginalType();
2637 if (const ArrayType *AT =
Steve Naroffab76d452009-04-14 00:03:58 +00002638 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
2639 // Use array's original type only if it has known number of
2640 // elements.
Steve Naroffbb3fde32009-04-14 00:40:09 +00002641 if (!isa<ConstantArrayType>(AT))
Steve Naroffab76d452009-04-14 00:03:58 +00002642 PType = PVDecl->getType();
2643 } else if (PType->isFunctionType())
2644 PType = PVDecl->getType();
Fariborz Jahanianecb01e62007-11-01 17:18:37 +00002645 // Process argument qualifiers for user supplied arguments; such as,
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002646 // 'in', 'inout', etc.
Fariborz Jahanian4306d3c2008-12-20 23:29:59 +00002647 getObjCEncodingForTypeQualifier(PVDecl->getObjCDeclQualifier(), S);
Daniel Dunbar0d504c12008-10-17 20:21:44 +00002648 getObjCEncodingForType(PType, S);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002649 S += llvm::utostr(ParmOffset);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002650 ParmOffset += getObjCEncodingTypeSize(PType);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002651 }
2652}
2653
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002654/// getObjCEncodingForPropertyDecl - Return the encoded type for this
Fariborz Jahanian83bccb82009-01-20 20:04:12 +00002655/// property declaration. If non-NULL, Container must be either an
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002656/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be
2657/// NULL when getting encodings for protocol properties.
Fariborz Jahanian83bccb82009-01-20 20:04:12 +00002658/// Property attributes are stored as a comma-delimited C string. The simple
2659/// attributes readonly and bycopy are encoded as single characters. The
2660/// parametrized attributes, getter=name, setter=name, and ivar=name, are
2661/// encoded as single characters, followed by an identifier. Property types
2662/// are also encoded as a parametrized attribute. The characters used to encode
2663/// these attributes are defined by the following enumeration:
2664/// @code
2665/// enum PropertyAttributes {
2666/// kPropertyReadOnly = 'R', // property is read-only.
2667/// kPropertyBycopy = 'C', // property is a copy of the value last assigned
2668/// kPropertyByref = '&', // property is a reference to the value last assigned
2669/// kPropertyDynamic = 'D', // property is dynamic
2670/// kPropertyGetter = 'G', // followed by getter selector name
2671/// kPropertySetter = 'S', // followed by setter selector name
2672/// kPropertyInstanceVariable = 'V' // followed by instance variable name
2673/// kPropertyType = 't' // followed by old-style type encoding.
2674/// kPropertyWeak = 'W' // 'weak' property
2675/// kPropertyStrong = 'P' // property GC'able
2676/// kPropertyNonAtomic = 'N' // property non-atomic
2677/// };
2678/// @endcode
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002679void ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
2680 const Decl *Container,
Chris Lattnere6db3b02008-11-19 07:24:05 +00002681 std::string& S) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002682 // Collect information from the property implementation decl(s).
2683 bool Dynamic = false;
2684 ObjCPropertyImplDecl *SynthesizePID = 0;
2685
2686 // FIXME: Duplicated code due to poor abstraction.
2687 if (Container) {
2688 if (const ObjCCategoryImplDecl *CID =
2689 dyn_cast<ObjCCategoryImplDecl>(Container)) {
2690 for (ObjCCategoryImplDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002691 i = CID->propimpl_begin(), e = CID->propimpl_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00002692 i != e; ++i) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002693 ObjCPropertyImplDecl *PID = *i;
2694 if (PID->getPropertyDecl() == PD) {
2695 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
2696 Dynamic = true;
2697 } else {
2698 SynthesizePID = PID;
2699 }
2700 }
2701 }
2702 } else {
Chris Lattner61710852008-10-05 17:34:18 +00002703 const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container);
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002704 for (ObjCCategoryImplDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002705 i = OID->propimpl_begin(), e = OID->propimpl_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00002706 i != e; ++i) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002707 ObjCPropertyImplDecl *PID = *i;
2708 if (PID->getPropertyDecl() == PD) {
2709 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
2710 Dynamic = true;
2711 } else {
2712 SynthesizePID = PID;
2713 }
2714 }
2715 }
2716 }
2717 }
2718
2719 // FIXME: This is not very efficient.
2720 S = "T";
2721
2722 // Encode result type.
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00002723 // GCC has some special rules regarding encoding of properties which
2724 // closely resembles encoding of ivars.
Daniel Dunbar153bfe52009-04-20 06:37:24 +00002725 getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0,
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00002726 true /* outermost type */,
2727 true /* encoding for property */);
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002728
2729 if (PD->isReadOnly()) {
2730 S += ",R";
2731 } else {
2732 switch (PD->getSetterKind()) {
2733 case ObjCPropertyDecl::Assign: break;
2734 case ObjCPropertyDecl::Copy: S += ",C"; break;
2735 case ObjCPropertyDecl::Retain: S += ",&"; break;
2736 }
2737 }
2738
2739 // It really isn't clear at all what this means, since properties
2740 // are "dynamic by default".
2741 if (Dynamic)
2742 S += ",D";
2743
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00002744 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
2745 S += ",N";
2746
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002747 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
2748 S += ",G";
Chris Lattner077bf5e2008-11-24 03:33:13 +00002749 S += PD->getGetterName().getAsString();
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002750 }
2751
2752 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
2753 S += ",S";
Chris Lattner077bf5e2008-11-24 03:33:13 +00002754 S += PD->getSetterName().getAsString();
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002755 }
2756
2757 if (SynthesizePID) {
2758 const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
2759 S += ",V";
Chris Lattner39f34e92008-11-24 04:00:27 +00002760 S += OID->getNameAsString();
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002761 }
2762
2763 // FIXME: OBJCGC: weak & strong
2764}
2765
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002766/// getLegacyIntegralTypeEncoding -
2767/// Another legacy compatibility encoding: 32-bit longs are encoded as
Fariborz Jahanianc657eba2009-02-11 23:59:18 +00002768/// 'l' or 'L' , but not always. For typedefs, we need to use
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002769/// 'i' or 'I' instead if encoding a struct field, or a pointer!
2770///
2771void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const {
Mike Stump8e1fab22009-07-22 18:58:19 +00002772 if (isa<TypedefType>(PointeeTy.getTypePtr())) {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002773 if (const BuiltinType *BT = PointeeTy->getAsBuiltinType()) {
Fariborz Jahanianc657eba2009-02-11 23:59:18 +00002774 if (BT->getKind() == BuiltinType::ULong &&
2775 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32))
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002776 PointeeTy = UnsignedIntTy;
Fariborz Jahanianc657eba2009-02-11 23:59:18 +00002777 else
2778 if (BT->getKind() == BuiltinType::Long &&
2779 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32))
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002780 PointeeTy = IntTy;
2781 }
2782 }
2783}
2784
Fariborz Jahanian7d6b46d2008-01-22 22:44:46 +00002785void ASTContext::getObjCEncodingForType(QualType T, std::string& S,
Daniel Dunbar153bfe52009-04-20 06:37:24 +00002786 const FieldDecl *Field) {
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00002787 // We follow the behavior of gcc, expanding structures which are
2788 // directly pointed to, and expanding embedded structures. Note that
2789 // these rules are sufficient to prevent recursive encoding of the
2790 // same type.
Fariborz Jahanian5b8c7d92008-12-22 23:22:27 +00002791 getObjCEncodingForTypeImpl(T, S, true, true, Field,
2792 true /* outermost type */);
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00002793}
2794
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00002795static void EncodeBitField(const ASTContext *Context, std::string& S,
Daniel Dunbar153bfe52009-04-20 06:37:24 +00002796 const FieldDecl *FD) {
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00002797 const Expr *E = FD->getBitWidth();
2798 assert(E && "bitfield width not there - getObjCEncodingForTypeImpl");
2799 ASTContext *Ctx = const_cast<ASTContext*>(Context);
Eli Friedman9a901bb2009-04-26 19:19:15 +00002800 unsigned N = E->EvaluateAsInt(*Ctx).getZExtValue();
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00002801 S += 'b';
2802 S += llvm::utostr(N);
2803}
2804
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00002805void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S,
2806 bool ExpandPointedToStructures,
2807 bool ExpandStructures,
Daniel Dunbar153bfe52009-04-20 06:37:24 +00002808 const FieldDecl *FD,
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00002809 bool OutermostType,
Douglas Gregor6ab35242009-04-09 21:40:53 +00002810 bool EncodingProperty) {
Anders Carlssone8c49532007-10-29 06:33:42 +00002811 if (const BuiltinType *BT = T->getAsBuiltinType()) {
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002812 if (FD && FD->isBitField())
2813 return EncodeBitField(this, S, FD);
2814 char encoding;
2815 switch (BT->getKind()) {
2816 default: assert(0 && "Unhandled builtin type kind");
2817 case BuiltinType::Void: encoding = 'v'; break;
2818 case BuiltinType::Bool: encoding = 'B'; break;
2819 case BuiltinType::Char_U:
2820 case BuiltinType::UChar: encoding = 'C'; break;
2821 case BuiltinType::UShort: encoding = 'S'; break;
2822 case BuiltinType::UInt: encoding = 'I'; break;
2823 case BuiltinType::ULong:
Fariborz Jahanian72696e12009-02-11 22:31:45 +00002824 encoding =
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002825 (const_cast<ASTContext *>(this))->getIntWidth(T) == 32 ? 'L' : 'Q';
Fariborz Jahanian72696e12009-02-11 22:31:45 +00002826 break;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002827 case BuiltinType::UInt128: encoding = 'T'; break;
2828 case BuiltinType::ULongLong: encoding = 'Q'; break;
2829 case BuiltinType::Char_S:
2830 case BuiltinType::SChar: encoding = 'c'; break;
2831 case BuiltinType::Short: encoding = 's'; break;
2832 case BuiltinType::Int: encoding = 'i'; break;
2833 case BuiltinType::Long:
2834 encoding =
2835 (const_cast<ASTContext *>(this))->getIntWidth(T) == 32 ? 'l' : 'q';
2836 break;
2837 case BuiltinType::LongLong: encoding = 'q'; break;
2838 case BuiltinType::Int128: encoding = 't'; break;
2839 case BuiltinType::Float: encoding = 'f'; break;
2840 case BuiltinType::Double: encoding = 'd'; break;
2841 case BuiltinType::LongDouble: encoding = 'd'; break;
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002842 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002843
2844 S += encoding;
2845 return;
2846 }
2847
2848 if (const ComplexType *CT = T->getAsComplexType()) {
Anders Carlssonc612f7b2009-04-09 21:55:45 +00002849 S += 'j';
2850 getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false,
2851 false);
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002852 return;
2853 }
2854
Ted Kremenek6217b802009-07-29 21:53:49 +00002855 if (const PointerType *PT = T->getAs<PointerType>()) {
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002856 QualType PointeeTy = PT->getPointeeType();
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002857 bool isReadOnly = false;
2858 // For historical/compatibility reasons, the read-only qualifier of the
2859 // pointee gets emitted _before_ the '^'. The read-only qualifier of
2860 // the pointer itself gets ignored, _unless_ we are looking at a typedef!
2861 // Also, do not emit the 'r' for anything but the outermost type!
Mike Stump8e1fab22009-07-22 18:58:19 +00002862 if (isa<TypedefType>(T.getTypePtr())) {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002863 if (OutermostType && T.isConstQualified()) {
2864 isReadOnly = true;
2865 S += 'r';
2866 }
Mike Stump9fdbab32009-07-31 02:02:20 +00002867 } else if (OutermostType) {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002868 QualType P = PointeeTy;
Ted Kremenek6217b802009-07-29 21:53:49 +00002869 while (P->getAs<PointerType>())
2870 P = P->getAs<PointerType>()->getPointeeType();
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002871 if (P.isConstQualified()) {
2872 isReadOnly = true;
2873 S += 'r';
2874 }
2875 }
2876 if (isReadOnly) {
2877 // Another legacy compatibility encoding. Some ObjC qualifier and type
2878 // combinations need to be rearranged.
2879 // Rewrite "in const" from "nr" to "rn"
2880 const char * s = S.c_str();
2881 int len = S.length();
2882 if (len >= 2 && s[len-2] == 'n' && s[len-1] == 'r') {
2883 std::string replace = "rn";
2884 S.replace(S.end()-2, S.end(), replace);
2885 }
2886 }
Steve Naroff14108da2009-07-10 23:34:53 +00002887 if (isObjCSelType(PointeeTy)) {
Anders Carlsson8baaca52007-10-31 02:53:19 +00002888 S += ':';
2889 return;
Fariborz Jahanianc2939bc2007-10-30 17:06:23 +00002890 }
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002891
2892 if (PointeeTy->isCharType()) {
2893 // char pointer types should be encoded as '*' unless it is a
2894 // type that has been typedef'd to 'BOOL'.
Anders Carlssone8c49532007-10-29 06:33:42 +00002895 if (!isTypeTypedefedAsBOOL(PointeeTy)) {
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002896 S += '*';
2897 return;
2898 }
Ted Kremenek6217b802009-07-29 21:53:49 +00002899 } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) {
Steve Naroff9533a7f2009-07-22 17:14:51 +00002900 // GCC binary compat: Need to convert "struct objc_class *" to "#".
2901 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
2902 S += '#';
2903 return;
2904 }
2905 // GCC binary compat: Need to convert "struct objc_object *" to "@".
2906 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
2907 S += '@';
2908 return;
2909 }
2910 // fall through...
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002911 }
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002912 S += '^';
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002913 getLegacyIntegralTypeEncoding(PointeeTy);
2914
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002915 getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures,
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002916 NULL);
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002917 return;
2918 }
2919
2920 if (const ArrayType *AT =
2921 // Ignore type qualifiers etc.
2922 dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) {
Anders Carlsson559a8332009-02-22 01:38:57 +00002923 if (isa<IncompleteArrayType>(AT)) {
2924 // Incomplete arrays are encoded as a pointer to the array element.
2925 S += '^';
2926
2927 getObjCEncodingForTypeImpl(AT->getElementType(), S,
2928 false, ExpandStructures, FD);
2929 } else {
2930 S += '[';
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002931
Anders Carlsson559a8332009-02-22 01:38:57 +00002932 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
2933 S += llvm::utostr(CAT->getSize().getZExtValue());
2934 else {
2935 //Variable length arrays are encoded as a regular array with 0 elements.
2936 assert(isa<VariableArrayType>(AT) && "Unknown array type!");
2937 S += '0';
2938 }
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002939
Anders Carlsson559a8332009-02-22 01:38:57 +00002940 getObjCEncodingForTypeImpl(AT->getElementType(), S,
2941 false, ExpandStructures, FD);
2942 S += ']';
2943 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002944 return;
2945 }
2946
2947 if (T->getAsFunctionType()) {
Anders Carlssonc0a87b72007-10-30 00:06:20 +00002948 S += '?';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002949 return;
2950 }
2951
Ted Kremenek6217b802009-07-29 21:53:49 +00002952 if (const RecordType *RTy = T->getAs<RecordType>()) {
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00002953 RecordDecl *RDecl = RTy->getDecl();
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002954 S += RDecl->isUnion() ? '(' : '{';
Daniel Dunbar502a4a12008-10-17 06:22:57 +00002955 // Anonymous structures print as '?'
2956 if (const IdentifierInfo *II = RDecl->getIdentifier()) {
2957 S += II->getName();
2958 } else {
2959 S += '?';
2960 }
Daniel Dunbar0d504c12008-10-17 20:21:44 +00002961 if (ExpandStructures) {
Fariborz Jahanian7d6b46d2008-01-22 22:44:46 +00002962 S += '=';
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002963 for (RecordDecl::field_iterator Field = RDecl->field_begin(),
2964 FieldEnd = RDecl->field_end();
Douglas Gregor44b43212008-12-11 16:49:14 +00002965 Field != FieldEnd; ++Field) {
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002966 if (FD) {
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002967 S += '"';
Douglas Gregor44b43212008-12-11 16:49:14 +00002968 S += Field->getNameAsString();
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002969 S += '"';
2970 }
2971
2972 // Special case bit-fields.
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002973 if (Field->isBitField()) {
2974 getObjCEncodingForTypeImpl(Field->getType(), S, false, true,
2975 (*Field));
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002976 } else {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002977 QualType qt = Field->getType();
2978 getLegacyIntegralTypeEncoding(qt);
2979 getObjCEncodingForTypeImpl(qt, S, false, true,
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002980 FD);
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002981 }
Fariborz Jahanian7d6b46d2008-01-22 22:44:46 +00002982 }
Fariborz Jahanian6de88a82007-11-13 23:21:38 +00002983 }
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002984 S += RDecl->isUnion() ? ')' : '}';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002985 return;
2986 }
2987
2988 if (T->isEnumeralType()) {
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00002989 if (FD && FD->isBitField())
2990 EncodeBitField(this, S, FD);
2991 else
2992 S += 'i';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002993 return;
2994 }
2995
2996 if (T->isBlockPointerType()) {
Steve Naroff21a98b12009-02-02 18:24:29 +00002997 S += "@?"; // Unlike a pointer-to-function, which is "^?".
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002998 return;
2999 }
3000
3001 if (T->isObjCInterfaceType()) {
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003002 // @encode(class_name)
3003 ObjCInterfaceDecl *OI = T->getAsObjCInterfaceType()->getDecl();
3004 S += '{';
3005 const IdentifierInfo *II = OI->getIdentifier();
3006 S += II->getName();
3007 S += '=';
Chris Lattnerf1690852009-03-31 08:48:01 +00003008 llvm::SmallVector<FieldDecl*, 32> RecFields;
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003009 CollectObjCIvars(OI, RecFields);
Chris Lattnerf1690852009-03-31 08:48:01 +00003010 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003011 if (RecFields[i]->isBitField())
3012 getObjCEncodingForTypeImpl(RecFields[i]->getType(), S, false, true,
3013 RecFields[i]);
3014 else
3015 getObjCEncodingForTypeImpl(RecFields[i]->getType(), S, false, true,
3016 FD);
3017 }
3018 S += '}';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003019 return;
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003020 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003021
3022 if (const ObjCObjectPointerType *OPT = T->getAsObjCObjectPointerType()) {
Steve Naroff14108da2009-07-10 23:34:53 +00003023 if (OPT->isObjCIdType()) {
3024 S += '@';
3025 return;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003026 }
3027
3028 if (OPT->isObjCClassType()) {
Steve Naroff14108da2009-07-10 23:34:53 +00003029 S += '#';
3030 return;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003031 }
3032
3033 if (OPT->isObjCQualifiedIdType()) {
Steve Naroff14108da2009-07-10 23:34:53 +00003034 getObjCEncodingForTypeImpl(getObjCIdType(), S,
3035 ExpandPointedToStructures,
3036 ExpandStructures, FD);
3037 if (FD || EncodingProperty) {
3038 // Note that we do extended encoding of protocol qualifer list
3039 // Only when doing ivar or property encoding.
Steve Naroff14108da2009-07-10 23:34:53 +00003040 S += '"';
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003041 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
3042 E = OPT->qual_end(); I != E; ++I) {
Steve Naroff14108da2009-07-10 23:34:53 +00003043 S += '<';
3044 S += (*I)->getNameAsString();
3045 S += '>';
3046 }
3047 S += '"';
3048 }
3049 return;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003050 }
3051
3052 QualType PointeeTy = OPT->getPointeeType();
3053 if (!EncodingProperty &&
3054 isa<TypedefType>(PointeeTy.getTypePtr())) {
3055 // Another historical/compatibility reason.
3056 // We encode the underlying type which comes out as
3057 // {...};
3058 S += '^';
3059 getObjCEncodingForTypeImpl(PointeeTy, S,
3060 false, ExpandPointedToStructures,
3061 NULL);
Steve Naroff14108da2009-07-10 23:34:53 +00003062 return;
3063 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003064
3065 S += '@';
3066 if (FD || EncodingProperty) {
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003067 S += '"';
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003068 S += OPT->getInterfaceDecl()->getNameAsCString();
3069 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
3070 E = OPT->qual_end(); I != E; ++I) {
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003071 S += '<';
3072 S += (*I)->getNameAsString();
3073 S += '>';
3074 }
3075 S += '"';
3076 }
3077 return;
3078 }
3079
3080 assert(0 && "@encode for type not implemented!");
Anders Carlsson85f9bce2007-10-29 05:01:08 +00003081}
3082
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003083void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
Fariborz Jahanianecb01e62007-11-01 17:18:37 +00003084 std::string& S) const {
3085 if (QT & Decl::OBJC_TQ_In)
3086 S += 'n';
3087 if (QT & Decl::OBJC_TQ_Inout)
3088 S += 'N';
3089 if (QT & Decl::OBJC_TQ_Out)
3090 S += 'o';
3091 if (QT & Decl::OBJC_TQ_Bycopy)
3092 S += 'O';
3093 if (QT & Decl::OBJC_TQ_Byref)
3094 S += 'R';
3095 if (QT & Decl::OBJC_TQ_Oneway)
3096 S += 'V';
3097}
3098
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003099void ASTContext::setBuiltinVaListType(QualType T) {
Anders Carlssonb2cf3572007-10-11 01:00:40 +00003100 assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!");
3101
3102 BuiltinVaListType = T;
3103}
3104
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003105void ASTContext::setObjCIdType(QualType T) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00003106 ObjCIdTypedefType = T;
Steve Naroff7e219e42007-10-15 14:41:52 +00003107}
3108
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003109void ASTContext::setObjCSelType(QualType T) {
Douglas Gregor319ac892009-04-23 22:29:11 +00003110 ObjCSelType = T;
3111
3112 const TypedefType *TT = T->getAsTypedefType();
3113 if (!TT)
3114 return;
3115 TypedefDecl *TD = TT->getDecl();
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00003116
3117 // typedef struct objc_selector *SEL;
Ted Kremenek6217b802009-07-29 21:53:49 +00003118 const PointerType *ptr = TD->getUnderlyingType()->getAs<PointerType>();
Fariborz Jahanianc55a2402009-01-16 19:58:32 +00003119 if (!ptr)
3120 return;
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00003121 const RecordType *rec = ptr->getPointeeType()->getAsStructureType();
Fariborz Jahanianc55a2402009-01-16 19:58:32 +00003122 if (!rec)
3123 return;
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00003124 SelStructType = rec;
3125}
3126
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003127void ASTContext::setObjCProtoType(QualType QT) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003128 ObjCProtoType = QT;
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00003129}
3130
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003131void ASTContext::setObjCClassType(QualType T) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00003132 ObjCClassTypedefType = T;
Anders Carlsson8baaca52007-10-31 02:53:19 +00003133}
3134
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003135void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) {
3136 assert(ObjCConstantStringType.isNull() &&
Steve Naroff21988912007-10-15 23:35:17 +00003137 "'NSConstantString' type already set!");
3138
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003139 ObjCConstantStringType = getObjCInterfaceType(Decl);
Steve Naroff21988912007-10-15 23:35:17 +00003140}
3141
Douglas Gregor7532dc62009-03-30 22:58:21 +00003142/// \brief Retrieve the template name that represents a qualified
3143/// template name such as \c std::vector.
3144TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
3145 bool TemplateKeyword,
3146 TemplateDecl *Template) {
3147 llvm::FoldingSetNodeID ID;
3148 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
3149
3150 void *InsertPos = 0;
3151 QualifiedTemplateName *QTN =
3152 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
3153 if (!QTN) {
3154 QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template);
3155 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
3156 }
3157
3158 return TemplateName(QTN);
3159}
3160
Douglas Gregord99cbe62009-07-29 18:26:50 +00003161/// \brief Retrieve the template name that represents a qualified
3162/// template name such as \c std::vector.
3163TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
3164 bool TemplateKeyword,
3165 OverloadedFunctionDecl *Template) {
3166 llvm::FoldingSetNodeID ID;
3167 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
3168
3169 void *InsertPos = 0;
3170 QualifiedTemplateName *QTN =
3171 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
3172 if (!QTN) {
3173 QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template);
3174 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
3175 }
3176
3177 return TemplateName(QTN);
3178}
3179
Douglas Gregor7532dc62009-03-30 22:58:21 +00003180/// \brief Retrieve the template name that represents a dependent
3181/// template name such as \c MetaFun::template apply.
3182TemplateName ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
3183 const IdentifierInfo *Name) {
3184 assert(NNS->isDependent() && "Nested name specifier must be dependent");
3185
3186 llvm::FoldingSetNodeID ID;
3187 DependentTemplateName::Profile(ID, NNS, Name);
3188
3189 void *InsertPos = 0;
3190 DependentTemplateName *QTN =
3191 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
3192
3193 if (QTN)
3194 return TemplateName(QTN);
3195
3196 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
3197 if (CanonNNS == NNS) {
3198 QTN = new (*this,4) DependentTemplateName(NNS, Name);
3199 } else {
3200 TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
3201 QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon);
3202 }
3203
3204 DependentTemplateNames.InsertNode(QTN, InsertPos);
3205 return TemplateName(QTN);
3206}
3207
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003208/// getFromTargetType - Given one of the integer types provided by
Douglas Gregord9341122008-11-03 15:57:00 +00003209/// TargetInfo, produce the corresponding type. The unsigned @p Type
3210/// is actually a value of type @c TargetInfo::IntType.
3211QualType ASTContext::getFromTargetType(unsigned Type) const {
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003212 switch (Type) {
3213 case TargetInfo::NoInt: return QualType();
3214 case TargetInfo::SignedShort: return ShortTy;
3215 case TargetInfo::UnsignedShort: return UnsignedShortTy;
3216 case TargetInfo::SignedInt: return IntTy;
3217 case TargetInfo::UnsignedInt: return UnsignedIntTy;
3218 case TargetInfo::SignedLong: return LongTy;
3219 case TargetInfo::UnsignedLong: return UnsignedLongTy;
3220 case TargetInfo::SignedLongLong: return LongLongTy;
3221 case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy;
3222 }
3223
3224 assert(false && "Unhandled TargetInfo::IntType value");
Daniel Dunbarb3ac5432008-11-11 01:16:00 +00003225 return QualType();
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003226}
Ted Kremenekb6ccaac2008-07-24 23:58:27 +00003227
3228//===----------------------------------------------------------------------===//
3229// Type Predicates.
3230//===----------------------------------------------------------------------===//
3231
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003232/// isObjCNSObjectType - Return true if this is an NSObject object using
3233/// NSObject attribute on a c-style pointer type.
3234/// FIXME - Make it work directly on types.
Steve Narofff4954562009-07-16 15:41:00 +00003235/// FIXME: Move to Type.
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003236///
3237bool ASTContext::isObjCNSObjectType(QualType Ty) const {
3238 if (TypedefType *TDT = dyn_cast<TypedefType>(Ty)) {
3239 if (TypedefDecl *TD = TDT->getDecl())
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00003240 if (TD->getAttr<ObjCNSObjectAttr>())
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003241 return true;
3242 }
3243 return false;
3244}
3245
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003246/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
3247/// garbage collection attribute.
3248///
3249QualType::GCAttrTypes ASTContext::getObjCGCAttrKind(const QualType &Ty) const {
Chris Lattnerb7d25532009-02-18 22:53:11 +00003250 QualType::GCAttrTypes GCAttrs = QualType::GCNone;
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003251 if (getLangOptions().ObjC1 &&
3252 getLangOptions().getGCMode() != LangOptions::NonGC) {
Chris Lattnerb7d25532009-02-18 22:53:11 +00003253 GCAttrs = Ty.getObjCGCAttr();
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003254 // Default behavious under objective-c's gc is for objective-c pointers
Fariborz Jahaniana223cca2009-02-19 23:36:06 +00003255 // (or pointers to them) be treated as though they were declared
3256 // as __strong.
3257 if (GCAttrs == QualType::GCNone) {
Steve Narofff4954562009-07-16 15:41:00 +00003258 if (Ty->isObjCObjectPointerType())
Fariborz Jahaniana223cca2009-02-19 23:36:06 +00003259 GCAttrs = QualType::Strong;
3260 else if (Ty->isPointerType())
Ted Kremenek6217b802009-07-29 21:53:49 +00003261 return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType());
Fariborz Jahaniana223cca2009-02-19 23:36:06 +00003262 }
Fariborz Jahanianc2112182009-04-11 00:00:54 +00003263 // Non-pointers have none gc'able attribute regardless of the attribute
3264 // set on them.
Steve Narofff4954562009-07-16 15:41:00 +00003265 else if (!Ty->isAnyPointerType() && !Ty->isBlockPointerType())
Fariborz Jahanianc2112182009-04-11 00:00:54 +00003266 return QualType::GCNone;
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003267 }
Chris Lattnerb7d25532009-02-18 22:53:11 +00003268 return GCAttrs;
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003269}
3270
Chris Lattner6ac46a42008-04-07 06:51:04 +00003271//===----------------------------------------------------------------------===//
3272// Type Compatibility Testing
3273//===----------------------------------------------------------------------===//
Chris Lattner770951b2007-11-01 05:03:41 +00003274
Chris Lattner6ac46a42008-04-07 06:51:04 +00003275/// areCompatVectorTypes - Return true if the two specified vector types are
3276/// compatible.
3277static bool areCompatVectorTypes(const VectorType *LHS,
3278 const VectorType *RHS) {
3279 assert(LHS->isCanonical() && RHS->isCanonical());
3280 return LHS->getElementType() == RHS->getElementType() &&
Chris Lattner61710852008-10-05 17:34:18 +00003281 LHS->getNumElements() == RHS->getNumElements();
Chris Lattner6ac46a42008-04-07 06:51:04 +00003282}
3283
Steve Naroff4084c302009-07-23 01:01:38 +00003284//===----------------------------------------------------------------------===//
3285// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
3286//===----------------------------------------------------------------------===//
3287
3288/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
3289/// inheritance hierarchy of 'rProto'.
3290static bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
3291 ObjCProtocolDecl *rProto) {
3292 if (lProto == rProto)
3293 return true;
3294 for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(),
3295 E = rProto->protocol_end(); PI != E; ++PI)
3296 if (ProtocolCompatibleWithProtocol(lProto, *PI))
3297 return true;
3298 return false;
3299}
3300
3301/// ClassImplementsProtocol - Checks that 'lProto' protocol
3302/// has been implemented in IDecl class, its super class or categories (if
3303/// lookupCategory is true).
3304static bool ClassImplementsProtocol(ObjCProtocolDecl *lProto,
3305 ObjCInterfaceDecl *IDecl,
3306 bool lookupCategory,
3307 bool RHSIsQualifiedID = false) {
3308
3309 // 1st, look up the class.
3310 const ObjCList<ObjCProtocolDecl> &Protocols =
3311 IDecl->getReferencedProtocols();
3312
3313 for (ObjCList<ObjCProtocolDecl>::iterator PI = Protocols.begin(),
3314 E = Protocols.end(); PI != E; ++PI) {
3315 if (ProtocolCompatibleWithProtocol(lProto, *PI))
3316 return true;
3317 // This is dubious and is added to be compatible with gcc. In gcc, it is
3318 // also allowed assigning a protocol-qualified 'id' type to a LHS object
3319 // when protocol in qualified LHS is in list of protocols in the rhs 'id'
3320 // object. This IMO, should be a bug.
3321 // FIXME: Treat this as an extension, and flag this as an error when GCC
3322 // extensions are not enabled.
3323 if (RHSIsQualifiedID && ProtocolCompatibleWithProtocol(*PI, lProto))
3324 return true;
3325 }
3326
3327 // 2nd, look up the category.
3328 if (lookupCategory)
3329 for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl;
3330 CDecl = CDecl->getNextClassCategory()) {
3331 for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(),
3332 E = CDecl->protocol_end(); PI != E; ++PI)
3333 if (ProtocolCompatibleWithProtocol(lProto, *PI))
3334 return true;
3335 }
3336
3337 // 3rd, look up the super class(s)
3338 if (IDecl->getSuperClass())
3339 return
3340 ClassImplementsProtocol(lProto, IDecl->getSuperClass(), lookupCategory,
3341 RHSIsQualifiedID);
3342
3343 return false;
3344}
3345
3346/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...>
3347/// return true if lhs's protocols conform to rhs's protocol; false
3348/// otherwise.
3349bool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) {
3350 if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType())
3351 return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false);
3352 return false;
3353}
3354
3355/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
3356/// ObjCQualifiedIDType.
3357bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs,
3358 bool compare) {
3359 // Allow id<P..> and an 'id' or void* type in all cases.
3360 if (lhs->isVoidPointerType() ||
3361 lhs->isObjCIdType() || lhs->isObjCClassType())
3362 return true;
3363 else if (rhs->isVoidPointerType() ||
3364 rhs->isObjCIdType() || rhs->isObjCClassType())
3365 return true;
3366
3367 if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) {
3368 const ObjCObjectPointerType *rhsOPT = rhs->getAsObjCObjectPointerType();
3369
3370 if (!rhsOPT) return false;
3371
3372 if (rhsOPT->qual_empty()) {
3373 // If the RHS is a unqualified interface pointer "NSString*",
3374 // make sure we check the class hierarchy.
3375 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
3376 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
3377 E = lhsQID->qual_end(); I != E; ++I) {
3378 // when comparing an id<P> on lhs with a static type on rhs,
3379 // see if static class implements all of id's protocols, directly or
3380 // through its super class and categories.
3381 if (!ClassImplementsProtocol(*I, rhsID, true))
3382 return false;
3383 }
3384 }
3385 // If there are no qualifiers and no interface, we have an 'id'.
3386 return true;
3387 }
3388 // Both the right and left sides have qualifiers.
3389 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
3390 E = lhsQID->qual_end(); I != E; ++I) {
3391 ObjCProtocolDecl *lhsProto = *I;
3392 bool match = false;
3393
3394 // when comparing an id<P> on lhs with a static type on rhs,
3395 // see if static class implements all of id's protocols, directly or
3396 // through its super class and categories.
3397 for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(),
3398 E = rhsOPT->qual_end(); J != E; ++J) {
3399 ObjCProtocolDecl *rhsProto = *J;
3400 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
3401 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
3402 match = true;
3403 break;
3404 }
3405 }
3406 // If the RHS is a qualified interface pointer "NSString<P>*",
3407 // make sure we check the class hierarchy.
3408 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
3409 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
3410 E = lhsQID->qual_end(); I != E; ++I) {
3411 // when comparing an id<P> on lhs with a static type on rhs,
3412 // see if static class implements all of id's protocols, directly or
3413 // through its super class and categories.
3414 if (ClassImplementsProtocol(*I, rhsID, true)) {
3415 match = true;
3416 break;
3417 }
3418 }
3419 }
3420 if (!match)
3421 return false;
3422 }
3423
3424 return true;
3425 }
3426
3427 const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType();
3428 assert(rhsQID && "One of the LHS/RHS should be id<x>");
3429
3430 if (const ObjCObjectPointerType *lhsOPT =
3431 lhs->getAsObjCInterfacePointerType()) {
3432 if (lhsOPT->qual_empty()) {
3433 bool match = false;
3434 if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) {
3435 for (ObjCObjectPointerType::qual_iterator I = rhsQID->qual_begin(),
3436 E = rhsQID->qual_end(); I != E; ++I) {
3437 // when comparing an id<P> on lhs with a static type on rhs,
3438 // see if static class implements all of id's protocols, directly or
3439 // through its super class and categories.
3440 if (ClassImplementsProtocol(*I, lhsID, true)) {
3441 match = true;
3442 break;
3443 }
3444 }
3445 if (!match)
3446 return false;
3447 }
3448 return true;
3449 }
3450 // Both the right and left sides have qualifiers.
3451 for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(),
3452 E = lhsOPT->qual_end(); I != E; ++I) {
3453 ObjCProtocolDecl *lhsProto = *I;
3454 bool match = false;
3455
3456 // when comparing an id<P> on lhs with a static type on rhs,
3457 // see if static class implements all of id's protocols, directly or
3458 // through its super class and categories.
3459 for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(),
3460 E = rhsQID->qual_end(); J != E; ++J) {
3461 ObjCProtocolDecl *rhsProto = *J;
3462 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
3463 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
3464 match = true;
3465 break;
3466 }
3467 }
3468 if (!match)
3469 return false;
3470 }
3471 return true;
3472 }
3473 return false;
3474}
3475
Eli Friedman3d815e72008-08-22 00:56:42 +00003476/// canAssignObjCInterfaces - Return true if the two interface types are
Chris Lattner6ac46a42008-04-07 06:51:04 +00003477/// compatible for assignment from RHS to LHS. This handles validation of any
3478/// protocol qualifiers on the LHS or RHS.
3479///
Steve Naroff14108da2009-07-10 23:34:53 +00003480bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
3481 const ObjCObjectPointerType *RHSOPT) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00003482 // If either type represents the built-in 'id' or 'Class' types, return true.
3483 if (LHSOPT->isObjCBuiltinType() || RHSOPT->isObjCBuiltinType())
Steve Naroff14108da2009-07-10 23:34:53 +00003484 return true;
3485
Steve Naroff4084c302009-07-23 01:01:38 +00003486 if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
3487 return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
3488 QualType(RHSOPT,0),
3489 false);
3490
Steve Naroff14108da2009-07-10 23:34:53 +00003491 const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
3492 const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
Steve Naroff4084c302009-07-23 01:01:38 +00003493 if (LHS && RHS) // We have 2 user-defined types.
3494 return canAssignObjCInterfaces(LHS, RHS);
3495
3496 return false;
Steve Naroff14108da2009-07-10 23:34:53 +00003497}
3498
Eli Friedman3d815e72008-08-22 00:56:42 +00003499bool ASTContext::canAssignObjCInterfaces(const ObjCInterfaceType *LHS,
3500 const ObjCInterfaceType *RHS) {
Chris Lattner6ac46a42008-04-07 06:51:04 +00003501 // Verify that the base decls are compatible: the RHS must be a subclass of
3502 // the LHS.
3503 if (!LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
3504 return false;
3505
3506 // RHS must have a superset of the protocols in the LHS. If the LHS is not
3507 // protocol qualified at all, then we are good.
Steve Naroffc15cb2a2009-07-18 15:33:26 +00003508 if (LHS->getNumProtocols() == 0)
Chris Lattner6ac46a42008-04-07 06:51:04 +00003509 return true;
3510
3511 // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, then it
3512 // isn't a superset.
Steve Naroffc15cb2a2009-07-18 15:33:26 +00003513 if (RHS->getNumProtocols() == 0)
Chris Lattner6ac46a42008-04-07 06:51:04 +00003514 return true; // FIXME: should return false!
3515
Steve Naroffc15cb2a2009-07-18 15:33:26 +00003516 for (ObjCInterfaceType::qual_iterator LHSPI = LHS->qual_begin(),
3517 LHSPE = LHS->qual_end();
Steve Naroff91b0b0c2009-03-01 16:12:44 +00003518 LHSPI != LHSPE; LHSPI++) {
3519 bool RHSImplementsProtocol = false;
3520
3521 // If the RHS doesn't implement the protocol on the left, the types
3522 // are incompatible.
Steve Naroffc15cb2a2009-07-18 15:33:26 +00003523 for (ObjCInterfaceType::qual_iterator RHSPI = RHS->qual_begin(),
Steve Naroff4084c302009-07-23 01:01:38 +00003524 RHSPE = RHS->qual_end();
Steve Naroff8f167562009-07-16 16:21:02 +00003525 RHSPI != RHSPE; RHSPI++) {
3526 if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) {
Steve Naroff91b0b0c2009-03-01 16:12:44 +00003527 RHSImplementsProtocol = true;
Steve Naroff8f167562009-07-16 16:21:02 +00003528 break;
3529 }
Steve Naroff91b0b0c2009-03-01 16:12:44 +00003530 }
3531 // FIXME: For better diagnostics, consider passing back the protocol name.
3532 if (!RHSImplementsProtocol)
3533 return false;
Chris Lattner6ac46a42008-04-07 06:51:04 +00003534 }
Steve Naroff91b0b0c2009-03-01 16:12:44 +00003535 // The RHS implements all protocols listed on the LHS.
3536 return true;
Chris Lattner6ac46a42008-04-07 06:51:04 +00003537}
3538
Steve Naroff389bf462009-02-12 17:52:19 +00003539bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) {
3540 // get the "pointed to" types
Steve Naroff14108da2009-07-10 23:34:53 +00003541 const ObjCObjectPointerType *LHSOPT = LHS->getAsObjCObjectPointerType();
3542 const ObjCObjectPointerType *RHSOPT = RHS->getAsObjCObjectPointerType();
Steve Naroff389bf462009-02-12 17:52:19 +00003543
Steve Naroff14108da2009-07-10 23:34:53 +00003544 if (!LHSOPT || !RHSOPT)
Steve Naroff389bf462009-02-12 17:52:19 +00003545 return false;
Steve Naroff14108da2009-07-10 23:34:53 +00003546
3547 return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
3548 canAssignObjCInterfaces(RHSOPT, LHSOPT);
Steve Naroff389bf462009-02-12 17:52:19 +00003549}
3550
Steve Naroffec0550f2007-10-15 20:41:53 +00003551/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,
3552/// both shall have the identically qualified version of a compatible type.
3553/// C99 6.2.7p1: Two types have compatible types if their types are the
3554/// same. See 6.7.[2,3,5] for additional rules.
Eli Friedman3d815e72008-08-22 00:56:42 +00003555bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS) {
3556 return !mergeTypes(LHS, RHS).isNull();
3557}
3558
3559QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs) {
3560 const FunctionType *lbase = lhs->getAsFunctionType();
3561 const FunctionType *rbase = rhs->getAsFunctionType();
Douglas Gregor72564e72009-02-26 23:50:07 +00003562 const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
3563 const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
Eli Friedman3d815e72008-08-22 00:56:42 +00003564 bool allLTypes = true;
3565 bool allRTypes = true;
3566
3567 // Check return type
3568 QualType retType = mergeTypes(lbase->getResultType(), rbase->getResultType());
3569 if (retType.isNull()) return QualType();
Chris Lattner61710852008-10-05 17:34:18 +00003570 if (getCanonicalType(retType) != getCanonicalType(lbase->getResultType()))
3571 allLTypes = false;
3572 if (getCanonicalType(retType) != getCanonicalType(rbase->getResultType()))
3573 allRTypes = false;
Mike Stump6dcbc292009-07-25 23:24:03 +00003574 // FIXME: double check this
Mike Stump24556362009-07-25 21:26:53 +00003575 bool NoReturn = lbase->getNoReturnAttr() || rbase->getNoReturnAttr();
3576 if (NoReturn != lbase->getNoReturnAttr())
3577 allLTypes = false;
3578 if (NoReturn != rbase->getNoReturnAttr())
3579 allRTypes = false;
3580
Eli Friedman3d815e72008-08-22 00:56:42 +00003581 if (lproto && rproto) { // two C99 style function prototypes
Sebastian Redl465226e2009-05-27 22:11:52 +00003582 assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&
3583 "C++ shouldn't be here");
Eli Friedman3d815e72008-08-22 00:56:42 +00003584 unsigned lproto_nargs = lproto->getNumArgs();
3585 unsigned rproto_nargs = rproto->getNumArgs();
3586
3587 // Compatible functions must have the same number of arguments
3588 if (lproto_nargs != rproto_nargs)
3589 return QualType();
3590
3591 // Variadic and non-variadic functions aren't compatible
3592 if (lproto->isVariadic() != rproto->isVariadic())
3593 return QualType();
3594
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00003595 if (lproto->getTypeQuals() != rproto->getTypeQuals())
3596 return QualType();
3597
Eli Friedman3d815e72008-08-22 00:56:42 +00003598 // Check argument compatibility
3599 llvm::SmallVector<QualType, 10> types;
3600 for (unsigned i = 0; i < lproto_nargs; i++) {
3601 QualType largtype = lproto->getArgType(i).getUnqualifiedType();
3602 QualType rargtype = rproto->getArgType(i).getUnqualifiedType();
3603 QualType argtype = mergeTypes(largtype, rargtype);
3604 if (argtype.isNull()) return QualType();
3605 types.push_back(argtype);
Chris Lattner61710852008-10-05 17:34:18 +00003606 if (getCanonicalType(argtype) != getCanonicalType(largtype))
3607 allLTypes = false;
3608 if (getCanonicalType(argtype) != getCanonicalType(rargtype))
3609 allRTypes = false;
Eli Friedman3d815e72008-08-22 00:56:42 +00003610 }
3611 if (allLTypes) return lhs;
3612 if (allRTypes) return rhs;
3613 return getFunctionType(retType, types.begin(), types.size(),
Mike Stump24556362009-07-25 21:26:53 +00003614 lproto->isVariadic(), lproto->getTypeQuals(),
3615 NoReturn);
Eli Friedman3d815e72008-08-22 00:56:42 +00003616 }
3617
3618 if (lproto) allRTypes = false;
3619 if (rproto) allLTypes = false;
3620
Douglas Gregor72564e72009-02-26 23:50:07 +00003621 const FunctionProtoType *proto = lproto ? lproto : rproto;
Eli Friedman3d815e72008-08-22 00:56:42 +00003622 if (proto) {
Sebastian Redl465226e2009-05-27 22:11:52 +00003623 assert(!proto->hasExceptionSpec() && "C++ shouldn't be here");
Eli Friedman3d815e72008-08-22 00:56:42 +00003624 if (proto->isVariadic()) return QualType();
3625 // Check that the types are compatible with the types that
3626 // would result from default argument promotions (C99 6.7.5.3p15).
3627 // The only types actually affected are promotable integer
3628 // types and floats, which would be passed as a different
3629 // type depending on whether the prototype is visible.
3630 unsigned proto_nargs = proto->getNumArgs();
3631 for (unsigned i = 0; i < proto_nargs; ++i) {
3632 QualType argTy = proto->getArgType(i);
3633 if (argTy->isPromotableIntegerType() ||
3634 getCanonicalType(argTy).getUnqualifiedType() == FloatTy)
3635 return QualType();
3636 }
3637
3638 if (allLTypes) return lhs;
3639 if (allRTypes) return rhs;
3640 return getFunctionType(retType, proto->arg_type_begin(),
Mike Stump2d3c1912009-07-27 00:44:23 +00003641 proto->getNumArgs(), proto->isVariadic(),
3642 proto->getTypeQuals(), NoReturn);
Eli Friedman3d815e72008-08-22 00:56:42 +00003643 }
3644
3645 if (allLTypes) return lhs;
3646 if (allRTypes) return rhs;
Mike Stump24556362009-07-25 21:26:53 +00003647 return getFunctionNoProtoType(retType, NoReturn);
Eli Friedman3d815e72008-08-22 00:56:42 +00003648}
3649
3650QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) {
Bill Wendling43d69752007-12-03 07:33:35 +00003651 // C++ [expr]: If an expression initially has the type "reference to T", the
3652 // type is adjusted to "T" prior to any further analysis, the expression
3653 // designates the object or function denoted by the reference, and the
Sebastian Redl7c80bd62009-03-16 23:22:08 +00003654 // expression is an lvalue unless the reference is an rvalue reference and
3655 // the expression is a function call (possibly inside parentheses).
Eli Friedman3d815e72008-08-22 00:56:42 +00003656 // FIXME: C++ shouldn't be going through here! The rules are different
3657 // enough that they should be handled separately.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00003658 // FIXME: Merging of lvalue and rvalue references is incorrect. C++ *really*
3659 // shouldn't be going through here!
Ted Kremenek6217b802009-07-29 21:53:49 +00003660 if (const ReferenceType *RT = LHS->getAs<ReferenceType>())
Chris Lattnerc4e40592008-04-07 04:07:56 +00003661 LHS = RT->getPointeeType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003662 if (const ReferenceType *RT = RHS->getAs<ReferenceType>())
Chris Lattnerc4e40592008-04-07 04:07:56 +00003663 RHS = RT->getPointeeType();
Chris Lattnerf3692dc2008-04-07 05:37:56 +00003664
Eli Friedman3d815e72008-08-22 00:56:42 +00003665 QualType LHSCan = getCanonicalType(LHS),
3666 RHSCan = getCanonicalType(RHS);
3667
3668 // If two types are identical, they are compatible.
3669 if (LHSCan == RHSCan)
3670 return LHS;
3671
3672 // If the qualifiers are different, the types aren't compatible
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003673 // Note that we handle extended qualifiers later, in the
3674 // case for ExtQualType.
3675 if (LHSCan.getCVRQualifiers() != RHSCan.getCVRQualifiers())
Eli Friedman3d815e72008-08-22 00:56:42 +00003676 return QualType();
3677
Eli Friedman852d63b2009-06-01 01:22:52 +00003678 Type::TypeClass LHSClass = LHSCan->getTypeClass();
3679 Type::TypeClass RHSClass = RHSCan->getTypeClass();
Eli Friedman3d815e72008-08-22 00:56:42 +00003680
Chris Lattner1adb8832008-01-14 05:45:46 +00003681 // We want to consider the two function types to be the same for these
3682 // comparisons, just force one to the other.
3683 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
3684 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
Eli Friedman4c721d32008-02-12 08:23:06 +00003685
Eli Friedman07d25872009-06-02 05:28:56 +00003686 // Strip off objc_gc attributes off the top level so they can be merged.
3687 // This is a complete mess, but the attribute itself doesn't make much sense.
Fariborz Jahanian585f7b22009-06-02 01:40:22 +00003688 if (RHSClass == Type::ExtQual) {
Eli Friedman07d25872009-06-02 05:28:56 +00003689 QualType::GCAttrTypes GCAttr = RHSCan.getObjCGCAttr();
3690 if (GCAttr != QualType::GCNone) {
Fariborz Jahanian86f43852009-06-02 20:58:58 +00003691 QualType::GCAttrTypes GCLHSAttr = LHSCan.getObjCGCAttr();
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003692 // __weak attribute must appear on both declarations.
Fariborz Jahanian86f43852009-06-02 20:58:58 +00003693 // __strong attribue is redundant if other decl is an objective-c
3694 // object pointer (or decorated with __strong attribute); otherwise
3695 // issue error.
3696 if ((GCAttr == QualType::Weak && GCLHSAttr != GCAttr) ||
3697 (GCAttr == QualType::Strong && GCLHSAttr != GCAttr &&
Steve Naroff14108da2009-07-10 23:34:53 +00003698 !LHSCan->isObjCObjectPointerType()))
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003699 return QualType();
3700
Eli Friedman07d25872009-06-02 05:28:56 +00003701 RHS = QualType(cast<ExtQualType>(RHS.getDesugaredType())->getBaseType(),
3702 RHS.getCVRQualifiers());
3703 QualType Result = mergeTypes(LHS, RHS);
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003704 if (!Result.isNull()) {
3705 if (Result.getObjCGCAttr() == QualType::GCNone)
3706 Result = getObjCGCQualType(Result, GCAttr);
3707 else if (Result.getObjCGCAttr() != GCAttr)
3708 Result = QualType();
3709 }
Eli Friedman07d25872009-06-02 05:28:56 +00003710 return Result;
3711 }
Fariborz Jahanian585f7b22009-06-02 01:40:22 +00003712 }
Fariborz Jahanian585f7b22009-06-02 01:40:22 +00003713 if (LHSClass == Type::ExtQual) {
Eli Friedman07d25872009-06-02 05:28:56 +00003714 QualType::GCAttrTypes GCAttr = LHSCan.getObjCGCAttr();
3715 if (GCAttr != QualType::GCNone) {
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003716 QualType::GCAttrTypes GCRHSAttr = RHSCan.getObjCGCAttr();
3717 // __weak attribute must appear on both declarations. __strong
Fariborz Jahanian86f43852009-06-02 20:58:58 +00003718 // __strong attribue is redundant if other decl is an objective-c
3719 // object pointer (or decorated with __strong attribute); otherwise
3720 // issue error.
3721 if ((GCAttr == QualType::Weak && GCRHSAttr != GCAttr) ||
3722 (GCAttr == QualType::Strong && GCRHSAttr != GCAttr &&
Steve Naroff14108da2009-07-10 23:34:53 +00003723 !RHSCan->isObjCObjectPointerType()))
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003724 return QualType();
Fariborz Jahanian86f43852009-06-02 20:58:58 +00003725
Eli Friedman07d25872009-06-02 05:28:56 +00003726 LHS = QualType(cast<ExtQualType>(LHS.getDesugaredType())->getBaseType(),
3727 LHS.getCVRQualifiers());
3728 QualType Result = mergeTypes(LHS, RHS);
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003729 if (!Result.isNull()) {
3730 if (Result.getObjCGCAttr() == QualType::GCNone)
3731 Result = getObjCGCQualType(Result, GCAttr);
3732 else if (Result.getObjCGCAttr() != GCAttr)
3733 Result = QualType();
3734 }
Eli Friedman354e53d2009-06-02 07:45:37 +00003735 return Result;
Eli Friedman07d25872009-06-02 05:28:56 +00003736 }
Fariborz Jahanian585f7b22009-06-02 01:40:22 +00003737 }
3738
Eli Friedman4c721d32008-02-12 08:23:06 +00003739 // Same as above for arrays
Chris Lattnera36a61f2008-04-07 05:43:21 +00003740 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
3741 LHSClass = Type::ConstantArray;
3742 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
3743 RHSClass = Type::ConstantArray;
Steve Naroffec0550f2007-10-15 20:41:53 +00003744
Nate Begeman213541a2008-04-18 23:10:10 +00003745 // Canonicalize ExtVector -> Vector.
3746 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
3747 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
Chris Lattnera36a61f2008-04-07 05:43:21 +00003748
3749 // If the canonical type classes don't match.
Chris Lattner1adb8832008-01-14 05:45:46 +00003750 if (LHSClass != RHSClass) {
Chris Lattner1adb8832008-01-14 05:45:46 +00003751 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
3752 // a signed integer type, or an unsigned integer type.
Eli Friedman3d815e72008-08-22 00:56:42 +00003753 if (const EnumType* ETy = LHS->getAsEnumType()) {
3754 if (ETy->getDecl()->getIntegerType() == RHSCan.getUnqualifiedType())
3755 return RHS;
Eli Friedmanbab96962008-02-12 08:46:17 +00003756 }
Eli Friedman3d815e72008-08-22 00:56:42 +00003757 if (const EnumType* ETy = RHS->getAsEnumType()) {
3758 if (ETy->getDecl()->getIntegerType() == LHSCan.getUnqualifiedType())
3759 return LHS;
Eli Friedmanbab96962008-02-12 08:46:17 +00003760 }
Chris Lattner1adb8832008-01-14 05:45:46 +00003761
Eli Friedman3d815e72008-08-22 00:56:42 +00003762 return QualType();
Steve Naroffec0550f2007-10-15 20:41:53 +00003763 }
Eli Friedman3d815e72008-08-22 00:56:42 +00003764
Steve Naroff4a746782008-01-09 22:43:08 +00003765 // The canonical type classes match.
Chris Lattner1adb8832008-01-14 05:45:46 +00003766 switch (LHSClass) {
Douglas Gregor72564e72009-02-26 23:50:07 +00003767#define TYPE(Class, Base)
3768#define ABSTRACT_TYPE(Class, Base)
3769#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3770#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3771#include "clang/AST/TypeNodes.def"
3772 assert(false && "Non-canonical and dependent types shouldn't get here");
3773 return QualType();
3774
Sebastian Redl7c80bd62009-03-16 23:22:08 +00003775 case Type::LValueReference:
3776 case Type::RValueReference:
Douglas Gregor72564e72009-02-26 23:50:07 +00003777 case Type::MemberPointer:
3778 assert(false && "C++ should never be in mergeTypes");
3779 return QualType();
3780
3781 case Type::IncompleteArray:
3782 case Type::VariableArray:
3783 case Type::FunctionProto:
3784 case Type::ExtVector:
Douglas Gregor72564e72009-02-26 23:50:07 +00003785 assert(false && "Types are eliminated above");
3786 return QualType();
3787
Chris Lattner1adb8832008-01-14 05:45:46 +00003788 case Type::Pointer:
Eli Friedman3d815e72008-08-22 00:56:42 +00003789 {
3790 // Merge two pointer types, while trying to preserve typedef info
Ted Kremenek6217b802009-07-29 21:53:49 +00003791 QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType();
3792 QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType();
Eli Friedman3d815e72008-08-22 00:56:42 +00003793 QualType ResultType = mergeTypes(LHSPointee, RHSPointee);
3794 if (ResultType.isNull()) return QualType();
Eli Friedman07d25872009-06-02 05:28:56 +00003795 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
Chris Lattner61710852008-10-05 17:34:18 +00003796 return LHS;
Eli Friedman07d25872009-06-02 05:28:56 +00003797 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
Chris Lattner61710852008-10-05 17:34:18 +00003798 return RHS;
Eli Friedman3d815e72008-08-22 00:56:42 +00003799 return getPointerType(ResultType);
3800 }
Steve Naroffc0febd52008-12-10 17:49:55 +00003801 case Type::BlockPointer:
3802 {
3803 // Merge two block pointer types, while trying to preserve typedef info
Ted Kremenek6217b802009-07-29 21:53:49 +00003804 QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType();
3805 QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType();
Steve Naroffc0febd52008-12-10 17:49:55 +00003806 QualType ResultType = mergeTypes(LHSPointee, RHSPointee);
3807 if (ResultType.isNull()) return QualType();
3808 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
3809 return LHS;
3810 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
3811 return RHS;
3812 return getBlockPointerType(ResultType);
3813 }
Chris Lattner1adb8832008-01-14 05:45:46 +00003814 case Type::ConstantArray:
Eli Friedman3d815e72008-08-22 00:56:42 +00003815 {
3816 const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
3817 const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
3818 if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
3819 return QualType();
3820
3821 QualType LHSElem = getAsArrayType(LHS)->getElementType();
3822 QualType RHSElem = getAsArrayType(RHS)->getElementType();
3823 QualType ResultType = mergeTypes(LHSElem, RHSElem);
3824 if (ResultType.isNull()) return QualType();
Chris Lattner61710852008-10-05 17:34:18 +00003825 if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
3826 return LHS;
3827 if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
3828 return RHS;
Eli Friedman3bc0f452008-08-22 01:48:21 +00003829 if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(),
3830 ArrayType::ArraySizeModifier(), 0);
3831 if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(),
3832 ArrayType::ArraySizeModifier(), 0);
Eli Friedman3d815e72008-08-22 00:56:42 +00003833 const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
3834 const VariableArrayType* RVAT = getAsVariableArrayType(RHS);
Chris Lattner61710852008-10-05 17:34:18 +00003835 if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
3836 return LHS;
3837 if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
3838 return RHS;
Eli Friedman3d815e72008-08-22 00:56:42 +00003839 if (LVAT) {
3840 // FIXME: This isn't correct! But tricky to implement because
3841 // the array's size has to be the size of LHS, but the type
3842 // has to be different.
3843 return LHS;
3844 }
3845 if (RVAT) {
3846 // FIXME: This isn't correct! But tricky to implement because
3847 // the array's size has to be the size of RHS, but the type
3848 // has to be different.
3849 return RHS;
3850 }
Eli Friedman3bc0f452008-08-22 01:48:21 +00003851 if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
3852 if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00003853 return getIncompleteArrayType(ResultType,
3854 ArrayType::ArraySizeModifier(), 0);
Eli Friedman3d815e72008-08-22 00:56:42 +00003855 }
Chris Lattner1adb8832008-01-14 05:45:46 +00003856 case Type::FunctionNoProto:
Eli Friedman3d815e72008-08-22 00:56:42 +00003857 return mergeFunctionTypes(LHS, RHS);
Douglas Gregor72564e72009-02-26 23:50:07 +00003858 case Type::Record:
Douglas Gregor72564e72009-02-26 23:50:07 +00003859 case Type::Enum:
Eli Friedman3d815e72008-08-22 00:56:42 +00003860 return QualType();
Chris Lattner1adb8832008-01-14 05:45:46 +00003861 case Type::Builtin:
Chris Lattner3cc4c0c2008-04-07 05:55:38 +00003862 // Only exactly equal builtin types are compatible, which is tested above.
Eli Friedman3d815e72008-08-22 00:56:42 +00003863 return QualType();
Daniel Dunbar64cfdb72009-01-28 21:22:12 +00003864 case Type::Complex:
3865 // Distinct complex types are incompatible.
3866 return QualType();
Chris Lattner3cc4c0c2008-04-07 05:55:38 +00003867 case Type::Vector:
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003868 // FIXME: The merged type should be an ExtVector!
Eli Friedman3d815e72008-08-22 00:56:42 +00003869 if (areCompatVectorTypes(LHS->getAsVectorType(), RHS->getAsVectorType()))
3870 return LHS;
Chris Lattner61710852008-10-05 17:34:18 +00003871 return QualType();
Cedric Venet61490e92009-02-21 17:14:49 +00003872 case Type::ObjCInterface: {
Steve Naroff5fd659d2009-02-21 16:18:07 +00003873 // Check if the interfaces are assignment compatible.
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003874 // FIXME: This should be type compatibility, e.g. whether
3875 // "LHS x; RHS x;" at global scope is legal.
Steve Naroff5fd659d2009-02-21 16:18:07 +00003876 const ObjCInterfaceType* LHSIface = LHS->getAsObjCInterfaceType();
3877 const ObjCInterfaceType* RHSIface = RHS->getAsObjCInterfaceType();
3878 if (LHSIface && RHSIface &&
3879 canAssignObjCInterfaces(LHSIface, RHSIface))
3880 return LHS;
3881
Eli Friedman3d815e72008-08-22 00:56:42 +00003882 return QualType();
Cedric Venet61490e92009-02-21 17:14:49 +00003883 }
Steve Naroff14108da2009-07-10 23:34:53 +00003884 case Type::ObjCObjectPointer: {
Steve Naroff14108da2009-07-10 23:34:53 +00003885 if (canAssignObjCInterfaces(LHS->getAsObjCObjectPointerType(),
3886 RHS->getAsObjCObjectPointerType()))
3887 return LHS;
3888
Steve Naroffbc76dd02008-12-10 22:14:21 +00003889 return QualType();
Steve Naroff14108da2009-07-10 23:34:53 +00003890 }
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003891 case Type::FixedWidthInt:
3892 // Distinct fixed-width integers are not compatible.
3893 return QualType();
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003894 case Type::ExtQual:
3895 // FIXME: ExtQual types can be compatible even if they're not
3896 // identical!
3897 return QualType();
3898 // First attempt at an implementation, but I'm not really sure it's
3899 // right...
3900#if 0
3901 ExtQualType* LQual = cast<ExtQualType>(LHSCan);
3902 ExtQualType* RQual = cast<ExtQualType>(RHSCan);
3903 if (LQual->getAddressSpace() != RQual->getAddressSpace() ||
3904 LQual->getObjCGCAttr() != RQual->getObjCGCAttr())
3905 return QualType();
3906 QualType LHSBase, RHSBase, ResultType, ResCanUnqual;
3907 LHSBase = QualType(LQual->getBaseType(), 0);
3908 RHSBase = QualType(RQual->getBaseType(), 0);
3909 ResultType = mergeTypes(LHSBase, RHSBase);
3910 if (ResultType.isNull()) return QualType();
3911 ResCanUnqual = getCanonicalType(ResultType).getUnqualifiedType();
3912 if (LHSCan.getUnqualifiedType() == ResCanUnqual)
3913 return LHS;
3914 if (RHSCan.getUnqualifiedType() == ResCanUnqual)
3915 return RHS;
3916 ResultType = getAddrSpaceQualType(ResultType, LQual->getAddressSpace());
3917 ResultType = getObjCGCQualType(ResultType, LQual->getObjCGCAttr());
3918 ResultType.setCVRQualifiers(LHSCan.getCVRQualifiers());
3919 return ResultType;
3920#endif
Douglas Gregor7532dc62009-03-30 22:58:21 +00003921
3922 case Type::TemplateSpecialization:
3923 assert(false && "Dependent types have no size");
3924 break;
Steve Naroffec0550f2007-10-15 20:41:53 +00003925 }
Douglas Gregor72564e72009-02-26 23:50:07 +00003926
3927 return QualType();
Steve Naroffec0550f2007-10-15 20:41:53 +00003928}
Ted Kremenek7192f8e2007-10-31 17:10:13 +00003929
Chris Lattner5426bf62008-04-07 07:01:58 +00003930//===----------------------------------------------------------------------===//
Eli Friedmanad74a752008-06-28 06:23:08 +00003931// Integer Predicates
3932//===----------------------------------------------------------------------===//
Chris Lattner88054de2009-01-16 07:15:35 +00003933
Eli Friedmanad74a752008-06-28 06:23:08 +00003934unsigned ASTContext::getIntWidth(QualType T) {
3935 if (T == BoolTy)
3936 return 1;
Eli Friedmanf98aba32009-02-13 02:31:07 +00003937 if (FixedWidthIntType* FWIT = dyn_cast<FixedWidthIntType>(T)) {
3938 return FWIT->getWidth();
3939 }
3940 // For builtin types, just use the standard type sizing method
Eli Friedmanad74a752008-06-28 06:23:08 +00003941 return (unsigned)getTypeSize(T);
3942}
3943
3944QualType ASTContext::getCorrespondingUnsignedType(QualType T) {
3945 assert(T->isSignedIntegerType() && "Unexpected type");
3946 if (const EnumType* ETy = T->getAsEnumType())
3947 T = ETy->getDecl()->getIntegerType();
3948 const BuiltinType* BTy = T->getAsBuiltinType();
3949 assert (BTy && "Unexpected signed integer type");
3950 switch (BTy->getKind()) {
3951 case BuiltinType::Char_S:
3952 case BuiltinType::SChar:
3953 return UnsignedCharTy;
3954 case BuiltinType::Short:
3955 return UnsignedShortTy;
3956 case BuiltinType::Int:
3957 return UnsignedIntTy;
3958 case BuiltinType::Long:
3959 return UnsignedLongTy;
3960 case BuiltinType::LongLong:
3961 return UnsignedLongLongTy;
Chris Lattner2df9ced2009-04-30 02:43:43 +00003962 case BuiltinType::Int128:
3963 return UnsignedInt128Ty;
Eli Friedmanad74a752008-06-28 06:23:08 +00003964 default:
3965 assert(0 && "Unexpected signed integer type");
3966 return QualType();
3967 }
3968}
3969
Douglas Gregor2cf26342009-04-09 22:27:44 +00003970ExternalASTSource::~ExternalASTSource() { }
3971
3972void ExternalASTSource::PrintStats() { }
Chris Lattner86df27b2009-06-14 00:45:47 +00003973
3974
3975//===----------------------------------------------------------------------===//
3976// Builtin Type Computation
3977//===----------------------------------------------------------------------===//
3978
3979/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
3980/// pointer over the consumed characters. This returns the resultant type.
3981static QualType DecodeTypeFromStr(const char *&Str, ASTContext &Context,
3982 ASTContext::GetBuiltinTypeError &Error,
3983 bool AllowTypeModifiers = true) {
3984 // Modifiers.
3985 int HowLong = 0;
3986 bool Signed = false, Unsigned = false;
3987
3988 // Read the modifiers first.
3989 bool Done = false;
3990 while (!Done) {
3991 switch (*Str++) {
3992 default: Done = true; --Str; break;
3993 case 'S':
3994 assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!");
3995 assert(!Signed && "Can't use 'S' modifier multiple times!");
3996 Signed = true;
3997 break;
3998 case 'U':
3999 assert(!Signed && "Can't use both 'S' and 'U' modifiers!");
4000 assert(!Unsigned && "Can't use 'S' modifier multiple times!");
4001 Unsigned = true;
4002 break;
4003 case 'L':
4004 assert(HowLong <= 2 && "Can't have LLLL modifier");
4005 ++HowLong;
4006 break;
4007 }
4008 }
4009
4010 QualType Type;
4011
4012 // Read the base type.
4013 switch (*Str++) {
4014 default: assert(0 && "Unknown builtin type letter!");
4015 case 'v':
4016 assert(HowLong == 0 && !Signed && !Unsigned &&
4017 "Bad modifiers used with 'v'!");
4018 Type = Context.VoidTy;
4019 break;
4020 case 'f':
4021 assert(HowLong == 0 && !Signed && !Unsigned &&
4022 "Bad modifiers used with 'f'!");
4023 Type = Context.FloatTy;
4024 break;
4025 case 'd':
4026 assert(HowLong < 2 && !Signed && !Unsigned &&
4027 "Bad modifiers used with 'd'!");
4028 if (HowLong)
4029 Type = Context.LongDoubleTy;
4030 else
4031 Type = Context.DoubleTy;
4032 break;
4033 case 's':
4034 assert(HowLong == 0 && "Bad modifiers used with 's'!");
4035 if (Unsigned)
4036 Type = Context.UnsignedShortTy;
4037 else
4038 Type = Context.ShortTy;
4039 break;
4040 case 'i':
4041 if (HowLong == 3)
4042 Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
4043 else if (HowLong == 2)
4044 Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
4045 else if (HowLong == 1)
4046 Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
4047 else
4048 Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
4049 break;
4050 case 'c':
4051 assert(HowLong == 0 && "Bad modifiers used with 'c'!");
4052 if (Signed)
4053 Type = Context.SignedCharTy;
4054 else if (Unsigned)
4055 Type = Context.UnsignedCharTy;
4056 else
4057 Type = Context.CharTy;
4058 break;
4059 case 'b': // boolean
4060 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!");
4061 Type = Context.BoolTy;
4062 break;
4063 case 'z': // size_t.
4064 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!");
4065 Type = Context.getSizeType();
4066 break;
4067 case 'F':
4068 Type = Context.getCFConstantStringType();
4069 break;
4070 case 'a':
4071 Type = Context.getBuiltinVaListType();
4072 assert(!Type.isNull() && "builtin va list type not initialized!");
4073 break;
4074 case 'A':
4075 // This is a "reference" to a va_list; however, what exactly
4076 // this means depends on how va_list is defined. There are two
4077 // different kinds of va_list: ones passed by value, and ones
4078 // passed by reference. An example of a by-value va_list is
4079 // x86, where va_list is a char*. An example of by-ref va_list
4080 // is x86-64, where va_list is a __va_list_tag[1]. For x86,
4081 // we want this argument to be a char*&; for x86-64, we want
4082 // it to be a __va_list_tag*.
4083 Type = Context.getBuiltinVaListType();
4084 assert(!Type.isNull() && "builtin va list type not initialized!");
4085 if (Type->isArrayType()) {
4086 Type = Context.getArrayDecayedType(Type);
4087 } else {
4088 Type = Context.getLValueReferenceType(Type);
4089 }
4090 break;
4091 case 'V': {
4092 char *End;
Chris Lattner86df27b2009-06-14 00:45:47 +00004093 unsigned NumElements = strtoul(Str, &End, 10);
4094 assert(End != Str && "Missing vector size");
4095
4096 Str = End;
4097
4098 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, false);
4099 Type = Context.getVectorType(ElementType, NumElements);
4100 break;
4101 }
Chris Lattner9a5a7e72009-07-28 22:49:34 +00004102 case 'P':
Douglas Gregorc29f77b2009-07-07 16:35:42 +00004103 Type = Context.getFILEType();
4104 if (Type.isNull()) {
Mike Stumpf711c412009-07-28 23:57:15 +00004105 Error = ASTContext::GE_Missing_stdio;
Chris Lattner86df27b2009-06-14 00:45:47 +00004106 return QualType();
4107 }
Mike Stumpfd612db2009-07-28 23:47:15 +00004108 break;
Chris Lattner9a5a7e72009-07-28 22:49:34 +00004109 case 'J':
Mike Stumpf711c412009-07-28 23:57:15 +00004110 if (Signed)
Mike Stump782fa302009-07-28 02:25:19 +00004111 Type = Context.getsigjmp_bufType();
Mike Stumpf711c412009-07-28 23:57:15 +00004112 else
4113 Type = Context.getjmp_bufType();
4114
Mike Stumpfd612db2009-07-28 23:47:15 +00004115 if (Type.isNull()) {
Mike Stumpf711c412009-07-28 23:57:15 +00004116 Error = ASTContext::GE_Missing_setjmp;
Mike Stumpfd612db2009-07-28 23:47:15 +00004117 return QualType();
4118 }
4119 break;
Mike Stump782fa302009-07-28 02:25:19 +00004120 }
Chris Lattner86df27b2009-06-14 00:45:47 +00004121
4122 if (!AllowTypeModifiers)
4123 return Type;
4124
4125 Done = false;
4126 while (!Done) {
4127 switch (*Str++) {
4128 default: Done = true; --Str; break;
4129 case '*':
4130 Type = Context.getPointerType(Type);
4131 break;
4132 case '&':
4133 Type = Context.getLValueReferenceType(Type);
4134 break;
4135 // FIXME: There's no way to have a built-in with an rvalue ref arg.
4136 case 'C':
4137 Type = Type.getQualifiedType(QualType::Const);
4138 break;
4139 }
4140 }
4141
4142 return Type;
4143}
4144
4145/// GetBuiltinType - Return the type for the specified builtin.
4146QualType ASTContext::GetBuiltinType(unsigned id,
4147 GetBuiltinTypeError &Error) {
4148 const char *TypeStr = BuiltinInfo.GetTypeString(id);
4149
4150 llvm::SmallVector<QualType, 8> ArgTypes;
4151
4152 Error = GE_None;
4153 QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error);
4154 if (Error != GE_None)
4155 return QualType();
4156 while (TypeStr[0] && TypeStr[0] != '.') {
4157 QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error);
4158 if (Error != GE_None)
4159 return QualType();
4160
4161 // Do array -> pointer decay. The builtin should use the decayed type.
4162 if (Ty->isArrayType())
4163 Ty = getArrayDecayedType(Ty);
4164
4165 ArgTypes.push_back(Ty);
4166 }
4167
4168 assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&
4169 "'.' should only occur at end of builtin type list!");
4170
4171 // handle untyped/variadic arguments "T c99Style();" or "T cppStyle(...);".
4172 if (ArgTypes.size() == 0 && TypeStr[0] == '.')
4173 return getFunctionNoProtoType(ResType);
4174 return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(),
4175 TypeStr[0] == '.', 0);
4176}