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