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