blob: cc7055dc68b850214b40388b69545fbf4185b3a6 [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"
Argyrios Kyrtzidisb17166c2009-08-19 01:27:32 +000018#include "clang/AST/TypeLoc.h"
Daniel Dunbare91593e2008-08-11 04:54:23 +000019#include "clang/AST/Expr.h"
Douglas Gregor2cf26342009-04-09 22:27:44 +000020#include "clang/AST/ExternalASTSource.h"
Anders Carlsson19cc4ab2009-07-18 19:43:29 +000021#include "clang/AST/RecordLayout.h"
Chris Lattner1b63e4f2009-06-14 01:54:56 +000022#include "clang/Basic/Builtins.h"
Chris Lattnera9376d42009-03-28 03:45:20 +000023#include "clang/Basic/SourceManager.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000024#include "clang/Basic/TargetInfo.h"
Benjamin Kramerf5942a42009-10-24 09:57:09 +000025#include "llvm/ADT/SmallString.h"
Anders Carlsson85f9bce2007-10-29 05:01:08 +000026#include "llvm/ADT/StringExtras.h"
Nate Begeman6fe7c8a2009-01-18 06:42:49 +000027#include "llvm/Support/MathExtras.h"
Benjamin Kramerf5942a42009-10-24 09:57:09 +000028#include "llvm/Support/raw_ostream.h"
Anders Carlsson29445a02009-07-18 21:19:52 +000029#include "RecordLayoutBuilder.h"
30
Reid Spencer5f016e22007-07-11 17:01:13 +000031using namespace clang;
32
33enum FloatingRank {
34 FloatRank, DoubleRank, LongDoubleRank
35};
36
Chris Lattner61710852008-10-05 17:34:18 +000037ASTContext::ASTContext(const LangOptions& LOpts, SourceManager &SM,
Daniel Dunbar444be732009-11-13 05:51:54 +000038 const TargetInfo &t,
Daniel Dunbare91593e2008-08-11 04:54:23 +000039 IdentifierTable &idents, SelectorTable &sels,
Chris Lattner1b63e4f2009-06-14 01:54:56 +000040 Builtin::Context &builtins,
Mike Stump1eb44332009-09-09 15:08:12 +000041 bool FreeMem, unsigned size_reserve) :
42 GlobalNestedNameSpecifier(0), CFConstantStringTypeDecl(0),
Mike Stump782fa302009-07-28 02:25:19 +000043 ObjCFastEnumerationStateTypeDecl(0), FILEDecl(0), jmp_bufDecl(0),
Mike Stump083c25e2009-10-22 00:49:09 +000044 sigjmp_bufDecl(0), BlockDescriptorType(0), BlockDescriptorExtendedType(0),
45 SourceMgr(SM), LangOpts(LOpts),
Mike Stump1eb44332009-09-09 15:08:12 +000046 LoadedExternalComments(false), FreeMemory(FreeMem), Target(t),
Douglas Gregor2e222532009-07-02 17:08:52 +000047 Idents(idents), Selectors(sels),
Mike Stump1eb44332009-09-09 15:08:12 +000048 BuiltinInfo(builtins), ExternalSource(0), PrintingPolicy(LOpts) {
David Chisnall0f436562009-08-17 16:35:33 +000049 ObjCIdRedefinitionType = QualType();
50 ObjCClassRedefinitionType = QualType();
Fariborz Jahanian369a3bd2009-11-25 23:07:42 +000051 ObjCSelRedefinitionType = QualType();
Mike Stump1eb44332009-09-09 15:08:12 +000052 if (size_reserve > 0) Types.reserve(size_reserve);
Daniel Dunbare91593e2008-08-11 04:54:23 +000053 TUDecl = TranslationUnitDecl::Create(*this);
Steve Naroff14108da2009-07-10 23:34:53 +000054 InitBuiltinTypes();
Daniel Dunbare91593e2008-08-11 04:54:23 +000055}
56
Reid Spencer5f016e22007-07-11 17:01:13 +000057ASTContext::~ASTContext() {
58 // Deallocate all the types.
59 while (!Types.empty()) {
Ted Kremenek4b05b1d2008-05-21 16:38:54 +000060 Types.back()->Destroy(*this);
Reid Spencer5f016e22007-07-11 17:01:13 +000061 Types.pop_back();
62 }
Eli Friedmanb26153c2008-05-27 03:08:09 +000063
Nuno Lopesb74668e2008-12-17 22:30:25 +000064 {
John McCall0953e762009-09-24 19:53:00 +000065 llvm::FoldingSet<ExtQuals>::iterator
66 I = ExtQualNodes.begin(), E = ExtQualNodes.end();
67 while (I != E)
68 Deallocate(&*I++);
69 }
70
71 {
Nuno Lopesb74668e2008-12-17 22:30:25 +000072 llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
73 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end();
74 while (I != E) {
75 ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second);
76 delete R;
77 }
78 }
79
80 {
Daniel Dunbarb2dbbb92009-05-03 10:38:35 +000081 llvm::DenseMap<const ObjCContainerDecl*, const ASTRecordLayout*>::iterator
82 I = ObjCLayouts.begin(), E = ObjCLayouts.end();
Nuno Lopesb74668e2008-12-17 22:30:25 +000083 while (I != E) {
84 ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second);
85 delete R;
86 }
87 }
88
Douglas Gregorab452ba2009-03-26 23:50:42 +000089 // Destroy nested-name-specifiers.
Douglas Gregor1ae0afa2009-03-27 23:54:10 +000090 for (llvm::FoldingSet<NestedNameSpecifier>::iterator
91 NNS = NestedNameSpecifiers.begin(),
Mike Stump1eb44332009-09-09 15:08:12 +000092 NNSEnd = NestedNameSpecifiers.end();
93 NNS != NNSEnd;
Douglas Gregor1ae0afa2009-03-27 23:54:10 +000094 /* Increment in loop */)
95 (*NNS++).Destroy(*this);
Douglas Gregorab452ba2009-03-26 23:50:42 +000096
97 if (GlobalNestedNameSpecifier)
98 GlobalNestedNameSpecifier->Destroy(*this);
99
Eli Friedmanb26153c2008-05-27 03:08:09 +0000100 TUDecl->Destroy(*this);
Reid Spencer5f016e22007-07-11 17:01:13 +0000101}
102
Mike Stump1eb44332009-09-09 15:08:12 +0000103void
Douglas Gregor2cf26342009-04-09 22:27:44 +0000104ASTContext::setExternalSource(llvm::OwningPtr<ExternalASTSource> &Source) {
105 ExternalSource.reset(Source.take());
106}
107
Reid Spencer5f016e22007-07-11 17:01:13 +0000108void ASTContext::PrintStats() const {
109 fprintf(stderr, "*** AST Context Stats:\n");
110 fprintf(stderr, " %d types total.\n", (int)Types.size());
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000111
Douglas Gregordbe833d2009-05-26 14:40:08 +0000112 unsigned counts[] = {
Mike Stump1eb44332009-09-09 15:08:12 +0000113#define TYPE(Name, Parent) 0,
Douglas Gregordbe833d2009-05-26 14:40:08 +0000114#define ABSTRACT_TYPE(Name, Parent)
115#include "clang/AST/TypeNodes.def"
116 0 // Extra
117 };
Douglas Gregorc2ee10d2009-04-07 17:20:56 +0000118
Reid Spencer5f016e22007-07-11 17:01:13 +0000119 for (unsigned i = 0, e = Types.size(); i != e; ++i) {
120 Type *T = Types[i];
Douglas Gregordbe833d2009-05-26 14:40:08 +0000121 counts[(unsigned)T->getTypeClass()]++;
Reid Spencer5f016e22007-07-11 17:01:13 +0000122 }
123
Douglas Gregordbe833d2009-05-26 14:40:08 +0000124 unsigned Idx = 0;
125 unsigned TotalBytes = 0;
126#define TYPE(Name, Parent) \
127 if (counts[Idx]) \
128 fprintf(stderr, " %d %s types\n", (int)counts[Idx], #Name); \
129 TotalBytes += counts[Idx] * sizeof(Name##Type); \
130 ++Idx;
131#define ABSTRACT_TYPE(Name, Parent)
132#include "clang/AST/TypeNodes.def"
Mike Stump1eb44332009-09-09 15:08:12 +0000133
Douglas Gregordbe833d2009-05-26 14:40:08 +0000134 fprintf(stderr, "Total bytes = %d\n", int(TotalBytes));
Douglas Gregor2cf26342009-04-09 22:27:44 +0000135
136 if (ExternalSource.get()) {
137 fprintf(stderr, "\n");
138 ExternalSource->PrintStats();
139 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000140}
141
142
John McCalle27ec8a2009-10-23 23:03:21 +0000143void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
John McCall6b304a02009-09-24 23:30:46 +0000144 BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K);
John McCalle27ec8a2009-10-23 23:03:21 +0000145 R = CanQualType::CreateUnsafe(QualType(Ty, 0));
John McCall6b304a02009-09-24 23:30:46 +0000146 Types.push_back(Ty);
Reid Spencer5f016e22007-07-11 17:01:13 +0000147}
148
Reid Spencer5f016e22007-07-11 17:01:13 +0000149void ASTContext::InitBuiltinTypes() {
150 assert(VoidTy.isNull() && "Context reinitialized?");
Mike Stump1eb44332009-09-09 15:08:12 +0000151
Reid Spencer5f016e22007-07-11 17:01:13 +0000152 // C99 6.2.5p19.
153 InitBuiltinType(VoidTy, BuiltinType::Void);
Mike Stump1eb44332009-09-09 15:08:12 +0000154
Reid Spencer5f016e22007-07-11 17:01:13 +0000155 // C99 6.2.5p2.
156 InitBuiltinType(BoolTy, BuiltinType::Bool);
157 // C99 6.2.5p3.
Eli Friedman15b91762009-06-05 07:05:05 +0000158 if (LangOpts.CharIsSigned)
Reid Spencer5f016e22007-07-11 17:01:13 +0000159 InitBuiltinType(CharTy, BuiltinType::Char_S);
160 else
161 InitBuiltinType(CharTy, BuiltinType::Char_U);
162 // C99 6.2.5p4.
163 InitBuiltinType(SignedCharTy, BuiltinType::SChar);
164 InitBuiltinType(ShortTy, BuiltinType::Short);
165 InitBuiltinType(IntTy, BuiltinType::Int);
166 InitBuiltinType(LongTy, BuiltinType::Long);
167 InitBuiltinType(LongLongTy, BuiltinType::LongLong);
Mike Stump1eb44332009-09-09 15:08:12 +0000168
Reid Spencer5f016e22007-07-11 17:01:13 +0000169 // C99 6.2.5p6.
170 InitBuiltinType(UnsignedCharTy, BuiltinType::UChar);
171 InitBuiltinType(UnsignedShortTy, BuiltinType::UShort);
172 InitBuiltinType(UnsignedIntTy, BuiltinType::UInt);
173 InitBuiltinType(UnsignedLongTy, BuiltinType::ULong);
174 InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong);
Mike Stump1eb44332009-09-09 15:08:12 +0000175
Reid Spencer5f016e22007-07-11 17:01:13 +0000176 // C99 6.2.5p10.
177 InitBuiltinType(FloatTy, BuiltinType::Float);
178 InitBuiltinType(DoubleTy, BuiltinType::Double);
179 InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble);
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +0000180
Chris Lattner2df9ced2009-04-30 02:43:43 +0000181 // GNU extension, 128-bit integers.
182 InitBuiltinType(Int128Ty, BuiltinType::Int128);
183 InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128);
184
Chris Lattner3a250322009-02-26 23:43:47 +0000185 if (LangOpts.CPlusPlus) // C++ 3.9.1p5
186 InitBuiltinType(WCharTy, BuiltinType::WChar);
187 else // C99
188 WCharTy = getFromTargetType(Target.getWCharType());
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +0000189
Alisdair Meredithf5c209d2009-07-14 06:30:34 +0000190 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
191 InitBuiltinType(Char16Ty, BuiltinType::Char16);
192 else // C99
193 Char16Ty = getFromTargetType(Target.getChar16Type());
194
195 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
196 InitBuiltinType(Char32Ty, BuiltinType::Char32);
197 else // C99
198 Char32Ty = getFromTargetType(Target.getChar32Type());
199
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000200 // Placeholder type for functions.
Douglas Gregor898574e2008-12-05 23:32:09 +0000201 InitBuiltinType(OverloadTy, BuiltinType::Overload);
202
203 // Placeholder type for type-dependent expressions whose type is
204 // completely unknown. No code should ever check a type against
205 // DependentTy and users should never see it; however, it is here to
206 // help diagnose failures to properly check for type-dependent
207 // expressions.
208 InitBuiltinType(DependentTy, BuiltinType::Dependent);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000209
Mike Stump1eb44332009-09-09 15:08:12 +0000210 // Placeholder type for C++0x auto declarations whose real type has
Anders Carlssone89d1592009-06-26 18:41:36 +0000211 // not yet been deduced.
212 InitBuiltinType(UndeducedAutoTy, BuiltinType::UndeducedAuto);
Mike Stump1eb44332009-09-09 15:08:12 +0000213
Reid Spencer5f016e22007-07-11 17:01:13 +0000214 // C99 6.2.5p11.
215 FloatComplexTy = getComplexType(FloatTy);
216 DoubleComplexTy = getComplexType(DoubleTy);
217 LongDoubleComplexTy = getComplexType(LongDoubleTy);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000218
Steve Naroff7e219e42007-10-15 14:41:52 +0000219 BuiltinVaListType = QualType();
Mike Stump1eb44332009-09-09 15:08:12 +0000220
Steve Naroffde2e22d2009-07-15 18:40:39 +0000221 // "Builtin" typedefs set by Sema::ActOnTranslationUnitScope().
222 ObjCIdTypedefType = QualType();
223 ObjCClassTypedefType = QualType();
Fariborz Jahanian13dcd002009-11-21 19:53:08 +0000224 ObjCSelTypedefType = QualType();
Mike Stump1eb44332009-09-09 15:08:12 +0000225
Fariborz Jahanian13dcd002009-11-21 19:53:08 +0000226 // Builtin types for 'id', 'Class', and 'SEL'.
Steve Naroffde2e22d2009-07-15 18:40:39 +0000227 InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
228 InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
Fariborz Jahanian13dcd002009-11-21 19:53:08 +0000229 InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);
Steve Naroff14108da2009-07-10 23:34:53 +0000230
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000231 ObjCConstantStringType = QualType();
Mike Stump1eb44332009-09-09 15:08:12 +0000232
Fariborz Jahanian33e1d642007-10-29 22:57:28 +0000233 // void * type
234 VoidPtrTy = getPointerType(VoidTy);
Sebastian Redl6e8ed162009-05-10 18:38:11 +0000235
236 // nullptr type (C++0x 2.14.7)
237 InitBuiltinType(NullPtrTy, BuiltinType::NullPtr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000238}
239
Douglas Gregor251b4ff2009-10-08 07:24:58 +0000240MemberSpecializationInfo *
Douglas Gregor663b5a02009-10-14 20:14:33 +0000241ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) {
Douglas Gregor7caa6822009-07-24 20:34:43 +0000242 assert(Var->isStaticDataMember() && "Not a static data member");
Douglas Gregor663b5a02009-10-14 20:14:33 +0000243 llvm::DenseMap<const VarDecl *, MemberSpecializationInfo *>::iterator Pos
Douglas Gregor7caa6822009-07-24 20:34:43 +0000244 = InstantiatedFromStaticDataMember.find(Var);
245 if (Pos == InstantiatedFromStaticDataMember.end())
246 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000247
Douglas Gregor7caa6822009-07-24 20:34:43 +0000248 return Pos->second;
249}
250
Mike Stump1eb44332009-09-09 15:08:12 +0000251void
Douglas Gregor251b4ff2009-10-08 07:24:58 +0000252ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
253 TemplateSpecializationKind TSK) {
Douglas Gregor7caa6822009-07-24 20:34:43 +0000254 assert(Inst->isStaticDataMember() && "Not a static data member");
255 assert(Tmpl->isStaticDataMember() && "Not a static data member");
256 assert(!InstantiatedFromStaticDataMember[Inst] &&
257 "Already noted what static data member was instantiated from");
Douglas Gregor251b4ff2009-10-08 07:24:58 +0000258 InstantiatedFromStaticDataMember[Inst]
259 = new (*this) MemberSpecializationInfo(Tmpl, TSK);
Douglas Gregor7caa6822009-07-24 20:34:43 +0000260}
261
John McCall7ba107a2009-11-18 02:36:19 +0000262NamedDecl *
John McCalled976492009-12-04 22:46:56 +0000263ASTContext::getInstantiatedFromUsingDecl(UsingDecl *UUD) {
John McCall7ba107a2009-11-18 02:36:19 +0000264 llvm::DenseMap<UsingDecl *, NamedDecl *>::const_iterator Pos
John McCalled976492009-12-04 22:46:56 +0000265 = InstantiatedFromUsingDecl.find(UUD);
266 if (Pos == InstantiatedFromUsingDecl.end())
Anders Carlsson0d8df782009-08-29 19:37:28 +0000267 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000268
Anders Carlsson0d8df782009-08-29 19:37:28 +0000269 return Pos->second;
270}
271
272void
John McCalled976492009-12-04 22:46:56 +0000273ASTContext::setInstantiatedFromUsingDecl(UsingDecl *Inst, NamedDecl *Pattern) {
274 assert((isa<UsingDecl>(Pattern) ||
275 isa<UnresolvedUsingValueDecl>(Pattern) ||
276 isa<UnresolvedUsingTypenameDecl>(Pattern)) &&
277 "pattern decl is not a using decl");
278 assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists");
279 InstantiatedFromUsingDecl[Inst] = Pattern;
280}
281
282UsingShadowDecl *
283ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) {
284 llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
285 = InstantiatedFromUsingShadowDecl.find(Inst);
286 if (Pos == InstantiatedFromUsingShadowDecl.end())
287 return 0;
288
289 return Pos->second;
290}
291
292void
293ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
294 UsingShadowDecl *Pattern) {
295 assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists");
296 InstantiatedFromUsingShadowDecl[Inst] = Pattern;
Anders Carlsson0d8df782009-08-29 19:37:28 +0000297}
298
Anders Carlssond8b285f2009-09-01 04:26:58 +0000299FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) {
300 llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
301 = InstantiatedFromUnnamedFieldDecl.find(Field);
302 if (Pos == InstantiatedFromUnnamedFieldDecl.end())
303 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000304
Anders Carlssond8b285f2009-09-01 04:26:58 +0000305 return Pos->second;
306}
307
308void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst,
309 FieldDecl *Tmpl) {
310 assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed");
311 assert(!Tmpl->getDeclName() && "Template field decl is not unnamed");
312 assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
313 "Already noted what unnamed field was instantiated from");
Mike Stump1eb44332009-09-09 15:08:12 +0000314
Anders Carlssond8b285f2009-09-01 04:26:58 +0000315 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
316}
317
Douglas Gregor2e222532009-07-02 17:08:52 +0000318namespace {
Mike Stump1eb44332009-09-09 15:08:12 +0000319 class BeforeInTranslationUnit
Douglas Gregor2e222532009-07-02 17:08:52 +0000320 : std::binary_function<SourceRange, SourceRange, bool> {
321 SourceManager *SourceMgr;
Mike Stump1eb44332009-09-09 15:08:12 +0000322
Douglas Gregor2e222532009-07-02 17:08:52 +0000323 public:
324 explicit BeforeInTranslationUnit(SourceManager *SM) : SourceMgr(SM) { }
Mike Stump1eb44332009-09-09 15:08:12 +0000325
Douglas Gregor2e222532009-07-02 17:08:52 +0000326 bool operator()(SourceRange X, SourceRange Y) {
327 return SourceMgr->isBeforeInTranslationUnit(X.getBegin(), Y.getBegin());
328 }
329 };
330}
331
332/// \brief Determine whether the given comment is a Doxygen-style comment.
333///
334/// \param Start the start of the comment text.
335///
336/// \param End the end of the comment text.
337///
338/// \param Member whether we want to check whether this is a member comment
339/// (which requires a < after the Doxygen-comment delimiter). Otherwise,
340/// we only return true when we find a non-member comment.
Mike Stump1eb44332009-09-09 15:08:12 +0000341static bool
342isDoxygenComment(SourceManager &SourceMgr, SourceRange Comment,
Douglas Gregor2e222532009-07-02 17:08:52 +0000343 bool Member = false) {
Mike Stump1eb44332009-09-09 15:08:12 +0000344 const char *BufferStart
Douglas Gregor2e222532009-07-02 17:08:52 +0000345 = SourceMgr.getBufferData(SourceMgr.getFileID(Comment.getBegin())).first;
346 const char *Start = BufferStart + SourceMgr.getFileOffset(Comment.getBegin());
347 const char* End = BufferStart + SourceMgr.getFileOffset(Comment.getEnd());
Mike Stump1eb44332009-09-09 15:08:12 +0000348
Douglas Gregor2e222532009-07-02 17:08:52 +0000349 if (End - Start < 4)
350 return false;
351
352 assert(Start[0] == '/' && "Not a comment?");
353 if (Start[1] == '*' && !(Start[2] == '!' || Start[2] == '*'))
354 return false;
355 if (Start[1] == '/' && !(Start[2] == '!' || Start[2] == '/'))
356 return false;
357
358 return (Start[3] == '<') == Member;
359}
360
361/// \brief Retrieve the comment associated with the given declaration, if
Mike Stump1eb44332009-09-09 15:08:12 +0000362/// it has one.
Douglas Gregor2e222532009-07-02 17:08:52 +0000363const char *ASTContext::getCommentForDecl(const Decl *D) {
364 if (!D)
365 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000366
Douglas Gregor2e222532009-07-02 17:08:52 +0000367 // Check whether we have cached a comment string for this declaration
368 // already.
Mike Stump1eb44332009-09-09 15:08:12 +0000369 llvm::DenseMap<const Decl *, std::string>::iterator Pos
Douglas Gregor2e222532009-07-02 17:08:52 +0000370 = DeclComments.find(D);
371 if (Pos != DeclComments.end())
372 return Pos->second.c_str();
373
Mike Stump1eb44332009-09-09 15:08:12 +0000374 // If we have an external AST source and have not yet loaded comments from
Douglas Gregor2e222532009-07-02 17:08:52 +0000375 // that source, do so now.
376 if (ExternalSource && !LoadedExternalComments) {
377 std::vector<SourceRange> LoadedComments;
378 ExternalSource->ReadComments(LoadedComments);
Mike Stump1eb44332009-09-09 15:08:12 +0000379
Douglas Gregor2e222532009-07-02 17:08:52 +0000380 if (!LoadedComments.empty())
381 Comments.insert(Comments.begin(), LoadedComments.begin(),
382 LoadedComments.end());
Mike Stump1eb44332009-09-09 15:08:12 +0000383
Douglas Gregor2e222532009-07-02 17:08:52 +0000384 LoadedExternalComments = true;
385 }
Mike Stump1eb44332009-09-09 15:08:12 +0000386
387 // If there are no comments anywhere, we won't find anything.
Douglas Gregor2e222532009-07-02 17:08:52 +0000388 if (Comments.empty())
389 return 0;
390
391 // If the declaration doesn't map directly to a location in a file, we
392 // can't find the comment.
393 SourceLocation DeclStartLoc = D->getLocStart();
394 if (DeclStartLoc.isInvalid() || !DeclStartLoc.isFileID())
395 return 0;
396
397 // Find the comment that occurs just before this declaration.
398 std::vector<SourceRange>::iterator LastComment
Mike Stump1eb44332009-09-09 15:08:12 +0000399 = std::lower_bound(Comments.begin(), Comments.end(),
Douglas Gregor2e222532009-07-02 17:08:52 +0000400 SourceRange(DeclStartLoc),
401 BeforeInTranslationUnit(&SourceMgr));
Mike Stump1eb44332009-09-09 15:08:12 +0000402
Douglas Gregor2e222532009-07-02 17:08:52 +0000403 // Decompose the location for the start of the declaration and find the
404 // beginning of the file buffer.
Mike Stump1eb44332009-09-09 15:08:12 +0000405 std::pair<FileID, unsigned> DeclStartDecomp
Douglas Gregor2e222532009-07-02 17:08:52 +0000406 = SourceMgr.getDecomposedLoc(DeclStartLoc);
Mike Stump1eb44332009-09-09 15:08:12 +0000407 const char *FileBufferStart
Douglas Gregor2e222532009-07-02 17:08:52 +0000408 = SourceMgr.getBufferData(DeclStartDecomp.first).first;
Mike Stump1eb44332009-09-09 15:08:12 +0000409
Douglas Gregor2e222532009-07-02 17:08:52 +0000410 // First check whether we have a comment for a member.
411 if (LastComment != Comments.end() &&
412 !isa<TagDecl>(D) && !isa<NamespaceDecl>(D) &&
413 isDoxygenComment(SourceMgr, *LastComment, true)) {
414 std::pair<FileID, unsigned> LastCommentEndDecomp
415 = SourceMgr.getDecomposedLoc(LastComment->getEnd());
416 if (DeclStartDecomp.first == LastCommentEndDecomp.first &&
417 SourceMgr.getLineNumber(DeclStartDecomp.first, DeclStartDecomp.second)
Mike Stump1eb44332009-09-09 15:08:12 +0000418 == SourceMgr.getLineNumber(LastCommentEndDecomp.first,
Douglas Gregor2e222532009-07-02 17:08:52 +0000419 LastCommentEndDecomp.second)) {
420 // The Doxygen member comment comes after the declaration starts and
421 // is on the same line and in the same file as the declaration. This
422 // is the comment we want.
423 std::string &Result = DeclComments[D];
Mike Stump1eb44332009-09-09 15:08:12 +0000424 Result.append(FileBufferStart +
425 SourceMgr.getFileOffset(LastComment->getBegin()),
Douglas Gregor2e222532009-07-02 17:08:52 +0000426 FileBufferStart + LastCommentEndDecomp.second + 1);
427 return Result.c_str();
428 }
429 }
Mike Stump1eb44332009-09-09 15:08:12 +0000430
Douglas Gregor2e222532009-07-02 17:08:52 +0000431 if (LastComment == Comments.begin())
432 return 0;
433 --LastComment;
434
435 // Decompose the end of the comment.
436 std::pair<FileID, unsigned> LastCommentEndDecomp
437 = SourceMgr.getDecomposedLoc(LastComment->getEnd());
Mike Stump1eb44332009-09-09 15:08:12 +0000438
Douglas Gregor2e222532009-07-02 17:08:52 +0000439 // If the comment and the declaration aren't in the same file, then they
440 // aren't related.
441 if (DeclStartDecomp.first != LastCommentEndDecomp.first)
442 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000443
Douglas Gregor2e222532009-07-02 17:08:52 +0000444 // Check that we actually have a Doxygen comment.
445 if (!isDoxygenComment(SourceMgr, *LastComment))
446 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000447
Douglas Gregor2e222532009-07-02 17:08:52 +0000448 // Compute the starting line for the declaration and for the end of the
449 // comment (this is expensive).
Mike Stump1eb44332009-09-09 15:08:12 +0000450 unsigned DeclStartLine
Douglas Gregor2e222532009-07-02 17:08:52 +0000451 = SourceMgr.getLineNumber(DeclStartDecomp.first, DeclStartDecomp.second);
452 unsigned CommentEndLine
Mike Stump1eb44332009-09-09 15:08:12 +0000453 = SourceMgr.getLineNumber(LastCommentEndDecomp.first,
Douglas Gregor2e222532009-07-02 17:08:52 +0000454 LastCommentEndDecomp.second);
Mike Stump1eb44332009-09-09 15:08:12 +0000455
Douglas Gregor2e222532009-07-02 17:08:52 +0000456 // If the comment does not end on the line prior to the declaration, then
457 // the comment is not associated with the declaration at all.
458 if (CommentEndLine + 1 != DeclStartLine)
459 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000460
Douglas Gregor2e222532009-07-02 17:08:52 +0000461 // We have a comment, but there may be more comments on the previous lines.
462 // Keep looking so long as the comments are still Doxygen comments and are
463 // still adjacent.
Mike Stump1eb44332009-09-09 15:08:12 +0000464 unsigned ExpectedLine
Douglas Gregor2e222532009-07-02 17:08:52 +0000465 = SourceMgr.getSpellingLineNumber(LastComment->getBegin()) - 1;
466 std::vector<SourceRange>::iterator FirstComment = LastComment;
467 while (FirstComment != Comments.begin()) {
468 // Look at the previous comment
469 --FirstComment;
470 std::pair<FileID, unsigned> Decomp
471 = SourceMgr.getDecomposedLoc(FirstComment->getEnd());
Mike Stump1eb44332009-09-09 15:08:12 +0000472
Douglas Gregor2e222532009-07-02 17:08:52 +0000473 // If this previous comment is in a different file, we're done.
474 if (Decomp.first != DeclStartDecomp.first) {
475 ++FirstComment;
476 break;
477 }
Mike Stump1eb44332009-09-09 15:08:12 +0000478
Douglas Gregor2e222532009-07-02 17:08:52 +0000479 // If this comment is not a Doxygen comment, we're done.
480 if (!isDoxygenComment(SourceMgr, *FirstComment)) {
481 ++FirstComment;
482 break;
483 }
Mike Stump1eb44332009-09-09 15:08:12 +0000484
Douglas Gregor2e222532009-07-02 17:08:52 +0000485 // If the line number is not what we expected, we're done.
486 unsigned Line = SourceMgr.getLineNumber(Decomp.first, Decomp.second);
487 if (Line != ExpectedLine) {
488 ++FirstComment;
489 break;
490 }
Mike Stump1eb44332009-09-09 15:08:12 +0000491
Douglas Gregor2e222532009-07-02 17:08:52 +0000492 // Set the next expected line number.
Mike Stump1eb44332009-09-09 15:08:12 +0000493 ExpectedLine
Douglas Gregor2e222532009-07-02 17:08:52 +0000494 = SourceMgr.getSpellingLineNumber(FirstComment->getBegin()) - 1;
495 }
Mike Stump1eb44332009-09-09 15:08:12 +0000496
Douglas Gregor2e222532009-07-02 17:08:52 +0000497 // The iterator range [FirstComment, LastComment] contains all of the
498 // BCPL comments that, together, are associated with this declaration.
499 // Form a single comment block string for this declaration that concatenates
500 // all of these comments.
501 std::string &Result = DeclComments[D];
502 while (FirstComment != LastComment) {
503 std::pair<FileID, unsigned> DecompStart
504 = SourceMgr.getDecomposedLoc(FirstComment->getBegin());
505 std::pair<FileID, unsigned> DecompEnd
506 = SourceMgr.getDecomposedLoc(FirstComment->getEnd());
507 Result.append(FileBufferStart + DecompStart.second,
508 FileBufferStart + DecompEnd.second + 1);
509 ++FirstComment;
510 }
Mike Stump1eb44332009-09-09 15:08:12 +0000511
Douglas Gregor2e222532009-07-02 17:08:52 +0000512 // Append the last comment line.
Mike Stump1eb44332009-09-09 15:08:12 +0000513 Result.append(FileBufferStart +
514 SourceMgr.getFileOffset(LastComment->getBegin()),
Douglas Gregor2e222532009-07-02 17:08:52 +0000515 FileBufferStart + LastCommentEndDecomp.second + 1);
516 return Result.c_str();
517}
518
Chris Lattner464175b2007-07-18 17:52:12 +0000519//===----------------------------------------------------------------------===//
520// Type Sizing and Analysis
521//===----------------------------------------------------------------------===//
Chris Lattnera7674d82007-07-13 22:13:22 +0000522
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000523/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
524/// scalar floating point type.
525const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
John McCall183700f2009-09-21 23:43:11 +0000526 const BuiltinType *BT = T->getAs<BuiltinType>();
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000527 assert(BT && "Not a floating point type!");
528 switch (BT->getKind()) {
529 default: assert(0 && "Not a floating point type!");
530 case BuiltinType::Float: return Target.getFloatFormat();
531 case BuiltinType::Double: return Target.getDoubleFormat();
532 case BuiltinType::LongDouble: return Target.getLongDoubleFormat();
533 }
534}
535
Mike Stump196efbf2009-09-22 02:43:44 +0000536/// getDeclAlignInBytes - Return a conservative estimate of the alignment of the
Chris Lattneraf707ab2009-01-24 21:53:27 +0000537/// specified decl. Note that bitfields do not have a valid alignment, so
538/// this method will assert on them.
Sebastian Redl5d484e82009-11-23 17:18:46 +0000539/// If @p RefAsPointee, references are treated like their underlying type
540/// (for alignof), else they're treated like pointers (for CodeGen).
541unsigned ASTContext::getDeclAlignInBytes(const Decl *D, bool RefAsPointee) {
Eli Friedmandcdafb62009-02-22 02:56:25 +0000542 unsigned Align = Target.getCharWidth();
543
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000544 if (const AlignedAttr* AA = D->getAttr<AlignedAttr>())
Sean Huntbbd37c62009-11-21 08:43:09 +0000545 Align = std::max(Align, AA->getMaxAlignment());
Eli Friedmandcdafb62009-02-22 02:56:25 +0000546
Chris Lattneraf707ab2009-01-24 21:53:27 +0000547 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
548 QualType T = VD->getType();
Ted Kremenek6217b802009-07-29 21:53:49 +0000549 if (const ReferenceType* RT = T->getAs<ReferenceType>()) {
Sebastian Redl5d484e82009-11-23 17:18:46 +0000550 if (RefAsPointee)
551 T = RT->getPointeeType();
552 else
553 T = getPointerType(RT->getPointeeType());
554 }
555 if (!T->isIncompleteType() && !T->isFunctionType()) {
Anders Carlsson4cc2cfd2009-04-10 04:47:03 +0000556 // Incomplete or function types default to 1.
Eli Friedmandcdafb62009-02-22 02:56:25 +0000557 while (isa<VariableArrayType>(T) || isa<IncompleteArrayType>(T))
558 T = cast<ArrayType>(T)->getElementType();
559
560 Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
561 }
Chris Lattneraf707ab2009-01-24 21:53:27 +0000562 }
Eli Friedmandcdafb62009-02-22 02:56:25 +0000563
564 return Align / Target.getCharWidth();
Chris Lattneraf707ab2009-01-24 21:53:27 +0000565}
Chris Lattnerb7cfe882008-06-30 18:32:54 +0000566
Chris Lattnera7674d82007-07-13 22:13:22 +0000567/// getTypeSize - Return the size of the specified type, in bits. This method
568/// does not work on incomplete types.
John McCall0953e762009-09-24 19:53:00 +0000569///
570/// FIXME: Pointers into different addr spaces could have different sizes and
571/// alignment requirements: getPointerInfo should take an AddrSpace, this
572/// should take a QualType, &c.
Chris Lattnerd2d2a112007-07-14 01:29:45 +0000573std::pair<uint64_t, unsigned>
Daniel Dunbar1d751182008-11-08 05:48:37 +0000574ASTContext::getTypeInfo(const Type *T) {
Mike Stump5e301002009-02-27 18:32:39 +0000575 uint64_t Width=0;
576 unsigned Align=8;
Chris Lattnera7674d82007-07-13 22:13:22 +0000577 switch (T->getTypeClass()) {
Douglas Gregor72564e72009-02-26 23:50:07 +0000578#define TYPE(Class, Base)
579#define ABSTRACT_TYPE(Class, Base)
Douglas Gregor18857642009-04-30 17:32:17 +0000580#define NON_CANONICAL_TYPE(Class, Base)
Douglas Gregor72564e72009-02-26 23:50:07 +0000581#define DEPENDENT_TYPE(Class, Base) case Type::Class:
582#include "clang/AST/TypeNodes.def"
Douglas Gregor18857642009-04-30 17:32:17 +0000583 assert(false && "Should not see dependent types");
Douglas Gregor72564e72009-02-26 23:50:07 +0000584 break;
585
Chris Lattner692233e2007-07-13 22:27:08 +0000586 case Type::FunctionNoProto:
587 case Type::FunctionProto:
Douglas Gregor18857642009-04-30 17:32:17 +0000588 // GCC extension: alignof(function) = 32 bits
589 Width = 0;
590 Align = 32;
591 break;
592
Douglas Gregor72564e72009-02-26 23:50:07 +0000593 case Type::IncompleteArray:
Steve Narofffb22d962007-08-30 01:06:46 +0000594 case Type::VariableArray:
Douglas Gregor18857642009-04-30 17:32:17 +0000595 Width = 0;
596 Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
597 break;
598
Steve Narofffb22d962007-08-30 01:06:46 +0000599 case Type::ConstantArray: {
Daniel Dunbar1d751182008-11-08 05:48:37 +0000600 const ConstantArrayType *CAT = cast<ConstantArrayType>(T);
Mike Stump1eb44332009-09-09 15:08:12 +0000601
Chris Lattner98be4942008-03-05 18:54:05 +0000602 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(CAT->getElementType());
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000603 Width = EltInfo.first*CAT->getSize().getZExtValue();
Chris Lattner030d8842007-07-19 22:06:24 +0000604 Align = EltInfo.second;
605 break;
Christopher Lamb5c09a022007-12-29 05:10:55 +0000606 }
Nate Begeman213541a2008-04-18 23:10:10 +0000607 case Type::ExtVector:
Chris Lattner030d8842007-07-19 22:06:24 +0000608 case Type::Vector: {
Chris Lattner9fcfe922009-10-22 05:17:15 +0000609 const VectorType *VT = cast<VectorType>(T);
610 std::pair<uint64_t, unsigned> EltInfo = getTypeInfo(VT->getElementType());
611 Width = EltInfo.first*VT->getNumElements();
Eli Friedman4bd998b2008-05-30 09:31:38 +0000612 Align = Width;
Nate Begeman6fe7c8a2009-01-18 06:42:49 +0000613 // If the alignment is not a power of 2, round up to the next power of 2.
614 // This happens for non-power-of-2 length vectors.
Chris Lattner9fcfe922009-10-22 05:17:15 +0000615 if (VT->getNumElements() & (VT->getNumElements()-1)) {
616 Align = llvm::NextPowerOf2(Align);
617 Width = llvm::RoundUpToAlignment(Width, Align);
618 }
Chris Lattner030d8842007-07-19 22:06:24 +0000619 break;
620 }
Chris Lattner5d2a6302007-07-18 18:26:58 +0000621
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000622 case Type::Builtin:
Chris Lattnera7674d82007-07-13 22:13:22 +0000623 switch (cast<BuiltinType>(T)->getKind()) {
Chris Lattner692233e2007-07-13 22:27:08 +0000624 default: assert(0 && "Unknown builtin type!");
Chris Lattnerd2d2a112007-07-14 01:29:45 +0000625 case BuiltinType::Void:
Douglas Gregor18857642009-04-30 17:32:17 +0000626 // GCC extension: alignof(void) = 8 bits.
627 Width = 0;
628 Align = 8;
629 break;
630
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000631 case BuiltinType::Bool:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000632 Width = Target.getBoolWidth();
633 Align = Target.getBoolAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000634 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000635 case BuiltinType::Char_S:
636 case BuiltinType::Char_U:
637 case BuiltinType::UChar:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000638 case BuiltinType::SChar:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000639 Width = Target.getCharWidth();
640 Align = Target.getCharAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000641 break;
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +0000642 case BuiltinType::WChar:
643 Width = Target.getWCharWidth();
644 Align = Target.getWCharAlign();
645 break;
Alisdair Meredithf5c209d2009-07-14 06:30:34 +0000646 case BuiltinType::Char16:
647 Width = Target.getChar16Width();
648 Align = Target.getChar16Align();
649 break;
650 case BuiltinType::Char32:
651 Width = Target.getChar32Width();
652 Align = Target.getChar32Align();
653 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000654 case BuiltinType::UShort:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000655 case BuiltinType::Short:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000656 Width = Target.getShortWidth();
657 Align = Target.getShortAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000658 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000659 case BuiltinType::UInt:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000660 case BuiltinType::Int:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000661 Width = Target.getIntWidth();
662 Align = Target.getIntAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000663 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000664 case BuiltinType::ULong:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000665 case BuiltinType::Long:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000666 Width = Target.getLongWidth();
667 Align = Target.getLongAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000668 break;
Chris Lattner692233e2007-07-13 22:27:08 +0000669 case BuiltinType::ULongLong:
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000670 case BuiltinType::LongLong:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000671 Width = Target.getLongLongWidth();
672 Align = Target.getLongLongAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000673 break;
Chris Lattnerec16cb92009-04-30 02:55:13 +0000674 case BuiltinType::Int128:
675 case BuiltinType::UInt128:
676 Width = 128;
677 Align = 128; // int128_t is 128-bit aligned on all targets.
678 break;
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000679 case BuiltinType::Float:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000680 Width = Target.getFloatWidth();
681 Align = Target.getFloatAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000682 break;
683 case BuiltinType::Double:
Chris Lattner5426bf62008-04-07 07:01:58 +0000684 Width = Target.getDoubleWidth();
685 Align = Target.getDoubleAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000686 break;
687 case BuiltinType::LongDouble:
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000688 Width = Target.getLongDoubleWidth();
689 Align = Target.getLongDoubleAlign();
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000690 break;
Sebastian Redl6e8ed162009-05-10 18:38:11 +0000691 case BuiltinType::NullPtr:
692 Width = Target.getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
693 Align = Target.getPointerAlign(0); // == sizeof(void*)
Sebastian Redl1590d9c2009-05-27 19:34:06 +0000694 break;
Chris Lattnera7674d82007-07-13 22:13:22 +0000695 }
Chris Lattnerbfef6d72007-07-15 23:46:53 +0000696 break;
Eli Friedmanf98aba32009-02-13 02:31:07 +0000697 case Type::FixedWidthInt:
698 // FIXME: This isn't precisely correct; the width/alignment should depend
699 // on the available types for the target
700 Width = cast<FixedWidthIntType>(T)->getWidth();
Chris Lattner736166b2009-02-15 21:20:13 +0000701 Width = std::max(llvm::NextPowerOf2(Width - 1), (uint64_t)8);
Eli Friedmanf98aba32009-02-13 02:31:07 +0000702 Align = Width;
703 break;
Steve Naroffd1b3c2d2009-06-17 22:40:22 +0000704 case Type::ObjCObjectPointer:
Chris Lattner5426bf62008-04-07 07:01:58 +0000705 Width = Target.getPointerWidth(0);
Chris Lattnerf72a4432008-03-08 08:34:58 +0000706 Align = Target.getPointerAlign(0);
Chris Lattner6f62c2a2007-12-19 19:23:28 +0000707 break;
Steve Naroff485eeff2008-09-24 15:05:44 +0000708 case Type::BlockPointer: {
709 unsigned AS = cast<BlockPointerType>(T)->getPointeeType().getAddressSpace();
710 Width = Target.getPointerWidth(AS);
711 Align = Target.getPointerAlign(AS);
712 break;
713 }
Sebastian Redl5d484e82009-11-23 17:18:46 +0000714 case Type::LValueReference:
715 case Type::RValueReference: {
716 // alignof and sizeof should never enter this code path here, so we go
717 // the pointer route.
718 unsigned AS = cast<ReferenceType>(T)->getPointeeType().getAddressSpace();
719 Width = Target.getPointerWidth(AS);
720 Align = Target.getPointerAlign(AS);
721 break;
722 }
Chris Lattnerf72a4432008-03-08 08:34:58 +0000723 case Type::Pointer: {
724 unsigned AS = cast<PointerType>(T)->getPointeeType().getAddressSpace();
Chris Lattner5426bf62008-04-07 07:01:58 +0000725 Width = Target.getPointerWidth(AS);
Chris Lattnerf72a4432008-03-08 08:34:58 +0000726 Align = Target.getPointerAlign(AS);
727 break;
728 }
Sebastian Redlf30208a2009-01-24 21:16:55 +0000729 case Type::MemberPointer: {
Sebastian Redlf30208a2009-01-24 21:16:55 +0000730 QualType Pointee = cast<MemberPointerType>(T)->getPointeeType();
Mike Stump1eb44332009-09-09 15:08:12 +0000731 std::pair<uint64_t, unsigned> PtrDiffInfo =
Anders Carlsson1cca74e2009-05-17 02:06:04 +0000732 getTypeInfo(getPointerDiffType());
733 Width = PtrDiffInfo.first;
Sebastian Redlf30208a2009-01-24 21:16:55 +0000734 if (Pointee->isFunctionType())
735 Width *= 2;
Anders Carlsson1cca74e2009-05-17 02:06:04 +0000736 Align = PtrDiffInfo.second;
737 break;
Sebastian Redlf30208a2009-01-24 21:16:55 +0000738 }
Chris Lattner5d2a6302007-07-18 18:26:58 +0000739 case Type::Complex: {
740 // Complex types have the same alignment as their elements, but twice the
741 // size.
Mike Stump1eb44332009-09-09 15:08:12 +0000742 std::pair<uint64_t, unsigned> EltInfo =
Chris Lattner98be4942008-03-05 18:54:05 +0000743 getTypeInfo(cast<ComplexType>(T)->getElementType());
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000744 Width = EltInfo.first*2;
Chris Lattner5d2a6302007-07-18 18:26:58 +0000745 Align = EltInfo.second;
746 break;
747 }
Devang Patel44a3dde2008-06-04 21:54:36 +0000748 case Type::ObjCInterface: {
Daniel Dunbar1d751182008-11-08 05:48:37 +0000749 const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T);
Devang Patel44a3dde2008-06-04 21:54:36 +0000750 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
751 Width = Layout.getSize();
752 Align = Layout.getAlignment();
753 break;
754 }
Douglas Gregor72564e72009-02-26 23:50:07 +0000755 case Type::Record:
Douglas Gregor72564e72009-02-26 23:50:07 +0000756 case Type::Enum: {
Daniel Dunbar1d751182008-11-08 05:48:37 +0000757 const TagType *TT = cast<TagType>(T);
758
759 if (TT->getDecl()->isInvalidDecl()) {
Chris Lattner8389eab2008-08-09 21:35:13 +0000760 Width = 1;
761 Align = 1;
762 break;
763 }
Mike Stump1eb44332009-09-09 15:08:12 +0000764
Daniel Dunbar1d751182008-11-08 05:48:37 +0000765 if (const EnumType *ET = dyn_cast<EnumType>(TT))
Chris Lattner71763312008-04-06 22:05:18 +0000766 return getTypeInfo(ET->getDecl()->getIntegerType());
767
Daniel Dunbar1d751182008-11-08 05:48:37 +0000768 const RecordType *RT = cast<RecordType>(TT);
Chris Lattner71763312008-04-06 22:05:18 +0000769 const ASTRecordLayout &Layout = getASTRecordLayout(RT->getDecl());
770 Width = Layout.getSize();
771 Align = Layout.getAlignment();
Chris Lattnerdc0d73e2007-07-23 22:46:22 +0000772 break;
Chris Lattnera7674d82007-07-13 22:13:22 +0000773 }
Douglas Gregor7532dc62009-03-30 22:58:21 +0000774
Chris Lattner9fcfe922009-10-22 05:17:15 +0000775 case Type::SubstTemplateTypeParm:
John McCall49a832b2009-10-18 09:09:24 +0000776 return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
777 getReplacementType().getTypePtr());
John McCall49a832b2009-10-18 09:09:24 +0000778
Chris Lattner9fcfe922009-10-22 05:17:15 +0000779 case Type::Elaborated:
780 return getTypeInfo(cast<ElaboratedType>(T)->getUnderlyingType()
781 .getTypePtr());
John McCall7da24312009-09-05 00:15:47 +0000782
Douglas Gregor18857642009-04-30 17:32:17 +0000783 case Type::Typedef: {
784 const TypedefDecl *Typedef = cast<TypedefType>(T)->getDecl();
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000785 if (const AlignedAttr *Aligned = Typedef->getAttr<AlignedAttr>()) {
Sean Huntbbd37c62009-11-21 08:43:09 +0000786 Align = std::max(Aligned->getMaxAlignment(),
787 getTypeAlign(Typedef->getUnderlyingType().getTypePtr()));
Douglas Gregor18857642009-04-30 17:32:17 +0000788 Width = getTypeSize(Typedef->getUnderlyingType().getTypePtr());
789 } else
790 return getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
Douglas Gregor7532dc62009-03-30 22:58:21 +0000791 break;
Chris Lattner71763312008-04-06 22:05:18 +0000792 }
Douglas Gregor18857642009-04-30 17:32:17 +0000793
794 case Type::TypeOfExpr:
795 return getTypeInfo(cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType()
796 .getTypePtr());
797
798 case Type::TypeOf:
799 return getTypeInfo(cast<TypeOfType>(T)->getUnderlyingType().getTypePtr());
800
Anders Carlsson395b4752009-06-24 19:06:50 +0000801 case Type::Decltype:
802 return getTypeInfo(cast<DecltypeType>(T)->getUnderlyingExpr()->getType()
803 .getTypePtr());
804
Douglas Gregor18857642009-04-30 17:32:17 +0000805 case Type::QualifiedName:
806 return getTypeInfo(cast<QualifiedNameType>(T)->getNamedType().getTypePtr());
Mike Stump1eb44332009-09-09 15:08:12 +0000807
Douglas Gregor18857642009-04-30 17:32:17 +0000808 case Type::TemplateSpecialization:
Mike Stump1eb44332009-09-09 15:08:12 +0000809 assert(getCanonicalType(T) != T &&
Douglas Gregor18857642009-04-30 17:32:17 +0000810 "Cannot request the size of a dependent type");
811 // FIXME: this is likely to be wrong once we support template
812 // aliases, since a template alias could refer to a typedef that
813 // has an __aligned__ attribute on it.
814 return getTypeInfo(getCanonicalType(T));
815 }
Mike Stump1eb44332009-09-09 15:08:12 +0000816
Chris Lattner464175b2007-07-18 17:52:12 +0000817 assert(Align && (Align & (Align-1)) == 0 && "Alignment must be power of 2");
Chris Lattner9e9b6dc2008-03-08 08:52:55 +0000818 return std::make_pair(Width, Align);
Chris Lattnera7674d82007-07-13 22:13:22 +0000819}
820
Chris Lattner34ebde42009-01-27 18:08:34 +0000821/// getPreferredTypeAlign - Return the "preferred" alignment of the specified
822/// type for the current target in bits. This can be different than the ABI
823/// alignment in cases where it is beneficial for performance to overalign
824/// a data type.
825unsigned ASTContext::getPreferredTypeAlign(const Type *T) {
826 unsigned ABIAlign = getTypeAlign(T);
Eli Friedman1eed6022009-05-25 21:27:19 +0000827
828 // Double and long long should be naturally aligned if possible.
John McCall183700f2009-09-21 23:43:11 +0000829 if (const ComplexType* CT = T->getAs<ComplexType>())
Eli Friedman1eed6022009-05-25 21:27:19 +0000830 T = CT->getElementType().getTypePtr();
831 if (T->isSpecificBuiltinType(BuiltinType::Double) ||
832 T->isSpecificBuiltinType(BuiltinType::LongLong))
833 return std::max(ABIAlign, (unsigned)getTypeSize(T));
834
Chris Lattner34ebde42009-01-27 18:08:34 +0000835 return ABIAlign;
836}
837
Daniel Dunbara80a0f62009-04-22 17:43:55 +0000838static void CollectLocalObjCIvars(ASTContext *Ctx,
839 const ObjCInterfaceDecl *OI,
840 llvm::SmallVectorImpl<FieldDecl*> &Fields) {
Fariborz Jahaniana769c002008-12-17 21:40:49 +0000841 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(),
842 E = OI->ivar_end(); I != E; ++I) {
Chris Lattnerf1690852009-03-31 08:48:01 +0000843 ObjCIvarDecl *IVDecl = *I;
Fariborz Jahaniana769c002008-12-17 21:40:49 +0000844 if (!IVDecl->isInvalidDecl())
845 Fields.push_back(cast<FieldDecl>(IVDecl));
846 }
847}
848
Daniel Dunbara80a0f62009-04-22 17:43:55 +0000849void ASTContext::CollectObjCIvars(const ObjCInterfaceDecl *OI,
850 llvm::SmallVectorImpl<FieldDecl*> &Fields) {
851 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
852 CollectObjCIvars(SuperClass, Fields);
853 CollectLocalObjCIvars(this, OI, Fields);
854}
855
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000856/// ShallowCollectObjCIvars -
857/// Collect all ivars, including those synthesized, in the current class.
858///
859void ASTContext::ShallowCollectObjCIvars(const ObjCInterfaceDecl *OI,
860 llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars,
861 bool CollectSynthesized) {
862 for (ObjCInterfaceDecl::ivar_iterator I = OI->ivar_begin(),
863 E = OI->ivar_end(); I != E; ++I) {
864 Ivars.push_back(*I);
865 }
866 if (CollectSynthesized)
867 CollectSynthesizedIvars(OI, Ivars);
868}
869
Fariborz Jahanian98200742009-05-12 18:14:29 +0000870void ASTContext::CollectProtocolSynthesizedIvars(const ObjCProtocolDecl *PD,
871 llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000872 for (ObjCContainerDecl::prop_iterator I = PD->prop_begin(),
873 E = PD->prop_end(); I != E; ++I)
Fariborz Jahanian98200742009-05-12 18:14:29 +0000874 if (ObjCIvarDecl *Ivar = (*I)->getPropertyIvarDecl())
875 Ivars.push_back(Ivar);
Mike Stump1eb44332009-09-09 15:08:12 +0000876
Fariborz Jahanian98200742009-05-12 18:14:29 +0000877 // Also look into nested protocols.
878 for (ObjCProtocolDecl::protocol_iterator P = PD->protocol_begin(),
879 E = PD->protocol_end(); P != E; ++P)
880 CollectProtocolSynthesizedIvars(*P, Ivars);
881}
882
883/// CollectSynthesizedIvars -
884/// This routine collect synthesized ivars for the designated class.
885///
886void ASTContext::CollectSynthesizedIvars(const ObjCInterfaceDecl *OI,
887 llvm::SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000888 for (ObjCInterfaceDecl::prop_iterator I = OI->prop_begin(),
889 E = OI->prop_end(); I != E; ++I) {
Fariborz Jahanian98200742009-05-12 18:14:29 +0000890 if (ObjCIvarDecl *Ivar = (*I)->getPropertyIvarDecl())
891 Ivars.push_back(Ivar);
892 }
893 // Also look into interface's protocol list for properties declared
894 // in the protocol and whose ivars are synthesized.
895 for (ObjCInterfaceDecl::protocol_iterator P = OI->protocol_begin(),
896 PE = OI->protocol_end(); P != PE; ++P) {
897 ObjCProtocolDecl *PD = (*P);
898 CollectProtocolSynthesizedIvars(PD, Ivars);
899 }
900}
901
Fariborz Jahaniane23fa2d2009-10-30 01:13:23 +0000902/// CollectInheritedProtocols - Collect all protocols in current class and
903/// those inherited by it.
904void ASTContext::CollectInheritedProtocols(const Decl *CDecl,
905 llvm::SmallVectorImpl<ObjCProtocolDecl*> &Protocols) {
906 if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
907 for (ObjCInterfaceDecl::protocol_iterator P = OI->protocol_begin(),
908 PE = OI->protocol_end(); P != PE; ++P) {
909 ObjCProtocolDecl *Proto = (*P);
910 Protocols.push_back(Proto);
911 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
912 PE = Proto->protocol_end(); P != PE; ++P)
913 CollectInheritedProtocols(*P, Protocols);
914 }
915
916 // Categories of this Interface.
917 for (const ObjCCategoryDecl *CDeclChain = OI->getCategoryList();
918 CDeclChain; CDeclChain = CDeclChain->getNextClassCategory())
919 CollectInheritedProtocols(CDeclChain, Protocols);
920 if (ObjCInterfaceDecl *SD = OI->getSuperClass())
921 while (SD) {
922 CollectInheritedProtocols(SD, Protocols);
923 SD = SD->getSuperClass();
924 }
925 return;
926 }
927 if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
928 for (ObjCInterfaceDecl::protocol_iterator P = OC->protocol_begin(),
929 PE = OC->protocol_end(); P != PE; ++P) {
930 ObjCProtocolDecl *Proto = (*P);
931 Protocols.push_back(Proto);
932 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
933 PE = Proto->protocol_end(); P != PE; ++P)
934 CollectInheritedProtocols(*P, Protocols);
935 }
936 return;
937 }
938 if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
939 for (ObjCProtocolDecl::protocol_iterator P = OP->protocol_begin(),
940 PE = OP->protocol_end(); P != PE; ++P) {
941 ObjCProtocolDecl *Proto = (*P);
942 Protocols.push_back(Proto);
943 for (ObjCProtocolDecl::protocol_iterator P = Proto->protocol_begin(),
944 PE = Proto->protocol_end(); P != PE; ++P)
945 CollectInheritedProtocols(*P, Protocols);
946 }
947 return;
948 }
949}
950
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000951unsigned ASTContext::CountProtocolSynthesizedIvars(const ObjCProtocolDecl *PD) {
952 unsigned count = 0;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000953 for (ObjCContainerDecl::prop_iterator I = PD->prop_begin(),
954 E = PD->prop_end(); I != E; ++I)
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000955 if ((*I)->getPropertyIvarDecl())
956 ++count;
957
958 // Also look into nested protocols.
959 for (ObjCProtocolDecl::protocol_iterator P = PD->protocol_begin(),
960 E = PD->protocol_end(); P != E; ++P)
961 count += CountProtocolSynthesizedIvars(*P);
962 return count;
963}
964
Mike Stump1eb44332009-09-09 15:08:12 +0000965unsigned ASTContext::CountSynthesizedIvars(const ObjCInterfaceDecl *OI) {
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000966 unsigned count = 0;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000967 for (ObjCInterfaceDecl::prop_iterator I = OI->prop_begin(),
968 E = OI->prop_end(); I != E; ++I) {
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +0000969 if ((*I)->getPropertyIvarDecl())
970 ++count;
971 }
972 // Also look into interface's protocol list for properties declared
973 // in the protocol and whose ivars are synthesized.
974 for (ObjCInterfaceDecl::protocol_iterator P = OI->protocol_begin(),
975 PE = OI->protocol_end(); P != PE; ++P) {
976 ObjCProtocolDecl *PD = (*P);
977 count += CountProtocolSynthesizedIvars(PD);
978 }
979 return count;
980}
981
Argyrios Kyrtzidis8a1d7222009-07-21 00:05:53 +0000982/// \brief Get the implementation of ObjCInterfaceDecl,or NULL if none exists.
983ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
984 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
985 I = ObjCImpls.find(D);
986 if (I != ObjCImpls.end())
987 return cast<ObjCImplementationDecl>(I->second);
988 return 0;
989}
990/// \brief Get the implementation of ObjCCategoryDecl, or NULL if none exists.
991ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) {
992 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
993 I = ObjCImpls.find(D);
994 if (I != ObjCImpls.end())
995 return cast<ObjCCategoryImplDecl>(I->second);
996 return 0;
997}
998
999/// \brief Set the implementation of ObjCInterfaceDecl.
1000void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD,
1001 ObjCImplementationDecl *ImplD) {
1002 assert(IFaceD && ImplD && "Passed null params");
1003 ObjCImpls[IFaceD] = ImplD;
1004}
1005/// \brief Set the implementation of ObjCCategoryDecl.
1006void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD,
1007 ObjCCategoryImplDecl *ImplD) {
1008 assert(CatD && ImplD && "Passed null params");
1009 ObjCImpls[CatD] = ImplD;
1010}
1011
John McCalla93c9342009-12-07 02:54:59 +00001012/// \brief Allocate an uninitialized TypeSourceInfo.
Argyrios Kyrtzidisb17166c2009-08-19 01:27:32 +00001013///
John McCalla93c9342009-12-07 02:54:59 +00001014/// The caller should initialize the memory held by TypeSourceInfo using
Argyrios Kyrtzidisb17166c2009-08-19 01:27:32 +00001015/// the TypeLoc wrappers.
1016///
1017/// \param T the type that will be the basis for type source info. This type
1018/// should refer to how the declarator was written in source code, not to
1019/// what type semantic analysis resolved the declarator to.
John McCalla93c9342009-12-07 02:54:59 +00001020TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T,
John McCall109de5e2009-10-21 00:23:54 +00001021 unsigned DataSize) {
1022 if (!DataSize)
1023 DataSize = TypeLoc::getFullDataSizeForType(T);
1024 else
1025 assert(DataSize == TypeLoc::getFullDataSizeForType(T) &&
John McCalla93c9342009-12-07 02:54:59 +00001026 "incorrect data size provided to CreateTypeSourceInfo!");
John McCall109de5e2009-10-21 00:23:54 +00001027
John McCalla93c9342009-12-07 02:54:59 +00001028 TypeSourceInfo *TInfo =
1029 (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
1030 new (TInfo) TypeSourceInfo(T);
1031 return TInfo;
Argyrios Kyrtzidisb17166c2009-08-19 01:27:32 +00001032}
1033
John McCalla93c9342009-12-07 02:54:59 +00001034TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T,
John McCalla4eb74d2009-10-23 21:14:09 +00001035 SourceLocation L) {
John McCalla93c9342009-12-07 02:54:59 +00001036 TypeSourceInfo *DI = CreateTypeSourceInfo(T);
John McCalla4eb74d2009-10-23 21:14:09 +00001037 DI->getTypeLoc().initialize(L);
1038 return DI;
1039}
1040
Daniel Dunbarb2dbbb92009-05-03 10:38:35 +00001041/// getInterfaceLayoutImpl - Get or compute information about the
1042/// layout of the given interface.
1043///
1044/// \param Impl - If given, also include the layout of the interface's
1045/// implementation. This may differ by including synthesized ivars.
Devang Patel44a3dde2008-06-04 21:54:36 +00001046const ASTRecordLayout &
Daniel Dunbarb2dbbb92009-05-03 10:38:35 +00001047ASTContext::getObjCLayout(const ObjCInterfaceDecl *D,
1048 const ObjCImplementationDecl *Impl) {
Daniel Dunbar532d4da2009-05-03 13:15:50 +00001049 assert(!D->isForwardDecl() && "Invalid interface decl!");
1050
Devang Patel44a3dde2008-06-04 21:54:36 +00001051 // Look up this layout, if already laid out, return what we have.
Mike Stump1eb44332009-09-09 15:08:12 +00001052 ObjCContainerDecl *Key =
Daniel Dunbard8fd6ff2009-05-03 11:41:43 +00001053 Impl ? (ObjCContainerDecl*) Impl : (ObjCContainerDecl*) D;
1054 if (const ASTRecordLayout *Entry = ObjCLayouts[Key])
1055 return *Entry;
Devang Patel44a3dde2008-06-04 21:54:36 +00001056
Daniel Dunbar453addb2009-05-03 11:16:44 +00001057 // Add in synthesized ivar count if laying out an implementation.
1058 if (Impl) {
Anders Carlsson29445a02009-07-18 21:19:52 +00001059 unsigned FieldCount = D->ivar_size();
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +00001060 unsigned SynthCount = CountSynthesizedIvars(D);
1061 FieldCount += SynthCount;
Daniel Dunbard8fd6ff2009-05-03 11:41:43 +00001062 // If there aren't any sythesized ivars then reuse the interface
Daniel Dunbar453addb2009-05-03 11:16:44 +00001063 // entry. Note we can't cache this because we simply free all
1064 // entries later; however we shouldn't look up implementations
1065 // frequently.
Fariborz Jahanian8e6ac1d2009-06-04 01:19:09 +00001066 if (SynthCount == 0)
Daniel Dunbar453addb2009-05-03 11:16:44 +00001067 return getObjCLayout(D, 0);
1068 }
1069
Mike Stump1eb44332009-09-09 15:08:12 +00001070 const ASTRecordLayout *NewEntry =
Anders Carlsson29445a02009-07-18 21:19:52 +00001071 ASTRecordLayoutBuilder::ComputeLayout(*this, D, Impl);
1072 ObjCLayouts[Key] = NewEntry;
Mike Stump1eb44332009-09-09 15:08:12 +00001073
Devang Patel44a3dde2008-06-04 21:54:36 +00001074 return *NewEntry;
1075}
1076
Daniel Dunbarb2dbbb92009-05-03 10:38:35 +00001077const ASTRecordLayout &
1078ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) {
1079 return getObjCLayout(D, 0);
1080}
1081
1082const ASTRecordLayout &
1083ASTContext::getASTObjCImplementationLayout(const ObjCImplementationDecl *D) {
1084 return getObjCLayout(D->getClassInterface(), D);
1085}
1086
Devang Patel88a981b2007-11-01 19:11:01 +00001087/// getASTRecordLayout - Get or compute information about the layout of the
Chris Lattner464175b2007-07-18 17:52:12 +00001088/// specified record (struct/union/class), which indicates its size and field
1089/// position information.
Chris Lattner98be4942008-03-05 18:54:05 +00001090const ASTRecordLayout &ASTContext::getASTRecordLayout(const RecordDecl *D) {
Ted Kremenek4b7c9832008-09-05 17:16:31 +00001091 D = D->getDefinition(*this);
1092 assert(D && "Cannot get layout of forward declarations!");
Eli Friedman4bd998b2008-05-30 09:31:38 +00001093
Chris Lattner464175b2007-07-18 17:52:12 +00001094 // Look up this layout, if already laid out, return what we have.
Eli Friedmanab22c432009-07-22 20:29:16 +00001095 // Note that we can't save a reference to the entry because this function
1096 // is recursive.
1097 const ASTRecordLayout *Entry = ASTRecordLayouts[D];
Chris Lattner464175b2007-07-18 17:52:12 +00001098 if (Entry) return *Entry;
Eli Friedman4bd998b2008-05-30 09:31:38 +00001099
Mike Stump1eb44332009-09-09 15:08:12 +00001100 const ASTRecordLayout *NewEntry =
Anders Carlsson29445a02009-07-18 21:19:52 +00001101 ASTRecordLayoutBuilder::ComputeLayout(*this, D);
Eli Friedmanab22c432009-07-22 20:29:16 +00001102 ASTRecordLayouts[D] = NewEntry;
Mike Stump1eb44332009-09-09 15:08:12 +00001103
Chris Lattner5d2a6302007-07-18 18:26:58 +00001104 return *NewEntry;
Chris Lattner464175b2007-07-18 17:52:12 +00001105}
1106
Anders Carlssonf53df232009-12-07 04:35:11 +00001107const CXXMethodDecl *ASTContext::getKeyFunction(const CXXRecordDecl *RD) {
1108 RD = cast<CXXRecordDecl>(RD->getDefinition(*this));
1109 assert(RD && "Cannot get key function for forward declarations!");
1110
1111 const CXXMethodDecl *&Entry = KeyFunctions[RD];
1112 if (!Entry)
1113 Entry = ASTRecordLayoutBuilder::ComputeKeyFunction(RD);
1114 else
1115 assert(Entry == ASTRecordLayoutBuilder::ComputeKeyFunction(RD) &&
1116 "Key function changed!");
1117
1118 return Entry;
1119}
1120
Chris Lattnera7674d82007-07-13 22:13:22 +00001121//===----------------------------------------------------------------------===//
1122// Type creation/memoization methods
1123//===----------------------------------------------------------------------===//
1124
John McCall0953e762009-09-24 19:53:00 +00001125QualType ASTContext::getExtQualType(const Type *TypeNode, Qualifiers Quals) {
1126 unsigned Fast = Quals.getFastQualifiers();
1127 Quals.removeFastQualifiers();
1128
1129 // Check if we've already instantiated this type.
1130 llvm::FoldingSetNodeID ID;
1131 ExtQuals::Profile(ID, TypeNode, Quals);
1132 void *InsertPos = 0;
1133 if (ExtQuals *EQ = ExtQualNodes.FindNodeOrInsertPos(ID, InsertPos)) {
1134 assert(EQ->getQualifiers() == Quals);
1135 QualType T = QualType(EQ, Fast);
1136 return T;
1137 }
1138
John McCall6b304a02009-09-24 23:30:46 +00001139 ExtQuals *New = new (*this, TypeAlignment) ExtQuals(*this, TypeNode, Quals);
John McCall0953e762009-09-24 19:53:00 +00001140 ExtQualNodes.InsertNode(New, InsertPos);
1141 QualType T = QualType(New, Fast);
1142 return T;
1143}
1144
1145QualType ASTContext::getVolatileType(QualType T) {
1146 QualType CanT = getCanonicalType(T);
1147 if (CanT.isVolatileQualified()) return T;
1148
1149 QualifierCollector Quals;
1150 const Type *TypeNode = Quals.strip(T);
1151 Quals.addVolatile();
1152
1153 return getExtQualType(TypeNode, Quals);
1154}
1155
Fariborz Jahanianf11284a2009-02-17 18:27:45 +00001156QualType ASTContext::getAddrSpaceQualType(QualType T, unsigned AddressSpace) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001157 QualType CanT = getCanonicalType(T);
1158 if (CanT.getAddressSpace() == AddressSpace)
Chris Lattnerf46699c2008-02-20 20:55:12 +00001159 return T;
Chris Lattnerb7d25532009-02-18 22:53:11 +00001160
John McCall0953e762009-09-24 19:53:00 +00001161 // If we are composing extended qualifiers together, merge together
1162 // into one ExtQuals node.
1163 QualifierCollector Quals;
1164 const Type *TypeNode = Quals.strip(T);
Mike Stump1eb44332009-09-09 15:08:12 +00001165
John McCall0953e762009-09-24 19:53:00 +00001166 // If this type already has an address space specified, it cannot get
1167 // another one.
1168 assert(!Quals.hasAddressSpace() &&
1169 "Type cannot be in multiple addr spaces!");
1170 Quals.addAddressSpace(AddressSpace);
Mike Stump1eb44332009-09-09 15:08:12 +00001171
John McCall0953e762009-09-24 19:53:00 +00001172 return getExtQualType(TypeNode, Quals);
Christopher Lambebb97e92008-02-04 02:31:56 +00001173}
1174
Chris Lattnerb7d25532009-02-18 22:53:11 +00001175QualType ASTContext::getObjCGCQualType(QualType T,
John McCall0953e762009-09-24 19:53:00 +00001176 Qualifiers::GC GCAttr) {
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001177 QualType CanT = getCanonicalType(T);
Chris Lattnerb7d25532009-02-18 22:53:11 +00001178 if (CanT.getObjCGCAttr() == GCAttr)
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001179 return T;
Mike Stump1eb44332009-09-09 15:08:12 +00001180
Fariborz Jahanian4027cd12009-06-03 17:15:17 +00001181 if (T->isPointerType()) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001182 QualType Pointee = T->getAs<PointerType>()->getPointeeType();
Steve Naroff58f9f2c2009-07-14 18:25:06 +00001183 if (Pointee->isAnyPointerType()) {
Fariborz Jahanian4027cd12009-06-03 17:15:17 +00001184 QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
1185 return getPointerType(ResultType);
1186 }
1187 }
Mike Stump1eb44332009-09-09 15:08:12 +00001188
John McCall0953e762009-09-24 19:53:00 +00001189 // If we are composing extended qualifiers together, merge together
1190 // into one ExtQuals node.
1191 QualifierCollector Quals;
1192 const Type *TypeNode = Quals.strip(T);
Mike Stump1eb44332009-09-09 15:08:12 +00001193
John McCall0953e762009-09-24 19:53:00 +00001194 // If this type already has an ObjCGC specified, it cannot get
1195 // another one.
1196 assert(!Quals.hasObjCGCAttr() &&
1197 "Type cannot have multiple ObjCGCs!");
1198 Quals.addObjCGCAttr(GCAttr);
Mike Stump1eb44332009-09-09 15:08:12 +00001199
John McCall0953e762009-09-24 19:53:00 +00001200 return getExtQualType(TypeNode, Quals);
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001201}
Chris Lattnera7674d82007-07-13 22:13:22 +00001202
Douglas Gregor43c79c22009-12-09 00:47:37 +00001203QualType ASTContext::getNoReturnType(QualType T, bool AddNoReturn) {
John McCall0953e762009-09-24 19:53:00 +00001204 QualType ResultType;
Douglas Gregor43c79c22009-12-09 00:47:37 +00001205 if (const PointerType *Pointer = T->getAs<PointerType>()) {
1206 QualType Pointee = Pointer->getPointeeType();
1207 ResultType = getNoReturnType(Pointee, AddNoReturn);
1208 if (ResultType == Pointee)
1209 return T;
1210
Mike Stump6dcbc292009-07-25 23:24:03 +00001211 ResultType = getPointerType(ResultType);
Douglas Gregor43c79c22009-12-09 00:47:37 +00001212 } else if (const BlockPointerType *BlockPointer
1213 = T->getAs<BlockPointerType>()) {
1214 QualType Pointee = BlockPointer->getPointeeType();
1215 ResultType = getNoReturnType(Pointee, AddNoReturn);
1216 if (ResultType == Pointee)
1217 return T;
1218
Mike Stump6dcbc292009-07-25 23:24:03 +00001219 ResultType = getBlockPointerType(ResultType);
Douglas Gregor43c79c22009-12-09 00:47:37 +00001220 } else if (const FunctionType *F = T->getAs<FunctionType>()) {
1221 if (F->getNoReturnAttr() == AddNoReturn)
1222 return T;
1223
1224 if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(F)) {
1225 ResultType = getFunctionNoProtoType(FNPT->getResultType(), AddNoReturn);
John McCall0953e762009-09-24 19:53:00 +00001226 } else {
Douglas Gregor43c79c22009-12-09 00:47:37 +00001227 const FunctionProtoType *FPT = cast<FunctionProtoType>(F);
John McCall0953e762009-09-24 19:53:00 +00001228 ResultType
Douglas Gregor43c79c22009-12-09 00:47:37 +00001229 = getFunctionType(FPT->getResultType(), FPT->arg_type_begin(),
1230 FPT->getNumArgs(), FPT->isVariadic(),
1231 FPT->getTypeQuals(),
1232 FPT->hasExceptionSpec(), FPT->hasAnyExceptionSpec(),
1233 FPT->getNumExceptions(), FPT->exception_begin(),
1234 AddNoReturn);
John McCall0953e762009-09-24 19:53:00 +00001235 }
Douglas Gregor43c79c22009-12-09 00:47:37 +00001236 } else
1237 return T;
1238
Douglas Gregora4923eb2009-11-16 21:35:15 +00001239 return getQualifiedType(ResultType, T.getLocalQualifiers());
Mike Stump24556362009-07-25 21:26:53 +00001240}
1241
Reid Spencer5f016e22007-07-11 17:01:13 +00001242/// getComplexType - Return the uniqued reference to the type for a complex
1243/// number with the specified element type.
1244QualType ASTContext::getComplexType(QualType T) {
1245 // Unique pointers, to guarantee there is only one pointer of a particular
1246 // structure.
1247 llvm::FoldingSetNodeID ID;
1248 ComplexType::Profile(ID, T);
Mike Stump1eb44332009-09-09 15:08:12 +00001249
Reid Spencer5f016e22007-07-11 17:01:13 +00001250 void *InsertPos = 0;
1251 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
1252 return QualType(CT, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001253
Reid Spencer5f016e22007-07-11 17:01:13 +00001254 // If the pointee type isn't canonical, this won't be a canonical type either,
1255 // so fill in the canonical type field.
1256 QualType Canonical;
John McCall467b27b2009-10-22 20:10:53 +00001257 if (!T.isCanonical()) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001258 Canonical = getComplexType(getCanonicalType(T));
Mike Stump1eb44332009-09-09 15:08:12 +00001259
Reid Spencer5f016e22007-07-11 17:01:13 +00001260 // Get the new insert position for the node we care about.
1261 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001262 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001263 }
John McCall6b304a02009-09-24 23:30:46 +00001264 ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
Reid Spencer5f016e22007-07-11 17:01:13 +00001265 Types.push_back(New);
1266 ComplexTypes.InsertNode(New, InsertPos);
1267 return QualType(New, 0);
1268}
1269
Eli Friedmanf98aba32009-02-13 02:31:07 +00001270QualType ASTContext::getFixedWidthIntType(unsigned Width, bool Signed) {
1271 llvm::DenseMap<unsigned, FixedWidthIntType*> &Map = Signed ?
1272 SignedFixedWidthIntTypes : UnsignedFixedWidthIntTypes;
1273 FixedWidthIntType *&Entry = Map[Width];
1274 if (!Entry)
1275 Entry = new FixedWidthIntType(Width, Signed);
1276 return QualType(Entry, 0);
1277}
Reid Spencer5f016e22007-07-11 17:01:13 +00001278
1279/// getPointerType - Return the uniqued reference to the type for a pointer to
1280/// the specified type.
1281QualType ASTContext::getPointerType(QualType T) {
1282 // Unique pointers, to guarantee there is only one pointer of a particular
1283 // structure.
1284 llvm::FoldingSetNodeID ID;
1285 PointerType::Profile(ID, T);
Mike Stump1eb44332009-09-09 15:08:12 +00001286
Reid Spencer5f016e22007-07-11 17:01:13 +00001287 void *InsertPos = 0;
1288 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
1289 return QualType(PT, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001290
Reid Spencer5f016e22007-07-11 17:01:13 +00001291 // If the pointee type isn't canonical, this won't be a canonical type either,
1292 // so fill in the canonical type field.
1293 QualType Canonical;
John McCall467b27b2009-10-22 20:10:53 +00001294 if (!T.isCanonical()) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001295 Canonical = getPointerType(getCanonicalType(T));
Mike Stump1eb44332009-09-09 15:08:12 +00001296
Reid Spencer5f016e22007-07-11 17:01:13 +00001297 // Get the new insert position for the node we care about.
1298 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001299 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001300 }
John McCall6b304a02009-09-24 23:30:46 +00001301 PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical);
Reid Spencer5f016e22007-07-11 17:01:13 +00001302 Types.push_back(New);
1303 PointerTypes.InsertNode(New, InsertPos);
1304 return QualType(New, 0);
1305}
1306
Mike Stump1eb44332009-09-09 15:08:12 +00001307/// getBlockPointerType - Return the uniqued reference to the type for
Steve Naroff5618bd42008-08-27 16:04:49 +00001308/// a pointer to the specified block.
1309QualType ASTContext::getBlockPointerType(QualType T) {
Steve Naroff296e8d52008-08-28 19:20:44 +00001310 assert(T->isFunctionType() && "block of function types only");
1311 // Unique pointers, to guarantee there is only one block of a particular
Steve Naroff5618bd42008-08-27 16:04:49 +00001312 // structure.
1313 llvm::FoldingSetNodeID ID;
1314 BlockPointerType::Profile(ID, T);
Mike Stump1eb44332009-09-09 15:08:12 +00001315
Steve Naroff5618bd42008-08-27 16:04:49 +00001316 void *InsertPos = 0;
1317 if (BlockPointerType *PT =
1318 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
1319 return QualType(PT, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001320
1321 // If the block pointee type isn't canonical, this won't be a canonical
Steve Naroff5618bd42008-08-27 16:04:49 +00001322 // type either so fill in the canonical type field.
1323 QualType Canonical;
John McCall467b27b2009-10-22 20:10:53 +00001324 if (!T.isCanonical()) {
Steve Naroff5618bd42008-08-27 16:04:49 +00001325 Canonical = getBlockPointerType(getCanonicalType(T));
Mike Stump1eb44332009-09-09 15:08:12 +00001326
Steve Naroff5618bd42008-08-27 16:04:49 +00001327 // Get the new insert position for the node we care about.
1328 BlockPointerType *NewIP =
1329 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001330 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Steve Naroff5618bd42008-08-27 16:04:49 +00001331 }
John McCall6b304a02009-09-24 23:30:46 +00001332 BlockPointerType *New
1333 = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
Steve Naroff5618bd42008-08-27 16:04:49 +00001334 Types.push_back(New);
1335 BlockPointerTypes.InsertNode(New, InsertPos);
1336 return QualType(New, 0);
1337}
1338
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001339/// getLValueReferenceType - Return the uniqued reference to the type for an
1340/// lvalue reference to the specified type.
John McCall54e14c42009-10-22 22:37:11 +00001341QualType ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001342 // Unique pointers, to guarantee there is only one pointer of a particular
1343 // structure.
1344 llvm::FoldingSetNodeID ID;
John McCall54e14c42009-10-22 22:37:11 +00001345 ReferenceType::Profile(ID, T, SpelledAsLValue);
Reid Spencer5f016e22007-07-11 17:01:13 +00001346
1347 void *InsertPos = 0;
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001348 if (LValueReferenceType *RT =
1349 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
Reid Spencer5f016e22007-07-11 17:01:13 +00001350 return QualType(RT, 0);
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001351
John McCall54e14c42009-10-22 22:37:11 +00001352 const ReferenceType *InnerRef = T->getAs<ReferenceType>();
1353
Reid Spencer5f016e22007-07-11 17:01:13 +00001354 // If the referencee type isn't canonical, this won't be a canonical type
1355 // either, so fill in the canonical type field.
1356 QualType Canonical;
John McCall54e14c42009-10-22 22:37:11 +00001357 if (!SpelledAsLValue || InnerRef || !T.isCanonical()) {
1358 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
1359 Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001360
Reid Spencer5f016e22007-07-11 17:01:13 +00001361 // Get the new insert position for the node we care about.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001362 LValueReferenceType *NewIP =
1363 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001364 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001365 }
1366
John McCall6b304a02009-09-24 23:30:46 +00001367 LValueReferenceType *New
John McCall54e14c42009-10-22 22:37:11 +00001368 = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
1369 SpelledAsLValue);
Reid Spencer5f016e22007-07-11 17:01:13 +00001370 Types.push_back(New);
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001371 LValueReferenceTypes.InsertNode(New, InsertPos);
John McCall54e14c42009-10-22 22:37:11 +00001372
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001373 return QualType(New, 0);
1374}
1375
1376/// getRValueReferenceType - Return the uniqued reference to the type for an
1377/// rvalue reference to the specified type.
1378QualType ASTContext::getRValueReferenceType(QualType T) {
1379 // Unique pointers, to guarantee there is only one pointer of a particular
1380 // structure.
1381 llvm::FoldingSetNodeID ID;
John McCall54e14c42009-10-22 22:37:11 +00001382 ReferenceType::Profile(ID, T, false);
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001383
1384 void *InsertPos = 0;
1385 if (RValueReferenceType *RT =
1386 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
1387 return QualType(RT, 0);
1388
John McCall54e14c42009-10-22 22:37:11 +00001389 const ReferenceType *InnerRef = T->getAs<ReferenceType>();
1390
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001391 // If the referencee type isn't canonical, this won't be a canonical type
1392 // either, so fill in the canonical type field.
1393 QualType Canonical;
John McCall54e14c42009-10-22 22:37:11 +00001394 if (InnerRef || !T.isCanonical()) {
1395 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
1396 Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001397
1398 // Get the new insert position for the node we care about.
1399 RValueReferenceType *NewIP =
1400 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
1401 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
1402 }
1403
John McCall6b304a02009-09-24 23:30:46 +00001404 RValueReferenceType *New
1405 = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
Sebastian Redl7c80bd62009-03-16 23:22:08 +00001406 Types.push_back(New);
1407 RValueReferenceTypes.InsertNode(New, InsertPos);
Reid Spencer5f016e22007-07-11 17:01:13 +00001408 return QualType(New, 0);
1409}
1410
Sebastian Redlf30208a2009-01-24 21:16:55 +00001411/// getMemberPointerType - Return the uniqued reference to the type for a
1412/// member pointer to the specified type, in the specified class.
Mike Stump1eb44332009-09-09 15:08:12 +00001413QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) {
Sebastian Redlf30208a2009-01-24 21:16:55 +00001414 // Unique pointers, to guarantee there is only one pointer of a particular
1415 // structure.
1416 llvm::FoldingSetNodeID ID;
1417 MemberPointerType::Profile(ID, T, Cls);
1418
1419 void *InsertPos = 0;
1420 if (MemberPointerType *PT =
1421 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
1422 return QualType(PT, 0);
1423
1424 // If the pointee or class type isn't canonical, this won't be a canonical
1425 // type either, so fill in the canonical type field.
1426 QualType Canonical;
Douglas Gregor87c12c42009-11-04 16:49:01 +00001427 if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
Sebastian Redlf30208a2009-01-24 21:16:55 +00001428 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
1429
1430 // Get the new insert position for the node we care about.
1431 MemberPointerType *NewIP =
1432 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
1433 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
1434 }
John McCall6b304a02009-09-24 23:30:46 +00001435 MemberPointerType *New
1436 = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
Sebastian Redlf30208a2009-01-24 21:16:55 +00001437 Types.push_back(New);
1438 MemberPointerTypes.InsertNode(New, InsertPos);
1439 return QualType(New, 0);
1440}
1441
Mike Stump1eb44332009-09-09 15:08:12 +00001442/// getConstantArrayType - Return the unique reference to the type for an
Steve Narofffb22d962007-08-30 01:06:46 +00001443/// array of the specified element type.
Mike Stump1eb44332009-09-09 15:08:12 +00001444QualType ASTContext::getConstantArrayType(QualType EltTy,
Chris Lattner38aeec72009-05-13 04:12:56 +00001445 const llvm::APInt &ArySizeIn,
Steve Naroffc9406122007-08-30 18:10:14 +00001446 ArrayType::ArraySizeModifier ASM,
1447 unsigned EltTypeQuals) {
Sebastian Redl923d56d2009-11-05 15:52:31 +00001448 assert((EltTy->isDependentType() ||
1449 EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&
Eli Friedman587cbdf2009-05-29 20:17:55 +00001450 "Constant array of VLAs is illegal!");
1451
Chris Lattner38aeec72009-05-13 04:12:56 +00001452 // Convert the array size into a canonical width matching the pointer size for
1453 // the target.
1454 llvm::APInt ArySize(ArySizeIn);
1455 ArySize.zextOrTrunc(Target.getPointerWidth(EltTy.getAddressSpace()));
Mike Stump1eb44332009-09-09 15:08:12 +00001456
Reid Spencer5f016e22007-07-11 17:01:13 +00001457 llvm::FoldingSetNodeID ID;
Chris Lattner0be2ef22009-02-19 17:31:02 +00001458 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, EltTypeQuals);
Mike Stump1eb44332009-09-09 15:08:12 +00001459
Reid Spencer5f016e22007-07-11 17:01:13 +00001460 void *InsertPos = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001461 if (ConstantArrayType *ATP =
Ted Kremenek7192f8e2007-10-31 17:10:13 +00001462 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
Reid Spencer5f016e22007-07-11 17:01:13 +00001463 return QualType(ATP, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001464
Reid Spencer5f016e22007-07-11 17:01:13 +00001465 // If the element type isn't canonical, this won't be a canonical type either,
1466 // so fill in the canonical type field.
1467 QualType Canonical;
John McCall467b27b2009-10-22 20:10:53 +00001468 if (!EltTy.isCanonical()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001469 Canonical = getConstantArrayType(getCanonicalType(EltTy), ArySize,
Steve Naroffc9406122007-08-30 18:10:14 +00001470 ASM, EltTypeQuals);
Reid Spencer5f016e22007-07-11 17:01:13 +00001471 // Get the new insert position for the node we care about.
Mike Stump1eb44332009-09-09 15:08:12 +00001472 ConstantArrayType *NewIP =
Ted Kremenek7192f8e2007-10-31 17:10:13 +00001473 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001474 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001475 }
Mike Stump1eb44332009-09-09 15:08:12 +00001476
John McCall6b304a02009-09-24 23:30:46 +00001477 ConstantArrayType *New = new(*this,TypeAlignment)
1478 ConstantArrayType(EltTy, Canonical, ArySize, ASM, EltTypeQuals);
Ted Kremenek7192f8e2007-10-31 17:10:13 +00001479 ConstantArrayTypes.InsertNode(New, InsertPos);
Reid Spencer5f016e22007-07-11 17:01:13 +00001480 Types.push_back(New);
1481 return QualType(New, 0);
1482}
1483
Steve Naroffbdbf7b02007-08-30 18:14:25 +00001484/// getVariableArrayType - Returns a non-unique reference to the type for a
1485/// variable array of the specified element type.
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001486QualType ASTContext::getVariableArrayType(QualType EltTy,
1487 Expr *NumElts,
Steve Naroffc9406122007-08-30 18:10:14 +00001488 ArrayType::ArraySizeModifier ASM,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001489 unsigned EltTypeQuals,
1490 SourceRange Brackets) {
Eli Friedmanc5773c42008-02-15 18:16:39 +00001491 // Since we don't unique expressions, it isn't possible to unique VLA's
1492 // that have an expression provided for their size.
1493
John McCall6b304a02009-09-24 23:30:46 +00001494 VariableArrayType *New = new(*this, TypeAlignment)
1495 VariableArrayType(EltTy, QualType(), NumElts, ASM, EltTypeQuals, Brackets);
Eli Friedmanc5773c42008-02-15 18:16:39 +00001496
1497 VariableArrayTypes.push_back(New);
1498 Types.push_back(New);
1499 return QualType(New, 0);
1500}
1501
Douglas Gregor898574e2008-12-05 23:32:09 +00001502/// getDependentSizedArrayType - Returns a non-unique reference to
1503/// the type for a dependently-sized array of the specified element
Douglas Gregor04d4bee2009-07-31 00:23:35 +00001504/// type.
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001505QualType ASTContext::getDependentSizedArrayType(QualType EltTy,
1506 Expr *NumElts,
Douglas Gregor898574e2008-12-05 23:32:09 +00001507 ArrayType::ArraySizeModifier ASM,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00001508 unsigned EltTypeQuals,
1509 SourceRange Brackets) {
Douglas Gregorcb78d882009-11-19 18:03:26 +00001510 assert((!NumElts || NumElts->isTypeDependent() ||
1511 NumElts->isValueDependent()) &&
Douglas Gregor898574e2008-12-05 23:32:09 +00001512 "Size must be type- or value-dependent!");
1513
Douglas Gregor04d4bee2009-07-31 00:23:35 +00001514 void *InsertPos = 0;
Douglas Gregorcb78d882009-11-19 18:03:26 +00001515 DependentSizedArrayType *Canon = 0;
1516
1517 if (NumElts) {
1518 // Dependently-sized array types that do not have a specified
1519 // number of elements will have their sizes deduced from an
1520 // initializer.
1521 llvm::FoldingSetNodeID ID;
1522 DependentSizedArrayType::Profile(ID, *this, getCanonicalType(EltTy), ASM,
1523 EltTypeQuals, NumElts);
1524
1525 Canon = DependentSizedArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
1526 }
1527
Douglas Gregor04d4bee2009-07-31 00:23:35 +00001528 DependentSizedArrayType *New;
1529 if (Canon) {
1530 // We already have a canonical version of this array type; use it as
1531 // the canonical type for a newly-built type.
John McCall6b304a02009-09-24 23:30:46 +00001532 New = new (*this, TypeAlignment)
1533 DependentSizedArrayType(*this, EltTy, QualType(Canon, 0),
1534 NumElts, ASM, EltTypeQuals, Brackets);
Douglas Gregor04d4bee2009-07-31 00:23:35 +00001535 } else {
1536 QualType CanonEltTy = getCanonicalType(EltTy);
1537 if (CanonEltTy == EltTy) {
John McCall6b304a02009-09-24 23:30:46 +00001538 New = new (*this, TypeAlignment)
1539 DependentSizedArrayType(*this, EltTy, QualType(),
1540 NumElts, ASM, EltTypeQuals, Brackets);
Douglas Gregorcb78d882009-11-19 18:03:26 +00001541
1542 if (NumElts)
1543 DependentSizedArrayTypes.InsertNode(New, InsertPos);
Douglas Gregor04d4bee2009-07-31 00:23:35 +00001544 } else {
1545 QualType Canon = getDependentSizedArrayType(CanonEltTy, NumElts,
1546 ASM, EltTypeQuals,
1547 SourceRange());
John McCall6b304a02009-09-24 23:30:46 +00001548 New = new (*this, TypeAlignment)
1549 DependentSizedArrayType(*this, EltTy, Canon,
1550 NumElts, ASM, EltTypeQuals, Brackets);
Douglas Gregor04d4bee2009-07-31 00:23:35 +00001551 }
1552 }
Mike Stump1eb44332009-09-09 15:08:12 +00001553
Douglas Gregor898574e2008-12-05 23:32:09 +00001554 Types.push_back(New);
1555 return QualType(New, 0);
1556}
1557
Eli Friedmanc5773c42008-02-15 18:16:39 +00001558QualType ASTContext::getIncompleteArrayType(QualType EltTy,
1559 ArrayType::ArraySizeModifier ASM,
1560 unsigned EltTypeQuals) {
1561 llvm::FoldingSetNodeID ID;
Chris Lattner0be2ef22009-02-19 17:31:02 +00001562 IncompleteArrayType::Profile(ID, EltTy, ASM, EltTypeQuals);
Eli Friedmanc5773c42008-02-15 18:16:39 +00001563
1564 void *InsertPos = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001565 if (IncompleteArrayType *ATP =
Eli Friedmanc5773c42008-02-15 18:16:39 +00001566 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
1567 return QualType(ATP, 0);
1568
1569 // If the element type isn't canonical, this won't be a canonical type
1570 // either, so fill in the canonical type field.
1571 QualType Canonical;
1572
John McCall467b27b2009-10-22 20:10:53 +00001573 if (!EltTy.isCanonical()) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001574 Canonical = getIncompleteArrayType(getCanonicalType(EltTy),
Ted Kremenek2bd24ba2007-10-29 23:37:31 +00001575 ASM, EltTypeQuals);
Eli Friedmanc5773c42008-02-15 18:16:39 +00001576
1577 // Get the new insert position for the node we care about.
1578 IncompleteArrayType *NewIP =
1579 IncompleteArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001580 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Ted Kremenek2bd24ba2007-10-29 23:37:31 +00001581 }
Eli Friedmanc5773c42008-02-15 18:16:39 +00001582
John McCall6b304a02009-09-24 23:30:46 +00001583 IncompleteArrayType *New = new (*this, TypeAlignment)
1584 IncompleteArrayType(EltTy, Canonical, ASM, EltTypeQuals);
Eli Friedmanc5773c42008-02-15 18:16:39 +00001585
1586 IncompleteArrayTypes.InsertNode(New, InsertPos);
1587 Types.push_back(New);
1588 return QualType(New, 0);
Steve Narofffb22d962007-08-30 01:06:46 +00001589}
1590
Steve Naroff73322922007-07-18 18:00:27 +00001591/// getVectorType - Return the unique reference to a vector type of
1592/// the specified element type and size. VectorType must be a built-in type.
1593QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001594 BuiltinType *baseType;
Mike Stump1eb44332009-09-09 15:08:12 +00001595
Chris Lattnerf52ab252008-04-06 22:59:24 +00001596 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr());
Steve Naroff73322922007-07-18 18:00:27 +00001597 assert(baseType != 0 && "getVectorType(): Expecting a built-in type");
Mike Stump1eb44332009-09-09 15:08:12 +00001598
Reid Spencer5f016e22007-07-11 17:01:13 +00001599 // Check if we've already instantiated a vector of this type.
1600 llvm::FoldingSetNodeID ID;
Mike Stump1eb44332009-09-09 15:08:12 +00001601 VectorType::Profile(ID, vecType, NumElts, Type::Vector);
Reid Spencer5f016e22007-07-11 17:01:13 +00001602 void *InsertPos = 0;
1603 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
1604 return QualType(VTP, 0);
1605
1606 // If the element type isn't canonical, this won't be a canonical type either,
1607 // so fill in the canonical type field.
1608 QualType Canonical;
John McCall467b27b2009-10-22 20:10:53 +00001609 if (!vecType.isCanonical()) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00001610 Canonical = getVectorType(getCanonicalType(vecType), NumElts);
Mike Stump1eb44332009-09-09 15:08:12 +00001611
Reid Spencer5f016e22007-07-11 17:01:13 +00001612 // Get the new insert position for the node we care about.
1613 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001614 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001615 }
John McCall6b304a02009-09-24 23:30:46 +00001616 VectorType *New = new (*this, TypeAlignment)
1617 VectorType(vecType, NumElts, Canonical);
Reid Spencer5f016e22007-07-11 17:01:13 +00001618 VectorTypes.InsertNode(New, InsertPos);
1619 Types.push_back(New);
1620 return QualType(New, 0);
1621}
1622
Nate Begeman213541a2008-04-18 23:10:10 +00001623/// getExtVectorType - Return the unique reference to an extended vector type of
Steve Naroff73322922007-07-18 18:00:27 +00001624/// the specified element type and size. VectorType must be a built-in type.
Nate Begeman213541a2008-04-18 23:10:10 +00001625QualType ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) {
Steve Naroff73322922007-07-18 18:00:27 +00001626 BuiltinType *baseType;
Mike Stump1eb44332009-09-09 15:08:12 +00001627
Chris Lattnerf52ab252008-04-06 22:59:24 +00001628 baseType = dyn_cast<BuiltinType>(getCanonicalType(vecType).getTypePtr());
Nate Begeman213541a2008-04-18 23:10:10 +00001629 assert(baseType != 0 && "getExtVectorType(): Expecting a built-in type");
Mike Stump1eb44332009-09-09 15:08:12 +00001630
Steve Naroff73322922007-07-18 18:00:27 +00001631 // Check if we've already instantiated a vector of this type.
1632 llvm::FoldingSetNodeID ID;
Mike Stump1eb44332009-09-09 15:08:12 +00001633 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector);
Steve Naroff73322922007-07-18 18:00:27 +00001634 void *InsertPos = 0;
1635 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
1636 return QualType(VTP, 0);
1637
1638 // If the element type isn't canonical, this won't be a canonical type either,
1639 // so fill in the canonical type field.
1640 QualType Canonical;
John McCall467b27b2009-10-22 20:10:53 +00001641 if (!vecType.isCanonical()) {
Nate Begeman213541a2008-04-18 23:10:10 +00001642 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
Mike Stump1eb44332009-09-09 15:08:12 +00001643
Steve Naroff73322922007-07-18 18:00:27 +00001644 // Get the new insert position for the node we care about.
1645 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001646 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Steve Naroff73322922007-07-18 18:00:27 +00001647 }
John McCall6b304a02009-09-24 23:30:46 +00001648 ExtVectorType *New = new (*this, TypeAlignment)
1649 ExtVectorType(vecType, NumElts, Canonical);
Steve Naroff73322922007-07-18 18:00:27 +00001650 VectorTypes.InsertNode(New, InsertPos);
1651 Types.push_back(New);
1652 return QualType(New, 0);
1653}
1654
Mike Stump1eb44332009-09-09 15:08:12 +00001655QualType ASTContext::getDependentSizedExtVectorType(QualType vecType,
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00001656 Expr *SizeExpr,
1657 SourceLocation AttrLoc) {
Douglas Gregor2ec09f12009-07-31 03:54:25 +00001658 llvm::FoldingSetNodeID ID;
Mike Stump1eb44332009-09-09 15:08:12 +00001659 DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType),
Douglas Gregor2ec09f12009-07-31 03:54:25 +00001660 SizeExpr);
Mike Stump1eb44332009-09-09 15:08:12 +00001661
Douglas Gregor2ec09f12009-07-31 03:54:25 +00001662 void *InsertPos = 0;
1663 DependentSizedExtVectorType *Canon
1664 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
1665 DependentSizedExtVectorType *New;
1666 if (Canon) {
1667 // We already have a canonical version of this array type; use it as
1668 // the canonical type for a newly-built type.
John McCall6b304a02009-09-24 23:30:46 +00001669 New = new (*this, TypeAlignment)
1670 DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
1671 SizeExpr, AttrLoc);
Douglas Gregor2ec09f12009-07-31 03:54:25 +00001672 } else {
1673 QualType CanonVecTy = getCanonicalType(vecType);
1674 if (CanonVecTy == vecType) {
John McCall6b304a02009-09-24 23:30:46 +00001675 New = new (*this, TypeAlignment)
1676 DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
1677 AttrLoc);
Douglas Gregor2ec09f12009-07-31 03:54:25 +00001678 DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
1679 } else {
1680 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
1681 SourceLocation());
John McCall6b304a02009-09-24 23:30:46 +00001682 New = new (*this, TypeAlignment)
1683 DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc);
Douglas Gregor2ec09f12009-07-31 03:54:25 +00001684 }
1685 }
Mike Stump1eb44332009-09-09 15:08:12 +00001686
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00001687 Types.push_back(New);
1688 return QualType(New, 0);
1689}
1690
Douglas Gregor72564e72009-02-26 23:50:07 +00001691/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
Reid Spencer5f016e22007-07-11 17:01:13 +00001692///
Mike Stump24556362009-07-25 21:26:53 +00001693QualType ASTContext::getFunctionNoProtoType(QualType ResultTy, bool NoReturn) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001694 // Unique functions, to guarantee there is only one function of a particular
1695 // structure.
1696 llvm::FoldingSetNodeID ID;
Mike Stump24556362009-07-25 21:26:53 +00001697 FunctionNoProtoType::Profile(ID, ResultTy, NoReturn);
Mike Stump1eb44332009-09-09 15:08:12 +00001698
Reid Spencer5f016e22007-07-11 17:01:13 +00001699 void *InsertPos = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001700 if (FunctionNoProtoType *FT =
Douglas Gregor72564e72009-02-26 23:50:07 +00001701 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
Reid Spencer5f016e22007-07-11 17:01:13 +00001702 return QualType(FT, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001703
Reid Spencer5f016e22007-07-11 17:01:13 +00001704 QualType Canonical;
John McCall467b27b2009-10-22 20:10:53 +00001705 if (!ResultTy.isCanonical()) {
Mike Stump24556362009-07-25 21:26:53 +00001706 Canonical = getFunctionNoProtoType(getCanonicalType(ResultTy), NoReturn);
Mike Stump1eb44332009-09-09 15:08:12 +00001707
Reid Spencer5f016e22007-07-11 17:01:13 +00001708 // Get the new insert position for the node we care about.
Douglas Gregor72564e72009-02-26 23:50:07 +00001709 FunctionNoProtoType *NewIP =
1710 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001711 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001712 }
Mike Stump1eb44332009-09-09 15:08:12 +00001713
John McCall6b304a02009-09-24 23:30:46 +00001714 FunctionNoProtoType *New = new (*this, TypeAlignment)
1715 FunctionNoProtoType(ResultTy, Canonical, NoReturn);
Reid Spencer5f016e22007-07-11 17:01:13 +00001716 Types.push_back(New);
Douglas Gregor72564e72009-02-26 23:50:07 +00001717 FunctionNoProtoTypes.InsertNode(New, InsertPos);
Reid Spencer5f016e22007-07-11 17:01:13 +00001718 return QualType(New, 0);
1719}
1720
1721/// getFunctionType - Return a normal function type with a typed argument
1722/// list. isVariadic indicates whether the argument list includes '...'.
Chris Lattner61710852008-10-05 17:34:18 +00001723QualType ASTContext::getFunctionType(QualType ResultTy,const QualType *ArgArray,
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +00001724 unsigned NumArgs, bool isVariadic,
Sebastian Redl465226e2009-05-27 22:11:52 +00001725 unsigned TypeQuals, bool hasExceptionSpec,
1726 bool hasAnyExceptionSpec, unsigned NumExs,
Mike Stump24556362009-07-25 21:26:53 +00001727 const QualType *ExArray, bool NoReturn) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001728 // Unique functions, to guarantee there is only one function of a particular
1729 // structure.
1730 llvm::FoldingSetNodeID ID;
Douglas Gregor72564e72009-02-26 23:50:07 +00001731 FunctionProtoType::Profile(ID, ResultTy, ArgArray, NumArgs, isVariadic,
Sebastian Redl465226e2009-05-27 22:11:52 +00001732 TypeQuals, hasExceptionSpec, hasAnyExceptionSpec,
Mike Stump24556362009-07-25 21:26:53 +00001733 NumExs, ExArray, NoReturn);
Reid Spencer5f016e22007-07-11 17:01:13 +00001734
1735 void *InsertPos = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001736 if (FunctionProtoType *FTP =
Douglas Gregor72564e72009-02-26 23:50:07 +00001737 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
Reid Spencer5f016e22007-07-11 17:01:13 +00001738 return QualType(FTP, 0);
Sebastian Redl465226e2009-05-27 22:11:52 +00001739
1740 // Determine whether the type being created is already canonical or not.
John McCall54e14c42009-10-22 22:37:11 +00001741 bool isCanonical = !hasExceptionSpec && ResultTy.isCanonical();
Reid Spencer5f016e22007-07-11 17:01:13 +00001742 for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
John McCall54e14c42009-10-22 22:37:11 +00001743 if (!ArgArray[i].isCanonicalAsParam())
Reid Spencer5f016e22007-07-11 17:01:13 +00001744 isCanonical = false;
1745
1746 // If this type isn't canonical, get the canonical version of it.
Sebastian Redl465226e2009-05-27 22:11:52 +00001747 // The exception spec is not part of the canonical type.
Reid Spencer5f016e22007-07-11 17:01:13 +00001748 QualType Canonical;
1749 if (!isCanonical) {
1750 llvm::SmallVector<QualType, 16> CanonicalArgs;
1751 CanonicalArgs.reserve(NumArgs);
1752 for (unsigned i = 0; i != NumArgs; ++i)
John McCall54e14c42009-10-22 22:37:11 +00001753 CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));
Sebastian Redl465226e2009-05-27 22:11:52 +00001754
Chris Lattnerf52ab252008-04-06 22:59:24 +00001755 Canonical = getFunctionType(getCanonicalType(ResultTy),
Jay Foadbeaaccd2009-05-21 09:52:38 +00001756 CanonicalArgs.data(), NumArgs,
Douglas Gregor47259d92009-08-05 19:03:35 +00001757 isVariadic, TypeQuals, false,
1758 false, 0, 0, NoReturn);
Sebastian Redl465226e2009-05-27 22:11:52 +00001759
Reid Spencer5f016e22007-07-11 17:01:13 +00001760 // Get the new insert position for the node we care about.
Douglas Gregor72564e72009-02-26 23:50:07 +00001761 FunctionProtoType *NewIP =
1762 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
Chris Lattnerf6e764f2008-10-12 00:26:57 +00001763 assert(NewIP == 0 && "Shouldn't be in the map!"); NewIP = NewIP;
Reid Spencer5f016e22007-07-11 17:01:13 +00001764 }
Sebastian Redl465226e2009-05-27 22:11:52 +00001765
Douglas Gregor72564e72009-02-26 23:50:07 +00001766 // FunctionProtoType objects are allocated with extra bytes after them
Sebastian Redl465226e2009-05-27 22:11:52 +00001767 // for two variable size arrays (for parameter and exception types) at the
1768 // end of them.
Mike Stump1eb44332009-09-09 15:08:12 +00001769 FunctionProtoType *FTP =
Sebastian Redl465226e2009-05-27 22:11:52 +00001770 (FunctionProtoType*)Allocate(sizeof(FunctionProtoType) +
1771 NumArgs*sizeof(QualType) +
John McCall6b304a02009-09-24 23:30:46 +00001772 NumExs*sizeof(QualType), TypeAlignment);
Douglas Gregor72564e72009-02-26 23:50:07 +00001773 new (FTP) FunctionProtoType(ResultTy, ArgArray, NumArgs, isVariadic,
Sebastian Redl465226e2009-05-27 22:11:52 +00001774 TypeQuals, hasExceptionSpec, hasAnyExceptionSpec,
Mike Stump24556362009-07-25 21:26:53 +00001775 ExArray, NumExs, Canonical, NoReturn);
Reid Spencer5f016e22007-07-11 17:01:13 +00001776 Types.push_back(FTP);
Douglas Gregor72564e72009-02-26 23:50:07 +00001777 FunctionProtoTypes.InsertNode(FTP, InsertPos);
Reid Spencer5f016e22007-07-11 17:01:13 +00001778 return QualType(FTP, 0);
1779}
1780
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001781/// getTypeDeclType - Return the unique reference to the type for the
1782/// specified type declaration.
Ted Kremenek4b7c9832008-09-05 17:16:31 +00001783QualType ASTContext::getTypeDeclType(TypeDecl *Decl, TypeDecl* PrevDecl) {
Argyrios Kyrtzidis1e6759e2008-10-16 16:50:47 +00001784 assert(Decl && "Passed null for Decl param");
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001785 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001786
Argyrios Kyrtzidis1e6759e2008-10-16 16:50:47 +00001787 if (TypedefDecl *Typedef = dyn_cast<TypedefDecl>(Decl))
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001788 return getTypedefType(Typedef);
Douglas Gregorfab9d672009-02-05 23:33:38 +00001789 else if (isa<TemplateTypeParmDecl>(Decl)) {
1790 assert(false && "Template type parameter types are always available.");
Mike Stump9fdbab32009-07-31 02:02:20 +00001791 } else if (ObjCInterfaceDecl *ObjCInterface
1792 = dyn_cast<ObjCInterfaceDecl>(Decl))
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001793 return getObjCInterfaceType(ObjCInterface);
Argyrios Kyrtzidis49aa7ff2008-08-07 20:55:28 +00001794
Douglas Gregorc1efaec2009-02-28 01:32:25 +00001795 if (RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) {
Ted Kremenek566c2ba2009-01-19 21:31:22 +00001796 if (PrevDecl)
1797 Decl->TypeForDecl = PrevDecl->TypeForDecl;
Steve Narofff83820b2009-01-27 22:08:43 +00001798 else
John McCall6b304a02009-09-24 23:30:46 +00001799 Decl->TypeForDecl = new (*this, TypeAlignment) RecordType(Record);
Mike Stump9fdbab32009-07-31 02:02:20 +00001800 } else if (EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) {
Ted Kremenek566c2ba2009-01-19 21:31:22 +00001801 if (PrevDecl)
1802 Decl->TypeForDecl = PrevDecl->TypeForDecl;
Steve Narofff83820b2009-01-27 22:08:43 +00001803 else
John McCall6b304a02009-09-24 23:30:46 +00001804 Decl->TypeForDecl = new (*this, TypeAlignment) EnumType(Enum);
John McCalled976492009-12-04 22:46:56 +00001805 } else if (UnresolvedUsingTypenameDecl *Using =
1806 dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
1807 Decl->TypeForDecl = new (*this, TypeAlignment) UnresolvedUsingType(Using);
Mike Stump9fdbab32009-07-31 02:02:20 +00001808 } else
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001809 assert(false && "TypeDecl without a type?");
Argyrios Kyrtzidis49aa7ff2008-08-07 20:55:28 +00001810
Ted Kremenek4b7c9832008-09-05 17:16:31 +00001811 if (!PrevDecl) Types.push_back(Decl->TypeForDecl);
Argyrios Kyrtzidis49aa7ff2008-08-07 20:55:28 +00001812 return QualType(Decl->TypeForDecl, 0);
Douglas Gregor2ce52f32008-04-13 21:07:44 +00001813}
1814
Reid Spencer5f016e22007-07-11 17:01:13 +00001815/// getTypedefType - Return the unique reference to the type for the
1816/// specified typename decl.
1817QualType ASTContext::getTypedefType(TypedefDecl *Decl) {
1818 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001819
Chris Lattnerf52ab252008-04-06 22:59:24 +00001820 QualType Canonical = getCanonicalType(Decl->getUnderlyingType());
John McCall6b304a02009-09-24 23:30:46 +00001821 Decl->TypeForDecl = new(*this, TypeAlignment)
1822 TypedefType(Type::Typedef, Decl, Canonical);
Reid Spencer5f016e22007-07-11 17:01:13 +00001823 Types.push_back(Decl->TypeForDecl);
1824 return QualType(Decl->TypeForDecl, 0);
1825}
1826
John McCall49a832b2009-10-18 09:09:24 +00001827/// \brief Retrieve a substitution-result type.
1828QualType
1829ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
1830 QualType Replacement) {
John McCall467b27b2009-10-22 20:10:53 +00001831 assert(Replacement.isCanonical()
John McCall49a832b2009-10-18 09:09:24 +00001832 && "replacement types must always be canonical");
1833
1834 llvm::FoldingSetNodeID ID;
1835 SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
1836 void *InsertPos = 0;
1837 SubstTemplateTypeParmType *SubstParm
1838 = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
1839
1840 if (!SubstParm) {
1841 SubstParm = new (*this, TypeAlignment)
1842 SubstTemplateTypeParmType(Parm, Replacement);
1843 Types.push_back(SubstParm);
1844 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
1845 }
1846
1847 return QualType(SubstParm, 0);
1848}
1849
Douglas Gregorfab9d672009-02-05 23:33:38 +00001850/// \brief Retrieve the template type parameter type for a template
Mike Stump1eb44332009-09-09 15:08:12 +00001851/// parameter or parameter pack with the given depth, index, and (optionally)
Anders Carlsson76e4ce42009-06-16 00:30:48 +00001852/// name.
Mike Stump1eb44332009-09-09 15:08:12 +00001853QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
Anders Carlsson76e4ce42009-06-16 00:30:48 +00001854 bool ParameterPack,
Douglas Gregorfab9d672009-02-05 23:33:38 +00001855 IdentifierInfo *Name) {
1856 llvm::FoldingSetNodeID ID;
Anders Carlsson76e4ce42009-06-16 00:30:48 +00001857 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, Name);
Douglas Gregorfab9d672009-02-05 23:33:38 +00001858 void *InsertPos = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001859 TemplateTypeParmType *TypeParm
Douglas Gregorfab9d672009-02-05 23:33:38 +00001860 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
1861
1862 if (TypeParm)
1863 return QualType(TypeParm, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001864
Anders Carlsson76e4ce42009-06-16 00:30:48 +00001865 if (Name) {
1866 QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
John McCall6b304a02009-09-24 23:30:46 +00001867 TypeParm = new (*this, TypeAlignment)
1868 TemplateTypeParmType(Depth, Index, ParameterPack, Name, Canon);
Anders Carlsson76e4ce42009-06-16 00:30:48 +00001869 } else
John McCall6b304a02009-09-24 23:30:46 +00001870 TypeParm = new (*this, TypeAlignment)
1871 TemplateTypeParmType(Depth, Index, ParameterPack);
Douglas Gregorfab9d672009-02-05 23:33:38 +00001872
1873 Types.push_back(TypeParm);
1874 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
1875
1876 return QualType(TypeParm, 0);
1877}
1878
Mike Stump1eb44332009-09-09 15:08:12 +00001879QualType
Douglas Gregor7532dc62009-03-30 22:58:21 +00001880ASTContext::getTemplateSpecializationType(TemplateName Template,
John McCalld5532b62009-11-23 01:53:49 +00001881 const TemplateArgumentListInfo &Args,
John McCall833ca992009-10-29 08:12:44 +00001882 QualType Canon) {
John McCalld5532b62009-11-23 01:53:49 +00001883 unsigned NumArgs = Args.size();
1884
John McCall833ca992009-10-29 08:12:44 +00001885 llvm::SmallVector<TemplateArgument, 4> ArgVec;
1886 ArgVec.reserve(NumArgs);
1887 for (unsigned i = 0; i != NumArgs; ++i)
1888 ArgVec.push_back(Args[i].getArgument());
1889
1890 return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs, Canon);
1891}
1892
1893QualType
1894ASTContext::getTemplateSpecializationType(TemplateName Template,
Douglas Gregor7532dc62009-03-30 22:58:21 +00001895 const TemplateArgument *Args,
1896 unsigned NumArgs,
1897 QualType Canon) {
Douglas Gregorb88e8882009-07-30 17:40:51 +00001898 if (!Canon.isNull())
1899 Canon = getCanonicalType(Canon);
1900 else {
1901 // Build the canonical template specialization type.
Douglas Gregor1275ae02009-07-28 23:00:59 +00001902 TemplateName CanonTemplate = getCanonicalTemplateName(Template);
1903 llvm::SmallVector<TemplateArgument, 4> CanonArgs;
1904 CanonArgs.reserve(NumArgs);
1905 for (unsigned I = 0; I != NumArgs; ++I)
1906 CanonArgs.push_back(getCanonicalTemplateArgument(Args[I]));
1907
1908 // Determine whether this canonical template specialization type already
1909 // exists.
1910 llvm::FoldingSetNodeID ID;
Mike Stump1eb44332009-09-09 15:08:12 +00001911 TemplateSpecializationType::Profile(ID, CanonTemplate,
Douglas Gregor828e2262009-07-29 16:09:57 +00001912 CanonArgs.data(), NumArgs, *this);
Douglas Gregor1275ae02009-07-28 23:00:59 +00001913
1914 void *InsertPos = 0;
1915 TemplateSpecializationType *Spec
1916 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
Mike Stump1eb44332009-09-09 15:08:12 +00001917
Douglas Gregor1275ae02009-07-28 23:00:59 +00001918 if (!Spec) {
1919 // Allocate a new canonical template specialization type.
Mike Stump1eb44332009-09-09 15:08:12 +00001920 void *Mem = Allocate((sizeof(TemplateSpecializationType) +
Douglas Gregor1275ae02009-07-28 23:00:59 +00001921 sizeof(TemplateArgument) * NumArgs),
John McCall6b304a02009-09-24 23:30:46 +00001922 TypeAlignment);
Mike Stump1eb44332009-09-09 15:08:12 +00001923 Spec = new (Mem) TemplateSpecializationType(*this, CanonTemplate,
Douglas Gregor1275ae02009-07-28 23:00:59 +00001924 CanonArgs.data(), NumArgs,
Douglas Gregorb88e8882009-07-30 17:40:51 +00001925 Canon);
Douglas Gregor1275ae02009-07-28 23:00:59 +00001926 Types.push_back(Spec);
Mike Stump1eb44332009-09-09 15:08:12 +00001927 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
Douglas Gregor1275ae02009-07-28 23:00:59 +00001928 }
Mike Stump1eb44332009-09-09 15:08:12 +00001929
Douglas Gregorb88e8882009-07-30 17:40:51 +00001930 if (Canon.isNull())
1931 Canon = QualType(Spec, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001932 assert(Canon->isDependentType() &&
Douglas Gregor1275ae02009-07-28 23:00:59 +00001933 "Non-dependent template-id type must have a canonical type");
Douglas Gregorb88e8882009-07-30 17:40:51 +00001934 }
Douglas Gregorfc705b82009-02-26 22:19:44 +00001935
Douglas Gregor1275ae02009-07-28 23:00:59 +00001936 // Allocate the (non-canonical) template specialization type, but don't
1937 // try to unique it: these types typically have location information that
1938 // we don't unique and don't want to lose.
Mike Stump1eb44332009-09-09 15:08:12 +00001939 void *Mem = Allocate((sizeof(TemplateSpecializationType) +
Douglas Gregor40808ce2009-03-09 23:48:35 +00001940 sizeof(TemplateArgument) * NumArgs),
John McCall6b304a02009-09-24 23:30:46 +00001941 TypeAlignment);
Mike Stump1eb44332009-09-09 15:08:12 +00001942 TemplateSpecializationType *Spec
1943 = new (Mem) TemplateSpecializationType(*this, Template, Args, NumArgs,
Douglas Gregor828e2262009-07-29 16:09:57 +00001944 Canon);
Mike Stump1eb44332009-09-09 15:08:12 +00001945
Douglas Gregor55f6b142009-02-09 18:46:07 +00001946 Types.push_back(Spec);
Mike Stump1eb44332009-09-09 15:08:12 +00001947 return QualType(Spec, 0);
Douglas Gregor55f6b142009-02-09 18:46:07 +00001948}
1949
Mike Stump1eb44332009-09-09 15:08:12 +00001950QualType
Douglas Gregorab452ba2009-03-26 23:50:42 +00001951ASTContext::getQualifiedNameType(NestedNameSpecifier *NNS,
Douglas Gregore4e5b052009-03-19 00:18:19 +00001952 QualType NamedType) {
1953 llvm::FoldingSetNodeID ID;
Douglas Gregorab452ba2009-03-26 23:50:42 +00001954 QualifiedNameType::Profile(ID, NNS, NamedType);
Douglas Gregore4e5b052009-03-19 00:18:19 +00001955
1956 void *InsertPos = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001957 QualifiedNameType *T
Douglas Gregore4e5b052009-03-19 00:18:19 +00001958 = QualifiedNameTypes.FindNodeOrInsertPos(ID, InsertPos);
1959 if (T)
1960 return QualType(T, 0);
1961
Mike Stump1eb44332009-09-09 15:08:12 +00001962 T = new (*this) QualifiedNameType(NNS, NamedType,
Douglas Gregorab452ba2009-03-26 23:50:42 +00001963 getCanonicalType(NamedType));
Douglas Gregore4e5b052009-03-19 00:18:19 +00001964 Types.push_back(T);
1965 QualifiedNameTypes.InsertNode(T, InsertPos);
1966 return QualType(T, 0);
1967}
1968
Mike Stump1eb44332009-09-09 15:08:12 +00001969QualType ASTContext::getTypenameType(NestedNameSpecifier *NNS,
Douglas Gregord57959a2009-03-27 23:10:48 +00001970 const IdentifierInfo *Name,
1971 QualType Canon) {
1972 assert(NNS->isDependent() && "nested-name-specifier must be dependent");
1973
1974 if (Canon.isNull()) {
1975 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
1976 if (CanonNNS != NNS)
1977 Canon = getTypenameType(CanonNNS, Name);
1978 }
1979
1980 llvm::FoldingSetNodeID ID;
1981 TypenameType::Profile(ID, NNS, Name);
1982
1983 void *InsertPos = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001984 TypenameType *T
Douglas Gregord57959a2009-03-27 23:10:48 +00001985 = TypenameTypes.FindNodeOrInsertPos(ID, InsertPos);
1986 if (T)
1987 return QualType(T, 0);
1988
1989 T = new (*this) TypenameType(NNS, Name, Canon);
1990 Types.push_back(T);
1991 TypenameTypes.InsertNode(T, InsertPos);
Mike Stump1eb44332009-09-09 15:08:12 +00001992 return QualType(T, 0);
Douglas Gregord57959a2009-03-27 23:10:48 +00001993}
1994
Mike Stump1eb44332009-09-09 15:08:12 +00001995QualType
1996ASTContext::getTypenameType(NestedNameSpecifier *NNS,
Douglas Gregor17343172009-04-01 00:28:59 +00001997 const TemplateSpecializationType *TemplateId,
1998 QualType Canon) {
1999 assert(NNS->isDependent() && "nested-name-specifier must be dependent");
2000
2001 if (Canon.isNull()) {
2002 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
2003 QualType CanonType = getCanonicalType(QualType(TemplateId, 0));
2004 if (CanonNNS != NNS || CanonType != QualType(TemplateId, 0)) {
2005 const TemplateSpecializationType *CanonTemplateId
John McCall183700f2009-09-21 23:43:11 +00002006 = CanonType->getAs<TemplateSpecializationType>();
Douglas Gregor17343172009-04-01 00:28:59 +00002007 assert(CanonTemplateId &&
2008 "Canonical type must also be a template specialization type");
2009 Canon = getTypenameType(CanonNNS, CanonTemplateId);
2010 }
2011 }
2012
2013 llvm::FoldingSetNodeID ID;
2014 TypenameType::Profile(ID, NNS, TemplateId);
2015
2016 void *InsertPos = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002017 TypenameType *T
Douglas Gregor17343172009-04-01 00:28:59 +00002018 = TypenameTypes.FindNodeOrInsertPos(ID, InsertPos);
2019 if (T)
2020 return QualType(T, 0);
2021
2022 T = new (*this) TypenameType(NNS, TemplateId, Canon);
2023 Types.push_back(T);
2024 TypenameTypes.InsertNode(T, InsertPos);
Mike Stump1eb44332009-09-09 15:08:12 +00002025 return QualType(T, 0);
Douglas Gregor17343172009-04-01 00:28:59 +00002026}
2027
John McCall7da24312009-09-05 00:15:47 +00002028QualType
2029ASTContext::getElaboratedType(QualType UnderlyingType,
2030 ElaboratedType::TagKind Tag) {
2031 llvm::FoldingSetNodeID ID;
2032 ElaboratedType::Profile(ID, UnderlyingType, Tag);
Mike Stump1eb44332009-09-09 15:08:12 +00002033
John McCall7da24312009-09-05 00:15:47 +00002034 void *InsertPos = 0;
2035 ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
2036 if (T)
2037 return QualType(T, 0);
2038
2039 QualType Canon = getCanonicalType(UnderlyingType);
2040
2041 T = new (*this) ElaboratedType(UnderlyingType, Tag, Canon);
2042 Types.push_back(T);
2043 ElaboratedTypes.InsertNode(T, InsertPos);
2044 return QualType(T, 0);
2045}
2046
Chris Lattner88cb27a2008-04-07 04:56:42 +00002047/// CmpProtocolNames - Comparison predicate for sorting protocols
2048/// alphabetically.
2049static bool CmpProtocolNames(const ObjCProtocolDecl *LHS,
2050 const ObjCProtocolDecl *RHS) {
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002051 return LHS->getDeclName() < RHS->getDeclName();
Chris Lattner88cb27a2008-04-07 04:56:42 +00002052}
2053
John McCall54e14c42009-10-22 22:37:11 +00002054static bool areSortedAndUniqued(ObjCProtocolDecl **Protocols,
2055 unsigned NumProtocols) {
2056 if (NumProtocols == 0) return true;
2057
2058 for (unsigned i = 1; i != NumProtocols; ++i)
2059 if (!CmpProtocolNames(Protocols[i-1], Protocols[i]))
2060 return false;
2061 return true;
2062}
2063
2064static void SortAndUniqueProtocols(ObjCProtocolDecl **Protocols,
Chris Lattner88cb27a2008-04-07 04:56:42 +00002065 unsigned &NumProtocols) {
2066 ObjCProtocolDecl **ProtocolsEnd = Protocols+NumProtocols;
Mike Stump1eb44332009-09-09 15:08:12 +00002067
Chris Lattner88cb27a2008-04-07 04:56:42 +00002068 // Sort protocols, keyed by name.
2069 std::sort(Protocols, Protocols+NumProtocols, CmpProtocolNames);
2070
2071 // Remove duplicates.
2072 ProtocolsEnd = std::unique(Protocols, ProtocolsEnd);
2073 NumProtocols = ProtocolsEnd-Protocols;
2074}
2075
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00002076/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
2077/// the given interface decl and the conforming protocol list.
Steve Naroff14108da2009-07-10 23:34:53 +00002078QualType ASTContext::getObjCObjectPointerType(QualType InterfaceT,
Mike Stump1eb44332009-09-09 15:08:12 +00002079 ObjCProtocolDecl **Protocols,
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00002080 unsigned NumProtocols) {
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00002081 llvm::FoldingSetNodeID ID;
Steve Naroff14108da2009-07-10 23:34:53 +00002082 ObjCObjectPointerType::Profile(ID, InterfaceT, Protocols, NumProtocols);
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00002083
2084 void *InsertPos = 0;
2085 if (ObjCObjectPointerType *QT =
2086 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2087 return QualType(QT, 0);
2088
John McCall54e14c42009-10-22 22:37:11 +00002089 // Sort the protocol list alphabetically to canonicalize it.
2090 QualType Canonical;
2091 if (!InterfaceT.isCanonical() ||
2092 !areSortedAndUniqued(Protocols, NumProtocols)) {
2093 if (!areSortedAndUniqued(Protocols, NumProtocols)) {
2094 llvm::SmallVector<ObjCProtocolDecl*, 8> Sorted(NumProtocols);
2095 unsigned UniqueCount = NumProtocols;
2096
2097 std::copy(Protocols, Protocols + NumProtocols, Sorted.begin());
2098 SortAndUniqueProtocols(&Sorted[0], UniqueCount);
2099
2100 Canonical = getObjCObjectPointerType(getCanonicalType(InterfaceT),
2101 &Sorted[0], UniqueCount);
2102 } else {
2103 Canonical = getObjCObjectPointerType(getCanonicalType(InterfaceT),
2104 Protocols, NumProtocols);
2105 }
2106
2107 // Regenerate InsertPos.
2108 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2109 }
2110
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00002111 // No Match;
John McCall6b304a02009-09-24 23:30:46 +00002112 ObjCObjectPointerType *QType = new (*this, TypeAlignment)
John McCall54e14c42009-10-22 22:37:11 +00002113 ObjCObjectPointerType(Canonical, InterfaceT, Protocols, NumProtocols);
Mike Stump1eb44332009-09-09 15:08:12 +00002114
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00002115 Types.push_back(QType);
2116 ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
2117 return QualType(QType, 0);
2118}
Chris Lattner88cb27a2008-04-07 04:56:42 +00002119
Steve Naroffc15cb2a2009-07-18 15:33:26 +00002120/// getObjCInterfaceType - Return the unique reference to the type for the
2121/// specified ObjC interface decl. The list of protocols is optional.
2122QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002123 ObjCProtocolDecl **Protocols, unsigned NumProtocols) {
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00002124 llvm::FoldingSetNodeID ID;
Steve Naroffc15cb2a2009-07-18 15:33:26 +00002125 ObjCInterfaceType::Profile(ID, Decl, Protocols, NumProtocols);
Mike Stump1eb44332009-09-09 15:08:12 +00002126
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00002127 void *InsertPos = 0;
Steve Naroffc15cb2a2009-07-18 15:33:26 +00002128 if (ObjCInterfaceType *QT =
2129 ObjCInterfaceTypes.FindNodeOrInsertPos(ID, InsertPos))
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00002130 return QualType(QT, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00002131
John McCall54e14c42009-10-22 22:37:11 +00002132 // Sort the protocol list alphabetically to canonicalize it.
2133 QualType Canonical;
2134 if (NumProtocols && !areSortedAndUniqued(Protocols, NumProtocols)) {
2135 llvm::SmallVector<ObjCProtocolDecl*, 8> Sorted(NumProtocols);
2136 std::copy(Protocols, Protocols + NumProtocols, Sorted.begin());
2137
2138 unsigned UniqueCount = NumProtocols;
2139 SortAndUniqueProtocols(&Sorted[0], UniqueCount);
2140
2141 Canonical = getObjCInterfaceType(Decl, &Sorted[0], UniqueCount);
2142
2143 ObjCInterfaceTypes.FindNodeOrInsertPos(ID, InsertPos);
2144 }
2145
John McCall6b304a02009-09-24 23:30:46 +00002146 ObjCInterfaceType *QType = new (*this, TypeAlignment)
John McCall54e14c42009-10-22 22:37:11 +00002147 ObjCInterfaceType(Canonical, const_cast<ObjCInterfaceDecl*>(Decl),
John McCall6b304a02009-09-24 23:30:46 +00002148 Protocols, NumProtocols);
John McCall54e14c42009-10-22 22:37:11 +00002149
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00002150 Types.push_back(QType);
Steve Naroffc15cb2a2009-07-18 15:33:26 +00002151 ObjCInterfaceTypes.InsertNode(QType, InsertPos);
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00002152 return QualType(QType, 0);
2153}
2154
Douglas Gregor72564e72009-02-26 23:50:07 +00002155/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
2156/// TypeOfExprType AST's (since expression's are never shared). For example,
Steve Naroff9752f252007-08-01 18:02:17 +00002157/// multiple declarations that refer to "typeof(x)" all contain different
Mike Stump1eb44332009-09-09 15:08:12 +00002158/// DeclRefExpr's. This doesn't effect the type checker, since it operates
Steve Naroff9752f252007-08-01 18:02:17 +00002159/// on canonical type's (which are always unique).
Douglas Gregor72564e72009-02-26 23:50:07 +00002160QualType ASTContext::getTypeOfExprType(Expr *tofExpr) {
Douglas Gregordd0257c2009-07-08 00:03:05 +00002161 TypeOfExprType *toe;
Douglas Gregorb1975722009-07-30 23:18:24 +00002162 if (tofExpr->isTypeDependent()) {
2163 llvm::FoldingSetNodeID ID;
2164 DependentTypeOfExprType::Profile(ID, *this, tofExpr);
Mike Stump1eb44332009-09-09 15:08:12 +00002165
Douglas Gregorb1975722009-07-30 23:18:24 +00002166 void *InsertPos = 0;
2167 DependentTypeOfExprType *Canon
2168 = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
2169 if (Canon) {
2170 // We already have a "canonical" version of an identical, dependent
2171 // typeof(expr) type. Use that as our canonical type.
John McCall6b304a02009-09-24 23:30:46 +00002172 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
Douglas Gregorb1975722009-07-30 23:18:24 +00002173 QualType((TypeOfExprType*)Canon, 0));
2174 }
2175 else {
2176 // Build a new, canonical typeof(expr) type.
John McCall6b304a02009-09-24 23:30:46 +00002177 Canon
2178 = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
Douglas Gregorb1975722009-07-30 23:18:24 +00002179 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
2180 toe = Canon;
2181 }
2182 } else {
Douglas Gregordd0257c2009-07-08 00:03:05 +00002183 QualType Canonical = getCanonicalType(tofExpr->getType());
John McCall6b304a02009-09-24 23:30:46 +00002184 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
Douglas Gregordd0257c2009-07-08 00:03:05 +00002185 }
Steve Naroff9752f252007-08-01 18:02:17 +00002186 Types.push_back(toe);
2187 return QualType(toe, 0);
Steve Naroffd1861fd2007-07-31 12:34:36 +00002188}
2189
Steve Naroff9752f252007-08-01 18:02:17 +00002190/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique
2191/// TypeOfType AST's. The only motivation to unique these nodes would be
2192/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
Mike Stump1eb44332009-09-09 15:08:12 +00002193/// an issue. This doesn't effect the type checker, since it operates
Steve Naroff9752f252007-08-01 18:02:17 +00002194/// on canonical type's (which are always unique).
Steve Naroffd1861fd2007-07-31 12:34:36 +00002195QualType ASTContext::getTypeOfType(QualType tofType) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00002196 QualType Canonical = getCanonicalType(tofType);
John McCall6b304a02009-09-24 23:30:46 +00002197 TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
Steve Naroff9752f252007-08-01 18:02:17 +00002198 Types.push_back(tot);
2199 return QualType(tot, 0);
Steve Naroffd1861fd2007-07-31 12:34:36 +00002200}
2201
Anders Carlsson60a9a2a2009-06-24 21:24:56 +00002202/// getDecltypeForExpr - Given an expr, will return the decltype for that
2203/// expression, according to the rules in C++0x [dcl.type.simple]p4
2204static QualType getDecltypeForExpr(const Expr *e, ASTContext &Context) {
Anders Carlssona07c33e2009-06-25 15:00:34 +00002205 if (e->isTypeDependent())
2206 return Context.DependentTy;
Mike Stump1eb44332009-09-09 15:08:12 +00002207
Anders Carlsson60a9a2a2009-06-24 21:24:56 +00002208 // If e is an id expression or a class member access, decltype(e) is defined
2209 // as the type of the entity named by e.
2210 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(e)) {
2211 if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl()))
2212 return VD->getType();
2213 }
2214 if (const MemberExpr *ME = dyn_cast<MemberExpr>(e)) {
2215 if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl()))
2216 return FD->getType();
2217 }
2218 // If e is a function call or an invocation of an overloaded operator,
2219 // (parentheses around e are ignored), decltype(e) is defined as the
2220 // return type of that function.
2221 if (const CallExpr *CE = dyn_cast<CallExpr>(e->IgnoreParens()))
2222 return CE->getCallReturnType();
Mike Stump1eb44332009-09-09 15:08:12 +00002223
Anders Carlsson60a9a2a2009-06-24 21:24:56 +00002224 QualType T = e->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00002225
2226 // Otherwise, where T is the type of e, if e is an lvalue, decltype(e) is
Anders Carlsson60a9a2a2009-06-24 21:24:56 +00002227 // defined as T&, otherwise decltype(e) is defined as T.
2228 if (e->isLvalue(Context) == Expr::LV_Valid)
2229 T = Context.getLValueReferenceType(T);
Mike Stump1eb44332009-09-09 15:08:12 +00002230
Anders Carlsson60a9a2a2009-06-24 21:24:56 +00002231 return T;
2232}
2233
Anders Carlsson395b4752009-06-24 19:06:50 +00002234/// getDecltypeType - Unlike many "get<Type>" functions, we don't unique
2235/// DecltypeType AST's. The only motivation to unique these nodes would be
2236/// memory savings. Since decltype(t) is fairly uncommon, space shouldn't be
Mike Stump1eb44332009-09-09 15:08:12 +00002237/// an issue. This doesn't effect the type checker, since it operates
Anders Carlsson395b4752009-06-24 19:06:50 +00002238/// on canonical type's (which are always unique).
2239QualType ASTContext::getDecltypeType(Expr *e) {
Douglas Gregordd0257c2009-07-08 00:03:05 +00002240 DecltypeType *dt;
Douglas Gregor9d702ae2009-07-30 23:36:40 +00002241 if (e->isTypeDependent()) {
2242 llvm::FoldingSetNodeID ID;
2243 DependentDecltypeType::Profile(ID, *this, e);
Mike Stump1eb44332009-09-09 15:08:12 +00002244
Douglas Gregor9d702ae2009-07-30 23:36:40 +00002245 void *InsertPos = 0;
2246 DependentDecltypeType *Canon
2247 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
2248 if (Canon) {
2249 // We already have a "canonical" version of an equivalent, dependent
2250 // decltype type. Use that as our canonical type.
John McCall6b304a02009-09-24 23:30:46 +00002251 dt = new (*this, TypeAlignment) DecltypeType(e, DependentTy,
Douglas Gregor9d702ae2009-07-30 23:36:40 +00002252 QualType((DecltypeType*)Canon, 0));
2253 }
2254 else {
2255 // Build a new, canonical typeof(expr) type.
John McCall6b304a02009-09-24 23:30:46 +00002256 Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
Douglas Gregor9d702ae2009-07-30 23:36:40 +00002257 DependentDecltypeTypes.InsertNode(Canon, InsertPos);
2258 dt = Canon;
2259 }
2260 } else {
Douglas Gregordd0257c2009-07-08 00:03:05 +00002261 QualType T = getDecltypeForExpr(e, *this);
John McCall6b304a02009-09-24 23:30:46 +00002262 dt = new (*this, TypeAlignment) DecltypeType(e, T, getCanonicalType(T));
Douglas Gregordd0257c2009-07-08 00:03:05 +00002263 }
Anders Carlsson395b4752009-06-24 19:06:50 +00002264 Types.push_back(dt);
2265 return QualType(dt, 0);
2266}
2267
Reid Spencer5f016e22007-07-11 17:01:13 +00002268/// getTagDeclType - Return the unique reference to the type for the
2269/// specified TagDecl (struct/union/class/enum) decl.
Mike Stumpe607ed02009-08-07 18:05:12 +00002270QualType ASTContext::getTagDeclType(const TagDecl *Decl) {
Ted Kremenekd778f882007-11-26 21:16:01 +00002271 assert (Decl);
Mike Stumpe607ed02009-08-07 18:05:12 +00002272 // FIXME: What is the design on getTagDeclType when it requires casting
2273 // away const? mutable?
2274 return getTypeDeclType(const_cast<TagDecl*>(Decl));
Reid Spencer5f016e22007-07-11 17:01:13 +00002275}
2276
Mike Stump1eb44332009-09-09 15:08:12 +00002277/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
2278/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
2279/// needs to agree with the definition in <stddef.h>.
Anders Carlssona3ccda52009-12-12 00:26:23 +00002280CanQualType ASTContext::getSizeType() const {
Douglas Gregorb4e66d52008-11-03 14:12:49 +00002281 return getFromTargetType(Target.getSizeType());
Reid Spencer5f016e22007-07-11 17:01:13 +00002282}
2283
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +00002284/// getSignedWCharType - Return the type of "signed wchar_t".
2285/// Used when in C++, as a GCC extension.
2286QualType ASTContext::getSignedWCharType() const {
2287 // FIXME: derive from "Target" ?
2288 return WCharTy;
2289}
2290
2291/// getUnsignedWCharType - Return the type of "unsigned wchar_t".
2292/// Used when in C++, as a GCC extension.
2293QualType ASTContext::getUnsignedWCharType() const {
2294 // FIXME: derive from "Target" ?
2295 return UnsignedIntTy;
2296}
2297
Chris Lattner8b9023b2007-07-13 03:05:23 +00002298/// getPointerDiffType - Return the unique type for "ptrdiff_t" (ref?)
2299/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
2300QualType ASTContext::getPointerDiffType() const {
Douglas Gregorb4e66d52008-11-03 14:12:49 +00002301 return getFromTargetType(Target.getPtrDiffType(0));
Chris Lattner8b9023b2007-07-13 03:05:23 +00002302}
2303
Chris Lattnere6327742008-04-02 05:18:44 +00002304//===----------------------------------------------------------------------===//
2305// Type Operators
2306//===----------------------------------------------------------------------===//
2307
John McCall54e14c42009-10-22 22:37:11 +00002308CanQualType ASTContext::getCanonicalParamType(QualType T) {
2309 // Push qualifiers into arrays, and then discard any remaining
2310 // qualifiers.
2311 T = getCanonicalType(T);
2312 const Type *Ty = T.getTypePtr();
2313
2314 QualType Result;
2315 if (isa<ArrayType>(Ty)) {
2316 Result = getArrayDecayedType(QualType(Ty,0));
2317 } else if (isa<FunctionType>(Ty)) {
2318 Result = getPointerType(QualType(Ty, 0));
2319 } else {
2320 Result = QualType(Ty, 0);
2321 }
2322
2323 return CanQualType::CreateUnsafe(Result);
2324}
2325
Chris Lattner77c96472008-04-06 22:41:35 +00002326/// getCanonicalType - Return the canonical (structural) type corresponding to
2327/// the specified potentially non-canonical type. The non-canonical version
2328/// of a type may have many "decorated" versions of types. Decorators can
2329/// include typedefs, 'typeof' operators, etc. The returned type is guaranteed
2330/// to be free of any of these, allowing two canonical types to be compared
2331/// for exact equality with a simple pointer comparison.
Douglas Gregor50d62d12009-08-05 05:36:45 +00002332CanQualType ASTContext::getCanonicalType(QualType T) {
John McCall0953e762009-09-24 19:53:00 +00002333 QualifierCollector Quals;
2334 const Type *Ptr = Quals.strip(T);
2335 QualType CanType = Ptr->getCanonicalTypeInternal();
Mike Stump1eb44332009-09-09 15:08:12 +00002336
John McCall0953e762009-09-24 19:53:00 +00002337 // The canonical internal type will be the canonical type *except*
2338 // that we push type qualifiers down through array types.
2339
2340 // If there are no new qualifiers to push down, stop here.
2341 if (!Quals.hasQualifiers())
Douglas Gregor50d62d12009-08-05 05:36:45 +00002342 return CanQualType::CreateUnsafe(CanType);
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002343
John McCall0953e762009-09-24 19:53:00 +00002344 // If the type qualifiers are on an array type, get the canonical
2345 // type of the array with the qualifiers applied to the element
2346 // type.
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002347 ArrayType *AT = dyn_cast<ArrayType>(CanType);
2348 if (!AT)
John McCall0953e762009-09-24 19:53:00 +00002349 return CanQualType::CreateUnsafe(getQualifiedType(CanType, Quals));
Mike Stump1eb44332009-09-09 15:08:12 +00002350
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002351 // Get the canonical version of the element with the extra qualifiers on it.
2352 // This can recursively sink qualifiers through multiple levels of arrays.
John McCall0953e762009-09-24 19:53:00 +00002353 QualType NewEltTy = getQualifiedType(AT->getElementType(), Quals);
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002354 NewEltTy = getCanonicalType(NewEltTy);
Mike Stump1eb44332009-09-09 15:08:12 +00002355
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002356 if (ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
Douglas Gregor50d62d12009-08-05 05:36:45 +00002357 return CanQualType::CreateUnsafe(
2358 getConstantArrayType(NewEltTy, CAT->getSize(),
2359 CAT->getSizeModifier(),
John McCall0953e762009-09-24 19:53:00 +00002360 CAT->getIndexTypeCVRQualifiers()));
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002361 if (IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT))
Douglas Gregor50d62d12009-08-05 05:36:45 +00002362 return CanQualType::CreateUnsafe(
2363 getIncompleteArrayType(NewEltTy, IAT->getSizeModifier(),
John McCall0953e762009-09-24 19:53:00 +00002364 IAT->getIndexTypeCVRQualifiers()));
Mike Stump1eb44332009-09-09 15:08:12 +00002365
Douglas Gregor898574e2008-12-05 23:32:09 +00002366 if (DependentSizedArrayType *DSAT = dyn_cast<DependentSizedArrayType>(AT))
Douglas Gregor50d62d12009-08-05 05:36:45 +00002367 return CanQualType::CreateUnsafe(
2368 getDependentSizedArrayType(NewEltTy,
Eli Friedmanbbed6b92009-08-15 02:50:32 +00002369 DSAT->getSizeExpr() ?
2370 DSAT->getSizeExpr()->Retain() : 0,
Douglas Gregor50d62d12009-08-05 05:36:45 +00002371 DSAT->getSizeModifier(),
John McCall0953e762009-09-24 19:53:00 +00002372 DSAT->getIndexTypeCVRQualifiers(),
Douglas Gregor87a924e2009-10-30 22:56:57 +00002373 DSAT->getBracketsRange())->getCanonicalTypeInternal());
Douglas Gregor898574e2008-12-05 23:32:09 +00002374
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002375 VariableArrayType *VAT = cast<VariableArrayType>(AT);
Douglas Gregor50d62d12009-08-05 05:36:45 +00002376 return CanQualType::CreateUnsafe(getVariableArrayType(NewEltTy,
Eli Friedmanbbed6b92009-08-15 02:50:32 +00002377 VAT->getSizeExpr() ?
2378 VAT->getSizeExpr()->Retain() : 0,
Douglas Gregor50d62d12009-08-05 05:36:45 +00002379 VAT->getSizeModifier(),
John McCall0953e762009-09-24 19:53:00 +00002380 VAT->getIndexTypeCVRQualifiers(),
Douglas Gregor50d62d12009-08-05 05:36:45 +00002381 VAT->getBracketsRange()));
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002382}
2383
John McCall80ad16f2009-11-24 18:42:40 +00002384DeclarationName ASTContext::getNameForTemplate(TemplateName Name) {
2385 if (TemplateDecl *TD = Name.getAsTemplateDecl())
2386 return TD->getDeclName();
2387
2388 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName()) {
2389 if (DTN->isIdentifier()) {
2390 return DeclarationNames.getIdentifier(DTN->getIdentifier());
2391 } else {
2392 return DeclarationNames.getCXXOperatorName(DTN->getOperator());
2393 }
2394 }
2395
John McCall0bd6feb2009-12-02 08:04:21 +00002396 OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate();
2397 assert(Storage);
2398 return (*Storage->begin())->getDeclName();
John McCall80ad16f2009-11-24 18:42:40 +00002399}
2400
Douglas Gregor25a3ef72009-05-07 06:41:52 +00002401TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) {
2402 // If this template name refers to a template, the canonical
2403 // template name merely stores the template itself.
2404 if (TemplateDecl *Template = Name.getAsTemplateDecl())
Argyrios Kyrtzidis97fbaa22009-07-18 00:34:25 +00002405 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
Douglas Gregor25a3ef72009-05-07 06:41:52 +00002406
John McCall0bd6feb2009-12-02 08:04:21 +00002407 assert(!Name.getAsOverloadedTemplate());
Mike Stump1eb44332009-09-09 15:08:12 +00002408
Douglas Gregor25a3ef72009-05-07 06:41:52 +00002409 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
2410 assert(DTN && "Non-dependent template names must refer to template decls.");
2411 return DTN->CanonicalTemplateName;
2412}
2413
Douglas Gregordb0d4b72009-11-11 23:06:43 +00002414bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) {
2415 X = getCanonicalTemplateName(X);
2416 Y = getCanonicalTemplateName(Y);
2417 return X.getAsVoidPointer() == Y.getAsVoidPointer();
2418}
2419
Mike Stump1eb44332009-09-09 15:08:12 +00002420TemplateArgument
Douglas Gregor1275ae02009-07-28 23:00:59 +00002421ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) {
2422 switch (Arg.getKind()) {
2423 case TemplateArgument::Null:
2424 return Arg;
Mike Stump1eb44332009-09-09 15:08:12 +00002425
Douglas Gregor1275ae02009-07-28 23:00:59 +00002426 case TemplateArgument::Expression:
Douglas Gregor1275ae02009-07-28 23:00:59 +00002427 return Arg;
Mike Stump1eb44332009-09-09 15:08:12 +00002428
Douglas Gregor1275ae02009-07-28 23:00:59 +00002429 case TemplateArgument::Declaration:
John McCall833ca992009-10-29 08:12:44 +00002430 return TemplateArgument(Arg.getAsDecl()->getCanonicalDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00002431
Douglas Gregor788cd062009-11-11 01:00:40 +00002432 case TemplateArgument::Template:
2433 return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));
2434
Douglas Gregor1275ae02009-07-28 23:00:59 +00002435 case TemplateArgument::Integral:
John McCall833ca992009-10-29 08:12:44 +00002436 return TemplateArgument(*Arg.getAsIntegral(),
Douglas Gregor1275ae02009-07-28 23:00:59 +00002437 getCanonicalType(Arg.getIntegralType()));
Mike Stump1eb44332009-09-09 15:08:12 +00002438
Douglas Gregor1275ae02009-07-28 23:00:59 +00002439 case TemplateArgument::Type:
John McCall833ca992009-10-29 08:12:44 +00002440 return TemplateArgument(getCanonicalType(Arg.getAsType()));
Mike Stump1eb44332009-09-09 15:08:12 +00002441
Douglas Gregor1275ae02009-07-28 23:00:59 +00002442 case TemplateArgument::Pack: {
2443 // FIXME: Allocate in ASTContext
2444 TemplateArgument *CanonArgs = new TemplateArgument[Arg.pack_size()];
2445 unsigned Idx = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002446 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
Douglas Gregor1275ae02009-07-28 23:00:59 +00002447 AEnd = Arg.pack_end();
2448 A != AEnd; (void)++A, ++Idx)
2449 CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
Mike Stump1eb44332009-09-09 15:08:12 +00002450
Douglas Gregor1275ae02009-07-28 23:00:59 +00002451 TemplateArgument Result;
2452 Result.setArgumentPack(CanonArgs, Arg.pack_size(), false);
2453 return Result;
2454 }
2455 }
2456
2457 // Silence GCC warning
2458 assert(false && "Unhandled template argument kind");
2459 return TemplateArgument();
2460}
2461
Douglas Gregord57959a2009-03-27 23:10:48 +00002462NestedNameSpecifier *
2463ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) {
Mike Stump1eb44332009-09-09 15:08:12 +00002464 if (!NNS)
Douglas Gregord57959a2009-03-27 23:10:48 +00002465 return 0;
2466
2467 switch (NNS->getKind()) {
2468 case NestedNameSpecifier::Identifier:
2469 // Canonicalize the prefix but keep the identifier the same.
Mike Stump1eb44332009-09-09 15:08:12 +00002470 return NestedNameSpecifier::Create(*this,
Douglas Gregord57959a2009-03-27 23:10:48 +00002471 getCanonicalNestedNameSpecifier(NNS->getPrefix()),
2472 NNS->getAsIdentifier());
2473
2474 case NestedNameSpecifier::Namespace:
2475 // A namespace is canonical; build a nested-name-specifier with
2476 // this namespace and no prefix.
2477 return NestedNameSpecifier::Create(*this, 0, NNS->getAsNamespace());
2478
2479 case NestedNameSpecifier::TypeSpec:
2480 case NestedNameSpecifier::TypeSpecWithTemplate: {
2481 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
Mike Stump1eb44332009-09-09 15:08:12 +00002482 return NestedNameSpecifier::Create(*this, 0,
2483 NNS->getKind() == NestedNameSpecifier::TypeSpecWithTemplate,
Douglas Gregord57959a2009-03-27 23:10:48 +00002484 T.getTypePtr());
2485 }
2486
2487 case NestedNameSpecifier::Global:
2488 // The global specifier is canonical and unique.
2489 return NNS;
2490 }
2491
2492 // Required to silence a GCC warning
2493 return 0;
2494}
2495
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002496
2497const ArrayType *ASTContext::getAsArrayType(QualType T) {
2498 // Handle the non-qualified case efficiently.
Douglas Gregora4923eb2009-11-16 21:35:15 +00002499 if (!T.hasLocalQualifiers()) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002500 // Handle the common positive case fast.
2501 if (const ArrayType *AT = dyn_cast<ArrayType>(T))
2502 return AT;
2503 }
Mike Stump1eb44332009-09-09 15:08:12 +00002504
John McCall0953e762009-09-24 19:53:00 +00002505 // Handle the common negative case fast.
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002506 QualType CType = T->getCanonicalTypeInternal();
John McCall0953e762009-09-24 19:53:00 +00002507 if (!isa<ArrayType>(CType))
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002508 return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002509
John McCall0953e762009-09-24 19:53:00 +00002510 // Apply any qualifiers from the array type to the element type. This
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002511 // implements C99 6.7.3p8: "If the specification of an array type includes
2512 // any type qualifiers, the element type is so qualified, not the array type."
Mike Stump1eb44332009-09-09 15:08:12 +00002513
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002514 // If we get here, we either have type qualifiers on the type, or we have
2515 // sugar such as a typedef in the way. If we have type qualifiers on the type
Douglas Gregor50d62d12009-08-05 05:36:45 +00002516 // we must propagate them down into the element type.
Mike Stump1eb44332009-09-09 15:08:12 +00002517
John McCall0953e762009-09-24 19:53:00 +00002518 QualifierCollector Qs;
2519 const Type *Ty = Qs.strip(T.getDesugaredType());
Mike Stump1eb44332009-09-09 15:08:12 +00002520
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002521 // If we have a simple case, just return now.
2522 const ArrayType *ATy = dyn_cast<ArrayType>(Ty);
John McCall0953e762009-09-24 19:53:00 +00002523 if (ATy == 0 || Qs.empty())
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002524 return ATy;
Mike Stump1eb44332009-09-09 15:08:12 +00002525
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002526 // Otherwise, we have an array and we have qualifiers on it. Push the
2527 // qualifiers into the array element type and return a new array type.
2528 // Get the canonical version of the element with the extra qualifiers on it.
2529 // This can recursively sink qualifiers through multiple levels of arrays.
John McCall0953e762009-09-24 19:53:00 +00002530 QualType NewEltTy = getQualifiedType(ATy->getElementType(), Qs);
Mike Stump1eb44332009-09-09 15:08:12 +00002531
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002532 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy))
2533 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
2534 CAT->getSizeModifier(),
John McCall0953e762009-09-24 19:53:00 +00002535 CAT->getIndexTypeCVRQualifiers()));
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002536 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy))
2537 return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
2538 IAT->getSizeModifier(),
John McCall0953e762009-09-24 19:53:00 +00002539 IAT->getIndexTypeCVRQualifiers()));
Douglas Gregor898574e2008-12-05 23:32:09 +00002540
Mike Stump1eb44332009-09-09 15:08:12 +00002541 if (const DependentSizedArrayType *DSAT
Douglas Gregor898574e2008-12-05 23:32:09 +00002542 = dyn_cast<DependentSizedArrayType>(ATy))
2543 return cast<ArrayType>(
Mike Stump1eb44332009-09-09 15:08:12 +00002544 getDependentSizedArrayType(NewEltTy,
Eli Friedmanbbed6b92009-08-15 02:50:32 +00002545 DSAT->getSizeExpr() ?
2546 DSAT->getSizeExpr()->Retain() : 0,
Douglas Gregor898574e2008-12-05 23:32:09 +00002547 DSAT->getSizeModifier(),
John McCall0953e762009-09-24 19:53:00 +00002548 DSAT->getIndexTypeCVRQualifiers(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002549 DSAT->getBracketsRange()));
Mike Stump1eb44332009-09-09 15:08:12 +00002550
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002551 const VariableArrayType *VAT = cast<VariableArrayType>(ATy);
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002552 return cast<ArrayType>(getVariableArrayType(NewEltTy,
Eli Friedmanbbed6b92009-08-15 02:50:32 +00002553 VAT->getSizeExpr() ?
John McCall0953e762009-09-24 19:53:00 +00002554 VAT->getSizeExpr()->Retain() : 0,
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002555 VAT->getSizeModifier(),
John McCall0953e762009-09-24 19:53:00 +00002556 VAT->getIndexTypeCVRQualifiers(),
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00002557 VAT->getBracketsRange()));
Chris Lattner77c96472008-04-06 22:41:35 +00002558}
2559
2560
Chris Lattnere6327742008-04-02 05:18:44 +00002561/// getArrayDecayedType - Return the properly qualified result of decaying the
2562/// specified array type to a pointer. This operation is non-trivial when
2563/// handling typedefs etc. The canonical type of "T" must be an array type,
2564/// this returns a pointer to a properly qualified element of the array.
2565///
2566/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
2567QualType ASTContext::getArrayDecayedType(QualType Ty) {
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002568 // Get the element type with 'getAsArrayType' so that we don't lose any
2569 // typedefs in the element type of the array. This also handles propagation
2570 // of type qualifiers from the array type into the element type if present
2571 // (C99 6.7.3p8).
2572 const ArrayType *PrettyArrayType = getAsArrayType(Ty);
2573 assert(PrettyArrayType && "Not an array type!");
Mike Stump1eb44332009-09-09 15:08:12 +00002574
Chris Lattnerc63a1f22008-08-04 07:31:14 +00002575 QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
Chris Lattnere6327742008-04-02 05:18:44 +00002576
2577 // int x[restrict 4] -> int *restrict
John McCall0953e762009-09-24 19:53:00 +00002578 return getQualifiedType(PtrTy, PrettyArrayType->getIndexTypeQualifiers());
Chris Lattnere6327742008-04-02 05:18:44 +00002579}
2580
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00002581QualType ASTContext::getBaseElementType(QualType QT) {
John McCall0953e762009-09-24 19:53:00 +00002582 QualifierCollector Qs;
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00002583 while (true) {
John McCall0953e762009-09-24 19:53:00 +00002584 const Type *UT = Qs.strip(QT);
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00002585 if (const ArrayType *AT = getAsArrayType(QualType(UT,0))) {
2586 QT = AT->getElementType();
Mike Stump6dcbc292009-07-25 23:24:03 +00002587 } else {
John McCall0953e762009-09-24 19:53:00 +00002588 return Qs.apply(QT);
Douglas Gregor5e03f9e2009-07-23 23:49:00 +00002589 }
2590 }
2591}
2592
Anders Carlssonfbbce492009-09-25 01:23:32 +00002593QualType ASTContext::getBaseElementType(const ArrayType *AT) {
2594 QualType ElemTy = AT->getElementType();
Mike Stump1eb44332009-09-09 15:08:12 +00002595
Anders Carlssonfbbce492009-09-25 01:23:32 +00002596 if (const ArrayType *AT = getAsArrayType(ElemTy))
2597 return getBaseElementType(AT);
Mike Stump1eb44332009-09-09 15:08:12 +00002598
Anders Carlsson6183a992008-12-21 03:44:36 +00002599 return ElemTy;
2600}
2601
Fariborz Jahanian0de78992009-08-21 16:31:06 +00002602/// getConstantArrayElementCount - Returns number of constant array elements.
Mike Stump1eb44332009-09-09 15:08:12 +00002603uint64_t
Fariborz Jahanian0de78992009-08-21 16:31:06 +00002604ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const {
2605 uint64_t ElementCount = 1;
2606 do {
2607 ElementCount *= CA->getSize().getZExtValue();
2608 CA = dyn_cast<ConstantArrayType>(CA->getElementType());
2609 } while (CA);
2610 return ElementCount;
2611}
2612
Reid Spencer5f016e22007-07-11 17:01:13 +00002613/// getFloatingRank - Return a relative rank for floating point types.
2614/// This routine will assert if passed a built-in type that isn't a float.
Chris Lattnera75cea32008-04-06 23:38:49 +00002615static FloatingRank getFloatingRank(QualType T) {
John McCall183700f2009-09-21 23:43:11 +00002616 if (const ComplexType *CT = T->getAs<ComplexType>())
Reid Spencer5f016e22007-07-11 17:01:13 +00002617 return getFloatingRank(CT->getElementType());
Chris Lattnera75cea32008-04-06 23:38:49 +00002618
John McCall183700f2009-09-21 23:43:11 +00002619 assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type");
2620 switch (T->getAs<BuiltinType>()->getKind()) {
Chris Lattnera75cea32008-04-06 23:38:49 +00002621 default: assert(0 && "getFloatingRank(): not a floating type");
Reid Spencer5f016e22007-07-11 17:01:13 +00002622 case BuiltinType::Float: return FloatRank;
2623 case BuiltinType::Double: return DoubleRank;
2624 case BuiltinType::LongDouble: return LongDoubleRank;
2625 }
2626}
2627
Mike Stump1eb44332009-09-09 15:08:12 +00002628/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
2629/// point or a complex type (based on typeDomain/typeSize).
Steve Naroff716c7302007-08-27 01:41:48 +00002630/// 'typeDomain' is a real floating point or complex type.
2631/// 'typeSize' is a real floating point or complex type.
Chris Lattner1361b112008-04-06 23:58:54 +00002632QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
2633 QualType Domain) const {
2634 FloatingRank EltRank = getFloatingRank(Size);
2635 if (Domain->isComplexType()) {
2636 switch (EltRank) {
Steve Naroff716c7302007-08-27 01:41:48 +00002637 default: assert(0 && "getFloatingRank(): illegal value for rank");
Steve Narofff1448a02007-08-27 01:27:54 +00002638 case FloatRank: return FloatComplexTy;
2639 case DoubleRank: return DoubleComplexTy;
2640 case LongDoubleRank: return LongDoubleComplexTy;
2641 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002642 }
Chris Lattner1361b112008-04-06 23:58:54 +00002643
2644 assert(Domain->isRealFloatingType() && "Unknown domain!");
2645 switch (EltRank) {
2646 default: assert(0 && "getFloatingRank(): illegal value for rank");
2647 case FloatRank: return FloatTy;
2648 case DoubleRank: return DoubleTy;
2649 case LongDoubleRank: return LongDoubleTy;
Steve Narofff1448a02007-08-27 01:27:54 +00002650 }
Reid Spencer5f016e22007-07-11 17:01:13 +00002651}
2652
Chris Lattner7cfeb082008-04-06 23:55:33 +00002653/// getFloatingTypeOrder - Compare the rank of the two specified floating
2654/// point types, ignoring the domain of the type (i.e. 'double' ==
2655/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
Mike Stump1eb44332009-09-09 15:08:12 +00002656/// LHS < RHS, return -1.
Chris Lattnera75cea32008-04-06 23:38:49 +00002657int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) {
2658 FloatingRank LHSR = getFloatingRank(LHS);
2659 FloatingRank RHSR = getFloatingRank(RHS);
Mike Stump1eb44332009-09-09 15:08:12 +00002660
Chris Lattnera75cea32008-04-06 23:38:49 +00002661 if (LHSR == RHSR)
Steve Narofffb0d4962007-08-27 15:30:22 +00002662 return 0;
Chris Lattnera75cea32008-04-06 23:38:49 +00002663 if (LHSR > RHSR)
Steve Narofffb0d4962007-08-27 15:30:22 +00002664 return 1;
2665 return -1;
Reid Spencer5f016e22007-07-11 17:01:13 +00002666}
2667
Chris Lattnerf52ab252008-04-06 22:59:24 +00002668/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
2669/// routine will assert if passed a built-in type that isn't an integer or enum,
2670/// or if it is not canonicalized.
Eli Friedmanf98aba32009-02-13 02:31:07 +00002671unsigned ASTContext::getIntegerRank(Type *T) {
John McCall467b27b2009-10-22 20:10:53 +00002672 assert(T->isCanonicalUnqualified() && "T should be canonicalized");
Eli Friedmanf98aba32009-02-13 02:31:07 +00002673 if (EnumType* ET = dyn_cast<EnumType>(T))
John McCall842aef82009-12-09 09:09:27 +00002674 T = ET->getDecl()->getPromotionType().getTypePtr();
Eli Friedmanf98aba32009-02-13 02:31:07 +00002675
Eli Friedmana3426752009-07-05 23:44:27 +00002676 if (T->isSpecificBuiltinType(BuiltinType::WChar))
2677 T = getFromTargetType(Target.getWCharType()).getTypePtr();
2678
Alisdair Meredithf5c209d2009-07-14 06:30:34 +00002679 if (T->isSpecificBuiltinType(BuiltinType::Char16))
2680 T = getFromTargetType(Target.getChar16Type()).getTypePtr();
2681
2682 if (T->isSpecificBuiltinType(BuiltinType::Char32))
2683 T = getFromTargetType(Target.getChar32Type()).getTypePtr();
2684
Eli Friedmanf98aba32009-02-13 02:31:07 +00002685 // There are two things which impact the integer rank: the width, and
2686 // the ordering of builtins. The builtin ordering is encoded in the
2687 // bottom three bits; the width is encoded in the bits above that.
Chris Lattner1b63e4f2009-06-14 01:54:56 +00002688 if (FixedWidthIntType* FWIT = dyn_cast<FixedWidthIntType>(T))
Eli Friedmanf98aba32009-02-13 02:31:07 +00002689 return FWIT->getWidth() << 3;
Eli Friedmanf98aba32009-02-13 02:31:07 +00002690
Chris Lattnerf52ab252008-04-06 22:59:24 +00002691 switch (cast<BuiltinType>(T)->getKind()) {
Chris Lattner7cfeb082008-04-06 23:55:33 +00002692 default: assert(0 && "getIntegerRank(): not a built-in integer");
2693 case BuiltinType::Bool:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002694 return 1 + (getIntWidth(BoolTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002695 case BuiltinType::Char_S:
2696 case BuiltinType::Char_U:
2697 case BuiltinType::SChar:
2698 case BuiltinType::UChar:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002699 return 2 + (getIntWidth(CharTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002700 case BuiltinType::Short:
2701 case BuiltinType::UShort:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002702 return 3 + (getIntWidth(ShortTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002703 case BuiltinType::Int:
2704 case BuiltinType::UInt:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002705 return 4 + (getIntWidth(IntTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002706 case BuiltinType::Long:
2707 case BuiltinType::ULong:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002708 return 5 + (getIntWidth(LongTy) << 3);
Chris Lattner7cfeb082008-04-06 23:55:33 +00002709 case BuiltinType::LongLong:
2710 case BuiltinType::ULongLong:
Eli Friedmanf98aba32009-02-13 02:31:07 +00002711 return 6 + (getIntWidth(LongLongTy) << 3);
Chris Lattner2df9ced2009-04-30 02:43:43 +00002712 case BuiltinType::Int128:
2713 case BuiltinType::UInt128:
2714 return 7 + (getIntWidth(Int128Ty) << 3);
Chris Lattnerf52ab252008-04-06 22:59:24 +00002715 }
2716}
2717
Eli Friedman04e83572009-08-20 04:21:42 +00002718/// \brief Whether this is a promotable bitfield reference according
2719/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
2720///
2721/// \returns the type this bit-field will promote to, or NULL if no
2722/// promotion occurs.
2723QualType ASTContext::isPromotableBitField(Expr *E) {
2724 FieldDecl *Field = E->getBitField();
2725 if (!Field)
2726 return QualType();
2727
2728 QualType FT = Field->getType();
2729
2730 llvm::APSInt BitWidthAP = Field->getBitWidth()->EvaluateAsInt(*this);
2731 uint64_t BitWidth = BitWidthAP.getZExtValue();
2732 uint64_t IntSize = getTypeSize(IntTy);
2733 // GCC extension compatibility: if the bit-field size is less than or equal
2734 // to the size of int, it gets promoted no matter what its type is.
2735 // For instance, unsigned long bf : 4 gets promoted to signed int.
2736 if (BitWidth < IntSize)
2737 return IntTy;
2738
2739 if (BitWidth == IntSize)
2740 return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy;
2741
2742 // Types bigger than int are not subject to promotions, and therefore act
2743 // like the base type.
2744 // FIXME: This doesn't quite match what gcc does, but what gcc does here
2745 // is ridiculous.
2746 return QualType();
2747}
2748
Eli Friedmana95d7572009-08-19 07:44:53 +00002749/// getPromotedIntegerType - Returns the type that Promotable will
2750/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
2751/// integer type.
2752QualType ASTContext::getPromotedIntegerType(QualType Promotable) {
2753 assert(!Promotable.isNull());
2754 assert(Promotable->isPromotableIntegerType());
John McCall842aef82009-12-09 09:09:27 +00002755 if (const EnumType *ET = Promotable->getAs<EnumType>())
2756 return ET->getDecl()->getPromotionType();
Eli Friedmana95d7572009-08-19 07:44:53 +00002757 if (Promotable->isSignedIntegerType())
2758 return IntTy;
2759 uint64_t PromotableSize = getTypeSize(Promotable);
2760 uint64_t IntSize = getTypeSize(IntTy);
2761 assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize);
2762 return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
2763}
2764
Mike Stump1eb44332009-09-09 15:08:12 +00002765/// getIntegerTypeOrder - Returns the highest ranked integer type:
Chris Lattner7cfeb082008-04-06 23:55:33 +00002766/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
Mike Stump1eb44332009-09-09 15:08:12 +00002767/// LHS < RHS, return -1.
Chris Lattner7cfeb082008-04-06 23:55:33 +00002768int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) {
Chris Lattnerf52ab252008-04-06 22:59:24 +00002769 Type *LHSC = getCanonicalType(LHS).getTypePtr();
2770 Type *RHSC = getCanonicalType(RHS).getTypePtr();
Chris Lattner7cfeb082008-04-06 23:55:33 +00002771 if (LHSC == RHSC) return 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002772
Chris Lattnerf52ab252008-04-06 22:59:24 +00002773 bool LHSUnsigned = LHSC->isUnsignedIntegerType();
2774 bool RHSUnsigned = RHSC->isUnsignedIntegerType();
Mike Stump1eb44332009-09-09 15:08:12 +00002775
Chris Lattner7cfeb082008-04-06 23:55:33 +00002776 unsigned LHSRank = getIntegerRank(LHSC);
2777 unsigned RHSRank = getIntegerRank(RHSC);
Mike Stump1eb44332009-09-09 15:08:12 +00002778
Chris Lattner7cfeb082008-04-06 23:55:33 +00002779 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
2780 if (LHSRank == RHSRank) return 0;
2781 return LHSRank > RHSRank ? 1 : -1;
2782 }
Mike Stump1eb44332009-09-09 15:08:12 +00002783
Chris Lattner7cfeb082008-04-06 23:55:33 +00002784 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
2785 if (LHSUnsigned) {
2786 // If the unsigned [LHS] type is larger, return it.
2787 if (LHSRank >= RHSRank)
2788 return 1;
Mike Stump1eb44332009-09-09 15:08:12 +00002789
Chris Lattner7cfeb082008-04-06 23:55:33 +00002790 // If the signed type can represent all values of the unsigned type, it
2791 // wins. Because we are dealing with 2's complement and types that are
Mike Stump1eb44332009-09-09 15:08:12 +00002792 // powers of two larger than each other, this is always safe.
Chris Lattner7cfeb082008-04-06 23:55:33 +00002793 return -1;
2794 }
Chris Lattnerf52ab252008-04-06 22:59:24 +00002795
Chris Lattner7cfeb082008-04-06 23:55:33 +00002796 // If the unsigned [RHS] type is larger, return it.
2797 if (RHSRank >= LHSRank)
2798 return -1;
Mike Stump1eb44332009-09-09 15:08:12 +00002799
Chris Lattner7cfeb082008-04-06 23:55:33 +00002800 // If the signed type can represent all values of the unsigned type, it
2801 // wins. Because we are dealing with 2's complement and types that are
Mike Stump1eb44332009-09-09 15:08:12 +00002802 // powers of two larger than each other, this is always safe.
Chris Lattner7cfeb082008-04-06 23:55:33 +00002803 return 1;
Reid Spencer5f016e22007-07-11 17:01:13 +00002804}
Anders Carlsson71993dd2007-08-17 05:31:46 +00002805
Anders Carlsson79cbc7d2009-11-14 21:45:58 +00002806static RecordDecl *
2807CreateRecordDecl(ASTContext &Ctx, RecordDecl::TagKind TK, DeclContext *DC,
2808 SourceLocation L, IdentifierInfo *Id) {
2809 if (Ctx.getLangOptions().CPlusPlus)
2810 return CXXRecordDecl::Create(Ctx, TK, DC, L, Id);
2811 else
2812 return RecordDecl::Create(Ctx, TK, DC, L, Id);
2813}
2814
Mike Stump1eb44332009-09-09 15:08:12 +00002815// getCFConstantStringType - Return the type used for constant CFStrings.
Anders Carlsson71993dd2007-08-17 05:31:46 +00002816QualType ASTContext::getCFConstantStringType() {
2817 if (!CFConstantStringTypeDecl) {
Mike Stump1eb44332009-09-09 15:08:12 +00002818 CFConstantStringTypeDecl =
Anders Carlsson79cbc7d2009-11-14 21:45:58 +00002819 CreateRecordDecl(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
2820 &Idents.get("NSConstantString"));
2821
Anders Carlssonf06273f2007-11-19 00:25:30 +00002822 QualType FieldTypes[4];
Mike Stump1eb44332009-09-09 15:08:12 +00002823
Anders Carlsson71993dd2007-08-17 05:31:46 +00002824 // const int *isa;
John McCall0953e762009-09-24 19:53:00 +00002825 FieldTypes[0] = getPointerType(IntTy.withConst());
Anders Carlssonf06273f2007-11-19 00:25:30 +00002826 // int flags;
2827 FieldTypes[1] = IntTy;
Anders Carlsson71993dd2007-08-17 05:31:46 +00002828 // const char *str;
John McCall0953e762009-09-24 19:53:00 +00002829 FieldTypes[2] = getPointerType(CharTy.withConst());
Anders Carlsson71993dd2007-08-17 05:31:46 +00002830 // long length;
Mike Stump1eb44332009-09-09 15:08:12 +00002831 FieldTypes[3] = LongTy;
2832
Anders Carlsson71993dd2007-08-17 05:31:46 +00002833 // Create fields
Douglas Gregor44b43212008-12-11 16:49:14 +00002834 for (unsigned i = 0; i < 4; ++i) {
Mike Stump1eb44332009-09-09 15:08:12 +00002835 FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTypeDecl,
Douglas Gregor44b43212008-12-11 16:49:14 +00002836 SourceLocation(), 0,
John McCalla93c9342009-12-07 02:54:59 +00002837 FieldTypes[i], /*TInfo=*/0,
Mike Stump1eb44332009-09-09 15:08:12 +00002838 /*BitWidth=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002839 /*Mutable=*/false);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002840 CFConstantStringTypeDecl->addDecl(Field);
Douglas Gregor44b43212008-12-11 16:49:14 +00002841 }
2842
2843 CFConstantStringTypeDecl->completeDefinition(*this);
Anders Carlsson71993dd2007-08-17 05:31:46 +00002844 }
Mike Stump1eb44332009-09-09 15:08:12 +00002845
Anders Carlsson71993dd2007-08-17 05:31:46 +00002846 return getTagDeclType(CFConstantStringTypeDecl);
Gabor Greif84675832007-09-11 15:32:40 +00002847}
Anders Carlssonb2cf3572007-10-11 01:00:40 +00002848
Douglas Gregor319ac892009-04-23 22:29:11 +00002849void ASTContext::setCFConstantStringType(QualType T) {
Ted Kremenek6217b802009-07-29 21:53:49 +00002850 const RecordType *Rec = T->getAs<RecordType>();
Douglas Gregor319ac892009-04-23 22:29:11 +00002851 assert(Rec && "Invalid CFConstantStringType");
2852 CFConstantStringTypeDecl = Rec->getDecl();
2853}
2854
Mike Stump1eb44332009-09-09 15:08:12 +00002855QualType ASTContext::getObjCFastEnumerationStateType() {
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002856 if (!ObjCFastEnumerationStateTypeDecl) {
Douglas Gregor44b43212008-12-11 16:49:14 +00002857 ObjCFastEnumerationStateTypeDecl =
Anders Carlsson79cbc7d2009-11-14 21:45:58 +00002858 CreateRecordDecl(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
2859 &Idents.get("__objcFastEnumerationState"));
Mike Stump1eb44332009-09-09 15:08:12 +00002860
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002861 QualType FieldTypes[] = {
2862 UnsignedLongTy,
Steve Naroffde2e22d2009-07-15 18:40:39 +00002863 getPointerType(ObjCIdTypedefType),
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002864 getPointerType(UnsignedLongTy),
2865 getConstantArrayType(UnsignedLongTy,
2866 llvm::APInt(32, 5), ArrayType::Normal, 0)
2867 };
Mike Stump1eb44332009-09-09 15:08:12 +00002868
Douglas Gregor44b43212008-12-11 16:49:14 +00002869 for (size_t i = 0; i < 4; ++i) {
Mike Stump1eb44332009-09-09 15:08:12 +00002870 FieldDecl *Field = FieldDecl::Create(*this,
2871 ObjCFastEnumerationStateTypeDecl,
2872 SourceLocation(), 0,
John McCalla93c9342009-12-07 02:54:59 +00002873 FieldTypes[i], /*TInfo=*/0,
Mike Stump1eb44332009-09-09 15:08:12 +00002874 /*BitWidth=*/0,
Douglas Gregor4afa39d2009-01-20 01:17:11 +00002875 /*Mutable=*/false);
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002876 ObjCFastEnumerationStateTypeDecl->addDecl(Field);
Douglas Gregor44b43212008-12-11 16:49:14 +00002877 }
Mike Stump1eb44332009-09-09 15:08:12 +00002878
Douglas Gregor44b43212008-12-11 16:49:14 +00002879 ObjCFastEnumerationStateTypeDecl->completeDefinition(*this);
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002880 }
Mike Stump1eb44332009-09-09 15:08:12 +00002881
Anders Carlssonbd4c1ad2008-08-30 19:34:46 +00002882 return getTagDeclType(ObjCFastEnumerationStateTypeDecl);
2883}
2884
Mike Stumpadaaad32009-10-20 02:12:22 +00002885QualType ASTContext::getBlockDescriptorType() {
2886 if (BlockDescriptorType)
2887 return getTagDeclType(BlockDescriptorType);
2888
2889 RecordDecl *T;
2890 // FIXME: Needs the FlagAppleBlock bit.
Anders Carlsson79cbc7d2009-11-14 21:45:58 +00002891 T = CreateRecordDecl(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
2892 &Idents.get("__block_descriptor"));
Mike Stumpadaaad32009-10-20 02:12:22 +00002893
2894 QualType FieldTypes[] = {
2895 UnsignedLongTy,
2896 UnsignedLongTy,
2897 };
2898
2899 const char *FieldNames[] = {
2900 "reserved",
Mike Stump083c25e2009-10-22 00:49:09 +00002901 "Size"
Mike Stumpadaaad32009-10-20 02:12:22 +00002902 };
2903
2904 for (size_t i = 0; i < 2; ++i) {
2905 FieldDecl *Field = FieldDecl::Create(*this,
2906 T,
2907 SourceLocation(),
2908 &Idents.get(FieldNames[i]),
John McCalla93c9342009-12-07 02:54:59 +00002909 FieldTypes[i], /*TInfo=*/0,
Mike Stumpadaaad32009-10-20 02:12:22 +00002910 /*BitWidth=*/0,
2911 /*Mutable=*/false);
2912 T->addDecl(Field);
2913 }
2914
2915 T->completeDefinition(*this);
2916
2917 BlockDescriptorType = T;
2918
2919 return getTagDeclType(BlockDescriptorType);
2920}
2921
2922void ASTContext::setBlockDescriptorType(QualType T) {
2923 const RecordType *Rec = T->getAs<RecordType>();
2924 assert(Rec && "Invalid BlockDescriptorType");
2925 BlockDescriptorType = Rec->getDecl();
2926}
2927
Mike Stump083c25e2009-10-22 00:49:09 +00002928QualType ASTContext::getBlockDescriptorExtendedType() {
2929 if (BlockDescriptorExtendedType)
2930 return getTagDeclType(BlockDescriptorExtendedType);
2931
2932 RecordDecl *T;
2933 // FIXME: Needs the FlagAppleBlock bit.
Anders Carlsson79cbc7d2009-11-14 21:45:58 +00002934 T = CreateRecordDecl(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
2935 &Idents.get("__block_descriptor_withcopydispose"));
Mike Stump083c25e2009-10-22 00:49:09 +00002936
2937 QualType FieldTypes[] = {
2938 UnsignedLongTy,
2939 UnsignedLongTy,
2940 getPointerType(VoidPtrTy),
2941 getPointerType(VoidPtrTy)
2942 };
2943
2944 const char *FieldNames[] = {
2945 "reserved",
2946 "Size",
2947 "CopyFuncPtr",
2948 "DestroyFuncPtr"
2949 };
2950
2951 for (size_t i = 0; i < 4; ++i) {
2952 FieldDecl *Field = FieldDecl::Create(*this,
2953 T,
2954 SourceLocation(),
2955 &Idents.get(FieldNames[i]),
John McCalla93c9342009-12-07 02:54:59 +00002956 FieldTypes[i], /*TInfo=*/0,
Mike Stump083c25e2009-10-22 00:49:09 +00002957 /*BitWidth=*/0,
2958 /*Mutable=*/false);
2959 T->addDecl(Field);
2960 }
2961
2962 T->completeDefinition(*this);
2963
2964 BlockDescriptorExtendedType = T;
2965
2966 return getTagDeclType(BlockDescriptorExtendedType);
2967}
2968
2969void ASTContext::setBlockDescriptorExtendedType(QualType T) {
2970 const RecordType *Rec = T->getAs<RecordType>();
2971 assert(Rec && "Invalid BlockDescriptorType");
2972 BlockDescriptorExtendedType = Rec->getDecl();
2973}
2974
Mike Stumpaf7b44d2009-10-21 18:16:27 +00002975bool ASTContext::BlockRequiresCopying(QualType Ty) {
2976 if (Ty->isBlockPointerType())
2977 return true;
2978 if (isObjCNSObjectType(Ty))
2979 return true;
2980 if (Ty->isObjCObjectPointerType())
2981 return true;
2982 return false;
2983}
2984
2985QualType ASTContext::BuildByRefType(const char *DeclName, QualType Ty) {
2986 // type = struct __Block_byref_1_X {
Mike Stumpea26cb52009-10-21 03:49:08 +00002987 // void *__isa;
Mike Stumpaf7b44d2009-10-21 18:16:27 +00002988 // struct __Block_byref_1_X *__forwarding;
Mike Stumpea26cb52009-10-21 03:49:08 +00002989 // unsigned int __flags;
2990 // unsigned int __size;
Mike Stump38e16272009-10-21 22:01:24 +00002991 // void *__copy_helper; // as needed
2992 // void *__destroy_help // as needed
Mike Stumpaf7b44d2009-10-21 18:16:27 +00002993 // int X;
Mike Stumpea26cb52009-10-21 03:49:08 +00002994 // } *
2995
Mike Stumpaf7b44d2009-10-21 18:16:27 +00002996 bool HasCopyAndDispose = BlockRequiresCopying(Ty);
2997
2998 // FIXME: Move up
Fariborz Jahanian4d0d85c2009-10-24 00:16:42 +00002999 static unsigned int UniqueBlockByRefTypeID = 0;
Benjamin Kramerf5942a42009-10-24 09:57:09 +00003000 llvm::SmallString<36> Name;
3001 llvm::raw_svector_ostream(Name) << "__Block_byref_" <<
3002 ++UniqueBlockByRefTypeID << '_' << DeclName;
Mike Stumpaf7b44d2009-10-21 18:16:27 +00003003 RecordDecl *T;
Anders Carlsson79cbc7d2009-11-14 21:45:58 +00003004 T = CreateRecordDecl(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
3005 &Idents.get(Name.str()));
Mike Stumpaf7b44d2009-10-21 18:16:27 +00003006 T->startDefinition();
3007 QualType Int32Ty = IntTy;
3008 assert(getIntWidth(IntTy) == 32 && "non-32bit int not supported");
3009 QualType FieldTypes[] = {
3010 getPointerType(VoidPtrTy),
3011 getPointerType(getTagDeclType(T)),
3012 Int32Ty,
3013 Int32Ty,
3014 getPointerType(VoidPtrTy),
3015 getPointerType(VoidPtrTy),
3016 Ty
3017 };
3018
3019 const char *FieldNames[] = {
3020 "__isa",
3021 "__forwarding",
3022 "__flags",
3023 "__size",
3024 "__copy_helper",
3025 "__destroy_helper",
3026 DeclName,
3027 };
3028
3029 for (size_t i = 0; i < 7; ++i) {
3030 if (!HasCopyAndDispose && i >=4 && i <= 5)
3031 continue;
3032 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(),
3033 &Idents.get(FieldNames[i]),
John McCalla93c9342009-12-07 02:54:59 +00003034 FieldTypes[i], /*TInfo=*/0,
Mike Stumpaf7b44d2009-10-21 18:16:27 +00003035 /*BitWidth=*/0, /*Mutable=*/false);
3036 T->addDecl(Field);
3037 }
3038
3039 T->completeDefinition(*this);
3040
3041 return getPointerType(getTagDeclType(T));
Mike Stumpea26cb52009-10-21 03:49:08 +00003042}
3043
3044
3045QualType ASTContext::getBlockParmType(
Mike Stump083c25e2009-10-22 00:49:09 +00003046 bool BlockHasCopyDispose,
Mike Stumpea26cb52009-10-21 03:49:08 +00003047 llvm::SmallVector<const Expr *, 8> &BlockDeclRefDecls) {
Mike Stumpadaaad32009-10-20 02:12:22 +00003048 // FIXME: Move up
Fariborz Jahanian4d0d85c2009-10-24 00:16:42 +00003049 static unsigned int UniqueBlockParmTypeID = 0;
Benjamin Kramerf5942a42009-10-24 09:57:09 +00003050 llvm::SmallString<36> Name;
3051 llvm::raw_svector_ostream(Name) << "__block_literal_"
3052 << ++UniqueBlockParmTypeID;
Mike Stumpadaaad32009-10-20 02:12:22 +00003053 RecordDecl *T;
Anders Carlsson79cbc7d2009-11-14 21:45:58 +00003054 T = CreateRecordDecl(*this, TagDecl::TK_struct, TUDecl, SourceLocation(),
3055 &Idents.get(Name.str()));
Mike Stumpadaaad32009-10-20 02:12:22 +00003056 QualType FieldTypes[] = {
3057 getPointerType(VoidPtrTy),
3058 IntTy,
3059 IntTy,
3060 getPointerType(VoidPtrTy),
Mike Stump083c25e2009-10-22 00:49:09 +00003061 (BlockHasCopyDispose ?
3062 getPointerType(getBlockDescriptorExtendedType()) :
3063 getPointerType(getBlockDescriptorType()))
Mike Stumpadaaad32009-10-20 02:12:22 +00003064 };
3065
3066 const char *FieldNames[] = {
3067 "__isa",
3068 "__flags",
3069 "__reserved",
3070 "__FuncPtr",
3071 "__descriptor"
3072 };
3073
3074 for (size_t i = 0; i < 5; ++i) {
Mike Stumpea26cb52009-10-21 03:49:08 +00003075 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(),
Mike Stumpadaaad32009-10-20 02:12:22 +00003076 &Idents.get(FieldNames[i]),
John McCalla93c9342009-12-07 02:54:59 +00003077 FieldTypes[i], /*TInfo=*/0,
Mike Stumpea26cb52009-10-21 03:49:08 +00003078 /*BitWidth=*/0, /*Mutable=*/false);
3079 T->addDecl(Field);
3080 }
3081
3082 for (size_t i = 0; i < BlockDeclRefDecls.size(); ++i) {
3083 const Expr *E = BlockDeclRefDecls[i];
3084 const BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(E);
3085 clang::IdentifierInfo *Name = 0;
3086 if (BDRE) {
3087 const ValueDecl *D = BDRE->getDecl();
3088 Name = &Idents.get(D->getName());
3089 }
3090 QualType FieldType = E->getType();
3091
3092 if (BDRE && BDRE->isByRef())
Mike Stumpaf7b44d2009-10-21 18:16:27 +00003093 FieldType = BuildByRefType(BDRE->getDecl()->getNameAsCString(),
3094 FieldType);
Mike Stumpea26cb52009-10-21 03:49:08 +00003095
3096 FieldDecl *Field = FieldDecl::Create(*this, T, SourceLocation(),
John McCalla93c9342009-12-07 02:54:59 +00003097 Name, FieldType, /*TInfo=*/0,
Mike Stumpea26cb52009-10-21 03:49:08 +00003098 /*BitWidth=*/0, /*Mutable=*/false);
Mike Stumpadaaad32009-10-20 02:12:22 +00003099 T->addDecl(Field);
3100 }
3101
3102 T->completeDefinition(*this);
Mike Stumpea26cb52009-10-21 03:49:08 +00003103
3104 return getPointerType(getTagDeclType(T));
Mike Stumpadaaad32009-10-20 02:12:22 +00003105}
3106
Douglas Gregor319ac892009-04-23 22:29:11 +00003107void ASTContext::setObjCFastEnumerationStateType(QualType T) {
Ted Kremenek6217b802009-07-29 21:53:49 +00003108 const RecordType *Rec = T->getAs<RecordType>();
Douglas Gregor319ac892009-04-23 22:29:11 +00003109 assert(Rec && "Invalid ObjCFAstEnumerationStateType");
3110 ObjCFastEnumerationStateTypeDecl = Rec->getDecl();
3111}
3112
Anders Carlssone8c49532007-10-29 06:33:42 +00003113// This returns true if a type has been typedefed to BOOL:
3114// typedef <type> BOOL;
Chris Lattner2d998332007-10-30 20:27:44 +00003115static bool isTypeTypedefedAsBOOL(QualType T) {
Anders Carlssone8c49532007-10-29 06:33:42 +00003116 if (const TypedefType *TT = dyn_cast<TypedefType>(T))
Chris Lattnerbb49c3e2008-11-24 03:52:59 +00003117 if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
3118 return II->isStr("BOOL");
Mike Stump1eb44332009-09-09 15:08:12 +00003119
Anders Carlsson85f9bce2007-10-29 05:01:08 +00003120 return false;
3121}
3122
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003123/// getObjCEncodingTypeSize returns size of type for objective-c encoding
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003124/// purpose.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003125int ASTContext::getObjCEncodingTypeSize(QualType type) {
Chris Lattner98be4942008-03-05 18:54:05 +00003126 uint64_t sz = getTypeSize(type);
Mike Stump1eb44332009-09-09 15:08:12 +00003127
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003128 // Make all integer and enum types at least as large as an int
3129 if (sz > 0 && type->isIntegralType())
Chris Lattner98be4942008-03-05 18:54:05 +00003130 sz = std::max(sz, getTypeSize(IntTy));
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003131 // Treat arrays as pointers, since that's how they're passed in.
3132 else if (type->isArrayType())
Chris Lattner98be4942008-03-05 18:54:05 +00003133 sz = getTypeSize(VoidPtrTy);
3134 return sz / getTypeSize(CharTy);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003135}
3136
David Chisnall5e530af2009-11-17 19:33:30 +00003137/// getObjCEncodingForBlockDecl - Return the encoded type for this method
3138/// declaration.
3139void ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr,
3140 std::string& S) {
3141 const BlockDecl *Decl = Expr->getBlockDecl();
3142 QualType BlockTy =
3143 Expr->getType()->getAs<BlockPointerType>()->getPointeeType();
3144 // Encode result type.
3145 getObjCEncodingForType(cast<FunctionType>(BlockTy)->getResultType(), S);
3146 // Compute size of all parameters.
3147 // Start with computing size of a pointer in number of bytes.
3148 // FIXME: There might(should) be a better way of doing this computation!
3149 SourceLocation Loc;
3150 int PtrSize = getTypeSize(VoidPtrTy) / getTypeSize(CharTy);
3151 int ParmOffset = PtrSize;
3152 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(),
3153 E = Decl->param_end(); PI != E; ++PI) {
3154 QualType PType = (*PI)->getType();
3155 int sz = getObjCEncodingTypeSize(PType);
3156 assert (sz > 0 && "BlockExpr - Incomplete param type");
3157 ParmOffset += sz;
3158 }
3159 // Size of the argument frame
3160 S += llvm::utostr(ParmOffset);
3161 // Block pointer and offset.
3162 S += "@?0";
3163 ParmOffset = PtrSize;
3164
3165 // Argument types.
3166 ParmOffset = PtrSize;
3167 for (BlockDecl::param_const_iterator PI = Decl->param_begin(), E =
3168 Decl->param_end(); PI != E; ++PI) {
3169 ParmVarDecl *PVDecl = *PI;
3170 QualType PType = PVDecl->getOriginalType();
3171 if (const ArrayType *AT =
3172 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
3173 // Use array's original type only if it has known number of
3174 // elements.
3175 if (!isa<ConstantArrayType>(AT))
3176 PType = PVDecl->getType();
3177 } else if (PType->isFunctionType())
3178 PType = PVDecl->getType();
3179 getObjCEncodingForType(PType, S);
3180 S += llvm::utostr(ParmOffset);
3181 ParmOffset += getObjCEncodingTypeSize(PType);
3182 }
3183}
3184
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003185/// getObjCEncodingForMethodDecl - Return the encoded type for this method
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003186/// declaration.
Mike Stump1eb44332009-09-09 15:08:12 +00003187void ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
Chris Lattnere6db3b02008-11-19 07:24:05 +00003188 std::string& S) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003189 // FIXME: This is not very efficient.
Fariborz Jahanianecb01e62007-11-01 17:18:37 +00003190 // Encode type qualifer, 'in', 'inout', etc. for the return type.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003191 getObjCEncodingForTypeQualifier(Decl->getObjCDeclQualifier(), S);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003192 // Encode result type.
Daniel Dunbar0d504c12008-10-17 20:21:44 +00003193 getObjCEncodingForType(Decl->getResultType(), S);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003194 // Compute size of all parameters.
3195 // Start with computing size of a pointer in number of bytes.
3196 // FIXME: There might(should) be a better way of doing this computation!
3197 SourceLocation Loc;
Chris Lattner98be4942008-03-05 18:54:05 +00003198 int PtrSize = getTypeSize(VoidPtrTy) / getTypeSize(CharTy);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003199 // The first two arguments (self and _cmd) are pointers; account for
3200 // their size.
3201 int ParmOffset = 2 * PtrSize;
Chris Lattner89951a82009-02-20 18:43:26 +00003202 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(),
3203 E = Decl->param_end(); PI != E; ++PI) {
3204 QualType PType = (*PI)->getType();
3205 int sz = getObjCEncodingTypeSize(PType);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003206 assert (sz > 0 && "getObjCEncodingForMethodDecl - Incomplete param type");
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003207 ParmOffset += sz;
3208 }
3209 S += llvm::utostr(ParmOffset);
3210 S += "@0:";
3211 S += llvm::utostr(PtrSize);
Mike Stump1eb44332009-09-09 15:08:12 +00003212
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003213 // Argument types.
3214 ParmOffset = 2 * PtrSize;
Chris Lattner89951a82009-02-20 18:43:26 +00003215 for (ObjCMethodDecl::param_iterator PI = Decl->param_begin(),
3216 E = Decl->param_end(); PI != E; ++PI) {
3217 ParmVarDecl *PVDecl = *PI;
Mike Stump1eb44332009-09-09 15:08:12 +00003218 QualType PType = PVDecl->getOriginalType();
Fariborz Jahanian4306d3c2008-12-20 23:29:59 +00003219 if (const ArrayType *AT =
Steve Naroffab76d452009-04-14 00:03:58 +00003220 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
3221 // Use array's original type only if it has known number of
3222 // elements.
Steve Naroffbb3fde32009-04-14 00:40:09 +00003223 if (!isa<ConstantArrayType>(AT))
Steve Naroffab76d452009-04-14 00:03:58 +00003224 PType = PVDecl->getType();
3225 } else if (PType->isFunctionType())
3226 PType = PVDecl->getType();
Fariborz Jahanianecb01e62007-11-01 17:18:37 +00003227 // Process argument qualifiers for user supplied arguments; such as,
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003228 // 'in', 'inout', etc.
Fariborz Jahanian4306d3c2008-12-20 23:29:59 +00003229 getObjCEncodingForTypeQualifier(PVDecl->getObjCDeclQualifier(), S);
Daniel Dunbar0d504c12008-10-17 20:21:44 +00003230 getObjCEncodingForType(PType, S);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003231 S += llvm::utostr(ParmOffset);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003232 ParmOffset += getObjCEncodingTypeSize(PType);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00003233 }
3234}
3235
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003236/// getObjCEncodingForPropertyDecl - Return the encoded type for this
Fariborz Jahanian83bccb82009-01-20 20:04:12 +00003237/// property declaration. If non-NULL, Container must be either an
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003238/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be
3239/// NULL when getting encodings for protocol properties.
Mike Stump1eb44332009-09-09 15:08:12 +00003240/// Property attributes are stored as a comma-delimited C string. The simple
3241/// attributes readonly and bycopy are encoded as single characters. The
3242/// parametrized attributes, getter=name, setter=name, and ivar=name, are
3243/// encoded as single characters, followed by an identifier. Property types
3244/// are also encoded as a parametrized attribute. The characters used to encode
Fariborz Jahanian83bccb82009-01-20 20:04:12 +00003245/// these attributes are defined by the following enumeration:
3246/// @code
3247/// enum PropertyAttributes {
3248/// kPropertyReadOnly = 'R', // property is read-only.
3249/// kPropertyBycopy = 'C', // property is a copy of the value last assigned
3250/// kPropertyByref = '&', // property is a reference to the value last assigned
3251/// kPropertyDynamic = 'D', // property is dynamic
3252/// kPropertyGetter = 'G', // followed by getter selector name
3253/// kPropertySetter = 'S', // followed by setter selector name
3254/// kPropertyInstanceVariable = 'V' // followed by instance variable name
3255/// kPropertyType = 't' // followed by old-style type encoding.
3256/// kPropertyWeak = 'W' // 'weak' property
3257/// kPropertyStrong = 'P' // property GC'able
3258/// kPropertyNonAtomic = 'N' // property non-atomic
3259/// };
3260/// @endcode
Mike Stump1eb44332009-09-09 15:08:12 +00003261void ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003262 const Decl *Container,
Chris Lattnere6db3b02008-11-19 07:24:05 +00003263 std::string& S) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003264 // Collect information from the property implementation decl(s).
3265 bool Dynamic = false;
3266 ObjCPropertyImplDecl *SynthesizePID = 0;
3267
3268 // FIXME: Duplicated code due to poor abstraction.
3269 if (Container) {
Mike Stump1eb44332009-09-09 15:08:12 +00003270 if (const ObjCCategoryImplDecl *CID =
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003271 dyn_cast<ObjCCategoryImplDecl>(Container)) {
3272 for (ObjCCategoryImplDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003273 i = CID->propimpl_begin(), e = CID->propimpl_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00003274 i != e; ++i) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003275 ObjCPropertyImplDecl *PID = *i;
3276 if (PID->getPropertyDecl() == PD) {
3277 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
3278 Dynamic = true;
3279 } else {
3280 SynthesizePID = PID;
3281 }
3282 }
3283 }
3284 } else {
Chris Lattner61710852008-10-05 17:34:18 +00003285 const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container);
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003286 for (ObjCCategoryImplDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003287 i = OID->propimpl_begin(), e = OID->propimpl_end();
Douglas Gregor653f1b12009-04-23 01:02:12 +00003288 i != e; ++i) {
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003289 ObjCPropertyImplDecl *PID = *i;
3290 if (PID->getPropertyDecl() == PD) {
3291 if (PID->getPropertyImplementation()==ObjCPropertyImplDecl::Dynamic) {
3292 Dynamic = true;
3293 } else {
3294 SynthesizePID = PID;
3295 }
3296 }
Mike Stump1eb44332009-09-09 15:08:12 +00003297 }
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003298 }
3299 }
3300
3301 // FIXME: This is not very efficient.
3302 S = "T";
3303
3304 // Encode result type.
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00003305 // GCC has some special rules regarding encoding of properties which
3306 // closely resembles encoding of ivars.
Mike Stump1eb44332009-09-09 15:08:12 +00003307 getObjCEncodingForTypeImpl(PD->getType(), S, true, true, 0,
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00003308 true /* outermost type */,
3309 true /* encoding for property */);
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003310
3311 if (PD->isReadOnly()) {
3312 S += ",R";
3313 } else {
3314 switch (PD->getSetterKind()) {
3315 case ObjCPropertyDecl::Assign: break;
3316 case ObjCPropertyDecl::Copy: S += ",C"; break;
Mike Stump1eb44332009-09-09 15:08:12 +00003317 case ObjCPropertyDecl::Retain: S += ",&"; break;
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003318 }
3319 }
3320
3321 // It really isn't clear at all what this means, since properties
3322 // are "dynamic by default".
3323 if (Dynamic)
3324 S += ",D";
3325
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00003326 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
3327 S += ",N";
Mike Stump1eb44332009-09-09 15:08:12 +00003328
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003329 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
3330 S += ",G";
Chris Lattner077bf5e2008-11-24 03:33:13 +00003331 S += PD->getGetterName().getAsString();
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003332 }
3333
3334 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
3335 S += ",S";
Chris Lattner077bf5e2008-11-24 03:33:13 +00003336 S += PD->getSetterName().getAsString();
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003337 }
3338
3339 if (SynthesizePID) {
3340 const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
3341 S += ",V";
Chris Lattner39f34e92008-11-24 04:00:27 +00003342 S += OID->getNameAsString();
Daniel Dunbarc56f34a2008-08-28 04:38:10 +00003343 }
3344
3345 // FIXME: OBJCGC: weak & strong
3346}
3347
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003348/// getLegacyIntegralTypeEncoding -
Mike Stump1eb44332009-09-09 15:08:12 +00003349/// Another legacy compatibility encoding: 32-bit longs are encoded as
3350/// 'l' or 'L' , but not always. For typedefs, we need to use
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003351/// 'i' or 'I' instead if encoding a struct field, or a pointer!
3352///
3353void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const {
Mike Stump8e1fab22009-07-22 18:58:19 +00003354 if (isa<TypedefType>(PointeeTy.getTypePtr())) {
John McCall183700f2009-09-21 23:43:11 +00003355 if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) {
Fariborz Jahanianc657eba2009-02-11 23:59:18 +00003356 if (BT->getKind() == BuiltinType::ULong &&
3357 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32))
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003358 PointeeTy = UnsignedIntTy;
Mike Stump1eb44332009-09-09 15:08:12 +00003359 else
Fariborz Jahanianc657eba2009-02-11 23:59:18 +00003360 if (BT->getKind() == BuiltinType::Long &&
3361 ((const_cast<ASTContext *>(this))->getIntWidth(PointeeTy) == 32))
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003362 PointeeTy = IntTy;
3363 }
3364 }
3365}
3366
Fariborz Jahanian7d6b46d2008-01-22 22:44:46 +00003367void ASTContext::getObjCEncodingForType(QualType T, std::string& S,
Daniel Dunbar153bfe52009-04-20 06:37:24 +00003368 const FieldDecl *Field) {
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00003369 // We follow the behavior of gcc, expanding structures which are
3370 // directly pointed to, and expanding embedded structures. Note that
3371 // these rules are sufficient to prevent recursive encoding of the
3372 // same type.
Mike Stump1eb44332009-09-09 15:08:12 +00003373 getObjCEncodingForTypeImpl(T, S, true, true, Field,
Fariborz Jahanian5b8c7d92008-12-22 23:22:27 +00003374 true /* outermost type */);
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00003375}
3376
Mike Stump1eb44332009-09-09 15:08:12 +00003377static void EncodeBitField(const ASTContext *Context, std::string& S,
Daniel Dunbar153bfe52009-04-20 06:37:24 +00003378 const FieldDecl *FD) {
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00003379 const Expr *E = FD->getBitWidth();
3380 assert(E && "bitfield width not there - getObjCEncodingForTypeImpl");
3381 ASTContext *Ctx = const_cast<ASTContext*>(Context);
Eli Friedman9a901bb2009-04-26 19:19:15 +00003382 unsigned N = E->EvaluateAsInt(*Ctx).getZExtValue();
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00003383 S += 'b';
3384 S += llvm::utostr(N);
3385}
3386
Daniel Dunbar01eb9b92009-10-18 21:17:35 +00003387// FIXME: Use SmallString for accumulating string.
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00003388void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S,
3389 bool ExpandPointedToStructures,
3390 bool ExpandStructures,
Daniel Dunbar153bfe52009-04-20 06:37:24 +00003391 const FieldDecl *FD,
Fariborz Jahanian090b3f72009-01-20 19:14:18 +00003392 bool OutermostType,
Douglas Gregor6ab35242009-04-09 21:40:53 +00003393 bool EncodingProperty) {
John McCall183700f2009-09-21 23:43:11 +00003394 if (const BuiltinType *BT = T->getAs<BuiltinType>()) {
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003395 if (FD && FD->isBitField())
3396 return EncodeBitField(this, S, FD);
3397 char encoding;
3398 switch (BT->getKind()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003399 default: assert(0 && "Unhandled builtin type kind");
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003400 case BuiltinType::Void: encoding = 'v'; break;
3401 case BuiltinType::Bool: encoding = 'B'; break;
3402 case BuiltinType::Char_U:
3403 case BuiltinType::UChar: encoding = 'C'; break;
3404 case BuiltinType::UShort: encoding = 'S'; break;
3405 case BuiltinType::UInt: encoding = 'I'; break;
Mike Stump1eb44332009-09-09 15:08:12 +00003406 case BuiltinType::ULong:
3407 encoding =
3408 (const_cast<ASTContext *>(this))->getIntWidth(T) == 32 ? 'L' : 'Q';
Fariborz Jahanian72696e12009-02-11 22:31:45 +00003409 break;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003410 case BuiltinType::UInt128: encoding = 'T'; break;
3411 case BuiltinType::ULongLong: encoding = 'Q'; break;
3412 case BuiltinType::Char_S:
3413 case BuiltinType::SChar: encoding = 'c'; break;
3414 case BuiltinType::Short: encoding = 's'; break;
3415 case BuiltinType::Int: encoding = 'i'; break;
Mike Stump1eb44332009-09-09 15:08:12 +00003416 case BuiltinType::Long:
3417 encoding =
3418 (const_cast<ASTContext *>(this))->getIntWidth(T) == 32 ? 'l' : 'q';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003419 break;
3420 case BuiltinType::LongLong: encoding = 'q'; break;
3421 case BuiltinType::Int128: encoding = 't'; break;
3422 case BuiltinType::Float: encoding = 'f'; break;
3423 case BuiltinType::Double: encoding = 'd'; break;
3424 case BuiltinType::LongDouble: encoding = 'd'; break;
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003425 }
Mike Stump1eb44332009-09-09 15:08:12 +00003426
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003427 S += encoding;
3428 return;
3429 }
Mike Stump1eb44332009-09-09 15:08:12 +00003430
John McCall183700f2009-09-21 23:43:11 +00003431 if (const ComplexType *CT = T->getAs<ComplexType>()) {
Anders Carlssonc612f7b2009-04-09 21:55:45 +00003432 S += 'j';
Mike Stump1eb44332009-09-09 15:08:12 +00003433 getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, 0, false,
Anders Carlssonc612f7b2009-04-09 21:55:45 +00003434 false);
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003435 return;
3436 }
Fariborz Jahanian60bce3e2009-11-23 20:40:50 +00003437
Ted Kremenek6217b802009-07-29 21:53:49 +00003438 if (const PointerType *PT = T->getAs<PointerType>()) {
Fariborz Jahanian8d2c0a92009-11-30 18:43:52 +00003439 if (PT->isObjCSelType()) {
3440 S += ':';
3441 return;
3442 }
Anders Carlsson85f9bce2007-10-29 05:01:08 +00003443 QualType PointeeTy = PT->getPointeeType();
Fariborz Jahanian8d2c0a92009-11-30 18:43:52 +00003444
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003445 bool isReadOnly = false;
3446 // For historical/compatibility reasons, the read-only qualifier of the
3447 // pointee gets emitted _before_ the '^'. The read-only qualifier of
3448 // the pointer itself gets ignored, _unless_ we are looking at a typedef!
Mike Stump1eb44332009-09-09 15:08:12 +00003449 // Also, do not emit the 'r' for anything but the outermost type!
Mike Stump8e1fab22009-07-22 18:58:19 +00003450 if (isa<TypedefType>(T.getTypePtr())) {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003451 if (OutermostType && T.isConstQualified()) {
3452 isReadOnly = true;
3453 S += 'r';
3454 }
Mike Stump9fdbab32009-07-31 02:02:20 +00003455 } else if (OutermostType) {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003456 QualType P = PointeeTy;
Ted Kremenek6217b802009-07-29 21:53:49 +00003457 while (P->getAs<PointerType>())
3458 P = P->getAs<PointerType>()->getPointeeType();
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003459 if (P.isConstQualified()) {
3460 isReadOnly = true;
3461 S += 'r';
3462 }
3463 }
3464 if (isReadOnly) {
3465 // Another legacy compatibility encoding. Some ObjC qualifier and type
3466 // combinations need to be rearranged.
3467 // Rewrite "in const" from "nr" to "rn"
3468 const char * s = S.c_str();
3469 int len = S.length();
3470 if (len >= 2 && s[len-2] == 'n' && s[len-1] == 'r') {
3471 std::string replace = "rn";
3472 S.replace(S.end()-2, S.end(), replace);
3473 }
3474 }
Mike Stump1eb44332009-09-09 15:08:12 +00003475
Anders Carlsson85f9bce2007-10-29 05:01:08 +00003476 if (PointeeTy->isCharType()) {
3477 // char pointer types should be encoded as '*' unless it is a
3478 // type that has been typedef'd to 'BOOL'.
Anders Carlssone8c49532007-10-29 06:33:42 +00003479 if (!isTypeTypedefedAsBOOL(PointeeTy)) {
Anders Carlsson85f9bce2007-10-29 05:01:08 +00003480 S += '*';
3481 return;
3482 }
Ted Kremenek6217b802009-07-29 21:53:49 +00003483 } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) {
Steve Naroff9533a7f2009-07-22 17:14:51 +00003484 // GCC binary compat: Need to convert "struct objc_class *" to "#".
3485 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
3486 S += '#';
3487 return;
3488 }
3489 // GCC binary compat: Need to convert "struct objc_object *" to "@".
3490 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
3491 S += '@';
3492 return;
3493 }
3494 // fall through...
Anders Carlsson85f9bce2007-10-29 05:01:08 +00003495 }
Anders Carlsson85f9bce2007-10-29 05:01:08 +00003496 S += '^';
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003497 getLegacyIntegralTypeEncoding(PointeeTy);
3498
Mike Stump1eb44332009-09-09 15:08:12 +00003499 getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures,
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003500 NULL);
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003501 return;
3502 }
Mike Stump1eb44332009-09-09 15:08:12 +00003503
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003504 if (const ArrayType *AT =
3505 // Ignore type qualifiers etc.
3506 dyn_cast<ArrayType>(T->getCanonicalTypeInternal())) {
Anders Carlsson559a8332009-02-22 01:38:57 +00003507 if (isa<IncompleteArrayType>(AT)) {
3508 // Incomplete arrays are encoded as a pointer to the array element.
3509 S += '^';
3510
Mike Stump1eb44332009-09-09 15:08:12 +00003511 getObjCEncodingForTypeImpl(AT->getElementType(), S,
Anders Carlsson559a8332009-02-22 01:38:57 +00003512 false, ExpandStructures, FD);
3513 } else {
3514 S += '[';
Mike Stump1eb44332009-09-09 15:08:12 +00003515
Anders Carlsson559a8332009-02-22 01:38:57 +00003516 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
3517 S += llvm::utostr(CAT->getSize().getZExtValue());
3518 else {
3519 //Variable length arrays are encoded as a regular array with 0 elements.
3520 assert(isa<VariableArrayType>(AT) && "Unknown array type!");
3521 S += '0';
3522 }
Mike Stump1eb44332009-09-09 15:08:12 +00003523
3524 getObjCEncodingForTypeImpl(AT->getElementType(), S,
Anders Carlsson559a8332009-02-22 01:38:57 +00003525 false, ExpandStructures, FD);
3526 S += ']';
3527 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003528 return;
3529 }
Mike Stump1eb44332009-09-09 15:08:12 +00003530
John McCall183700f2009-09-21 23:43:11 +00003531 if (T->getAs<FunctionType>()) {
Anders Carlssonc0a87b72007-10-30 00:06:20 +00003532 S += '?';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003533 return;
3534 }
Mike Stump1eb44332009-09-09 15:08:12 +00003535
Ted Kremenek6217b802009-07-29 21:53:49 +00003536 if (const RecordType *RTy = T->getAs<RecordType>()) {
Daniel Dunbar82a6cfb2008-10-17 07:30:50 +00003537 RecordDecl *RDecl = RTy->getDecl();
Daniel Dunbard96b35b2008-10-17 16:17:37 +00003538 S += RDecl->isUnion() ? '(' : '{';
Daniel Dunbar502a4a12008-10-17 06:22:57 +00003539 // Anonymous structures print as '?'
3540 if (const IdentifierInfo *II = RDecl->getIdentifier()) {
3541 S += II->getName();
3542 } else {
3543 S += '?';
3544 }
Daniel Dunbar0d504c12008-10-17 20:21:44 +00003545 if (ExpandStructures) {
Fariborz Jahanian7d6b46d2008-01-22 22:44:46 +00003546 S += '=';
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00003547 for (RecordDecl::field_iterator Field = RDecl->field_begin(),
3548 FieldEnd = RDecl->field_end();
Douglas Gregor44b43212008-12-11 16:49:14 +00003549 Field != FieldEnd; ++Field) {
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003550 if (FD) {
Daniel Dunbard96b35b2008-10-17 16:17:37 +00003551 S += '"';
Douglas Gregor44b43212008-12-11 16:49:14 +00003552 S += Field->getNameAsString();
Daniel Dunbard96b35b2008-10-17 16:17:37 +00003553 S += '"';
3554 }
Mike Stump1eb44332009-09-09 15:08:12 +00003555
Daniel Dunbard96b35b2008-10-17 16:17:37 +00003556 // Special case bit-fields.
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003557 if (Field->isBitField()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003558 getObjCEncodingForTypeImpl(Field->getType(), S, false, true,
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003559 (*Field));
Daniel Dunbard96b35b2008-10-17 16:17:37 +00003560 } else {
Fariborz Jahaniana1c033e2008-12-23 19:56:47 +00003561 QualType qt = Field->getType();
3562 getLegacyIntegralTypeEncoding(qt);
Mike Stump1eb44332009-09-09 15:08:12 +00003563 getObjCEncodingForTypeImpl(qt, S, false, true,
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003564 FD);
Daniel Dunbard96b35b2008-10-17 16:17:37 +00003565 }
Fariborz Jahanian7d6b46d2008-01-22 22:44:46 +00003566 }
Fariborz Jahanian6de88a82007-11-13 23:21:38 +00003567 }
Daniel Dunbard96b35b2008-10-17 16:17:37 +00003568 S += RDecl->isUnion() ? ')' : '}';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003569 return;
3570 }
Mike Stump1eb44332009-09-09 15:08:12 +00003571
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003572 if (T->isEnumeralType()) {
Fariborz Jahanian8b4bf902009-01-13 01:18:13 +00003573 if (FD && FD->isBitField())
3574 EncodeBitField(this, S, FD);
3575 else
3576 S += 'i';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003577 return;
3578 }
Mike Stump1eb44332009-09-09 15:08:12 +00003579
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003580 if (T->isBlockPointerType()) {
Steve Naroff21a98b12009-02-02 18:24:29 +00003581 S += "@?"; // Unlike a pointer-to-function, which is "^?".
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003582 return;
3583 }
Mike Stump1eb44332009-09-09 15:08:12 +00003584
John McCall0953e762009-09-24 19:53:00 +00003585 if (const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>()) {
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003586 // @encode(class_name)
John McCall0953e762009-09-24 19:53:00 +00003587 ObjCInterfaceDecl *OI = OIT->getDecl();
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003588 S += '{';
3589 const IdentifierInfo *II = OI->getIdentifier();
3590 S += II->getName();
3591 S += '=';
Chris Lattnerf1690852009-03-31 08:48:01 +00003592 llvm::SmallVector<FieldDecl*, 32> RecFields;
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003593 CollectObjCIvars(OI, RecFields);
Chris Lattnerf1690852009-03-31 08:48:01 +00003594 for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003595 if (RecFields[i]->isBitField())
Mike Stump1eb44332009-09-09 15:08:12 +00003596 getObjCEncodingForTypeImpl(RecFields[i]->getType(), S, false, true,
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003597 RecFields[i]);
3598 else
Mike Stump1eb44332009-09-09 15:08:12 +00003599 getObjCEncodingForTypeImpl(RecFields[i]->getType(), S, false, true,
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003600 FD);
3601 }
3602 S += '}';
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003603 return;
Fariborz Jahanian43822ea2008-12-19 23:34:38 +00003604 }
Mike Stump1eb44332009-09-09 15:08:12 +00003605
John McCall183700f2009-09-21 23:43:11 +00003606 if (const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>()) {
Steve Naroff14108da2009-07-10 23:34:53 +00003607 if (OPT->isObjCIdType()) {
3608 S += '@';
3609 return;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003610 }
Mike Stump1eb44332009-09-09 15:08:12 +00003611
Steve Naroff27d20a22009-10-28 22:03:49 +00003612 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
3613 // FIXME: Consider if we need to output qualifiers for 'Class<p>'.
3614 // Since this is a binary compatibility issue, need to consult with runtime
3615 // folks. Fortunately, this is a *very* obsure construct.
Steve Naroff14108da2009-07-10 23:34:53 +00003616 S += '#';
3617 return;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003618 }
Mike Stump1eb44332009-09-09 15:08:12 +00003619
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003620 if (OPT->isObjCQualifiedIdType()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003621 getObjCEncodingForTypeImpl(getObjCIdType(), S,
Steve Naroff14108da2009-07-10 23:34:53 +00003622 ExpandPointedToStructures,
3623 ExpandStructures, FD);
3624 if (FD || EncodingProperty) {
3625 // Note that we do extended encoding of protocol qualifer list
3626 // Only when doing ivar or property encoding.
Steve Naroff14108da2009-07-10 23:34:53 +00003627 S += '"';
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003628 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
3629 E = OPT->qual_end(); I != E; ++I) {
Steve Naroff14108da2009-07-10 23:34:53 +00003630 S += '<';
3631 S += (*I)->getNameAsString();
3632 S += '>';
3633 }
3634 S += '"';
3635 }
3636 return;
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003637 }
Mike Stump1eb44332009-09-09 15:08:12 +00003638
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003639 QualType PointeeTy = OPT->getPointeeType();
3640 if (!EncodingProperty &&
3641 isa<TypedefType>(PointeeTy.getTypePtr())) {
3642 // Another historical/compatibility reason.
Mike Stump1eb44332009-09-09 15:08:12 +00003643 // We encode the underlying type which comes out as
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003644 // {...};
3645 S += '^';
Mike Stump1eb44332009-09-09 15:08:12 +00003646 getObjCEncodingForTypeImpl(PointeeTy, S,
3647 false, ExpandPointedToStructures,
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003648 NULL);
Steve Naroff14108da2009-07-10 23:34:53 +00003649 return;
3650 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003651
3652 S += '@';
Steve Naroff27d20a22009-10-28 22:03:49 +00003653 if (OPT->getInterfaceDecl() && (FD || EncodingProperty)) {
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003654 S += '"';
Steve Naroff27d20a22009-10-28 22:03:49 +00003655 S += OPT->getInterfaceDecl()->getIdentifier()->getName();
Steve Naroff67ef8ea2009-07-20 17:56:53 +00003656 for (ObjCObjectPointerType::qual_iterator I = OPT->qual_begin(),
3657 E = OPT->qual_end(); I != E; ++I) {
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003658 S += '<';
3659 S += (*I)->getNameAsString();
3660 S += '>';
Mike Stump1eb44332009-09-09 15:08:12 +00003661 }
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003662 S += '"';
3663 }
3664 return;
3665 }
Mike Stump1eb44332009-09-09 15:08:12 +00003666
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003667 assert(0 && "@encode for type not implemented!");
Anders Carlsson85f9bce2007-10-29 05:01:08 +00003668}
3669
Mike Stump1eb44332009-09-09 15:08:12 +00003670void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
Fariborz Jahanianecb01e62007-11-01 17:18:37 +00003671 std::string& S) const {
3672 if (QT & Decl::OBJC_TQ_In)
3673 S += 'n';
3674 if (QT & Decl::OBJC_TQ_Inout)
3675 S += 'N';
3676 if (QT & Decl::OBJC_TQ_Out)
3677 S += 'o';
3678 if (QT & Decl::OBJC_TQ_Bycopy)
3679 S += 'O';
3680 if (QT & Decl::OBJC_TQ_Byref)
3681 S += 'R';
3682 if (QT & Decl::OBJC_TQ_Oneway)
3683 S += 'V';
3684}
3685
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003686void ASTContext::setBuiltinVaListType(QualType T) {
Anders Carlssonb2cf3572007-10-11 01:00:40 +00003687 assert(BuiltinVaListType.isNull() && "__builtin_va_list type already set!");
Mike Stump1eb44332009-09-09 15:08:12 +00003688
Anders Carlssonb2cf3572007-10-11 01:00:40 +00003689 BuiltinVaListType = T;
3690}
3691
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003692void ASTContext::setObjCIdType(QualType T) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00003693 ObjCIdTypedefType = T;
Steve Naroff7e219e42007-10-15 14:41:52 +00003694}
3695
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003696void ASTContext::setObjCSelType(QualType T) {
Fariborz Jahanian13dcd002009-11-21 19:53:08 +00003697 ObjCSelTypedefType = T;
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00003698}
3699
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003700void ASTContext::setObjCProtoType(QualType QT) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003701 ObjCProtoType = QT;
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00003702}
3703
Chris Lattnerce7b38c2009-07-13 00:10:46 +00003704void ASTContext::setObjCClassType(QualType T) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00003705 ObjCClassTypedefType = T;
Anders Carlsson8baaca52007-10-31 02:53:19 +00003706}
3707
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003708void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) {
Mike Stump1eb44332009-09-09 15:08:12 +00003709 assert(ObjCConstantStringType.isNull() &&
Steve Naroff21988912007-10-15 23:35:17 +00003710 "'NSConstantString' type already set!");
Mike Stump1eb44332009-09-09 15:08:12 +00003711
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003712 ObjCConstantStringType = getObjCInterfaceType(Decl);
Steve Naroff21988912007-10-15 23:35:17 +00003713}
3714
John McCall0bd6feb2009-12-02 08:04:21 +00003715/// \brief Retrieve the template name that corresponds to a non-empty
3716/// lookup.
3717TemplateName ASTContext::getOverloadedTemplateName(NamedDecl * const *Begin,
3718 NamedDecl * const *End) {
3719 unsigned size = End - Begin;
3720 assert(size > 1 && "set is not overloaded!");
3721
3722 void *memory = Allocate(sizeof(OverloadedTemplateStorage) +
3723 size * sizeof(FunctionTemplateDecl*));
3724 OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size);
3725
3726 NamedDecl **Storage = OT->getStorage();
3727 for (NamedDecl * const *I = Begin; I != End; ++I) {
3728 NamedDecl *D = *I;
3729 assert(isa<FunctionTemplateDecl>(D) ||
3730 (isa<UsingShadowDecl>(D) &&
3731 isa<FunctionTemplateDecl>(D->getUnderlyingDecl())));
3732 *Storage++ = D;
3733 }
3734
3735 return TemplateName(OT);
3736}
3737
Douglas Gregor7532dc62009-03-30 22:58:21 +00003738/// \brief Retrieve the template name that represents a qualified
3739/// template name such as \c std::vector.
Mike Stump1eb44332009-09-09 15:08:12 +00003740TemplateName ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
Douglas Gregor7532dc62009-03-30 22:58:21 +00003741 bool TemplateKeyword,
3742 TemplateDecl *Template) {
3743 llvm::FoldingSetNodeID ID;
3744 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
3745
3746 void *InsertPos = 0;
3747 QualifiedTemplateName *QTN =
3748 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
3749 if (!QTN) {
3750 QTN = new (*this,4) QualifiedTemplateName(NNS, TemplateKeyword, Template);
3751 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
3752 }
3753
3754 return TemplateName(QTN);
3755}
3756
3757/// \brief Retrieve the template name that represents a dependent
3758/// template name such as \c MetaFun::template apply.
Mike Stump1eb44332009-09-09 15:08:12 +00003759TemplateName ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
Douglas Gregor7532dc62009-03-30 22:58:21 +00003760 const IdentifierInfo *Name) {
Mike Stump1eb44332009-09-09 15:08:12 +00003761 assert((!NNS || NNS->isDependent()) &&
Douglas Gregor3b6afbb2009-09-09 00:23:06 +00003762 "Nested name specifier must be dependent");
Douglas Gregor7532dc62009-03-30 22:58:21 +00003763
3764 llvm::FoldingSetNodeID ID;
3765 DependentTemplateName::Profile(ID, NNS, Name);
3766
3767 void *InsertPos = 0;
3768 DependentTemplateName *QTN =
3769 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
3770
3771 if (QTN)
3772 return TemplateName(QTN);
3773
3774 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
3775 if (CanonNNS == NNS) {
3776 QTN = new (*this,4) DependentTemplateName(NNS, Name);
3777 } else {
3778 TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
3779 QTN = new (*this,4) DependentTemplateName(NNS, Name, Canon);
3780 }
3781
3782 DependentTemplateNames.InsertNode(QTN, InsertPos);
3783 return TemplateName(QTN);
3784}
3785
Douglas Gregorca1bdd72009-11-04 00:56:37 +00003786/// \brief Retrieve the template name that represents a dependent
3787/// template name such as \c MetaFun::template operator+.
3788TemplateName
3789ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
3790 OverloadedOperatorKind Operator) {
3791 assert((!NNS || NNS->isDependent()) &&
3792 "Nested name specifier must be dependent");
3793
3794 llvm::FoldingSetNodeID ID;
3795 DependentTemplateName::Profile(ID, NNS, Operator);
3796
3797 void *InsertPos = 0;
3798 DependentTemplateName *QTN =
3799 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
3800
3801 if (QTN)
3802 return TemplateName(QTN);
3803
3804 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
3805 if (CanonNNS == NNS) {
3806 QTN = new (*this,4) DependentTemplateName(NNS, Operator);
3807 } else {
3808 TemplateName Canon = getDependentTemplateName(CanonNNS, Operator);
3809 QTN = new (*this,4) DependentTemplateName(NNS, Operator, Canon);
3810 }
3811
3812 DependentTemplateNames.InsertNode(QTN, InsertPos);
3813 return TemplateName(QTN);
3814}
3815
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003816/// getFromTargetType - Given one of the integer types provided by
Douglas Gregord9341122008-11-03 15:57:00 +00003817/// TargetInfo, produce the corresponding type. The unsigned @p Type
3818/// is actually a value of type @c TargetInfo::IntType.
John McCalle27ec8a2009-10-23 23:03:21 +00003819CanQualType ASTContext::getFromTargetType(unsigned Type) const {
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003820 switch (Type) {
John McCalle27ec8a2009-10-23 23:03:21 +00003821 case TargetInfo::NoInt: return CanQualType();
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003822 case TargetInfo::SignedShort: return ShortTy;
3823 case TargetInfo::UnsignedShort: return UnsignedShortTy;
3824 case TargetInfo::SignedInt: return IntTy;
3825 case TargetInfo::UnsignedInt: return UnsignedIntTy;
3826 case TargetInfo::SignedLong: return LongTy;
3827 case TargetInfo::UnsignedLong: return UnsignedLongTy;
3828 case TargetInfo::SignedLongLong: return LongLongTy;
3829 case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy;
3830 }
3831
3832 assert(false && "Unhandled TargetInfo::IntType value");
John McCalle27ec8a2009-10-23 23:03:21 +00003833 return CanQualType();
Douglas Gregorb4e66d52008-11-03 14:12:49 +00003834}
Ted Kremenekb6ccaac2008-07-24 23:58:27 +00003835
3836//===----------------------------------------------------------------------===//
3837// Type Predicates.
3838//===----------------------------------------------------------------------===//
3839
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003840/// isObjCNSObjectType - Return true if this is an NSObject object using
3841/// NSObject attribute on a c-style pointer type.
3842/// FIXME - Make it work directly on types.
Steve Narofff4954562009-07-16 15:41:00 +00003843/// FIXME: Move to Type.
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003844///
3845bool ASTContext::isObjCNSObjectType(QualType Ty) const {
3846 if (TypedefType *TDT = dyn_cast<TypedefType>(Ty)) {
3847 if (TypedefDecl *TD = TDT->getDecl())
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00003848 if (TD->getAttr<ObjCNSObjectAttr>())
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003849 return true;
3850 }
Mike Stump1eb44332009-09-09 15:08:12 +00003851 return false;
Fariborz Jahanianfa23c1d2009-01-13 23:34:40 +00003852}
3853
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003854/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
3855/// garbage collection attribute.
3856///
John McCall0953e762009-09-24 19:53:00 +00003857Qualifiers::GC ASTContext::getObjCGCAttrKind(const QualType &Ty) const {
3858 Qualifiers::GC GCAttrs = Qualifiers::GCNone;
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003859 if (getLangOptions().ObjC1 &&
3860 getLangOptions().getGCMode() != LangOptions::NonGC) {
Chris Lattnerb7d25532009-02-18 22:53:11 +00003861 GCAttrs = Ty.getObjCGCAttr();
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003862 // Default behavious under objective-c's gc is for objective-c pointers
Mike Stump1eb44332009-09-09 15:08:12 +00003863 // (or pointers to them) be treated as though they were declared
Fariborz Jahaniana223cca2009-02-19 23:36:06 +00003864 // as __strong.
John McCall0953e762009-09-24 19:53:00 +00003865 if (GCAttrs == Qualifiers::GCNone) {
Fariborz Jahanian75212ee2009-09-10 23:38:45 +00003866 if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType())
John McCall0953e762009-09-24 19:53:00 +00003867 GCAttrs = Qualifiers::Strong;
Fariborz Jahaniana223cca2009-02-19 23:36:06 +00003868 else if (Ty->isPointerType())
Ted Kremenek6217b802009-07-29 21:53:49 +00003869 return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType());
Fariborz Jahaniana223cca2009-02-19 23:36:06 +00003870 }
Fariborz Jahanianc2112182009-04-11 00:00:54 +00003871 // Non-pointers have none gc'able attribute regardless of the attribute
3872 // set on them.
Steve Narofff4954562009-07-16 15:41:00 +00003873 else if (!Ty->isAnyPointerType() && !Ty->isBlockPointerType())
John McCall0953e762009-09-24 19:53:00 +00003874 return Qualifiers::GCNone;
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003875 }
Chris Lattnerb7d25532009-02-18 22:53:11 +00003876 return GCAttrs;
Fariborz Jahanian4fd83ea2009-02-18 21:49:28 +00003877}
3878
Chris Lattner6ac46a42008-04-07 06:51:04 +00003879//===----------------------------------------------------------------------===//
3880// Type Compatibility Testing
3881//===----------------------------------------------------------------------===//
Chris Lattner770951b2007-11-01 05:03:41 +00003882
Mike Stump1eb44332009-09-09 15:08:12 +00003883/// areCompatVectorTypes - Return true if the two specified vector types are
Chris Lattner6ac46a42008-04-07 06:51:04 +00003884/// compatible.
3885static bool areCompatVectorTypes(const VectorType *LHS,
3886 const VectorType *RHS) {
John McCall467b27b2009-10-22 20:10:53 +00003887 assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified());
Chris Lattner6ac46a42008-04-07 06:51:04 +00003888 return LHS->getElementType() == RHS->getElementType() &&
Chris Lattner61710852008-10-05 17:34:18 +00003889 LHS->getNumElements() == RHS->getNumElements();
Chris Lattner6ac46a42008-04-07 06:51:04 +00003890}
3891
Steve Naroff4084c302009-07-23 01:01:38 +00003892//===----------------------------------------------------------------------===//
3893// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
3894//===----------------------------------------------------------------------===//
3895
3896/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
3897/// inheritance hierarchy of 'rProto'.
Fariborz Jahanian0fd89042009-08-11 22:02:25 +00003898bool ASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
3899 ObjCProtocolDecl *rProto) {
Steve Naroff4084c302009-07-23 01:01:38 +00003900 if (lProto == rProto)
3901 return true;
3902 for (ObjCProtocolDecl::protocol_iterator PI = rProto->protocol_begin(),
3903 E = rProto->protocol_end(); PI != E; ++PI)
3904 if (ProtocolCompatibleWithProtocol(lProto, *PI))
3905 return true;
3906 return false;
3907}
3908
Steve Naroff4084c302009-07-23 01:01:38 +00003909/// QualifiedIdConformsQualifiedId - compare id<p,...> with id<p1,...>
3910/// return true if lhs's protocols conform to rhs's protocol; false
3911/// otherwise.
3912bool ASTContext::QualifiedIdConformsQualifiedId(QualType lhs, QualType rhs) {
3913 if (lhs->isObjCQualifiedIdType() && rhs->isObjCQualifiedIdType())
3914 return ObjCQualifiedIdTypesAreCompatible(lhs, rhs, false);
3915 return false;
3916}
3917
3918/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
3919/// ObjCQualifiedIDType.
3920bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs,
3921 bool compare) {
3922 // Allow id<P..> and an 'id' or void* type in all cases.
Mike Stump1eb44332009-09-09 15:08:12 +00003923 if (lhs->isVoidPointerType() ||
Steve Naroff4084c302009-07-23 01:01:38 +00003924 lhs->isObjCIdType() || lhs->isObjCClassType())
3925 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00003926 else if (rhs->isVoidPointerType() ||
Steve Naroff4084c302009-07-23 01:01:38 +00003927 rhs->isObjCIdType() || rhs->isObjCClassType())
3928 return true;
3929
3930 if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) {
John McCall183700f2009-09-21 23:43:11 +00003931 const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
Mike Stump1eb44332009-09-09 15:08:12 +00003932
Steve Naroff4084c302009-07-23 01:01:38 +00003933 if (!rhsOPT) return false;
Mike Stump1eb44332009-09-09 15:08:12 +00003934
Steve Naroff4084c302009-07-23 01:01:38 +00003935 if (rhsOPT->qual_empty()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003936 // If the RHS is a unqualified interface pointer "NSString*",
Steve Naroff4084c302009-07-23 01:01:38 +00003937 // make sure we check the class hierarchy.
3938 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
3939 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
3940 E = lhsQID->qual_end(); I != E; ++I) {
3941 // when comparing an id<P> on lhs with a static type on rhs,
3942 // see if static class implements all of id's protocols, directly or
3943 // through its super class and categories.
Fariborz Jahanian0fd89042009-08-11 22:02:25 +00003944 if (!rhsID->ClassImplementsProtocol(*I, true))
Steve Naroff4084c302009-07-23 01:01:38 +00003945 return false;
3946 }
3947 }
3948 // If there are no qualifiers and no interface, we have an 'id'.
3949 return true;
3950 }
Mike Stump1eb44332009-09-09 15:08:12 +00003951 // Both the right and left sides have qualifiers.
Steve Naroff4084c302009-07-23 01:01:38 +00003952 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
3953 E = lhsQID->qual_end(); I != E; ++I) {
3954 ObjCProtocolDecl *lhsProto = *I;
3955 bool match = false;
3956
3957 // when comparing an id<P> on lhs with a static type on rhs,
3958 // see if static class implements all of id's protocols, directly or
3959 // through its super class and categories.
3960 for (ObjCObjectPointerType::qual_iterator J = rhsOPT->qual_begin(),
3961 E = rhsOPT->qual_end(); J != E; ++J) {
3962 ObjCProtocolDecl *rhsProto = *J;
3963 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
3964 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
3965 match = true;
3966 break;
3967 }
3968 }
Mike Stump1eb44332009-09-09 15:08:12 +00003969 // If the RHS is a qualified interface pointer "NSString<P>*",
Steve Naroff4084c302009-07-23 01:01:38 +00003970 // make sure we check the class hierarchy.
3971 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
3972 for (ObjCObjectPointerType::qual_iterator I = lhsQID->qual_begin(),
3973 E = lhsQID->qual_end(); I != E; ++I) {
3974 // when comparing an id<P> on lhs with a static type on rhs,
3975 // see if static class implements all of id's protocols, directly or
3976 // through its super class and categories.
Fariborz Jahanian0fd89042009-08-11 22:02:25 +00003977 if (rhsID->ClassImplementsProtocol(*I, true)) {
Steve Naroff4084c302009-07-23 01:01:38 +00003978 match = true;
3979 break;
3980 }
3981 }
3982 }
3983 if (!match)
3984 return false;
3985 }
Mike Stump1eb44332009-09-09 15:08:12 +00003986
Steve Naroff4084c302009-07-23 01:01:38 +00003987 return true;
3988 }
Mike Stump1eb44332009-09-09 15:08:12 +00003989
Steve Naroff4084c302009-07-23 01:01:38 +00003990 const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType();
3991 assert(rhsQID && "One of the LHS/RHS should be id<x>");
3992
Mike Stump1eb44332009-09-09 15:08:12 +00003993 if (const ObjCObjectPointerType *lhsOPT =
Steve Naroff4084c302009-07-23 01:01:38 +00003994 lhs->getAsObjCInterfacePointerType()) {
3995 if (lhsOPT->qual_empty()) {
3996 bool match = false;
3997 if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) {
3998 for (ObjCObjectPointerType::qual_iterator I = rhsQID->qual_begin(),
3999 E = rhsQID->qual_end(); I != E; ++I) {
4000 // when comparing an id<P> on lhs with a static type on rhs,
4001 // see if static class implements all of id's protocols, directly or
4002 // through its super class and categories.
Fariborz Jahanian0fd89042009-08-11 22:02:25 +00004003 if (lhsID->ClassImplementsProtocol(*I, true)) {
Steve Naroff4084c302009-07-23 01:01:38 +00004004 match = true;
4005 break;
4006 }
4007 }
4008 if (!match)
4009 return false;
4010 }
4011 return true;
4012 }
Mike Stump1eb44332009-09-09 15:08:12 +00004013 // Both the right and left sides have qualifiers.
Steve Naroff4084c302009-07-23 01:01:38 +00004014 for (ObjCObjectPointerType::qual_iterator I = lhsOPT->qual_begin(),
4015 E = lhsOPT->qual_end(); I != E; ++I) {
4016 ObjCProtocolDecl *lhsProto = *I;
4017 bool match = false;
4018
4019 // when comparing an id<P> on lhs with a static type on rhs,
4020 // see if static class implements all of id's protocols, directly or
4021 // through its super class and categories.
4022 for (ObjCObjectPointerType::qual_iterator J = rhsQID->qual_begin(),
4023 E = rhsQID->qual_end(); J != E; ++J) {
4024 ObjCProtocolDecl *rhsProto = *J;
4025 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
4026 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
4027 match = true;
4028 break;
4029 }
4030 }
4031 if (!match)
4032 return false;
4033 }
4034 return true;
4035 }
4036 return false;
4037}
4038
Eli Friedman3d815e72008-08-22 00:56:42 +00004039/// canAssignObjCInterfaces - Return true if the two interface types are
Chris Lattner6ac46a42008-04-07 06:51:04 +00004040/// compatible for assignment from RHS to LHS. This handles validation of any
4041/// protocol qualifiers on the LHS or RHS.
4042///
Steve Naroff14108da2009-07-10 23:34:53 +00004043bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
4044 const ObjCObjectPointerType *RHSOPT) {
Steve Naroffde2e22d2009-07-15 18:40:39 +00004045 // If either type represents the built-in 'id' or 'Class' types, return true.
4046 if (LHSOPT->isObjCBuiltinType() || RHSOPT->isObjCBuiltinType())
Steve Naroff14108da2009-07-10 23:34:53 +00004047 return true;
4048
Steve Naroff4084c302009-07-23 01:01:38 +00004049 if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
Mike Stump1eb44332009-09-09 15:08:12 +00004050 return ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
4051 QualType(RHSOPT,0),
Steve Naroff4084c302009-07-23 01:01:38 +00004052 false);
4053
Steve Naroff14108da2009-07-10 23:34:53 +00004054 const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
4055 const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
Steve Naroff4084c302009-07-23 01:01:38 +00004056 if (LHS && RHS) // We have 2 user-defined types.
4057 return canAssignObjCInterfaces(LHS, RHS);
Mike Stump1eb44332009-09-09 15:08:12 +00004058
Steve Naroff4084c302009-07-23 01:01:38 +00004059 return false;
Steve Naroff14108da2009-07-10 23:34:53 +00004060}
4061
Fariborz Jahaniane23fa2d2009-10-30 01:13:23 +00004062/// getIntersectionOfProtocols - This routine finds the intersection of set
4063/// of protocols inherited from two distinct objective-c pointer objects.
4064/// It is used to build composite qualifier list of the composite type of
4065/// the conditional expression involving two objective-c pointer objects.
4066static
4067void getIntersectionOfProtocols(ASTContext &Context,
4068 const ObjCObjectPointerType *LHSOPT,
4069 const ObjCObjectPointerType *RHSOPT,
4070 llvm::SmallVectorImpl<ObjCProtocolDecl *> &IntersectionOfProtocols) {
4071
4072 const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
4073 const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
4074
4075 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocolSet;
4076 unsigned LHSNumProtocols = LHS->getNumProtocols();
4077 if (LHSNumProtocols > 0)
4078 InheritedProtocolSet.insert(LHS->qual_begin(), LHS->qual_end());
4079 else {
4080 llvm::SmallVector<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
4081 Context.CollectInheritedProtocols(LHS->getDecl(), LHSInheritedProtocols);
4082 InheritedProtocolSet.insert(LHSInheritedProtocols.begin(),
4083 LHSInheritedProtocols.end());
4084 }
4085
4086 unsigned RHSNumProtocols = RHS->getNumProtocols();
4087 if (RHSNumProtocols > 0) {
4088 ObjCProtocolDecl **RHSProtocols = (ObjCProtocolDecl **)RHS->qual_begin();
4089 for (unsigned i = 0; i < RHSNumProtocols; ++i)
4090 if (InheritedProtocolSet.count(RHSProtocols[i]))
4091 IntersectionOfProtocols.push_back(RHSProtocols[i]);
4092 }
4093 else {
4094 llvm::SmallVector<ObjCProtocolDecl *, 8> RHSInheritedProtocols;
4095 Context.CollectInheritedProtocols(RHS->getDecl(), RHSInheritedProtocols);
4096 // FIXME. This may cause duplication of protocols in the list, but should
4097 // be harmless.
4098 for (unsigned i = 0, len = RHSInheritedProtocols.size(); i < len; ++i)
4099 if (InheritedProtocolSet.count(RHSInheritedProtocols[i]))
4100 IntersectionOfProtocols.push_back(RHSInheritedProtocols[i]);
4101 }
4102}
4103
Fariborz Jahaniandb07b3f2009-10-27 23:02:38 +00004104/// areCommonBaseCompatible - Returns common base class of the two classes if
4105/// one found. Note that this is O'2 algorithm. But it will be called as the
4106/// last type comparison in a ?-exp of ObjC pointer types before a
4107/// warning is issued. So, its invokation is extremely rare.
4108QualType ASTContext::areCommonBaseCompatible(
4109 const ObjCObjectPointerType *LHSOPT,
4110 const ObjCObjectPointerType *RHSOPT) {
4111 const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
4112 const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
4113 if (!LHS || !RHS)
4114 return QualType();
4115
4116 while (const ObjCInterfaceDecl *LHSIDecl = LHS->getDecl()->getSuperClass()) {
4117 QualType LHSTy = getObjCInterfaceType(LHSIDecl);
4118 LHS = LHSTy->getAs<ObjCInterfaceType>();
Fariborz Jahaniane23fa2d2009-10-30 01:13:23 +00004119 if (canAssignObjCInterfaces(LHS, RHS)) {
4120 llvm::SmallVector<ObjCProtocolDecl *, 8> IntersectionOfProtocols;
4121 getIntersectionOfProtocols(*this,
4122 LHSOPT, RHSOPT, IntersectionOfProtocols);
4123 if (IntersectionOfProtocols.empty())
4124 LHSTy = getObjCObjectPointerType(LHSTy);
4125 else
4126 LHSTy = getObjCObjectPointerType(LHSTy, &IntersectionOfProtocols[0],
4127 IntersectionOfProtocols.size());
4128 return LHSTy;
4129 }
Fariborz Jahaniandb07b3f2009-10-27 23:02:38 +00004130 }
4131
4132 return QualType();
4133}
4134
Eli Friedman3d815e72008-08-22 00:56:42 +00004135bool ASTContext::canAssignObjCInterfaces(const ObjCInterfaceType *LHS,
4136 const ObjCInterfaceType *RHS) {
Chris Lattner6ac46a42008-04-07 06:51:04 +00004137 // Verify that the base decls are compatible: the RHS must be a subclass of
4138 // the LHS.
4139 if (!LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
4140 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00004141
Chris Lattner6ac46a42008-04-07 06:51:04 +00004142 // RHS must have a superset of the protocols in the LHS. If the LHS is not
4143 // protocol qualified at all, then we are good.
Steve Naroffc15cb2a2009-07-18 15:33:26 +00004144 if (LHS->getNumProtocols() == 0)
Chris Lattner6ac46a42008-04-07 06:51:04 +00004145 return true;
Mike Stump1eb44332009-09-09 15:08:12 +00004146
Chris Lattner6ac46a42008-04-07 06:51:04 +00004147 // Okay, we know the LHS has protocol qualifiers. If the RHS doesn't, then it
4148 // isn't a superset.
Steve Naroffc15cb2a2009-07-18 15:33:26 +00004149 if (RHS->getNumProtocols() == 0)
Chris Lattner6ac46a42008-04-07 06:51:04 +00004150 return true; // FIXME: should return false!
Mike Stump1eb44332009-09-09 15:08:12 +00004151
Steve Naroffc15cb2a2009-07-18 15:33:26 +00004152 for (ObjCInterfaceType::qual_iterator LHSPI = LHS->qual_begin(),
4153 LHSPE = LHS->qual_end();
Steve Naroff91b0b0c2009-03-01 16:12:44 +00004154 LHSPI != LHSPE; LHSPI++) {
4155 bool RHSImplementsProtocol = false;
4156
4157 // If the RHS doesn't implement the protocol on the left, the types
4158 // are incompatible.
Steve Naroffc15cb2a2009-07-18 15:33:26 +00004159 for (ObjCInterfaceType::qual_iterator RHSPI = RHS->qual_begin(),
Steve Naroff4084c302009-07-23 01:01:38 +00004160 RHSPE = RHS->qual_end();
Steve Naroff8f167562009-07-16 16:21:02 +00004161 RHSPI != RHSPE; RHSPI++) {
4162 if ((*RHSPI)->lookupProtocolNamed((*LHSPI)->getIdentifier())) {
Steve Naroff91b0b0c2009-03-01 16:12:44 +00004163 RHSImplementsProtocol = true;
Steve Naroff8f167562009-07-16 16:21:02 +00004164 break;
4165 }
Steve Naroff91b0b0c2009-03-01 16:12:44 +00004166 }
4167 // FIXME: For better diagnostics, consider passing back the protocol name.
4168 if (!RHSImplementsProtocol)
4169 return false;
Chris Lattner6ac46a42008-04-07 06:51:04 +00004170 }
Steve Naroff91b0b0c2009-03-01 16:12:44 +00004171 // The RHS implements all protocols listed on the LHS.
4172 return true;
Chris Lattner6ac46a42008-04-07 06:51:04 +00004173}
4174
Steve Naroff389bf462009-02-12 17:52:19 +00004175bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) {
4176 // get the "pointed to" types
John McCall183700f2009-09-21 23:43:11 +00004177 const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
4178 const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>();
Mike Stump1eb44332009-09-09 15:08:12 +00004179
Steve Naroff14108da2009-07-10 23:34:53 +00004180 if (!LHSOPT || !RHSOPT)
Steve Naroff389bf462009-02-12 17:52:19 +00004181 return false;
Steve Naroff14108da2009-07-10 23:34:53 +00004182
4183 return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
4184 canAssignObjCInterfaces(RHSOPT, LHSOPT);
Steve Naroff389bf462009-02-12 17:52:19 +00004185}
4186
Mike Stump1eb44332009-09-09 15:08:12 +00004187/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,
Steve Naroffec0550f2007-10-15 20:41:53 +00004188/// both shall have the identically qualified version of a compatible type.
Mike Stump1eb44332009-09-09 15:08:12 +00004189/// C99 6.2.7p1: Two types have compatible types if their types are the
Steve Naroffec0550f2007-10-15 20:41:53 +00004190/// same. See 6.7.[2,3,5] for additional rules.
Eli Friedman3d815e72008-08-22 00:56:42 +00004191bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS) {
4192 return !mergeTypes(LHS, RHS).isNull();
4193}
4194
4195QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs) {
John McCall183700f2009-09-21 23:43:11 +00004196 const FunctionType *lbase = lhs->getAs<FunctionType>();
4197 const FunctionType *rbase = rhs->getAs<FunctionType>();
Douglas Gregor72564e72009-02-26 23:50:07 +00004198 const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
4199 const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
Eli Friedman3d815e72008-08-22 00:56:42 +00004200 bool allLTypes = true;
4201 bool allRTypes = true;
4202
4203 // Check return type
4204 QualType retType = mergeTypes(lbase->getResultType(), rbase->getResultType());
4205 if (retType.isNull()) return QualType();
Chris Lattner61710852008-10-05 17:34:18 +00004206 if (getCanonicalType(retType) != getCanonicalType(lbase->getResultType()))
4207 allLTypes = false;
4208 if (getCanonicalType(retType) != getCanonicalType(rbase->getResultType()))
4209 allRTypes = false;
Mike Stump6dcbc292009-07-25 23:24:03 +00004210 // FIXME: double check this
Mike Stump24556362009-07-25 21:26:53 +00004211 bool NoReturn = lbase->getNoReturnAttr() || rbase->getNoReturnAttr();
4212 if (NoReturn != lbase->getNoReturnAttr())
4213 allLTypes = false;
4214 if (NoReturn != rbase->getNoReturnAttr())
4215 allRTypes = false;
Mike Stump1eb44332009-09-09 15:08:12 +00004216
Eli Friedman3d815e72008-08-22 00:56:42 +00004217 if (lproto && rproto) { // two C99 style function prototypes
Sebastian Redl465226e2009-05-27 22:11:52 +00004218 assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&
4219 "C++ shouldn't be here");
Eli Friedman3d815e72008-08-22 00:56:42 +00004220 unsigned lproto_nargs = lproto->getNumArgs();
4221 unsigned rproto_nargs = rproto->getNumArgs();
4222
4223 // Compatible functions must have the same number of arguments
4224 if (lproto_nargs != rproto_nargs)
4225 return QualType();
4226
4227 // Variadic and non-variadic functions aren't compatible
4228 if (lproto->isVariadic() != rproto->isVariadic())
4229 return QualType();
4230
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00004231 if (lproto->getTypeQuals() != rproto->getTypeQuals())
4232 return QualType();
4233
Eli Friedman3d815e72008-08-22 00:56:42 +00004234 // Check argument compatibility
4235 llvm::SmallVector<QualType, 10> types;
4236 for (unsigned i = 0; i < lproto_nargs; i++) {
4237 QualType largtype = lproto->getArgType(i).getUnqualifiedType();
4238 QualType rargtype = rproto->getArgType(i).getUnqualifiedType();
4239 QualType argtype = mergeTypes(largtype, rargtype);
4240 if (argtype.isNull()) return QualType();
4241 types.push_back(argtype);
Chris Lattner61710852008-10-05 17:34:18 +00004242 if (getCanonicalType(argtype) != getCanonicalType(largtype))
4243 allLTypes = false;
4244 if (getCanonicalType(argtype) != getCanonicalType(rargtype))
4245 allRTypes = false;
Eli Friedman3d815e72008-08-22 00:56:42 +00004246 }
4247 if (allLTypes) return lhs;
4248 if (allRTypes) return rhs;
4249 return getFunctionType(retType, types.begin(), types.size(),
Mike Stump24556362009-07-25 21:26:53 +00004250 lproto->isVariadic(), lproto->getTypeQuals(),
4251 NoReturn);
Eli Friedman3d815e72008-08-22 00:56:42 +00004252 }
4253
4254 if (lproto) allRTypes = false;
4255 if (rproto) allLTypes = false;
4256
Douglas Gregor72564e72009-02-26 23:50:07 +00004257 const FunctionProtoType *proto = lproto ? lproto : rproto;
Eli Friedman3d815e72008-08-22 00:56:42 +00004258 if (proto) {
Sebastian Redl465226e2009-05-27 22:11:52 +00004259 assert(!proto->hasExceptionSpec() && "C++ shouldn't be here");
Eli Friedman3d815e72008-08-22 00:56:42 +00004260 if (proto->isVariadic()) return QualType();
4261 // Check that the types are compatible with the types that
4262 // would result from default argument promotions (C99 6.7.5.3p15).
4263 // The only types actually affected are promotable integer
4264 // types and floats, which would be passed as a different
4265 // type depending on whether the prototype is visible.
4266 unsigned proto_nargs = proto->getNumArgs();
4267 for (unsigned i = 0; i < proto_nargs; ++i) {
4268 QualType argTy = proto->getArgType(i);
4269 if (argTy->isPromotableIntegerType() ||
4270 getCanonicalType(argTy).getUnqualifiedType() == FloatTy)
4271 return QualType();
4272 }
4273
4274 if (allLTypes) return lhs;
4275 if (allRTypes) return rhs;
4276 return getFunctionType(retType, proto->arg_type_begin(),
Mike Stump2d3c1912009-07-27 00:44:23 +00004277 proto->getNumArgs(), proto->isVariadic(),
4278 proto->getTypeQuals(), NoReturn);
Eli Friedman3d815e72008-08-22 00:56:42 +00004279 }
4280
4281 if (allLTypes) return lhs;
4282 if (allRTypes) return rhs;
Mike Stump24556362009-07-25 21:26:53 +00004283 return getFunctionNoProtoType(retType, NoReturn);
Eli Friedman3d815e72008-08-22 00:56:42 +00004284}
4285
4286QualType ASTContext::mergeTypes(QualType LHS, QualType RHS) {
Bill Wendling43d69752007-12-03 07:33:35 +00004287 // C++ [expr]: If an expression initially has the type "reference to T", the
4288 // type is adjusted to "T" prior to any further analysis, the expression
4289 // designates the object or function denoted by the reference, and the
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004290 // expression is an lvalue unless the reference is an rvalue reference and
4291 // the expression is a function call (possibly inside parentheses).
Eli Friedman3d815e72008-08-22 00:56:42 +00004292 // FIXME: C++ shouldn't be going through here! The rules are different
4293 // enough that they should be handled separately.
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004294 // FIXME: Merging of lvalue and rvalue references is incorrect. C++ *really*
4295 // shouldn't be going through here!
Ted Kremenek6217b802009-07-29 21:53:49 +00004296 if (const ReferenceType *RT = LHS->getAs<ReferenceType>())
Chris Lattnerc4e40592008-04-07 04:07:56 +00004297 LHS = RT->getPointeeType();
Ted Kremenek6217b802009-07-29 21:53:49 +00004298 if (const ReferenceType *RT = RHS->getAs<ReferenceType>())
Chris Lattnerc4e40592008-04-07 04:07:56 +00004299 RHS = RT->getPointeeType();
Chris Lattnerf3692dc2008-04-07 05:37:56 +00004300
Eli Friedman3d815e72008-08-22 00:56:42 +00004301 QualType LHSCan = getCanonicalType(LHS),
4302 RHSCan = getCanonicalType(RHS);
4303
4304 // If two types are identical, they are compatible.
4305 if (LHSCan == RHSCan)
4306 return LHS;
4307
John McCall0953e762009-09-24 19:53:00 +00004308 // If the qualifiers are different, the types aren't compatible... mostly.
Douglas Gregora4923eb2009-11-16 21:35:15 +00004309 Qualifiers LQuals = LHSCan.getLocalQualifiers();
4310 Qualifiers RQuals = RHSCan.getLocalQualifiers();
John McCall0953e762009-09-24 19:53:00 +00004311 if (LQuals != RQuals) {
4312 // If any of these qualifiers are different, we have a type
4313 // mismatch.
4314 if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
4315 LQuals.getAddressSpace() != RQuals.getAddressSpace())
4316 return QualType();
4317
4318 // Exactly one GC qualifier difference is allowed: __strong is
4319 // okay if the other type has no GC qualifier but is an Objective
4320 // C object pointer (i.e. implicitly strong by default). We fix
4321 // this by pretending that the unqualified type was actually
4322 // qualified __strong.
4323 Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
4324 Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
4325 assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements");
4326
4327 if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
4328 return QualType();
4329
4330 if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) {
4331 return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong));
4332 }
4333 if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) {
4334 return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS);
4335 }
Eli Friedman3d815e72008-08-22 00:56:42 +00004336 return QualType();
John McCall0953e762009-09-24 19:53:00 +00004337 }
4338
4339 // Okay, qualifiers are equal.
Eli Friedman3d815e72008-08-22 00:56:42 +00004340
Eli Friedman852d63b2009-06-01 01:22:52 +00004341 Type::TypeClass LHSClass = LHSCan->getTypeClass();
4342 Type::TypeClass RHSClass = RHSCan->getTypeClass();
Eli Friedman3d815e72008-08-22 00:56:42 +00004343
Chris Lattner1adb8832008-01-14 05:45:46 +00004344 // We want to consider the two function types to be the same for these
4345 // comparisons, just force one to the other.
4346 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
4347 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
Eli Friedman4c721d32008-02-12 08:23:06 +00004348
4349 // Same as above for arrays
Chris Lattnera36a61f2008-04-07 05:43:21 +00004350 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
4351 LHSClass = Type::ConstantArray;
4352 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
4353 RHSClass = Type::ConstantArray;
Mike Stump1eb44332009-09-09 15:08:12 +00004354
Nate Begeman213541a2008-04-18 23:10:10 +00004355 // Canonicalize ExtVector -> Vector.
4356 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
4357 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
Mike Stump1eb44332009-09-09 15:08:12 +00004358
Chris Lattnera36a61f2008-04-07 05:43:21 +00004359 // If the canonical type classes don't match.
Chris Lattner1adb8832008-01-14 05:45:46 +00004360 if (LHSClass != RHSClass) {
Chris Lattner1adb8832008-01-14 05:45:46 +00004361 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
Mike Stump1eb44332009-09-09 15:08:12 +00004362 // a signed integer type, or an unsigned integer type.
John McCall842aef82009-12-09 09:09:27 +00004363 // Compatibility is based on the underlying type, not the promotion
4364 // type.
John McCall183700f2009-09-21 23:43:11 +00004365 if (const EnumType* ETy = LHS->getAs<EnumType>()) {
Eli Friedman3d815e72008-08-22 00:56:42 +00004366 if (ETy->getDecl()->getIntegerType() == RHSCan.getUnqualifiedType())
4367 return RHS;
Eli Friedmanbab96962008-02-12 08:46:17 +00004368 }
John McCall183700f2009-09-21 23:43:11 +00004369 if (const EnumType* ETy = RHS->getAs<EnumType>()) {
Eli Friedman3d815e72008-08-22 00:56:42 +00004370 if (ETy->getDecl()->getIntegerType() == LHSCan.getUnqualifiedType())
4371 return LHS;
Eli Friedmanbab96962008-02-12 08:46:17 +00004372 }
Chris Lattner1adb8832008-01-14 05:45:46 +00004373
Eli Friedman3d815e72008-08-22 00:56:42 +00004374 return QualType();
Steve Naroffec0550f2007-10-15 20:41:53 +00004375 }
Eli Friedman3d815e72008-08-22 00:56:42 +00004376
Steve Naroff4a746782008-01-09 22:43:08 +00004377 // The canonical type classes match.
Chris Lattner1adb8832008-01-14 05:45:46 +00004378 switch (LHSClass) {
Douglas Gregor72564e72009-02-26 23:50:07 +00004379#define TYPE(Class, Base)
4380#define ABSTRACT_TYPE(Class, Base)
4381#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4382#define DEPENDENT_TYPE(Class, Base) case Type::Class:
4383#include "clang/AST/TypeNodes.def"
4384 assert(false && "Non-canonical and dependent types shouldn't get here");
4385 return QualType();
4386
Sebastian Redl7c80bd62009-03-16 23:22:08 +00004387 case Type::LValueReference:
4388 case Type::RValueReference:
Douglas Gregor72564e72009-02-26 23:50:07 +00004389 case Type::MemberPointer:
4390 assert(false && "C++ should never be in mergeTypes");
4391 return QualType();
4392
4393 case Type::IncompleteArray:
4394 case Type::VariableArray:
4395 case Type::FunctionProto:
4396 case Type::ExtVector:
Douglas Gregor72564e72009-02-26 23:50:07 +00004397 assert(false && "Types are eliminated above");
4398 return QualType();
4399
Chris Lattner1adb8832008-01-14 05:45:46 +00004400 case Type::Pointer:
Eli Friedman3d815e72008-08-22 00:56:42 +00004401 {
4402 // Merge two pointer types, while trying to preserve typedef info
Ted Kremenek6217b802009-07-29 21:53:49 +00004403 QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType();
4404 QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType();
Eli Friedman3d815e72008-08-22 00:56:42 +00004405 QualType ResultType = mergeTypes(LHSPointee, RHSPointee);
4406 if (ResultType.isNull()) return QualType();
Eli Friedman07d25872009-06-02 05:28:56 +00004407 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
Chris Lattner61710852008-10-05 17:34:18 +00004408 return LHS;
Eli Friedman07d25872009-06-02 05:28:56 +00004409 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
Chris Lattner61710852008-10-05 17:34:18 +00004410 return RHS;
Eli Friedman3d815e72008-08-22 00:56:42 +00004411 return getPointerType(ResultType);
4412 }
Steve Naroffc0febd52008-12-10 17:49:55 +00004413 case Type::BlockPointer:
4414 {
4415 // Merge two block pointer types, while trying to preserve typedef info
Ted Kremenek6217b802009-07-29 21:53:49 +00004416 QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType();
4417 QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType();
Steve Naroffc0febd52008-12-10 17:49:55 +00004418 QualType ResultType = mergeTypes(LHSPointee, RHSPointee);
4419 if (ResultType.isNull()) return QualType();
4420 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
4421 return LHS;
4422 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
4423 return RHS;
4424 return getBlockPointerType(ResultType);
4425 }
Chris Lattner1adb8832008-01-14 05:45:46 +00004426 case Type::ConstantArray:
Eli Friedman3d815e72008-08-22 00:56:42 +00004427 {
4428 const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
4429 const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
4430 if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
4431 return QualType();
4432
4433 QualType LHSElem = getAsArrayType(LHS)->getElementType();
4434 QualType RHSElem = getAsArrayType(RHS)->getElementType();
4435 QualType ResultType = mergeTypes(LHSElem, RHSElem);
4436 if (ResultType.isNull()) return QualType();
Chris Lattner61710852008-10-05 17:34:18 +00004437 if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
4438 return LHS;
4439 if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
4440 return RHS;
Eli Friedman3bc0f452008-08-22 01:48:21 +00004441 if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(),
4442 ArrayType::ArraySizeModifier(), 0);
4443 if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(),
4444 ArrayType::ArraySizeModifier(), 0);
Eli Friedman3d815e72008-08-22 00:56:42 +00004445 const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
4446 const VariableArrayType* RVAT = getAsVariableArrayType(RHS);
Chris Lattner61710852008-10-05 17:34:18 +00004447 if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
4448 return LHS;
4449 if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
4450 return RHS;
Eli Friedman3d815e72008-08-22 00:56:42 +00004451 if (LVAT) {
4452 // FIXME: This isn't correct! But tricky to implement because
4453 // the array's size has to be the size of LHS, but the type
4454 // has to be different.
4455 return LHS;
4456 }
4457 if (RVAT) {
4458 // FIXME: This isn't correct! But tricky to implement because
4459 // the array's size has to be the size of RHS, but the type
4460 // has to be different.
4461 return RHS;
4462 }
Eli Friedman3bc0f452008-08-22 01:48:21 +00004463 if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
4464 if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +00004465 return getIncompleteArrayType(ResultType,
4466 ArrayType::ArraySizeModifier(), 0);
Eli Friedman3d815e72008-08-22 00:56:42 +00004467 }
Chris Lattner1adb8832008-01-14 05:45:46 +00004468 case Type::FunctionNoProto:
Eli Friedman3d815e72008-08-22 00:56:42 +00004469 return mergeFunctionTypes(LHS, RHS);
Douglas Gregor72564e72009-02-26 23:50:07 +00004470 case Type::Record:
Douglas Gregor72564e72009-02-26 23:50:07 +00004471 case Type::Enum:
Eli Friedman3d815e72008-08-22 00:56:42 +00004472 return QualType();
Chris Lattner1adb8832008-01-14 05:45:46 +00004473 case Type::Builtin:
Chris Lattner3cc4c0c2008-04-07 05:55:38 +00004474 // Only exactly equal builtin types are compatible, which is tested above.
Eli Friedman3d815e72008-08-22 00:56:42 +00004475 return QualType();
Daniel Dunbar64cfdb72009-01-28 21:22:12 +00004476 case Type::Complex:
4477 // Distinct complex types are incompatible.
4478 return QualType();
Chris Lattner3cc4c0c2008-04-07 05:55:38 +00004479 case Type::Vector:
Eli Friedman5a61f0e2009-02-27 23:04:43 +00004480 // FIXME: The merged type should be an ExtVector!
John McCall183700f2009-09-21 23:43:11 +00004481 if (areCompatVectorTypes(LHS->getAs<VectorType>(), RHS->getAs<VectorType>()))
Eli Friedman3d815e72008-08-22 00:56:42 +00004482 return LHS;
Chris Lattner61710852008-10-05 17:34:18 +00004483 return QualType();
Cedric Venet61490e92009-02-21 17:14:49 +00004484 case Type::ObjCInterface: {
Steve Naroff5fd659d2009-02-21 16:18:07 +00004485 // Check if the interfaces are assignment compatible.
Eli Friedman5a61f0e2009-02-27 23:04:43 +00004486 // FIXME: This should be type compatibility, e.g. whether
4487 // "LHS x; RHS x;" at global scope is legal.
John McCall183700f2009-09-21 23:43:11 +00004488 const ObjCInterfaceType* LHSIface = LHS->getAs<ObjCInterfaceType>();
4489 const ObjCInterfaceType* RHSIface = RHS->getAs<ObjCInterfaceType>();
Steve Naroff5fd659d2009-02-21 16:18:07 +00004490 if (LHSIface && RHSIface &&
4491 canAssignObjCInterfaces(LHSIface, RHSIface))
4492 return LHS;
4493
Eli Friedman3d815e72008-08-22 00:56:42 +00004494 return QualType();
Cedric Venet61490e92009-02-21 17:14:49 +00004495 }
Steve Naroff14108da2009-07-10 23:34:53 +00004496 case Type::ObjCObjectPointer: {
John McCall183700f2009-09-21 23:43:11 +00004497 if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(),
4498 RHS->getAs<ObjCObjectPointerType>()))
Steve Naroff14108da2009-07-10 23:34:53 +00004499 return LHS;
4500
Steve Naroffbc76dd02008-12-10 22:14:21 +00004501 return QualType();
Steve Naroff14108da2009-07-10 23:34:53 +00004502 }
Eli Friedman5a61f0e2009-02-27 23:04:43 +00004503 case Type::FixedWidthInt:
4504 // Distinct fixed-width integers are not compatible.
4505 return QualType();
Douglas Gregor7532dc62009-03-30 22:58:21 +00004506 case Type::TemplateSpecialization:
4507 assert(false && "Dependent types have no size");
4508 break;
Steve Naroffec0550f2007-10-15 20:41:53 +00004509 }
Douglas Gregor72564e72009-02-26 23:50:07 +00004510
4511 return QualType();
Steve Naroffec0550f2007-10-15 20:41:53 +00004512}
Ted Kremenek7192f8e2007-10-31 17:10:13 +00004513
Chris Lattner5426bf62008-04-07 07:01:58 +00004514//===----------------------------------------------------------------------===//
Eli Friedmanad74a752008-06-28 06:23:08 +00004515// Integer Predicates
4516//===----------------------------------------------------------------------===//
Chris Lattner88054de2009-01-16 07:15:35 +00004517
Eli Friedmanad74a752008-06-28 06:23:08 +00004518unsigned ASTContext::getIntWidth(QualType T) {
Sebastian Redl632d7722009-11-05 21:10:57 +00004519 if (T->isBooleanType())
Eli Friedmanad74a752008-06-28 06:23:08 +00004520 return 1;
Chris Lattner6a2b9262009-10-17 20:33:28 +00004521 if (FixedWidthIntType *FWIT = dyn_cast<FixedWidthIntType>(T)) {
Eli Friedmanf98aba32009-02-13 02:31:07 +00004522 return FWIT->getWidth();
4523 }
John McCall842aef82009-12-09 09:09:27 +00004524 if (EnumType *ET = dyn_cast<EnumType>(T))
Eli Friedman29a7f332009-12-10 22:29:29 +00004525 T = ET->getDecl()->getIntegerType();
Eli Friedmanf98aba32009-02-13 02:31:07 +00004526 // For builtin types, just use the standard type sizing method
Eli Friedmanad74a752008-06-28 06:23:08 +00004527 return (unsigned)getTypeSize(T);
4528}
4529
4530QualType ASTContext::getCorrespondingUnsignedType(QualType T) {
4531 assert(T->isSignedIntegerType() && "Unexpected type");
Chris Lattner6a2b9262009-10-17 20:33:28 +00004532
4533 // Turn <4 x signed int> -> <4 x unsigned int>
4534 if (const VectorType *VTy = T->getAs<VectorType>())
4535 return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()),
4536 VTy->getNumElements());
4537
4538 // For enums, we return the unsigned version of the base type.
4539 if (const EnumType *ETy = T->getAs<EnumType>())
Eli Friedmanad74a752008-06-28 06:23:08 +00004540 T = ETy->getDecl()->getIntegerType();
Chris Lattner6a2b9262009-10-17 20:33:28 +00004541
4542 const BuiltinType *BTy = T->getAs<BuiltinType>();
4543 assert(BTy && "Unexpected signed integer type");
Eli Friedmanad74a752008-06-28 06:23:08 +00004544 switch (BTy->getKind()) {
4545 case BuiltinType::Char_S:
4546 case BuiltinType::SChar:
4547 return UnsignedCharTy;
4548 case BuiltinType::Short:
4549 return UnsignedShortTy;
4550 case BuiltinType::Int:
4551 return UnsignedIntTy;
4552 case BuiltinType::Long:
4553 return UnsignedLongTy;
4554 case BuiltinType::LongLong:
4555 return UnsignedLongLongTy;
Chris Lattner2df9ced2009-04-30 02:43:43 +00004556 case BuiltinType::Int128:
4557 return UnsignedInt128Ty;
Eli Friedmanad74a752008-06-28 06:23:08 +00004558 default:
4559 assert(0 && "Unexpected signed integer type");
4560 return QualType();
4561 }
4562}
4563
Douglas Gregor2cf26342009-04-09 22:27:44 +00004564ExternalASTSource::~ExternalASTSource() { }
4565
4566void ExternalASTSource::PrintStats() { }
Chris Lattner86df27b2009-06-14 00:45:47 +00004567
4568
4569//===----------------------------------------------------------------------===//
4570// Builtin Type Computation
4571//===----------------------------------------------------------------------===//
4572
4573/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
4574/// pointer over the consumed characters. This returns the resultant type.
Mike Stump1eb44332009-09-09 15:08:12 +00004575static QualType DecodeTypeFromStr(const char *&Str, ASTContext &Context,
Chris Lattner86df27b2009-06-14 00:45:47 +00004576 ASTContext::GetBuiltinTypeError &Error,
4577 bool AllowTypeModifiers = true) {
4578 // Modifiers.
4579 int HowLong = 0;
4580 bool Signed = false, Unsigned = false;
Mike Stump1eb44332009-09-09 15:08:12 +00004581
Chris Lattner86df27b2009-06-14 00:45:47 +00004582 // Read the modifiers first.
4583 bool Done = false;
4584 while (!Done) {
4585 switch (*Str++) {
Mike Stump1eb44332009-09-09 15:08:12 +00004586 default: Done = true; --Str; break;
Chris Lattner86df27b2009-06-14 00:45:47 +00004587 case 'S':
4588 assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!");
4589 assert(!Signed && "Can't use 'S' modifier multiple times!");
4590 Signed = true;
4591 break;
4592 case 'U':
4593 assert(!Signed && "Can't use both 'S' and 'U' modifiers!");
4594 assert(!Unsigned && "Can't use 'S' modifier multiple times!");
4595 Unsigned = true;
4596 break;
4597 case 'L':
4598 assert(HowLong <= 2 && "Can't have LLLL modifier");
4599 ++HowLong;
4600 break;
4601 }
4602 }
4603
4604 QualType Type;
Mike Stump1eb44332009-09-09 15:08:12 +00004605
Chris Lattner86df27b2009-06-14 00:45:47 +00004606 // Read the base type.
4607 switch (*Str++) {
4608 default: assert(0 && "Unknown builtin type letter!");
4609 case 'v':
4610 assert(HowLong == 0 && !Signed && !Unsigned &&
4611 "Bad modifiers used with 'v'!");
4612 Type = Context.VoidTy;
4613 break;
4614 case 'f':
4615 assert(HowLong == 0 && !Signed && !Unsigned &&
4616 "Bad modifiers used with 'f'!");
4617 Type = Context.FloatTy;
4618 break;
4619 case 'd':
4620 assert(HowLong < 2 && !Signed && !Unsigned &&
4621 "Bad modifiers used with 'd'!");
4622 if (HowLong)
4623 Type = Context.LongDoubleTy;
4624 else
4625 Type = Context.DoubleTy;
4626 break;
4627 case 's':
4628 assert(HowLong == 0 && "Bad modifiers used with 's'!");
4629 if (Unsigned)
4630 Type = Context.UnsignedShortTy;
4631 else
4632 Type = Context.ShortTy;
4633 break;
4634 case 'i':
4635 if (HowLong == 3)
4636 Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
4637 else if (HowLong == 2)
4638 Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
4639 else if (HowLong == 1)
4640 Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
4641 else
4642 Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
4643 break;
4644 case 'c':
4645 assert(HowLong == 0 && "Bad modifiers used with 'c'!");
4646 if (Signed)
4647 Type = Context.SignedCharTy;
4648 else if (Unsigned)
4649 Type = Context.UnsignedCharTy;
4650 else
4651 Type = Context.CharTy;
4652 break;
4653 case 'b': // boolean
4654 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!");
4655 Type = Context.BoolTy;
4656 break;
4657 case 'z': // size_t.
4658 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!");
4659 Type = Context.getSizeType();
4660 break;
4661 case 'F':
4662 Type = Context.getCFConstantStringType();
4663 break;
4664 case 'a':
4665 Type = Context.getBuiltinVaListType();
4666 assert(!Type.isNull() && "builtin va list type not initialized!");
4667 break;
4668 case 'A':
4669 // This is a "reference" to a va_list; however, what exactly
4670 // this means depends on how va_list is defined. There are two
4671 // different kinds of va_list: ones passed by value, and ones
4672 // passed by reference. An example of a by-value va_list is
4673 // x86, where va_list is a char*. An example of by-ref va_list
4674 // is x86-64, where va_list is a __va_list_tag[1]. For x86,
4675 // we want this argument to be a char*&; for x86-64, we want
4676 // it to be a __va_list_tag*.
4677 Type = Context.getBuiltinVaListType();
4678 assert(!Type.isNull() && "builtin va list type not initialized!");
4679 if (Type->isArrayType()) {
4680 Type = Context.getArrayDecayedType(Type);
4681 } else {
4682 Type = Context.getLValueReferenceType(Type);
4683 }
4684 break;
4685 case 'V': {
4686 char *End;
Chris Lattner86df27b2009-06-14 00:45:47 +00004687 unsigned NumElements = strtoul(Str, &End, 10);
4688 assert(End != Str && "Missing vector size");
Mike Stump1eb44332009-09-09 15:08:12 +00004689
Chris Lattner86df27b2009-06-14 00:45:47 +00004690 Str = End;
Mike Stump1eb44332009-09-09 15:08:12 +00004691
Chris Lattner86df27b2009-06-14 00:45:47 +00004692 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, false);
4693 Type = Context.getVectorType(ElementType, NumElements);
4694 break;
4695 }
Douglas Gregord3a23b22009-09-28 21:45:01 +00004696 case 'X': {
4697 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, false);
4698 Type = Context.getComplexType(ElementType);
4699 break;
4700 }
Chris Lattner9a5a7e72009-07-28 22:49:34 +00004701 case 'P':
Douglas Gregorc29f77b2009-07-07 16:35:42 +00004702 Type = Context.getFILEType();
4703 if (Type.isNull()) {
Mike Stumpf711c412009-07-28 23:57:15 +00004704 Error = ASTContext::GE_Missing_stdio;
Chris Lattner86df27b2009-06-14 00:45:47 +00004705 return QualType();
4706 }
Mike Stumpfd612db2009-07-28 23:47:15 +00004707 break;
Chris Lattner9a5a7e72009-07-28 22:49:34 +00004708 case 'J':
Mike Stumpf711c412009-07-28 23:57:15 +00004709 if (Signed)
Mike Stump782fa302009-07-28 02:25:19 +00004710 Type = Context.getsigjmp_bufType();
Mike Stumpf711c412009-07-28 23:57:15 +00004711 else
4712 Type = Context.getjmp_bufType();
4713
Mike Stumpfd612db2009-07-28 23:47:15 +00004714 if (Type.isNull()) {
Mike Stumpf711c412009-07-28 23:57:15 +00004715 Error = ASTContext::GE_Missing_setjmp;
Mike Stumpfd612db2009-07-28 23:47:15 +00004716 return QualType();
4717 }
4718 break;
Mike Stump782fa302009-07-28 02:25:19 +00004719 }
Mike Stump1eb44332009-09-09 15:08:12 +00004720
Chris Lattner86df27b2009-06-14 00:45:47 +00004721 if (!AllowTypeModifiers)
4722 return Type;
Mike Stump1eb44332009-09-09 15:08:12 +00004723
Chris Lattner86df27b2009-06-14 00:45:47 +00004724 Done = false;
4725 while (!Done) {
4726 switch (*Str++) {
4727 default: Done = true; --Str; break;
4728 case '*':
4729 Type = Context.getPointerType(Type);
4730 break;
4731 case '&':
4732 Type = Context.getLValueReferenceType(Type);
4733 break;
4734 // FIXME: There's no way to have a built-in with an rvalue ref arg.
4735 case 'C':
John McCall0953e762009-09-24 19:53:00 +00004736 Type = Type.withConst();
Chris Lattner86df27b2009-06-14 00:45:47 +00004737 break;
4738 }
4739 }
Mike Stump1eb44332009-09-09 15:08:12 +00004740
Chris Lattner86df27b2009-06-14 00:45:47 +00004741 return Type;
4742}
4743
4744/// GetBuiltinType - Return the type for the specified builtin.
4745QualType ASTContext::GetBuiltinType(unsigned id,
4746 GetBuiltinTypeError &Error) {
4747 const char *TypeStr = BuiltinInfo.GetTypeString(id);
Mike Stump1eb44332009-09-09 15:08:12 +00004748
Chris Lattner86df27b2009-06-14 00:45:47 +00004749 llvm::SmallVector<QualType, 8> ArgTypes;
Mike Stump1eb44332009-09-09 15:08:12 +00004750
Chris Lattner86df27b2009-06-14 00:45:47 +00004751 Error = GE_None;
4752 QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error);
4753 if (Error != GE_None)
4754 return QualType();
4755 while (TypeStr[0] && TypeStr[0] != '.') {
4756 QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error);
4757 if (Error != GE_None)
4758 return QualType();
4759
4760 // Do array -> pointer decay. The builtin should use the decayed type.
4761 if (Ty->isArrayType())
4762 Ty = getArrayDecayedType(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00004763
Chris Lattner86df27b2009-06-14 00:45:47 +00004764 ArgTypes.push_back(Ty);
4765 }
4766
4767 assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&
4768 "'.' should only occur at end of builtin type list!");
4769
4770 // handle untyped/variadic arguments "T c99Style();" or "T cppStyle(...);".
4771 if (ArgTypes.size() == 0 && TypeStr[0] == '.')
4772 return getFunctionNoProtoType(ResType);
4773 return getFunctionType(ResType, ArgTypes.data(), ArgTypes.size(),
4774 TypeStr[0] == '.', 0);
4775}
Eli Friedmana95d7572009-08-19 07:44:53 +00004776
4777QualType
4778ASTContext::UsualArithmeticConversionsType(QualType lhs, QualType rhs) {
4779 // Perform the usual unary conversions. We do this early so that
4780 // integral promotions to "int" can allow us to exit early, in the
4781 // lhs == rhs check. Also, for conversion purposes, we ignore any
4782 // qualifiers. For example, "const float" and "float" are
4783 // equivalent.
4784 if (lhs->isPromotableIntegerType())
4785 lhs = getPromotedIntegerType(lhs);
4786 else
4787 lhs = lhs.getUnqualifiedType();
4788 if (rhs->isPromotableIntegerType())
4789 rhs = getPromotedIntegerType(rhs);
4790 else
4791 rhs = rhs.getUnqualifiedType();
4792
4793 // If both types are identical, no conversion is needed.
4794 if (lhs == rhs)
4795 return lhs;
Mike Stump1eb44332009-09-09 15:08:12 +00004796
Eli Friedmana95d7572009-08-19 07:44:53 +00004797 // If either side is a non-arithmetic type (e.g. a pointer), we are done.
4798 // The caller can deal with this (e.g. pointer + int).
4799 if (!lhs->isArithmeticType() || !rhs->isArithmeticType())
4800 return lhs;
Mike Stump1eb44332009-09-09 15:08:12 +00004801
4802 // At this point, we have two different arithmetic types.
4803
Eli Friedmana95d7572009-08-19 07:44:53 +00004804 // Handle complex types first (C99 6.3.1.8p1).
4805 if (lhs->isComplexType() || rhs->isComplexType()) {
4806 // if we have an integer operand, the result is the complex type.
Mike Stump1eb44332009-09-09 15:08:12 +00004807 if (rhs->isIntegerType() || rhs->isComplexIntegerType()) {
Eli Friedmana95d7572009-08-19 07:44:53 +00004808 // convert the rhs to the lhs complex type.
4809 return lhs;
4810 }
Mike Stump1eb44332009-09-09 15:08:12 +00004811 if (lhs->isIntegerType() || lhs->isComplexIntegerType()) {
Eli Friedmana95d7572009-08-19 07:44:53 +00004812 // convert the lhs to the rhs complex type.
4813 return rhs;
4814 }
4815 // This handles complex/complex, complex/float, or float/complex.
Mike Stump1eb44332009-09-09 15:08:12 +00004816 // When both operands are complex, the shorter operand is converted to the
4817 // type of the longer, and that is the type of the result. This corresponds
4818 // to what is done when combining two real floating-point operands.
4819 // The fun begins when size promotion occur across type domains.
Eli Friedmana95d7572009-08-19 07:44:53 +00004820 // From H&S 6.3.4: When one operand is complex and the other is a real
Mike Stump1eb44332009-09-09 15:08:12 +00004821 // floating-point type, the less precise type is converted, within it's
Eli Friedmana95d7572009-08-19 07:44:53 +00004822 // real or complex domain, to the precision of the other type. For example,
Mike Stump1eb44332009-09-09 15:08:12 +00004823 // when combining a "long double" with a "double _Complex", the
Eli Friedmana95d7572009-08-19 07:44:53 +00004824 // "double _Complex" is promoted to "long double _Complex".
4825 int result = getFloatingTypeOrder(lhs, rhs);
Mike Stump1eb44332009-09-09 15:08:12 +00004826
4827 if (result > 0) { // The left side is bigger, convert rhs.
Eli Friedmana95d7572009-08-19 07:44:53 +00004828 rhs = getFloatingTypeOfSizeWithinDomain(lhs, rhs);
Mike Stump1eb44332009-09-09 15:08:12 +00004829 } else if (result < 0) { // The right side is bigger, convert lhs.
Eli Friedmana95d7572009-08-19 07:44:53 +00004830 lhs = getFloatingTypeOfSizeWithinDomain(rhs, lhs);
Mike Stump1eb44332009-09-09 15:08:12 +00004831 }
Eli Friedmana95d7572009-08-19 07:44:53 +00004832 // At this point, lhs and rhs have the same rank/size. Now, make sure the
4833 // domains match. This is a requirement for our implementation, C99
4834 // does not require this promotion.
4835 if (lhs != rhs) { // Domains don't match, we have complex/float mix.
4836 if (lhs->isRealFloatingType()) { // handle "double, _Complex double".
4837 return rhs;
4838 } else { // handle "_Complex double, double".
4839 return lhs;
4840 }
4841 }
4842 return lhs; // The domain/size match exactly.
4843 }
4844 // Now handle "real" floating types (i.e. float, double, long double).
4845 if (lhs->isRealFloatingType() || rhs->isRealFloatingType()) {
4846 // if we have an integer operand, the result is the real floating type.
4847 if (rhs->isIntegerType()) {
4848 // convert rhs to the lhs floating point type.
4849 return lhs;
4850 }
4851 if (rhs->isComplexIntegerType()) {
4852 // convert rhs to the complex floating point type.
4853 return getComplexType(lhs);
4854 }
4855 if (lhs->isIntegerType()) {
4856 // convert lhs to the rhs floating point type.
4857 return rhs;
4858 }
Mike Stump1eb44332009-09-09 15:08:12 +00004859 if (lhs->isComplexIntegerType()) {
Eli Friedmana95d7572009-08-19 07:44:53 +00004860 // convert lhs to the complex floating point type.
4861 return getComplexType(rhs);
4862 }
4863 // We have two real floating types, float/complex combos were handled above.
4864 // Convert the smaller operand to the bigger result.
4865 int result = getFloatingTypeOrder(lhs, rhs);
4866 if (result > 0) // convert the rhs
4867 return lhs;
4868 assert(result < 0 && "illegal float comparison");
4869 return rhs; // convert the lhs
4870 }
4871 if (lhs->isComplexIntegerType() || rhs->isComplexIntegerType()) {
4872 // Handle GCC complex int extension.
4873 const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType();
4874 const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType();
4875
4876 if (lhsComplexInt && rhsComplexInt) {
Mike Stump1eb44332009-09-09 15:08:12 +00004877 if (getIntegerTypeOrder(lhsComplexInt->getElementType(),
Eli Friedmana95d7572009-08-19 07:44:53 +00004878 rhsComplexInt->getElementType()) >= 0)
4879 return lhs; // convert the rhs
4880 return rhs;
4881 } else if (lhsComplexInt && rhs->isIntegerType()) {
4882 // convert the rhs to the lhs complex type.
4883 return lhs;
4884 } else if (rhsComplexInt && lhs->isIntegerType()) {
4885 // convert the lhs to the rhs complex type.
4886 return rhs;
4887 }
4888 }
4889 // Finally, we have two differing integer types.
4890 // The rules for this case are in C99 6.3.1.8
4891 int compare = getIntegerTypeOrder(lhs, rhs);
4892 bool lhsSigned = lhs->isSignedIntegerType(),
4893 rhsSigned = rhs->isSignedIntegerType();
4894 QualType destType;
4895 if (lhsSigned == rhsSigned) {
4896 // Same signedness; use the higher-ranked type
4897 destType = compare >= 0 ? lhs : rhs;
4898 } else if (compare != (lhsSigned ? 1 : -1)) {
4899 // The unsigned type has greater than or equal rank to the
4900 // signed type, so use the unsigned type
4901 destType = lhsSigned ? rhs : lhs;
4902 } else if (getIntWidth(lhs) != getIntWidth(rhs)) {
4903 // The two types are different widths; if we are here, that
4904 // means the signed type is larger than the unsigned type, so
4905 // use the signed type.
4906 destType = lhsSigned ? lhs : rhs;
4907 } else {
4908 // The signed type is higher-ranked than the unsigned type,
4909 // but isn't actually any bigger (like unsigned int and long
4910 // on most 32-bit systems). Use the unsigned type corresponding
4911 // to the signed type.
4912 destType = getCorrespondingUnsignedType(lhsSigned ? lhs : rhs);
4913 }
4914 return destType;
4915}