blob: 1b73679beb7c2f7f4b285566f2871c0c9d363d61 [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.
2073QualType ASTContext::getCanonicalType(QualType T) {
2074 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();
2078 if (TypeQuals == 0) return CanType;
2079
2080 // If the type qualifiers are on an array type, get the canonical type of the
2081 // array with the qualifiers applied to the element type.
2082 ArrayType *AT = dyn_cast<ArrayType>(CanType);
2083 if (!AT)
2084 return CanType.getQualifiedType(TypeQuals);
2085
2086 // Get the canonical version of the element with the extra qualifiers on it.
2087 // This can recursively sink qualifiers through multiple levels of arrays.
2088 QualType NewEltTy=AT->getElementType().getWithAdditionalQualifiers(TypeQuals);
2089 NewEltTy = getCanonicalType(NewEltTy);
2090
2091 if (ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
2092 return getConstantArrayType(NewEltTy, CAT->getSize(),CAT->getSizeModifier(),
2093 CAT->getIndexTypeQualifier());
2094 if (IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT))
2095 return getIncompleteArrayType(NewEltTy, IAT->getSizeModifier(),
2096 IAT->getIndexTypeQualifier());
2097
Douglas Gregor898574e2008-12-05 23:32:09 +00002098 if (DependentSizedArrayType *DSAT = dyn_cast<DependentSizedArrayType>(AT))
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002099 return getDependentSizedArrayType(NewEltTy,
2100 DSAT->getSizeExpr(),
Douglas Gregor898574e2008-12-05 23:32:09 +00002101 DSAT->getSizeModifier(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002102 DSAT->getIndexTypeQualifier(),
2103 DSAT->getBracketsRange());
Douglas Gregor898574e2008-12-05 23:32:09 +00002104
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002105 VariableArrayType *VAT = cast<VariableArrayType>(AT);
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002106 return getVariableArrayType(NewEltTy,
2107 VAT->getSizeExpr(),
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002108 VAT->getSizeModifier(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002109 VAT->getIndexTypeQualifier(),
2110 VAT->getBracketsRange());
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002111}
2112
Douglas Gregor25a3ef72009-05-07 06:41:52 +00002113TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) {
2114 // If this template name refers to a template, the canonical
2115 // template name merely stores the template itself.
2116 if (TemplateDecl *Template = Name.getAsTemplateDecl())
Argyrios Kyrtzidis97fbaa22009-07-18 00:34:25 +00002117 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
Douglas Gregor25a3ef72009-05-07 06:41:52 +00002118
Douglas Gregord99cbe62009-07-29 18:26:50 +00002119 // If this template name refers to a set of overloaded function templates,
2120 /// the canonical template name merely stores the set of function templates.
2121 if (OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl())
2122 // FIXME: Can't really canonicalize a set of overloaded functions, can we?
2123 return TemplateName(Ovl);
2124
Douglas Gregor25a3ef72009-05-07 06:41:52 +00002125 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
2126 assert(DTN && "Non-dependent template names must refer to template decls.");
2127 return DTN->CanonicalTemplateName;
2128}
2129
Douglas Gregor1275ae02009-07-28 23:00:59 +00002130TemplateArgument
2131ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) {
2132 switch (Arg.getKind()) {
2133 case TemplateArgument::Null:
2134 return Arg;
2135
2136 case TemplateArgument::Expression:
2137 // FIXME: Build canonical expression?
2138 return Arg;
2139
2140 case TemplateArgument::Declaration:
2141 return TemplateArgument(SourceLocation(),
2142 Arg.getAsDecl()->getCanonicalDecl());
2143
2144 case TemplateArgument::Integral:
2145 return TemplateArgument(SourceLocation(),
2146 *Arg.getAsIntegral(),
2147 getCanonicalType(Arg.getIntegralType()));
2148
2149 case TemplateArgument::Type:
2150 return TemplateArgument(SourceLocation(),
2151 getCanonicalType(Arg.getAsType()));
2152
2153 case TemplateArgument::Pack: {
2154 // FIXME: Allocate in ASTContext
2155 TemplateArgument *CanonArgs = new TemplateArgument[Arg.pack_size()];
2156 unsigned Idx = 0;
2157 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
2158 AEnd = Arg.pack_end();
2159 A != AEnd; (void)++A, ++Idx)
2160 CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
2161
2162 TemplateArgument Result;
2163 Result.setArgumentPack(CanonArgs, Arg.pack_size(), false);
2164 return Result;
2165 }
2166 }
2167
2168 // Silence GCC warning
2169 assert(false && "Unhandled template argument kind");
2170 return TemplateArgument();
2171}
2172
Douglas Gregord57959a2009-03-27 23:10:48 +00002173NestedNameSpecifier *
2174ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) {
2175 if (!NNS)
2176 return 0;
2177
2178 switch (NNS->getKind()) {
2179 case NestedNameSpecifier::Identifier:
2180 // Canonicalize the prefix but keep the identifier the same.
2181 return NestedNameSpecifier::Create(*this,
2182 getCanonicalNestedNameSpecifier(NNS->getPrefix()),
2183 NNS->getAsIdentifier());
2184
2185 case NestedNameSpecifier::Namespace:
2186 // A namespace is canonical; build a nested-name-specifier with
2187 // this namespace and no prefix.
2188 return NestedNameSpecifier::Create(*this, 0, NNS->getAsNamespace());
2189
2190 case NestedNameSpecifier::TypeSpec:
2191 case NestedNameSpecifier::TypeSpecWithTemplate: {
2192 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
2193 NestedNameSpecifier *Prefix = 0;
2194
2195 // FIXME: This isn't the right check!
2196 if (T->isDependentType())
2197 Prefix = getCanonicalNestedNameSpecifier(NNS->getPrefix());
2198
2199 return NestedNameSpecifier::Create(*this, Prefix,
2200 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
2201 T.getTypePtr());
2202 }
2203
2204 case NestedNameSpecifier::Global:
2205 // The global specifier is canonical and unique.
2206 return NNS;
2207 }
2208
2209 // Required to silence a GCC warning
2210 return 0;
2211}
2212
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002213
2214const ArrayType *ASTContext::getAsArrayType(QualType T) {
2215 // Handle the non-qualified case efficiently.
2216 if (T.getCVRQualifiers() == 0) {
2217 // Handle the common positive case fast.
2218 if (const ArrayType *AT = dyn_cast<ArrayType>(T))
2219 return AT;
2220 }
2221
2222 // Handle the common negative case fast, ignoring CVR qualifiers.
2223 QualType CType = T->getCanonicalTypeInternal();
2224
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00002225 // Make sure to look through type qualifiers (like ExtQuals) for the negative
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002226 // test.
2227 if (!isa<ArrayType>(CType) &&
2228 !isa<ArrayType>(CType.getUnqualifiedType()))
2229 return 0;
2230
2231 // Apply any CVR qualifiers from the array type to the element type. This
2232 // implements C99 6.7.3p8: "If the specification of an array type includes
2233 // any type qualifiers, the element type is so qualified, not the array type."
2234
2235 // If we get here, we either have type qualifiers on the type, or we have
2236 // sugar such as a typedef in the way. If we have type qualifiers on the type
2237 // we must propagate them down into the elemeng type.
2238 unsigned CVRQuals = T.getCVRQualifiers();
2239 unsigned AddrSpace = 0;
2240 Type *Ty = T.getTypePtr();
2241
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00002242 // Rip through ExtQualType's and typedefs to get to a concrete type.
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002243 while (1) {
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00002244 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(Ty)) {
2245 AddrSpace = EXTQT->getAddressSpace();
2246 Ty = EXTQT->getBaseType();
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002247 } else {
2248 T = Ty->getDesugaredType();
2249 if (T.getTypePtr() == Ty && T.getCVRQualifiers() == 0)
2250 break;
2251 CVRQuals |= T.getCVRQualifiers();
2252 Ty = T.getTypePtr();
2253 }
2254 }
2255
2256 // If we have a simple case, just return now.
2257 const ArrayType *ATy = dyn_cast<ArrayType>(Ty);
2258 if (ATy == 0 || (AddrSpace == 0 && CVRQuals == 0))
2259 return ATy;
2260
2261 // Otherwise, we have an array and we have qualifiers on it. Push the
2262 // qualifiers into the array element type and return a new array type.
2263 // Get the canonical version of the element with the extra qualifiers on it.
2264 // This can recursively sink qualifiers through multiple levels of arrays.
2265 QualType NewEltTy = ATy->getElementType();
2266 if (AddrSpace)
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00002267 NewEltTy = getAddrSpaceQualType(NewEltTy, AddrSpace);
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002268 NewEltTy = NewEltTy.getWithAdditionalQualifiers(CVRQuals);
2269
2270 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy))
2271 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
2272 CAT->getSizeModifier(),
2273 CAT->getIndexTypeQualifier()));
2274 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy))
2275 return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
2276 IAT->getSizeModifier(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002277 IAT->getIndexTypeQualifier()));
Douglas Gregor898574e2008-12-05 23:32:09 +00002278
Douglas Gregor898574e2008-12-05 23:32:09 +00002279 if (const DependentSizedArrayType *DSAT
2280 = dyn_cast<DependentSizedArrayType>(ATy))
2281 return cast<ArrayType>(
2282 getDependentSizedArrayType(NewEltTy,
2283 DSAT->getSizeExpr(),
2284 DSAT->getSizeModifier(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002285 DSAT->getIndexTypeQualifier(),
2286 DSAT->getBracketsRange()));
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002287
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002288 const VariableArrayType *VAT = cast<VariableArrayType>(ATy);
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002289 return cast<ArrayType>(getVariableArrayType(NewEltTy,
2290 VAT->getSizeExpr(),
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002291 VAT->getSizeModifier(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002292 VAT->getIndexTypeQualifier(),
2293 VAT->getBracketsRange()));
Chris Lattner77c96472008-04-06 22:41:35 +00002294}
2295
2296
Chris Lattnere6327742008-04-02 05:18:44 +00002297/// getArrayDecayedType - Return the properly qualified result of decaying the
2298/// specified array type to a pointer. This operation is non-trivial when
2299/// handling typedefs etc. The canonical type of "T" must be an array type,
2300/// this returns a pointer to a properly qualified element of the array.
2301///
2302/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
2303QualType ASTContext::getArrayDecayedType(QualType Ty) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002304 // Get the element type with 'getAsArrayType' so that we don't lose any
2305 // typedefs in the element type of the array. This also handles propagation
2306 // of type qualifiers from the array type into the element type if present
2307 // (C99 6.7.3p8).
2308 const ArrayType *PrettyArrayType = getAsArrayType(Ty);
2309 assert(PrettyArrayType && "Not an array type!");
Chris Lattnere6327742008-04-02 05:18:44 +00002310
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002311 QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
Chris Lattnere6327742008-04-02 05:18:44 +00002312
2313 // int x[restrict 4] -> int *restrict
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002314 return PtrTy.getQualifiedType(PrettyArrayType->getIndexTypeQualifier());
Chris Lattnere6327742008-04-02 05:18:44 +00002315}
2316
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00002317QualType ASTContext::getBaseElementType(QualType QT) {
2318 QualifierSet qualifiers;
2319 while (true) {
2320 const Type *UT = qualifiers.strip(QT);
2321 if (const ArrayType *AT = getAsArrayType(QualType(UT,0))) {
2322 QT = AT->getElementType();
Mike Stump6dcbc292009-07-25 23:24:03 +00002323 } else {
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00002324 return qualifiers.apply(QT, *this);
2325 }
2326 }
2327}
2328
Daniel Dunbard786f6a2009-01-05 22:14:37 +00002329QualType ASTContext::getBaseElementType(const VariableArrayType *VAT) {
Anders Carlsson6183a992008-12-21 03:44:36 +00002330 QualType ElemTy = VAT->getElementType();
2331
2332 if (const VariableArrayType *VAT = getAsVariableArrayType(ElemTy))
2333 return getBaseElementType(VAT);
2334
2335 return ElemTy;
2336}
2337
Reid Spencer5f016e22007-07-11 17:01:13 +00002338/// getFloatingRank - Return a relative rank for floating point types.
2339/// This routine will assert if passed a built-in type that isn't a float.
Chris Lattnera75cea32008-04-06 23:38:49 +00002340static FloatingRank getFloatingRank(QualType T) {
Christopher Lambebb97e92008-02-04 02:31:56 +00002341 if (const ComplexType *CT = T->getAsComplexType())
Reid Spencer5f016e22007-07-11 17:01:13 +00002342 return getFloatingRank(CT->getElementType());
Chris Lattnera75cea32008-04-06 23:38:49 +00002343
Daniel Dunbard786f6a2009-01-05 22:14:37 +00002344 assert(T->getAsBuiltinType() && "getFloatingRank(): not a floating type");
Christopher Lambebb97e92008-02-04 02:31:56 +00002345 switch (T->getAsBuiltinType()->getKind()) {
Chris Lattnera75cea32008-04-06 23:38:49 +00002346 default: assert(0 && "getFloatingRank(): not a floating type");
Reid Spencer5f016e22007-07-11 17:01:13 +00002347 case BuiltinType::Float: return FloatRank;
2348 case BuiltinType::Double: return DoubleRank;
2349 case BuiltinType::LongDouble: return LongDoubleRank;
2350 }
2351}
2352
Steve Naroff716c7302007-08-27 01:41:48 +00002353/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
2354/// point or a complex type (based on typeDomain/typeSize).
2355/// 'typeDomain' is a real floating point or complex type.
2356/// 'typeSize' is a real floating point or complex type.
Chris Lattner1361b112008-04-06 23:58:54 +00002357QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
2358 QualType Domain) const {
2359 FloatingRank EltRank = getFloatingRank(Size);
2360 if (Domain->isComplexType()) {
2361 switch (EltRank) {
Steve Naroff716c7302007-08-27 01:41:48 +00002362 default: assert(0 && "getFloatingRank(): illegal value for rank");
Steve Narofff1448a02007-08-27 01:27:54 +00002363 case FloatRank: return FloatComplexTy;
2364 case DoubleRank: return DoubleComplexTy;
2365 case LongDoubleRank: return LongDoubleComplexTy;
2366 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002367 }
Chris Lattner1361b112008-04-06 23:58:54 +00002368
2369 assert(Domain->isRealFloatingType() && "Unknown domain!");
2370 switch (EltRank) {
2371 default: assert(0 && "getFloatingRank(): illegal value for rank");
2372 case FloatRank: return FloatTy;
2373 case DoubleRank: return DoubleTy;
2374 case LongDoubleRank: return LongDoubleTy;
Steve Narofff1448a02007-08-27 01:27:54 +00002375 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002376}
2377
Chris Lattner7cfeb082008-04-06 23:55:33 +00002378/// getFloatingTypeOrder - Compare the rank of the two specified floating
2379/// point types, ignoring the domain of the type (i.e. 'double' ==
2380/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
2381/// LHS < RHS, return -1.
Chris Lattnera75cea32008-04-06 23:38:49 +00002382int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) {
2383 FloatingRank LHSR = getFloatingRank(LHS);
2384 FloatingRank RHSR = getFloatingRank(RHS);
2385
2386 if (LHSR == RHSR)
Steve Narofffb0d4962007-08-27 15:30:22 +00002387 return 0;
Chris Lattnera75cea32008-04-06 23:38:49 +00002388 if (LHSR > RHSR)
Steve Narofffb0d4962007-08-27 15:30:22 +00002389 return 1;
2390 return -1;
Reid Spencer5f016e22007-07-11 17:01:13 +00002391}
2392
Chris Lattnerf52ab252008-04-06 22:59:24 +00002393/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
2394/// routine will assert if passed a built-in type that isn't an integer or enum,
2395/// or if it is not canonicalized.
Eli Friedmanf98aba32009-02-13 02:31:07 +00002396unsigned ASTContext::getIntegerRank(Type *T) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00002397 assert(T->isCanonical() && "T should be canonicalized");
Eli Friedmanf98aba32009-02-13 02:31:07 +00002398 if (EnumType* ET = dyn_cast<EnumType>(T))
2399 T = ET->getDecl()->getIntegerType().getTypePtr();
2400
Eli Friedmana3426752009-07-05 23:44:27 +00002401 if (T->isSpecificBuiltinType(BuiltinType::WChar))
2402 T = getFromTargetType(Target.getWCharType()).getTypePtr();
2403
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002404 if (T->isSpecificBuiltinType(BuiltinType::Char16))
2405 T = getFromTargetType(Target.getChar16Type()).getTypePtr();
2406
2407 if (T->isSpecificBuiltinType(BuiltinType::Char32))
2408 T = getFromTargetType(Target.getChar32Type()).getTypePtr();
2409
Eli Friedmanf98aba32009-02-13 02:31:07 +00002410 // There are two things which impact the integer rank: the width, and
2411 // the ordering of builtins. The builtin ordering is encoded in the
2412 // bottom three bits; the width is encoded in the bits above that.
Chris Lattner1b63e4f2009-06-14 01:54:56 +00002413 if (FixedWidthIntType* FWIT = dyn_cast<FixedWidthIntType>(T))
Eli Friedmanf98aba32009-02-13 02:31:07 +00002414 return FWIT->getWidth() << 3;
Eli Friedmanf98aba32009-02-13 02:31:07 +00002415
Chris Lattnerf52ab252008-04-06 22:59:24 +00002416 switch (cast<BuiltinType>(T)->getKind()) {
Chris Lattner7cfeb082008-04-06 23:55:33 +00002417 default: assert(0 && "getIntegerRank(): not a built-in integer");
2418 case BuiltinType::Bool:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002419 return 1 + (getIntWidth(BoolTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002420 case BuiltinType::Char_S:
2421 case BuiltinType::Char_U:
2422 case BuiltinType::SChar:
2423 case BuiltinType::UChar:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002424 return 2 + (getIntWidth(CharTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002425 case BuiltinType::Short:
2426 case BuiltinType::UShort:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002427 return 3 + (getIntWidth(ShortTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002428 case BuiltinType::Int:
2429 case BuiltinType::UInt:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002430 return 4 + (getIntWidth(IntTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002431 case BuiltinType::Long:
2432 case BuiltinType::ULong:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002433 return 5 + (getIntWidth(LongTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002434 case BuiltinType::LongLong:
2435 case BuiltinType::ULongLong:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002436 return 6 + (getIntWidth(LongLongTy) << 3);
Chris Lattner2df9ced2009-04-30 02:43:43 +00002437 case BuiltinType::Int128:
2438 case BuiltinType::UInt128:
2439 return 7 + (getIntWidth(Int128Ty) << 3);
Chris Lattnerf52ab252008-04-06 22:59:24 +00002440 }
2441}
2442
Chris Lattner7cfeb082008-04-06 23:55:33 +00002443/// getIntegerTypeOrder - Returns the highest ranked integer type:
2444/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
2445/// LHS < RHS, return -1.
2446int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00002447 Type *LHSC = getCanonicalType(LHS).getTypePtr();
2448 Type *RHSC = getCanonicalType(RHS).getTypePtr();
Chris Lattner7cfeb082008-04-06 23:55:33 +00002449 if (LHSC == RHSC) return 0;
Reid Spencer5f016e22007-07-11 17:01:13 +00002450
Chris Lattnerf52ab252008-04-06 22:59:24 +00002451 bool LHSUnsigned = LHSC->isUnsignedIntegerType();
2452 bool RHSUnsigned = RHSC->isUnsignedIntegerType();
Reid Spencer5f016e22007-07-11 17:01:13 +00002453
Chris Lattner7cfeb082008-04-06 23:55:33 +00002454 unsigned LHSRank = getIntegerRank(LHSC);
2455 unsigned RHSRank = getIntegerRank(RHSC);
Reid Spencer5f016e22007-07-11 17:01:13 +00002456
Chris Lattner7cfeb082008-04-06 23:55:33 +00002457 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
2458 if (LHSRank == RHSRank) return 0;
2459 return LHSRank > RHSRank ? 1 : -1;
2460 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002461
Chris Lattner7cfeb082008-04-06 23:55:33 +00002462 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
2463 if (LHSUnsigned) {
2464 // If the unsigned [LHS] type is larger, return it.
2465 if (LHSRank >= RHSRank)
2466 return 1;
2467
2468 // If the signed type can represent all values of the unsigned type, it
2469 // wins. Because we are dealing with 2's complement and types that are
2470 // powers of two larger than each other, this is always safe.
2471 return -1;
2472 }
Chris Lattnerf52ab252008-04-06 22:59:24 +00002473
Chris Lattner7cfeb082008-04-06 23:55:33 +00002474 // If the unsigned [RHS] type is larger, return it.
2475 if (RHSRank >= LHSRank)
2476 return -1;
2477
2478 // If the signed type can represent all values of the unsigned type, it
2479 // wins. Because we are dealing with 2's complement and types that are
2480 // powers of two larger than each other, this is always safe.
2481 return 1;
Reid Spencer5f016e22007-07-11 17:01:13 +00002482}
Anders Carlsson71993dd2007-08-17 05:31:46 +00002483
2484// getCFConstantStringType - Return the type used for constant CFStrings.
2485QualType ASTContext::getCFConstantStringType() {
2486 if (!CFConstantStringTypeDecl) {
Chris Lattner6c2b6eb2008-03-15 06:12:44 +00002487 CFConstantStringTypeDecl =
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002488 RecordDecl::Create(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00002489 &Idents.get("NSConstantString"));
Anders Carlssonf06273f2007-11-19 00:25:30 +00002490 QualType FieldTypes[4];
Anders Carlsson71993dd2007-08-17 05:31:46 +00002491
2492 // const int *isa;
2493 FieldTypes[0] = getPointerType(IntTy.getQualifiedType(QualType::Const));
Anders Carlssonf06273f2007-11-19 00:25:30 +00002494 // int flags;
2495 FieldTypes[1] = IntTy;
Anders Carlsson71993dd2007-08-17 05:31:46 +00002496 // const char *str;
Anders Carlssonf06273f2007-11-19 00:25:30 +00002497 FieldTypes[2] = getPointerType(CharTy.getQualifiedType(QualType::Const));
Anders Carlsson71993dd2007-08-17 05:31:46 +00002498 // long length;
Anders Carlssonf06273f2007-11-19 00:25:30 +00002499 FieldTypes[3] = LongTy;
Douglas Gregor44b43212008-12-11 16:49:14 +00002500
Anders Carlsson71993dd2007-08-17 05:31:46 +00002501 // Create fields
Douglas Gregor44b43212008-12-11 16:49:14 +00002502 for (unsigned i = 0; i < 4; ++i) {
2503 FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl,
2504 SourceLocation(), 0,
2505 FieldTypes[i], /*BitWidth=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002506 /*Mutable=*/false);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002507 CFConstantStringTypeDecl->addDecl(Field);
Douglas Gregor44b43212008-12-11 16:49:14 +00002508 }
2509
2510 CFConstantStringTypeDecl->completeDefinition(*this);
Anders Carlsson71993dd2007-08-17 05:31:46 +00002511 }
2512
2513 return getTagDeclType(CFConstantStringTypeDecl);
Gabor Greif84675832007-09-11 15:32:40 +00002514}
Anders Carlssonb2cf3572007-10-11 01:00:40 +00002515
Douglas Gregor319ac892009-04-23 22:29:11 +00002516void ASTContext::setCFConstantStringType(QualType T) {
Ted Kremenek6217b802009-07-29 21:53:49 +00002517 const RecordType *Rec = T->getAs<RecordType>();
Douglas Gregor319ac892009-04-23 22:29:11 +00002518 assert(Rec && "Invalid CFConstantStringType");
2519 CFConstantStringTypeDecl = Rec->getDecl();
2520}
2521
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002522QualType ASTContext::getObjCFastEnumerationStateType()
2523{
2524 if (!ObjCFastEnumerationStateTypeDecl) {
Douglas Gregor44b43212008-12-11 16:49:14 +00002525 ObjCFastEnumerationStateTypeDecl =
2526 RecordDecl::Create(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
2527 &Idents.get("__objcFastEnumerationState"));
2528
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002529 QualType FieldTypes[] = {
2530 UnsignedLongTy,
Steve Naroffde2e22d2009-07-15 18:40:39 +00002531 getPointerType(ObjCIdTypedefType),
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002532 getPointerType(UnsignedLongTy),
2533 getConstantArrayType(UnsignedLongTy,
2534 llvm::APInt(32, 5), ArrayType::Normal, 0)
2535 };
2536
Douglas Gregor44b43212008-12-11 16:49:14 +00002537 for (size_t i = 0; i < 4; ++i) {
2538 FieldDecl *Field = FieldDecl::Create(*this,
2539 ObjCFastEnumerationStateTypeDecl,
2540 SourceLocation(), 0,
2541 FieldTypes[i], /*BitWidth=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002542 /*Mutable=*/false);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002543 ObjCFastEnumerationStateTypeDecl->addDecl(Field);
Douglas Gregor44b43212008-12-11 16:49:14 +00002544 }
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002545
Douglas Gregor44b43212008-12-11 16:49:14 +00002546 ObjCFastEnumerationStateTypeDecl->completeDefinition(*this);
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002547 }
2548
2549 return getTagDeclType(ObjCFastEnumerationStateTypeDecl);
2550}
2551
Douglas Gregor319ac892009-04-23 22:29:11 +00002552void ASTContext::setObjCFastEnumerationStateType(QualType T) {
Ted Kremenek6217b802009-07-29 21:53:49 +00002553 const RecordType *Rec = T->getAs<RecordType>();
Douglas Gregor319ac892009-04-23 22:29:11 +00002554 assert(Rec && "Invalid ObjCFAstEnumerationStateType");
2555 ObjCFastEnumerationStateTypeDecl = Rec->getDecl();
2556}
2557
Anders Carlssone8c49532007-10-29 06:33:42 +00002558// This returns true if a type has been typedefed to BOOL:
2559// typedef <type> BOOL;
Chris Lattner2d998332007-10-30 20:27:44 +00002560static bool isTypeTypedefedAsBOOL(QualType T) {
Anders Carlssone8c49532007-10-29 06:33:42 +00002561 if (const TypedefType *TT = dyn_cast<TypedefType>(T))
Chris Lattnerbb49c3e2008-11-24 03:52:59 +00002562 if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
2563 return II->isStr("BOOL");
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002564
2565 return false;
2566}
2567
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002568/// getObjCEncodingTypeSize returns size of type for objective-c encoding
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002569/// purpose.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002570int ASTContext::getObjCEncodingTypeSize(QualType type) {
Chris Lattner98be4942008-03-05 18:54:05 +00002571 uint64_t sz = getTypeSize(type);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002572
2573 // Make all integer and enum types at least as large as an int
2574 if (sz > 0 && type->isIntegralType())
Chris Lattner98be4942008-03-05 18:54:05 +00002575 sz = std::max(sz, getTypeSize(IntTy));
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002576 // Treat arrays as pointers, since that's how they're passed in.
2577 else if (type->isArrayType())
Chris Lattner98be4942008-03-05 18:54:05 +00002578 sz = getTypeSize(VoidPtrTy);
2579 return sz / getTypeSize(CharTy);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002580}
2581
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002582/// getObjCEncodingForMethodDecl - Return the encoded type for this method
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002583/// declaration.
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002584void ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
Chris Lattnere6db3b02008-11-19 07:24:05 +00002585 std::string& S) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002586 // FIXME: This is not very efficient.
Fariborz Jahanianecb01e62007-11-01 17:18:37 +00002587 // Encode type qualifer, 'in', 'inout', etc. for the return type.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002588 getObjCEncodingForTypeQualifier(Decl->getObjCDeclQualifier(), S);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002589 // Encode result type.
Daniel Dunbar0d504c12008-10-17 20:21:44 +00002590 getObjCEncodingForType(Decl->getResultType(), S);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002591 // Compute size of all parameters.
2592 // Start with computing size of a pointer in number of bytes.
2593 // FIXME: There might(should) be a better way of doing this computation!
2594 SourceLocation Loc;
Chris Lattner98be4942008-03-05 18:54:05 +00002595 int PtrSize = getTypeSize(VoidPtrTy) / getTypeSize(CharTy);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002596 // The first two arguments (self and _cmd) are pointers; account for
2597 // their size.
2598 int ParmOffset = 2 * PtrSize;
Chris Lattner89951a82009-02-20 18:43:26 +00002599 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(),
2600 E = Decl->param_end(); PI != E; ++PI) {
2601 QualType PType = (*PI)->getType();
2602 int sz = getObjCEncodingTypeSize(PType);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002603 assert (sz > 0 && "getObjCEncodingForMethodDecl - Incomplete param type");
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002604 ParmOffset += sz;
2605 }
2606 S += llvm::utostr(ParmOffset);
2607 S += "@0:";
2608 S += llvm::utostr(PtrSize);
2609
2610 // Argument types.
2611 ParmOffset = 2 * PtrSize;
Chris Lattner89951a82009-02-20 18:43:26 +00002612 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(),
2613 E = Decl->param_end(); PI != E; ++PI) {
2614 ParmVarDecl *PVDecl = *PI;
Fariborz Jahanian4306d3c2008-12-20 23:29:59 +00002615 QualType PType = PVDecl->getOriginalType();
2616 if (const ArrayType *AT =
Steve Naroffab76d452009-04-14 00:03:58 +00002617 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
2618 // Use array's original type only if it has known number of
2619 // elements.
Steve Naroffbb3fde32009-04-14 00:40:09 +00002620 if (!isa<ConstantArrayType>(AT))
Steve Naroffab76d452009-04-14 00:03:58 +00002621 PType = PVDecl->getType();
2622 } else if (PType->isFunctionType())
2623 PType = PVDecl->getType();
Fariborz Jahanianecb01e62007-11-01 17:18:37 +00002624 // Process argument qualifiers for user supplied arguments; such as,
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002625 // 'in', 'inout', etc.
Fariborz Jahanian4306d3c2008-12-20 23:29:59 +00002626 getObjCEncodingForTypeQualifier(PVDecl->getObjCDeclQualifier(), S);
Daniel Dunbar0d504c12008-10-17 20:21:44 +00002627 getObjCEncodingForType(PType, S);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002628 S += llvm::utostr(ParmOffset);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002629 ParmOffset += getObjCEncodingTypeSize(PType);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002630 }
2631}
2632
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002633/// getObjCEncodingForPropertyDecl - Return the encoded type for this
Fariborz Jahanian83bccb82009-01-20 20:04:12 +00002634/// property declaration. If non-NULL, Container must be either an
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002635/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be
2636/// NULL when getting encodings for protocol properties.
Fariborz Jahanian83bccb82009-01-20 20:04:12 +00002637/// Property attributes are stored as a comma-delimited C string. The simple
2638/// attributes readonly and bycopy are encoded as single characters. The
2639/// parametrized attributes, getter=name, setter=name, and ivar=name, are
2640/// encoded as single characters, followed by an identifier. Property types
2641/// are also encoded as a parametrized attribute. The characters used to encode
2642/// these attributes are defined by the following enumeration:
2643/// @code
2644/// enum PropertyAttributes {
2645/// kPropertyReadOnly = 'R', // property is read-only.
2646/// kPropertyBycopy = 'C', // property is a copy of the value last assigned
2647/// kPropertyByref = '&', // property is a reference to the value last assigned
2648/// kPropertyDynamic = 'D', // property is dynamic
2649/// kPropertyGetter = 'G', // followed by getter selector name
2650/// kPropertySetter = 'S', // followed by setter selector name
2651/// kPropertyInstanceVariable = 'V' // followed by instance variable name
2652/// kPropertyType = 't' // followed by old-style type encoding.
2653/// kPropertyWeak = 'W' // 'weak' property
2654/// kPropertyStrong = 'P' // property GC'able
2655/// kPropertyNonAtomic = 'N' // property non-atomic
2656/// };
2657/// @endcode
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002658void ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
2659 const Decl *Container,
Chris Lattnere6db3b02008-11-19 07:24:05 +00002660 std::string& S) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002661 // Collect information from the property implementation decl(s).
2662 bool Dynamic = false;
2663 ObjCPropertyImplDecl *SynthesizePID = 0;
2664
2665 // FIXME: Duplicated code due to poor abstraction.
2666 if (Container) {
2667 if (const ObjCCategoryImplDecl *CID =
2668 dyn_cast<ObjCCategoryImplDecl>(Container)) {
2669 for (ObjCCategoryImplDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002670 i = CID->propimpl_begin(), e = CID->propimpl_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00002671 i != e; ++i) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002672 ObjCPropertyImplDecl *PID = *i;
2673 if (PID->getPropertyDecl() == PD) {
2674 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
2675 Dynamic = true;
2676 } else {
2677 SynthesizePID = PID;
2678 }
2679 }
2680 }
2681 } else {
Chris Lattner61710852008-10-05 17:34:18 +00002682 const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container);
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002683 for (ObjCCategoryImplDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002684 i = OID->propimpl_begin(), e = OID->propimpl_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00002685 i != e; ++i) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002686 ObjCPropertyImplDecl *PID = *i;
2687 if (PID->getPropertyDecl() == PD) {
2688 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
2689 Dynamic = true;
2690 } else {
2691 SynthesizePID = PID;
2692 }
2693 }
2694 }
2695 }
2696 }
2697
2698 // FIXME: This is not very efficient.
2699 S = "T";
2700
2701 // Encode result type.
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00002702 // GCC has some special rules regarding encoding of properties which
2703 // closely resembles encoding of ivars.
Daniel Dunbar153bfe52009-04-20 06:37:24 +00002704 getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0,
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00002705 true /* outermost type */,
2706 true /* encoding for property */);
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002707
2708 if (PD->isReadOnly()) {
2709 S += ",R";
2710 } else {
2711 switch (PD->getSetterKind()) {
2712 case ObjCPropertyDecl::Assign: break;
2713 case ObjCPropertyDecl::Copy: S += ",C"; break;
2714 case ObjCPropertyDecl::Retain: S += ",&"; break;
2715 }
2716 }
2717
2718 // It really isn't clear at all what this means, since properties
2719 // are "dynamic by default".
2720 if (Dynamic)
2721 S += ",D";
2722
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00002723 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
2724 S += ",N";
2725
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002726 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
2727 S += ",G";
Chris Lattner077bf5e2008-11-24 03:33:13 +00002728 S += PD->getGetterName().getAsString();
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002729 }
2730
2731 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
2732 S += ",S";
Chris Lattner077bf5e2008-11-24 03:33:13 +00002733 S += PD->getSetterName().getAsString();
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002734 }
2735
2736 if (SynthesizePID) {
2737 const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
2738 S += ",V";
Chris Lattner39f34e92008-11-24 04:00:27 +00002739 S += OID->getNameAsString();
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00002740 }
2741
2742 // FIXME: OBJCGC: weak & strong
2743}
2744
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002745/// getLegacyIntegralTypeEncoding -
2746/// Another legacy compatibility encoding: 32-bit longs are encoded as
Fariborz Jahanianc657eba2009-02-11 23:59:18 +00002747/// 'l' or 'L' , but not always. For typedefs, we need to use
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002748/// 'i' or 'I' instead if encoding a struct field, or a pointer!
2749///
2750void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const {
Mike Stump8e1fab22009-07-22 18:58:19 +00002751 if (isa<TypedefType>(PointeeTy.getTypePtr())) {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002752 if (const BuiltinType *BT = PointeeTy->getAsBuiltinType()) {
Fariborz Jahanianc657eba2009-02-11 23:59:18 +00002753 if (BT->getKind() == BuiltinType::ULong &&
2754 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32))
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002755 PointeeTy = UnsignedIntTy;
Fariborz Jahanianc657eba2009-02-11 23:59:18 +00002756 else
2757 if (BT->getKind() == BuiltinType::Long &&
2758 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32))
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002759 PointeeTy = IntTy;
2760 }
2761 }
2762}
2763
Fariborz Jahanian7d6b46d2008-01-22 22:44:46 +00002764void ASTContext::getObjCEncodingForType(QualType T, std::string& S,
Daniel Dunbar153bfe52009-04-20 06:37:24 +00002765 const FieldDecl *Field) {
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00002766 // We follow the behavior of gcc, expanding structures which are
2767 // directly pointed to, and expanding embedded structures. Note that
2768 // these rules are sufficient to prevent recursive encoding of the
2769 // same type.
Fariborz Jahanian5b8c7d92008-12-22 23:22:27 +00002770 getObjCEncodingForTypeImpl(T, S, true, true, Field,
2771 true /* outermost type */);
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00002772}
2773
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00002774static void EncodeBitField(const ASTContext *Context, std::string& S,
Daniel Dunbar153bfe52009-04-20 06:37:24 +00002775 const FieldDecl *FD) {
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00002776 const Expr *E = FD->getBitWidth();
2777 assert(E && "bitfield width not there - getObjCEncodingForTypeImpl");
2778 ASTContext *Ctx = const_cast<ASTContext*>(Context);
Eli Friedman9a901bb2009-04-26 19:19:15 +00002779 unsigned N = E->EvaluateAsInt(*Ctx).getZExtValue();
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00002780 S += 'b';
2781 S += llvm::utostr(N);
2782}
2783
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00002784void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S,
2785 bool ExpandPointedToStructures,
2786 bool ExpandStructures,
Daniel Dunbar153bfe52009-04-20 06:37:24 +00002787 const FieldDecl *FD,
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00002788 bool OutermostType,
Douglas Gregor6ab35242009-04-09 21:40:53 +00002789 bool EncodingProperty) {
Anders Carlssone8c49532007-10-29 06:33:42 +00002790 if (const BuiltinType *BT = T->getAsBuiltinType()) {
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002791 if (FD && FD->isBitField())
2792 return EncodeBitField(this, S, FD);
2793 char encoding;
2794 switch (BT->getKind()) {
2795 default: assert(0 && "Unhandled builtin type kind");
2796 case BuiltinType::Void: encoding = 'v'; break;
2797 case BuiltinType::Bool: encoding = 'B'; break;
2798 case BuiltinType::Char_U:
2799 case BuiltinType::UChar: encoding = 'C'; break;
2800 case BuiltinType::UShort: encoding = 'S'; break;
2801 case BuiltinType::UInt: encoding = 'I'; break;
2802 case BuiltinType::ULong:
Fariborz Jahanian72696e12009-02-11 22:31:45 +00002803 encoding =
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002804 (const_cast<ASTContext *>(this))->getIntWidth(T) == 32 ? 'L' : 'Q';
Fariborz Jahanian72696e12009-02-11 22:31:45 +00002805 break;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002806 case BuiltinType::UInt128: encoding = 'T'; break;
2807 case BuiltinType::ULongLong: encoding = 'Q'; break;
2808 case BuiltinType::Char_S:
2809 case BuiltinType::SChar: encoding = 'c'; break;
2810 case BuiltinType::Short: encoding = 's'; break;
2811 case BuiltinType::Int: encoding = 'i'; break;
2812 case BuiltinType::Long:
2813 encoding =
2814 (const_cast<ASTContext *>(this))->getIntWidth(T) == 32 ? 'l' : 'q';
2815 break;
2816 case BuiltinType::LongLong: encoding = 'q'; break;
2817 case BuiltinType::Int128: encoding = 't'; break;
2818 case BuiltinType::Float: encoding = 'f'; break;
2819 case BuiltinType::Double: encoding = 'd'; break;
2820 case BuiltinType::LongDouble: encoding = 'd'; break;
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002821 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002822
2823 S += encoding;
2824 return;
2825 }
2826
2827 if (const ComplexType *CT = T->getAsComplexType()) {
Anders Carlssonc612f7b2009-04-09 21:55:45 +00002828 S += 'j';
2829 getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false,
2830 false);
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002831 return;
2832 }
2833
Ted Kremenek6217b802009-07-29 21:53:49 +00002834 if (const PointerType *PT = T->getAs<PointerType>()) {
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002835 QualType PointeeTy = PT->getPointeeType();
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002836 bool isReadOnly = false;
2837 // For historical/compatibility reasons, the read-only qualifier of the
2838 // pointee gets emitted _before_ the '^'. The read-only qualifier of
2839 // the pointer itself gets ignored, _unless_ we are looking at a typedef!
2840 // Also, do not emit the 'r' for anything but the outermost type!
Mike Stump8e1fab22009-07-22 18:58:19 +00002841 if (isa<TypedefType>(T.getTypePtr())) {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002842 if (OutermostType && T.isConstQualified()) {
2843 isReadOnly = true;
2844 S += 'r';
2845 }
Mike Stump9fdbab32009-07-31 02:02:20 +00002846 } else if (OutermostType) {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002847 QualType P = PointeeTy;
Ted Kremenek6217b802009-07-29 21:53:49 +00002848 while (P->getAs<PointerType>())
2849 P = P->getAs<PointerType>()->getPointeeType();
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002850 if (P.isConstQualified()) {
2851 isReadOnly = true;
2852 S += 'r';
2853 }
2854 }
2855 if (isReadOnly) {
2856 // Another legacy compatibility encoding. Some ObjC qualifier and type
2857 // combinations need to be rearranged.
2858 // Rewrite "in const" from "nr" to "rn"
2859 const char * s = S.c_str();
2860 int len = S.length();
2861 if (len >= 2 && s[len-2] == 'n' && s[len-1] == 'r') {
2862 std::string replace = "rn";
2863 S.replace(S.end()-2, S.end(), replace);
2864 }
2865 }
Steve Naroff14108da2009-07-10 23:34:53 +00002866 if (isObjCSelType(PointeeTy)) {
Anders Carlsson8baaca52007-10-31 02:53:19 +00002867 S += ':';
2868 return;
Fariborz Jahanianc2939bc2007-10-30 17:06:23 +00002869 }
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002870
2871 if (PointeeTy->isCharType()) {
2872 // char pointer types should be encoded as '*' unless it is a
2873 // type that has been typedef'd to 'BOOL'.
Anders Carlssone8c49532007-10-29 06:33:42 +00002874 if (!isTypeTypedefedAsBOOL(PointeeTy)) {
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002875 S += '*';
2876 return;
2877 }
Ted Kremenek6217b802009-07-29 21:53:49 +00002878 } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) {
Steve Naroff9533a7f2009-07-22 17:14:51 +00002879 // GCC binary compat: Need to convert "struct objc_class *" to "#".
2880 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
2881 S += '#';
2882 return;
2883 }
2884 // GCC binary compat: Need to convert "struct objc_object *" to "@".
2885 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
2886 S += '@';
2887 return;
2888 }
2889 // fall through...
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002890 }
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002891 S += '^';
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002892 getLegacyIntegralTypeEncoding(PointeeTy);
2893
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002894 getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures,
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002895 NULL);
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002896 return;
2897 }
2898
2899 if (const ArrayType *AT =
2900 // Ignore type qualifiers etc.
2901 dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) {
Anders Carlsson559a8332009-02-22 01:38:57 +00002902 if (isa<IncompleteArrayType>(AT)) {
2903 // Incomplete arrays are encoded as a pointer to the array element.
2904 S += '^';
2905
2906 getObjCEncodingForTypeImpl(AT->getElementType(), S,
2907 false, ExpandStructures, FD);
2908 } else {
2909 S += '[';
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002910
Anders Carlsson559a8332009-02-22 01:38:57 +00002911 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
2912 S += llvm::utostr(CAT->getSize().getZExtValue());
2913 else {
2914 //Variable length arrays are encoded as a regular array with 0 elements.
2915 assert(isa<VariableArrayType>(AT) && "Unknown array type!");
2916 S += '0';
2917 }
Anders Carlsson85f9bce2007-10-29 05:01:08 +00002918
Anders Carlsson559a8332009-02-22 01:38:57 +00002919 getObjCEncodingForTypeImpl(AT->getElementType(), S,
2920 false, ExpandStructures, FD);
2921 S += ']';
2922 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002923 return;
2924 }
2925
2926 if (T->getAsFunctionType()) {
Anders Carlssonc0a87b72007-10-30 00:06:20 +00002927 S += '?';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002928 return;
2929 }
2930
Ted Kremenek6217b802009-07-29 21:53:49 +00002931 if (const RecordType *RTy = T->getAs<RecordType>()) {
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00002932 RecordDecl *RDecl = RTy->getDecl();
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002933 S += RDecl->isUnion() ? '(' : '{';
Daniel Dunbar502a4a12008-10-17 06:22:57 +00002934 // Anonymous structures print as '?'
2935 if (const IdentifierInfo *II = RDecl->getIdentifier()) {
2936 S += II->getName();
2937 } else {
2938 S += '?';
2939 }
Daniel Dunbar0d504c12008-10-17 20:21:44 +00002940 if (ExpandStructures) {
Fariborz Jahanian7d6b46d2008-01-22 22:44:46 +00002941 S += '=';
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002942 for (RecordDecl::field_iterator Field = RDecl->field_begin(),
2943 FieldEnd = RDecl->field_end();
Douglas Gregor44b43212008-12-11 16:49:14 +00002944 Field != FieldEnd; ++Field) {
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002945 if (FD) {
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002946 S += '"';
Douglas Gregor44b43212008-12-11 16:49:14 +00002947 S += Field->getNameAsString();
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002948 S += '"';
2949 }
2950
2951 // Special case bit-fields.
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002952 if (Field->isBitField()) {
2953 getObjCEncodingForTypeImpl(Field->getType(), S, false, true,
2954 (*Field));
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002955 } else {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00002956 QualType qt = Field->getType();
2957 getLegacyIntegralTypeEncoding(qt);
2958 getObjCEncodingForTypeImpl(qt, S, false, true,
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002959 FD);
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002960 }
Fariborz Jahanian7d6b46d2008-01-22 22:44:46 +00002961 }
Fariborz Jahanian6de88a82007-11-13 23:21:38 +00002962 }
Daniel Dunbard96b35b2008-10-17 16:17:37 +00002963 S += RDecl->isUnion() ? ')' : '}';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002964 return;
2965 }
2966
2967 if (T->isEnumeralType()) {
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00002968 if (FD && FD->isBitField())
2969 EncodeBitField(this, S, FD);
2970 else
2971 S += 'i';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002972 return;
2973 }
2974
2975 if (T->isBlockPointerType()) {
Steve Naroff21a98b12009-02-02 18:24:29 +00002976 S += "@?"; // Unlike a pointer-to-function, which is "^?".
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002977 return;
2978 }
2979
2980 if (T->isObjCInterfaceType()) {
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002981 // @encode(class_name)
2982 ObjCInterfaceDecl *OI = T->getAsObjCInterfaceType()->getDecl();
2983 S += '{';
2984 const IdentifierInfo *II = OI->getIdentifier();
2985 S += II->getName();
2986 S += '=';
Chris Lattnerf1690852009-03-31 08:48:01 +00002987 llvm::SmallVector<FieldDecl*, 32> RecFields;
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002988 CollectObjCIvars(OI, RecFields);
Chris Lattnerf1690852009-03-31 08:48:01 +00002989 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002990 if (RecFields[i]->isBitField())
2991 getObjCEncodingForTypeImpl(RecFields[i]->getType(), S, false, true,
2992 RecFields[i]);
2993 else
2994 getObjCEncodingForTypeImpl(RecFields[i]->getType(), S, false, true,
2995 FD);
2996 }
2997 S += '}';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00002998 return;
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00002999 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003000
3001 if (const ObjCObjectPointerType *OPT = T->getAsObjCObjectPointerType()) {
Steve Naroff14108da2009-07-10 23:34:53 +00003002 if (OPT->isObjCIdType()) {
3003 S += '@';
3004 return;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003005 }
3006
3007 if (OPT->isObjCClassType()) {
Steve Naroff14108da2009-07-10 23:34:53 +00003008 S += '#';
3009 return;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003010 }
3011
3012 if (OPT->isObjCQualifiedIdType()) {
Steve Naroff14108da2009-07-10 23:34:53 +00003013 getObjCEncodingForTypeImpl(getObjCIdType(), S,
3014 ExpandPointedToStructures,
3015 ExpandStructures, FD);
3016 if (FD || EncodingProperty) {
3017 // Note that we do extended encoding of protocol qualifer list
3018 // Only when doing ivar or property encoding.
Steve Naroff14108da2009-07-10 23:34:53 +00003019 S += '"';
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003020 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
3021 E = OPT->qual_end(); I != E; ++I) {
Steve Naroff14108da2009-07-10 23:34:53 +00003022 S += '<';
3023 S += (*I)->getNameAsString();
3024 S += '>';
3025 }
3026 S += '"';
3027 }
3028 return;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003029 }
3030
3031 QualType PointeeTy = OPT->getPointeeType();
3032 if (!EncodingProperty &&
3033 isa<TypedefType>(PointeeTy.getTypePtr())) {
3034 // Another historical/compatibility reason.
3035 // We encode the underlying type which comes out as
3036 // {...};
3037 S += '^';
3038 getObjCEncodingForTypeImpl(PointeeTy, S,
3039 false, ExpandPointedToStructures,
3040 NULL);
Steve Naroff14108da2009-07-10 23:34:53 +00003041 return;
3042 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003043
3044 S += '@';
3045 if (FD || EncodingProperty) {
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003046 S += '"';
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003047 S += OPT->getInterfaceDecl()->getNameAsCString();
3048 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
3049 E = OPT->qual_end(); I != E; ++I) {
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003050 S += '<';
3051 S += (*I)->getNameAsString();
3052 S += '>';
3053 }
3054 S += '"';
3055 }
3056 return;
3057 }
3058
3059 assert(0 && "@encode for type not implemented!");
Anders Carlsson85f9bce2007-10-29 05:01:08 +00003060}
3061
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003062void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
Fariborz Jahanianecb01e62007-11-01 17:18:37 +00003063 std::string& S) const {
3064 if (QT & Decl::OBJC_TQ_In)
3065 S += 'n';
3066 if (QT & Decl::OBJC_TQ_Inout)
3067 S += 'N';
3068 if (QT & Decl::OBJC_TQ_Out)
3069 S += 'o';
3070 if (QT & Decl::OBJC_TQ_Bycopy)
3071 S += 'O';
3072 if (QT & Decl::OBJC_TQ_Byref)
3073 S += 'R';
3074 if (QT & Decl::OBJC_TQ_Oneway)
3075 S += 'V';
3076}
3077
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003078void ASTContext::setBuiltinVaListType(QualType T) {
Anders Carlssonb2cf3572007-10-11 01:00:40 +00003079 assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!");
3080
3081 BuiltinVaListType = T;
3082}
3083
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003084void ASTContext::setObjCIdType(QualType T) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00003085 ObjCIdTypedefType = T;
Steve Naroff7e219e42007-10-15 14:41:52 +00003086}
3087
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003088void ASTContext::setObjCSelType(QualType T) {
Douglas Gregor319ac892009-04-23 22:29:11 +00003089 ObjCSelType = T;
3090
3091 const TypedefType *TT = T->getAsTypedefType();
3092 if (!TT)
3093 return;
3094 TypedefDecl *TD = TT->getDecl();
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00003095
3096 // typedef struct objc_selector *SEL;
Ted Kremenek6217b802009-07-29 21:53:49 +00003097 const PointerType *ptr = TD->getUnderlyingType()->getAs<PointerType>();
Fariborz Jahanianc55a2402009-01-16 19:58:32 +00003098 if (!ptr)
3099 return;
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00003100 const RecordType *rec = ptr->getPointeeType()->getAsStructureType();
Fariborz Jahanianc55a2402009-01-16 19:58:32 +00003101 if (!rec)
3102 return;
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00003103 SelStructType = rec;
3104}
3105
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003106void ASTContext::setObjCProtoType(QualType QT) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003107 ObjCProtoType = QT;
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00003108}
3109
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003110void ASTContext::setObjCClassType(QualType T) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00003111 ObjCClassTypedefType = T;
Anders Carlsson8baaca52007-10-31 02:53:19 +00003112}
3113
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003114void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) {
3115 assert(ObjCConstantStringType.isNull() &&
Steve Naroff21988912007-10-15 23:35:17 +00003116 "'NSConstantString' type already set!");
3117
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003118 ObjCConstantStringType = getObjCInterfaceType(Decl);
Steve Naroff21988912007-10-15 23:35:17 +00003119}
3120
Douglas Gregor7532dc62009-03-30 22:58:21 +00003121/// \brief Retrieve the template name that represents a qualified
3122/// template name such as \c std::vector.
3123TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
3124 bool TemplateKeyword,
3125 TemplateDecl *Template) {
3126 llvm::FoldingSetNodeID ID;
3127 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
3128
3129 void *InsertPos = 0;
3130 QualifiedTemplateName *QTN =
3131 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
3132 if (!QTN) {
3133 QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template);
3134 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
3135 }
3136
3137 return TemplateName(QTN);
3138}
3139
Douglas Gregord99cbe62009-07-29 18:26:50 +00003140/// \brief Retrieve the template name that represents a qualified
3141/// template name such as \c std::vector.
3142TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
3143 bool TemplateKeyword,
3144 OverloadedFunctionDecl *Template) {
3145 llvm::FoldingSetNodeID ID;
3146 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
3147
3148 void *InsertPos = 0;
3149 QualifiedTemplateName *QTN =
3150 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
3151 if (!QTN) {
3152 QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template);
3153 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
3154 }
3155
3156 return TemplateName(QTN);
3157}
3158
Douglas Gregor7532dc62009-03-30 22:58:21 +00003159/// \brief Retrieve the template name that represents a dependent
3160/// template name such as \c MetaFun::template apply.
3161TemplateName ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
3162 const IdentifierInfo *Name) {
3163 assert(NNS->isDependent() && "Nested name specifier must be dependent");
3164
3165 llvm::FoldingSetNodeID ID;
3166 DependentTemplateName::Profile(ID, NNS, Name);
3167
3168 void *InsertPos = 0;
3169 DependentTemplateName *QTN =
3170 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
3171
3172 if (QTN)
3173 return TemplateName(QTN);
3174
3175 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
3176 if (CanonNNS == NNS) {
3177 QTN = new (*this,4) DependentTemplateName(NNS, Name);
3178 } else {
3179 TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
3180 QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon);
3181 }
3182
3183 DependentTemplateNames.InsertNode(QTN, InsertPos);
3184 return TemplateName(QTN);
3185}
3186
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003187/// getFromTargetType - Given one of the integer types provided by
Douglas Gregord9341122008-11-03 15:57:00 +00003188/// TargetInfo, produce the corresponding type. The unsigned @p Type
3189/// is actually a value of type @c TargetInfo::IntType.
3190QualType ASTContext::getFromTargetType(unsigned Type) const {
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003191 switch (Type) {
3192 case TargetInfo::NoInt: return QualType();
3193 case TargetInfo::SignedShort: return ShortTy;
3194 case TargetInfo::UnsignedShort: return UnsignedShortTy;
3195 case TargetInfo::SignedInt: return IntTy;
3196 case TargetInfo::UnsignedInt: return UnsignedIntTy;
3197 case TargetInfo::SignedLong: return LongTy;
3198 case TargetInfo::UnsignedLong: return UnsignedLongTy;
3199 case TargetInfo::SignedLongLong: return LongLongTy;
3200 case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy;
3201 }
3202
3203 assert(false && "Unhandled TargetInfo::IntType value");
Daniel Dunbarb3ac5432008-11-11 01:16:00 +00003204 return QualType();
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003205}
Ted Kremenekb6ccaac2008-07-24 23:58:27 +00003206
3207//===----------------------------------------------------------------------===//
3208// Type Predicates.
3209//===----------------------------------------------------------------------===//
3210
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003211/// isObjCNSObjectType - Return true if this is an NSObject object using
3212/// NSObject attribute on a c-style pointer type.
3213/// FIXME - Make it work directly on types.
Steve Narofff4954562009-07-16 15:41:00 +00003214/// FIXME: Move to Type.
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003215///
3216bool ASTContext::isObjCNSObjectType(QualType Ty) const {
3217 if (TypedefType *TDT = dyn_cast<TypedefType>(Ty)) {
3218 if (TypedefDecl *TD = TDT->getDecl())
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00003219 if (TD->getAttr<ObjCNSObjectAttr>())
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003220 return true;
3221 }
3222 return false;
3223}
3224
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003225/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
3226/// garbage collection attribute.
3227///
3228QualType::GCAttrTypes ASTContext::getObjCGCAttrKind(const QualType &Ty) const {
Chris Lattnerb7d25532009-02-18 22:53:11 +00003229 QualType::GCAttrTypes GCAttrs = QualType::GCNone;
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003230 if (getLangOptions().ObjC1 &&
3231 getLangOptions().getGCMode() != LangOptions::NonGC) {
Chris Lattnerb7d25532009-02-18 22:53:11 +00003232 GCAttrs = Ty.getObjCGCAttr();
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003233 // Default behavious under objective-c's gc is for objective-c pointers
Fariborz Jahaniana223cca2009-02-19 23:36:06 +00003234 // (or pointers to them) be treated as though they were declared
3235 // as __strong.
3236 if (GCAttrs == QualType::GCNone) {
Steve Narofff4954562009-07-16 15:41:00 +00003237 if (Ty->isObjCObjectPointerType())
Fariborz Jahaniana223cca2009-02-19 23:36:06 +00003238 GCAttrs = QualType::Strong;
3239 else if (Ty->isPointerType())
Ted Kremenek6217b802009-07-29 21:53:49 +00003240 return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType());
Fariborz Jahaniana223cca2009-02-19 23:36:06 +00003241 }
Fariborz Jahanianc2112182009-04-11 00:00:54 +00003242 // Non-pointers have none gc'able attribute regardless of the attribute
3243 // set on them.
Steve Narofff4954562009-07-16 15:41:00 +00003244 else if (!Ty->isAnyPointerType() && !Ty->isBlockPointerType())
Fariborz Jahanianc2112182009-04-11 00:00:54 +00003245 return QualType::GCNone;
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003246 }
Chris Lattnerb7d25532009-02-18 22:53:11 +00003247 return GCAttrs;
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003248}
3249
Chris Lattner6ac46a42008-04-07 06:51:04 +00003250//===----------------------------------------------------------------------===//
3251// Type Compatibility Testing
3252//===----------------------------------------------------------------------===//
Chris Lattner770951b2007-11-01 05:03:41 +00003253
Chris Lattner6ac46a42008-04-07 06:51:04 +00003254/// areCompatVectorTypes - Return true if the two specified vector types are
3255/// compatible.
3256static bool areCompatVectorTypes(const VectorType *LHS,
3257 const VectorType *RHS) {
3258 assert(LHS->isCanonical() && RHS->isCanonical());
3259 return LHS->getElementType() == RHS->getElementType() &&
Chris Lattner61710852008-10-05 17:34:18 +00003260 LHS->getNumElements() == RHS->getNumElements();
Chris Lattner6ac46a42008-04-07 06:51:04 +00003261}
3262
Steve Naroff4084c302009-07-23 01:01:38 +00003263//===----------------------------------------------------------------------===//
3264// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
3265//===----------------------------------------------------------------------===//
3266
3267/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
3268/// inheritance hierarchy of 'rProto'.
3269static bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
3270 ObjCProtocolDecl *rProto) {
3271 if (lProto == rProto)
3272 return true;
3273 for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(),
3274 E = rProto->protocol_end(); PI != E; ++PI)
3275 if (ProtocolCompatibleWithProtocol(lProto, *PI))
3276 return true;
3277 return false;
3278}
3279
3280/// ClassImplementsProtocol - Checks that 'lProto' protocol
3281/// has been implemented in IDecl class, its super class or categories (if
3282/// lookupCategory is true).
3283static bool ClassImplementsProtocol(ObjCProtocolDecl *lProto,
3284 ObjCInterfaceDecl *IDecl,
3285 bool lookupCategory,
3286 bool RHSIsQualifiedID = false) {
3287
3288 // 1st, look up the class.
3289 const ObjCList<ObjCProtocolDecl> &Protocols =
3290 IDecl->getReferencedProtocols();
3291
3292 for (ObjCList<ObjCProtocolDecl>::iterator PI = Protocols.begin(),
3293 E = Protocols.end(); PI != E; ++PI) {
3294 if (ProtocolCompatibleWithProtocol(lProto, *PI))
3295 return true;
3296 // This is dubious and is added to be compatible with gcc. In gcc, it is
3297 // also allowed assigning a protocol-qualified 'id' type to a LHS object
3298 // when protocol in qualified LHS is in list of protocols in the rhs 'id'
3299 // object. This IMO, should be a bug.
3300 // FIXME: Treat this as an extension, and flag this as an error when GCC
3301 // extensions are not enabled.
3302 if (RHSIsQualifiedID && ProtocolCompatibleWithProtocol(*PI, lProto))
3303 return true;
3304 }
3305
3306 // 2nd, look up the category.
3307 if (lookupCategory)
3308 for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl;
3309 CDecl = CDecl->getNextClassCategory()) {
3310 for (ObjCCategoryDecl::protocol_iterator PI = CDecl->protocol_begin(),
3311 E = CDecl->protocol_end(); PI != E; ++PI)
3312 if (ProtocolCompatibleWithProtocol(lProto, *PI))
3313 return true;
3314 }
3315
3316 // 3rd, look up the super class(s)
3317 if (IDecl->getSuperClass())
3318 return
3319 ClassImplementsProtocol(lProto, IDecl->getSuperClass(), lookupCategory,
3320 RHSIsQualifiedID);
3321
3322 return false;
3323}
3324
3325/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...>
3326/// return true if lhs's protocols conform to rhs's protocol; false
3327/// otherwise.
3328bool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) {
3329 if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType())
3330 return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false);
3331 return false;
3332}
3333
3334/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
3335/// ObjCQualifiedIDType.
3336bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs,
3337 bool compare) {
3338 // Allow id<P..> and an 'id' or void* type in all cases.
3339 if (lhs->isVoidPointerType() ||
3340 lhs->isObjCIdType() || lhs->isObjCClassType())
3341 return true;
3342 else if (rhs->isVoidPointerType() ||
3343 rhs->isObjCIdType() || rhs->isObjCClassType())
3344 return true;
3345
3346 if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) {
3347 const ObjCObjectPointerType *rhsOPT = rhs->getAsObjCObjectPointerType();
3348
3349 if (!rhsOPT) return false;
3350
3351 if (rhsOPT->qual_empty()) {
3352 // If the RHS is a unqualified interface pointer "NSString*",
3353 // make sure we check the class hierarchy.
3354 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
3355 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
3356 E = lhsQID->qual_end(); I != E; ++I) {
3357 // when comparing an id<P> on lhs with a static type on rhs,
3358 // see if static class implements all of id's protocols, directly or
3359 // through its super class and categories.
3360 if (!ClassImplementsProtocol(*I, rhsID, true))
3361 return false;
3362 }
3363 }
3364 // If there are no qualifiers and no interface, we have an 'id'.
3365 return true;
3366 }
3367 // Both the right and left sides have qualifiers.
3368 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
3369 E = lhsQID->qual_end(); I != E; ++I) {
3370 ObjCProtocolDecl *lhsProto = *I;
3371 bool match = false;
3372
3373 // when comparing an id<P> on lhs with a static type on rhs,
3374 // see if static class implements all of id's protocols, directly or
3375 // through its super class and categories.
3376 for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(),
3377 E = rhsOPT->qual_end(); J != E; ++J) {
3378 ObjCProtocolDecl *rhsProto = *J;
3379 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
3380 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
3381 match = true;
3382 break;
3383 }
3384 }
3385 // If the RHS is a qualified interface pointer "NSString<P>*",
3386 // make sure we check the class hierarchy.
3387 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
3388 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
3389 E = lhsQID->qual_end(); I != E; ++I) {
3390 // when comparing an id<P> on lhs with a static type on rhs,
3391 // see if static class implements all of id's protocols, directly or
3392 // through its super class and categories.
3393 if (ClassImplementsProtocol(*I, rhsID, true)) {
3394 match = true;
3395 break;
3396 }
3397 }
3398 }
3399 if (!match)
3400 return false;
3401 }
3402
3403 return true;
3404 }
3405
3406 const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType();
3407 assert(rhsQID && "One of the LHS/RHS should be id<x>");
3408
3409 if (const ObjCObjectPointerType *lhsOPT =
3410 lhs->getAsObjCInterfacePointerType()) {
3411 if (lhsOPT->qual_empty()) {
3412 bool match = false;
3413 if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) {
3414 for (ObjCObjectPointerType::qual_iterator I = rhsQID->qual_begin(),
3415 E = rhsQID->qual_end(); I != E; ++I) {
3416 // when comparing an id<P> on lhs with a static type on rhs,
3417 // see if static class implements all of id's protocols, directly or
3418 // through its super class and categories.
3419 if (ClassImplementsProtocol(*I, lhsID, true)) {
3420 match = true;
3421 break;
3422 }
3423 }
3424 if (!match)
3425 return false;
3426 }
3427 return true;
3428 }
3429 // Both the right and left sides have qualifiers.
3430 for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(),
3431 E = lhsOPT->qual_end(); I != E; ++I) {
3432 ObjCProtocolDecl *lhsProto = *I;
3433 bool match = false;
3434
3435 // when comparing an id<P> on lhs with a static type on rhs,
3436 // see if static class implements all of id's protocols, directly or
3437 // through its super class and categories.
3438 for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(),
3439 E = rhsQID->qual_end(); J != E; ++J) {
3440 ObjCProtocolDecl *rhsProto = *J;
3441 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
3442 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
3443 match = true;
3444 break;
3445 }
3446 }
3447 if (!match)
3448 return false;
3449 }
3450 return true;
3451 }
3452 return false;
3453}
3454
Eli Friedman3d815e72008-08-22 00:56:42 +00003455/// canAssignObjCInterfaces - Return true if the two interface types are
Chris Lattner6ac46a42008-04-07 06:51:04 +00003456/// compatible for assignment from RHS to LHS. This handles validation of any
3457/// protocol qualifiers on the LHS or RHS.
3458///
Steve Naroff14108da2009-07-10 23:34:53 +00003459bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
3460 const ObjCObjectPointerType *RHSOPT) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00003461 // If either type represents the built-in 'id' or 'Class' types, return true.
3462 if (LHSOPT->isObjCBuiltinType() || RHSOPT->isObjCBuiltinType())
Steve Naroff14108da2009-07-10 23:34:53 +00003463 return true;
3464
Steve Naroff4084c302009-07-23 01:01:38 +00003465 if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
3466 return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
3467 QualType(RHSOPT,0),
3468 false);
3469
Steve Naroff14108da2009-07-10 23:34:53 +00003470 const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
3471 const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
Steve Naroff4084c302009-07-23 01:01:38 +00003472 if (LHS && RHS) // We have 2 user-defined types.
3473 return canAssignObjCInterfaces(LHS, RHS);
3474
3475 return false;
Steve Naroff14108da2009-07-10 23:34:53 +00003476}
3477
Eli Friedman3d815e72008-08-22 00:56:42 +00003478bool ASTContext::canAssignObjCInterfaces(const ObjCInterfaceType *LHS,
3479 const ObjCInterfaceType *RHS) {
Chris Lattner6ac46a42008-04-07 06:51:04 +00003480 // Verify that the base decls are compatible: the RHS must be a subclass of
3481 // the LHS.
3482 if (!LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
3483 return false;
3484
3485 // RHS must have a superset of the protocols in the LHS. If the LHS is not
3486 // protocol qualified at all, then we are good.
Steve Naroffc15cb2a2009-07-18 15:33:26 +00003487 if (LHS->getNumProtocols() == 0)
Chris Lattner6ac46a42008-04-07 06:51:04 +00003488 return true;
3489
3490 // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, then it
3491 // isn't a superset.
Steve Naroffc15cb2a2009-07-18 15:33:26 +00003492 if (RHS->getNumProtocols() == 0)
Chris Lattner6ac46a42008-04-07 06:51:04 +00003493 return true; // FIXME: should return false!
3494
Steve Naroffc15cb2a2009-07-18 15:33:26 +00003495 for (ObjCInterfaceType::qual_iterator LHSPI = LHS->qual_begin(),
3496 LHSPE = LHS->qual_end();
Steve Naroff91b0b0c2009-03-01 16:12:44 +00003497 LHSPI != LHSPE; LHSPI++) {
3498 bool RHSImplementsProtocol = false;
3499
3500 // If the RHS doesn't implement the protocol on the left, the types
3501 // are incompatible.
Steve Naroffc15cb2a2009-07-18 15:33:26 +00003502 for (ObjCInterfaceType::qual_iterator RHSPI = RHS->qual_begin(),
Steve Naroff4084c302009-07-23 01:01:38 +00003503 RHSPE = RHS->qual_end();
Steve Naroff8f167562009-07-16 16:21:02 +00003504 RHSPI != RHSPE; RHSPI++) {
3505 if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) {
Steve Naroff91b0b0c2009-03-01 16:12:44 +00003506 RHSImplementsProtocol = true;
Steve Naroff8f167562009-07-16 16:21:02 +00003507 break;
3508 }
Steve Naroff91b0b0c2009-03-01 16:12:44 +00003509 }
3510 // FIXME: For better diagnostics, consider passing back the protocol name.
3511 if (!RHSImplementsProtocol)
3512 return false;
Chris Lattner6ac46a42008-04-07 06:51:04 +00003513 }
Steve Naroff91b0b0c2009-03-01 16:12:44 +00003514 // The RHS implements all protocols listed on the LHS.
3515 return true;
Chris Lattner6ac46a42008-04-07 06:51:04 +00003516}
3517
Steve Naroff389bf462009-02-12 17:52:19 +00003518bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) {
3519 // get the "pointed to" types
Steve Naroff14108da2009-07-10 23:34:53 +00003520 const ObjCObjectPointerType *LHSOPT = LHS->getAsObjCObjectPointerType();
3521 const ObjCObjectPointerType *RHSOPT = RHS->getAsObjCObjectPointerType();
Steve Naroff389bf462009-02-12 17:52:19 +00003522
Steve Naroff14108da2009-07-10 23:34:53 +00003523 if (!LHSOPT || !RHSOPT)
Steve Naroff389bf462009-02-12 17:52:19 +00003524 return false;
Steve Naroff14108da2009-07-10 23:34:53 +00003525
3526 return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
3527 canAssignObjCInterfaces(RHSOPT, LHSOPT);
Steve Naroff389bf462009-02-12 17:52:19 +00003528}
3529
Steve Naroffec0550f2007-10-15 20:41:53 +00003530/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,
3531/// both shall have the identically qualified version of a compatible type.
3532/// C99 6.2.7p1: Two types have compatible types if their types are the
3533/// same. See 6.7.[2,3,5] for additional rules.
Eli Friedman3d815e72008-08-22 00:56:42 +00003534bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS) {
3535 return !mergeTypes(LHS, RHS).isNull();
3536}
3537
3538QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs) {
3539 const FunctionType *lbase = lhs->getAsFunctionType();
3540 const FunctionType *rbase = rhs->getAsFunctionType();
Douglas Gregor72564e72009-02-26 23:50:07 +00003541 const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
3542 const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
Eli Friedman3d815e72008-08-22 00:56:42 +00003543 bool allLTypes = true;
3544 bool allRTypes = true;
3545
3546 // Check return type
3547 QualType retType = mergeTypes(lbase->getResultType(), rbase->getResultType());
3548 if (retType.isNull()) return QualType();
Chris Lattner61710852008-10-05 17:34:18 +00003549 if (getCanonicalType(retType) != getCanonicalType(lbase->getResultType()))
3550 allLTypes = false;
3551 if (getCanonicalType(retType) != getCanonicalType(rbase->getResultType()))
3552 allRTypes = false;
Mike Stump6dcbc292009-07-25 23:24:03 +00003553 // FIXME: double check this
Mike Stump24556362009-07-25 21:26:53 +00003554 bool NoReturn = lbase->getNoReturnAttr() || rbase->getNoReturnAttr();
3555 if (NoReturn != lbase->getNoReturnAttr())
3556 allLTypes = false;
3557 if (NoReturn != rbase->getNoReturnAttr())
3558 allRTypes = false;
3559
Eli Friedman3d815e72008-08-22 00:56:42 +00003560 if (lproto && rproto) { // two C99 style function prototypes
Sebastian Redl465226e2009-05-27 22:11:52 +00003561 assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&
3562 "C++ shouldn't be here");
Eli Friedman3d815e72008-08-22 00:56:42 +00003563 unsigned lproto_nargs = lproto->getNumArgs();
3564 unsigned rproto_nargs = rproto->getNumArgs();
3565
3566 // Compatible functions must have the same number of arguments
3567 if (lproto_nargs != rproto_nargs)
3568 return QualType();
3569
3570 // Variadic and non-variadic functions aren't compatible
3571 if (lproto->isVariadic() != rproto->isVariadic())
3572 return QualType();
3573
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00003574 if (lproto->getTypeQuals() != rproto->getTypeQuals())
3575 return QualType();
3576
Eli Friedman3d815e72008-08-22 00:56:42 +00003577 // Check argument compatibility
3578 llvm::SmallVector<QualType, 10> types;
3579 for (unsigned i = 0; i < lproto_nargs; i++) {
3580 QualType largtype = lproto->getArgType(i).getUnqualifiedType();
3581 QualType rargtype = rproto->getArgType(i).getUnqualifiedType();
3582 QualType argtype = mergeTypes(largtype, rargtype);
3583 if (argtype.isNull()) return QualType();
3584 types.push_back(argtype);
Chris Lattner61710852008-10-05 17:34:18 +00003585 if (getCanonicalType(argtype) != getCanonicalType(largtype))
3586 allLTypes = false;
3587 if (getCanonicalType(argtype) != getCanonicalType(rargtype))
3588 allRTypes = false;
Eli Friedman3d815e72008-08-22 00:56:42 +00003589 }
3590 if (allLTypes) return lhs;
3591 if (allRTypes) return rhs;
3592 return getFunctionType(retType, types.begin(), types.size(),
Mike Stump24556362009-07-25 21:26:53 +00003593 lproto->isVariadic(), lproto->getTypeQuals(),
3594 NoReturn);
Eli Friedman3d815e72008-08-22 00:56:42 +00003595 }
3596
3597 if (lproto) allRTypes = false;
3598 if (rproto) allLTypes = false;
3599
Douglas Gregor72564e72009-02-26 23:50:07 +00003600 const FunctionProtoType *proto = lproto ? lproto : rproto;
Eli Friedman3d815e72008-08-22 00:56:42 +00003601 if (proto) {
Sebastian Redl465226e2009-05-27 22:11:52 +00003602 assert(!proto->hasExceptionSpec() && "C++ shouldn't be here");
Eli Friedman3d815e72008-08-22 00:56:42 +00003603 if (proto->isVariadic()) return QualType();
3604 // Check that the types are compatible with the types that
3605 // would result from default argument promotions (C99 6.7.5.3p15).
3606 // The only types actually affected are promotable integer
3607 // types and floats, which would be passed as a different
3608 // type depending on whether the prototype is visible.
3609 unsigned proto_nargs = proto->getNumArgs();
3610 for (unsigned i = 0; i < proto_nargs; ++i) {
3611 QualType argTy = proto->getArgType(i);
3612 if (argTy->isPromotableIntegerType() ||
3613 getCanonicalType(argTy).getUnqualifiedType() == FloatTy)
3614 return QualType();
3615 }
3616
3617 if (allLTypes) return lhs;
3618 if (allRTypes) return rhs;
3619 return getFunctionType(retType, proto->arg_type_begin(),
Mike Stump2d3c1912009-07-27 00:44:23 +00003620 proto->getNumArgs(), proto->isVariadic(),
3621 proto->getTypeQuals(), NoReturn);
Eli Friedman3d815e72008-08-22 00:56:42 +00003622 }
3623
3624 if (allLTypes) return lhs;
3625 if (allRTypes) return rhs;
Mike Stump24556362009-07-25 21:26:53 +00003626 return getFunctionNoProtoType(retType, NoReturn);
Eli Friedman3d815e72008-08-22 00:56:42 +00003627}
3628
3629QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) {
Bill Wendling43d69752007-12-03 07:33:35 +00003630 // C++ [expr]: If an expression initially has the type "reference to T", the
3631 // type is adjusted to "T" prior to any further analysis, the expression
3632 // designates the object or function denoted by the reference, and the
Sebastian Redl7c80bd62009-03-16 23:22:08 +00003633 // expression is an lvalue unless the reference is an rvalue reference and
3634 // the expression is a function call (possibly inside parentheses).
Eli Friedman3d815e72008-08-22 00:56:42 +00003635 // FIXME: C++ shouldn't be going through here! The rules are different
3636 // enough that they should be handled separately.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00003637 // FIXME: Merging of lvalue and rvalue references is incorrect. C++ *really*
3638 // shouldn't be going through here!
Ted Kremenek6217b802009-07-29 21:53:49 +00003639 if (const ReferenceType *RT = LHS->getAs<ReferenceType>())
Chris Lattnerc4e40592008-04-07 04:07:56 +00003640 LHS = RT->getPointeeType();
Ted Kremenek6217b802009-07-29 21:53:49 +00003641 if (const ReferenceType *RT = RHS->getAs<ReferenceType>())
Chris Lattnerc4e40592008-04-07 04:07:56 +00003642 RHS = RT->getPointeeType();
Chris Lattnerf3692dc2008-04-07 05:37:56 +00003643
Eli Friedman3d815e72008-08-22 00:56:42 +00003644 QualType LHSCan = getCanonicalType(LHS),
3645 RHSCan = getCanonicalType(RHS);
3646
3647 // If two types are identical, they are compatible.
3648 if (LHSCan == RHSCan)
3649 return LHS;
3650
3651 // If the qualifiers are different, the types aren't compatible
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003652 // Note that we handle extended qualifiers later, in the
3653 // case for ExtQualType.
3654 if (LHSCan.getCVRQualifiers() != RHSCan.getCVRQualifiers())
Eli Friedman3d815e72008-08-22 00:56:42 +00003655 return QualType();
3656
Eli Friedman852d63b2009-06-01 01:22:52 +00003657 Type::TypeClass LHSClass = LHSCan->getTypeClass();
3658 Type::TypeClass RHSClass = RHSCan->getTypeClass();
Eli Friedman3d815e72008-08-22 00:56:42 +00003659
Chris Lattner1adb8832008-01-14 05:45:46 +00003660 // We want to consider the two function types to be the same for these
3661 // comparisons, just force one to the other.
3662 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
3663 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
Eli Friedman4c721d32008-02-12 08:23:06 +00003664
Eli Friedman07d25872009-06-02 05:28:56 +00003665 // Strip off objc_gc attributes off the top level so they can be merged.
3666 // This is a complete mess, but the attribute itself doesn't make much sense.
Fariborz Jahanian585f7b22009-06-02 01:40:22 +00003667 if (RHSClass == Type::ExtQual) {
Eli Friedman07d25872009-06-02 05:28:56 +00003668 QualType::GCAttrTypes GCAttr = RHSCan.getObjCGCAttr();
3669 if (GCAttr != QualType::GCNone) {
Fariborz Jahanian86f43852009-06-02 20:58:58 +00003670 QualType::GCAttrTypes GCLHSAttr = LHSCan.getObjCGCAttr();
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003671 // __weak attribute must appear on both declarations.
Fariborz Jahanian86f43852009-06-02 20:58:58 +00003672 // __strong attribue is redundant if other decl is an objective-c
3673 // object pointer (or decorated with __strong attribute); otherwise
3674 // issue error.
3675 if ((GCAttr == QualType::Weak && GCLHSAttr != GCAttr) ||
3676 (GCAttr == QualType::Strong && GCLHSAttr != GCAttr &&
Steve Naroff14108da2009-07-10 23:34:53 +00003677 !LHSCan->isObjCObjectPointerType()))
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003678 return QualType();
3679
Eli Friedman07d25872009-06-02 05:28:56 +00003680 RHS = QualType(cast<ExtQualType>(RHS.getDesugaredType())->getBaseType(),
3681 RHS.getCVRQualifiers());
3682 QualType Result = mergeTypes(LHS, RHS);
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003683 if (!Result.isNull()) {
3684 if (Result.getObjCGCAttr() == QualType::GCNone)
3685 Result = getObjCGCQualType(Result, GCAttr);
3686 else if (Result.getObjCGCAttr() != GCAttr)
3687 Result = QualType();
3688 }
Eli Friedman07d25872009-06-02 05:28:56 +00003689 return Result;
3690 }
Fariborz Jahanian585f7b22009-06-02 01:40:22 +00003691 }
Fariborz Jahanian585f7b22009-06-02 01:40:22 +00003692 if (LHSClass == Type::ExtQual) {
Eli Friedman07d25872009-06-02 05:28:56 +00003693 QualType::GCAttrTypes GCAttr = LHSCan.getObjCGCAttr();
3694 if (GCAttr != QualType::GCNone) {
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003695 QualType::GCAttrTypes GCRHSAttr = RHSCan.getObjCGCAttr();
3696 // __weak attribute must appear on both declarations. __strong
Fariborz Jahanian86f43852009-06-02 20:58:58 +00003697 // __strong attribue is redundant if other decl is an objective-c
3698 // object pointer (or decorated with __strong attribute); otherwise
3699 // issue error.
3700 if ((GCAttr == QualType::Weak && GCRHSAttr != GCAttr) ||
3701 (GCAttr == QualType::Strong && GCRHSAttr != GCAttr &&
Steve Naroff14108da2009-07-10 23:34:53 +00003702 !RHSCan->isObjCObjectPointerType()))
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003703 return QualType();
Fariborz Jahanian86f43852009-06-02 20:58:58 +00003704
Eli Friedman07d25872009-06-02 05:28:56 +00003705 LHS = QualType(cast<ExtQualType>(LHS.getDesugaredType())->getBaseType(),
3706 LHS.getCVRQualifiers());
3707 QualType Result = mergeTypes(LHS, RHS);
Fariborz Jahanian8df7a282009-06-02 18:32:00 +00003708 if (!Result.isNull()) {
3709 if (Result.getObjCGCAttr() == QualType::GCNone)
3710 Result = getObjCGCQualType(Result, GCAttr);
3711 else if (Result.getObjCGCAttr() != GCAttr)
3712 Result = QualType();
3713 }
Eli Friedman354e53d2009-06-02 07:45:37 +00003714 return Result;
Eli Friedman07d25872009-06-02 05:28:56 +00003715 }
Fariborz Jahanian585f7b22009-06-02 01:40:22 +00003716 }
3717
Eli Friedman4c721d32008-02-12 08:23:06 +00003718 // Same as above for arrays
Chris Lattnera36a61f2008-04-07 05:43:21 +00003719 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
3720 LHSClass = Type::ConstantArray;
3721 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
3722 RHSClass = Type::ConstantArray;
Steve Naroffec0550f2007-10-15 20:41:53 +00003723
Nate Begeman213541a2008-04-18 23:10:10 +00003724 // Canonicalize ExtVector -> Vector.
3725 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
3726 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
Chris Lattnera36a61f2008-04-07 05:43:21 +00003727
3728 // If the canonical type classes don't match.
Chris Lattner1adb8832008-01-14 05:45:46 +00003729 if (LHSClass != RHSClass) {
Chris Lattner1adb8832008-01-14 05:45:46 +00003730 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
3731 // a signed integer type, or an unsigned integer type.
Eli Friedman3d815e72008-08-22 00:56:42 +00003732 if (const EnumType* ETy = LHS->getAsEnumType()) {
3733 if (ETy->getDecl()->getIntegerType() == RHSCan.getUnqualifiedType())
3734 return RHS;
Eli Friedmanbab96962008-02-12 08:46:17 +00003735 }
Eli Friedman3d815e72008-08-22 00:56:42 +00003736 if (const EnumType* ETy = RHS->getAsEnumType()) {
3737 if (ETy->getDecl()->getIntegerType() == LHSCan.getUnqualifiedType())
3738 return LHS;
Eli Friedmanbab96962008-02-12 08:46:17 +00003739 }
Chris Lattner1adb8832008-01-14 05:45:46 +00003740
Eli Friedman3d815e72008-08-22 00:56:42 +00003741 return QualType();
Steve Naroffec0550f2007-10-15 20:41:53 +00003742 }
Eli Friedman3d815e72008-08-22 00:56:42 +00003743
Steve Naroff4a746782008-01-09 22:43:08 +00003744 // The canonical type classes match.
Chris Lattner1adb8832008-01-14 05:45:46 +00003745 switch (LHSClass) {
Douglas Gregor72564e72009-02-26 23:50:07 +00003746#define TYPE(Class, Base)
3747#define ABSTRACT_TYPE(Class, Base)
3748#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3749#define DEPENDENT_TYPE(Class, Base) case Type::Class:
3750#include "clang/AST/TypeNodes.def"
3751 assert(false && "Non-canonical and dependent types shouldn't get here");
3752 return QualType();
3753
Sebastian Redl7c80bd62009-03-16 23:22:08 +00003754 case Type::LValueReference:
3755 case Type::RValueReference:
Douglas Gregor72564e72009-02-26 23:50:07 +00003756 case Type::MemberPointer:
3757 assert(false && "C++ should never be in mergeTypes");
3758 return QualType();
3759
3760 case Type::IncompleteArray:
3761 case Type::VariableArray:
3762 case Type::FunctionProto:
3763 case Type::ExtVector:
Douglas Gregor72564e72009-02-26 23:50:07 +00003764 assert(false && "Types are eliminated above");
3765 return QualType();
3766
Chris Lattner1adb8832008-01-14 05:45:46 +00003767 case Type::Pointer:
Eli Friedman3d815e72008-08-22 00:56:42 +00003768 {
3769 // Merge two pointer types, while trying to preserve typedef info
Ted Kremenek6217b802009-07-29 21:53:49 +00003770 QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType();
3771 QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType();
Eli Friedman3d815e72008-08-22 00:56:42 +00003772 QualType ResultType = mergeTypes(LHSPointee, RHSPointee);
3773 if (ResultType.isNull()) return QualType();
Eli Friedman07d25872009-06-02 05:28:56 +00003774 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
Chris Lattner61710852008-10-05 17:34:18 +00003775 return LHS;
Eli Friedman07d25872009-06-02 05:28:56 +00003776 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
Chris Lattner61710852008-10-05 17:34:18 +00003777 return RHS;
Eli Friedman3d815e72008-08-22 00:56:42 +00003778 return getPointerType(ResultType);
3779 }
Steve Naroffc0febd52008-12-10 17:49:55 +00003780 case Type::BlockPointer:
3781 {
3782 // Merge two block pointer types, while trying to preserve typedef info
Ted Kremenek6217b802009-07-29 21:53:49 +00003783 QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType();
3784 QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType();
Steve Naroffc0febd52008-12-10 17:49:55 +00003785 QualType ResultType = mergeTypes(LHSPointee, RHSPointee);
3786 if (ResultType.isNull()) return QualType();
3787 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
3788 return LHS;
3789 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
3790 return RHS;
3791 return getBlockPointerType(ResultType);
3792 }
Chris Lattner1adb8832008-01-14 05:45:46 +00003793 case Type::ConstantArray:
Eli Friedman3d815e72008-08-22 00:56:42 +00003794 {
3795 const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
3796 const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
3797 if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
3798 return QualType();
3799
3800 QualType LHSElem = getAsArrayType(LHS)->getElementType();
3801 QualType RHSElem = getAsArrayType(RHS)->getElementType();
3802 QualType ResultType = mergeTypes(LHSElem, RHSElem);
3803 if (ResultType.isNull()) return QualType();
Chris Lattner61710852008-10-05 17:34:18 +00003804 if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
3805 return LHS;
3806 if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
3807 return RHS;
Eli Friedman3bc0f452008-08-22 01:48:21 +00003808 if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(),
3809 ArrayType::ArraySizeModifier(), 0);
3810 if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(),
3811 ArrayType::ArraySizeModifier(), 0);
Eli Friedman3d815e72008-08-22 00:56:42 +00003812 const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
3813 const VariableArrayType* RVAT = getAsVariableArrayType(RHS);
Chris Lattner61710852008-10-05 17:34:18 +00003814 if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
3815 return LHS;
3816 if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
3817 return RHS;
Eli Friedman3d815e72008-08-22 00:56:42 +00003818 if (LVAT) {
3819 // FIXME: This isn't correct! But tricky to implement because
3820 // the array's size has to be the size of LHS, but the type
3821 // has to be different.
3822 return LHS;
3823 }
3824 if (RVAT) {
3825 // FIXME: This isn't correct! But tricky to implement because
3826 // the array's size has to be the size of RHS, but the type
3827 // has to be different.
3828 return RHS;
3829 }
Eli Friedman3bc0f452008-08-22 01:48:21 +00003830 if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
3831 if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00003832 return getIncompleteArrayType(ResultType,
3833 ArrayType::ArraySizeModifier(), 0);
Eli Friedman3d815e72008-08-22 00:56:42 +00003834 }
Chris Lattner1adb8832008-01-14 05:45:46 +00003835 case Type::FunctionNoProto:
Eli Friedman3d815e72008-08-22 00:56:42 +00003836 return mergeFunctionTypes(LHS, RHS);
Douglas Gregor72564e72009-02-26 23:50:07 +00003837 case Type::Record:
Douglas Gregor72564e72009-02-26 23:50:07 +00003838 case Type::Enum:
Eli Friedman3d815e72008-08-22 00:56:42 +00003839 return QualType();
Chris Lattner1adb8832008-01-14 05:45:46 +00003840 case Type::Builtin:
Chris Lattner3cc4c0c2008-04-07 05:55:38 +00003841 // Only exactly equal builtin types are compatible, which is tested above.
Eli Friedman3d815e72008-08-22 00:56:42 +00003842 return QualType();
Daniel Dunbar64cfdb72009-01-28 21:22:12 +00003843 case Type::Complex:
3844 // Distinct complex types are incompatible.
3845 return QualType();
Chris Lattner3cc4c0c2008-04-07 05:55:38 +00003846 case Type::Vector:
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003847 // FIXME: The merged type should be an ExtVector!
Eli Friedman3d815e72008-08-22 00:56:42 +00003848 if (areCompatVectorTypes(LHS->getAsVectorType(), RHS->getAsVectorType()))
3849 return LHS;
Chris Lattner61710852008-10-05 17:34:18 +00003850 return QualType();
Cedric Venet61490e92009-02-21 17:14:49 +00003851 case Type::ObjCInterface: {
Steve Naroff5fd659d2009-02-21 16:18:07 +00003852 // Check if the interfaces are assignment compatible.
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003853 // FIXME: This should be type compatibility, e.g. whether
3854 // "LHS x; RHS x;" at global scope is legal.
Steve Naroff5fd659d2009-02-21 16:18:07 +00003855 const ObjCInterfaceType* LHSIface = LHS->getAsObjCInterfaceType();
3856 const ObjCInterfaceType* RHSIface = RHS->getAsObjCInterfaceType();
3857 if (LHSIface && RHSIface &&
3858 canAssignObjCInterfaces(LHSIface, RHSIface))
3859 return LHS;
3860
Eli Friedman3d815e72008-08-22 00:56:42 +00003861 return QualType();
Cedric Venet61490e92009-02-21 17:14:49 +00003862 }
Steve Naroff14108da2009-07-10 23:34:53 +00003863 case Type::ObjCObjectPointer: {
Steve Naroff14108da2009-07-10 23:34:53 +00003864 if (canAssignObjCInterfaces(LHS->getAsObjCObjectPointerType(),
3865 RHS->getAsObjCObjectPointerType()))
3866 return LHS;
3867
Steve Naroffbc76dd02008-12-10 22:14:21 +00003868 return QualType();
Steve Naroff14108da2009-07-10 23:34:53 +00003869 }
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003870 case Type::FixedWidthInt:
3871 // Distinct fixed-width integers are not compatible.
3872 return QualType();
Eli Friedman5a61f0e2009-02-27 23:04:43 +00003873 case Type::ExtQual:
3874 // FIXME: ExtQual types can be compatible even if they're not
3875 // identical!
3876 return QualType();
3877 // First attempt at an implementation, but I'm not really sure it's
3878 // right...
3879#if 0
3880 ExtQualType* LQual = cast<ExtQualType>(LHSCan);
3881 ExtQualType* RQual = cast<ExtQualType>(RHSCan);
3882 if (LQual->getAddressSpace() != RQual->getAddressSpace() ||
3883 LQual->getObjCGCAttr() != RQual->getObjCGCAttr())
3884 return QualType();
3885 QualType LHSBase, RHSBase, ResultType, ResCanUnqual;
3886 LHSBase = QualType(LQual->getBaseType(), 0);
3887 RHSBase = QualType(RQual->getBaseType(), 0);
3888 ResultType = mergeTypes(LHSBase, RHSBase);
3889 if (ResultType.isNull()) return QualType();
3890 ResCanUnqual = getCanonicalType(ResultType).getUnqualifiedType();
3891 if (LHSCan.getUnqualifiedType() == ResCanUnqual)
3892 return LHS;
3893 if (RHSCan.getUnqualifiedType() == ResCanUnqual)
3894 return RHS;
3895 ResultType = getAddrSpaceQualType(ResultType, LQual->getAddressSpace());
3896 ResultType = getObjCGCQualType(ResultType, LQual->getObjCGCAttr());
3897 ResultType.setCVRQualifiers(LHSCan.getCVRQualifiers());
3898 return ResultType;
3899#endif
Douglas Gregor7532dc62009-03-30 22:58:21 +00003900
3901 case Type::TemplateSpecialization:
3902 assert(false && "Dependent types have no size");
3903 break;
Steve Naroffec0550f2007-10-15 20:41:53 +00003904 }
Douglas Gregor72564e72009-02-26 23:50:07 +00003905
3906 return QualType();
Steve Naroffec0550f2007-10-15 20:41:53 +00003907}
Ted Kremenek7192f8e2007-10-31 17:10:13 +00003908
Chris Lattner5426bf62008-04-07 07:01:58 +00003909//===----------------------------------------------------------------------===//
Eli Friedmanad74a752008-06-28 06:23:08 +00003910// Integer Predicates
3911//===----------------------------------------------------------------------===//
Chris Lattner88054de2009-01-16 07:15:35 +00003912
Eli Friedmanad74a752008-06-28 06:23:08 +00003913unsigned ASTContext::getIntWidth(QualType T) {
3914 if (T == BoolTy)
3915 return 1;
Eli Friedmanf98aba32009-02-13 02:31:07 +00003916 if (FixedWidthIntType* FWIT = dyn_cast<FixedWidthIntType>(T)) {
3917 return FWIT->getWidth();
3918 }
3919 // For builtin types, just use the standard type sizing method
Eli Friedmanad74a752008-06-28 06:23:08 +00003920 return (unsigned)getTypeSize(T);
3921}
3922
3923QualType ASTContext::getCorrespondingUnsignedType(QualType T) {
3924 assert(T->isSignedIntegerType() && "Unexpected type");
3925 if (const EnumType* ETy = T->getAsEnumType())
3926 T = ETy->getDecl()->getIntegerType();
3927 const BuiltinType* BTy = T->getAsBuiltinType();
3928 assert (BTy && "Unexpected signed integer type");
3929 switch (BTy->getKind()) {
3930 case BuiltinType::Char_S:
3931 case BuiltinType::SChar:
3932 return UnsignedCharTy;
3933 case BuiltinType::Short:
3934 return UnsignedShortTy;
3935 case BuiltinType::Int:
3936 return UnsignedIntTy;
3937 case BuiltinType::Long:
3938 return UnsignedLongTy;
3939 case BuiltinType::LongLong:
3940 return UnsignedLongLongTy;
Chris Lattner2df9ced2009-04-30 02:43:43 +00003941 case BuiltinType::Int128:
3942 return UnsignedInt128Ty;
Eli Friedmanad74a752008-06-28 06:23:08 +00003943 default:
3944 assert(0 && "Unexpected signed integer type");
3945 return QualType();
3946 }
3947}
3948
Douglas Gregor2cf26342009-04-09 22:27:44 +00003949ExternalASTSource::~ExternalASTSource() { }
3950
3951void ExternalASTSource::PrintStats() { }
Chris Lattner86df27b2009-06-14 00:45:47 +00003952
3953
3954//===----------------------------------------------------------------------===//
3955// Builtin Type Computation
3956//===----------------------------------------------------------------------===//
3957
3958/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
3959/// pointer over the consumed characters. This returns the resultant type.
3960static QualType DecodeTypeFromStr(const char *&Str, ASTContext &Context,
3961 ASTContext::GetBuiltinTypeError &Error,
3962 bool AllowTypeModifiers = true) {
3963 // Modifiers.
3964 int HowLong = 0;
3965 bool Signed = false, Unsigned = false;
3966
3967 // Read the modifiers first.
3968 bool Done = false;
3969 while (!Done) {
3970 switch (*Str++) {
3971 default: Done = true; --Str; break;
3972 case 'S':
3973 assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!");
3974 assert(!Signed && "Can't use 'S' modifier multiple times!");
3975 Signed = true;
3976 break;
3977 case 'U':
3978 assert(!Signed && "Can't use both 'S' and 'U' modifiers!");
3979 assert(!Unsigned && "Can't use 'S' modifier multiple times!");
3980 Unsigned = true;
3981 break;
3982 case 'L':
3983 assert(HowLong <= 2 && "Can't have LLLL modifier");
3984 ++HowLong;
3985 break;
3986 }
3987 }
3988
3989 QualType Type;
3990
3991 // Read the base type.
3992 switch (*Str++) {
3993 default: assert(0 && "Unknown builtin type letter!");
3994 case 'v':
3995 assert(HowLong == 0 && !Signed && !Unsigned &&
3996 "Bad modifiers used with 'v'!");
3997 Type = Context.VoidTy;
3998 break;
3999 case 'f':
4000 assert(HowLong == 0 && !Signed && !Unsigned &&
4001 "Bad modifiers used with 'f'!");
4002 Type = Context.FloatTy;
4003 break;
4004 case 'd':
4005 assert(HowLong < 2 && !Signed && !Unsigned &&
4006 "Bad modifiers used with 'd'!");
4007 if (HowLong)
4008 Type = Context.LongDoubleTy;
4009 else
4010 Type = Context.DoubleTy;
4011 break;
4012 case 's':
4013 assert(HowLong == 0 && "Bad modifiers used with 's'!");
4014 if (Unsigned)
4015 Type = Context.UnsignedShortTy;
4016 else
4017 Type = Context.ShortTy;
4018 break;
4019 case 'i':
4020 if (HowLong == 3)
4021 Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
4022 else if (HowLong == 2)
4023 Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
4024 else if (HowLong == 1)
4025 Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
4026 else
4027 Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
4028 break;
4029 case 'c':
4030 assert(HowLong == 0 && "Bad modifiers used with 'c'!");
4031 if (Signed)
4032 Type = Context.SignedCharTy;
4033 else if (Unsigned)
4034 Type = Context.UnsignedCharTy;
4035 else
4036 Type = Context.CharTy;
4037 break;
4038 case 'b': // boolean
4039 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!");
4040 Type = Context.BoolTy;
4041 break;
4042 case 'z': // size_t.
4043 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!");
4044 Type = Context.getSizeType();
4045 break;
4046 case 'F':
4047 Type = Context.getCFConstantStringType();
4048 break;
4049 case 'a':
4050 Type = Context.getBuiltinVaListType();
4051 assert(!Type.isNull() && "builtin va list type not initialized!");
4052 break;
4053 case 'A':
4054 // This is a "reference" to a va_list; however, what exactly
4055 // this means depends on how va_list is defined. There are two
4056 // different kinds of va_list: ones passed by value, and ones
4057 // passed by reference. An example of a by-value va_list is
4058 // x86, where va_list is a char*. An example of by-ref va_list
4059 // is x86-64, where va_list is a __va_list_tag[1]. For x86,
4060 // we want this argument to be a char*&; for x86-64, we want
4061 // it to be a __va_list_tag*.
4062 Type = Context.getBuiltinVaListType();
4063 assert(!Type.isNull() && "builtin va list type not initialized!");
4064 if (Type->isArrayType()) {
4065 Type = Context.getArrayDecayedType(Type);
4066 } else {
4067 Type = Context.getLValueReferenceType(Type);
4068 }
4069 break;
4070 case 'V': {
4071 char *End;
Chris Lattner86df27b2009-06-14 00:45:47 +00004072 unsigned NumElements = strtoul(Str, &End, 10);
4073 assert(End != Str && "Missing vector size");
4074
4075 Str = End;
4076
4077 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, false);
4078 Type = Context.getVectorType(ElementType, NumElements);
4079 break;
4080 }
Chris Lattner9a5a7e72009-07-28 22:49:34 +00004081 case 'P':
Douglas Gregorc29f77b2009-07-07 16:35:42 +00004082 Type = Context.getFILEType();
4083 if (Type.isNull()) {
Mike Stumpf711c412009-07-28 23:57:15 +00004084 Error = ASTContext::GE_Missing_stdio;
Chris Lattner86df27b2009-06-14 00:45:47 +00004085 return QualType();
4086 }
Mike Stumpfd612db2009-07-28 23:47:15 +00004087 break;
Chris Lattner9a5a7e72009-07-28 22:49:34 +00004088 case 'J':
Mike Stumpf711c412009-07-28 23:57:15 +00004089 if (Signed)
Mike Stump782fa302009-07-28 02:25:19 +00004090 Type = Context.getsigjmp_bufType();
Mike Stumpf711c412009-07-28 23:57:15 +00004091 else
4092 Type = Context.getjmp_bufType();
4093
Mike Stumpfd612db2009-07-28 23:47:15 +00004094 if (Type.isNull()) {
Mike Stumpf711c412009-07-28 23:57:15 +00004095 Error = ASTContext::GE_Missing_setjmp;
Mike Stumpfd612db2009-07-28 23:47:15 +00004096 return QualType();
4097 }
4098 break;
Mike Stump782fa302009-07-28 02:25:19 +00004099 }
Chris Lattner86df27b2009-06-14 00:45:47 +00004100
4101 if (!AllowTypeModifiers)
4102 return Type;
4103
4104 Done = false;
4105 while (!Done) {
4106 switch (*Str++) {
4107 default: Done = true; --Str; break;
4108 case '*':
4109 Type = Context.getPointerType(Type);
4110 break;
4111 case '&':
4112 Type = Context.getLValueReferenceType(Type);
4113 break;
4114 // FIXME: There's no way to have a built-in with an rvalue ref arg.
4115 case 'C':
4116 Type = Type.getQualifiedType(QualType::Const);
4117 break;
4118 }
4119 }
4120
4121 return Type;
4122}
4123
4124/// GetBuiltinType - Return the type for the specified builtin.
4125QualType ASTContext::GetBuiltinType(unsigned id,
4126 GetBuiltinTypeError &Error) {
4127 const char *TypeStr = BuiltinInfo.GetTypeString(id);
4128
4129 llvm::SmallVector<QualType, 8> ArgTypes;
4130
4131 Error = GE_None;
4132 QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error);
4133 if (Error != GE_None)
4134 return QualType();
4135 while (TypeStr[0] && TypeStr[0] != '.') {
4136 QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error);
4137 if (Error != GE_None)
4138 return QualType();
4139
4140 // Do array -> pointer decay. The builtin should use the decayed type.
4141 if (Ty->isArrayType())
4142 Ty = getArrayDecayedType(Ty);
4143
4144 ArgTypes.push_back(Ty);
4145 }
4146
4147 assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&
4148 "'.' should only occur at end of builtin type list!");
4149
4150 // handle untyped/variadic arguments "T c99Style();" or "T cppStyle(...);".
4151 if (ArgTypes.size() == 0 && TypeStr[0] == '.')
4152 return getFunctionNoProtoType(ResType);
4153 return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(),
4154 TypeStr[0] == '.', 0);
4155}