clang  6.0.0
ASTContext.cpp
Go to the documentation of this file.
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/APValue.h"
19 #include "clang/AST/Attr.h"
20 #include "clang/AST/AttrIterator.h"
21 #include "clang/AST/CharUnits.h"
22 #include "clang/AST/Comment.h"
23 #include "clang/AST/Decl.h"
24 #include "clang/AST/DeclBase.h"
25 #include "clang/AST/DeclCXX.h"
27 #include "clang/AST/DeclObjC.h"
28 #include "clang/AST/DeclOpenMP.h"
29 #include "clang/AST/DeclTemplate.h"
31 #include "clang/AST/Expr.h"
32 #include "clang/AST/ExprCXX.h"
34 #include "clang/AST/Mangle.h"
38 #include "clang/AST/RecordLayout.h"
40 #include "clang/AST/Stmt.h"
41 #include "clang/AST/TemplateBase.h"
42 #include "clang/AST/TemplateName.h"
43 #include "clang/AST/Type.h"
44 #include "clang/AST/TypeLoc.h"
48 #include "clang/Basic/Builtins.h"
51 #include "clang/Basic/LLVM.h"
53 #include "clang/Basic/Linkage.h"
58 #include "clang/Basic/Specifiers.h"
60 #include "clang/Basic/TargetInfo.h"
61 #include "clang/Basic/XRayLists.h"
62 #include "llvm/ADT/APInt.h"
63 #include "llvm/ADT/APSInt.h"
64 #include "llvm/ADT/ArrayRef.h"
65 #include "llvm/ADT/DenseMap.h"
66 #include "llvm/ADT/DenseSet.h"
67 #include "llvm/ADT/FoldingSet.h"
68 #include "llvm/ADT/None.h"
69 #include "llvm/ADT/Optional.h"
70 #include "llvm/ADT/PointerUnion.h"
71 #include "llvm/ADT/STLExtras.h"
72 #include "llvm/ADT/SmallPtrSet.h"
73 #include "llvm/ADT/SmallVector.h"
74 #include "llvm/ADT/StringExtras.h"
75 #include "llvm/ADT/StringRef.h"
76 #include "llvm/ADT/Triple.h"
77 #include "llvm/Support/Capacity.h"
78 #include "llvm/Support/Casting.h"
79 #include "llvm/Support/Compiler.h"
80 #include "llvm/Support/ErrorHandling.h"
81 #include "llvm/Support/MathExtras.h"
82 #include "llvm/Support/raw_ostream.h"
83 #include <algorithm>
84 #include <cassert>
85 #include <cstddef>
86 #include <cstdint>
87 #include <cstdlib>
88 #include <map>
89 #include <memory>
90 #include <string>
91 #include <tuple>
92 #include <utility>
93 
94 using namespace clang;
95 
108 
111 };
112 
114  if (!CommentsLoaded && ExternalSource) {
115  ExternalSource->ReadComments();
116 
117 #ifndef NDEBUG
119  assert(std::is_sorted(RawComments.begin(), RawComments.end(),
120  BeforeThanCompare<RawComment>(SourceMgr)));
121 #endif
122 
123  CommentsLoaded = true;
124  }
125 
126  assert(D);
127 
128  // User can not attach documentation to implicit declarations.
129  if (D->isImplicit())
130  return nullptr;
131 
132  // User can not attach documentation to implicit instantiations.
133  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
134  if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
135  return nullptr;
136  }
137 
138  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
139  if (VD->isStaticDataMember() &&
140  VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
141  return nullptr;
142  }
143 
144  if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) {
145  if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
146  return nullptr;
147  }
148 
149  if (const ClassTemplateSpecializationDecl *CTSD =
150  dyn_cast<ClassTemplateSpecializationDecl>(D)) {
151  TemplateSpecializationKind TSK = CTSD->getSpecializationKind();
152  if (TSK == TSK_ImplicitInstantiation ||
153  TSK == TSK_Undeclared)
154  return nullptr;
155  }
156 
157  if (const EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
158  if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
159  return nullptr;
160  }
161  if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
162  // When tag declaration (but not definition!) is part of the
163  // decl-specifier-seq of some other declaration, it doesn't get comment
164  if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
165  return nullptr;
166  }
167  // TODO: handle comments for function parameters properly.
168  if (isa<ParmVarDecl>(D))
169  return nullptr;
170 
171  // TODO: we could look up template parameter documentation in the template
172  // documentation.
173  if (isa<TemplateTypeParmDecl>(D) ||
174  isa<NonTypeTemplateParmDecl>(D) ||
175  isa<TemplateTemplateParmDecl>(D))
176  return nullptr;
177 
179 
180  // If there are no comments anywhere, we won't find anything.
181  if (RawComments.empty())
182  return nullptr;
183 
184  // Find declaration location.
185  // For Objective-C declarations we generally don't expect to have multiple
186  // declarators, thus use declaration starting location as the "declaration
187  // location".
188  // For all other declarations multiple declarators are used quite frequently,
189  // so we use the location of the identifier as the "declaration location".
190  SourceLocation DeclLoc;
191  if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) ||
192  isa<ObjCPropertyDecl>(D) ||
193  isa<RedeclarableTemplateDecl>(D) ||
194  isa<ClassTemplateSpecializationDecl>(D))
195  DeclLoc = D->getLocStart();
196  else {
197  DeclLoc = D->getLocation();
198  if (DeclLoc.isMacroID()) {
199  if (isa<TypedefDecl>(D)) {
200  // If location of the typedef name is in a macro, it is because being
201  // declared via a macro. Try using declaration's starting location as
202  // the "declaration location".
203  DeclLoc = D->getLocStart();
204  } else if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
205  // If location of the tag decl is inside a macro, but the spelling of
206  // the tag name comes from a macro argument, it looks like a special
207  // macro like NS_ENUM is being used to define the tag decl. In that
208  // case, adjust the source location to the expansion loc so that we can
209  // attach the comment to the tag decl.
210  if (SourceMgr.isMacroArgExpansion(DeclLoc) &&
211  TD->isCompleteDefinition())
212  DeclLoc = SourceMgr.getExpansionLoc(DeclLoc);
213  }
214  }
215  }
216 
217  // If the declaration doesn't map directly to a location in a file, we
218  // can't find the comment.
219  if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
220  return nullptr;
221 
222  // Find the comment that occurs just after this declaration.
224  {
225  // When searching for comments during parsing, the comment we are looking
226  // for is usually among the last two comments we parsed -- check them
227  // first.
228  RawComment CommentAtDeclLoc(
229  SourceMgr, SourceRange(DeclLoc), false,
230  LangOpts.CommentOpts.ParseAllComments);
231  BeforeThanCompare<RawComment> Compare(SourceMgr);
232  ArrayRef<RawComment *>::iterator MaybeBeforeDecl = RawComments.end() - 1;
233  bool Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
234  if (!Found && RawComments.size() >= 2) {
235  MaybeBeforeDecl--;
236  Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
237  }
238 
239  if (Found) {
240  Comment = MaybeBeforeDecl + 1;
241  assert(Comment == std::lower_bound(RawComments.begin(), RawComments.end(),
242  &CommentAtDeclLoc, Compare));
243  } else {
244  // Slow path.
245  Comment = std::lower_bound(RawComments.begin(), RawComments.end(),
246  &CommentAtDeclLoc, Compare);
247  }
248  }
249 
250  // Decompose the location for the declaration and find the beginning of the
251  // file buffer.
252  std::pair<FileID, unsigned> DeclLocDecomp = SourceMgr.getDecomposedLoc(DeclLoc);
253 
254  // First check whether we have a trailing comment.
255  if (Comment != RawComments.end() &&
256  (*Comment)->isDocumentation() && (*Comment)->isTrailingComment() &&
257  (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D) ||
258  isa<ObjCMethodDecl>(D) || isa<ObjCPropertyDecl>(D))) {
259  std::pair<FileID, unsigned> CommentBeginDecomp
260  = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getBegin());
261  // Check that Doxygen trailing comment comes after the declaration, starts
262  // on the same line and in the same file as the declaration.
263  if (DeclLocDecomp.first == CommentBeginDecomp.first &&
264  SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second)
265  == SourceMgr.getLineNumber(CommentBeginDecomp.first,
266  CommentBeginDecomp.second)) {
267  return *Comment;
268  }
269  }
270 
271  // The comment just after the declaration was not a trailing comment.
272  // Let's look at the previous comment.
273  if (Comment == RawComments.begin())
274  return nullptr;
275  --Comment;
276 
277  // Check that we actually have a non-member Doxygen comment.
278  if (!(*Comment)->isDocumentation() || (*Comment)->isTrailingComment())
279  return nullptr;
280 
281  // Decompose the end of the comment.
282  std::pair<FileID, unsigned> CommentEndDecomp
283  = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getEnd());
284 
285  // If the comment and the declaration aren't in the same file, then they
286  // aren't related.
287  if (DeclLocDecomp.first != CommentEndDecomp.first)
288  return nullptr;
289 
290  // Get the corresponding buffer.
291  bool Invalid = false;
292  const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,
293  &Invalid).data();
294  if (Invalid)
295  return nullptr;
296 
297  // Extract text between the comment and declaration.
298  StringRef Text(Buffer + CommentEndDecomp.second,
299  DeclLocDecomp.second - CommentEndDecomp.second);
300 
301  // There should be no other declarations or preprocessor directives between
302  // comment and declaration.
303  if (Text.find_first_of(";{}#@") != StringRef::npos)
304  return nullptr;
305 
306  return *Comment;
307 }
308 
309 /// If we have a 'templated' declaration for a template, adjust 'D' to
310 /// refer to the actual template.
311 /// If we have an implicit instantiation, adjust 'D' to refer to template.
312 static const Decl *adjustDeclToTemplate(const Decl *D) {
313  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
314  // Is this function declaration part of a function template?
315  if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
316  return FTD;
317 
318  // Nothing to do if function is not an implicit instantiation.
319  if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
320  return D;
321 
322  // Function is an implicit instantiation of a function template?
323  if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())
324  return FTD;
325 
326  // Function is instantiated from a member definition of a class template?
327  if (const FunctionDecl *MemberDecl =
329  return MemberDecl;
330 
331  return D;
332  }
333  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
334  // Static data member is instantiated from a member definition of a class
335  // template?
336  if (VD->isStaticDataMember())
337  if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember())
338  return MemberDecl;
339 
340  return D;
341  }
342  if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) {
343  // Is this class declaration part of a class template?
344  if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate())
345  return CTD;
346 
347  // Class is an implicit instantiation of a class template or partial
348  // specialization?
349  if (const ClassTemplateSpecializationDecl *CTSD =
350  dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
351  if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation)
352  return D;
353  llvm::PointerUnion<ClassTemplateDecl *,
355  PU = CTSD->getSpecializedTemplateOrPartial();
356  return PU.is<ClassTemplateDecl*>() ?
357  static_cast<const Decl*>(PU.get<ClassTemplateDecl *>()) :
358  static_cast<const Decl*>(
360  }
361 
362  // Class is instantiated from a member definition of a class template?
363  if (const MemberSpecializationInfo *Info =
364  CRD->getMemberSpecializationInfo())
365  return Info->getInstantiatedFrom();
366 
367  return D;
368  }
369  if (const EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
370  // Enum is instantiated from a member definition of a class template?
371  if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum())
372  return MemberDecl;
373 
374  return D;
375  }
376  // FIXME: Adjust alias templates?
377  return D;
378 }
379 
381  const Decl *D,
382  const Decl **OriginalDecl) const {
383  D = adjustDeclToTemplate(D);
384 
385  // Check whether we have cached a comment for this declaration already.
386  {
387  llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
388  RedeclComments.find(D);
389  if (Pos != RedeclComments.end()) {
390  const RawCommentAndCacheFlags &Raw = Pos->second;
392  if (OriginalDecl)
393  *OriginalDecl = Raw.getOriginalDecl();
394  return Raw.getRaw();
395  }
396  }
397  }
398 
399  // Search for comments attached to declarations in the redeclaration chain.
400  const RawComment *RC = nullptr;
401  const Decl *OriginalDeclForRC = nullptr;
402  for (auto I : D->redecls()) {
403  llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
404  RedeclComments.find(I);
405  if (Pos != RedeclComments.end()) {
406  const RawCommentAndCacheFlags &Raw = Pos->second;
408  RC = Raw.getRaw();
409  OriginalDeclForRC = Raw.getOriginalDecl();
410  break;
411  }
412  } else {
414  OriginalDeclForRC = I;
416  if (RC) {
417  // Call order swapped to work around ICE in VS2015 RTM (Release Win32)
418  // https://connect.microsoft.com/VisualStudio/feedback/details/1741530
420  Raw.setRaw(RC);
421  } else
423  Raw.setOriginalDecl(I);
424  RedeclComments[I] = Raw;
425  if (RC)
426  break;
427  }
428  }
429 
430  // If we found a comment, it should be a documentation comment.
431  assert(!RC || RC->isDocumentation());
432 
433  if (OriginalDecl)
434  *OriginalDecl = OriginalDeclForRC;
435 
436  // Update cache for every declaration in the redeclaration chain.
438  Raw.setRaw(RC);
440  Raw.setOriginalDecl(OriginalDeclForRC);
441 
442  for (auto I : D->redecls()) {
445  R = Raw;
446  }
447 
448  return RC;
449 }
450 
451 static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod,
453  const DeclContext *DC = ObjCMethod->getDeclContext();
454  if (const ObjCImplDecl *IMD = dyn_cast<ObjCImplDecl>(DC)) {
455  const ObjCInterfaceDecl *ID = IMD->getClassInterface();
456  if (!ID)
457  return;
458  // Add redeclared method here.
459  for (const auto *Ext : ID->known_extensions()) {
460  if (ObjCMethodDecl *RedeclaredMethod =
461  Ext->getMethod(ObjCMethod->getSelector(),
462  ObjCMethod->isInstanceMethod()))
463  Redeclared.push_back(RedeclaredMethod);
464  }
465  }
466 }
467 
469  const Decl *D) const {
470  comments::DeclInfo *ThisDeclInfo = new (*this) comments::DeclInfo;
471  ThisDeclInfo->CommentDecl = D;
472  ThisDeclInfo->IsFilled = false;
473  ThisDeclInfo->fill();
474  ThisDeclInfo->CommentDecl = FC->getDecl();
475  if (!ThisDeclInfo->TemplateParameters)
476  ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;
477  comments::FullComment *CFC =
478  new (*this) comments::FullComment(FC->getBlocks(),
479  ThisDeclInfo);
480  return CFC;
481 }
482 
485  return RC ? RC->parse(*this, nullptr, D) : nullptr;
486 }
487 
489  const Decl *D,
490  const Preprocessor *PP) const {
491  if (D->isInvalidDecl())
492  return nullptr;
493  D = adjustDeclToTemplate(D);
494 
495  const Decl *Canonical = D->getCanonicalDecl();
496  llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
497  ParsedComments.find(Canonical);
498 
499  if (Pos != ParsedComments.end()) {
500  if (Canonical != D) {
501  comments::FullComment *FC = Pos->second;
503  return CFC;
504  }
505  return Pos->second;
506  }
507 
508  const Decl *OriginalDecl;
509 
510  const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);
511  if (!RC) {
512  if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
514  const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D);
515  if (OMD && OMD->isPropertyAccessor())
516  if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
517  if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))
518  return cloneFullComment(FC, D);
519  if (OMD)
520  addRedeclaredMethods(OMD, Overridden);
521  getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden);
522  for (unsigned i = 0, e = Overridden.size(); i < e; i++)
523  if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP))
524  return cloneFullComment(FC, D);
525  }
526  else if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
527  // Attach any tag type's documentation to its typedef if latter
528  // does not have one of its own.
529  QualType QT = TD->getUnderlyingType();
530  if (const TagType *TT = QT->getAs<TagType>())
531  if (const Decl *TD = TT->getDecl())
532  if (comments::FullComment *FC = getCommentForDecl(TD, PP))
533  return cloneFullComment(FC, D);
534  }
535  else if (const ObjCInterfaceDecl *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
536  while (IC->getSuperClass()) {
537  IC = IC->getSuperClass();
538  if (comments::FullComment *FC = getCommentForDecl(IC, PP))
539  return cloneFullComment(FC, D);
540  }
541  }
542  else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) {
543  if (const ObjCInterfaceDecl *IC = CD->getClassInterface())
544  if (comments::FullComment *FC = getCommentForDecl(IC, PP))
545  return cloneFullComment(FC, D);
546  }
547  else if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
548  if (!(RD = RD->getDefinition()))
549  return nullptr;
550  // Check non-virtual bases.
551  for (const auto &I : RD->bases()) {
552  if (I.isVirtual() || (I.getAccessSpecifier() != AS_public))
553  continue;
554  QualType Ty = I.getType();
555  if (Ty.isNull())
556  continue;
557  if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) {
558  if (!(NonVirtualBase= NonVirtualBase->getDefinition()))
559  continue;
560 
561  if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP))
562  return cloneFullComment(FC, D);
563  }
564  }
565  // Check virtual bases.
566  for (const auto &I : RD->vbases()) {
567  if (I.getAccessSpecifier() != AS_public)
568  continue;
569  QualType Ty = I.getType();
570  if (Ty.isNull())
571  continue;
572  if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) {
573  if (!(VirtualBase= VirtualBase->getDefinition()))
574  continue;
575  if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP))
576  return cloneFullComment(FC, D);
577  }
578  }
579  }
580  return nullptr;
581  }
582 
583  // If the RawComment was attached to other redeclaration of this Decl, we
584  // should parse the comment in context of that other Decl. This is important
585  // because comments can contain references to parameter names which can be
586  // different across redeclarations.
587  if (D != OriginalDecl)
588  return getCommentForDecl(OriginalDecl, PP);
589 
590  comments::FullComment *FC = RC->parse(*this, PP, D);
591  ParsedComments[Canonical] = FC;
592  return FC;
593 }
594 
595 void
596 ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
597  TemplateTemplateParmDecl *Parm) {
598  ID.AddInteger(Parm->getDepth());
599  ID.AddInteger(Parm->getPosition());
600  ID.AddBoolean(Parm->isParameterPack());
601 
603  ID.AddInteger(Params->size());
605  PEnd = Params->end();
606  P != PEnd; ++P) {
607  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
608  ID.AddInteger(0);
609  ID.AddBoolean(TTP->isParameterPack());
610  continue;
611  }
612 
613  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
614  ID.AddInteger(1);
615  ID.AddBoolean(NTTP->isParameterPack());
616  ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
617  if (NTTP->isExpandedParameterPack()) {
618  ID.AddBoolean(true);
619  ID.AddInteger(NTTP->getNumExpansionTypes());
620  for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
621  QualType T = NTTP->getExpansionType(I);
622  ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
623  }
624  } else
625  ID.AddBoolean(false);
626  continue;
627  }
628 
629  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
630  ID.AddInteger(2);
631  Profile(ID, TTP);
632  }
633 }
634 
636 ASTContext::getCanonicalTemplateTemplateParmDecl(
637  TemplateTemplateParmDecl *TTP) const {
638  // Check if we already have a canonical template template parameter.
639  llvm::FoldingSetNodeID ID;
640  CanonicalTemplateTemplateParm::Profile(ID, TTP);
641  void *InsertPos = nullptr;
642  CanonicalTemplateTemplateParm *Canonical
643  = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
644  if (Canonical)
645  return Canonical->getParam();
646 
647  // Build a canonical template parameter list.
649  SmallVector<NamedDecl *, 4> CanonParams;
650  CanonParams.reserve(Params->size());
652  PEnd = Params->end();
653  P != PEnd; ++P) {
654  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P))
655  CanonParams.push_back(
657  SourceLocation(),
658  SourceLocation(),
659  TTP->getDepth(),
660  TTP->getIndex(), nullptr, false,
661  TTP->isParameterPack()));
662  else if (NonTypeTemplateParmDecl *NTTP
663  = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
664  QualType T = getCanonicalType(NTTP->getType());
667  if (NTTP->isExpandedParameterPack()) {
668  SmallVector<QualType, 2> ExpandedTypes;
669  SmallVector<TypeSourceInfo *, 2> ExpandedTInfos;
670  for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
671  ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I)));
672  ExpandedTInfos.push_back(
673  getTrivialTypeSourceInfo(ExpandedTypes.back()));
674  }
675 
677  SourceLocation(),
678  SourceLocation(),
679  NTTP->getDepth(),
680  NTTP->getPosition(), nullptr,
681  T,
682  TInfo,
683  ExpandedTypes,
684  ExpandedTInfos);
685  } else {
687  SourceLocation(),
688  SourceLocation(),
689  NTTP->getDepth(),
690  NTTP->getPosition(), nullptr,
691  T,
692  NTTP->isParameterPack(),
693  TInfo);
694  }
695  CanonParams.push_back(Param);
696 
697  } else
698  CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
699  cast<TemplateTemplateParmDecl>(*P)));
700  }
701 
702  assert(!TTP->getRequiresClause() &&
703  "Unexpected requires-clause on template template-parameter");
704  Expr *const CanonRequiresClause = nullptr;
705 
706  TemplateTemplateParmDecl *CanonTTP
708  SourceLocation(), TTP->getDepth(),
709  TTP->getPosition(),
710  TTP->isParameterPack(),
711  nullptr,
713  SourceLocation(),
714  CanonParams,
715  SourceLocation(),
716  CanonRequiresClause));
717 
718  // Get the new insert position for the node we care about.
719  Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
720  assert(!Canonical && "Shouldn't be in the map!");
721  (void)Canonical;
722 
723  // Create the canonical template template parameter entry.
724  Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);
725  CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
726  return CanonTTP;
727 }
728 
729 CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
730  if (!LangOpts.CPlusPlus) return nullptr;
731 
732  switch (T.getCXXABI().getKind()) {
733  case TargetCXXABI::GenericARM: // Same as Itanium at this level
734  case TargetCXXABI::iOS:
735  case TargetCXXABI::iOS64:
741  return CreateItaniumCXXABI(*this);
743  return CreateMicrosoftCXXABI(*this);
744  }
745  llvm_unreachable("Invalid CXXABI type!");
746 }
747 
748 static const LangASMap *getAddressSpaceMap(const TargetInfo &T,
749  const LangOptions &LOpts) {
750  if (LOpts.FakeAddressSpaceMap) {
751  // The fake address space map must have a distinct entry for each
752  // language-specific address space.
753  static const unsigned FakeAddrSpaceMap[] = {
754  0, // Default
755  1, // opencl_global
756  3, // opencl_local
757  2, // opencl_constant
758  0, // opencl_private
759  4, // opencl_generic
760  5, // cuda_device
761  6, // cuda_constant
762  7 // cuda_shared
763  };
764  return &FakeAddrSpaceMap;
765  } else {
766  return &T.getAddressSpaceMap();
767  }
768 }
769 
771  const LangOptions &LangOpts) {
772  switch (LangOpts.getAddressSpaceMapMangling()) {
774  return TI.useAddressSpaceMapMangling();
776  return true;
778  return false;
779  }
780  llvm_unreachable("getAddressSpaceMapMangling() doesn't cover anything.");
781 }
782 
784  IdentifierTable &idents, SelectorTable &sels,
785  Builtin::Context &builtins)
786  : FunctionProtoTypes(this_()), TemplateSpecializationTypes(this_()),
787  DependentTemplateSpecializationTypes(this_()),
788  SubstTemplateTemplateParmPacks(this_()), SourceMgr(SM), LangOpts(LOpts),
789  SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
790  XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
791  LangOpts.XRayNeverInstrumentFiles, SM)),
792  PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
793  BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
794  CommentCommandTraits(BumpAlloc, LOpts.CommentOpts), LastSDM(nullptr, 0) {
795  TUDecl = TranslationUnitDecl::Create(*this);
796 }
797 
799  ReleaseParentMapEntries();
800 
801  // Release the DenseMaps associated with DeclContext objects.
802  // FIXME: Is this the ideal solution?
803  ReleaseDeclContextMaps();
804 
805  // Call all of the deallocation functions on all of their targets.
806  for (auto &Pair : Deallocations)
807  (Pair.first)(Pair.second);
808 
809  // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed
810  // because they can contain DenseMaps.
811  for (llvm::DenseMap<const ObjCContainerDecl*,
812  const ASTRecordLayout*>::iterator
813  I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
814  // Increment in loop to prevent using deallocated memory.
815  if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second))
816  R->Destroy(*this);
817 
818  for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
819  I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
820  // Increment in loop to prevent using deallocated memory.
821  if (ASTRecordLayout *R = const_cast<ASTRecordLayout*>((I++)->second))
822  R->Destroy(*this);
823  }
824 
825  for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
826  AEnd = DeclAttrs.end();
827  A != AEnd; ++A)
828  A->second->~AttrVec();
829 
830  for (std::pair<const MaterializeTemporaryExpr *, APValue *> &MTVPair :
831  MaterializedTemporaryValues)
832  MTVPair.second->~APValue();
833 
834  for (const auto &Value : ModuleInitializers)
835  Value.second->~PerModuleInitializers();
836 }
837 
838 void ASTContext::ReleaseParentMapEntries() {
839  if (!PointerParents) return;
840  for (const auto &Entry : *PointerParents) {
841  if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
842  delete Entry.second.get<ast_type_traits::DynTypedNode *>();
843  } else if (Entry.second.is<ParentVector *>()) {
844  delete Entry.second.get<ParentVector *>();
845  }
846  }
847  for (const auto &Entry : *OtherParents) {
848  if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
849  delete Entry.second.get<ast_type_traits::DynTypedNode *>();
850  } else if (Entry.second.is<ParentVector *>()) {
851  delete Entry.second.get<ParentVector *>();
852  }
853  }
854 }
855 
856 void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) {
857  Deallocations.push_back({Callback, Data});
858 }
859 
860 void
862  ExternalSource = std::move(Source);
863 }
864 
866  llvm::errs() << "\n*** AST Context Stats:\n";
867  llvm::errs() << " " << Types.size() << " types total.\n";
868 
869  unsigned counts[] = {
870 #define TYPE(Name, Parent) 0,
871 #define ABSTRACT_TYPE(Name, Parent)
872 #include "clang/AST/TypeNodes.def"
873  0 // Extra
874  };
875 
876  for (unsigned i = 0, e = Types.size(); i != e; ++i) {
877  Type *T = Types[i];
878  counts[(unsigned)T->getTypeClass()]++;
879  }
880 
881  unsigned Idx = 0;
882  unsigned TotalBytes = 0;
883 #define TYPE(Name, Parent) \
884  if (counts[Idx]) \
885  llvm::errs() << " " << counts[Idx] << " " << #Name \
886  << " types\n"; \
887  TotalBytes += counts[Idx] * sizeof(Name##Type); \
888  ++Idx;
889 #define ABSTRACT_TYPE(Name, Parent)
890 #include "clang/AST/TypeNodes.def"
891 
892  llvm::errs() << "Total bytes = " << TotalBytes << "\n";
893 
894  // Implicit special member functions.
895  llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/"
897  << " implicit default constructors created\n";
898  llvm::errs() << NumImplicitCopyConstructorsDeclared << "/"
900  << " implicit copy constructors created\n";
901  if (getLangOpts().CPlusPlus)
902  llvm::errs() << NumImplicitMoveConstructorsDeclared << "/"
904  << " implicit move constructors created\n";
905  llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/"
907  << " implicit copy assignment operators created\n";
908  if (getLangOpts().CPlusPlus)
909  llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/"
911  << " implicit move assignment operators created\n";
912  llvm::errs() << NumImplicitDestructorsDeclared << "/"
914  << " implicit destructors created\n";
915 
916  if (ExternalSource) {
917  llvm::errs() << "\n";
918  ExternalSource->PrintStats();
919  }
920 
921  BumpAlloc.PrintStats();
922 }
923 
925  bool NotifyListeners) {
926  if (NotifyListeners)
927  if (auto *Listener = getASTMutationListener())
929 
930  if (getLangOpts().ModulesLocalVisibility)
931  MergedDefModules[ND].push_back(M);
932  else
934 }
935 
937  auto It = MergedDefModules.find(ND);
938  if (It == MergedDefModules.end())
939  return;
940 
941  auto &Merged = It->second;
943  for (Module *&M : Merged)
944  if (!Found.insert(M).second)
945  M = nullptr;
946  Merged.erase(std::remove(Merged.begin(), Merged.end(), nullptr), Merged.end());
947 }
948 
949 void ASTContext::PerModuleInitializers::resolve(ASTContext &Ctx) {
950  if (LazyInitializers.empty())
951  return;
952 
953  auto *Source = Ctx.getExternalSource();
954  assert(Source && "lazy initializers but no external source");
955 
956  auto LazyInits = std::move(LazyInitializers);
957  LazyInitializers.clear();
958 
959  for (auto ID : LazyInits)
960  Initializers.push_back(Source->GetExternalDecl(ID));
961 
962  assert(LazyInitializers.empty() &&
963  "GetExternalDecl for lazy module initializer added more inits");
964 }
965 
967  // One special case: if we add a module initializer that imports another
968  // module, and that module's only initializer is an ImportDecl, simplify.
969  if (auto *ID = dyn_cast<ImportDecl>(D)) {
970  auto It = ModuleInitializers.find(ID->getImportedModule());
971 
972  // Maybe the ImportDecl does nothing at all. (Common case.)
973  if (It == ModuleInitializers.end())
974  return;
975 
976  // Maybe the ImportDecl only imports another ImportDecl.
977  auto &Imported = *It->second;
978  if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
979  Imported.resolve(*this);
980  auto *OnlyDecl = Imported.Initializers.front();
981  if (isa<ImportDecl>(OnlyDecl))
982  D = OnlyDecl;
983  }
984  }
985 
986  auto *&Inits = ModuleInitializers[M];
987  if (!Inits)
988  Inits = new (*this) PerModuleInitializers;
989  Inits->Initializers.push_back(D);
990 }
991 
993  auto *&Inits = ModuleInitializers[M];
994  if (!Inits)
995  Inits = new (*this) PerModuleInitializers;
996  Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
997  IDs.begin(), IDs.end());
998 }
999 
1001  auto It = ModuleInitializers.find(M);
1002  if (It == ModuleInitializers.end())
1003  return None;
1004 
1005  auto *Inits = It->second;
1006  Inits->resolve(*this);
1007  return Inits->Initializers;
1008 }
1009 
1011  if (!ExternCContext)
1012  ExternCContext = ExternCContextDecl::Create(*this, getTranslationUnitDecl());
1013 
1014  return ExternCContext;
1015 }
1016 
1019  const IdentifierInfo *II) const {
1020  auto *BuiltinTemplate = BuiltinTemplateDecl::Create(*this, TUDecl, II, BTK);
1021  BuiltinTemplate->setImplicit();
1022  TUDecl->addDecl(BuiltinTemplate);
1023 
1024  return BuiltinTemplate;
1025 }
1026 
1029  if (!MakeIntegerSeqDecl)
1030  MakeIntegerSeqDecl = buildBuiltinTemplateDecl(BTK__make_integer_seq,
1032  return MakeIntegerSeqDecl;
1033 }
1034 
1037  if (!TypePackElementDecl)
1038  TypePackElementDecl = buildBuiltinTemplateDecl(BTK__type_pack_element,
1040  return TypePackElementDecl;
1041 }
1042 
1044  RecordDecl::TagKind TK) const {
1045  SourceLocation Loc;
1046  RecordDecl *NewDecl;
1047  if (getLangOpts().CPlusPlus)
1048  NewDecl = CXXRecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc,
1049  Loc, &Idents.get(Name));
1050  else
1051  NewDecl = RecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc, Loc,
1052  &Idents.get(Name));
1053  NewDecl->setImplicit();
1054  NewDecl->addAttr(TypeVisibilityAttr::CreateImplicit(
1055  const_cast<ASTContext &>(*this), TypeVisibilityAttr::Default));
1056  return NewDecl;
1057 }
1058 
1060  StringRef Name) const {
1062  TypedefDecl *NewDecl = TypedefDecl::Create(
1063  const_cast<ASTContext &>(*this), getTranslationUnitDecl(),
1064  SourceLocation(), SourceLocation(), &Idents.get(Name), TInfo);
1065  NewDecl->setImplicit();
1066  return NewDecl;
1067 }
1068 
1070  if (!Int128Decl)
1071  Int128Decl = buildImplicitTypedef(Int128Ty, "__int128_t");
1072  return Int128Decl;
1073 }
1074 
1076  if (!UInt128Decl)
1077  UInt128Decl = buildImplicitTypedef(UnsignedInt128Ty, "__uint128_t");
1078  return UInt128Decl;
1079 }
1080 
1081 void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
1082  BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K);
1083  R = CanQualType::CreateUnsafe(QualType(Ty, 0));
1084  Types.push_back(Ty);
1085 }
1086 
1088  const TargetInfo *AuxTarget) {
1089  assert((!this->Target || this->Target == &Target) &&
1090  "Incorrect target reinitialization");
1091  assert(VoidTy.isNull() && "Context reinitialized?");
1092 
1093  this->Target = &Target;
1094  this->AuxTarget = AuxTarget;
1095 
1096  ABI.reset(createCXXABI(Target));
1097  AddrSpaceMap = getAddressSpaceMap(Target, LangOpts);
1098  AddrSpaceMapMangling = isAddrSpaceMapManglingEnabled(Target, LangOpts);
1099 
1100  // C99 6.2.5p19.
1101  InitBuiltinType(VoidTy, BuiltinType::Void);
1102 
1103  // C99 6.2.5p2.
1104  InitBuiltinType(BoolTy, BuiltinType::Bool);
1105  // C99 6.2.5p3.
1106  if (LangOpts.CharIsSigned)
1107  InitBuiltinType(CharTy, BuiltinType::Char_S);
1108  else
1109  InitBuiltinType(CharTy, BuiltinType::Char_U);
1110  // C99 6.2.5p4.
1111  InitBuiltinType(SignedCharTy, BuiltinType::SChar);
1112  InitBuiltinType(ShortTy, BuiltinType::Short);
1113  InitBuiltinType(IntTy, BuiltinType::Int);
1114  InitBuiltinType(LongTy, BuiltinType::Long);
1115  InitBuiltinType(LongLongTy, BuiltinType::LongLong);
1116 
1117  // C99 6.2.5p6.
1118  InitBuiltinType(UnsignedCharTy, BuiltinType::UChar);
1119  InitBuiltinType(UnsignedShortTy, BuiltinType::UShort);
1120  InitBuiltinType(UnsignedIntTy, BuiltinType::UInt);
1121  InitBuiltinType(UnsignedLongTy, BuiltinType::ULong);
1122  InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong);
1123 
1124  // C99 6.2.5p10.
1125  InitBuiltinType(FloatTy, BuiltinType::Float);
1126  InitBuiltinType(DoubleTy, BuiltinType::Double);
1127  InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble);
1128 
1129  // GNU extension, __float128 for IEEE quadruple precision
1130  InitBuiltinType(Float128Ty, BuiltinType::Float128);
1131 
1132  // C11 extension ISO/IEC TS 18661-3
1133  InitBuiltinType(Float16Ty, BuiltinType::Float16);
1134 
1135  // GNU extension, 128-bit integers.
1136  InitBuiltinType(Int128Ty, BuiltinType::Int128);
1137  InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128);
1138 
1139  // C++ 3.9.1p5
1140  if (TargetInfo::isTypeSigned(Target.getWCharType()))
1141  InitBuiltinType(WCharTy, BuiltinType::WChar_S);
1142  else // -fshort-wchar makes wchar_t be unsigned.
1143  InitBuiltinType(WCharTy, BuiltinType::WChar_U);
1144  if (LangOpts.CPlusPlus && LangOpts.WChar)
1145  WideCharTy = WCharTy;
1146  else {
1147  // C99 (or C++ using -fno-wchar).
1148  WideCharTy = getFromTargetType(Target.getWCharType());
1149  }
1150 
1151  WIntTy = getFromTargetType(Target.getWIntType());
1152 
1153  if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
1154  InitBuiltinType(Char16Ty, BuiltinType::Char16);
1155  else // C99
1156  Char16Ty = getFromTargetType(Target.getChar16Type());
1157 
1158  if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
1159  InitBuiltinType(Char32Ty, BuiltinType::Char32);
1160  else // C99
1161  Char32Ty = getFromTargetType(Target.getChar32Type());
1162 
1163  // Placeholder type for type-dependent expressions whose type is
1164  // completely unknown. No code should ever check a type against
1165  // DependentTy and users should never see it; however, it is here to
1166  // help diagnose failures to properly check for type-dependent
1167  // expressions.
1168  InitBuiltinType(DependentTy, BuiltinType::Dependent);
1169 
1170  // Placeholder type for functions.
1171  InitBuiltinType(OverloadTy, BuiltinType::Overload);
1172 
1173  // Placeholder type for bound members.
1174  InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember);
1175 
1176  // Placeholder type for pseudo-objects.
1177  InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject);
1178 
1179  // "any" type; useful for debugger-like clients.
1180  InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny);
1181 
1182  // Placeholder type for unbridged ARC casts.
1183  InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast);
1184 
1185  // Placeholder type for builtin functions.
1186  InitBuiltinType(BuiltinFnTy, BuiltinType::BuiltinFn);
1187 
1188  // Placeholder type for OMP array sections.
1189  if (LangOpts.OpenMP)
1190  InitBuiltinType(OMPArraySectionTy, BuiltinType::OMPArraySection);
1191 
1192  // C99 6.2.5p11.
1197 
1198  // Builtin types for 'id', 'Class', and 'SEL'.
1199  InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
1200  InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
1201  InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);
1202 
1203  if (LangOpts.OpenCL) {
1204 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1205  InitBuiltinType(SingletonId, BuiltinType::Id);
1206 #include "clang/Basic/OpenCLImageTypes.def"
1207 
1208  InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler);
1209  InitBuiltinType(OCLEventTy, BuiltinType::OCLEvent);
1210  InitBuiltinType(OCLClkEventTy, BuiltinType::OCLClkEvent);
1211  InitBuiltinType(OCLQueueTy, BuiltinType::OCLQueue);
1212  InitBuiltinType(OCLReserveIDTy, BuiltinType::OCLReserveID);
1213  }
1214 
1215  // Builtin type for __objc_yes and __objc_no
1216  ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ?
1217  SignedCharTy : BoolTy);
1218 
1219  ObjCConstantStringType = QualType();
1220 
1221  ObjCSuperType = QualType();
1222 
1223  // void * type
1224  if (LangOpts.OpenCLVersion >= 200) {
1225  auto Q = VoidTy.getQualifiers();
1229  } else {
1231  }
1232 
1233  // nullptr type (C++0x 2.14.7)
1234  InitBuiltinType(NullPtrTy, BuiltinType::NullPtr);
1235 
1236  // half type (OpenCL 6.1.1.1) / ARM NEON __fp16
1237  InitBuiltinType(HalfTy, BuiltinType::Half);
1238 
1239  // Builtin type used to help define __builtin_va_list.
1240  VaListTagDecl = nullptr;
1241 }
1242 
1244  return SourceMgr.getDiagnostics();
1245 }
1246 
1248  AttrVec *&Result = DeclAttrs[D];
1249  if (!Result) {
1250  void *Mem = Allocate(sizeof(AttrVec));
1251  Result = new (Mem) AttrVec;
1252  }
1253 
1254  return *Result;
1255 }
1256 
1257 /// \brief Erase the attributes corresponding to the given declaration.
1259  llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
1260  if (Pos != DeclAttrs.end()) {
1261  Pos->second->~AttrVec();
1262  DeclAttrs.erase(Pos);
1263  }
1264 }
1265 
1266 // FIXME: Remove ?
1269  assert(Var->isStaticDataMember() && "Not a static data member");
1271  .dyn_cast<MemberSpecializationInfo *>();
1272 }
1273 
1276  llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
1277  TemplateOrInstantiation.find(Var);
1278  if (Pos == TemplateOrInstantiation.end())
1280 
1281  return Pos->second;
1282 }
1283 
1284 void
1287  SourceLocation PointOfInstantiation) {
1288  assert(Inst->isStaticDataMember() && "Not a static data member");
1289  assert(Tmpl->isStaticDataMember() && "Not a static data member");
1291  Tmpl, TSK, PointOfInstantiation));
1292 }
1293 
1294 void
1297  assert(!TemplateOrInstantiation[Inst] &&
1298  "Already noted what the variable was instantiated from");
1299  TemplateOrInstantiation[Inst] = TSI;
1300 }
1301 
1303  const FunctionDecl *FD){
1304  assert(FD && "Specialization is 0");
1305  llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos
1306  = ClassScopeSpecializationPattern.find(FD);
1307  if (Pos == ClassScopeSpecializationPattern.end())
1308  return nullptr;
1309 
1310  return Pos->second;
1311 }
1312 
1314  FunctionDecl *Pattern) {
1315  assert(FD && "Specialization is 0");
1316  assert(Pattern && "Class scope specialization pattern is 0");
1317  ClassScopeSpecializationPattern[FD] = Pattern;
1318 }
1319 
1320 NamedDecl *
1322  auto Pos = InstantiatedFromUsingDecl.find(UUD);
1323  if (Pos == InstantiatedFromUsingDecl.end())
1324  return nullptr;
1325 
1326  return Pos->second;
1327 }
1328 
1329 void
1331  assert((isa<UsingDecl>(Pattern) ||
1332  isa<UnresolvedUsingValueDecl>(Pattern) ||
1333  isa<UnresolvedUsingTypenameDecl>(Pattern)) &&
1334  "pattern decl is not a using decl");
1335  assert((isa<UsingDecl>(Inst) ||
1336  isa<UnresolvedUsingValueDecl>(Inst) ||
1337  isa<UnresolvedUsingTypenameDecl>(Inst)) &&
1338  "instantiation did not produce a using decl");
1339  assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists");
1340  InstantiatedFromUsingDecl[Inst] = Pattern;
1341 }
1342 
1345  llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
1346  = InstantiatedFromUsingShadowDecl.find(Inst);
1347  if (Pos == InstantiatedFromUsingShadowDecl.end())
1348  return nullptr;
1349 
1350  return Pos->second;
1351 }
1352 
1353 void
1355  UsingShadowDecl *Pattern) {
1356  assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists");
1357  InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1358 }
1359 
1361  llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
1362  = InstantiatedFromUnnamedFieldDecl.find(Field);
1363  if (Pos == InstantiatedFromUnnamedFieldDecl.end())
1364  return nullptr;
1365 
1366  return Pos->second;
1367 }
1368 
1370  FieldDecl *Tmpl) {
1371  assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed");
1372  assert(!Tmpl->getDeclName() && "Template field decl is not unnamed");
1373  assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
1374  "Already noted what unnamed field was instantiated from");
1375 
1376  InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1377 }
1378 
1381  return overridden_methods(Method).begin();
1382 }
1383 
1386  return overridden_methods(Method).end();
1387 }
1388 
1389 unsigned
1391  auto Range = overridden_methods(Method);
1392  return Range.end() - Range.begin();
1393 }
1394 
1397  llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
1398  OverriddenMethods.find(Method->getCanonicalDecl());
1399  if (Pos == OverriddenMethods.end())
1400  return overridden_method_range(nullptr, nullptr);
1401  return overridden_method_range(Pos->second.begin(), Pos->second.end());
1402 }
1403 
1405  const CXXMethodDecl *Overridden) {
1406  assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl());
1407  OverriddenMethods[Method].push_back(Overridden);
1408 }
1409 
1411  const NamedDecl *D,
1412  SmallVectorImpl<const NamedDecl *> &Overridden) const {
1413  assert(D);
1414 
1415  if (const CXXMethodDecl *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
1416  Overridden.append(overridden_methods_begin(CXXMethod),
1417  overridden_methods_end(CXXMethod));
1418  return;
1419  }
1420 
1421  const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D);
1422  if (!Method)
1423  return;
1424 
1426  Method->getOverriddenMethods(OverDecls);
1427  Overridden.append(OverDecls.begin(), OverDecls.end());
1428 }
1429 
1431  assert(!Import->NextLocalImport && "Import declaration already in the chain");
1432  assert(!Import->isFromASTFile() && "Non-local import declaration");
1433  if (!FirstLocalImport) {
1434  FirstLocalImport = Import;
1435  LastLocalImport = Import;
1436  return;
1437  }
1438 
1439  LastLocalImport->NextLocalImport = Import;
1440  LastLocalImport = Import;
1441 }
1442 
1443 //===----------------------------------------------------------------------===//
1444 // Type Sizing and Analysis
1445 //===----------------------------------------------------------------------===//
1446 
1447 /// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
1448 /// scalar floating point type.
1449 const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
1450  const BuiltinType *BT = T->getAs<BuiltinType>();
1451  assert(BT && "Not a floating point type!");
1452  switch (BT->getKind()) {
1453  default: llvm_unreachable("Not a floating point type!");
1454  case BuiltinType::Float16:
1455  case BuiltinType::Half:
1456  return Target->getHalfFormat();
1457  case BuiltinType::Float: return Target->getFloatFormat();
1458  case BuiltinType::Double: return Target->getDoubleFormat();
1459  case BuiltinType::LongDouble: return Target->getLongDoubleFormat();
1460  case BuiltinType::Float128: return Target->getFloat128Format();
1461  }
1462 }
1463 
1464 CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
1465  unsigned Align = Target->getCharWidth();
1466 
1467  bool UseAlignAttrOnly = false;
1468  if (unsigned AlignFromAttr = D->getMaxAlignment()) {
1469  Align = AlignFromAttr;
1470 
1471  // __attribute__((aligned)) can increase or decrease alignment
1472  // *except* on a struct or struct member, where it only increases
1473  // alignment unless 'packed' is also specified.
1474  //
1475  // It is an error for alignas to decrease alignment, so we can
1476  // ignore that possibility; Sema should diagnose it.
1477  if (isa<FieldDecl>(D)) {
1478  UseAlignAttrOnly = D->hasAttr<PackedAttr>() ||
1479  cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1480  } else {
1481  UseAlignAttrOnly = true;
1482  }
1483  }
1484  else if (isa<FieldDecl>(D))
1485  UseAlignAttrOnly =
1486  D->hasAttr<PackedAttr>() ||
1487  cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1488 
1489  // If we're using the align attribute only, just ignore everything
1490  // else about the declaration and its type.
1491  if (UseAlignAttrOnly) {
1492  // do nothing
1493  } else if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) {
1494  QualType T = VD->getType();
1495  if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
1496  if (ForAlignof)
1497  T = RT->getPointeeType();
1498  else
1499  T = getPointerType(RT->getPointeeType());
1500  }
1501  QualType BaseT = getBaseElementType(T);
1502  if (T->isFunctionType())
1503  Align = getTypeInfoImpl(T.getTypePtr()).Align;
1504  else if (!BaseT->isIncompleteType()) {
1505  // Adjust alignments of declarations with array type by the
1506  // large-array alignment on the target.
1507  if (const ArrayType *arrayType = getAsArrayType(T)) {
1508  unsigned MinWidth = Target->getLargeArrayMinWidth();
1509  if (!ForAlignof && MinWidth) {
1510  if (isa<VariableArrayType>(arrayType))
1511  Align = std::max(Align, Target->getLargeArrayAlign());
1512  else if (isa<ConstantArrayType>(arrayType) &&
1513  MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType)))
1514  Align = std::max(Align, Target->getLargeArrayAlign());
1515  }
1516  }
1517  Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
1518  if (BaseT.getQualifiers().hasUnaligned())
1519  Align = Target->getCharWidth();
1520  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1521  if (VD->hasGlobalStorage() && !ForAlignof)
1522  Align = std::max(Align, getTargetInfo().getMinGlobalAlign());
1523  }
1524  }
1525 
1526  // Fields can be subject to extra alignment constraints, like if
1527  // the field is packed, the struct is packed, or the struct has a
1528  // a max-field-alignment constraint (#pragma pack). So calculate
1529  // the actual alignment of the field within the struct, and then
1530  // (as we're expected to) constrain that by the alignment of the type.
1531  if (const FieldDecl *Field = dyn_cast<FieldDecl>(VD)) {
1532  const RecordDecl *Parent = Field->getParent();
1533  // We can only produce a sensible answer if the record is valid.
1534  if (!Parent->isInvalidDecl()) {
1535  const ASTRecordLayout &Layout = getASTRecordLayout(Parent);
1536 
1537  // Start with the record's overall alignment.
1538  unsigned FieldAlign = toBits(Layout.getAlignment());
1539 
1540  // Use the GCD of that and the offset within the record.
1541  uint64_t Offset = Layout.getFieldOffset(Field->getFieldIndex());
1542  if (Offset > 0) {
1543  // Alignment is always a power of 2, so the GCD will be a power of 2,
1544  // which means we get to do this crazy thing instead of Euclid's.
1545  uint64_t LowBitOfOffset = Offset & (~Offset + 1);
1546  if (LowBitOfOffset < FieldAlign)
1547  FieldAlign = static_cast<unsigned>(LowBitOfOffset);
1548  }
1549 
1550  Align = std::min(Align, FieldAlign);
1551  }
1552  }
1553  }
1554 
1555  return toCharUnitsFromBits(Align);
1556 }
1557 
1558 // getTypeInfoDataSizeInChars - Return the size of a type, in
1559 // chars. If the type is a record, its data size is returned. This is
1560 // the size of the memcpy that's performed when assigning this type
1561 // using a trivial copy/move assignment operator.
1562 std::pair<CharUnits, CharUnits>
1564  std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T);
1565 
1566  // In C++, objects can sometimes be allocated into the tail padding
1567  // of a base-class subobject. We decide whether that's possible
1568  // during class layout, so here we can just trust the layout results.
1569  if (getLangOpts().CPlusPlus) {
1570  if (const RecordType *RT = T->getAs<RecordType>()) {
1571  const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl());
1572  sizeAndAlign.first = layout.getDataSize();
1573  }
1574  }
1575 
1576  return sizeAndAlign;
1577 }
1578 
1579 /// getConstantArrayInfoInChars - Performing the computation in CharUnits
1580 /// instead of in bits prevents overflowing the uint64_t for some large arrays.
1581 std::pair<CharUnits, CharUnits>
1583  const ConstantArrayType *CAT) {
1584  std::pair<CharUnits, CharUnits> EltInfo =
1585  Context.getTypeInfoInChars(CAT->getElementType());
1586  uint64_t Size = CAT->getSize().getZExtValue();
1587  assert((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <=
1588  (uint64_t)(-1)/Size) &&
1589  "Overflow in array type char size evaluation");
1590  uint64_t Width = EltInfo.first.getQuantity() * Size;
1591  unsigned Align = EltInfo.second.getQuantity();
1592  if (!Context.getTargetInfo().getCXXABI().isMicrosoft() ||
1593  Context.getTargetInfo().getPointerWidth(0) == 64)
1594  Width = llvm::alignTo(Width, Align);
1595  return std::make_pair(CharUnits::fromQuantity(Width),
1596  CharUnits::fromQuantity(Align));
1597 }
1598 
1599 std::pair<CharUnits, CharUnits>
1601  if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(T))
1602  return getConstantArrayInfoInChars(*this, CAT);
1603  TypeInfo Info = getTypeInfo(T);
1604  return std::make_pair(toCharUnitsFromBits(Info.Width),
1605  toCharUnitsFromBits(Info.Align));
1606 }
1607 
1608 std::pair<CharUnits, CharUnits>
1610  return getTypeInfoInChars(T.getTypePtr());
1611 }
1612 
1614  return getTypeInfo(T).AlignIsRequired;
1615 }
1616 
1618  return isAlignmentRequired(T.getTypePtr());
1619 }
1620 
1622  // An alignment on a typedef overrides anything else.
1623  if (auto *TT = T->getAs<TypedefType>())
1624  if (unsigned Align = TT->getDecl()->getMaxAlignment())
1625  return Align;
1626 
1627  // If we have an (array of) complete type, we're done.
1628  T = getBaseElementType(T);
1629  if (!T->isIncompleteType())
1630  return getTypeAlign(T);
1631 
1632  // If we had an array type, its element type might be a typedef
1633  // type with an alignment attribute.
1634  if (auto *TT = T->getAs<TypedefType>())
1635  if (unsigned Align = TT->getDecl()->getMaxAlignment())
1636  return Align;
1637 
1638  // Otherwise, see if the declaration of the type had an attribute.
1639  if (auto *TT = T->getAs<TagType>())
1640  return TT->getDecl()->getMaxAlignment();
1641 
1642  return 0;
1643 }
1644 
1646  TypeInfoMap::iterator I = MemoizedTypeInfo.find(T);
1647  if (I != MemoizedTypeInfo.end())
1648  return I->second;
1649 
1650  // This call can invalidate MemoizedTypeInfo[T], so we need a second lookup.
1651  TypeInfo TI = getTypeInfoImpl(T);
1652  MemoizedTypeInfo[T] = TI;
1653  return TI;
1654 }
1655 
1656 /// getTypeInfoImpl - Return the size of the specified type, in bits. This
1657 /// method does not work on incomplete types.
1658 ///
1659 /// FIXME: Pointers into different addr spaces could have different sizes and
1660 /// alignment requirements: getPointerInfo should take an AddrSpace, this
1661 /// should take a QualType, &c.
1662 TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
1663  uint64_t Width = 0;
1664  unsigned Align = 8;
1665  bool AlignIsRequired = false;
1666  unsigned AS = 0;
1667  switch (T->getTypeClass()) {
1668 #define TYPE(Class, Base)
1669 #define ABSTRACT_TYPE(Class, Base)
1670 #define NON_CANONICAL_TYPE(Class, Base)
1671 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
1672 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \
1673  case Type::Class: \
1674  assert(!T->isDependentType() && "should not see dependent types here"); \
1675  return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
1676 #include "clang/AST/TypeNodes.def"
1677  llvm_unreachable("Should not see dependent types");
1678 
1679  case Type::FunctionNoProto:
1680  case Type::FunctionProto:
1681  // GCC extension: alignof(function) = 32 bits
1682  Width = 0;
1683  Align = 32;
1684  break;
1685 
1686  case Type::IncompleteArray:
1687  case Type::VariableArray:
1688  Width = 0;
1689  Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
1690  break;
1691 
1692  case Type::ConstantArray: {
1693  const ConstantArrayType *CAT = cast<ConstantArrayType>(T);
1694 
1695  TypeInfo EltInfo = getTypeInfo(CAT->getElementType());
1696  uint64_t Size = CAT->getSize().getZExtValue();
1697  assert((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&
1698  "Overflow in array type bit size evaluation");
1699  Width = EltInfo.Width * Size;
1700  Align = EltInfo.Align;
1701  if (!getTargetInfo().getCXXABI().isMicrosoft() ||
1702  getTargetInfo().getPointerWidth(0) == 64)
1703  Width = llvm::alignTo(Width, Align);
1704  break;
1705  }
1706  case Type::ExtVector:
1707  case Type::Vector: {
1708  const VectorType *VT = cast<VectorType>(T);
1709  TypeInfo EltInfo = getTypeInfo(VT->getElementType());
1710  Width = EltInfo.Width * VT->getNumElements();
1711  Align = Width;
1712  // If the alignment is not a power of 2, round up to the next power of 2.
1713  // This happens for non-power-of-2 length vectors.
1714  if (Align & (Align-1)) {
1715  Align = llvm::NextPowerOf2(Align);
1716  Width = llvm::alignTo(Width, Align);
1717  }
1718  // Adjust the alignment based on the target max.
1719  uint64_t TargetVectorAlign = Target->getMaxVectorAlign();
1720  if (TargetVectorAlign && TargetVectorAlign < Align)
1721  Align = TargetVectorAlign;
1722  break;
1723  }
1724 
1725  case Type::Builtin:
1726  switch (cast<BuiltinType>(T)->getKind()) {
1727  default: llvm_unreachable("Unknown builtin type!");
1728  case BuiltinType::Void:
1729  // GCC extension: alignof(void) = 8 bits.
1730  Width = 0;
1731  Align = 8;
1732  break;
1733  case BuiltinType::Bool:
1734  Width = Target->getBoolWidth();
1735  Align = Target->getBoolAlign();
1736  break;
1737  case BuiltinType::Char_S:
1738  case BuiltinType::Char_U:
1739  case BuiltinType::UChar:
1740  case BuiltinType::SChar:
1741  Width = Target->getCharWidth();
1742  Align = Target->getCharAlign();
1743  break;
1744  case BuiltinType::WChar_S:
1745  case BuiltinType::WChar_U:
1746  Width = Target->getWCharWidth();
1747  Align = Target->getWCharAlign();
1748  break;
1749  case BuiltinType::Char16:
1750  Width = Target->getChar16Width();
1751  Align = Target->getChar16Align();
1752  break;
1753  case BuiltinType::Char32:
1754  Width = Target->getChar32Width();
1755  Align = Target->getChar32Align();
1756  break;
1757  case BuiltinType::UShort:
1758  case BuiltinType::Short:
1759  Width = Target->getShortWidth();
1760  Align = Target->getShortAlign();
1761  break;
1762  case BuiltinType::UInt:
1763  case BuiltinType::Int:
1764  Width = Target->getIntWidth();
1765  Align = Target->getIntAlign();
1766  break;
1767  case BuiltinType::ULong:
1768  case BuiltinType::Long:
1769  Width = Target->getLongWidth();
1770  Align = Target->getLongAlign();
1771  break;
1772  case BuiltinType::ULongLong:
1773  case BuiltinType::LongLong:
1774  Width = Target->getLongLongWidth();
1775  Align = Target->getLongLongAlign();
1776  break;
1777  case BuiltinType::Int128:
1778  case BuiltinType::UInt128:
1779  Width = 128;
1780  Align = 128; // int128_t is 128-bit aligned on all targets.
1781  break;
1782  case BuiltinType::Float16:
1783  case BuiltinType::Half:
1784  Width = Target->getHalfWidth();
1785  Align = Target->getHalfAlign();
1786  break;
1787  case BuiltinType::Float:
1788  Width = Target->getFloatWidth();
1789  Align = Target->getFloatAlign();
1790  break;
1791  case BuiltinType::Double:
1792  Width = Target->getDoubleWidth();
1793  Align = Target->getDoubleAlign();
1794  break;
1795  case BuiltinType::LongDouble:
1796  Width = Target->getLongDoubleWidth();
1797  Align = Target->getLongDoubleAlign();
1798  break;
1799  case BuiltinType::Float128:
1800  Width = Target->getFloat128Width();
1801  Align = Target->getFloat128Align();
1802  break;
1803  case BuiltinType::NullPtr:
1804  Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
1805  Align = Target->getPointerAlign(0); // == sizeof(void*)
1806  break;
1807  case BuiltinType::ObjCId:
1808  case BuiltinType::ObjCClass:
1809  case BuiltinType::ObjCSel:
1810  Width = Target->getPointerWidth(0);
1811  Align = Target->getPointerAlign(0);
1812  break;
1813  case BuiltinType::OCLSampler:
1814  case BuiltinType::OCLEvent:
1815  case BuiltinType::OCLClkEvent:
1816  case BuiltinType::OCLQueue:
1817  case BuiltinType::OCLReserveID:
1818 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1819  case BuiltinType::Id:
1820 #include "clang/Basic/OpenCLImageTypes.def"
1821  AS = getTargetAddressSpace(
1823  Width = Target->getPointerWidth(AS);
1824  Align = Target->getPointerAlign(AS);
1825  break;
1826  }
1827  break;
1828  case Type::ObjCObjectPointer:
1829  Width = Target->getPointerWidth(0);
1830  Align = Target->getPointerAlign(0);
1831  break;
1832  case Type::BlockPointer:
1833  AS = getTargetAddressSpace(cast<BlockPointerType>(T)->getPointeeType());
1834  Width = Target->getPointerWidth(AS);
1835  Align = Target->getPointerAlign(AS);
1836  break;
1837  case Type::LValueReference:
1838  case Type::RValueReference:
1839  // alignof and sizeof should never enter this code path here, so we go
1840  // the pointer route.
1841  AS = getTargetAddressSpace(cast<ReferenceType>(T)->getPointeeType());
1842  Width = Target->getPointerWidth(AS);
1843  Align = Target->getPointerAlign(AS);
1844  break;
1845  case Type::Pointer:
1846  AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType());
1847  Width = Target->getPointerWidth(AS);
1848  Align = Target->getPointerAlign(AS);
1849  break;
1850  case Type::MemberPointer: {
1851  const MemberPointerType *MPT = cast<MemberPointerType>(T);
1852  CXXABI::MemberPointerInfo MPI = ABI->getMemberPointerInfo(MPT);
1853  Width = MPI.Width;
1854  Align = MPI.Align;
1855  break;
1856  }
1857  case Type::Complex: {
1858  // Complex types have the same alignment as their elements, but twice the
1859  // size.
1860  TypeInfo EltInfo = getTypeInfo(cast<ComplexType>(T)->getElementType());
1861  Width = EltInfo.Width * 2;
1862  Align = EltInfo.Align;
1863  break;
1864  }
1865  case Type::ObjCObject:
1866  return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr());
1867  case Type::Adjusted:
1868  case Type::Decayed:
1869  return getTypeInfo(cast<AdjustedType>(T)->getAdjustedType().getTypePtr());
1870  case Type::ObjCInterface: {
1871  const ObjCInterfaceType *ObjCI = cast<ObjCInterfaceType>(T);
1872  const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
1873  Width = toBits(Layout.getSize());
1874  Align = toBits(Layout.getAlignment());
1875  break;
1876  }
1877  case Type::Record:
1878  case Type::Enum: {
1879  const TagType *TT = cast<TagType>(T);
1880 
1881  if (TT->getDecl()->isInvalidDecl()) {
1882  Width = 8;
1883  Align = 8;
1884  break;
1885  }
1886 
1887  if (const EnumType *ET = dyn_cast<EnumType>(TT)) {
1888  const EnumDecl *ED = ET->getDecl();
1889  TypeInfo Info =
1891  if (unsigned AttrAlign = ED->getMaxAlignment()) {
1892  Info.Align = AttrAlign;
1893  Info.AlignIsRequired = true;
1894  }
1895  return Info;
1896  }
1897 
1898  const RecordType *RT = cast<RecordType>(TT);
1899  const RecordDecl *RD = RT->getDecl();
1900  const ASTRecordLayout &Layout = getASTRecordLayout(RD);
1901  Width = toBits(Layout.getSize());
1902  Align = toBits(Layout.getAlignment());
1903  AlignIsRequired = RD->hasAttr<AlignedAttr>();
1904  break;
1905  }
1906 
1907  case Type::SubstTemplateTypeParm:
1908  return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
1909  getReplacementType().getTypePtr());
1910 
1911  case Type::Auto:
1912  case Type::DeducedTemplateSpecialization: {
1913  const DeducedType *A = cast<DeducedType>(T);
1914  assert(!A->getDeducedType().isNull() &&
1915  "cannot request the size of an undeduced or dependent auto type");
1916  return getTypeInfo(A->getDeducedType().getTypePtr());
1917  }
1918 
1919  case Type::Paren:
1920  return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr());
1921 
1922  case Type::ObjCTypeParam:
1923  return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr());
1924 
1925  case Type::Typedef: {
1926  const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl();
1927  TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
1928  // If the typedef has an aligned attribute on it, it overrides any computed
1929  // alignment we have. This violates the GCC documentation (which says that
1930  // attribute(aligned) can only round up) but matches its implementation.
1931  if (unsigned AttrAlign = Typedef->getMaxAlignment()) {
1932  Align = AttrAlign;
1933  AlignIsRequired = true;
1934  } else {
1935  Align = Info.Align;
1936  AlignIsRequired = Info.AlignIsRequired;
1937  }
1938  Width = Info.Width;
1939  break;
1940  }
1941 
1942  case Type::Elaborated:
1943  return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr());
1944 
1945  case Type::Attributed:
1946  return getTypeInfo(
1947  cast<AttributedType>(T)->getEquivalentType().getTypePtr());
1948 
1949  case Type::Atomic: {
1950  // Start with the base type information.
1951  TypeInfo Info = getTypeInfo(cast<AtomicType>(T)->getValueType());
1952  Width = Info.Width;
1953  Align = Info.Align;
1954 
1955  // If the size of the type doesn't exceed the platform's max
1956  // atomic promotion width, make the size and alignment more
1957  // favorable to atomic operations:
1958  if (Width != 0 && Width <= Target->getMaxAtomicPromoteWidth()) {
1959  // Round the size up to a power of 2.
1960  if (!llvm::isPowerOf2_64(Width))
1961  Width = llvm::NextPowerOf2(Width);
1962 
1963  // Set the alignment equal to the size.
1964  Align = static_cast<unsigned>(Width);
1965  }
1966  }
1967  break;
1968 
1969  case Type::Pipe:
1972  break;
1973  }
1974 
1975  assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2");
1976  return TypeInfo(Width, Align, AlignIsRequired);
1977 }
1978 
1980  unsigned SimdAlign = getTargetInfo().getSimdDefaultAlign();
1981  // Target ppc64 with QPX: simd default alignment for pointer to double is 32.
1982  if ((getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64 ||
1983  getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64le) &&
1984  getTargetInfo().getABI() == "elfv1-qpx" &&
1985  T->isSpecificBuiltinType(BuiltinType::Double))
1986  SimdAlign = 256;
1987  return SimdAlign;
1988 }
1989 
1990 /// toCharUnitsFromBits - Convert a size in bits to a size in characters.
1992  return CharUnits::fromQuantity(BitSize / getCharWidth());
1993 }
1994 
1995 /// toBits - Convert a size in characters to a size in characters.
1996 int64_t ASTContext::toBits(CharUnits CharSize) const {
1997  return CharSize.getQuantity() * getCharWidth();
1998 }
1999 
2000 /// getTypeSizeInChars - Return the size of the specified type, in characters.
2001 /// This method does not work on incomplete types.
2003  return getTypeInfoInChars(T).first;
2004 }
2006  return getTypeInfoInChars(T).first;
2007 }
2008 
2009 /// getTypeAlignInChars - Return the ABI-specified alignment of a type, in
2010 /// characters. This method does not work on incomplete types.
2012  return toCharUnitsFromBits(getTypeAlign(T));
2013 }
2015  return toCharUnitsFromBits(getTypeAlign(T));
2016 }
2017 
2018 /// getPreferredTypeAlign - Return the "preferred" alignment of the specified
2019 /// type for the current target in bits. This can be different than the ABI
2020 /// alignment in cases where it is beneficial for performance to overalign
2021 /// a data type.
2022 unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
2023  TypeInfo TI = getTypeInfo(T);
2024  unsigned ABIAlign = TI.Align;
2025 
2026  T = T->getBaseElementTypeUnsafe();
2027 
2028  // The preferred alignment of member pointers is that of a pointer.
2029  if (T->isMemberPointerType())
2031 
2032  if (!Target->allowsLargerPreferedTypeAlignment())
2033  return ABIAlign;
2034 
2035  // Double and long long should be naturally aligned if possible.
2036  if (const ComplexType *CT = T->getAs<ComplexType>())
2037  T = CT->getElementType().getTypePtr();
2038  if (const EnumType *ET = T->getAs<EnumType>())
2039  T = ET->getDecl()->getIntegerType().getTypePtr();
2040  if (T->isSpecificBuiltinType(BuiltinType::Double) ||
2041  T->isSpecificBuiltinType(BuiltinType::LongLong) ||
2042  T->isSpecificBuiltinType(BuiltinType::ULongLong))
2043  // Don't increase the alignment if an alignment attribute was specified on a
2044  // typedef declaration.
2045  if (!TI.AlignIsRequired)
2046  return std::max(ABIAlign, (unsigned)getTypeSize(T));
2047 
2048  return ABIAlign;
2049 }
2050 
2051 /// getTargetDefaultAlignForAttributeAligned - Return the default alignment
2052 /// for __attribute__((aligned)) on this target, to be used if no alignment
2053 /// value is specified.
2056 }
2057 
2058 /// getAlignOfGlobalVar - Return the alignment in bits that should be given
2059 /// to a global variable of the specified type.
2061  return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign());
2062 }
2063 
2064 /// getAlignOfGlobalVarInChars - Return the alignment in characters that
2065 /// should be given to a global variable of the specified type.
2068 }
2069 
2072  const ASTRecordLayout *Layout = &getASTRecordLayout(RD);
2073  while (const CXXRecordDecl *Base = Layout->getBaseSharingVBPtr()) {
2074  Offset += Layout->getBaseClassOffset(Base);
2075  Layout = &getASTRecordLayout(Base);
2076  }
2077  return Offset;
2078 }
2079 
2080 /// DeepCollectObjCIvars -
2081 /// This routine first collects all declared, but not synthesized, ivars in
2082 /// super class and then collects all ivars, including those synthesized for
2083 /// current class. This routine is used for implementation of current class
2084 /// when all ivars, declared and synthesized are known.
2086  bool leafClass,
2087  SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const {
2088  if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
2089  DeepCollectObjCIvars(SuperClass, false, Ivars);
2090  if (!leafClass) {
2091  for (const auto *I : OI->ivars())
2092  Ivars.push_back(I);
2093  } else {
2094  ObjCInterfaceDecl *IDecl = const_cast<ObjCInterfaceDecl *>(OI);
2095  for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
2096  Iv= Iv->getNextIvar())
2097  Ivars.push_back(Iv);
2098  }
2099 }
2100 
2101 /// CollectInheritedProtocols - Collect all protocols in current class and
2102 /// those inherited by it.
2104  llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
2105  if (const ObjCInterfaceDecl *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2106  // We can use protocol_iterator here instead of
2107  // all_referenced_protocol_iterator since we are walking all categories.
2108  for (auto *Proto : OI->all_referenced_protocols()) {
2109  CollectInheritedProtocols(Proto, Protocols);
2110  }
2111 
2112  // Categories of this Interface.
2113  for (const auto *Cat : OI->visible_categories())
2114  CollectInheritedProtocols(Cat, Protocols);
2115 
2116  if (ObjCInterfaceDecl *SD = OI->getSuperClass())
2117  while (SD) {
2118  CollectInheritedProtocols(SD, Protocols);
2119  SD = SD->getSuperClass();
2120  }
2121  } else if (const ObjCCategoryDecl *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2122  for (auto *Proto : OC->protocols()) {
2123  CollectInheritedProtocols(Proto, Protocols);
2124  }
2125  } else if (const ObjCProtocolDecl *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
2126  // Insert the protocol.
2127  if (!Protocols.insert(
2128  const_cast<ObjCProtocolDecl *>(OP->getCanonicalDecl())).second)
2129  return;
2130 
2131  for (auto *Proto : OP->protocols())
2132  CollectInheritedProtocols(Proto, Protocols);
2133  }
2134 }
2135 
2137  const RecordDecl *RD) {
2138  assert(RD->isUnion() && "Must be union type");
2139  CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());
2140 
2141  for (const auto *Field : RD->fields()) {
2142  if (!Context.hasUniqueObjectRepresentations(Field->getType()))
2143  return false;
2144  CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
2145  if (FieldSize != UnionSize)
2146  return false;
2147  }
2148  return !RD->field_empty();
2149 }
2150 
2151 static bool isStructEmpty(QualType Ty) {
2152  const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();
2153 
2154  if (!RD->field_empty())
2155  return false;
2156 
2157  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD))
2158  return ClassDecl->isEmpty();
2159 
2160  return true;
2161 }
2162 
2165  const RecordDecl *RD) {
2166  assert(!RD->isUnion() && "Must be struct/class type");
2167  const auto &Layout = Context.getASTRecordLayout(RD);
2168 
2169  int64_t CurOffsetInBits = 0;
2170  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2171  if (ClassDecl->isDynamicClass())
2172  return llvm::None;
2173 
2175  for (const auto Base : ClassDecl->bases()) {
2176  // Empty types can be inherited from, and non-empty types can potentially
2177  // have tail padding, so just make sure there isn't an error.
2178  if (!isStructEmpty(Base.getType())) {
2180  Context, Base.getType()->getAs<RecordType>()->getDecl());
2181  if (!Size)
2182  return llvm::None;
2183  Bases.emplace_back(Base.getType(), Size.getValue());
2184  }
2185  }
2186 
2187  std::sort(
2188  Bases.begin(), Bases.end(), [&](const std::pair<QualType, int64_t> &L,
2189  const std::pair<QualType, int64_t> &R) {
2190  return Layout.getBaseClassOffset(L.first->getAsCXXRecordDecl()) <
2191  Layout.getBaseClassOffset(R.first->getAsCXXRecordDecl());
2192  });
2193 
2194  for (const auto Base : Bases) {
2195  int64_t BaseOffset = Context.toBits(
2196  Layout.getBaseClassOffset(Base.first->getAsCXXRecordDecl()));
2197  int64_t BaseSize = Base.second;
2198  if (BaseOffset != CurOffsetInBits)
2199  return llvm::None;
2200  CurOffsetInBits = BaseOffset + BaseSize;
2201  }
2202  }
2203 
2204  for (const auto *Field : RD->fields()) {
2205  if (!Field->getType()->isReferenceType() &&
2206  !Context.hasUniqueObjectRepresentations(Field->getType()))
2207  return llvm::None;
2208 
2209  int64_t FieldSizeInBits =
2210  Context.toBits(Context.getTypeSizeInChars(Field->getType()));
2211  if (Field->isBitField()) {
2212  int64_t BitfieldSize = Field->getBitWidthValue(Context);
2213 
2214  if (BitfieldSize > FieldSizeInBits)
2215  return llvm::None;
2216  FieldSizeInBits = BitfieldSize;
2217  }
2218 
2219  int64_t FieldOffsetInBits = Context.getFieldOffset(Field);
2220 
2221  if (FieldOffsetInBits != CurOffsetInBits)
2222  return llvm::None;
2223 
2224  CurOffsetInBits = FieldSizeInBits + FieldOffsetInBits;
2225  }
2226 
2227  return CurOffsetInBits;
2228 }
2229 
2231  // C++17 [meta.unary.prop]:
2232  // The predicate condition for a template specialization
2233  // has_unique_object_representations<T> shall be
2234  // satisfied if and only if:
2235  // (9.1) - T is trivially copyable, and
2236  // (9.2) - any two objects of type T with the same value have the same
2237  // object representation, where two objects
2238  // of array or non-union class type are considered to have the same value
2239  // if their respective sequences of
2240  // direct subobjects have the same values, and two objects of union type
2241  // are considered to have the same
2242  // value if they have the same active member and the corresponding members
2243  // have the same value.
2244  // The set of scalar types for which this condition holds is
2245  // implementation-defined. [ Note: If a type has padding
2246  // bits, the condition does not hold; otherwise, the condition holds true
2247  // for unsigned integral types. -- end note ]
2248  assert(!Ty.isNull() && "Null QualType sent to unique object rep check");
2249 
2250  // Arrays are unique only if their element type is unique.
2251  if (Ty->isArrayType())
2253 
2254  // (9.1) - T is trivially copyable...
2255  if (!Ty.isTriviallyCopyableType(*this))
2256  return false;
2257 
2258  // All integrals and enums are unique.
2259  if (Ty->isIntegralOrEnumerationType())
2260  return true;
2261 
2262  // All other pointers are unique.
2263  if (Ty->isPointerType())
2264  return true;
2265 
2266  if (Ty->isMemberPointerType()) {
2267  const MemberPointerType *MPT = Ty->getAs<MemberPointerType>();
2268  return !ABI->getMemberPointerInfo(MPT).HasPadding;
2269  }
2270 
2271  if (Ty->isRecordType()) {
2272  const RecordDecl *Record = Ty->getAs<RecordType>()->getDecl();
2273 
2274  if (Record->isInvalidDecl())
2275  return false;
2276 
2277  if (Record->isUnion())
2278  return unionHasUniqueObjectRepresentations(*this, Record);
2279 
2280  Optional<int64_t> StructSize =
2281  structHasUniqueObjectRepresentations(*this, Record);
2282 
2283  return StructSize &&
2284  StructSize.getValue() == static_cast<int64_t>(getTypeSize(Ty));
2285  }
2286 
2287  // FIXME: More cases to handle here (list by rsmith):
2288  // vectors (careful about, eg, vector of 3 foo)
2289  // _Complex int and friends
2290  // _Atomic T
2291  // Obj-C block pointers
2292  // Obj-C object pointers
2293  // and perhaps OpenCL's various builtin types (pipe, sampler_t, event_t,
2294  // clk_event_t, queue_t, reserve_id_t)
2295  // There're also Obj-C class types and the Obj-C selector type, but I think it
2296  // makes sense for those to return false here.
2297 
2298  return false;
2299 }
2300 
2302  unsigned count = 0;
2303  // Count ivars declared in class extension.
2304  for (const auto *Ext : OI->known_extensions())
2305  count += Ext->ivar_size();
2306 
2307  // Count ivar defined in this class's implementation. This
2308  // includes synthesized ivars.
2309  if (ObjCImplementationDecl *ImplDecl = OI->getImplementation())
2310  count += ImplDecl->ivar_size();
2311 
2312  return count;
2313 }
2314 
2316  if (!E)
2317  return false;
2318 
2319  // nullptr_t is always treated as null.
2320  if (E->getType()->isNullPtrType()) return true;
2321 
2322  if (E->getType()->isAnyPointerType() &&
2325  return true;
2326 
2327  // Unfortunately, __null has type 'int'.
2328  if (isa<GNUNullExpr>(E)) return true;
2329 
2330  return false;
2331 }
2332 
2333 /// \brief Get the implementation of ObjCInterfaceDecl, or nullptr if none
2334 /// exists.
2336  llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2337  I = ObjCImpls.find(D);
2338  if (I != ObjCImpls.end())
2339  return cast<ObjCImplementationDecl>(I->second);
2340  return nullptr;
2341 }
2342 
2343 /// \brief Get the implementation of ObjCCategoryDecl, or nullptr if none
2344 /// exists.
2346  llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2347  I = ObjCImpls.find(D);
2348  if (I != ObjCImpls.end())
2349  return cast<ObjCCategoryImplDecl>(I->second);
2350  return nullptr;
2351 }
2352 
2353 /// \brief Set the implementation of ObjCInterfaceDecl.
2355  ObjCImplementationDecl *ImplD) {
2356  assert(IFaceD && ImplD && "Passed null params");
2357  ObjCImpls[IFaceD] = ImplD;
2358 }
2359 
2360 /// \brief Set the implementation of ObjCCategoryDecl.
2362  ObjCCategoryImplDecl *ImplD) {
2363  assert(CatD && ImplD && "Passed null params");
2364  ObjCImpls[CatD] = ImplD;
2365 }
2366 
2367 const ObjCMethodDecl *
2369  return ObjCMethodRedecls.lookup(MD);
2370 }
2371 
2373  const ObjCMethodDecl *Redecl) {
2374  assert(!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration");
2375  ObjCMethodRedecls[MD] = Redecl;
2376 }
2377 
2379  const NamedDecl *ND) const {
2380  if (const ObjCInterfaceDecl *ID =
2381  dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext()))
2382  return ID;
2383  if (const ObjCCategoryDecl *CD =
2384  dyn_cast<ObjCCategoryDecl>(ND->getDeclContext()))
2385  return CD->getClassInterface();
2386  if (const ObjCImplDecl *IMD =
2387  dyn_cast<ObjCImplDecl>(ND->getDeclContext()))
2388  return IMD->getClassInterface();
2389 
2390  return nullptr;
2391 }
2392 
2393 /// \brief Get the copy initialization expression of VarDecl, or nullptr if
2394 /// none exists.
2396  assert(VD && "Passed null params");
2397  assert(VD->hasAttr<BlocksAttr>() &&
2398  "getBlockVarCopyInits - not __block var");
2399  llvm::DenseMap<const VarDecl*, Expr*>::iterator
2400  I = BlockVarCopyInits.find(VD);
2401  return (I != BlockVarCopyInits.end()) ? cast<Expr>(I->second) : nullptr;
2402 }
2403 
2404 /// \brief Set the copy inialization expression of a block var decl.
2406  assert(VD && Init && "Passed null params");
2407  assert(VD->hasAttr<BlocksAttr>() &&
2408  "setBlockVarCopyInits - not __block var");
2409  BlockVarCopyInits[VD] = Init;
2410 }
2411 
2413  unsigned DataSize) const {
2414  if (!DataSize)
2415  DataSize = TypeLoc::getFullDataSizeForType(T);
2416  else
2417  assert(DataSize == TypeLoc::getFullDataSizeForType(T) &&
2418  "incorrect data size provided to CreateTypeSourceInfo!");
2419 
2420  TypeSourceInfo *TInfo =
2421  (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
2422  new (TInfo) TypeSourceInfo(T);
2423  return TInfo;
2424 }
2425 
2427  SourceLocation L) const {
2429  DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L);
2430  return DI;
2431 }
2432 
2433 const ASTRecordLayout &
2435  return getObjCLayout(D, nullptr);
2436 }
2437 
2438 const ASTRecordLayout &
2440  const ObjCImplementationDecl *D) const {
2441  return getObjCLayout(D->getClassInterface(), D);
2442 }
2443 
2444 //===----------------------------------------------------------------------===//
2445 // Type creation/memoization methods
2446 //===----------------------------------------------------------------------===//
2447 
2448 QualType
2449 ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
2450  unsigned fastQuals = quals.getFastQualifiers();
2451  quals.removeFastQualifiers();
2452 
2453  // Check if we've already instantiated this type.
2454  llvm::FoldingSetNodeID ID;
2455  ExtQuals::Profile(ID, baseType, quals);
2456  void *insertPos = nullptr;
2457  if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
2458  assert(eq->getQualifiers() == quals);
2459  return QualType(eq, fastQuals);
2460  }
2461 
2462  // If the base type is not canonical, make the appropriate canonical type.
2463  QualType canon;
2464  if (!baseType->isCanonicalUnqualified()) {
2465  SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split();
2466  canonSplit.Quals.addConsistentQualifiers(quals);
2467  canon = getExtQualType(canonSplit.Ty, canonSplit.Quals);
2468 
2469  // Re-find the insert position.
2470  (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
2471  }
2472 
2473  ExtQuals *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
2474  ExtQualNodes.InsertNode(eq, insertPos);
2475  return QualType(eq, fastQuals);
2476 }
2477 
2479  LangAS AddressSpace) const {
2480  QualType CanT = getCanonicalType(T);
2481  if (CanT.getAddressSpace() == AddressSpace)
2482  return T;
2483 
2484  // If we are composing extended qualifiers together, merge together
2485  // into one ExtQuals node.
2486  QualifierCollector Quals;
2487  const Type *TypeNode = Quals.strip(T);
2488 
2489  // If this type already has an address space specified, it cannot get
2490  // another one.
2491  assert(!Quals.hasAddressSpace() &&
2492  "Type cannot be in multiple addr spaces!");
2493  Quals.addAddressSpace(AddressSpace);
2494 
2495  return getExtQualType(TypeNode, Quals);
2496 }
2497 
2499  // If we are composing extended qualifiers together, merge together
2500  // into one ExtQuals node.
2501  QualifierCollector Quals;
2502  const Type *TypeNode = Quals.strip(T);
2503 
2504  // If the qualifier doesn't have an address space just return it.
2505  if (!Quals.hasAddressSpace())
2506  return T;
2507 
2508  Quals.removeAddressSpace();
2509 
2510  // Removal of the address space can mean there are no longer any
2511  // non-fast qualifiers, so creating an ExtQualType isn't possible (asserts)
2512  // or required.
2513  if (Quals.hasNonFastQualifiers())
2514  return getExtQualType(TypeNode, Quals);
2515  else
2516  return QualType(TypeNode, Quals.getFastQualifiers());
2517 }
2518 
2520  Qualifiers::GC GCAttr) const {
2521  QualType CanT = getCanonicalType(T);
2522  if (CanT.getObjCGCAttr() == GCAttr)
2523  return T;
2524 
2525  if (const PointerType *ptr = T->getAs<PointerType>()) {
2526  QualType Pointee = ptr->getPointeeType();
2527  if (Pointee->isAnyPointerType()) {
2528  QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
2529  return getPointerType(ResultType);
2530  }
2531  }
2532 
2533  // If we are composing extended qualifiers together, merge together
2534  // into one ExtQuals node.
2535  QualifierCollector Quals;
2536  const Type *TypeNode = Quals.strip(T);
2537 
2538  // If this type already has an ObjCGC specified, it cannot get
2539  // another one.
2540  assert(!Quals.hasObjCGCAttr() &&
2541  "Type cannot have multiple ObjCGCs!");
2542  Quals.addObjCGCAttr(GCAttr);
2543 
2544  return getExtQualType(TypeNode, Quals);
2545 }
2546 
2548  FunctionType::ExtInfo Info) {
2549  if (T->getExtInfo() == Info)
2550  return T;
2551 
2552  QualType Result;
2553  if (const FunctionNoProtoType *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
2554  Result = getFunctionNoProtoType(FNPT->getReturnType(), Info);
2555  } else {
2556  const FunctionProtoType *FPT = cast<FunctionProtoType>(T);
2558  EPI.ExtInfo = Info;
2559  Result = getFunctionType(FPT->getReturnType(), FPT->getParamTypes(), EPI);
2560  }
2561 
2562  return cast<FunctionType>(Result.getTypePtr());
2563 }
2564 
2566  QualType ResultType) {
2567  FD = FD->getMostRecentDecl();
2568  while (true) {
2569  const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>();
2571  FD->setType(getFunctionType(ResultType, FPT->getParamTypes(), EPI));
2572  if (FunctionDecl *Next = FD->getPreviousDecl())
2573  FD = Next;
2574  else
2575  break;
2576  }
2578  L->DeducedReturnType(FD, ResultType);
2579 }
2580 
2581 /// Get a function type and produce the equivalent function type with the
2582 /// specified exception specification. Type sugar that can be present on a
2583 /// declaration of a function with an exception specification is permitted
2584 /// and preserved. Other type sugar (for instance, typedefs) is not.
2586  ASTContext &Context, QualType Orig,
2588  // Might have some parens.
2589  if (auto *PT = dyn_cast<ParenType>(Orig))
2590  return Context.getParenType(
2591  getFunctionTypeWithExceptionSpec(Context, PT->getInnerType(), ESI));
2592 
2593  // Might have a calling-convention attribute.
2594  if (auto *AT = dyn_cast<AttributedType>(Orig))
2595  return Context.getAttributedType(
2596  AT->getAttrKind(),
2597  getFunctionTypeWithExceptionSpec(Context, AT->getModifiedType(), ESI),
2598  getFunctionTypeWithExceptionSpec(Context, AT->getEquivalentType(),
2599  ESI));
2600 
2601  // Anything else must be a function type. Rebuild it with the new exception
2602  // specification.
2603  const FunctionProtoType *Proto = cast<FunctionProtoType>(Orig);
2604  return Context.getFunctionType(
2605  Proto->getReturnType(), Proto->getParamTypes(),
2606  Proto->getExtProtoInfo().withExceptionSpec(ESI));
2607 }
2608 
2610  QualType U) {
2611  return hasSameType(T, U) ||
2612  (getLangOpts().CPlusPlus17 &&
2615 }
2616 
2619  bool AsWritten) {
2620  // Update the type.
2621  QualType Updated =
2622  getFunctionTypeWithExceptionSpec(*this, FD->getType(), ESI);
2623  FD->setType(Updated);
2624 
2625  if (!AsWritten)
2626  return;
2627 
2628  // Update the type in the type source information too.
2629  if (TypeSourceInfo *TSInfo = FD->getTypeSourceInfo()) {
2630  // If the type and the type-as-written differ, we may need to update
2631  // the type-as-written too.
2632  if (TSInfo->getType() != FD->getType())
2633  Updated = getFunctionTypeWithExceptionSpec(*this, TSInfo->getType(), ESI);
2634 
2635  // FIXME: When we get proper type location information for exceptions,
2636  // we'll also have to rebuild the TypeSourceInfo. For now, we just patch
2637  // up the TypeSourceInfo;
2638  assert(TypeLoc::getFullDataSizeForType(Updated) ==
2639  TypeLoc::getFullDataSizeForType(TSInfo->getType()) &&
2640  "TypeLoc size mismatch from updating exception specification");
2641  TSInfo->overrideType(Updated);
2642  }
2643 }
2644 
2645 /// getComplexType - Return the uniqued reference to the type for a complex
2646 /// number with the specified element type.
2648  // Unique pointers, to guarantee there is only one pointer of a particular
2649  // structure.
2650  llvm::FoldingSetNodeID ID;
2651  ComplexType::Profile(ID, T);
2652 
2653  void *InsertPos = nullptr;
2654  if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
2655  return QualType(CT, 0);
2656 
2657  // If the pointee type isn't canonical, this won't be a canonical type either,
2658  // so fill in the canonical type field.
2659  QualType Canonical;
2660  if (!T.isCanonical()) {
2661  Canonical = getComplexType(getCanonicalType(T));
2662 
2663  // Get the new insert position for the node we care about.
2664  ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
2665  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2666  }
2667  ComplexType *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
2668  Types.push_back(New);
2669  ComplexTypes.InsertNode(New, InsertPos);
2670  return QualType(New, 0);
2671 }
2672 
2673 /// getPointerType - Return the uniqued reference to the type for a pointer to
2674 /// the specified type.
2676  // Unique pointers, to guarantee there is only one pointer of a particular
2677  // structure.
2678  llvm::FoldingSetNodeID ID;
2679  PointerType::Profile(ID, T);
2680 
2681  void *InsertPos = nullptr;
2682  if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2683  return QualType(PT, 0);
2684 
2685  // If the pointee type isn't canonical, this won't be a canonical type either,
2686  // so fill in the canonical type field.
2687  QualType Canonical;
2688  if (!T.isCanonical()) {
2689  Canonical = getPointerType(getCanonicalType(T));
2690 
2691  // Get the new insert position for the node we care about.
2692  PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2693  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2694  }
2695  PointerType *New = new (*this, TypeAlignment) PointerType(T, Canonical);
2696  Types.push_back(New);
2697  PointerTypes.InsertNode(New, InsertPos);
2698  return QualType(New, 0);
2699 }
2700 
2702  llvm::FoldingSetNodeID ID;
2703  AdjustedType::Profile(ID, Orig, New);
2704  void *InsertPos = nullptr;
2705  AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2706  if (AT)
2707  return QualType(AT, 0);
2708 
2709  QualType Canonical = getCanonicalType(New);
2710 
2711  // Get the new insert position for the node we care about.
2712  AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2713  assert(!AT && "Shouldn't be in the map!");
2714 
2715  AT = new (*this, TypeAlignment)
2716  AdjustedType(Type::Adjusted, Orig, New, Canonical);
2717  Types.push_back(AT);
2718  AdjustedTypes.InsertNode(AT, InsertPos);
2719  return QualType(AT, 0);
2720 }
2721 
2723  assert((T->isArrayType() || T->isFunctionType()) && "T does not decay");
2724 
2725  QualType Decayed;
2726 
2727  // C99 6.7.5.3p7:
2728  // A declaration of a parameter as "array of type" shall be
2729  // adjusted to "qualified pointer to type", where the type
2730  // qualifiers (if any) are those specified within the [ and ] of
2731  // the array type derivation.
2732  if (T->isArrayType())
2733  Decayed = getArrayDecayedType(T);
2734 
2735  // C99 6.7.5.3p8:
2736  // A declaration of a parameter as "function returning type"
2737  // shall be adjusted to "pointer to function returning type", as
2738  // in 6.3.2.1.
2739  if (T->isFunctionType())
2740  Decayed = getPointerType(T);
2741 
2742  llvm::FoldingSetNodeID ID;
2743  AdjustedType::Profile(ID, T, Decayed);
2744  void *InsertPos = nullptr;
2745  AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2746  if (AT)
2747  return QualType(AT, 0);
2748 
2749  QualType Canonical = getCanonicalType(Decayed);
2750 
2751  // Get the new insert position for the node we care about.
2752  AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2753  assert(!AT && "Shouldn't be in the map!");
2754 
2755  AT = new (*this, TypeAlignment) DecayedType(T, Decayed, Canonical);
2756  Types.push_back(AT);
2757  AdjustedTypes.InsertNode(AT, InsertPos);
2758  return QualType(AT, 0);
2759 }
2760 
2761 /// getBlockPointerType - Return the uniqued reference to the type for
2762 /// a pointer to the specified block.
2764  assert(T->isFunctionType() && "block of function types only");
2765  // Unique pointers, to guarantee there is only one block of a particular
2766  // structure.
2767  llvm::FoldingSetNodeID ID;
2769 
2770  void *InsertPos = nullptr;
2771  if (BlockPointerType *PT =
2772  BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2773  return QualType(PT, 0);
2774 
2775  // If the block pointee type isn't canonical, this won't be a canonical
2776  // type either so fill in the canonical type field.
2777  QualType Canonical;
2778  if (!T.isCanonical()) {
2779  Canonical = getBlockPointerType(getCanonicalType(T));
2780 
2781  // Get the new insert position for the node we care about.
2782  BlockPointerType *NewIP =
2783  BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2784  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2785  }
2786  BlockPointerType *New
2787  = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
2788  Types.push_back(New);
2789  BlockPointerTypes.InsertNode(New, InsertPos);
2790  return QualType(New, 0);
2791 }
2792 
2793 /// getLValueReferenceType - Return the uniqued reference to the type for an
2794 /// lvalue reference to the specified type.
2795 QualType
2796 ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const {
2797  assert(getCanonicalType(T) != OverloadTy &&
2798  "Unresolved overloaded function type");
2799 
2800  // Unique pointers, to guarantee there is only one pointer of a particular
2801  // structure.
2802  llvm::FoldingSetNodeID ID;
2803  ReferenceType::Profile(ID, T, SpelledAsLValue);
2804 
2805  void *InsertPos = nullptr;
2806  if (LValueReferenceType *RT =
2807  LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2808  return QualType(RT, 0);
2809 
2810  const ReferenceType *InnerRef = T->getAs<ReferenceType>();
2811 
2812  // If the referencee type isn't canonical, this won't be a canonical type
2813  // either, so fill in the canonical type field.
2814  QualType Canonical;
2815  if (!SpelledAsLValue || InnerRef || !T.isCanonical()) {
2816  QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2817  Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
2818 
2819  // Get the new insert position for the node we care about.
2820  LValueReferenceType *NewIP =
2821  LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
2822  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2823  }
2824 
2825  LValueReferenceType *New
2826  = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
2827  SpelledAsLValue);
2828  Types.push_back(New);
2829  LValueReferenceTypes.InsertNode(New, InsertPos);
2830 
2831  return QualType(New, 0);
2832 }
2833 
2834 /// getRValueReferenceType - Return the uniqued reference to the type for an
2835 /// rvalue reference to the specified type.
2837  // Unique pointers, to guarantee there is only one pointer of a particular
2838  // structure.
2839  llvm::FoldingSetNodeID ID;
2840  ReferenceType::Profile(ID, T, false);
2841 
2842  void *InsertPos = nullptr;
2843  if (RValueReferenceType *RT =
2844  RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2845  return QualType(RT, 0);
2846 
2847  const ReferenceType *InnerRef = T->getAs<ReferenceType>();
2848 
2849  // If the referencee type isn't canonical, this won't be a canonical type
2850  // either, so fill in the canonical type field.
2851  QualType Canonical;
2852  if (InnerRef || !T.isCanonical()) {
2853  QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2854  Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
2855 
2856  // Get the new insert position for the node we care about.
2857  RValueReferenceType *NewIP =
2858  RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
2859  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2860  }
2861 
2862  RValueReferenceType *New
2863  = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
2864  Types.push_back(New);
2865  RValueReferenceTypes.InsertNode(New, InsertPos);
2866  return QualType(New, 0);
2867 }
2868 
2869 /// getMemberPointerType - Return the uniqued reference to the type for a
2870 /// member pointer to the specified type, in the specified class.
2872  // Unique pointers, to guarantee there is only one pointer of a particular
2873  // structure.
2874  llvm::FoldingSetNodeID ID;
2875  MemberPointerType::Profile(ID, T, Cls);
2876 
2877  void *InsertPos = nullptr;
2878  if (MemberPointerType *PT =
2879  MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2880  return QualType(PT, 0);
2881 
2882  // If the pointee or class type isn't canonical, this won't be a canonical
2883  // type either, so fill in the canonical type field.
2884  QualType Canonical;
2885  if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
2887 
2888  // Get the new insert position for the node we care about.
2889  MemberPointerType *NewIP =
2890  MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2891  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2892  }
2893  MemberPointerType *New
2894  = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
2895  Types.push_back(New);
2896  MemberPointerTypes.InsertNode(New, InsertPos);
2897  return QualType(New, 0);
2898 }
2899 
2900 /// getConstantArrayType - Return the unique reference to the type for an
2901 /// array of the specified element type.
2903  const llvm::APInt &ArySizeIn,
2905  unsigned IndexTypeQuals) const {
2906  assert((EltTy->isDependentType() ||
2907  EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&
2908  "Constant array of VLAs is illegal!");
2909 
2910  // Convert the array size into a canonical width matching the pointer size for
2911  // the target.
2912  llvm::APInt ArySize(ArySizeIn);
2913  ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());
2914 
2915  llvm::FoldingSetNodeID ID;
2916  ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals);
2917 
2918  void *InsertPos = nullptr;
2919  if (ConstantArrayType *ATP =
2920  ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
2921  return QualType(ATP, 0);
2922 
2923  // If the element type isn't canonical or has qualifiers, this won't
2924  // be a canonical type either, so fill in the canonical type field.
2925  QualType Canon;
2926  if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
2927  SplitQualType canonSplit = getCanonicalType(EltTy).split();
2928  Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize,
2929  ASM, IndexTypeQuals);
2930  Canon = getQualifiedType(Canon, canonSplit.Quals);
2931 
2932  // Get the new insert position for the node we care about.
2933  ConstantArrayType *NewIP =
2934  ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
2935  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2936  }
2937 
2938  ConstantArrayType *New = new(*this,TypeAlignment)
2939  ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals);
2940  ConstantArrayTypes.InsertNode(New, InsertPos);
2941  Types.push_back(New);
2942  return QualType(New, 0);
2943 }
2944 
2945 /// getVariableArrayDecayedType - Turns the given type, which may be
2946 /// variably-modified, into the corresponding type with all the known
2947 /// sizes replaced with [*].
2949  // Vastly most common case.
2950  if (!type->isVariablyModifiedType()) return type;
2951 
2952  QualType result;
2953 
2954  SplitQualType split = type.getSplitDesugaredType();
2955  const Type *ty = split.Ty;
2956  switch (ty->getTypeClass()) {
2957 #define TYPE(Class, Base)
2958 #define ABSTRACT_TYPE(Class, Base)
2959 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2960 #include "clang/AST/TypeNodes.def"
2961  llvm_unreachable("didn't desugar past all non-canonical types?");
2962 
2963  // These types should never be variably-modified.
2964  case Type::Builtin:
2965  case Type::Complex:
2966  case Type::Vector:
2967  case Type::ExtVector:
2968  case Type::DependentSizedExtVector:
2969  case Type::DependentAddressSpace:
2970  case Type::ObjCObject:
2971  case Type::ObjCInterface:
2972  case Type::ObjCObjectPointer:
2973  case Type::Record:
2974  case Type::Enum:
2975  case Type::UnresolvedUsing:
2976  case Type::TypeOfExpr:
2977  case Type::TypeOf:
2978  case Type::Decltype:
2979  case Type::UnaryTransform:
2980  case Type::DependentName:
2981  case Type::InjectedClassName:
2982  case Type::TemplateSpecialization:
2983  case Type::DependentTemplateSpecialization:
2984  case Type::TemplateTypeParm:
2985  case Type::SubstTemplateTypeParmPack:
2986  case Type::Auto:
2987  case Type::DeducedTemplateSpecialization:
2988  case Type::PackExpansion:
2989  llvm_unreachable("type should never be variably-modified");
2990 
2991  // These types can be variably-modified but should never need to
2992  // further decay.
2993  case Type::FunctionNoProto:
2994  case Type::FunctionProto:
2995  case Type::BlockPointer:
2996  case Type::MemberPointer:
2997  case Type::Pipe:
2998  return type;
2999 
3000  // These types can be variably-modified. All these modifications
3001  // preserve structure except as noted by comments.
3002  // TODO: if we ever care about optimizing VLAs, there are no-op
3003  // optimizations available here.
3004  case Type::Pointer:
3006  cast<PointerType>(ty)->getPointeeType()));
3007  break;
3008 
3009  case Type::LValueReference: {
3010  const LValueReferenceType *lv = cast<LValueReferenceType>(ty);
3011  result = getLValueReferenceType(
3013  lv->isSpelledAsLValue());
3014  break;
3015  }
3016 
3017  case Type::RValueReference: {
3018  const RValueReferenceType *lv = cast<RValueReferenceType>(ty);
3019  result = getRValueReferenceType(
3021  break;
3022  }
3023 
3024  case Type::Atomic: {
3025  const AtomicType *at = cast<AtomicType>(ty);
3027  break;
3028  }
3029 
3030  case Type::ConstantArray: {
3031  const ConstantArrayType *cat = cast<ConstantArrayType>(ty);
3032  result = getConstantArrayType(
3034  cat->getSize(),
3035  cat->getSizeModifier(),
3036  cat->getIndexTypeCVRQualifiers());
3037  break;
3038  }
3039 
3040  case Type::DependentSizedArray: {
3041  const DependentSizedArrayType *dat = cast<DependentSizedArrayType>(ty);
3042  result = getDependentSizedArrayType(
3044  dat->getSizeExpr(),
3045  dat->getSizeModifier(),
3047  dat->getBracketsRange());
3048  break;
3049  }
3050 
3051  // Turn incomplete types into [*] types.
3052  case Type::IncompleteArray: {
3053  const IncompleteArrayType *iat = cast<IncompleteArrayType>(ty);
3054  result = getVariableArrayType(
3056  /*size*/ nullptr,
3059  SourceRange());
3060  break;
3061  }
3062 
3063  // Turn VLA types into [*] types.
3064  case Type::VariableArray: {
3065  const VariableArrayType *vat = cast<VariableArrayType>(ty);
3066  result = getVariableArrayType(
3068  /*size*/ nullptr,
3071  vat->getBracketsRange());
3072  break;
3073  }
3074  }
3075 
3076  // Apply the top-level qualifiers from the original.
3077  return getQualifiedType(result, split.Quals);
3078 }
3079 
3080 /// getVariableArrayType - Returns a non-unique reference to the type for a
3081 /// variable array of the specified element type.
3083  Expr *NumElts,
3085  unsigned IndexTypeQuals,
3086  SourceRange Brackets) const {
3087  // Since we don't unique expressions, it isn't possible to unique VLA's
3088  // that have an expression provided for their size.
3089  QualType Canon;
3090 
3091  // Be sure to pull qualifiers off the element type.
3092  if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
3093  SplitQualType canonSplit = getCanonicalType(EltTy).split();
3094  Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM,
3095  IndexTypeQuals, Brackets);
3096  Canon = getQualifiedType(Canon, canonSplit.Quals);
3097  }
3098 
3099  VariableArrayType *New = new(*this, TypeAlignment)
3100  VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);
3101 
3102  VariableArrayTypes.push_back(New);
3103  Types.push_back(New);
3104  return QualType(New, 0);
3105 }
3106 
3107 /// getDependentSizedArrayType - Returns a non-unique reference to
3108 /// the type for a dependently-sized array of the specified element
3109 /// type.
3111  Expr *numElements,
3113  unsigned elementTypeQuals,
3114  SourceRange brackets) const {
3115  assert((!numElements || numElements->isTypeDependent() ||
3116  numElements->isValueDependent()) &&
3117  "Size must be type- or value-dependent!");
3118 
3119  // Dependently-sized array types that do not have a specified number
3120  // of elements will have their sizes deduced from a dependent
3121  // initializer. We do no canonicalization here at all, which is okay
3122  // because they can't be used in most locations.
3123  if (!numElements) {
3124  DependentSizedArrayType *newType
3125  = new (*this, TypeAlignment)
3126  DependentSizedArrayType(*this, elementType, QualType(),
3127  numElements, ASM, elementTypeQuals,
3128  brackets);
3129  Types.push_back(newType);
3130  return QualType(newType, 0);
3131  }
3132 
3133  // Otherwise, we actually build a new type every time, but we
3134  // also build a canonical type.
3135 
3136  SplitQualType canonElementType = getCanonicalType(elementType).split();
3137 
3138  void *insertPos = nullptr;
3139  llvm::FoldingSetNodeID ID;
3141  QualType(canonElementType.Ty, 0),
3142  ASM, elementTypeQuals, numElements);
3143 
3144  // Look for an existing type with these properties.
3145  DependentSizedArrayType *canonTy =
3146  DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3147 
3148  // If we don't have one, build one.
3149  if (!canonTy) {
3150  canonTy = new (*this, TypeAlignment)
3151  DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0),
3152  QualType(), numElements, ASM, elementTypeQuals,
3153  brackets);
3154  DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
3155  Types.push_back(canonTy);
3156  }
3157 
3158  // Apply qualifiers from the element type to the array.
3159  QualType canon = getQualifiedType(QualType(canonTy,0),
3160  canonElementType.Quals);
3161 
3162  // If we didn't need extra canonicalization for the element type or the size
3163  // expression, then just use that as our result.
3164  if (QualType(canonElementType.Ty, 0) == elementType &&
3165  canonTy->getSizeExpr() == numElements)
3166  return canon;
3167 
3168  // Otherwise, we need to build a type which follows the spelling
3169  // of the element type.
3170  DependentSizedArrayType *sugaredType
3171  = new (*this, TypeAlignment)
3172  DependentSizedArrayType(*this, elementType, canon, numElements,
3173  ASM, elementTypeQuals, brackets);
3174  Types.push_back(sugaredType);
3175  return QualType(sugaredType, 0);
3176 }
3177 
3180  unsigned elementTypeQuals) const {
3181  llvm::FoldingSetNodeID ID;
3182  IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals);
3183 
3184  void *insertPos = nullptr;
3185  if (IncompleteArrayType *iat =
3186  IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
3187  return QualType(iat, 0);
3188 
3189  // If the element type isn't canonical, this won't be a canonical type
3190  // either, so fill in the canonical type field. We also have to pull
3191  // qualifiers off the element type.
3192  QualType canon;
3193 
3194  if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) {
3195  SplitQualType canonSplit = getCanonicalType(elementType).split();
3196  canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0),
3197  ASM, elementTypeQuals);
3198  canon = getQualifiedType(canon, canonSplit.Quals);
3199 
3200  // Get the new insert position for the node we care about.
3201  IncompleteArrayType *existing =
3202  IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3203  assert(!existing && "Shouldn't be in the map!"); (void) existing;
3204  }
3205 
3206  IncompleteArrayType *newType = new (*this, TypeAlignment)
3207  IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);
3208 
3209  IncompleteArrayTypes.InsertNode(newType, insertPos);
3210  Types.push_back(newType);
3211  return QualType(newType, 0);
3212 }
3213 
3214 /// getVectorType - Return the unique reference to a vector type of
3215 /// the specified element type and size. VectorType must be a built-in type.
3216 QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts,
3217  VectorType::VectorKind VecKind) const {
3218  assert(vecType->isBuiltinType());
3219 
3220  // Check if we've already instantiated a vector of this type.
3221  llvm::FoldingSetNodeID ID;
3222  VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind);
3223 
3224  void *InsertPos = nullptr;
3225  if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3226  return QualType(VTP, 0);
3227 
3228  // If the element type isn't canonical, this won't be a canonical type either,
3229  // so fill in the canonical type field.
3230  QualType Canonical;
3231  if (!vecType.isCanonical()) {
3232  Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind);
3233 
3234  // Get the new insert position for the node we care about.
3235  VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3236  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3237  }
3238  VectorType *New = new (*this, TypeAlignment)
3239  VectorType(vecType, NumElts, Canonical, VecKind);
3240  VectorTypes.InsertNode(New, InsertPos);
3241  Types.push_back(New);
3242  return QualType(New, 0);
3243 }
3244 
3245 /// getExtVectorType - Return the unique reference to an extended vector type of
3246 /// the specified element type and size. VectorType must be a built-in type.
3247 QualType
3248 ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const {
3249  assert(vecType->isBuiltinType() || vecType->isDependentType());
3250 
3251  // Check if we've already instantiated a vector of this type.
3252  llvm::FoldingSetNodeID ID;
3253  VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
3255  void *InsertPos = nullptr;
3256  if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3257  return QualType(VTP, 0);
3258 
3259  // If the element type isn't canonical, this won't be a canonical type either,
3260  // so fill in the canonical type field.
3261  QualType Canonical;
3262  if (!vecType.isCanonical()) {
3263  Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
3264 
3265  // Get the new insert position for the node we care about.
3266  VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3267  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3268  }
3269  ExtVectorType *New = new (*this, TypeAlignment)
3270  ExtVectorType(vecType, NumElts, Canonical);
3271  VectorTypes.InsertNode(New, InsertPos);
3272  Types.push_back(New);
3273  return QualType(New, 0);
3274 }
3275 
3276 QualType
3278  Expr *SizeExpr,
3279  SourceLocation AttrLoc) const {
3280  llvm::FoldingSetNodeID ID;
3282  SizeExpr);
3283 
3284  void *InsertPos = nullptr;
3286  = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3288  if (Canon) {
3289  // We already have a canonical version of this array type; use it as
3290  // the canonical type for a newly-built type.
3291  New = new (*this, TypeAlignment)
3292  DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
3293  SizeExpr, AttrLoc);
3294  } else {
3295  QualType CanonVecTy = getCanonicalType(vecType);
3296  if (CanonVecTy == vecType) {
3297  New = new (*this, TypeAlignment)
3298  DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
3299  AttrLoc);
3300 
3301  DependentSizedExtVectorType *CanonCheck
3302  = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3303  assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken");
3304  (void)CanonCheck;
3305  DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
3306  } else {
3307  QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
3308  SourceLocation());
3309  New = new (*this, TypeAlignment)
3310  DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc);
3311  }
3312  }
3313 
3314  Types.push_back(New);
3315  return QualType(New, 0);
3316 }
3317 
3319  Expr *AddrSpaceExpr,
3320  SourceLocation AttrLoc) const {
3321  assert(AddrSpaceExpr->isInstantiationDependent());
3322 
3323  QualType canonPointeeType = getCanonicalType(PointeeType);
3324 
3325  void *insertPos = nullptr;
3326  llvm::FoldingSetNodeID ID;
3327  DependentAddressSpaceType::Profile(ID, *this, canonPointeeType,
3328  AddrSpaceExpr);
3329 
3330  DependentAddressSpaceType *canonTy =
3331  DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
3332 
3333  if (!canonTy) {
3334  canonTy = new (*this, TypeAlignment)
3335  DependentAddressSpaceType(*this, canonPointeeType,
3336  QualType(), AddrSpaceExpr, AttrLoc);
3337  DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
3338  Types.push_back(canonTy);
3339  }
3340 
3341  if (canonPointeeType == PointeeType &&
3342  canonTy->getAddrSpaceExpr() == AddrSpaceExpr)
3343  return QualType(canonTy, 0);
3344 
3345  DependentAddressSpaceType *sugaredType
3346  = new (*this, TypeAlignment)
3347  DependentAddressSpaceType(*this, PointeeType, QualType(canonTy, 0),
3348  AddrSpaceExpr, AttrLoc);
3349  Types.push_back(sugaredType);
3350  return QualType(sugaredType, 0);
3351 }
3352 
3353 /// \brief Determine whether \p T is canonical as the result type of a function.
3355  return T.isCanonical() &&
3358 }
3359 
3360 /// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
3361 QualType
3363  const FunctionType::ExtInfo &Info) const {
3364  // Unique functions, to guarantee there is only one function of a particular
3365  // structure.
3366  llvm::FoldingSetNodeID ID;
3367  FunctionNoProtoType::Profile(ID, ResultTy, Info);
3368 
3369  void *InsertPos = nullptr;
3370  if (FunctionNoProtoType *FT =
3371  FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
3372  return QualType(FT, 0);
3373 
3374  QualType Canonical;
3375  if (!isCanonicalResultType(ResultTy)) {
3376  Canonical =
3378 
3379  // Get the new insert position for the node we care about.
3380  FunctionNoProtoType *NewIP =
3381  FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3382  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3383  }
3384 
3385  FunctionNoProtoType *New = new (*this, TypeAlignment)
3386  FunctionNoProtoType(ResultTy, Canonical, Info);
3387  Types.push_back(New);
3388  FunctionNoProtoTypes.InsertNode(New, InsertPos);
3389  return QualType(New, 0);
3390 }
3391 
3394  CanQualType CanResultType = getCanonicalType(ResultType);
3395 
3396  // Canonical result types do not have ARC lifetime qualifiers.
3397  if (CanResultType.getQualifiers().hasObjCLifetime()) {
3398  Qualifiers Qs = CanResultType.getQualifiers();
3399  Qs.removeObjCLifetime();
3401  getQualifiedType(CanResultType.getUnqualifiedType(), Qs));
3402  }
3403 
3404  return CanResultType;
3405 }
3406 
3408  const FunctionProtoType::ExceptionSpecInfo &ESI, bool NoexceptInType) {
3409  if (ESI.Type == EST_None)
3410  return true;
3411  if (!NoexceptInType)
3412  return false;
3413 
3414  // C++17 onwards: exception specification is part of the type, as a simple
3415  // boolean "can this function type throw".
3416  if (ESI.Type == EST_BasicNoexcept)
3417  return true;
3418 
3419  // A dynamic exception specification is canonical if it only contains pack
3420  // expansions (so we can't tell whether it's non-throwing) and all its
3421  // contained types are canonical.
3422  if (ESI.Type == EST_Dynamic) {
3423  bool AnyPackExpansions = false;
3424  for (QualType ET : ESI.Exceptions) {
3425  if (!ET.isCanonical())
3426  return false;
3427  if (ET->getAs<PackExpansionType>())
3428  AnyPackExpansions = true;
3429  }
3430  return AnyPackExpansions;
3431  }
3432 
3433  // A noexcept(expr) specification is (possibly) canonical if expr is
3434  // value-dependent.
3435  if (ESI.Type == EST_ComputedNoexcept)
3436  return ESI.NoexceptExpr && ESI.NoexceptExpr->isValueDependent();
3437 
3438  return false;
3439 }
3440 
3441 QualType ASTContext::getFunctionTypeInternal(
3442  QualType ResultTy, ArrayRef<QualType> ArgArray,
3443  const FunctionProtoType::ExtProtoInfo &EPI, bool OnlyWantCanonical) const {
3444  size_t NumArgs = ArgArray.size();
3445 
3446  // Unique functions, to guarantee there is only one function of a particular
3447  // structure.
3448  llvm::FoldingSetNodeID ID;
3449  FunctionProtoType::Profile(ID, ResultTy, ArgArray.begin(), NumArgs, EPI,
3450  *this, true);
3451 
3452  QualType Canonical;
3453  bool Unique = false;
3454 
3455  void *InsertPos = nullptr;
3456  if (FunctionProtoType *FPT =
3457  FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
3458  QualType Existing = QualType(FPT, 0);
3459 
3460  // If we find a pre-existing equivalent FunctionProtoType, we can just reuse
3461  // it so long as our exception specification doesn't contain a dependent
3462  // noexcept expression, or we're just looking for a canonical type.
3463  // Otherwise, we're going to need to create a type
3464  // sugar node to hold the concrete expression.
3465  if (OnlyWantCanonical || EPI.ExceptionSpec.Type != EST_ComputedNoexcept ||
3466  EPI.ExceptionSpec.NoexceptExpr == FPT->getNoexceptExpr())
3467  return Existing;
3468 
3469  // We need a new type sugar node for this one, to hold the new noexcept
3470  // expression. We do no canonicalization here, but that's OK since we don't
3471  // expect to see the same noexcept expression much more than once.
3472  Canonical = getCanonicalType(Existing);
3473  Unique = true;
3474  }
3475 
3476  bool NoexceptInType = getLangOpts().CPlusPlus17;
3477  bool IsCanonicalExceptionSpec =
3478  isCanonicalExceptionSpecification(EPI.ExceptionSpec, NoexceptInType);
3479 
3480  // Determine whether the type being created is already canonical or not.
3481  bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
3482  isCanonicalResultType(ResultTy) && !EPI.HasTrailingReturn;
3483  for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
3484  if (!ArgArray[i].isCanonicalAsParam())
3485  isCanonical = false;
3486 
3487  if (OnlyWantCanonical)
3488  assert(isCanonical &&
3489  "given non-canonical parameters constructing canonical type");
3490 
3491  // If this type isn't canonical, get the canonical version of it if we don't
3492  // already have it. The exception spec is only partially part of the
3493  // canonical type, and only in C++17 onwards.
3494  if (!isCanonical && Canonical.isNull()) {
3495  SmallVector<QualType, 16> CanonicalArgs;
3496  CanonicalArgs.reserve(NumArgs);
3497  for (unsigned i = 0; i != NumArgs; ++i)
3498  CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));
3499 
3500  llvm::SmallVector<QualType, 8> ExceptionTypeStorage;
3501  FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
3502  CanonicalEPI.HasTrailingReturn = false;
3503 
3504  if (IsCanonicalExceptionSpec) {
3505  // Exception spec is already OK.
3506  } else if (NoexceptInType) {
3507  switch (EPI.ExceptionSpec.Type) {
3509  // We don't know yet. It shouldn't matter what we pick here; no-one
3510  // should ever look at this.
3511  LLVM_FALLTHROUGH;
3512  case EST_None: case EST_MSAny:
3513  CanonicalEPI.ExceptionSpec.Type = EST_None;
3514  break;
3515 
3516  // A dynamic exception specification is almost always "not noexcept",
3517  // with the exception that a pack expansion might expand to no types.
3518  case EST_Dynamic: {
3519  bool AnyPacks = false;
3520  for (QualType ET : EPI.ExceptionSpec.Exceptions) {
3521  if (ET->getAs<PackExpansionType>())
3522  AnyPacks = true;
3523  ExceptionTypeStorage.push_back(getCanonicalType(ET));
3524  }
3525  if (!AnyPacks)
3526  CanonicalEPI.ExceptionSpec.Type = EST_None;
3527  else {
3528  CanonicalEPI.ExceptionSpec.Type = EST_Dynamic;
3529  CanonicalEPI.ExceptionSpec.Exceptions = ExceptionTypeStorage;
3530  }
3531  break;
3532  }
3533 
3535  CanonicalEPI.ExceptionSpec.Type = EST_BasicNoexcept;
3536  break;
3537 
3538  case EST_ComputedNoexcept:
3539  llvm::APSInt Value(1);
3540  auto *E = CanonicalEPI.ExceptionSpec.NoexceptExpr;
3541  if (!E || !E->isIntegerConstantExpr(Value, *this, nullptr,
3542  /*IsEvaluated*/false)) {
3543  // This noexcept specification is invalid.
3544  // FIXME: Should this be able to happen?
3545  CanonicalEPI.ExceptionSpec.Type = EST_None;
3546  break;
3547  }
3548 
3549  CanonicalEPI.ExceptionSpec.Type =
3550  Value.getBoolValue() ? EST_BasicNoexcept : EST_None;
3551  break;
3552  }
3553  } else {
3555  }
3556 
3557  // Adjust the canonical function result type.
3558  CanQualType CanResultTy = getCanonicalFunctionResultType(ResultTy);
3559  Canonical =
3560  getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI, true);
3561 
3562  // Get the new insert position for the node we care about.
3563  FunctionProtoType *NewIP =
3564  FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3565  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3566  }
3567 
3568  // FunctionProtoType objects are allocated with extra bytes after
3569  // them for three variable size arrays at the end:
3570  // - parameter types
3571  // - exception types
3572  // - extended parameter information
3573  // Instead of the exception types, there could be a noexcept
3574  // expression, or information used to resolve the exception
3575  // specification.
3576  size_t Size = sizeof(FunctionProtoType) +
3577  NumArgs * sizeof(QualType);
3578 
3579  if (EPI.ExceptionSpec.Type == EST_Dynamic) {
3580  Size += EPI.ExceptionSpec.Exceptions.size() * sizeof(QualType);
3581  } else if (EPI.ExceptionSpec.Type == EST_ComputedNoexcept) {
3582  Size += sizeof(Expr*);
3583  } else if (EPI.ExceptionSpec.Type == EST_Uninstantiated) {
3584  Size += 2 * sizeof(FunctionDecl*);
3585  } else if (EPI.ExceptionSpec.Type == EST_Unevaluated) {
3586  Size += sizeof(FunctionDecl*);
3587  }
3588 
3589  // Put the ExtParameterInfos last. If all were equal, it would make
3590  // more sense to put these before the exception specification, because
3591  // it's much easier to skip past them compared to the elaborate switch
3592  // required to skip the exception specification. However, all is not
3593  // equal; ExtParameterInfos are used to model very uncommon features,
3594  // and it's better not to burden the more common paths.
3595  if (EPI.ExtParameterInfos) {
3596  Size += NumArgs * sizeof(FunctionProtoType::ExtParameterInfo);
3597  }
3598 
3600  FunctionProtoType::ExtProtoInfo newEPI = EPI;
3601  new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
3602  Types.push_back(FTP);
3603  if (!Unique)
3604  FunctionProtoTypes.InsertNode(FTP, InsertPos);
3605  return QualType(FTP, 0);
3606 }
3607 
3608 QualType ASTContext::getPipeType(QualType T, bool ReadOnly) const {
3609  llvm::FoldingSetNodeID ID;
3610  PipeType::Profile(ID, T, ReadOnly);
3611 
3612  void *InsertPos = nullptr;
3613  if (PipeType *PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))
3614  return QualType(PT, 0);
3615 
3616  // If the pipe element type isn't canonical, this won't be a canonical type
3617  // either, so fill in the canonical type field.
3618  QualType Canonical;
3619  if (!T.isCanonical()) {
3620  Canonical = getPipeType(getCanonicalType(T), ReadOnly);
3621 
3622  // Get the new insert position for the node we care about.
3623  PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);
3624  assert(!NewIP && "Shouldn't be in the map!");
3625  (void)NewIP;
3626  }
3627  PipeType *New = new (*this, TypeAlignment) PipeType(T, Canonical, ReadOnly);
3628  Types.push_back(New);
3629  PipeTypes.InsertNode(New, InsertPos);
3630  return QualType(New, 0);
3631 }
3632 
3634  return getPipeType(T, true);
3635 }
3636 
3638  return getPipeType(T, false);
3639 }
3640 
3641 #ifndef NDEBUG
3643  if (!isa<CXXRecordDecl>(D)) return false;
3644  const CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
3645  if (isa<ClassTemplatePartialSpecializationDecl>(RD))
3646  return true;
3647  if (RD->getDescribedClassTemplate() &&
3648  !isa<ClassTemplateSpecializationDecl>(RD))
3649  return true;
3650  return false;
3651 }
3652 #endif
3653 
3654 /// getInjectedClassNameType - Return the unique reference to the
3655 /// injected class name type for the specified templated declaration.
3657  QualType TST) const {
3658  assert(NeedsInjectedClassNameType(Decl));
3659  if (Decl->TypeForDecl) {
3660  assert(isa<InjectedClassNameType>(Decl->TypeForDecl));
3661  } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) {
3662  assert(PrevDecl->TypeForDecl && "previous declaration has no type");
3663  Decl->TypeForDecl = PrevDecl->TypeForDecl;
3664  assert(isa<InjectedClassNameType>(Decl->TypeForDecl));
3665  } else {
3666  Type *newType =
3667  new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
3668  Decl->TypeForDecl = newType;
3669  Types.push_back(newType);
3670  }
3671  return QualType(Decl->TypeForDecl, 0);
3672 }
3673 
3674 /// getTypeDeclType - Return the unique reference to the type for the
3675 /// specified type declaration.
3676 QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const {
3677  assert(Decl && "Passed null for Decl param");
3678  assert(!Decl->TypeForDecl && "TypeForDecl present in slow case");
3679 
3680  if (const TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Decl))
3681  return getTypedefType(Typedef);
3682 
3683  assert(!isa<TemplateTypeParmDecl>(Decl) &&
3684  "Template type parameter types are always available.");
3685 
3686  if (const RecordDecl *Record = dyn_cast<RecordDecl>(Decl)) {
3687  assert(Record->isFirstDecl() && "struct/union has previous declaration");
3688  assert(!NeedsInjectedClassNameType(Record));
3689  return getRecordType(Record);
3690  } else if (const EnumDecl *Enum = dyn_cast<EnumDecl>(Decl)) {
3691  assert(Enum->isFirstDecl() && "enum has previous declaration");
3692  return getEnumType(Enum);
3693  } else if (const UnresolvedUsingTypenameDecl *Using =
3694  dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
3695  Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using);
3696  Decl->TypeForDecl = newType;
3697  Types.push_back(newType);
3698  } else
3699  llvm_unreachable("TypeDecl without a type?");
3700 
3701  return QualType(Decl->TypeForDecl, 0);
3702 }
3703 
3704 /// getTypedefType - Return the unique reference to the type for the
3705 /// specified typedef name decl.
3706 QualType
3708  QualType Canonical) const {
3709  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3710 
3711  if (Canonical.isNull())
3712  Canonical = getCanonicalType(Decl->getUnderlyingType());
3713  TypedefType *newType = new(*this, TypeAlignment)
3714  TypedefType(Type::Typedef, Decl, Canonical);
3715  Decl->TypeForDecl = newType;
3716  Types.push_back(newType);
3717  return QualType(newType, 0);
3718 }
3719 
3721  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3722 
3723  if (const RecordDecl *PrevDecl = Decl->getPreviousDecl())
3724  if (PrevDecl->TypeForDecl)
3725  return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3726 
3727  RecordType *newType = new (*this, TypeAlignment) RecordType(Decl);
3728  Decl->TypeForDecl = newType;
3729  Types.push_back(newType);
3730  return QualType(newType, 0);
3731 }
3732 
3734  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3735 
3736  if (const EnumDecl *PrevDecl = Decl->getPreviousDecl())
3737  if (PrevDecl->TypeForDecl)
3738  return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3739 
3740  EnumType *newType = new (*this, TypeAlignment) EnumType(Decl);
3741  Decl->TypeForDecl = newType;
3742  Types.push_back(newType);
3743  return QualType(newType, 0);
3744 }
3745 
3747  QualType modifiedType,
3748  QualType equivalentType) {
3749  llvm::FoldingSetNodeID id;
3750  AttributedType::Profile(id, attrKind, modifiedType, equivalentType);
3751 
3752  void *insertPos = nullptr;
3753  AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos);
3754  if (type) return QualType(type, 0);
3755 
3756  QualType canon = getCanonicalType(equivalentType);
3757  type = new (*this, TypeAlignment)
3758  AttributedType(canon, attrKind, modifiedType, equivalentType);
3759 
3760  Types.push_back(type);
3761  AttributedTypes.InsertNode(type, insertPos);
3762 
3763  return QualType(type, 0);
3764 }
3765 
3766 /// \brief Retrieve a substitution-result type.
3767 QualType
3769  QualType Replacement) const {
3770  assert(Replacement.isCanonical()
3771  && "replacement types must always be canonical");
3772 
3773  llvm::FoldingSetNodeID ID;
3774  SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
3775  void *InsertPos = nullptr;
3776  SubstTemplateTypeParmType *SubstParm
3777  = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3778 
3779  if (!SubstParm) {
3780  SubstParm = new (*this, TypeAlignment)
3781  SubstTemplateTypeParmType(Parm, Replacement);
3782  Types.push_back(SubstParm);
3783  SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
3784  }
3785 
3786  return QualType(SubstParm, 0);
3787 }
3788 
3789 /// \brief Retrieve a
3791  const TemplateTypeParmType *Parm,
3792  const TemplateArgument &ArgPack) {
3793 #ifndef NDEBUG
3794  for (const auto &P : ArgPack.pack_elements()) {
3795  assert(P.getKind() == TemplateArgument::Type &&"Pack contains a non-type");
3796  assert(P.getAsType().isCanonical() && "Pack contains non-canonical type");
3797  }
3798 #endif
3799 
3800  llvm::FoldingSetNodeID ID;
3801  SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack);
3802  void *InsertPos = nullptr;
3803  if (SubstTemplateTypeParmPackType *SubstParm
3804  = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
3805  return QualType(SubstParm, 0);
3806 
3807  QualType Canon;
3808  if (!Parm->isCanonicalUnqualified()) {
3809  Canon = getCanonicalType(QualType(Parm, 0));
3810  Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon),
3811  ArgPack);
3812  SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
3813  }
3814 
3816  = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon,
3817  ArgPack);
3818  Types.push_back(SubstParm);
3819  SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
3820  return QualType(SubstParm, 0);
3821 }
3822 
3823 /// \brief Retrieve the template type parameter type for a template
3824 /// parameter or parameter pack with the given depth, index, and (optionally)
3825 /// name.
3827  bool ParameterPack,
3828  TemplateTypeParmDecl *TTPDecl) const {
3829  llvm::FoldingSetNodeID ID;
3830  TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
3831  void *InsertPos = nullptr;
3832  TemplateTypeParmType *TypeParm
3833  = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3834 
3835  if (TypeParm)
3836  return QualType(TypeParm, 0);
3837 
3838  if (TTPDecl) {
3839  QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
3840  TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon);
3841 
3842  TemplateTypeParmType *TypeCheck
3843  = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3844  assert(!TypeCheck && "Template type parameter canonical type broken");
3845  (void)TypeCheck;
3846  } else
3847  TypeParm = new (*this, TypeAlignment)
3848  TemplateTypeParmType(Depth, Index, ParameterPack);
3849 
3850  Types.push_back(TypeParm);
3851  TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
3852 
3853  return QualType(TypeParm, 0);
3854 }
3855 
3858  SourceLocation NameLoc,
3859  const TemplateArgumentListInfo &Args,
3860  QualType Underlying) const {
3861  assert(!Name.getAsDependentTemplateName() &&
3862  "No dependent template names here!");
3863  QualType TST = getTemplateSpecializationType(Name, Args, Underlying);
3864 
3869  TL.setTemplateNameLoc(NameLoc);
3870  TL.setLAngleLoc(Args.getLAngleLoc());
3871  TL.setRAngleLoc(Args.getRAngleLoc());
3872  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3873  TL.setArgLocInfo(i, Args[i].getLocInfo());
3874  return DI;
3875 }
3876 
3877 QualType
3879  const TemplateArgumentListInfo &Args,
3880  QualType Underlying) const {
3881  assert(!Template.getAsDependentTemplateName() &&
3882  "No dependent template names here!");
3883 
3885  ArgVec.reserve(Args.size());
3886  for (const TemplateArgumentLoc &Arg : Args.arguments())
3887  ArgVec.push_back(Arg.getArgument());
3888 
3889  return getTemplateSpecializationType(Template, ArgVec, Underlying);
3890 }
3891 
3892 #ifndef NDEBUG
3894  for (const TemplateArgument &Arg : Args)
3895  if (Arg.isPackExpansion())
3896  return true;
3897 
3898  return true;
3899 }
3900 #endif
3901 
3902 QualType
3905  QualType Underlying) const {
3906  assert(!Template.getAsDependentTemplateName() &&
3907  "No dependent template names here!");
3908  // Look through qualified template names.
3909  if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
3910  Template = TemplateName(QTN->getTemplateDecl());
3911 
3912  bool IsTypeAlias =
3913  Template.getAsTemplateDecl() &&
3914  isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
3915  QualType CanonType;
3916  if (!Underlying.isNull())
3917  CanonType = getCanonicalType(Underlying);
3918  else {
3919  // We can get here with an alias template when the specialization contains
3920  // a pack expansion that does not match up with a parameter pack.
3921  assert((!IsTypeAlias || hasAnyPackExpansions(Args)) &&
3922  "Caller must compute aliased type");
3923  IsTypeAlias = false;
3924  CanonType = getCanonicalTemplateSpecializationType(Template, Args);
3925  }
3926 
3927  // Allocate the (non-canonical) template specialization type, but don't
3928  // try to unique it: these types typically have location information that
3929  // we don't unique and don't want to lose.
3930  void *Mem = Allocate(sizeof(TemplateSpecializationType) +
3931  sizeof(TemplateArgument) * Args.size() +
3932  (IsTypeAlias? sizeof(QualType) : 0),
3933  TypeAlignment);
3935  = new (Mem) TemplateSpecializationType(Template, Args, CanonType,
3936  IsTypeAlias ? Underlying : QualType());
3937 
3938  Types.push_back(Spec);
3939  return QualType(Spec, 0);
3940 }
3941 
3943  TemplateName Template, ArrayRef<TemplateArgument> Args) const {
3944  assert(!Template.getAsDependentTemplateName() &&
3945  "No dependent template names here!");
3946 
3947  // Look through qualified template names.
3948  if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
3949  Template = TemplateName(QTN->getTemplateDecl());
3950 
3951  // Build the canonical template specialization type.
3952  TemplateName CanonTemplate = getCanonicalTemplateName(Template);
3954  unsigned NumArgs = Args.size();
3955  CanonArgs.reserve(NumArgs);
3956  for (const TemplateArgument &Arg : Args)
3957  CanonArgs.push_back(getCanonicalTemplateArgument(Arg));
3958 
3959  // Determine whether this canonical template specialization type already
3960  // exists.
3961  llvm::FoldingSetNodeID ID;
3962  TemplateSpecializationType::Profile(ID, CanonTemplate,
3963  CanonArgs, *this);
3964 
3965  void *InsertPos = nullptr;
3967  = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
3968 
3969  if (!Spec) {
3970  // Allocate a new canonical template specialization type.
3971  void *Mem = Allocate((sizeof(TemplateSpecializationType) +
3972  sizeof(TemplateArgument) * NumArgs),
3973  TypeAlignment);
3974  Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
3975  CanonArgs,
3976  QualType(), QualType());
3977  Types.push_back(Spec);
3978  TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
3979  }
3980 
3981  assert(Spec->isDependentType() &&
3982  "Non-dependent template-id type must have a canonical type");
3983  return QualType(Spec, 0);
3984 }
3985 
3986 QualType
3988  NestedNameSpecifier *NNS,
3989  QualType NamedType) const {
3990  llvm::FoldingSetNodeID ID;
3991  ElaboratedType::Profile(ID, Keyword, NNS, NamedType);
3992 
3993  void *InsertPos = nullptr;
3994  ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
3995  if (T)
3996  return QualType(T, 0);
3997 
3998  QualType Canon = NamedType;
3999  if (!Canon.isCanonical()) {
4000  Canon = getCanonicalType(NamedType);
4001  ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
4002  assert(!CheckT && "Elaborated canonical type broken");
4003  (void)CheckT;
4004  }
4005 
4006  T = new (*this, TypeAlignment) ElaboratedType(Keyword, NNS, NamedType, Canon);
4007  Types.push_back(T);
4008  ElaboratedTypes.InsertNode(T, InsertPos);
4009  return QualType(T, 0);
4010 }
4011 
4012 QualType
4014  llvm::FoldingSetNodeID ID;
4015  ParenType::Profile(ID, InnerType);
4016 
4017  void *InsertPos = nullptr;
4018  ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4019  if (T)
4020  return QualType(T, 0);
4021 
4022  QualType Canon = InnerType;
4023  if (!Canon.isCanonical()) {
4024  Canon = getCanonicalType(InnerType);
4025  ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4026  assert(!CheckT && "Paren canonical type broken");
4027  (void)CheckT;
4028  }
4029 
4030  T = new (*this, TypeAlignment) ParenType(InnerType, Canon);
4031  Types.push_back(T);
4032  ParenTypes.InsertNode(T, InsertPos);
4033  return QualType(T, 0);
4034 }
4035 
4037  NestedNameSpecifier *NNS,
4038  const IdentifierInfo *Name,
4039  QualType Canon) const {
4040  if (Canon.isNull()) {
4042  if (CanonNNS != NNS)
4043  Canon = getDependentNameType(Keyword, CanonNNS, Name);
4044  }
4045 
4046  llvm::FoldingSetNodeID ID;
4047  DependentNameType::Profile(ID, Keyword, NNS, Name);
4048 
4049  void *InsertPos = nullptr;
4051  = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
4052  if (T)
4053  return QualType(T, 0);
4054 
4055  T = new (*this, TypeAlignment) DependentNameType(Keyword, NNS, Name, Canon);
4056  Types.push_back(T);
4057  DependentNameTypes.InsertNode(T, InsertPos);
4058  return QualType(T, 0);
4059 }
4060 
4061 QualType
4063  ElaboratedTypeKeyword Keyword,
4064  NestedNameSpecifier *NNS,
4065  const IdentifierInfo *Name,
4066  const TemplateArgumentListInfo &Args) const {
4067  // TODO: avoid this copy
4069  for (unsigned I = 0, E = Args.size(); I != E; ++I)
4070  ArgCopy.push_back(Args[I].getArgument());
4071  return getDependentTemplateSpecializationType(Keyword, NNS, Name, ArgCopy);
4072 }
4073 
4074 QualType
4076  ElaboratedTypeKeyword Keyword,
4077  NestedNameSpecifier *NNS,
4078  const IdentifierInfo *Name,
4079  ArrayRef<TemplateArgument> Args) const {
4080  assert((!NNS || NNS->isDependent()) &&
4081  "nested-name-specifier must be dependent");
4082 
4083  llvm::FoldingSetNodeID ID;
4084  DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
4085  Name, Args);
4086 
4087  void *InsertPos = nullptr;
4089  = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4090  if (T)
4091  return QualType(T, 0);
4092 
4094 
4095  ElaboratedTypeKeyword CanonKeyword = Keyword;
4096  if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
4097 
4098  bool AnyNonCanonArgs = false;
4099  unsigned NumArgs = Args.size();
4100  SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
4101  for (unsigned I = 0; I != NumArgs; ++I) {
4102  CanonArgs[I] = getCanonicalTemplateArgument(Args[I]);
4103  if (!CanonArgs[I].structurallyEquals(Args[I]))
4104  AnyNonCanonArgs = true;
4105  }
4106 
4107  QualType Canon;
4108  if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
4109  Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
4110  Name,
4111  CanonArgs);
4112 
4113  // Find the insert position again.
4114  DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4115  }
4116 
4117  void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
4118  sizeof(TemplateArgument) * NumArgs),
4119  TypeAlignment);
4120  T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
4121  Name, Args, Canon);
4122  Types.push_back(T);
4123  DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
4124  return QualType(T, 0);
4125 }
4126 
4128  TemplateArgument Arg;
4129  if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
4130  QualType ArgType = getTypeDeclType(TTP);
4131  if (TTP->isParameterPack())
4132  ArgType = getPackExpansionType(ArgType, None);
4133 
4134  Arg = TemplateArgument(ArgType);
4135  } else if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4136  Expr *E = new (*this) DeclRefExpr(
4137  NTTP, /*enclosing*/false,
4138  NTTP->getType().getNonLValueExprType(*this),
4139  Expr::getValueKindForType(NTTP->getType()), NTTP->getLocation());
4140 
4141  if (NTTP->isParameterPack())
4142  E = new (*this) PackExpansionExpr(DependentTy, E, NTTP->getLocation(),
4143  None);
4144  Arg = TemplateArgument(E);
4145  } else {
4146  auto *TTP = cast<TemplateTemplateParmDecl>(Param);
4147  if (TTP->isParameterPack())
4149  else
4150  Arg = TemplateArgument(TemplateName(TTP));
4151  }
4152 
4153  if (Param->isTemplateParameterPack())
4154  Arg = TemplateArgument::CreatePackCopy(*this, Arg);
4155 
4156  return Arg;
4157 }
4158 
4159 void
4162  Args.reserve(Args.size() + Params->size());
4163 
4164  for (NamedDecl *Param : *Params)
4165  Args.push_back(getInjectedTemplateArg(Param));
4166 }
4167 
4169  Optional<unsigned> NumExpansions) {
4170  llvm::FoldingSetNodeID ID;
4171  PackExpansionType::Profile(ID, Pattern, NumExpansions);
4172 
4173  assert(Pattern->containsUnexpandedParameterPack() &&
4174  "Pack expansions must expand one or more parameter packs");
4175  void *InsertPos = nullptr;
4177  = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4178  if (T)
4179  return QualType(T, 0);
4180 
4181  QualType Canon;
4182  if (!Pattern.isCanonical()) {
4183  Canon = getCanonicalType(Pattern);
4184  // The canonical type might not contain an unexpanded parameter pack, if it
4185  // contains an alias template specialization which ignores one of its
4186  // parameters.
4187  if (Canon->containsUnexpandedParameterPack()) {
4188  Canon = getPackExpansionType(Canon, NumExpansions);
4189 
4190  // Find the insert position again, in case we inserted an element into
4191  // PackExpansionTypes and invalidated our insert position.
4192  PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4193  }
4194  }
4195 
4196  T = new (*this, TypeAlignment)
4197  PackExpansionType(Pattern, Canon, NumExpansions);
4198  Types.push_back(T);
4199  PackExpansionTypes.InsertNode(T, InsertPos);
4200  return QualType(T, 0);
4201 }
4202 
4203 /// CmpProtocolNames - Comparison predicate for sorting protocols
4204 /// alphabetically.
4205 static int CmpProtocolNames(ObjCProtocolDecl *const *LHS,
4206  ObjCProtocolDecl *const *RHS) {
4207  return DeclarationName::compare((*LHS)->getDeclName(), (*RHS)->getDeclName());
4208 }
4209 
4211  if (Protocols.empty()) return true;
4212 
4213  if (Protocols[0]->getCanonicalDecl() != Protocols[0])
4214  return false;
4215 
4216  for (unsigned i = 1; i != Protocols.size(); ++i)
4217  if (CmpProtocolNames(&Protocols[i - 1], &Protocols[i]) >= 0 ||
4218  Protocols[i]->getCanonicalDecl() != Protocols[i])
4219  return false;
4220  return true;
4221 }
4222 
4223 static void
4225  // Sort protocols, keyed by name.
4226  llvm::array_pod_sort(Protocols.begin(), Protocols.end(), CmpProtocolNames);
4227 
4228  // Canonicalize.
4229  for (ObjCProtocolDecl *&P : Protocols)
4230  P = P->getCanonicalDecl();
4231 
4232  // Remove duplicates.
4233  auto ProtocolsEnd = std::unique(Protocols.begin(), Protocols.end());
4234  Protocols.erase(ProtocolsEnd, Protocols.end());
4235 }
4236 
4238  ObjCProtocolDecl * const *Protocols,
4239  unsigned NumProtocols) const {
4240  return getObjCObjectType(BaseType, {},
4241  llvm::makeArrayRef(Protocols, NumProtocols),
4242  /*isKindOf=*/false);
4243 }
4244 
4246  QualType baseType,
4247  ArrayRef<QualType> typeArgs,
4248  ArrayRef<ObjCProtocolDecl *> protocols,
4249  bool isKindOf) const {
4250  // If the base type is an interface and there aren't any protocols or
4251  // type arguments to add, then the interface type will do just fine.
4252  if (typeArgs.empty() && protocols.empty() && !isKindOf &&
4253  isa<ObjCInterfaceType>(baseType))
4254  return baseType;
4255 
4256  // Look in the folding set for an existing type.
4257  llvm::FoldingSetNodeID ID;
4258  ObjCObjectTypeImpl::Profile(ID, baseType, typeArgs, protocols, isKindOf);
4259  void *InsertPos = nullptr;
4260  if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
4261  return QualType(QT, 0);
4262 
4263  // Determine the type arguments to be used for canonicalization,
4264  // which may be explicitly specified here or written on the base
4265  // type.
4266  ArrayRef<QualType> effectiveTypeArgs = typeArgs;
4267  if (effectiveTypeArgs.empty()) {
4268  if (auto baseObject = baseType->getAs<ObjCObjectType>())
4269  effectiveTypeArgs = baseObject->getTypeArgs();
4270  }
4271 
4272  // Build the canonical type, which has the canonical base type and a
4273  // sorted-and-uniqued list of protocols and the type arguments
4274  // canonicalized.
4275  QualType canonical;
4276  bool typeArgsAreCanonical = std::all_of(effectiveTypeArgs.begin(),
4277  effectiveTypeArgs.end(),
4278  [&](QualType type) {
4279  return type.isCanonical();
4280  });
4281  bool protocolsSorted = areSortedAndUniqued(protocols);
4282  if (!typeArgsAreCanonical || !protocolsSorted || !baseType.isCanonical()) {
4283  // Determine the canonical type arguments.
4284  ArrayRef<QualType> canonTypeArgs;
4285  SmallVector<QualType, 4> canonTypeArgsVec;
4286  if (!typeArgsAreCanonical) {
4287  canonTypeArgsVec.reserve(effectiveTypeArgs.size());
4288  for (auto typeArg : effectiveTypeArgs)
4289  canonTypeArgsVec.push_back(getCanonicalType(typeArg));
4290  canonTypeArgs = canonTypeArgsVec;
4291  } else {
4292  canonTypeArgs = effectiveTypeArgs;
4293  }
4294 
4295  ArrayRef<ObjCProtocolDecl *> canonProtocols;
4296  SmallVector<ObjCProtocolDecl*, 8> canonProtocolsVec;
4297  if (!protocolsSorted) {
4298  canonProtocolsVec.append(protocols.begin(), protocols.end());
4299  SortAndUniqueProtocols(canonProtocolsVec);
4300  canonProtocols = canonProtocolsVec;
4301  } else {
4302  canonProtocols = protocols;
4303  }
4304 
4305  canonical = getObjCObjectType(getCanonicalType(baseType), canonTypeArgs,
4306  canonProtocols, isKindOf);
4307 
4308  // Regenerate InsertPos.
4309  ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
4310  }
4311 
4312  unsigned size = sizeof(ObjCObjectTypeImpl);
4313  size += typeArgs.size() * sizeof(QualType);
4314  size += protocols.size() * sizeof(ObjCProtocolDecl *);
4315  void *mem = Allocate(size, TypeAlignment);
4316  ObjCObjectTypeImpl *T =
4317  new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
4318  isKindOf);
4319 
4320  Types.push_back(T);
4321  ObjCObjectTypes.InsertNode(T, InsertPos);
4322  return QualType(T, 0);
4323 }
4324 
4325 /// Apply Objective-C protocol qualifiers to the given type.
4326 /// If this is for the canonical type of a type parameter, we can apply
4327 /// protocol qualifiers on the ObjCObjectPointerType.
4328 QualType
4330  ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
4331  bool allowOnPointerType) const {
4332  hasError = false;
4333 
4334  if (const ObjCTypeParamType *objT =
4335  dyn_cast<ObjCTypeParamType>(type.getTypePtr())) {
4336  return getObjCTypeParamType(objT->getDecl(), protocols);
4337  }
4338 
4339  // Apply protocol qualifiers to ObjCObjectPointerType.
4340  if (allowOnPointerType) {
4341  if (const ObjCObjectPointerType *objPtr =
4342  dyn_cast<ObjCObjectPointerType>(type.getTypePtr())) {
4343  const ObjCObjectType *objT = objPtr->getObjectType();
4344  // Merge protocol lists and construct ObjCObjectType.
4345  SmallVector<ObjCProtocolDecl*, 8> protocolsVec;
4346  protocolsVec.append(objT->qual_begin(),
4347  objT->qual_end());
4348  protocolsVec.append(protocols.begin(), protocols.end());
4349  ArrayRef<ObjCProtocolDecl *> protocols = protocolsVec;
4350  type = getObjCObjectType(
4351  objT->getBaseType(),
4352  objT->getTypeArgsAsWritten(),
4353  protocols,
4354  objT->isKindOfTypeAsWritten());
4355  return getObjCObjectPointerType(type);
4356  }
4357  }
4358 
4359  // Apply protocol qualifiers to ObjCObjectType.
4360  if (const ObjCObjectType *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){
4361  // FIXME: Check for protocols to which the class type is already
4362  // known to conform.
4363 
4364  return getObjCObjectType(objT->getBaseType(),
4365  objT->getTypeArgsAsWritten(),
4366  protocols,
4367  objT->isKindOfTypeAsWritten());
4368  }
4369 
4370  // If the canonical type is ObjCObjectType, ...
4371  if (type->isObjCObjectType()) {
4372  // Silently overwrite any existing protocol qualifiers.
4373  // TODO: determine whether that's the right thing to do.
4374 
4375  // FIXME: Check for protocols to which the class type is already
4376  // known to conform.
4377  return getObjCObjectType(type, {}, protocols, false);
4378  }
4379 
4380  // id<protocol-list>
4381  if (type->isObjCIdType()) {
4382  const ObjCObjectPointerType *objPtr = type->castAs<ObjCObjectPointerType>();
4383  type = getObjCObjectType(ObjCBuiltinIdTy, {}, protocols,
4384  objPtr->isKindOfType());
4385  return getObjCObjectPointerType(type);
4386  }
4387 
4388  // Class<protocol-list>
4389  if (type->isObjCClassType()) {
4390  const ObjCObjectPointerType *objPtr = type->castAs<ObjCObjectPointerType>();
4391  type = getObjCObjectType(ObjCBuiltinClassTy, {}, protocols,
4392  objPtr->isKindOfType());
4393  return getObjCObjectPointerType(type);
4394  }
4395 
4396  hasError = true;
4397  return type;
4398 }
4399 
4400 QualType
4402  ArrayRef<ObjCProtocolDecl *> protocols,
4403  QualType Canonical) const {
4404  // Look in the folding set for an existing type.
4405  llvm::FoldingSetNodeID ID;
4406  ObjCTypeParamType::Profile(ID, Decl, protocols);
4407  void *InsertPos = nullptr;
4408  if (ObjCTypeParamType *TypeParam =
4409  ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
4410  return QualType(TypeParam, 0);
4411 
4412  if (Canonical.isNull()) {
4413  // We canonicalize to the underlying type.
4414  Canonical = getCanonicalType(Decl->getUnderlyingType());
4415  if (!protocols.empty()) {
4416  // Apply the protocol qualifers.
4417  bool hasError;
4418  Canonical = applyObjCProtocolQualifiers(Canonical, protocols, hasError,
4419  true/*allowOnPointerType*/);
4420  assert(!hasError && "Error when apply protocol qualifier to bound type");
4421  }
4422  }
4423 
4424  unsigned size = sizeof(ObjCTypeParamType);
4425  size += protocols.size() * sizeof(ObjCProtocolDecl *);
4426  void *mem = Allocate(size, TypeAlignment);
4427  ObjCTypeParamType *newType = new (mem)
4428  ObjCTypeParamType(Decl, Canonical, protocols);
4429 
4430  Types.push_back(newType);
4431  ObjCTypeParamTypes.InsertNode(newType, InsertPos);
4432  return QualType(newType, 0);
4433 }
4434 
4435 /// ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC's
4436 /// protocol list adopt all protocols in QT's qualified-id protocol
4437 /// list.
4439  ObjCInterfaceDecl *IC) {
4440  if (!QT->isObjCQualifiedIdType())
4441  return false;
4442 
4443  if (const ObjCObjectPointerType *OPT = QT->getAs<ObjCObjectPointerType>()) {
4444  // If both the right and left sides have qualifiers.
4445  for (auto *Proto : OPT->quals()) {
4446  if (!IC->ClassImplementsProtocol(Proto, false))
4447  return false;
4448  }
4449  return true;
4450  }
4451  return false;
4452 }
4453 
4454 /// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
4455 /// QT's qualified-id protocol list adopt all protocols in IDecl's list
4456 /// of protocols.
4458  ObjCInterfaceDecl *IDecl) {
4459  if (!QT->isObjCQualifiedIdType())
4460  return false;
4462  if (!OPT)
4463  return false;
4464  if (!IDecl->hasDefinition())
4465  return false;
4466  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols;
4467  CollectInheritedProtocols(IDecl, InheritedProtocols);
4468  if (InheritedProtocols.empty())
4469  return false;
4470  // Check that if every protocol in list of id<plist> conforms to a protcol
4471  // of IDecl's, then bridge casting is ok.
4472  bool Conforms = false;
4473  for (auto *Proto : OPT->quals()) {
4474  Conforms = false;
4475  for (auto *PI : InheritedProtocols) {
4476  if (ProtocolCompatibleWithProtocol(Proto, PI)) {
4477  Conforms = true;
4478  break;
4479  }
4480  }
4481  if (!Conforms)
4482  break;
4483  }
4484  if (Conforms)
4485  return true;
4486 
4487  for (auto *PI : InheritedProtocols) {
4488  // If both the right and left sides have qualifiers.
4489  bool Adopts = false;
4490  for (auto *Proto : OPT->quals()) {
4491  // return 'true' if 'PI' is in the inheritance hierarchy of Proto
4492  if ((Adopts = ProtocolCompatibleWithProtocol(PI, Proto)))
4493  break;
4494  }
4495  if (!Adopts)
4496  return false;
4497  }
4498  return true;
4499 }
4500 
4501 /// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
4502 /// the given object type.
4504  llvm::FoldingSetNodeID ID;
4505  ObjCObjectPointerType::Profile(ID, ObjectT);
4506 
4507  void *InsertPos = nullptr;
4508  if (ObjCObjectPointerType *QT =
4509  ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
4510  return QualType(QT, 0);
4511 
4512  // Find the canonical object type.
4513  QualType Canonical;
4514  if (!ObjectT.isCanonical()) {
4515  Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));
4516 
4517  // Regenerate InsertPos.
4518  ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
4519  }
4520 
4521  // No match.
4522  void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
4523  ObjCObjectPointerType *QType =
4524  new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
4525 
4526  Types.push_back(QType);
4527  ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
4528  return QualType(QType, 0);
4529 }
4530 
4531 /// getObjCInterfaceType - Return the unique reference to the type for the
4532 /// specified ObjC interface decl. The list of protocols is optional.
4534  ObjCInterfaceDecl *PrevDecl) const {
4535  if (Decl->TypeForDecl)
4536  return QualType(Decl->TypeForDecl, 0);
4537 
4538  if (PrevDecl) {
4539  assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl");
4540  Decl->TypeForDecl = PrevDecl->TypeForDecl;
4541  return QualType(PrevDecl->TypeForDecl, 0);
4542  }
4543 
4544  // Prefer the definition, if there is one.
4545  if (const ObjCInterfaceDecl *Def = Decl->getDefinition())
4546  Decl = Def;
4547 
4548  void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
4549  ObjCInterfaceType *T = new (Mem) ObjCInterfaceType(Decl);
4550  Decl->TypeForDecl = T;
4551  Types.push_back(T);
4552  return QualType(T, 0);
4553 }
4554 
4555 /// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
4556 /// TypeOfExprType AST's (since expression's are never shared). For example,
4557 /// multiple declarations that refer to "typeof(x)" all contain different
4558 /// DeclRefExpr's. This doesn't effect the type checker, since it operates
4559 /// on canonical type's (which are always unique).
4561  TypeOfExprType *toe;
4562  if (tofExpr->isTypeDependent()) {
4563  llvm::FoldingSetNodeID ID;
4564  DependentTypeOfExprType::Profile(ID, *this, tofExpr);
4565 
4566  void *InsertPos = nullptr;
4568  = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
4569  if (Canon) {
4570  // We already have a "canonical" version of an identical, dependent
4571  // typeof(expr) type. Use that as our canonical type.
4572  toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
4573  QualType((TypeOfExprType*)Canon, 0));
4574  } else {
4575  // Build a new, canonical typeof(expr) type.
4576  Canon
4577  = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
4578  DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
4579  toe = Canon;
4580  }
4581  } else {
4582  QualType Canonical = getCanonicalType(tofExpr->getType());
4583  toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
4584  }
4585  Types.push_back(toe);
4586  return QualType(toe, 0);
4587 }
4588 
4589 /// getTypeOfType - Unlike many "get<Type>" functions, we don't unique
4590 /// TypeOfType nodes. The only motivation to unique these nodes would be
4591 /// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
4592 /// an issue. This doesn't affect the type checker, since it operates
4593 /// on canonical types (which are always unique).
4595  QualType Canonical = getCanonicalType(tofType);
4596  TypeOfType *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
4597  Types.push_back(tot);
4598  return QualType(tot, 0);
4599 }
4600 
4601 /// \brief Unlike many "get<Type>" functions, we don't unique DecltypeType
4602 /// nodes. This would never be helpful, since each such type has its own
4603 /// expression, and would not give a significant memory saving, since there
4604 /// is an Expr tree under each such type.
4606  DecltypeType *dt;
4607 
4608  // C++11 [temp.type]p2:
4609  // If an expression e involves a template parameter, decltype(e) denotes a
4610  // unique dependent type. Two such decltype-specifiers refer to the same
4611  // type only if their expressions are equivalent (14.5.6.1).
4612  if (e->isInstantiationDependent()) {
4613  llvm::FoldingSetNodeID ID;
4614  DependentDecltypeType::Profile(ID, *this, e);
4615 
4616  void *InsertPos = nullptr;
4617  DependentDecltypeType *Canon
4618  = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
4619  if (!Canon) {
4620  // Build a new, canonical decltype(expr) type.
4621  Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
4622  DependentDecltypeTypes.InsertNode(Canon, InsertPos);
4623  }
4624  dt = new (*this, TypeAlignment)
4625  DecltypeType(e, UnderlyingType, QualType((DecltypeType *)Canon, 0));
4626  } else {
4627  dt = new (*this, TypeAlignment)
4628  DecltypeType(e, UnderlyingType, getCanonicalType(UnderlyingType));
4629  }
4630  Types.push_back(dt);
4631  return QualType(dt, 0);
4632 }
4633 
4634 /// getUnaryTransformationType - We don't unique these, since the memory
4635 /// savings are minimal and these are rare.
4637  QualType UnderlyingType,
4639  const {
4640  UnaryTransformType *ut = nullptr;
4641 
4642  if (BaseType->isDependentType()) {
4643  // Look in the folding set for an existing type.
4644  llvm::FoldingSetNodeID ID;
4646 
4647  void *InsertPos = nullptr;
4649  = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
4650 
4651  if (!Canon) {
4652  // Build a new, canonical __underlying_type(type) type.
4653  Canon = new (*this, TypeAlignment)
4655  Kind);
4656  DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);
4657  }
4658  ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4659  QualType(), Kind,
4660  QualType(Canon, 0));
4661  } else {
4662  QualType CanonType = getCanonicalType(UnderlyingType);
4663  ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4664  UnderlyingType, Kind,
4665  CanonType);
4666  }
4667  Types.push_back(ut);
4668  return QualType(ut, 0);
4669 }
4670 
4671 /// getAutoType - Return the uniqued reference to the 'auto' type which has been
4672 /// deduced to the given type, or to the canonical undeduced 'auto' type, or the
4673 /// canonical deduced-but-dependent 'auto' type.
4675  bool IsDependent) const {
4676  if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto && !IsDependent)
4677  return getAutoDeductType();
4678 
4679  // Look in the folding set for an existing type.
4680  void *InsertPos = nullptr;
4681  llvm::FoldingSetNodeID ID;
4682  AutoType::Profile(ID, DeducedType, Keyword, IsDependent);
4683  if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
4684  return QualType(AT, 0);
4685 
4686  AutoType *AT = new (*this, TypeAlignment) AutoType(DeducedType,
4687  Keyword,
4688  IsDependent);
4689  Types.push_back(AT);
4690  if (InsertPos)
4691  AutoTypes.InsertNode(AT, InsertPos);
4692  return QualType(AT, 0);
4693 }
4694 
4695 /// Return the uniqued reference to the deduced template specialization type
4696 /// which has been deduced to the given type, or to the canonical undeduced
4697 /// such type, or the canonical deduced-but-dependent such type.
4699  TemplateName Template, QualType DeducedType, bool IsDependent) const {
4700  // Look in the folding set for an existing type.
4701  void *InsertPos = nullptr;
4702  llvm::FoldingSetNodeID ID;
4703  DeducedTemplateSpecializationType::Profile(ID, Template, DeducedType,
4704  IsDependent);
4706  DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
4707  return QualType(DTST, 0);
4708 
4710  DeducedTemplateSpecializationType(Template, DeducedType, IsDependent);
4711  Types.push_back(DTST);
4712  if (InsertPos)
4713  DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
4714  return QualType(DTST, 0);
4715 }
4716 
4717 /// getAtomicType - Return the uniqued reference to the atomic type for
4718 /// the given value type.
4720  // Unique pointers, to guarantee there is only one pointer of a particular
4721  // structure.
4722  llvm::FoldingSetNodeID ID;
4723  AtomicType::Profile(ID, T);
4724 
4725  void *InsertPos = nullptr;
4726  if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
4727  return QualType(AT, 0);
4728 
4729  // If the atomic value type isn't canonical, this won't be a canonical type
4730  // either, so fill in the canonical type field.
4731  QualType Canonical;
4732  if (!T.isCanonical()) {
4733  Canonical = getAtomicType(getCanonicalType(T));
4734 
4735  // Get the new insert position for the node we care about.
4736  AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
4737  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
4738  }
4739  AtomicType *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
4740  Types.push_back(New);
4741  AtomicTypes.InsertNode(New, InsertPos);
4742  return QualType(New, 0);
4743 }
4744 
4745 /// getAutoDeductType - Get type pattern for deducing against 'auto'.
4747  if (AutoDeductTy.isNull())
4750  /*dependent*/false),
4751  0);
4752  return AutoDeductTy;
4753 }
4754 
4755 /// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'.
4757  if (AutoRRefDeductTy.isNull())
4759  assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern");
4760  return AutoRRefDeductTy;
4761 }
4762 
4763 /// getTagDeclType - Return the unique reference to the type for the
4764 /// specified TagDecl (struct/union/class/enum) decl.
4766  assert(Decl);
4767  // FIXME: What is the design on getTagDeclType when it requires casting
4768  // away const? mutable?
4769  return getTypeDeclType(const_cast<TagDecl*>(Decl));
4770 }
4771 
4772 /// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
4773 /// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
4774 /// needs to agree with the definition in <stddef.h>.
4776  return getFromTargetType(Target->getSizeType());
4777 }
4778 
4779 /// Return the unique signed counterpart of the integer type
4780 /// corresponding to size_t.
4782  return getFromTargetType(Target->getSignedSizeType());
4783 }
4784 
4785 /// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5).
4787  return getFromTargetType(Target->getIntMaxType());
4788 }
4789 
4790 /// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5).
4792  return getFromTargetType(Target->getUIntMaxType());
4793 }
4794 
4795 /// getSignedWCharType - Return the type of "signed wchar_t".
4796 /// Used when in C++, as a GCC extension.
4798  // FIXME: derive from "Target" ?
4799  return WCharTy;
4800 }
4801 
4802 /// getUnsignedWCharType - Return the type of "unsigned wchar_t".
4803 /// Used when in C++, as a GCC extension.
4805  // FIXME: derive from "Target" ?
4806  return UnsignedIntTy;
4807 }
4808 
4810  return getFromTargetType(Target->getIntPtrType());
4811 }
4812 
4815 }
4816 
4817 /// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17)
4818 /// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
4820  return getFromTargetType(Target->getPtrDiffType(0));
4821 }
4822 
4823 /// \brief Return the unique unsigned counterpart of "ptrdiff_t"
4824 /// integer type. The standard (C11 7.21.6.1p7) refers to this type
4825 /// in the definition of %tu format specifier.
4827  return getFromTargetType(Target->getUnsignedPtrDiffType(0));
4828 }
4829 
4830 /// \brief Return the unique type for "pid_t" defined in
4831 /// <sys/types.h>. We need this to compute the correct type for vfork().
4833  return getFromTargetType(Target->getProcessIDType());
4834 }
4835 
4836 //===----------------------------------------------------------------------===//
4837 // Type Operators
4838 //===----------------------------------------------------------------------===//
4839 
4841  // Push qualifiers into arrays, and then discard any remaining
4842  // qualifiers.
4843  T = getCanonicalType(T);
4845  const Type *Ty = T.getTypePtr();
4846  QualType Result;
4847  if (isa<ArrayType>(Ty)) {
4848  Result = getArrayDecayedType(QualType(Ty,0));
4849  } else if (isa<FunctionType>(Ty)) {
4850  Result = getPointerType(QualType(Ty, 0));
4851  } else {
4852  Result = QualType(Ty, 0);
4853  }
4854 
4855  return CanQualType::CreateUnsafe(Result);
4856 }
4857 
4859  Qualifiers &quals) {
4860  SplitQualType splitType = type.getSplitUnqualifiedType();
4861 
4862  // FIXME: getSplitUnqualifiedType() actually walks all the way to
4863  // the unqualified desugared type and then drops it on the floor.
4864  // We then have to strip that sugar back off with
4865  // getUnqualifiedDesugaredType(), which is silly.
4866  const ArrayType *AT =
4867  dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType());
4868 
4869  // If we don't have an array, just use the results in splitType.
4870  if (!AT) {
4871  quals = splitType.Quals;
4872  return QualType(splitType.Ty, 0);
4873  }
4874 
4875  // Otherwise, recurse on the array's element type.
4876  QualType elementType = AT->getElementType();
4877  QualType unqualElementType = getUnqualifiedArrayType(elementType, quals);
4878 
4879  // If that didn't change the element type, AT has no qualifiers, so we
4880  // can just use the results in splitType.
4881  if (elementType == unqualElementType) {
4882  assert(quals.empty()); // from the recursive call
4883  quals = splitType.Quals;
4884  return QualType(splitType.Ty, 0);
4885  }
4886 
4887  // Otherwise, add in the qualifiers from the outermost type, then
4888  // build the type back up.
4889  quals.addConsistentQualifiers(splitType.Quals);
4890 
4891  if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) {
4892  return getConstantArrayType(unqualElementType, CAT->getSize(),
4893  CAT->getSizeModifier(), 0);
4894  }
4895 
4896  if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
4897  return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0);
4898  }
4899 
4900  if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(AT)) {
4901  return getVariableArrayType(unqualElementType,
4902  VAT->getSizeExpr(),
4903  VAT->getSizeModifier(),
4904  VAT->getIndexTypeCVRQualifiers(),
4905  VAT->getBracketsRange());
4906  }
4907 
4908  const DependentSizedArrayType *DSAT = cast<DependentSizedArrayType>(AT);
4909  return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(),
4910  DSAT->getSizeModifier(), 0,
4911  SourceRange());
4912 }
4913 
4914 /// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that
4915 /// may be similar (C++ 4.4), replaces T1 and T2 with the type that
4916 /// they point to and return true. If T1 and T2 aren't pointer types
4917 /// or pointer-to-member types, or if they are not similar at this
4918 /// level, returns false and leaves T1 and T2 unchanged. Top-level
4919 /// qualifiers on T1 and T2 are ignored. This function will typically
4920 /// be called in a loop that successively "unwraps" pointer and
4921 /// pointer-to-member types to compare them at each level.
4923  const PointerType *T1PtrType = T1->getAs<PointerType>(),
4924  *T2PtrType = T2->getAs<PointerType>();
4925  if (T1PtrType && T2PtrType) {
4926  T1 = T1PtrType->getPointeeType();
4927  T2 = T2PtrType->getPointeeType();
4928  return true;
4929  }
4930 
4931  const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(),
4932  *T2MPType = T2->getAs<MemberPointerType>();
4933  if (T1MPType && T2MPType &&
4934  hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
4935  QualType(T2MPType->getClass(), 0))) {
4936  T1 = T1MPType->getPointeeType();
4937  T2 = T2MPType->getPointeeType();
4938  return true;
4939  }
4940 
4941  if (getLangOpts().ObjC1) {
4942  const ObjCObjectPointerType *T1OPType = T1->getAs<ObjCObjectPointerType>(),
4943  *T2OPType = T2->getAs<ObjCObjectPointerType>();
4944  if (T1OPType && T2OPType) {
4945  T1 = T1OPType->getPointeeType();
4946  T2 = T2OPType->getPointeeType();
4947  return true;
4948  }
4949  }
4950 
4951  // FIXME: Block pointers, too?
4952 
4953  return false;
4954 }
4955 
4958  SourceLocation NameLoc) const {
4959  switch (Name.getKind()) {
4962  // DNInfo work in progress: CHECKME: what about DNLoc?
4964  NameLoc);
4965 
4968  // DNInfo work in progress: CHECKME: what about DNLoc?
4969  return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc);
4970  }
4971 
4974  DeclarationName DName;
4975  if (DTN->isIdentifier()) {
4977  return DeclarationNameInfo(DName, NameLoc);
4978  } else {
4980  // DNInfo work in progress: FIXME: source locations?
4981  DeclarationNameLoc DNLoc;
4984  return DeclarationNameInfo(DName, NameLoc, DNLoc);
4985  }
4986  }
4987 
4991  return DeclarationNameInfo(subst->getParameter()->getDeclName(),
4992  NameLoc);
4993  }
4994 
4999  NameLoc);
5000  }
5001  }
5002 
5003  llvm_unreachable("bad template name kind!");
5004 }
5005 
5007  switch (Name.getKind()) {
5009  case TemplateName::Template: {
5010  TemplateDecl *Template = Name.getAsTemplateDecl();
5011  if (TemplateTemplateParmDecl *TTP
5012  = dyn_cast<TemplateTemplateParmDecl>(Template))
5013  Template = getCanonicalTemplateTemplateParmDecl(TTP);
5014 
5015  // The canonical template name is the canonical template declaration.
5016  return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
5017  }
5018 
5020  llvm_unreachable("cannot canonicalize overloaded template");
5021 
5024  assert(DTN && "Non-dependent template names must refer to template decls.");
5025  return DTN->CanonicalTemplateName;
5026  }
5027 
5031  return getCanonicalTemplateName(subst->getReplacement());
5032  }
5033 
5037  TemplateTemplateParmDecl *canonParameter
5038  = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
5039  TemplateArgument canonArgPack
5041  return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
5042  }
5043  }
5044 
5045  llvm_unreachable("bad template name!");
5046 }
5047 
5049  X = getCanonicalTemplateName(X);
5050  Y = getCanonicalTemplateName(Y);
5051  return X.getAsVoidPointer() == Y.getAsVoidPointer();
5052 }
5053 
5056  switch (Arg.getKind()) {
5058  return Arg;
5059 
5061  return Arg;
5062 
5064  ValueDecl *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
5065  return TemplateArgument(D, Arg.getParamTypeForDecl());
5066  }
5067 
5070  /*isNullPtr*/true);
5071 
5074 
5078  Arg.getNumTemplateExpansions());
5079 
5082 
5085 
5086  case TemplateArgument::Pack: {
5087  if (Arg.pack_size() == 0)
5088  return Arg;
5089 
5090  TemplateArgument *CanonArgs
5091  = new (*this) TemplateArgument[Arg.pack_size()];
5092  unsigned Idx = 0;
5094  AEnd = Arg.pack_end();
5095  A != AEnd; (void)++A, ++Idx)
5096  CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
5097 
5098  return TemplateArgument(llvm::makeArrayRef(CanonArgs, Arg.pack_size()));
5099  }
5100  }
5101 
5102  // Silence GCC warning
5103  llvm_unreachable("Unhandled template argument kind");
5104 }
5105 
5108  if (!NNS)
5109  return nullptr;
5110 
5111  switch (NNS->getKind()) {
5113  // Canonicalize the prefix but keep the identifier the same.
5114  return NestedNameSpecifier::Create(*this,
5116  NNS->getAsIdentifier());
5117 
5119  // A namespace is canonical; build a nested-name-specifier with
5120  // this namespace and no prefix.
5121  return NestedNameSpecifier::Create(*this, nullptr,
5123 
5125  // A namespace is canonical; build a nested-name-specifier with
5126  // this namespace and no prefix.
5127  return NestedNameSpecifier::Create(*this, nullptr,
5129  ->getOriginalNamespace());
5130 
5133  QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
5134 
5135  // If we have some kind of dependent-named type (e.g., "typename T::type"),
5136  // break it apart into its prefix and identifier, then reconsititute those
5137  // as the canonical nested-name-specifier. This is required to canonicalize
5138  // a dependent nested-name-specifier involving typedefs of dependent-name
5139  // types, e.g.,
5140  // typedef typename T::type T1;
5141  // typedef typename T1::type T2;
5142  if (const DependentNameType *DNT = T->getAs<DependentNameType>())
5143  return NestedNameSpecifier::Create(*this, DNT->getQualifier(),
5144  const_cast<IdentifierInfo *>(DNT->getIdentifier()));
5145 
5146  // Otherwise, just canonicalize the type, and force it to be a TypeSpec.
5147  // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the
5148  // first place?
5149  return NestedNameSpecifier::Create(*this, nullptr, false,
5150  const_cast<Type *>(T.getTypePtr()));
5151  }
5152 
5155  // The global specifier and __super specifer are canonical and unique.
5156  return NNS;
5157  }
5158 
5159  llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
5160 }
5161 
5163  // Handle the non-qualified case efficiently.
5164  if (!T.hasLocalQualifiers()) {
5165  // Handle the common positive case fast.
5166  if (const ArrayType *AT = dyn_cast<ArrayType>(T))
5167  return AT;
5168  }
5169 
5170  // Handle the common negative case fast.
5171  if (!isa<ArrayType>(T.getCanonicalType()))
5172  return nullptr;
5173 
5174  // Apply any qualifiers from the array type to the element type. This
5175  // implements C99 6.7.3p8: "If the specification of an array type includes
5176  // any type qualifiers, the element type is so qualified, not the array type."
5177 
5178  // If we get here, we either have type qualifiers on the type, or we have
5179  // sugar such as a typedef in the way. If we have type qualifiers on the type
5180  // we must propagate them down into the element type.
5181 
5183  Qualifiers qs = split.Quals;
5184 
5185  // If we have a simple case, just return now.
5186  const ArrayType *ATy = dyn_cast<ArrayType>(split.Ty);
5187  if (!ATy || qs.empty())
5188  return ATy;
5189 
5190  // Otherwise, we have an array and we have qualifiers on it. Push the
5191  // qualifiers into the array element type and return a new array type.
5192  QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs);
5193 
5194  if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(ATy))
5195  return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
5196  CAT->getSizeModifier(),
5197  CAT->getIndexTypeCVRQualifiers()));
5198  if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(ATy))
5199  return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
5200  IAT->getSizeModifier(),
5201  IAT->getIndexTypeCVRQualifiers()));
5202 
5203  if (const DependentSizedArrayType *DSAT
5204  = dyn_cast<DependentSizedArrayType>(ATy))
5205  return cast<ArrayType>(
5206  getDependentSizedArrayType(NewEltTy,
5207  DSAT->getSizeExpr(),
5208  DSAT->getSizeModifier(),
5209  DSAT->getIndexTypeCVRQualifiers(),
5210  DSAT->getBracketsRange()));
5211 
5212  const VariableArrayType *VAT = cast<VariableArrayType>(ATy);
5213  return cast<ArrayType>(getVariableArrayType(NewEltTy,
5214  VAT->getSizeExpr(),
5215  VAT->getSizeModifier(),
5217  VAT->getBracketsRange()));
5218 }
5219 
5221  if (T->isArrayType() || T->isFunctionType())
5222  return getDecayedType(T);
5223  return T;
5224 }
5225 
5228  T = getAdjustedParameterType(T);
5229  return T.getUnqualifiedType();
5230 }
5231 
5233  // C++ [except.throw]p3:
5234  // A throw-expression initializes a temporary object, called the exception
5235  // object, the type of which is determined by removing any top-level
5236  // cv-qualifiers from the static type of the operand of throw and adjusting
5237  // the type from "array of T" or "function returning T" to "pointer to T"
5238  // or "pointer to function returning T", [...]
5240  if (T->isArrayType() || T->isFunctionType())
5241  T = getDecayedType(T);
5242  return T.getUnqualifiedType();
5243 }
5244 
5245 /// getArrayDecayedType - Return the properly qualified result of decaying the
5246 /// specified array type to a pointer. This operation is non-trivial when
5247 /// handling typedefs etc. The canonical type of "T" must be an array type,
5248 /// this returns a pointer to a properly qualified element of the array.
5249 ///
5250 /// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
5252  // Get the element type with 'getAsArrayType' so that we don't lose any
5253  // typedefs in the element type of the array. This also handles propagation
5254  // of type qualifiers from the array type into the element type if present
5255  // (C99 6.7.3p8).
5256  const ArrayType *PrettyArrayType = getAsArrayType(Ty);
5257  assert(PrettyArrayType && "Not an array type!");
5258 
5259  QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
5260 
5261  // int x[restrict 4] -> int *restrict
5263  PrettyArrayType->getIndexTypeQualifiers());
5264 
5265  // int x[_Nullable] -> int * _Nullable
5266  if (auto Nullability = Ty->getNullability(*this)) {
5267  Result = const_cast<ASTContext *>(this)->getAttributedType(
5269  }
5270  return Result;
5271 }
5272 
5274  return getBaseElementType(array->getElementType());
5275 }
5276 
5278  Qualifiers qs;
5279  while (true) {
5280  SplitQualType split = type.getSplitDesugaredType();
5281  const ArrayType *array = split.Ty->getAsArrayTypeUnsafe();
5282  if (!array) break;
5283 
5284  type = array->getElementType();
5285  qs.addConsistentQualifiers(split.Quals);
5286  }
5287 
5288  return getQualifiedType(type, qs);
5289 }
5290 
5291 /// getConstantArrayElementCount - Returns number of constant array elements.
5292 uint64_t
5294  uint64_t ElementCount = 1;
5295  do {
5296  ElementCount *= CA->getSize().getZExtValue();
5297  CA = dyn_cast_or_null<ConstantArrayType>(
5299  } while (CA);
5300  return ElementCount;
5301 }
5302 
5303 /// getFloatingRank - Return a relative rank for floating point types.
5304 /// This routine will assert if passed a built-in type that isn't a float.
5306  if (const ComplexType *CT = T->getAs<ComplexType>())
5307  return getFloatingRank(CT->getElementType());
5308 
5309  assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type");
5310  switch (T->getAs<BuiltinType>()->getKind()) {
5311  default: llvm_unreachable("getFloatingRank(): not a floating type");
5312  case BuiltinType::Float16: return Float16Rank;
5313  case BuiltinType::Half: return HalfRank;
5314  case BuiltinType::Float: return FloatRank;
5315  case BuiltinType::Double: return DoubleRank;
5316  case BuiltinType::LongDouble: return LongDoubleRank;
5317  case BuiltinType::Float128: return Float128Rank;
5318  }
5319 }
5320 
5321 /// getFloatingTypeOfSizeWithinDomain - Returns a real floating
5322 /// point or a complex type (based on typeDomain/typeSize).
5323 /// 'typeDomain' is a real floating point or complex type.
5324 /// 'typeSize' is a real floating point or complex type.
5326  QualType Domain) const {
5327  FloatingRank EltRank = getFloatingRank(Size);
5328  if (Domain->isComplexType()) {
5329  switch (EltRank) {
5330  case Float16Rank:
5331  case HalfRank: llvm_unreachable("Complex half is not supported");
5332  case FloatRank: return FloatComplexTy;
5333  case DoubleRank: return DoubleComplexTy;
5334  case LongDoubleRank: return LongDoubleComplexTy;
5335  case Float128Rank: return Float128ComplexTy;
5336  }
5337  }
5338 
5339  assert(Domain->isRealFloatingType() && "Unknown domain!");
5340  switch (EltRank) {
5341  case Float16Rank: return HalfTy;
5342  case HalfRank: return HalfTy;
5343  case FloatRank: return FloatTy;
5344  case DoubleRank: return DoubleTy;
5345  case LongDoubleRank: return LongDoubleTy;
5346  case Float128Rank: return Float128Ty;
5347  }
5348  llvm_unreachable("getFloatingRank(): illegal value for rank");
5349 }
5350 
5351 /// getFloatingTypeOrder - Compare the rank of the two specified floating
5352 /// point types, ignoring the domain of the type (i.e. 'double' ==
5353 /// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
5354 /// LHS < RHS, return -1.
5356  FloatingRank LHSR = getFloatingRank(LHS);
5357  FloatingRank RHSR = getFloatingRank(RHS);
5358 
5359  if (LHSR == RHSR)
5360  return 0;
5361  if (LHSR > RHSR)
5362  return 1;
5363  return -1;
5364 }
5365 
5366 /// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
5367 /// routine will assert if passed a built-in type that isn't an integer or enum,
5368 /// or if it is not canonicalized.
5369 unsigned ASTContext::getIntegerRank(const Type *T) const {
5370  assert(T->isCanonicalUnqualified() && "T should be canonicalized");
5371 
5372  switch (cast<BuiltinType>(T)->getKind()) {
5373  default: llvm_unreachable("getIntegerRank(): not a built-in integer");
5374  case BuiltinType::Bool:
5375  return 1 + (getIntWidth(BoolTy) << 3);
5376  case BuiltinType::Char_S:
5377  case BuiltinType::Char_U:
5378  case BuiltinType::SChar:
5379  case BuiltinType::UChar:
5380  return 2 + (getIntWidth(CharTy) << 3);
5381  case BuiltinType::Short:
5382  case BuiltinType::UShort:
5383  return 3 + (getIntWidth(ShortTy) << 3);
5384  case BuiltinType::Int:
5385  case BuiltinType::UInt:
5386  return 4 + (getIntWidth(IntTy) << 3);
5387  case BuiltinType::Long:
5388  case BuiltinType::ULong:
5389  return 5 + (getIntWidth(LongTy) << 3);
5390  case BuiltinType::LongLong:
5391  case BuiltinType::ULongLong:
5392  return 6 + (getIntWidth(LongLongTy) << 3);
5393  case BuiltinType::Int128:
5394  case BuiltinType::UInt128:
5395  return 7 + (getIntWidth(Int128Ty) << 3);
5396  }
5397 }
5398 
5399 /// \brief Whether this is a promotable bitfield reference according
5400 /// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
5401 ///
5402 /// \returns the type this bit-field will promote to, or NULL if no
5403 /// promotion occurs.
5405  if (E->isTypeDependent() || E->isValueDependent())
5406  return QualType();
5407 
5408  // FIXME: We should not do this unless E->refersToBitField() is true. This
5409  // matters in C where getSourceBitField() will find bit-fields for various
5410  // cases where the source expression is not a bit-field designator.
5411 
5412  FieldDecl *Field = E->getSourceBitField(); // FIXME: conditional bit-fields?
5413  if (!Field)
5414  return QualType();
5415 
5416  QualType FT = Field->getType();
5417 
5418  uint64_t BitWidth = Field->getBitWidthValue(*this);
5419  uint64_t IntSize = getTypeSize(IntTy);
5420  // C++ [conv.prom]p5:
5421  // A prvalue for an integral bit-field can be converted to a prvalue of type
5422  // int if int can represent all the values of the bit-field; otherwise, it
5423  // can be converted to unsigned int if unsigned int can represent all the
5424  // values of the bit-field. If the bit-field is larger yet, no integral
5425  // promotion applies to it.
5426  // C11 6.3.1.1/2:
5427  // [For a bit-field of type _Bool, int, signed int, or unsigned int:]
5428  // If an int can represent all values of the original type (as restricted by
5429  // the width, for a bit-field), the value is converted to an int; otherwise,
5430  // it is converted to an unsigned int.
5431  //
5432  // FIXME: C does not permit promotion of a 'long : 3' bitfield to int.
5433  // We perform that promotion here to match GCC and C++.
5434  if (BitWidth < IntSize)
5435  return IntTy;
5436 
5437  if (BitWidth == IntSize)
5438  return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy;
5439 
5440  // Types bigger than int are not subject to promotions, and therefore act
5441  // like the base type. GCC has some weird bugs in this area that we
5442  // deliberately do not follow (GCC follows a pre-standard resolution to
5443  // C's DR315 which treats bit-width as being part of the type, and this leaks
5444  // into their semantics in some cases).
5445  return QualType();
5446 }
5447 
5448 /// getPromotedIntegerType - Returns the type that Promotable will
5449 /// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
5450 /// integer type.
5452  assert(!Promotable.isNull());
5453  assert(Promotable->isPromotableIntegerType());
5454  if (const EnumType *ET = Promotable->getAs<EnumType>())
5455  return ET->getDecl()->getPromotionType();
5456 
5457  if (const BuiltinType *BT = Promotable->getAs<BuiltinType>()) {
5458  // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t
5459  // (3.9.1) can be converted to a prvalue of the first of the following
5460  // types that can represent all the values of its underlying type:
5461  // int, unsigned int, long int, unsigned long int, long long int, or
5462  // unsigned long long int [...]
5463  // FIXME: Is there some better way to compute this?
5464  if (BT->getKind() == BuiltinType::WChar_S ||
5465  BT->getKind() == BuiltinType::WChar_U ||
5466  BT->getKind() == BuiltinType::Char16 ||
5467  BT->getKind() == BuiltinType::Char32) {
5468  bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
5469  uint64_t FromSize = getTypeSize(BT);
5470  QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy,
5472  for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) {
5473  uint64_t ToSize = getTypeSize(PromoteTypes[Idx]);
5474  if (FromSize < ToSize ||
5475  (FromSize == ToSize &&
5476  FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType()))
5477  return PromoteTypes[Idx];
5478  }
5479  llvm_unreachable("char type should fit into long long");
5480  }
5481  }
5482 
5483  // At this point, we should have a signed or unsigned integer type.
5484  if (Promotable->isSignedIntegerType())
5485  return IntTy;
5486  uint64_t PromotableSize = getIntWidth(Promotable);
5487  uint64_t IntSize = getIntWidth(IntTy);
5488  assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize);
5489  return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
5490 }
5491 
5492 /// \brief Recurses in pointer/array types until it finds an objc retainable
5493 /// type and returns its ownership.
5495  while (!T.isNull()) {
5497  return T.getObjCLifetime();
5498  if (T->isArrayType())
5499  T = getBaseElementType(T);
5500  else if (const PointerType *PT = T->getAs<PointerType>())
5501  T = PT->getPointeeType();
5502  else if (const ReferenceType *RT = T->getAs<ReferenceType>())
5503  T = RT->getPointeeType();
5504  else
5505  break;
5506  }
5507 
5508  return Qualifiers::OCL_None;
5509 }
5510 
5511 static const Type *getIntegerTypeForEnum(const EnumType *ET) {
5512  // Incomplete enum types are not treated as integer types.
5513  // FIXME: In C++, enum types are never integer types.
5514  if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
5515  return ET->getDecl()->getIntegerType().getTypePtr();
5516  return nullptr;
5517 }
5518 
5519 /// getIntegerTypeOrder - Returns the highest ranked integer type:
5520 /// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
5521 /// LHS < RHS, return -1.
5523  const Type *LHSC = getCanonicalType(LHS).getTypePtr();
5524  const Type *RHSC = getCanonicalType(RHS).getTypePtr();
5525 
5526  // Unwrap enums to their underlying type.
5527  if (const EnumType *ET = dyn_cast<EnumType>(LHSC))
5528  LHSC = getIntegerTypeForEnum(ET);
5529  if (const EnumType *ET = dyn_cast<EnumType>(RHSC))
5530  RHSC = getIntegerTypeForEnum(ET);
5531 
5532  if (LHSC == RHSC) return 0;
5533 
5534  bool LHSUnsigned = LHSC->isUnsignedIntegerType();
5535  bool RHSUnsigned = RHSC->isUnsignedIntegerType();
5536 
5537  unsigned LHSRank = getIntegerRank(LHSC);
5538  unsigned RHSRank = getIntegerRank(RHSC);
5539 
5540  if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
5541  if (LHSRank == RHSRank) return 0;
5542  return LHSRank > RHSRank ? 1 : -1;
5543  }
5544 
5545  // Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
5546  if (LHSUnsigned) {
5547  // If the unsigned [LHS] type is larger, return it.
5548  if (LHSRank >= RHSRank)
5549  return 1;
5550 
5551  // If the signed type can represent all values of the unsigned type, it
5552  // wins. Because we are dealing with 2's complement and types that are
5553  // powers of two larger than each other, this is always safe.
5554  return -1;
5555  }
5556 
5557  // If the unsigned [RHS] type is larger, return it.
5558  if (RHSRank >= LHSRank)
5559  return -1;
5560 
5561  // If the signed type can represent all values of the unsigned type, it
5562  // wins. Because we are dealing with 2's complement and types that are
5563  // powers of two larger than each other, this is always safe.
5564  return 1;
5565 }
5566 
5568  if (!CFConstantStringTypeDecl) {
5569  assert(!CFConstantStringTagDecl &&
5570  "tag and typedef should be initialized together");
5571  CFConstantStringTagDecl = buildImplicitRecord("__NSConstantString_tag");
5572  CFConstantStringTagDecl->startDefinition();
5573 
5574  QualType FieldTypes[4];
5575  const char *FieldNames[4];
5576 
5577  // const int *isa;
5578  FieldTypes[0] = getPointerType(IntTy.withConst());
5579  FieldNames[0] = "isa";
5580  // int flags;
5581  FieldTypes[1] = IntTy;
5582  FieldNames[1] = "flags";
5583  // const char *str;
5584  FieldTypes[2] = getPointerType(CharTy.withConst());
5585  FieldNames[2] = "str";
5586  // long length;
5587  FieldTypes[3] = LongTy;
5588  FieldNames[3] = "length";
5589 
5590  // Create fields
5591  for (unsigned i = 0; i < 4; ++i) {
5592  FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTagDecl,
5593  SourceLocation(),
5594  SourceLocation(),
5595  &Idents.get(FieldNames[i]),
5596  FieldTypes[i], /*TInfo=*/nullptr,
5597  /*BitWidth=*/nullptr,
5598  /*Mutable=*/false,
5599  ICIS_NoInit);
5600  Field->setAccess(AS_public);
5601  CFConstantStringTagDecl->addDecl(Field);
5602  }
5603 
5604  CFConstantStringTagDecl->completeDefinition();
5605  // This type is designed to be compatible with NSConstantString, but cannot
5606  // use the same name, since NSConstantString is an interface.
5607  auto tagType = getTagDeclType(CFConstantStringTagDecl);
5608  CFConstantStringTypeDecl =
5609  buildImplicitTypedef(tagType, "__NSConstantString");
5610  }
5611 
5612  return CFConstantStringTypeDecl;
5613 }
5614 
5616  if (!CFConstantStringTagDecl)
5617  getCFConstantStringDecl(); // Build the tag and the typedef.
5618  return CFConstantStringTagDecl;
5619 }
5620 
5621 // getCFConstantStringType - Return the type used for constant CFStrings.
5624 }
5625 
5627  if (ObjCSuperType.isNull()) {
5628  RecordDecl *ObjCSuperTypeDecl = buildImplicitRecord("objc_super");
5629  TUDecl->addDecl(ObjCSuperTypeDecl);
5630  ObjCSuperType = getTagDeclType(ObjCSuperTypeDecl);
5631  }
5632  return ObjCSuperType;
5633 }
5634 
5636  const TypedefType *TD = T->getAs<TypedefType>();
5637  assert(TD && "Invalid CFConstantStringType");
5638  CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());
5639  auto TagType =
5640  CFConstantStringTypeDecl->getUnderlyingType()->getAs<RecordType>();
5641  assert(TagType && "Invalid CFConstantStringType");
5642  CFConstantStringTagDecl = TagType->getDecl();
5643 }
5644 
5646  if (BlockDescriptorType)
5647  return getTagDeclType(BlockDescriptorType);
5648 
5649  RecordDecl *RD;
5650  // FIXME: Needs the FlagAppleBlock bit.
5651  RD = buildImplicitRecord("__block_descriptor");
5652  RD->startDefinition();
5653 
5654  QualType FieldTypes[] = {
5657  };
5658 
5659  static const char *const FieldNames[] = {
5660  "reserved",
5661  "Size"
5662  };
5663 
5664  for (size_t i = 0; i < 2; ++i) {
5665  FieldDecl *Field = FieldDecl::Create(
5666  *this, RD, SourceLocation(), SourceLocation(),
5667  &Idents.get(FieldNames[i]), FieldTypes[i], /*TInfo=*/nullptr,
5668  /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
5669  Field->setAccess(AS_public);
5670  RD->addDecl(Field);
5671  }
5672 
5673  RD->completeDefinition();
5674 
5675  BlockDescriptorType = RD;
5676 
5677  return getTagDeclType(BlockDescriptorType);
5678 }
5679 
5681  if (BlockDescriptorExtendedType)
5682  return getTagDeclType(BlockDescriptorExtendedType);
5683 
5684  RecordDecl *RD;
5685  // FIXME: Needs the FlagAppleBlock bit.
5686  RD = buildImplicitRecord("__block_descriptor_withcopydispose");
5687  RD->startDefinition();
5688 
5689  QualType FieldTypes[] = {
5694  };
5695 
5696  static const char *const FieldNames[] = {
5697  "reserved",
5698  "Size",
5699  "CopyFuncPtr",
5700  "DestroyFuncPtr"
5701  };
5702 
5703  for (size_t i = 0; i < 4; ++i) {
5704  FieldDecl *Field = FieldDecl::Create(
5705  *this, RD, SourceLocation(), SourceLocation(),
5706  &Idents.get(FieldNames[i]), FieldTypes[i], /*TInfo=*/nullptr,
5707  /*BitWidth=*/nullptr,
5708  /*Mutable=*/false, ICIS_NoInit);
5709  Field->setAccess(AS_public);
5710  RD->addDecl(Field);
5711  }
5712 
5713  RD->completeDefinition();
5714 
5715  BlockDescriptorExtendedType = RD;
5716  return getTagDeclType(BlockDescriptorExtendedType);
5717 }
5718 
5720  auto BT = dyn_cast<BuiltinType>(T);
5721 
5722  if (!BT) {
5723  if (isa<PipeType>(T))
5724  return TargetInfo::OCLTK_Pipe;
5725 
5727  }
5728 
5729  switch (BT->getKind()) {
5730 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
5731  case BuiltinType::Id: \
5732  return TargetInfo::OCLTK_Image;
5733 #include "clang/Basic/OpenCLImageTypes.def"
5734 
5735  case BuiltinType::OCLClkEvent:
5737 
5738  case BuiltinType::OCLEvent:
5739  return TargetInfo::OCLTK_Event;
5740 
5741  case BuiltinType::OCLQueue:
5742  return TargetInfo::OCLTK_Queue;
5743 
5744  case BuiltinType::OCLReserveID:
5746 
5747  case BuiltinType::OCLSampler:
5749 
5750  default:
5752  }
5753 }
5754 
5756  return Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T));
5757 }
5758 
5759 /// BlockRequiresCopying - Returns true if byref variable "D" of type "Ty"
5760 /// requires copy/dispose. Note that this must match the logic
5761 /// in buildByrefHelpers.
5763  const VarDecl *D) {
5764  if (const CXXRecordDecl *record = Ty->getAsCXXRecordDecl()) {
5765  const Expr *copyExpr = getBlockVarCopyInits(D);
5766  if (!copyExpr && record->hasTrivialDestructor()) return false;
5767 
5768  return true;
5769  }
5770 
5771  if (!Ty->isObjCRetainableType()) return false;
5772 
5773  Qualifiers qs = Ty.getQualifiers();
5774 
5775  // If we have lifetime, that dominates.
5776  if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) {
5777  switch (lifetime) {
5778  case Qualifiers::OCL_None: llvm_unreachable("impossible");
5779 
5780  // These are just bits as far as the runtime is concerned.
5783  return false;
5784 
5785  // Tell the runtime that this is ARC __weak, called by the
5786  // byref routines.
5787  case Qualifiers::OCL_Weak:
5788  // ARC __strong __block variables need to be retained.
5790  return true;
5791  }
5792  llvm_unreachable("fell out of lifetime switch!");
5793  }
5794  return (Ty->isBlockPointerType() || isObjCNSObjectType(Ty) ||
5795  Ty->isObjCObjectPointerType());
5796 }
5797 
5799  Qualifiers::ObjCLifetime &LifeTime,
5800  bool &HasByrefExtendedLayout) const {
5801  if (!getLangOpts().ObjC1 ||
5802  getLangOpts().getGC() != LangOptions::NonGC)
5803  return false;
5804 
5805  HasByrefExtendedLayout = false;
5806  if (Ty->isRecordType()) {
5807  HasByrefExtendedLayout = true;
5808  LifeTime = Qualifiers::OCL_None;
5809  } else if ((LifeTime = Ty.getObjCLifetime())) {
5810  // Honor the ARC qualifiers.
5811  } else if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) {
5812  // The MRR rule.
5813  LifeTime = Qualifiers::OCL_ExplicitNone;
5814  } else {
5815  LifeTime = Qualifiers::OCL_None;
5816  }
5817  return true;
5818 }
5819 
5821  if (!ObjCInstanceTypeDecl)
5822  ObjCInstanceTypeDecl =
5823  buildImplicitTypedef(getObjCIdType(), "instancetype");
5824  return ObjCInstanceTypeDecl;
5825 }
5826 
5827 // This returns true if a type has been typedefed to BOOL:
5828 // typedef <type> BOOL;
5830  if (const TypedefType *TT = dyn_cast<TypedefType>(T))
5831  if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
5832  return II->isStr("BOOL");
5833 
5834  return false;
5835 }
5836 
5837 /// getObjCEncodingTypeSize returns size of type for objective-c encoding
5838 /// purpose.
5840  if (!type->isIncompleteArrayType() && type->isIncompleteType())
5841  return CharUnits::Zero();
5842 
5843  CharUnits sz = getTypeSizeInChars(type);
5844 
5845  // Make all integer and enum types at least as large as an int
5846  if (sz.isPositive() && type->isIntegralOrEnumerationType())
5847  sz = std::max(sz, getTypeSizeInChars(IntTy));
5848  // Treat arrays as pointers, since that's how they're passed in.
5849  else if (type->isArrayType())
5851  return sz;
5852 }
5853 
5855  return getTargetInfo().getCXXABI().isMicrosoft() &&
5856  VD->isStaticDataMember() &&
5858  !VD->getFirstDecl()->isOutOfLine() && VD->getFirstDecl()->hasInit();
5859 }
5860 
5863  if (!VD->isInline())
5865 
5866  // In almost all cases, it's a weak definition.
5867  auto *First = VD->getFirstDecl();
5868  if (First->isInlineSpecified() || !First->isStaticDataMember())
5870 
5871  // If there's a file-context declaration in this translation unit, it's a
5872  // non-discardable definition.
5873  for (auto *D : VD->redecls())
5874  if (D->getLexicalDeclContext()->isFileContext() &&
5875  !D->isInlineSpecified() && (D->isConstexpr() || First->isConstexpr()))
5877 
5878  // If we've not seen one yet, we don't know.
5880 }
5881 
5882 static inline
5883 std::string charUnitsToString(const CharUnits &CU) {
5884  return llvm::itostr(CU.getQuantity());
5885 }
5886 
5887 /// getObjCEncodingForBlock - Return the encoded type for this block
5888 /// declaration.
5890  std::string S;
5891 
5892  const BlockDecl *Decl = Expr->getBlockDecl();
5893  QualType BlockTy =
5894  Expr->getType()->getAs<BlockPointerType>()->getPointeeType();
5895  // Encode result type.
5896  if (getLangOpts().EncodeExtendedBlockSig)
5899  true /*Extended*/);
5900  else
5902  // Compute size of all parameters.
5903  // Start with computing size of a pointer in number of bytes.
5904  // FIXME: There might(should) be a better way of doing this computation!
5906  CharUnits ParmOffset = PtrSize;
5907  for (auto PI : Decl->parameters()) {
5908  QualType PType = PI->getType();
5909  CharUnits sz = getObjCEncodingTypeSize(PType);
5910  if (sz.isZero())
5911  continue;
5912  assert(sz.isPositive() && "BlockExpr - Incomplete param type");
5913  ParmOffset += sz;
5914  }
5915  // Size of the argument frame
5916  S += charUnitsToString(ParmOffset);
5917  // Block pointer and offset.
5918  S += "@?0";
5919 
5920  // Argument types.
5921  ParmOffset = PtrSize;
5922  for (auto PVDecl : Decl->parameters()) {
5923  QualType PType = PVDecl->getOriginalType();
5924  if (const ArrayType *AT =
5925  dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
5926  // Use array's original type only if it has known number of
5927  // elements.
5928  if (!isa<ConstantArrayType>(AT))
5929  PType = PVDecl->getType();
5930  } else if (PType->isFunctionType())
5931  PType = PVDecl->getType();
5932  if (getLangOpts().EncodeExtendedBlockSig)
5934  S, true /*Extended*/);
5935  else
5936  getObjCEncodingForType(PType, S);
5937  S += charUnitsToString(ParmOffset);
5938  ParmOffset += getObjCEncodingTypeSize(PType);
5939  }
5940 
5941  return S;
5942 }
5943 
5944 std::string
5946  std::string S;
5947  // Encode result type.
5949  CharUnits ParmOffset;
5950  // Compute size of all parameters.
5951  for (auto PI : Decl->parameters()) {
5952  QualType PType = PI->getType();
5953  CharUnits sz = getObjCEncodingTypeSize(PType);
5954  if (sz.isZero())
5955  continue;
5956 
5957  assert(sz.isPositive() &&
5958  "getObjCEncodingForFunctionDecl - Incomplete param type");
5959  ParmOffset += sz;
5960  }
5961  S += charUnitsToString(ParmOffset);
5962  ParmOffset = CharUnits::Zero();
5963 
5964  // Argument types.
5965  for (auto PVDecl : Decl->parameters()) {
5966  QualType PType = PVDecl->getOriginalType();
5967  if (const ArrayType *AT =
5968  dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
5969  // Use array's original type only if it has known number of
5970  // elements.
5971  if (!isa<ConstantArrayType>(AT))
5972  PType = PVDecl->getType();
5973  } else if (PType->isFunctionType())
5974  PType = PVDecl->getType();
5975  getObjCEncodingForType(PType, S);
5976  S += charUnitsToString(ParmOffset);
5977  ParmOffset += getObjCEncodingTypeSize(PType);
5978  }
5979 
5980  return S;
5981 }
5982 
5983 /// getObjCEncodingForMethodParameter - Return the encoded type for a single
5984 /// method parameter or return type. If Extended, include class names and
5985 /// block object types.
5987  QualType T, std::string& S,
5988  bool Extended) const {
5989  // Encode type qualifer, 'in', 'inout', etc. for the parameter.
5991  // Encode parameter type.
5992  getObjCEncodingForTypeImpl(T, S, true, true, nullptr,
5993  true /*OutermostType*/,
5994  false /*EncodingProperty*/,
5995  false /*StructField*/,
5996  Extended /*EncodeBlockParameters*/,
5997  Extended /*EncodeClassNames*/);
5998 }
5999 
6000 /// getObjCEncodingForMethodDecl - Return the encoded type for this method
6001 /// declaration.
6003  bool Extended) const {
6004  // FIXME: This is not very efficient.
6005  // Encode return type.
6006  std::string S;
6008  Decl->getReturnType(), S, Extended);
6009  // Compute size of all parameters.
6010  // Start with computing size of a pointer in number of bytes.
6011  // FIXME: There might(should) be a better way of doing this computation!
6013  // The first two arguments (self and _cmd) are pointers; account for
6014  // their size.
6015  CharUnits ParmOffset = 2 * PtrSize;
6017  E = Decl->sel_param_end(); PI != E; ++PI) {
6018  QualType PType = (*PI)->getType();
6019  CharUnits sz = getObjCEncodingTypeSize(PType);
6020  if (sz.isZero())
6021  continue;
6022 
6023  assert(sz.isPositive() &&
6024  "getObjCEncodingForMethodDecl - Incomplete param type");
6025  ParmOffset += sz;
6026  }
6027  S += charUnitsToString(ParmOffset);
6028  S += "@0:";
6029  S += charUnitsToString(PtrSize);
6030 
6031  // Argument types.
6032  ParmOffset = 2 * PtrSize;
6034  E = Decl->sel_param_end(); PI != E; ++PI) {
6035  const ParmVarDecl *PVDecl = *PI;
6036  QualType PType = PVDecl->getOriginalType();
6037  if (const ArrayType *AT =
6038  dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
6039  // Use array's original type only if it has known number of
6040  // elements.
6041  if (!isa<ConstantArrayType>(AT))
6042  PType = PVDecl->getType();
6043  } else if (PType->isFunctionType())
6044  PType = PVDecl->getType();
6046  PType, S, Extended);
6047  S += charUnitsToString(ParmOffset);
6048  ParmOffset += getObjCEncodingTypeSize(PType);
6049  }
6050 
6051  return S;
6052 }
6053 
6056  const ObjCPropertyDecl *PD,
6057  const Decl *Container) const {
6058  if (!Container)
6059  return nullptr;
6060  if (const ObjCCategoryImplDecl *CID =
6061  dyn_cast<ObjCCategoryImplDecl>(Container)) {
6062  for (auto *PID : CID->property_impls())
6063  if (PID->getPropertyDecl() == PD)
6064  return PID;
6065  } else {
6066  const ObjCImplementationDecl *OID=cast<ObjCImplementationDecl>(Container);
6067  for (auto *PID : OID->property_impls())
6068  if (PID->getPropertyDecl() == PD)
6069  return PID;
6070  }
6071  return nullptr;
6072 }
6073 
6074 /// getObjCEncodingForPropertyDecl - Return the encoded type for this
6075 /// property declaration. If non-NULL, Container must be either an
6076 /// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be
6077 /// NULL when getting encodings for protocol properties.
6078 /// Property attributes are stored as a comma-delimited C string. The simple
6079 /// attributes readonly and bycopy are encoded as single characters. The
6080 /// parametrized attributes, getter=name, setter=name, and ivar=name, are
6081 /// encoded as single characters, followed by an identifier. Property types
6082 /// are also encoded as a parametrized attribute. The characters used to encode
6083 /// these attributes are defined by the following enumeration:
6084 /// @code
6085 /// enum PropertyAttributes {
6086 /// kPropertyReadOnly = 'R', // property is read-only.
6087 /// kPropertyBycopy = 'C', // property is a copy of the value last assigned
6088 /// kPropertyByref = '&', // property is a reference to the value last assigned
6089 /// kPropertyDynamic = 'D', // property is dynamic
6090 /// kPropertyGetter = 'G', // followed by getter selector name
6091 /// kPropertySetter = 'S', // followed by setter selector name
6092 /// kPropertyInstanceVariable = 'V' // followed by instance variable name
6093 /// kPropertyType = 'T' // followed by old-style type encoding.
6094 /// kPropertyWeak = 'W' // 'weak' property
6095 /// kPropertyStrong = 'P' // property GC'able
6096 /// kPropertyNonAtomic = 'N' // property non-atomic
6097 /// };
6098 /// @endcode
6099 std::string
6101  const Decl *Container) const {
6102  // Collect information from the property implementation decl(s).
6103  bool Dynamic = false;
6104  ObjCPropertyImplDecl *SynthesizePID = nullptr;
6105 
6106  if (ObjCPropertyImplDecl *PropertyImpDecl =
6107  getObjCPropertyImplDeclForPropertyDecl(PD, Container)) {
6108  if (PropertyImpDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
6109  Dynamic = true;
6110  else
6111  SynthesizePID = PropertyImpDecl;
6112  }
6113 
6114  // FIXME: This is not very efficient.
6115  std::string S = "T";
6116 
6117  // Encode result type.
6118  // GCC has some special rules regarding encoding of properties which
6119  // closely resembles encoding of ivars.
6121 
6122  if (PD->isReadOnly()) {
6123  S += ",R";
6125  S += ",C";
6127  S += ",&";
6129  S += ",W";
6130  } else {
6131  switch (PD->getSetterKind()) {
6132  case ObjCPropertyDecl::Assign: break;
6133  case ObjCPropertyDecl::Copy: S += ",C"; break;
6134  case ObjCPropertyDecl::Retain: S += ",&"; break;
6135  case ObjCPropertyDecl::Weak: S += ",W"; break;
6136  }
6137  }
6138 
6139  // It really isn't clear at all what this means, since properties
6140  // are "dynamic by default".
6141  if (Dynamic)
6142  S += ",D";
6143 
6145  S += ",N";
6146 
6148  S += ",G";
6149  S += PD->getGetterName().getAsString();
6150  }
6151 
6153  S += ",S";
6154  S += PD->getSetterName().getAsString();
6155  }
6156 
6157  if (SynthesizePID) {
6158  const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
6159  S += ",V";
6160  S += OID->getNameAsString();
6161  }
6162 
6163  // FIXME: OBJCGC: weak & strong
6164  return S;
6165 }
6166 
6167 /// getLegacyIntegralTypeEncoding -
6168 /// Another legacy compatibility encoding: 32-bit longs are encoded as
6169 /// 'l' or 'L' , but not always. For typedefs, we need to use
6170 /// 'i' or 'I' instead if encoding a struct field, or a pointer!
6172  if (isa<TypedefType>(PointeeTy.getTypePtr())) {
6173  if (const BuiltinType *BT = PointeeTy->getAs<BuiltinType>()) {
6174  if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32)
6175  PointeeTy = UnsignedIntTy;
6176  else
6177  if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32)
6178  PointeeTy = IntTy;
6179  }
6180  }
6181 }
6182 
6184  const FieldDecl *Field,
6185  QualType *NotEncodedT) const {
6186  // We follow the behavior of gcc, expanding structures which are
6187  // directly pointed to, and expanding embedded structures. Note that
6188  // these rules are sufficient to prevent recursive encoding of the
6189  // same type.
6190  getObjCEncodingForTypeImpl(T, S, true, true, Field,
6191  true /* outermost type */, false, false,
6192  false, false, false, NotEncodedT);
6193 }
6194 
6196  std::string& S) const {
6197  // Encode result type.
6198  // GCC has some special rules regarding encoding of properties which
6199  // closely resembles encoding of ivars.
6200  getObjCEncodingForTypeImpl(T, S, true, true, nullptr,
6201  true /* outermost type */,
6202  true /* encoding property */);
6203 }
6204 
6207  switch (kind) {
6208  case BuiltinType::Void: return 'v';
6209  case BuiltinType::Bool: return 'B';
6210  case BuiltinType::Char_U:
6211  case BuiltinType::UChar: return 'C';
6212  case BuiltinType::Char16:
6213  case BuiltinType::UShort: return 'S';
6214  case BuiltinType::Char32:
6215  case BuiltinType::UInt: return 'I';
6216  case BuiltinType::ULong:
6217  return C->getTargetInfo().getLongWidth() == 32 ? 'L' : 'Q';
6218  case BuiltinType::UInt128: return 'T';
6219  case BuiltinType::ULongLong: return 'Q';
6220  case BuiltinType::Char_S:
6221  case BuiltinType::SChar: return 'c';
6222  case BuiltinType::Short: return 's';
6223  case BuiltinType::WChar_S:
6224  case BuiltinType::WChar_U:
6225  case BuiltinType::Int: return 'i';
6226  case BuiltinType::Long:
6227  return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
6228  case BuiltinType::LongLong: return 'q';
6229  case BuiltinType::Int128: return 't';
6230  case BuiltinType::Float: return 'f';
6231  case BuiltinType::Double: return 'd';
6232  case BuiltinType::LongDouble: return 'D';
6233  case BuiltinType::NullPtr: return '*'; // like char*
6234 
6235  case BuiltinType::Float16:
6236  case BuiltinType::Float128:
6237  case BuiltinType::Half:
6238  // FIXME: potentially need @encodes for these!
6239  return ' ';
6240 
6241  case BuiltinType::ObjCId:
6242  case BuiltinType::ObjCClass:
6243  case BuiltinType::ObjCSel:
6244  llvm_unreachable("@encoding ObjC primitive type");
6245 
6246  // OpenCL and placeholder types don't need @encodings.
6247 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6248  case BuiltinType::Id:
6249 #include "clang/Basic/OpenCLImageTypes.def"
6250  case BuiltinType::OCLEvent:
6251  case BuiltinType::OCLClkEvent:
6252  case BuiltinType::OCLQueue:
6253  case BuiltinType::OCLReserveID:
6254  case BuiltinType::OCLSampler:
6255  case BuiltinType::Dependent:
6256 #define BUILTIN_TYPE(KIND, ID)
6257 #define PLACEHOLDER_TYPE(KIND, ID) \
6258  case BuiltinType::KIND:
6259 #include "clang/AST/BuiltinTypes.def"
6260  llvm_unreachable("invalid builtin type for @encode");
6261  }
6262  llvm_unreachable("invalid BuiltinType::Kind value");
6263 }
6264 
6265 static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) {
6266  EnumDecl *Enum = ET->getDecl();
6267 
6268  // The encoding of an non-fixed enum type is always 'i', regardless of size.
6269  if (!Enum->isFixed())
6270  return 'i';
6271 
6272  // The encoding of a fixed enum type matches its fixed underlying type.
6273  const BuiltinType *BT = Enum->getIntegerType()->castAs<BuiltinType>();
6274  return getObjCEncodingForPrimitiveKind(C, BT->getKind());
6275 }
6276 
6277 static void EncodeBitField(const ASTContext *Ctx, std::string& S,
6278  QualType T, const FieldDecl *FD) {
6279  assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl");
6280  S += 'b';
6281  // The NeXT runtime encodes bit fields as b followed by the number of bits.
6282  // The GNU runtime requires more information; bitfields are encoded as b,
6283  // then the offset (in bits) of the first element, then the type of the
6284  // bitfield, then the size in bits. For example, in this structure:
6285  //
6286  // struct
6287  // {
6288  // int integer;
6289  // int flags:2;
6290  // };
6291  // On a 32-bit system, the encoding for flags would be b2 for the NeXT
6292  // runtime, but b32i2 for the GNU runtime. The reason for this extra
6293  // information is not especially sensible, but we're stuck with it for
6294  // compatibility with GCC, although providing it breaks anything that
6295  // actually uses runtime introspection and wants to work on both runtimes...
6296  if (Ctx->getLangOpts().ObjCRuntime.isGNUFamily()) {
6297  uint64_t Offset;
6298 
6299  if (const auto *IVD = dyn_cast<ObjCIvarDecl>(FD)) {
6300  Offset = Ctx->lookupFieldBitOffset(IVD->getContainingInterface(), nullptr,
6301  IVD);
6302  } else {
6303  const RecordDecl *RD = FD->getParent();
6304  const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD);
6305  Offset = RL.getFieldOffset(FD->getFieldIndex());
6306  }
6307 
6308  S += llvm::utostr(Offset);
6309 
6310  if (const EnumType *ET = T->getAs<EnumType>())
6311  S += ObjCEncodingForEnumType(Ctx, ET);
6312  else {
6313  const BuiltinType *BT = T->castAs<BuiltinType>();
6314  S += getObjCEncodingForPrimitiveKind(Ctx, BT->getKind());
6315  }
6316  }
6317  S += llvm::utostr(FD->getBitWidthValue(*Ctx));
6318 }
6319 
6320 // FIXME: Use SmallString for accumulating string.
6321 void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S,
6322  bool ExpandPointedToStructures,
6323  bool ExpandStructures,
6324  const FieldDecl *FD,
6325  bool OutermostType,
6326  bool EncodingProperty,
6327  bool StructField,
6328  bool EncodeBlockParameters,
6329  bool EncodeClassNames,
6330  bool EncodePointerToObjCTypedef,
6331  QualType *NotEncodedT) const {
6332  CanQualType CT = getCanonicalType(T);
6333  switch (CT->getTypeClass()) {
6334  case Type::Builtin:
6335  case Type::Enum:
6336  if (FD && FD->isBitField())
6337  return EncodeBitField(this, S, T, FD);
6338  if (const BuiltinType *BT = dyn_cast<BuiltinType>(CT))
6339  S += getObjCEncodingForPrimitiveKind(this, BT->getKind());
6340  else
6341  S += ObjCEncodingForEnumType(this, cast<EnumType>(CT));
6342  return;
6343 
6344  case Type::Complex: {
6345  const ComplexType *CT = T->castAs<ComplexType>();
6346  S += 'j';
6347  getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, nullptr);
6348  return;
6349  }
6350 
6351  case Type::Atomic: {
6352  const AtomicType *AT = T->castAs<AtomicType>();
6353  S += 'A';
6354  getObjCEncodingForTypeImpl(AT->getValueType(), S, false, false, nullptr);
6355  return;
6356  }
6357 
6358  // encoding for pointer or reference types.
6359  case Type::Pointer:
6360  case Type::LValueReference:
6361  case Type::RValueReference: {
6362  QualType PointeeTy;
6363  if (isa<PointerType>(CT)) {
6364  const PointerType *PT = T->castAs<PointerType>();
6365  if (PT->isObjCSelType()) {
6366  S += ':';
6367  return;
6368  }
6369  PointeeTy = PT->getPointeeType();
6370  } else {
6371  PointeeTy = T->castAs<ReferenceType>()->getPointeeType();
6372  }
6373 
6374  bool isReadOnly = false;
6375  // For historical/compatibility reasons, the read-only qualifier of the
6376  // pointee gets emitted _before_ the '^'. The read-only qualifier of
6377  // the pointer itself gets ignored, _unless_ we are looking at a typedef!
6378  // Also, do not emit the 'r' for anything but the outermost type!
6379  if (isa<TypedefType>(T.getTypePtr())) {
6380  if (OutermostType && T.isConstQualified()) {
6381  isReadOnly = true;
6382  S += 'r';
6383  }
6384  } else if (OutermostType) {
6385  QualType P = PointeeTy;
6386  while (P->getAs<PointerType>())
6387  P = P->getAs<PointerType>()->getPointeeType();
6388  if (P.isConstQualified()) {
6389  isReadOnly = true;
6390  S += 'r';
6391  }
6392  }
6393  if (isReadOnly) {
6394  // Another legacy compatibility encoding. Some ObjC qualifier and type
6395  // combinations need to be rearranged.
6396  // Rewrite "in const" from "nr" to "rn"
6397  if (StringRef(S).endswith("nr"))
6398  S.replace(S.end()-2, S.end(), "rn");
6399  }
6400 
6401  if (PointeeTy->isCharType()) {
6402  // char pointer types should be encoded as '*' unless it is a
6403  // type that has been typedef'd to 'BOOL'.
6404  if (!isTypeTypedefedAsBOOL(PointeeTy)) {
6405  S += '*';
6406  return;
6407  }
6408  } else if (const RecordType *RTy = PointeeTy->getAs<RecordType>()) {
6409  // GCC binary compat: Need to convert "struct objc_class *" to "#".
6410  if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
6411  S += '#';
6412  return;
6413  }
6414  // GCC binary compat: Need to convert "struct objc_object *" to "@".
6415  if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
6416  S += '@';
6417  return;
6418  }
6419  // fall through...
6420  }
6421  S += '^';
6422  getLegacyIntegralTypeEncoding(PointeeTy);
6423 
6424  getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures,
6425  nullptr, false, false, false, false, false, false,
6426  NotEncodedT);
6427  return;
6428  }
6429 
6430  case Type::ConstantArray:
6431  case Type::IncompleteArray:
6432  case Type::VariableArray: {
6433  const ArrayType *AT = cast<ArrayType>(CT);
6434 
6435  if (isa<IncompleteArrayType>(AT) && !StructField) {
6436  // Incomplete arrays are encoded as a pointer to the array element.
6437  S += '^';
6438 
6439  getObjCEncodingForTypeImpl(AT->getElementType(), S,
6440  false, ExpandStructures, FD);
6441  } else {
6442  S += '[';
6443 
6444  if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT))
6445  S += llvm::utostr(CAT->getSize().getZExtValue());
6446  else {
6447  //Variable length arrays are encoded as a regular array with 0 elements.
6448  assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) &&
6449  "Unknown array type!");
6450  S += '0';
6451  }
6452 
6453  getObjCEncodingForTypeImpl(AT->getElementType(), S,
6454  false, ExpandStructures, FD,
6455  false, false, false, false, false, false,
6456  NotEncodedT);
6457  S += ']';
6458  }
6459  return;
6460  }
6461 
6462  case Type::FunctionNoProto:
6463  case Type::FunctionProto:
6464  S += '?';
6465  return;
6466 
6467  case Type::Record: {
6468  RecordDecl *RDecl = cast<RecordType>(CT)->getDecl();
6469  S += RDecl->isUnion() ? '(' : '{';
6470  // Anonymous structures print as '?'
6471  if (const IdentifierInfo *II = RDecl->getIdentifier()) {
6472  S += II->getName();
6474  = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
6475  const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
6476  llvm::raw_string_ostream OS(S);
6477  printTemplateArgumentList(OS, TemplateArgs.asArray(),
6478  getPrintingPolicy());
6479  }
6480  } else {
6481  S += '?';
6482  }
6483  if (ExpandStructures) {
6484  S += '=';
6485  if (!RDecl->isUnion()) {
6486  getObjCEncodingForStructureImpl(RDecl, S, FD, true, NotEncodedT);
6487  } else {
6488  for (const auto *Field : RDecl->fields()) {
6489  if (FD) {
6490  S += '"';
6491  S += Field->getNameAsString();
6492  S += '"';
6493  }
6494 
6495  // Special case bit-fields.
6496  if (Field->isBitField()) {
6497  getObjCEncodingForTypeImpl(Field->getType(), S, false, true,
6498  Field);
6499  } else {
6500  QualType qt = Field->getType();
6502  getObjCEncodingForTypeImpl(qt, S, false, true,
6503  FD, /*OutermostType*/false,
6504  /*EncodingProperty*/false,
6505  /*StructField*/true,
6506  false, false, false, NotEncodedT);
6507  }
6508  }
6509  }
6510  }
6511  S += RDecl->isUnion() ? ')' : '}';
6512  return;
6513  }
6514 
6515  case Type::BlockPointer: {
6516  const BlockPointerType *BT = T->castAs<BlockPointerType>();
6517  S += "@?"; // Unlike a pointer-to-function, which is "^?".
6518  if (EncodeBlockParameters) {
6519  const FunctionType *FT = BT->getPointeeType()->castAs<FunctionType>();
6520 
6521  S += '<';
6522  // Block return type
6523  getObjCEncodingForTypeImpl(
6524  FT->getReturnType(), S, ExpandPointedToStructures, ExpandStructures,
6525  FD, false /* OutermostType */, EncodingProperty,
6526  false /* StructField */, EncodeBlockParameters, EncodeClassNames, false,
6527  NotEncodedT);
6528  // Block self
6529  S += "@?";
6530  // Block parameters
6531  if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(FT)) {
6532  for (const auto &I : FPT->param_types())
6533  getObjCEncodingForTypeImpl(
6534  I, S, ExpandPointedToStructures, ExpandStructures, FD,
6535  false /* OutermostType */, EncodingProperty,
6536  false /* StructField */, EncodeBlockParameters, EncodeClassNames,
6537  false, NotEncodedT);
6538  }
6539  S += '>';
6540  }
6541  return;
6542  }
6543 
6544  case Type::ObjCObject: {
6545  // hack to match legacy encoding of *id and *Class
6547  if (Ty->isObjCIdType()) {
6548  S += "{objc_object=}";
6549  return;
6550  }
6551  else if (Ty->isObjCClassType()) {
6552  S += "{objc_class=}";
6553  return;
6554  }
6555  // TODO: Double check to make sure this intentially falls through.
6556  LLVM_FALLTHROUGH;
6557  }
6558 
6559  case Type::ObjCInterface: {
6560  // Ignore protocol qualifiers when mangling at this level.
6561  // @encode(class_name)
6562  ObjCInterfaceDecl *OI = T->castAs<ObjCObjectType>()->getInterface();
6563  S += '{';
6564  S += OI->getObjCRuntimeNameAsString();
6565  if (ExpandStructures) {
6566  S += '=';
6568  DeepCollectObjCIvars(OI, true, Ivars);
6569  for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
6570  const FieldDecl *Field = cast<FieldDecl>(Ivars[i]);
6571  if (Field->isBitField())
6572  getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field);
6573  else
6574  getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD,
6575  false, false, false, false, false,
6576  EncodePointerToObjCTypedef,
6577  NotEncodedT);
6578  }
6579  }
6580  S += '}';
6581  return;
6582  }
6583 
6584  case Type::ObjCObjectPointer: {
6586  if (OPT->isObjCIdType()) {
6587  S += '@';
6588  return;
6589  }
6590 
6591  if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
6592  // FIXME: Consider if we need to output qualifiers for 'Class<p>'.
6593  // Since this is a binary compatibility issue, need to consult with runtime
6594  // folks. Fortunately, this is a *very* obsure construct.
6595  S += '#';
6596  return;
6597  }
6598 
6599  if (OPT->isObjCQualifiedIdType()) {
6600  getObjCEncodingForTypeImpl(getObjCIdType(), S,
6601  ExpandPointedToStructures,
6602  ExpandStructures, FD);
6603  if (FD || EncodingProperty || EncodeClassNames) {
6604  // Note that we do extended encoding of protocol qualifer list
6605  // Only when doing ivar or property encoding.
6606  S += '"';
6607  for (const auto *I : OPT->quals()) {
6608  S += '<';
6609  S += I->getObjCRuntimeNameAsString();
6610  S += '>';
6611  }
6612  S += '"';
6613  }
6614  return;
6615  }
6616 
6617  QualType PointeeTy = OPT->getPointeeType();
6618  if (!EncodingProperty &&
6619  isa<TypedefType>(PointeeTy.getTypePtr()) &&
6620  !EncodePointerToObjCTypedef) {
6621  // Another historical/compatibility reason.
6622  // We encode the underlying type which comes out as
6623  // {...};
6624  S += '^';
6625  if (FD && OPT->getInterfaceDecl()) {
6626  // Prevent recursive encoding of fields in some rare cases.
6627  ObjCInterfaceDecl *OI = OPT->getInterfaceDecl();
6629  DeepCollectObjCIvars(OI, true, Ivars);
6630  for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
6631  if (cast<FieldDecl>(Ivars[i]) == FD) {
6632  S += '{';
6633  S += OI->getObjCRuntimeNameAsString();
6634  S += '}';
6635  return;
6636  }
6637  }
6638  }
6639  getObjCEncodingForTypeImpl(PointeeTy, S,
6640  false, ExpandPointedToStructures,
6641  nullptr,
6642  false, false, false, false, false,
6643  /*EncodePointerToObjCTypedef*/true);
6644  return;
6645  }
6646 
6647  S += '@';
6648  if (OPT->getInterfaceDecl() &&
6649  (FD || EncodingProperty || EncodeClassNames)) {
6650  S += '"';
6652  for (const auto *I : OPT->quals()) {
6653  S += '<';
6654  S += I->getObjCRuntimeNameAsString();
6655  S += '>';
6656  }
6657  S += '"';
6658  }
6659  return;
6660  }
6661 
6662  // gcc just blithely ignores member pointers.
6663  // FIXME: we shoul do better than that. 'M' is available.
6664  case Type::MemberPointer:
6665  // This matches gcc's encoding, even though technically it is insufficient.
6666  //FIXME. We should do a better job than gcc.
6667  case Type::Vector:
6668  case Type::ExtVector:
6669  // Until we have a coherent encoding of these three types, issue warning.
6670  if (NotEncodedT)
6671  *NotEncodedT = T;
6672  return;
6673 
6674  // We could see an undeduced auto type here during error recovery.
6675  // Just ignore it.
6676  case Type::Auto:
6677  case Type::DeducedTemplateSpecialization:
6678  return;
6679 
6680  case Type::Pipe:
6681 #define ABSTRACT_TYPE(KIND, BASE)
6682 #define TYPE(KIND, BASE)
6683 #define DEPENDENT_TYPE(KIND, BASE) \
6684  case Type::KIND:
6685 #define NON_CANONICAL_TYPE(KIND, BASE) \
6686  case Type::KIND:
6687 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \
6688  case Type::KIND:
6689 #include "clang/AST/TypeNodes.def"
6690  llvm_unreachable("@encode for dependent type!");
6691  }
6692  llvm_unreachable("bad type kind!");
6693 }
6694 
6695 void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl,
6696  std::string &S,
6697  const FieldDecl *FD,
6698  bool includeVBases,
6699  QualType *NotEncodedT) const {
6700  assert(RDecl && "Expected non-null RecordDecl");
6701  assert(!RDecl->isUnion() && "Should not be called for unions");
6702  if (!RDecl->getDefinition() || RDecl->getDefinition()->isInvalidDecl())
6703  return;
6704 
6705  CXXRecordDecl *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
6706  std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;
6707  const ASTRecordLayout &layout = getASTRecordLayout(RDecl);
6708 
6709  if (CXXRec) {
6710  for (const auto &BI : CXXRec->bases()) {
6711  if (!BI.isVirtual()) {
6712  CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
6713  if (base->isEmpty())
6714  continue;
6715  uint64_t offs = toBits(layout.getBaseClassOffset(base));
6716  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
6717  std::make_pair(offs, base));
6718  }
6719  }
6720  }
6721 
6722  unsigned i = 0;
6723  for (auto *Field : RDecl->fields()) {
6724  uint64_t offs = layout.getFieldOffset(i);
6725  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
6726  std::make_pair(offs, Field));
6727  ++i;
6728  }
6729 
6730  if (CXXRec && includeVBases) {
6731  for (const auto &BI : CXXRec->vbases()) {
6732  CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
6733  if (base->isEmpty())
6734  continue;
6735  uint64_t offs = toBits(layout.getVBaseClassOffset(base));
6736  if (offs >= uint64_t(toBits(layout.getNonVirtualSize())) &&
6737  FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end())
6738  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(),
6739  std::make_pair(offs, base));
6740  }
6741  }
6742 
6743  CharUnits size;
6744  if (CXXRec) {
6745  size = includeVBases ? layout.getSize() : layout.getNonVirtualSize();
6746  } else {
6747  size = layout.getSize();
6748  }
6749 
6750 #ifndef NDEBUG
6751  uint64_t CurOffs = 0;
6752 #endif
6753  std::multimap<uint64_t, NamedDecl *>::iterator
6754  CurLayObj = FieldOrBaseOffsets.begin();
6755 
6756  if (CXXRec && CXXRec->isDynamicClass() &&
6757  (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
6758  if (FD) {
6759  S += "\"_vptr$";
6760  std::string recname = CXXRec->getNameAsString();
6761  if (recname.empty()) recname = "?";
6762  S += recname;
6763  S += '"';
6764  }
6765  S += "^^?";
6766 #ifndef NDEBUG
6767  CurOffs += getTypeSize(VoidPtrTy);
6768 #endif
6769  }
6770 
6771  if (!RDecl->hasFlexibleArrayMember()) {
6772  // Mark the end of the structure.
6773  uint64_t offs = toBits(size);
6774  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
6775  std::make_pair(offs, nullptr));
6776  }
6777 
6778  for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {
6779 #ifndef NDEBUG
6780  assert(CurOffs <= CurLayObj->first);
6781  if (CurOffs < CurLayObj->first) {
6782  uint64_t padding = CurLayObj->first - CurOffs;
6783  // FIXME: There doesn't seem to be a way to indicate in the encoding that
6784  // packing/alignment of members is different that normal, in which case
6785  // the encoding will be out-of-sync with the real layout.
6786  // If the runtime switches to just consider the size of types without
6787  // taking into account alignment, we could make padding explicit in the
6788  // encoding (e.g. using arrays of chars). The encoding strings would be
6789  // longer then though.
6790  CurOffs += padding;
6791  }
6792 #endif
6793 
6794  NamedDecl *dcl = CurLayObj->second;
6795  if (!dcl)
6796  break; // reached end of structure.
6797 
6798  if (CXXRecordDecl *base = dyn_cast<CXXRecordDecl>(dcl)) {
6799  // We expand the bases without their virtual bases since those are going
6800  // in the initial structure. Note that this differs from gcc which
6801  // expands virtual bases each time one is encountered in the hierarchy,
6802  // making the encoding type bigger than it really is.
6803  getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false,
6804  NotEncodedT);
6805  assert(!base->isEmpty());
6806 #ifndef NDEBUG
6807  CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize());
6808 #endif
6809  } else {
6810  FieldDecl *field = cast<FieldDecl>(dcl);
6811  if (FD) {
6812  S += '"';
6813  S += field->getNameAsString();
6814  S += '"';
6815  }
6816 
6817  if (field->isBitField()) {
6818  EncodeBitField(this, S, field->getType(), field);
6819 #ifndef NDEBUG
6820  CurOffs += field->getBitWidthValue(*this);
6821 #endif
6822  } else {
6823  QualType qt = field->getType();
6825  getObjCEncodingForTypeImpl(qt, S, false, true, FD,
6826  /*OutermostType*/false,
6827  /*EncodingProperty*/false,
6828  /*StructField*/true,
6829  false, false, false, NotEncodedT);
6830 #ifndef NDEBUG
6831  CurOffs += getTypeSize(field->getType());
6832 #endif
6833  }
6834  }
6835  }
6836 }
6837 
6839  std::string& S) const {
6840  if (QT & Decl::OBJC_TQ_In)
6841  S += 'n';
6842  if (QT & Decl::OBJC_TQ_Inout)
6843  S += 'N';
6844  if (QT & Decl::OBJC_TQ_Out)
6845  S += 'o';
6846  if (QT & Decl::OBJC_TQ_Bycopy)
6847  S += 'O';
6848  if (QT & Decl::OBJC_TQ_Byref)
6849  S += 'R';
6850  if (QT & Decl::OBJC_TQ_Oneway)
6851  S += 'V';
6852 }
6853 
6855  if (!ObjCIdDecl) {
6857  T = getObjCObjectPointerType(T);
6858  ObjCIdDecl = buildImplicitTypedef(T, "id");
6859  }
6860  return ObjCIdDecl;
6861 }
6862 
6864  if (!ObjCSelDecl) {
6866  ObjCSelDecl = buildImplicitTypedef(T, "SEL");
6867  }
6868  return ObjCSelDecl;
6869 }
6870 
6872  if (!ObjCClassDecl) {
6874  T = getObjCObjectPointerType(T);
6875  ObjCClassDecl = buildImplicitTypedef(T, "Class");
6876  }
6877  return ObjCClassDecl;
6878 }
6879 
6881  if (!ObjCProtocolClassDecl) {
6882  ObjCProtocolClassDecl
6884  SourceLocation(),
6885  &Idents.get("Protocol"),
6886  /*typeParamList=*/nullptr,
6887  /*PrevDecl=*/nullptr,
6888  SourceLocation(), true);
6889  }
6890 
6891  return ObjCProtocolClassDecl;
6892 }
6893 
6894 //===----------------------------------------------------------------------===//
6895 // __builtin_va_list Construction Functions
6896 //===----------------------------------------------------------------------===//
6897 
6899  StringRef Name) {
6900  // typedef char* __builtin[_ms]_va_list;
6901  QualType T = Context->getPointerType(Context->CharTy);
6902  return Context->buildImplicitTypedef(T, Name);
6903 }
6904 
6905 static TypedefDecl *CreateMSVaListDecl(const ASTContext *Context) {
6906  return CreateCharPtrNamedVaListDecl(Context, "__builtin_ms_va_list");
6907 }
6908 
6910  return CreateCharPtrNamedVaListDecl(Context, "__builtin_va_list");
6911 }
6912 
6914  // typedef void* __builtin_va_list;
6915  QualType T = Context->getPointerType(Context->VoidTy);
6916  return Context->buildImplicitTypedef(T, "__builtin_va_list");
6917 }
6918 
6919 static TypedefDecl *
6921  // struct __va_list
6922  RecordDecl *VaListTagDecl = Context->buildImplicitRecord("__va_list");
6923  if (Context->getLangOpts().CPlusPlus) {
6924  // namespace std { struct __va_list {
6925  NamespaceDecl *NS;
6926  NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
6927  Context->getTranslationUnitDecl(),
6928  /*Inline*/ false, SourceLocation(),
6929  SourceLocation(), &Context->Idents.get("std"),
6930  /*PrevDecl*/ nullptr);
6931  NS->setImplicit();
6932  VaListTagDecl->setDeclContext(NS);
6933  }
6934 
6935  VaListTagDecl->startDefinition();
6936 
6937  const size_t NumFields = 5;
6938  QualType FieldTypes[NumFields];
6939  const char *FieldNames[NumFields];
6940 
6941  // void *__stack;
6942  FieldTypes[0] = Context->getPointerType(Context->VoidTy);
6943  FieldNames[0] = "__stack";
6944 
6945  // void *__gr_top;
6946  FieldTypes[1] = Context->getPointerType(Context->VoidTy);
6947  FieldNames[1] = "__gr_top";
6948 
6949  // void *__vr_top;
6950  FieldTypes[2] = Context->getPointerType(Context->VoidTy);
6951  FieldNames[2] = "__vr_top";
6952 
6953  // int __gr_offs;
6954  FieldTypes[3] = Context->IntTy;
6955  FieldNames[3] = "__gr_offs";
6956 
6957  // int __vr_offs;
6958  FieldTypes[4] = Context->IntTy;
6959  FieldNames[4] = "__vr_offs";
6960 
6961  // Create fields
6962  for (unsigned i = 0; i < NumFields; ++i) {
6963  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
6964  VaListTagDecl,
6965  SourceLocation(),
6966  SourceLocation(),
6967  &Context->Idents.get(FieldNames[i]),
6968  FieldTypes[i], /*TInfo=*/nullptr,
6969  /*BitWidth=*/nullptr,
6970  /*Mutable=*/false,
6971  ICIS_NoInit);
6972  Field->setAccess(AS_public);
6973  VaListTagDecl->addDecl(Field);
6974  }
6975  VaListTagDecl->completeDefinition();
6976  Context->VaListTagDecl = VaListTagDecl;
6977  QualType VaListTagType = Context->getRecordType(VaListTagDecl);
6978 
6979  // } __builtin_va_list;
6980  return Context->buildImplicitTypedef(VaListTagType, "__builtin_va_list");
6981 }
6982 
6984  // typedef struct __va_list_tag {
6986 
6987  VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
6988  VaListTagDecl->startDefinition();
6989 
6990  const size_t NumFields = 5;
6991  QualType FieldTypes[NumFields];
6992  const char *FieldNames[NumFields];
6993 
6994  // unsigned char gpr;
6995  FieldTypes[0] = Context->UnsignedCharTy;
6996  FieldNames[0] = "gpr";
6997 
6998  // unsigned char fpr;
6999  FieldTypes[1] = Context->UnsignedCharTy;
7000  FieldNames[1] = "fpr";
7001 
7002  // unsigned short reserved;
7003  FieldTypes[2] = Context->UnsignedShortTy;
7004  FieldNames[2] = "reserved";
7005 
7006  // void* overflow_arg_area;
7007  FieldTypes[3] = Context->getPointerType(Context->VoidTy);
7008  FieldNames[3] = "overflow_arg_area";
7009 
7010  // void* reg_save_area;
7011  FieldTypes[4] = Context->getPointerType(Context->VoidTy);
7012  FieldNames[4] = "reg_save_area";
7013 
7014  // Create fields
7015  for (unsigned i = 0; i < NumFields; ++i) {
7016  FieldDecl *Field = FieldDecl::Create(*Context, VaListTagDecl,
7017  SourceLocation(),
7018  SourceLocation(),
7019  &Context->Idents.get(FieldNames[i]),
7020  FieldTypes[i], /*TInfo=*/nullptr,
7021  /*BitWidth=*/nullptr,
7022  /*Mutable=*/false,
7023  ICIS_NoInit);
7024  Field->setAccess(AS_public);
7025  VaListTagDecl->addDecl(Field);
7026  }
7027  VaListTagDecl->completeDefinition();
7028  Context->VaListTagDecl = VaListTagDecl;
7029  QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7030 
7031  // } __va_list_tag;
7032  TypedefDecl *VaListTagTypedefDecl =
7033  Context->buildImplicitTypedef(VaListTagType, "__va_list_tag");
7034 
7035  QualType VaListTagTypedefType =
7036  Context->getTypedefType(VaListTagTypedefDecl);
7037 
7038  // typedef __va_list_tag __builtin_va_list[1];
7039  llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
7040  QualType VaListTagArrayType
7041  = Context->getConstantArrayType(VaListTagTypedefType,
7042  Size, ArrayType::Normal, 0);
7043  return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7044 }
7045 
7046 static TypedefDecl *
7048  // struct __va_list_tag {
7050  VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
7051  VaListTagDecl->startDefinition();
7052 
7053  const size_t NumFields = 4;
7054  QualType FieldTypes[NumFields];
7055  const char *FieldNames[NumFields];
7056 
7057  // unsigned gp_offset;
7058  FieldTypes[0] = Context->UnsignedIntTy;
7059  FieldNames[0] = "gp_offset";
7060 
7061  // unsigned fp_offset;
7062  FieldTypes[1] = Context->UnsignedIntTy;
7063  FieldNames[1] = "fp_offset";
7064 
7065  // void* overflow_arg_area;
7066  FieldTypes[2] = Context->getPointerType(Context->VoidTy);
7067  FieldNames[2] = "overflow_arg_area";
7068 
7069  // void* reg_save_area;
7070  FieldTypes[3] = Context->getPointerType(Context->VoidTy);
7071  FieldNames[3] = "reg_save_area";
7072 
7073  // Create fields
7074  for (unsigned i = 0; i < NumFields; ++i) {
7075  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7076  VaListTagDecl,
7077  SourceLocation(),
7078  SourceLocation(),
7079  &Context->Idents.get(FieldNames[i]),
7080  FieldTypes[i], /*TInfo=*/nullptr,
7081  /*BitWidth=*/nullptr,
7082  /*Mutable=*/false,
7083  ICIS_NoInit);
7084  Field->setAccess(AS_public);
7085  VaListTagDecl->addDecl(Field);
7086  }
7087  VaListTagDecl->completeDefinition();
7088  Context->VaListTagDecl = VaListTagDecl;
7089  QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7090 
7091  // };
7092 
7093  // typedef struct __va_list_tag __builtin_va_list[1];
7094  llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
7095  QualType VaListTagArrayType =
7096  Context->getConstantArrayType(VaListTagType, Size, ArrayType::Normal, 0);
7097  return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7098 }
7099 
7101  // typedef int __builtin_va_list[4];
7102  llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 4);
7103  QualType IntArrayType =
7104  Context->getConstantArrayType(Context->IntTy, Size, ArrayType::Normal, 0);
7105  return Context->buildImplicitTypedef(IntArrayType, "__builtin_va_list");
7106 }
7107 
7108 static TypedefDecl *
7110  // struct __va_list
7111  RecordDecl *VaListDecl = Context->buildImplicitRecord("__va_list");
7112  if (Context->getLangOpts().CPlusPlus) {
7113  // namespace std { struct __va_list {
7114  NamespaceDecl *NS;
7115  NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
7116  Context->getTranslationUnitDecl(),
7117  /*Inline*/false, SourceLocation(),
7118  SourceLocation(), &Context->Idents.get("std"),
7119  /*PrevDecl*/ nullptr);
7120  NS->setImplicit();
7121  VaListDecl->setDeclContext(NS);
7122  }
7123 
7124  VaListDecl->startDefinition();
7125 
7126  // void * __ap;
7127  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7128  VaListDecl,
7129  SourceLocation(),
7130  SourceLocation(),
7131  &Context->Idents.get("__ap"),
7132  Context->getPointerType(Context->VoidTy),
7133  /*TInfo=*/nullptr,
7134  /*BitWidth=*/nullptr,
7135  /*Mutable=*/false,
7136  ICIS_NoInit);
7137  Field->setAccess(AS_public);
7138  VaListDecl->addDecl(Field);
7139 
7140  // };
7141  VaListDecl->completeDefinition();
7142  Context->VaListTagDecl = VaListDecl;
7143 
7144  // typedef struct __va_list __builtin_va_list;
7145  QualType T = Context->getRecordType(VaListDecl);
7146  return Context->buildImplicitTypedef(T, "__builtin_va_list");
7147 }
7148 
7149 static TypedefDecl *
7151  // struct __va_list_tag {
7153  VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
7154  VaListTagDecl->startDefinition();
7155 
7156  const size_t NumFields = 4;
7157  QualType FieldTypes[NumFields];
7158  const char *FieldNames[NumFields];
7159 
7160  // long __gpr;
7161  FieldTypes[0] = Context->LongTy;
7162  FieldNames[0] = "__gpr";
7163 
7164  // long __fpr;
7165  FieldTypes[1] = Context->LongTy;
7166  FieldNames[1] = "__fpr";
7167 
7168  // void *__overflow_arg_area;
7169  FieldTypes[2] = Context->getPointerType(Context->VoidTy);
7170  FieldNames[2] = "__overflow_arg_area";
7171 
7172  // void *__reg_save_area;
7173  FieldTypes[3] = Context->getPointerType(Context->VoidTy);
7174  FieldNames[3] = "__reg_save_area";
7175 
7176  // Create fields
7177  for (unsigned i = 0; i < NumFields; ++i) {
7178  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7179  VaListTagDecl,
7180  SourceLocation(),
7181  SourceLocation(),
7182  &Context->Idents.get(FieldNames[i]),
7183  FieldTypes[i], /*TInfo=*/nullptr,
7184  /*BitWidth=*/nullptr,
7185  /*Mutable=*/false,
7186  ICIS_NoInit);
7187  Field->setAccess(AS_public);
7188  VaListTagDecl->addDecl(Field);
7189  }
7190  VaListTagDecl->completeDefinition();
7191  Context->VaListTagDecl = VaListTagDecl;
7192  QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7193 
7194  // };
7195 
7196  // typedef __va_list_tag __builtin_va_list[1];
7197  llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
7198  QualType VaListTagArrayType =
7199  Context->getConstantArrayType(VaListTagType, Size, ArrayType::Normal, 0);
7200 
7201  return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7202 }
7203 
7204 static TypedefDecl *CreateVaListDecl(const ASTContext *Context,
7206  switch (Kind) {
7208  return CreateCharPtrBuiltinVaListDecl(Context);
7210  return CreateVoidPtrBuiltinVaListDecl(Context);
7212  return CreateAArch64ABIBuiltinVaListDecl(Context);
7214  return CreatePowerABIBuiltinVaListDecl(Context);
7216  return CreateX86_64ABIBuiltinVaListDecl(Context);
7218  return CreatePNaClABIBuiltinVaListDecl(Context);
7220  return CreateAAPCSABIBuiltinVaListDecl(Context);
7222  return CreateSystemZBuiltinVaListDecl(Context);
7223  }
7224 
7225  llvm_unreachable("Unhandled __builtin_va_list type kind");
7226 }
7227 
7229  if (!BuiltinVaListDecl) {
7230  BuiltinVaListDecl = CreateVaListDecl(this, Target->getBuiltinVaListKind());
7231  assert(BuiltinVaListDecl->isImplicit());
7232  }
7233 
7234  return BuiltinVaListDecl;
7235 }
7236 
7238  // Force the creation of VaListTagDecl by building the __builtin_va_list
7239  // declaration.
7240  if (!VaListTagDecl)
7241  (void)getBuiltinVaListDecl();
7242 
7243  return VaListTagDecl;
7244 }
7245 
7247  if (!BuiltinMSVaListDecl)
7248  BuiltinMSVaListDecl = CreateMSVaListDecl(this);
7249 
7250  return BuiltinMSVaListDecl;
7251 }
7252 
7254  assert(ObjCConstantStringType.isNull() &&
7255  "'NSConstantString' type already set!");
7256 
7257  ObjCConstantStringType = getObjCInterfaceType(Decl);
7258 }
7259 
7260 /// \brief Retrieve the template name that corresponds to a non-empty
7261 /// lookup.
7264  UnresolvedSetIterator End) const {
7265  unsigned size = End - Begin;
7266  assert(size > 1 && "set is not overloaded!");
7267 
7268  void *memory = Allocate(sizeof(OverloadedTemplateStorage) +
7269  size * sizeof(FunctionTemplateDecl*));
7270  OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size);
7271 
7272  NamedDecl **Storage = OT->getStorage();
7273  for (UnresolvedSetIterator I = Begin; I != End; ++I) {
7274  NamedDecl *D = *I;
7275  assert(isa<FunctionTemplateDecl>(D) ||
7276  (isa<UsingShadowDecl>(D) &&
7277  isa<FunctionTemplateDecl>(D->getUnderlyingDecl())));
7278  *Storage++ = D;
7279  }
7280 
7281  return TemplateName(OT);
7282 }
7283 
7284 /// \brief Retrieve the template name that represents a qualified
7285 /// template name such as \c std::vector.
7288  bool TemplateKeyword,
7289  TemplateDecl *Template) const {
7290  assert(NNS && "Missing nested-name-specifier in qualified template name");
7291 
7292  // FIXME: Canonicalization?
7293  llvm::FoldingSetNodeID ID;
7294  QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
7295 
7296  void *InsertPos = nullptr;
7297  QualifiedTemplateName *QTN =
7298  QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7299  if (!QTN) {
7300  QTN = new (*this, alignof(QualifiedTemplateName))
7301  QualifiedTemplateName(NNS, TemplateKeyword, Template);
7302  QualifiedTemplateNames.InsertNode(QTN, InsertPos);
7303  }
7304 
7305  return TemplateName(QTN);
7306 }
7307 
7308 /// \brief Retrieve the template name that represents a dependent
7309 /// template name such as \c MetaFun::template apply.
7312  const IdentifierInfo *Name) const {
7313  assert((!NNS || NNS->isDependent()) &&
7314  "Nested name specifier must be dependent");
7315 
7316  llvm::FoldingSetNodeID ID;
7317  DependentTemplateName::Profile(ID, NNS, Name);
7318 
7319  void *InsertPos = nullptr;
7320  DependentTemplateName *QTN =
7321  DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7322 
7323  if (QTN)
7324  return TemplateName(QTN);
7325 
7327  if (CanonNNS == NNS) {
7328  QTN = new (*this, alignof(DependentTemplateName))
7329  DependentTemplateName(NNS, Name);
7330  } else {
7331  TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
7332  QTN = new (*this, alignof(DependentTemplateName))
7333  DependentTemplateName(NNS, Name, Canon);
7334  DependentTemplateName *CheckQTN =
7335  DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7336  assert(!CheckQTN && "Dependent type name canonicalization broken");
7337  (void)CheckQTN;
7338  }
7339 
7340  DependentTemplateNames.InsertNode(QTN, InsertPos);
7341  return TemplateName(QTN);
7342 }
7343 
7344 /// \brief Retrieve the template name that represents a dependent
7345 /// template name such as \c MetaFun::template operator+.
7346 TemplateName
7348  OverloadedOperatorKind Operator) const {
7349  assert((!NNS || NNS->isDependent()) &&
7350  "Nested name specifier must be dependent");
7351 
7352  llvm::FoldingSetNodeID ID;
7353  DependentTemplateName::Profile(ID, NNS, Operator);
7354 
7355  void *InsertPos = nullptr;
7357  = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7358 
7359  if (QTN)
7360  return TemplateName(QTN);
7361 
7363  if (CanonNNS == NNS) {
7364  QTN = new (*this, alignof(DependentTemplateName))
7365  DependentTemplateName(NNS, Operator);
7366  } else {
7367  TemplateName Canon = getDependentTemplateName(CanonNNS, Operator);
7368  QTN = new (*this, alignof(DependentTemplateName))
7369  DependentTemplateName(NNS, Operator, Canon);
7370 
7371  DependentTemplateName *CheckQTN
7372  = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7373  assert(!CheckQTN && "Dependent template name canonicalization broken");
7374  (void)CheckQTN;
7375  }
7376 
7377  DependentTemplateNames.InsertNode(QTN, InsertPos);
7378  return TemplateName(QTN);
7379 }
7380 
7381 TemplateName
7383  TemplateName replacement) const {
7384  llvm::FoldingSetNodeID ID;
7385  SubstTemplateTemplateParmStorage::Profile(ID, param, replacement);
7386 
7387  void *insertPos = nullptr;
7389  = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);
7390 
7391  if (!subst) {
7392  subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement);
7393  SubstTemplateTemplateParms.InsertNode(subst, insertPos);
7394  }
7395 
7396  return TemplateName(subst);
7397 }
7398 
7399 TemplateName
7401  const TemplateArgument &ArgPack) const {
7402  ASTContext &Self = const_cast<ASTContext &>(*this);
7403  llvm::FoldingSetNodeID ID;
7404  SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack);
7405 
7406  void *InsertPos = nullptr;
7408  = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);
7409 
7410  if (!Subst) {
7411  Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param,
7412  ArgPack.pack_size(),
7413  ArgPack.pack_begin());
7414  SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
7415  }
7416 
7417  return TemplateName(Subst);
7418 }
7419 
7420 /// getFromTargetType - Given one of the integer types provided by
7421 /// TargetInfo, produce the corresponding type. The unsigned @p Type
7422 /// is actually a value of type @c TargetInfo::IntType.
7423 CanQualType ASTContext::getFromTargetType(unsigned Type) const {
7424  switch (Type) {
7425  case TargetInfo::NoInt: return CanQualType();
7426  case TargetInfo::SignedChar: return SignedCharTy;
7428  case TargetInfo::SignedShort: return ShortTy;
7430  case TargetInfo::SignedInt: return IntTy;
7432  case TargetInfo::SignedLong: return LongTy;
7436  }
7437 
7438  llvm_unreachable("Unhandled TargetInfo::IntType value");
7439 }
7440 
7441 //===----------------------------------------------------------------------===//
7442 // Type Predicates.
7443 //===----------------------------------------------------------------------===//
7444 
7445 /// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
7446 /// garbage collection attribute.
7447 ///
7449  if (getLangOpts().getGC() == LangOptions::NonGC)
7450  return Qualifiers::GCNone;
7451 
7452  assert(getLangOpts().ObjC1);
7453  Qualifiers::GC GCAttrs = Ty.getObjCGCAttr();
7454 
7455  // Default behaviour under objective-C's gc is for ObjC pointers
7456  // (or pointers to them) be treated as though they were declared
7457  // as __strong.
7458  if (GCAttrs == Qualifiers::GCNone) {
7459  if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType())
7460  return Qualifiers::Strong;
7461  else if (Ty->isPointerType())
7463  } else {
7464  // It's not valid to set GC attributes on anything that isn't a
7465  // pointer.
7466 #ifndef NDEBUG
7468  while (const ArrayType *AT = dyn_cast<ArrayType>(CT))
7469  CT = AT->getElementType();
7470  assert(CT->isAnyPointerType() || CT->isBlockPointerType());
7471 #endif
7472  }
7473  return GCAttrs;
7474 }
7475 
7476 //===----------------------------------------------------------------------===//
7477 // Type Compatibility Testing
7478 //===----------------------------------------------------------------------===//
7479 
7480 /// areCompatVectorTypes - Return true if the two specified vector types are
7481 /// compatible.
7482 static bool areCompatVectorTypes(const VectorType *LHS,
7483  const VectorType *RHS) {
7484  assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified());
7485  return LHS->getElementType() == RHS->getElementType() &&
7486  LHS->getNumElements() == RHS->getNumElements();
7487 }
7488 
7490  QualType SecondVec) {
7491  assert(FirstVec->isVectorType() && "FirstVec should be a vector type");
7492  assert(SecondVec->isVectorType() && "SecondVec should be a vector type");
7493 
7494  if (hasSameUnqualifiedType(FirstVec, SecondVec))
7495  return true;
7496 
7497  // Treat Neon vector types and most AltiVec vector types as if they are the
7498  // equivalent GCC vector types.
7499  const VectorType *First = FirstVec->getAs<VectorType>();
7500  const VectorType *Second = SecondVec->getAs<VectorType>();
7501  if (First->getNumElements() == Second->getNumElements() &&
7502  hasSameType(First->getElementType(), Second->getElementType()) &&
7504  First->getVectorKind() != VectorType::AltiVecBool &&
7505  Second->getVectorKind() != VectorType::AltiVecPixel &&
7506  Second->getVectorKind() != VectorType::AltiVecBool)
7507  return true;
7508 
7509  return false;
7510 }
7511 
7512 //===----------------------------------------------------------------------===//
7513 // ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
7514 //===----------------------------------------------------------------------===//
7515 
7516 /// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
7517 /// inheritance hierarchy of 'rProto'.
7518 bool
7520  ObjCProtocolDecl *rProto) const {
7521  if (declaresSameEntity(lProto, rProto))
7522  return true;
7523  for (auto *PI : rProto->protocols())
7524  if (ProtocolCompatibleWithProtocol(lProto, PI))
7525  return true;
7526  return false;
7527 }
7528 
7529 /// ObjCQualifiedClassTypesAreCompatible - compare Class<pr,...> and
7530 /// Class<pr1, ...>.
7532  QualType rhs) {
7533  const ObjCObjectPointerType *lhsQID = lhs->getAs<ObjCObjectPointerType>();
7534  const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
7535  assert((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible");
7536 
7537  for (auto *lhsProto : lhsQID->quals()) {
7538  bool match = false;
7539  for (auto *rhsProto : rhsOPT->quals()) {
7540  if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) {
7541  match = true;
7542  break;
7543  }
7544  }
7545  if (!match)
7546  return false;
7547  }
7548  return true;
7549 }
7550 
7551 /// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
7552 /// ObjCQualifiedIDType.
7554  bool compare) {
7555  // Allow id<P..> and an 'id' or void* type in all cases.
7556  if (lhs->isVoidPointerType() ||
7557  lhs->isObjCIdType() || lhs->isObjCClassType())
7558  return true;
7559  else if (rhs->isVoidPointerType() ||
7560  rhs->isObjCIdType() || rhs->isObjCClassType())
7561  return true;
7562 
7563  if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) {
7564  const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
7565 
7566  if (!rhsOPT) return false;
7567 
7568  if (rhsOPT->qual_empty()) {
7569  // If the RHS is a unqualified interface pointer "NSString*",
7570  // make sure we check the class hierarchy.
7571  if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
7572  for (auto *I : lhsQID->quals()) {
7573  // when comparing an id<P> on lhs with a static type on rhs,
7574  // see if static class implements all of id's protocols, directly or
7575  // through its super class and categories.
7576  if (!rhsID->ClassImplementsProtocol(I, true))
7577  return false;
7578  }
7579  }
7580  // If there are no qualifiers and no interface, we have an 'id'.
7581  return true;
7582  }
7583  // Both the right and left sides have qualifiers.
7584  for (auto *lhsProto : lhsQID->quals()) {
7585  bool match = false;
7586 
7587  // when comparing an id<P> on lhs with a static type on rhs,
7588  // see if static class implements all of id's protocols, directly or
7589  // through its super class and categories.
7590  for (auto *rhsProto : rhsOPT->quals()) {
7591  if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
7592  (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
7593  match = true;
7594  break;
7595  }
7596  }
7597  // If the RHS is a qualified interface pointer "NSString<P>*",
7598  // make sure we check the class hierarchy.
7599  if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
7600  for (auto *I : lhsQID->quals()) {
7601  // when comparing an id<P> on lhs with a static type on rhs,
7602  // see if static class implements all of id's protocols, directly or
7603  // through its super class and categories.
7604  if (rhsID->ClassImplementsProtocol(I, true)) {
7605  match = true;
7606  break;
7607  }
7608  }
7609  }
7610  if (!match)
7611  return false;
7612  }
7613 
7614  return true;
7615  }
7616 
7617  const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType();
7618  assert(rhsQID && "One of the LHS/RHS should be id<x>");
7619 
7620  if (const ObjCObjectPointerType *lhsOPT =
7622  // If both the right and left sides have qualifiers.
7623  for (auto *lhsProto : lhsOPT->quals()) {
7624  bool match = false;
7625 
7626  // when comparing an id<P> on rhs with a static type on lhs,
7627  // see if static class implements all of id's protocols, directly or
7628  // through its super class and categories.
7629  // First, lhs protocols in the qualifier list must be found, direct
7630  // or indirect in rhs's qualifier list or it is a mismatch.
7631  for (auto *rhsProto : rhsQID->quals()) {
7632  if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
7633  (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
7634  match = true;
7635  break;
7636  }
7637  }
7638  if (!match)
7639  return false;
7640  }
7641 
7642  // Static class's protocols, or its super class or category protocols
7643  // must be found, direct or indirect in rhs's qualifier list or it is a mismatch.
7644  if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) {
7645  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
7646  CollectInheritedProtocols(lhsID, LHSInheritedProtocols);
7647  // This is rather dubious but matches gcc's behavior. If lhs has
7648  // no type qualifier and its class has no static protocol(s)
7649  // assume that it is mismatch.
7650  if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty())
7651  return false;
7652  for (auto *lhsProto : LHSInheritedProtocols) {
7653  bool match = false;
7654  for (auto *rhsProto : rhsQID->quals()) {
7655  if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
7656  (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
7657  match = true;
7658  break;
7659  }
7660  }
7661  if (!match)
7662  return false;
7663  }
7664  }
7665  return true;
7666  }
7667  return false;
7668 }
7669 
7670 /// canAssignObjCInterfaces - Return true if the two interface types are
7671 /// compatible for assignment from RHS to LHS. This handles validation of any
7672 /// protocol qualifiers on the LHS or RHS.
7674  const ObjCObjectPointerType *RHSOPT) {
7675  const ObjCObjectType* LHS = LHSOPT->getObjectType();
7676  const ObjCObjectType* RHS = RHSOPT->getObjectType();
7677 
7678  // If either type represents the built-in 'id' or 'Class' types, return true.
7679  if (LHS->isObjCUnqualifiedIdOrClass() ||
7681  return true;
7682 
7683  // Function object that propagates a successful result or handles
7684  // __kindof types.
7685  auto finish = [&](bool succeeded) -> bool {
7686  if (succeeded)
7687  return true;
7688 
7689  if (!RHS->isKindOfType())
7690  return false;
7691 
7692  // Strip off __kindof and protocol qualifiers, then check whether
7693  // we can assign the other way.
7695  LHSOPT->stripObjCKindOfTypeAndQuals(*this));
7696  };
7697 
7698  if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) {
7699  return finish(ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
7700  QualType(RHSOPT,0),
7701  false));
7702  }
7703 
7704  if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) {
7705  return finish(ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0),
7706  QualType(RHSOPT,0)));
7707  }
7708 
7709  // If we have 2 user-defined types, fall into that path.
7710  if (LHS->getInterface() && RHS->getInterface()) {
7711  return finish(canAssignObjCInterfaces(LHS, RHS));
7712  }
7713 
7714  return false;
7715 }
7716 
7717 /// canAssignObjCInterfacesInBlockPointer - This routine is specifically written
7718 /// for providing type-safety for objective-c pointers used to pass/return
7719 /// arguments in block literals. When passed as arguments, passing 'A*' where
7720 /// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is
7721 /// not OK. For the return type, the opposite is not OK.
7723  const ObjCObjectPointerType *LHSOPT,
7724  const ObjCObjectPointerType *RHSOPT,
7725  bool BlockReturnType) {
7726 
7727  // Function object that propagates a successful result or handles
7728  // __kindof types.
7729  auto finish = [&](bool succeeded) -> bool {
7730  if (succeeded)
7731  return true;
7732 
7733  const ObjCObjectPointerType *Expected = BlockReturnType ? RHSOPT : LHSOPT;
7734  if (!Expected->isKindOfType())
7735  return false;
7736 
7737  // Strip off __kindof and protocol qualifiers, then check whether
7738  // we can assign the other way.
7740  RHSOPT->stripObjCKindOfTypeAndQuals(*this),
7741  LHSOPT->stripObjCKindOfTypeAndQuals(*this),
7742  BlockReturnType);
7743  };
7744 
7745  if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType())
7746  return true;
7747 
7748  if (LHSOPT->isObjCBuiltinType()) {
7749  return finish(RHSOPT->isObjCBuiltinType() ||
7750  RHSOPT->isObjCQualifiedIdType());
7751  }
7752 
7753  if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
7754  return finish(ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
7755  QualType(RHSOPT,0),
7756  false));
7757 
7758  const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
7759  const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
7760  if (LHS && RHS) { // We have 2 user-defined types.
7761  if (LHS != RHS) {
7762  if (LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
7763  return finish(BlockReturnType);
7764  if (RHS->getDecl()->isSuperClassOf(LHS->getDecl()))
7765  return finish(!BlockReturnType);
7766  }
7767  else
7768  return true;
7769  }
7770  return false;
7771 }
7772 
7773 /// Comparison routine for Objective-C protocols to be used with
7774 /// llvm::array_pod_sort.
7776  ObjCProtocolDecl * const *rhs) {
7777  return (*lhs)->getName().compare((*rhs)->getName());
7778 }
7779 
7780 /// getIntersectionOfProtocols - This routine finds the intersection of set
7781 /// of protocols inherited from two distinct objective-c pointer objects with
7782 /// the given common base.
7783 /// It is used to build composite qualifier list of the composite type of
7784 /// the conditional expression involving two objective-c pointer objects.
7785 static
7788  const ObjCObjectPointerType *LHSOPT,
7789  const ObjCObjectPointerType *RHSOPT,
7790  SmallVectorImpl<ObjCProtocolDecl *> &IntersectionSet) {
7791 
7792  const ObjCObjectType* LHS = LHSOPT->getObjectType();
7793  const ObjCObjectType* RHS = RHSOPT->getObjectType();
7794  assert(LHS->getInterface() && "LHS must have an interface base");
7795  assert(RHS->getInterface() && "RHS must have an interface base");
7796 
7797  // Add all of the protocols for the LHS.
7798  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSProtocolSet;
7799 
7800  // Start with the protocol qualifiers.
7801  for (auto proto : LHS->quals()) {
7802  Context.CollectInheritedProtocols(proto, LHSProtocolSet);
7803  }
7804 
7805  // Also add the protocols associated with the LHS interface.
7806  Context.CollectInheritedProtocols(LHS->getInterface(), LHSProtocolSet);
7807 
7808  // Add all of the protocls for the RHS.
7809  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSProtocolSet;
7810 
7811  // Start with the protocol qualifiers.
7812  for (auto proto : RHS->quals()) {
7813  Context.CollectInheritedProtocols(proto, RHSProtocolSet);
7814  }
7815 
7816  // Also add the protocols associated with the RHS interface.
7817  Context.CollectInheritedProtocols(RHS->getInterface(), RHSProtocolSet);
7818 
7819  // Compute the intersection of the collected protocol sets.
7820  for (auto proto : LHSProtocolSet) {
7821  if (RHSProtocolSet.count(proto))
7822  IntersectionSet.push_back(proto);
7823  }
7824 
7825  // Compute the set of protocols that is implied by either the common type or
7826  // the protocols within the intersection.
7827  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> ImpliedProtocols;
7828  Context.CollectInheritedProtocols(CommonBase, ImpliedProtocols);
7829 
7830  // Remove any implied protocols from the list of inherited protocols.
7831  if (!ImpliedProtocols.empty()) {
7832  IntersectionSet.erase(
7833  std::remove_if(IntersectionSet.begin(),
7834  IntersectionSet.end(),
7835  [&](ObjCProtocolDecl *proto) -> bool {
7836  return ImpliedProtocols.count(proto) > 0;
7837  }),
7838  IntersectionSet.end());
7839  }
7840 
7841  // Sort the remaining protocols by name.
7842  llvm::array_pod_sort(IntersectionSet.begin(), IntersectionSet.end(),
7844 }
7845 
7846 /// Determine whether the first type is a subtype of the second.
7848  QualType rhs) {
7849  // Common case: two object pointers.
7850  const ObjCObjectPointerType *lhsOPT = lhs->getAs<ObjCObjectPointerType>();
7851  const ObjCObjectPointerType *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
7852  if (lhsOPT && rhsOPT)
7853  return ctx.canAssignObjCInterfaces(lhsOPT, rhsOPT);
7854 
7855  // Two block pointers.
7856  const BlockPointerType *lhsBlock = lhs->getAs<BlockPointerType>();
7857  const BlockPointerType *rhsBlock = rhs->getAs<BlockPointerType>();
7858  if (lhsBlock && rhsBlock)
7859  return ctx.typesAreBlockPointerCompatible(lhs, rhs);
7860 
7861  // If either is an unqualified 'id' and the other is a block, it's
7862  // acceptable.
7863  if ((lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||
7864  (rhsOPT && rhsOPT->isObjCIdType() && lhsBlock))
7865  return true;
7866 
7867  return false;
7868 }
7869 
7870 // Check that the given Objective-C type argument lists are equivalent.
7871 static bool sameObjCTypeArgs(ASTContext &ctx,
7872  const ObjCInterfaceDecl *iface,
7873  ArrayRef<QualType> lhsArgs,
7874  ArrayRef<QualType> rhsArgs,
7875  bool stripKindOf) {
7876  if (lhsArgs.size() != rhsArgs.size())
7877  return false;
7878 
7879  ObjCTypeParamList *typeParams = iface->getTypeParamList();
7880  for (unsigned i = 0, n = lhsArgs.size(); i != n; ++i) {
7881  if (ctx.hasSameType(lhsArgs[i], rhsArgs[i]))
7882  continue;
7883 
7884  switch (typeParams->begin()[i]->getVariance()) {
7886  if (!stripKindOf ||
7887  !ctx.hasSameType(lhsArgs[i].stripObjCKindOfType(ctx),
7888  rhsArgs[i].stripObjCKindOfType(ctx))) {
7889  return false;
7890  }
7891  break;
7892 
7894  if (!canAssignObjCObjectTypes(ctx, lhsArgs[i], rhsArgs[i]))
7895  return false;
7896  break;
7897 
7899  if (!canAssignObjCObjectTypes(ctx, rhsArgs[i], lhsArgs[i]))
7900  return false;
7901  break;
7902  }
7903  }
7904 
7905  return true;
7906 }
7907 
7909  const ObjCObjectPointerType *Lptr,
7910  const ObjCObjectPointerType *Rptr) {
7911  const ObjCObjectType *LHS = Lptr->getObjectType();
7912  const ObjCObjectType *RHS = Rptr->getObjectType();
7913  const ObjCInterfaceDecl* LDecl = LHS->getInterface();
7914  const ObjCInterfaceDecl* RDecl = RHS->getInterface();
7915 
7916  if (!LDecl || !RDecl)
7917  return QualType();
7918 
7919  // When either LHS or RHS is a kindof type, we should return a kindof type.
7920  // For example, for common base of kindof(ASub1) and kindof(ASub2), we return
7921  // kindof(A).
7922  bool anyKindOf = LHS->isKindOfType() || RHS->isKindOfType();
7923 
7924  // Follow the left-hand side up the class hierarchy until we either hit a
7925  // root or find the RHS. Record the ancestors in case we don't find it.
7926  llvm::SmallDenseMap<const ObjCInterfaceDecl *, const ObjCObjectType *, 4>
7927  LHSAncestors;
7928  while (true) {
7929  // Record this ancestor. We'll need this if the common type isn't in the
7930  // path from the LHS to the root.
7931  LHSAncestors[LHS->getInterface()->getCanonicalDecl()] = LHS;
7932 
7933  if (declaresSameEntity(LHS->getInterface(), RDecl)) {
7934  // Get the type arguments.
7935  ArrayRef<QualType> LHSTypeArgs = LHS->getTypeArgsAsWritten();
7936  bool anyChanges = false;
7937  if (LHS->isSpecialized() && RHS->isSpecialized()) {
7938  // Both have type arguments, compare them.
7939  if (!sameObjCTypeArgs(*this, LHS->getInterface(),
7940  LHS->getTypeArgs(), RHS->getTypeArgs(),
7941  /*stripKindOf=*/true))
7942  return QualType();
7943  } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
7944  // If only one has type arguments, the result will not have type
7945  // arguments.
7946  LHSTypeArgs = {};
7947  anyChanges = true;
7948  }
7949 
7950  // Compute the intersection of protocols.
7952  getIntersectionOfProtocols(*this, LHS->getInterface(), Lptr, Rptr,
7953  Protocols);
7954  if (!Protocols.empty())
7955  anyChanges = true;
7956 
7957  // If anything in the LHS will have changed, build a new result type.
7958  // If we need to return a kindof type but LHS is not a kindof type, we
7959  // build a new result type.
7960  if (anyChanges || LHS->isKindOfType() != anyKindOf) {
7962  Result = getObjCObjectType(Result, LHSTypeArgs, Protocols,
7963  anyKindOf || LHS->isKindOfType());
7964  return getObjCObjectPointerType(Result);
7965  }
7966 
7967  return getObjCObjectPointerType(QualType(LHS, 0));
7968  }
7969 
7970  // Find the superclass.
7971  QualType LHSSuperType = LHS->getSuperClassType();
7972  if (LHSSuperType.isNull())
7973  break;
7974 
7975  LHS = LHSSuperType->castAs<ObjCObjectType>();
7976  }
7977 
7978  // We didn't find anything by following the LHS to its root; now check
7979  // the RHS against the cached set of ancestors.
7980  while (true) {
7981  auto KnownLHS = LHSAncestors.find(RHS->getInterface()->getCanonicalDecl());
7982  if (KnownLHS != LHSAncestors.end()) {
7983  LHS = KnownLHS->second;
7984 
7985  // Get the type arguments.
7986  ArrayRef<QualType> RHSTypeArgs = RHS->getTypeArgsAsWritten();
7987  bool anyChanges = false;
7988  if (LHS->isSpecialized() && RHS->isSpecialized()) {
7989  // Both have type arguments, compare them.
7990  if (!sameObjCTypeArgs(*this, LHS->getInterface(),
7991  LHS->getTypeArgs(), RHS->getTypeArgs(),
7992  /*stripKindOf=*/true))
7993  return QualType();
7994  } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
7995  // If only one has type arguments, the result will not have type
7996  // arguments.
7997  RHSTypeArgs = {};
7998  anyChanges = true;
7999  }
8000 
8001  // Compute the intersection of protocols.
8003  getIntersectionOfProtocols(*this, RHS->getInterface(), Lptr, Rptr,
8004  Protocols);
8005  if (!Protocols.empty())
8006  anyChanges = true;
8007 
8008  // If we need to return a kindof type but RHS is not a kindof type, we
8009  // build a new result type.
8010  if (anyChanges || RHS->isKindOfType() != anyKindOf) {
8012  Result = getObjCObjectType(Result, RHSTypeArgs, Protocols,
8013  anyKindOf || RHS->isKindOfType());
8014  return getObjCObjectPointerType(Result);
8015  }
8016 
8017  return getObjCObjectPointerType(QualType(RHS, 0));
8018  }
8019 
8020  // Find the superclass of the RHS.
8021  QualType RHSSuperType = RHS->getSuperClassType();
8022  if (RHSSuperType.isNull())
8023  break;
8024 
8025  RHS = RHSSuperType->castAs<ObjCObjectType>();
8026  }
8027 
8028  return QualType();
8029 }
8030 
8032  const ObjCObjectType *RHS) {
8033  assert(LHS->getInterface() && "LHS is not an interface type");
8034  assert(RHS->getInterface() && "RHS is not an interface type");
8035 
8036  // Verify that the base decls are compatible: the RHS must be a subclass of
8037  // the LHS.
8038  ObjCInterfaceDecl *LHSInterface = LHS->getInterface();
8039  bool IsSuperClass = LHSInterface->isSuperClassOf(RHS->getInterface());
8040  if (!IsSuperClass)
8041  return false;
8042 
8043  // If the LHS has protocol qualifiers, determine whether all of them are
8044  // satisfied by the RHS (i.e., the RHS has a superset of the protocols in the
8045  // LHS).
8046  if (LHS->getNumProtocols() > 0) {
8047  // OK if conversion of LHS to SuperClass results in narrowing of types
8048  // ; i.e., SuperClass may implement at least one of the protocols
8049  // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok.
8050  // But not SuperObj<P1,P2,P3> = lhs<P1,P2>.
8051  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols;
8052  CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols);
8053  // Also, if RHS has explicit quelifiers, include them for comparing with LHS's
8054  // qualifiers.
8055  for (auto *RHSPI : RHS->quals())
8056  CollectInheritedProtocols(RHSPI, SuperClassInheritedProtocols);
8057  // If there is no protocols associated with RHS, it is not a match.
8058  if (SuperClassInheritedProtocols.empty())
8059  return false;
8060 
8061  for (const auto *LHSProto : LHS->quals()) {
8062  bool SuperImplementsProtocol = false;
8063  for (auto *SuperClassProto : SuperClassInheritedProtocols)
8064  if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {
8065  SuperImplementsProtocol = true;
8066  break;
8067  }
8068  if (!SuperImplementsProtocol)
8069  return false;
8070  }
8071  }
8072 
8073  // If the LHS is specialized, we may need to check type arguments.
8074  if (LHS->isSpecialized()) {
8075  // Follow the superclass chain until we've matched the LHS class in the
8076  // hierarchy. This substitutes type arguments through.
8077  const ObjCObjectType *RHSSuper = RHS;
8078  while (!declaresSameEntity(RHSSuper->getInterface(), LHSInterface))
8079  RHSSuper = RHSSuper->getSuperClassType()->castAs<ObjCObjectType>();
8080 
8081  // If the RHS is specializd, compare type arguments.
8082  if (RHSSuper->isSpecialized() &&
8083  !sameObjCTypeArgs(*this, LHS->getInterface(),
8084  LHS->getTypeArgs(), RHSSuper->getTypeArgs(),
8085  /*stripKindOf=*/true)) {
8086  return false;
8087  }
8088  }
8089 
8090  return true;
8091 }
8092 
8094  // get the "pointed to" types
8095  const ObjCObjectPointerType *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
8096  const ObjCObjectPointerType *RHSOPT = RHS->getAs<ObjCObjectPointerType>();
8097 
8098  if (!LHSOPT || !RHSOPT)
8099  return false;
8100 
8101  return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
8102  canAssignObjCInterfaces(RHSOPT, LHSOPT);
8103 }
8104 
8106  return canAssignObjCInterfaces(
8107  getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(),
8108  getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>());
8109 }
8110 
8111 /// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,
8112 /// both shall have the identically qualified version of a compatible type.
8113 /// C99 6.2.7p1: Two types have compatible types if their types are the
8114 /// same. See 6.7.[2,3,5] for additional rules.
8116  bool CompareUnqualified) {
8117  if (getLangOpts().CPlusPlus)
8118  return hasSameType(LHS, RHS);
8119 
8120  return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull();
8121 }
8122 
8124  return typesAreCompatible(LHS, RHS);
8125 }
8126 
8128  return !mergeTypes(LHS, RHS, true).isNull();
8129 }
8130 
8131 /// mergeTransparentUnionType - if T is a transparent union type and a member
8132 /// of T is compatible with SubType, return the merged type, else return
8133 /// QualType()
8135  bool OfBlockPointer,
8136  bool Unqualified) {
8137  if (const RecordType *UT = T->getAsUnionType()) {
8138  RecordDecl *UD = UT->getDecl();
8139  if (UD->hasAttr<TransparentUnionAttr>()) {
8140  for (const auto *I : UD->fields()) {
8141  QualType ET = I->getType().getUnqualifiedType();
8142  QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified);
8143  if (!MT.isNull())
8144  return MT;
8145  }
8146  }
8147  }
8148 
8149  return QualType();
8150 }
8151 
8152 /// mergeFunctionParameterTypes - merge two types which appear as function
8153 /// parameter types
8155  bool OfBlockPointer,
8156  bool Unqualified) {
8157  // GNU extension: two types are compatible if they appear as a function
8158  // argument, one of the types is a transparent union type and the other
8159  // type is compatible with a union member
8160  QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer,
8161  Unqualified);
8162  if (!lmerge.isNull())
8163  return lmerge;
8164 
8165  QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer,
8166  Unqualified);
8167  if (!rmerge.isNull())
8168  return rmerge;
8169 
8170  return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified);
8171 }
8172 
8174  bool OfBlockPointer,
8175  bool Unqualified) {
8176  const FunctionType *lbase = lhs->getAs<FunctionType>();
8177  const FunctionType *rbase = rhs->getAs<FunctionType>();
8178  const FunctionProtoType *lproto = dyn_cast<FunctionProtoType>(lbase);
8179  const FunctionProtoType *rproto = dyn_cast<FunctionProtoType>(rbase);
8180  bool allLTypes = true;
8181  bool allRTypes = true;
8182 
8183  // Check return type
8184  QualType retType;
8185  if (OfBlockPointer) {
8186  QualType RHS = rbase->getReturnType();
8187  QualType LHS = lbase->getReturnType();
8188  bool UnqualifiedResult = Unqualified;
8189  if (!UnqualifiedResult)
8190  UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers());
8191  retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true);
8192  }
8193  else
8194  retType = mergeTypes(lbase->getReturnType(), rbase->getReturnType(), false,
8195  Unqualified);
8196  if (retType.isNull()) return QualType();
8197 
8198  if (Unqualified)
8199  retType = retType.getUnqualifiedType();
8200 
8201  CanQualType LRetType = getCanonicalType(lbase->getReturnType());
8202  CanQualType RRetType = getCanonicalType(rbase->getReturnType());
8203  if (Unqualified) {
8204  LRetType = LRetType.getUnqualifiedType();
8205  RRetType = RRetType.getUnqualifiedType();
8206  }
8207 
8208  if (getCanonicalType(retType) != LRetType)
8209  allLTypes = false;
8210  if (getCanonicalType(retType) != RRetType)
8211  allRTypes = false;
8212 
8213  // FIXME: double check this
8214  // FIXME: should we error if lbase->getRegParmAttr() != 0 &&
8215  // rbase->getRegParmAttr() != 0 &&
8216  // lbase->getRegParmAttr() != rbase->getRegParmAttr()?
8217  FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo();
8218  FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo();
8219 
8220  // Compatible functions must have compatible calling conventions
8221  if (lbaseInfo.getCC() != rbaseInfo.getCC())
8222  return QualType();
8223 
8224  // Regparm is part of the calling convention.
8225  if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm())
8226  return QualType();
8227  if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm())
8228  return QualType();
8229 
8230  if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult())
8231  return QualType();
8232  if (lbaseInfo.getNoCallerSavedRegs() != rbaseInfo.getNoCallerSavedRegs())
8233  return QualType();
8234 
8235  // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'.
8236  bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn();
8237 
8238  if (lbaseInfo.getNoReturn() != NoReturn)
8239  allLTypes = false;
8240  if (rbaseInfo.getNoReturn() != NoReturn)
8241  allRTypes = false;
8242 
8243  FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn);
8244 
8245  if (lproto && rproto) { // two C99 style function prototypes
8246  assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&
8247  "C++ shouldn't be here");
8248  // Compatible functions must have the same number of parameters
8249  if (lproto->getNumParams() != rproto->getNumParams())
8250  return QualType();
8251 
8252  // Variadic and non-variadic functions aren't compatible
8253  if (lproto->isVariadic() != rproto->isVariadic())
8254  return QualType();
8255 
8256  if (lproto->getTypeQuals() != rproto->getTypeQuals())
8257  return QualType();
8258 
8260  bool canUseLeft, canUseRight;
8261  if (!mergeExtParameterInfo(lproto, rproto, canUseLeft, canUseRight,
8262  newParamInfos))
8263  return QualType();
8264 
8265  if (!canUseLeft)
8266  allLTypes = false;
8267  if (!canUseRight)
8268  allRTypes = false;
8269 
8270  // Check parameter type compatibility
8272  for (unsigned i = 0, n = lproto->getNumParams(); i < n; i++) {
8273  QualType lParamType = lproto->getParamType(i).getUnqualifiedType();
8274  QualType rParamType = rproto->getParamType(i).getUnqualifiedType();
8276  lParamType, rParamType, OfBlockPointer, Unqualified);
8277  if (paramType.isNull())
8278  return QualType();
8279 
8280  if (Unqualified)
8281  paramType = paramType.getUnqualifiedType();
8282 
8283  types.push_back(paramType);
8284  if (Unqualified) {
8285  lParamType = lParamType.getUnqualifiedType();
8286  rParamType = rParamType.getUnqualifiedType();
8287  }
8288 
8289  if (getCanonicalType(paramType) != getCanonicalType(lParamType))
8290  allLTypes = false;
8291  if (getCanonicalType(paramType) != getCanonicalType(rParamType))
8292  allRTypes = false;
8293  }
8294 
8295  if (allLTypes) return lhs;
8296  if (allRTypes) return rhs;
8297 
8298  FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo();
8299  EPI.ExtInfo = einfo;
8300  EPI.ExtParameterInfos =
8301  newParamInfos.empty() ? nullptr : newParamInfos.data();
8302  return getFunctionType(retType, types, EPI);
8303  }
8304 
8305  if (lproto) allRTypes = false;
8306  if (rproto) allLTypes = false;
8307 
8308  const FunctionProtoType *proto = lproto ? lproto : rproto;
8309  if (proto) {
8310  assert(!proto->hasExceptionSpec() && "C++ shouldn't be here");
8311  if (proto->isVariadic()) return QualType();
8312  // Check that the types are compatible with the types that
8313  // would result from default argument promotions (C99 6.7.5.3p15).
8314  // The only types actually affected are promotable integer
8315  // types and floats, which would be passed as a different
8316  // type depending on whether the prototype is visible.
8317  for (unsigned i = 0, n = proto->getNumParams(); i < n; ++i) {
8318  QualType paramTy = proto->getParamType(i);
8319 
8320  // Look at the converted type of enum types, since that is the type used
8321  // to pass enum values.
8322  if (const EnumType *Enum = paramTy->getAs<EnumType>()) {
8323  paramTy = Enum->getDecl()->getIntegerType();
8324  if (paramTy.isNull())
8325  return QualType();
8326  }
8327 
8328  if (paramTy->isPromotableIntegerType() ||
8330  return QualType();
8331  }
8332 
8333  if (allLTypes) return lhs;
8334  if (allRTypes) return rhs;
8335 
8337  EPI.ExtInfo = einfo;
8338  return getFunctionType(retType, proto->getParamTypes(), EPI);
8339  }
8340 
8341  if (allLTypes) return lhs;
8342  if (allRTypes) return rhs;
8343  return getFunctionNoProtoType(retType, einfo);
8344 }
8345 
8346 /// Given that we have an enum type and a non-enum type, try to merge them.
8348  QualType other, bool isBlockReturnType) {
8349  // C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
8350  // a signed integer type, or an unsigned integer type.
8351  // Compatibility is based on the underlying type, not the promotion
8352  // type.
8353  QualType underlyingType = ET->getDecl()->getIntegerType();
8354  if (underlyingType.isNull()) return QualType();
8355  if (Context.hasSameType(underlyingType, other))
8356  return other;
8357 
8358  // In block return types, we're more permissive and accept any
8359  // integral type of the same size.
8360  if (isBlockReturnType && other->isIntegerType() &&
8361  Context.getTypeSize(underlyingType) == Context.getTypeSize(other))
8362  return other;
8363 
8364  return QualType();
8365 }
8366 
8368  bool OfBlockPointer,
8369  bool Unqualified, bool BlockReturnType) {
8370  // C++ [expr]: If an expression initially has the type "reference to T", the
8371  // type is adjusted to "T" prior to any further analysis, the expression
8372  // designates the object or function denoted by the reference, and the
8373  // expression is an lvalue unless the reference is an rvalue reference and
8374  // the expression is a function call (possibly inside parentheses).
8375  assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?");
8376  assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?");
8377 
8378  if (Unqualified) {
8379  LHS = LHS.getUnqualifiedType();
8380  RHS = RHS.getUnqualifiedType();
8381  }
8382 
8383  QualType LHSCan = getCanonicalType(LHS),
8384  RHSCan = getCanonicalType(RHS);
8385 
8386  // If two types are identical, they are compatible.
8387  if (LHSCan == RHSCan)
8388  return LHS;
8389 
8390  // If the qualifiers are different, the types aren't compatible... mostly.
8391  Qualifiers LQuals = LHSCan.getLocalQualifiers();
8392  Qualifiers RQuals = RHSCan.getLocalQualifiers();
8393  if (LQuals != RQuals) {
8394  // If any of these qualifiers are different, we have a type
8395  // mismatch.
8396  if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
8397  LQuals.getAddressSpace() != RQuals.getAddressSpace() ||
8398  LQuals.getObjCLifetime() != RQuals.getObjCLifetime() ||
8399  LQuals.hasUnaligned() != RQuals.hasUnaligned())
8400  return QualType();
8401 
8402  // Exactly one GC qualifier difference is allowed: __strong is
8403  // okay if the other type has no GC qualifier but is an Objective
8404  // C object pointer (i.e. implicitly strong by default). We fix
8405  // this by pretending that the unqualified type was actually
8406  // qualified __strong.
8407  Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
8408  Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
8409  assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements");
8410 
8411  if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
8412  return QualType();
8413 
8414  if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) {
8415  return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong));
8416  }
8417  if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) {
8418  return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS);
8419  }
8420  return QualType();
8421  }
8422 
8423  // Okay, qualifiers are equal.
8424 
8425  Type::TypeClass LHSClass = LHSCan->getTypeClass();
8426  Type::TypeClass RHSClass = RHSCan->getTypeClass();
8427 
8428  // We want to consider the two function types to be the same for these
8429  // comparisons, just force one to the other.
8430  if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
8431  if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
8432 
8433  // Same as above for arrays
8434  if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
8435  LHSClass = Type::ConstantArray;
8436  if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
8437  RHSClass = Type::ConstantArray;
8438 
8439  // ObjCInterfaces are just specialized ObjCObjects.
8440  if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
8441  if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
8442 
8443  // Canonicalize ExtVector -> Vector.
8444  if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
8445  if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
8446 
8447  // If the canonical type classes don't match.
8448  if (LHSClass != RHSClass) {
8449  // Note that we only have special rules for turning block enum
8450  // returns into block int returns, not vice-versa.
8451  if (const EnumType* ETy = LHS->getAs<EnumType>()) {
8452  return mergeEnumWithInteger(*this, ETy, RHS, false);
8453  }
8454  if (const EnumType* ETy = RHS->getAs<EnumType>()) {
8455  return mergeEnumWithInteger(*this, ETy, LHS, BlockReturnType);
8456  }
8457  // allow block pointer type to match an 'id' type.
8458  if (OfBlockPointer && !BlockReturnType) {
8459  if (LHS->isObjCIdType() && RHS->isBlockPointerType())
8460  return LHS;
8461  if (RHS->isObjCIdType() && LHS->isBlockPointerType())
8462  return RHS;
8463  }
8464 
8465  return QualType();
8466  }
8467 
8468  // The canonical type classes match.
8469  switch (LHSClass) {
8470 #define TYPE(Class, Base)
8471 #define ABSTRACT_TYPE(Class, Base)
8472 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
8473 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
8474 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
8475 #include "clang/AST/TypeNodes.def"
8476  llvm_unreachable("Non-canonical and dependent types shouldn't get here");
8477 
8478  case Type::Auto:
8479  case Type::DeducedTemplateSpecialization:
8480  case Type::LValueReference:
8481  case Type::RValueReference:
8482  case Type::MemberPointer:
8483  llvm_unreachable("C++ should never be in mergeTypes");
8484 
8485  case Type::ObjCInterface:
8486  case Type::IncompleteArray:
8487  case Type::VariableArray:
8488  case Type::FunctionProto:
8489  case Type::ExtVector:
8490  llvm_unreachable("Types are eliminated above");
8491 
8492  case Type::Pointer:
8493  {
8494  // Merge two pointer types, while trying to preserve typedef info
8495  QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType();
8496  QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType();
8497  if (Unqualified) {
8498  LHSPointee = LHSPointee.getUnqualifiedType();
8499  RHSPointee = RHSPointee.getUnqualifiedType();
8500  }
8501  QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false,
8502  Unqualified);
8503  if (ResultType.isNull()) return QualType();
8504  if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
8505  return LHS;
8506  if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
8507  return RHS;
8508  return getPointerType(ResultType);
8509  }
8510  case Type::BlockPointer:
8511  {
8512  // Merge two block pointer types, while trying to preserve typedef info
8513  QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType();
8514  QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType();
8515  if (Unqualified) {
8516  LHSPointee = LHSPointee.getUnqualifiedType();
8517  RHSPointee = RHSPointee.getUnqualifiedType();
8518  }
8519  if (getLangOpts().OpenCL) {
8520  Qualifiers LHSPteeQual = LHSPointee.getQualifiers();
8521  Qualifiers RHSPteeQual = RHSPointee.getQualifiers();
8522  // Blocks can't be an expression in a ternary operator (OpenCL v2.0
8523  // 6.12.5) thus the following check is asymmetric.
8524  if (!LHSPteeQual.isAddressSpaceSupersetOf(RHSPteeQual))
8525  return QualType();
8526  LHSPteeQual.removeAddressSpace();
8527  RHSPteeQual.removeAddressSpace();
8528  LHSPointee =
8529  QualType(LHSPointee.getTypePtr(), LHSPteeQual.getAsOpaqueValue());
8530  RHSPointee =
8531  QualType(RHSPointee.getTypePtr(), RHSPteeQual.getAsOpaqueValue());
8532  }
8533  QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer,
8534  Unqualified);
8535  if (ResultType.isNull()) return QualType();
8536  if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
8537  return LHS;
8538  if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
8539  return RHS;
8540  return getBlockPointerType(ResultType);
8541  }
8542  case Type::Atomic:
8543  {
8544  // Merge two pointer types, while trying to preserve typedef info
8545  QualType LHSValue = LHS->getAs<AtomicType>()->getValueType();
8546  QualType RHSValue = RHS->getAs<AtomicType>()->getValueType();
8547  if (Unqualified) {
8548  LHSValue = LHSValue.getUnqualifiedType();
8549  RHSValue = RHSValue.getUnqualifiedType();
8550  }
8551  QualType ResultType = mergeTypes(LHSValue, RHSValue, false,
8552  Unqualified);
8553  if (ResultType.isNull()) return QualType();
8554  if (getCanonicalType(LHSValue) == getCanonicalType(ResultType))
8555  return LHS;
8556  if (getCanonicalType(RHSValue) == getCanonicalType(ResultType))
8557  return RHS;
8558  return getAtomicType(ResultType);
8559  }
8560  case Type::ConstantArray:
8561  {
8562  const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
8563  const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
8564  if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
8565  return QualType();
8566 
8567  QualType LHSElem = getAsArrayType(LHS)->getElementType();
8568  QualType RHSElem = getAsArrayType(RHS)->getElementType();
8569  if (Unqualified) {
8570  LHSElem = LHSElem.getUnqualifiedType();
8571  RHSElem = RHSElem.getUnqualifiedType();
8572  }
8573 
8574  QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified);
8575  if (ResultType.isNull()) return QualType();
8576  if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
8577  return LHS;
8578  if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
8579  return RHS;
8580  if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(),
8582  if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(),
8584  const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
8585  const VariableArrayType* RVAT = getAsVariableArrayType(RHS);
8586  if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
8587  return LHS;
8588  if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
8589  return RHS;
8590  if (LVAT) {
8591  // FIXME: This isn't correct! But tricky to implement because
8592  // the array's size has to be the size of LHS, but the type
8593  // has to be different.
8594  return LHS;
8595  }
8596  if (RVAT) {
8597  // FIXME: This isn't correct! But tricky to implement because
8598  // the array's size has to be the size of RHS, but the type
8599  // has to be different.
8600  return RHS;
8601  }
8602  if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
8603  if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
8604  return getIncompleteArrayType(ResultType,
8606  }
8607  case Type::FunctionNoProto:
8608  return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified);
8609  case Type::Record:
8610  case Type::Enum:
8611  return QualType();
8612  case Type::Builtin:
8613  // Only exactly equal builtin types are compatible, which is tested above.
8614  return QualType();
8615  case Type::Complex:
8616  // Distinct complex types are incompatible.
8617  return QualType();
8618  case Type::Vector:
8619  // FIXME: The merged type should be an ExtVector!
8620  if (areCompatVectorTypes(LHSCan->getAs<VectorType>(),
8621  RHSCan->getAs<VectorType>()))
8622  return LHS;
8623  return QualType();
8624  case Type::ObjCObject: {
8625  // Check if the types are assignment compatible.
8626  // FIXME: This should be type compatibility, e.g. whether
8627  // "LHS x; RHS x;" at global scope is legal.
8628  const ObjCObjectType* LHSIface = LHS->getAs<ObjCObjectType>();
8629  const ObjCObjectType* RHSIface = RHS->getAs<ObjCObjectType>();
8630  if (canAssignObjCInterfaces(LHSIface, RHSIface))
8631  return LHS;
8632 
8633  return QualType();
8634  }
8635  case Type::ObjCObjectPointer:
8636  if (OfBlockPointer) {
8638  LHS->getAs<ObjCObjectPointerType>(),
8639  RHS->getAs<ObjCObjectPointerType>(),
8640  BlockReturnType))
8641  return LHS;
8642  return QualType();
8643  }
8645  RHS->getAs<ObjCObjectPointerType>()))
8646  return LHS;
8647 
8648  return QualType();
8649  case Type::Pipe:
8650  assert(LHS != RHS &&
8651  "Equivalent pipe types should have already been handled!");
8652  return QualType();
8653  }
8654 
8655  llvm_unreachable("Invalid Type::Class!");
8656 }
8657 
8659  const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType,
8660  bool &CanUseFirst, bool &CanUseSecond,
8662  assert(NewParamInfos.empty() && "param info list not empty");
8663  CanUseFirst = CanUseSecond = true;
8664  bool FirstHasInfo = FirstFnType->hasExtParameterInfos();
8665  bool SecondHasInfo = SecondFnType->hasExtParameterInfos();
8666 
8667  // Fast path: if the first type doesn't have ext parameter infos,
8668  // we match if and only if the second type also doesn't have them.
8669  if (!FirstHasInfo && !SecondHasInfo)
8670  return true;
8671 
8672  bool NeedParamInfo = false;
8673  size_t E = FirstHasInfo ? FirstFnType->getExtParameterInfos().size()
8674  : SecondFnType->getExtParameterInfos().size();
8675 
8676  for (size_t I = 0; I < E; ++I) {
8677  FunctionProtoType::ExtParameterInfo FirstParam, SecondParam;
8678  if (FirstHasInfo)
8679  FirstParam = FirstFnType->getExtParameterInfo(I);
8680  if (SecondHasInfo)
8681  SecondParam = SecondFnType->getExtParameterInfo(I);
8682 
8683  // Cannot merge unless everything except the noescape flag matches.
8684  if (FirstParam.withIsNoEscape(false) != SecondParam.withIsNoEscape(false))
8685  return false;
8686 
8687  bool FirstNoEscape = FirstParam.isNoEscape();
8688  bool SecondNoEscape = SecondParam.isNoEscape();
8689  bool IsNoEscape = FirstNoEscape && SecondNoEscape;
8690  NewParamInfos.push_back(FirstParam.withIsNoEscape(IsNoEscape));
8691  if (NewParamInfos.back().getOpaqueValue())
8692  NeedParamInfo = true;
8693  if (FirstNoEscape != IsNoEscape)
8694  CanUseFirst = false;
8695  if (SecondNoEscape != IsNoEscape)
8696  CanUseSecond = false;
8697  }
8698 
8699  if (!NeedParamInfo)
8700  NewParamInfos.clear();
8701 
8702  return true;
8703 }
8704 
8706  ObjCLayouts[CD] = nullptr;
8707 }
8708 
8709 /// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and
8710 /// 'RHS' attributes and returns the merged version; including for function
8711 /// return types.
8713  QualType LHSCan = getCanonicalType(LHS),
8714  RHSCan = getCanonicalType(RHS);
8715  // If two types are identical, they are compatible.
8716  if (LHSCan == RHSCan)
8717  return LHS;
8718  if (RHSCan->isFunctionType()) {
8719  if (!LHSCan->isFunctionType())
8720  return QualType();
8721  QualType OldReturnType =
8722  cast<FunctionType>(RHSCan.getTypePtr())->getReturnType();
8723  QualType NewReturnType =
8724  cast<FunctionType>(LHSCan.getTypePtr())->getReturnType();
8725  QualType ResReturnType =
8726  mergeObjCGCQualifiers(NewReturnType, OldReturnType);
8727  if (ResReturnType.isNull())
8728  return QualType();
8729  if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
8730  // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo();
8731  // In either case, use OldReturnType to build the new function type.
8732  const FunctionType *F = LHS->getAs<FunctionType>();
8733  if (const FunctionProtoType *FPT = cast<FunctionProtoType>(F)) {
8734  FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
8735  EPI.ExtInfo = getFunctionExtInfo(LHS);
8736  QualType ResultType =
8737  getFunctionType(OldReturnType, FPT->getParamTypes(), EPI);
8738  return ResultType;
8739  }
8740  }
8741  return QualType();
8742  }
8743 
8744  // If the qualifiers are different, the types can still be merged.
8745  Qualifiers LQuals = LHSCan.getLocalQualifiers();
8746  Qualifiers RQuals = RHSCan.getLocalQualifiers();
8747  if (LQuals != RQuals) {
8748  // If any of these qualifiers are different, we have a type mismatch.
8749  if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
8750  LQuals.getAddressSpace() != RQuals.getAddressSpace())
8751  return QualType();
8752 
8753  // Exactly one GC qualifier difference is allowed: __strong is
8754  // okay if the other type has no GC qualifier but is an Objective
8755  // C object pointer (i.e. implicitly strong by default). We fix
8756  // this by pretending that the unqualified type was actually
8757  // qualified __strong.
8758  Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
8759  Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
8760  assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements");
8761 
8762  if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
8763  return QualType();
8764 
8765  if (GC_L == Qualifiers::Strong)
8766  return LHS;
8767  if (GC_R == Qualifiers::Strong)
8768  return RHS;
8769  return QualType();
8770  }
8771 
8772  if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) {
8773  QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType();
8774  QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType();
8775  QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT);
8776  if (ResQT == LHSBaseQT)
8777  return LHS;
8778  if (ResQT == RHSBaseQT)
8779  return RHS;
8780  }
8781  return QualType();
8782 }
8783 
8784 //===----------------------------------------------------------------------===//
8785 // Integer Predicates
8786 //===----------------------------------------------------------------------===//
8787 
8789  if (const EnumType *ET = T->getAs<EnumType>())
8790  T = ET->getDecl()->getIntegerType();
8791  if (T->isBooleanType())
8792  return 1;
8793  // For builtin types, just use the standard type sizing method
8794  return (unsigned)getTypeSize(T);
8795 }
8796 
8798  assert(T->hasSignedIntegerRepresentation() && "Unexpected type");
8799 
8800  // Turn <4 x signed int> -> <4 x unsigned int>
8801  if (const VectorType *VTy = T->getAs<VectorType>())
8802  return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()),
8803  VTy->getNumElements(), VTy->getVectorKind());
8804 
8805  // For enums, we return the unsigned version of the base type.
8806  if (const EnumType *ETy = T->getAs<EnumType>())
8807  T = ETy->getDecl()->getIntegerType();
8808 
8809  const BuiltinType *BTy = T->getAs<BuiltinType>();
8810  assert(BTy && "Unexpected signed integer type");
8811  switch (BTy->getKind()) {
8812  case BuiltinType::Char_S:
8813  case BuiltinType::SChar:
8814  return UnsignedCharTy;
8815  case BuiltinType::Short:
8816  return UnsignedShortTy;
8817  case BuiltinType::Int:
8818  return UnsignedIntTy;
8819  case BuiltinType::Long:
8820  return UnsignedLongTy;
8821  case BuiltinType::LongLong:
8822  return UnsignedLongLongTy;
8823  case BuiltinType::Int128:
8824  return UnsignedInt128Ty;
8825  default:
8826  llvm_unreachable("Unexpected signed integer type");
8827  }
8828 }
8829 
8831 
8833  QualType ReturnType) {}
8834 
8835 //===----------------------------------------------------------------------===//
8836 // Builtin Type Computation
8837 //===----------------------------------------------------------------------===//
8838 
8839 /// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
8840 /// pointer over the consumed characters. This returns the resultant type. If
8841 /// AllowTypeModifiers is false then modifier like * are not parsed, just basic
8842 /// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of
8843 /// a vector of "i*".
8844 ///
8845 /// RequiresICE is filled in on return to indicate whether the value is required
8846 /// to be an Integer Constant Expression.
8847 static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context,
8849  bool &RequiresICE,
8850  bool AllowTypeModifiers) {
8851  // Modifiers.
8852  int HowLong = 0;
8853  bool Signed = false, Unsigned = false;
8854  RequiresICE = false;
8855 
8856  // Read the prefixed modifiers first.
8857  bool Done = false;
8858  #ifndef NDEBUG
8859  bool IsSpecialLong = false;
8860  #endif
8861  while (!Done) {
8862  switch (*Str++) {
8863  default: Done = true; --Str; break;
8864  case 'I':
8865  RequiresICE = true;
8866  break;
8867  case 'S':
8868  assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!");
8869  assert(!Signed && "Can't use 'S' modifier multiple times!");
8870  Signed = true;
8871  break;
8872  case 'U':
8873  assert(!Signed && "Can't use both 'S' and 'U' modifiers!");
8874  assert(!Unsigned && "Can't use 'U' modifier multiple times!");
8875  Unsigned = true;
8876  break;
8877  case 'L':
8878  assert(!IsSpecialLong && "Can't use 'L' with 'W' or 'N' modifiers");
8879  assert(HowLong <= 2 && "Can't have LLLL modifier");
8880  ++HowLong;
8881  break;
8882  case 'N':
8883  // 'N' behaves like 'L' for all non LP64 targets and 'int' otherwise.
8884  assert(!IsSpecialLong && "Can't use two 'N' or 'W' modifiers!");
8885  assert(HowLong == 0 && "Can't use both 'L' and 'N' modifiers!");
8886  #ifndef NDEBUG
8887  IsSpecialLong = true;
8888  #endif
8889  if (Context.getTargetInfo().getLongWidth() == 32)
8890  ++HowLong;
8891  break;
8892  case 'W':
8893  // This modifier represents int64 type.
8894  assert(!IsSpecialLong && "Can't use two 'N' or 'W' modifiers!");
8895  assert(HowLong == 0 && "Can't use both 'L' and 'W' modifiers!");
8896  #ifndef NDEBUG
8897  IsSpecialLong = true;
8898  #endif
8899  switch (Context.getTargetInfo().getInt64Type()) {
8900  default:
8901  llvm_unreachable("Unexpected integer type");
8903  HowLong = 1;
8904  break;
8906  HowLong = 2;
8907  break;
8908  }
8909  break;
8910  }
8911  }
8912 
8913  QualType Type;
8914 
8915  // Read the base type.
8916  switch (*Str++) {
8917  default: llvm_unreachable("Unknown builtin type letter!");
8918  case 'v':
8919  assert(HowLong == 0 && !Signed && !Unsigned &&
8920  "Bad modifiers used with 'v'!");
8921  Type = Context.VoidTy;
8922  break;
8923  case 'h':
8924  assert(HowLong == 0 && !Signed && !Unsigned &&
8925  "Bad modifiers used with 'h'!");
8926  Type = Context.HalfTy;
8927  break;
8928  case 'f':
8929  assert(HowLong == 0 && !Signed && !Unsigned &&
8930  "Bad modifiers used with 'f'!");
8931  Type = Context.FloatTy;
8932  break;
8933  case 'd':
8934  assert(HowLong < 2 && !Signed && !Unsigned &&
8935  "Bad modifiers used with 'd'!");
8936  if (HowLong)
8937  Type = Context.LongDoubleTy;
8938  else
8939  Type = Context.DoubleTy;
8940  break;
8941  case 's':
8942  assert(HowLong == 0 && "Bad modifiers used with 's'!");
8943  if (Unsigned)
8944  Type = Context.UnsignedShortTy;
8945  else
8946  Type = Context.ShortTy;
8947  break;
8948  case 'i':
8949  if (HowLong == 3)
8950  Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
8951  else if (HowLong == 2)
8952  Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
8953  else if (HowLong == 1)
8954  Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
8955  else
8956  Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
8957  break;
8958  case 'c':
8959  assert(HowLong == 0 && "Bad modifiers used with 'c'!");
8960  if (Signed)
8961  Type = Context.SignedCharTy;
8962  else if (Unsigned)
8963  Type = Context.UnsignedCharTy;
8964  else
8965  Type = Context.CharTy;
8966  break;
8967  case 'b': // boolean
8968  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!");
8969  Type = Context.BoolTy;
8970  break;
8971  case 'z': // size_t.
8972  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!");
8973  Type = Context.getSizeType();
8974  break;
8975  case 'w': // wchar_t.
8976  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'w'!");
8977  Type = Context.getWideCharType();
8978  break;
8979  case 'F':
8980  Type = Context.getCFConstantStringType();
8981  break;
8982  case 'G':
8983  Type = Context.getObjCIdType();
8984  break;
8985  case 'H':
8986  Type = Context.getObjCSelType();
8987  break;
8988  case 'M':
8989  Type = Context.getObjCSuperType();
8990  break;
8991  case 'a':
8992  Type = Context.getBuiltinVaListType();
8993  assert(!Type.isNull() && "builtin va list type not initialized!");
8994  break;
8995  case 'A':
8996  // This is a "reference" to a va_list; however, what exactly
8997  // this means depends on how va_list is defined. There are two
8998  // different kinds of va_list: ones passed by value, and ones
8999  // passed by reference. An example of a by-value va_list is
9000  // x86, where va_list is a char*. An example of by-ref va_list
9001  // is x86-64, where va_list is a __va_list_tag[1]. For x86,
9002  // we want this argument to be a char*&; for x86-64, we want
9003  // it to be a __va_list_tag*.
9004  Type = Context.getBuiltinVaListType();
9005  assert(!Type.isNull() && "builtin va list type not initialized!");
9006  if (Type->isArrayType())
9007  Type = Context.getArrayDecayedType(Type);
9008  else
9009  Type = Context.getLValueReferenceType(Type);
9010  break;
9011  case 'V': {
9012  char *End;
9013  unsigned NumElements = strtoul(Str, &End, 10);
9014  assert(End != Str && "Missing vector size");
9015  Str = End;
9016 
9017  QualType ElementType = DecodeTypeFromStr(Str, Context, Error,
9018  RequiresICE, false);
9019  assert(!RequiresICE && "Can't require vector ICE");
9020 
9021  // TODO: No way to make AltiVec vectors in builtins yet.
9022  Type = Context.getVectorType(ElementType, NumElements,
9024  break;
9025  }
9026  case 'E': {
9027  char *End;
9028 
9029  unsigned NumElements = strtoul(Str, &End, 10);
9030  assert(End != Str && "Missing vector size");
9031 
9032  Str = End;
9033 
9034  QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
9035  false);
9036  Type = Context.getExtVectorType(ElementType, NumElements);
9037  break;
9038  }
9039  case 'X': {
9040  QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
9041  false);
9042  assert(!RequiresICE && "Can't require complex ICE");
9043  Type = Context.getComplexType(ElementType);
9044  break;
9045  }
9046  case 'Y':
9047  Type = Context.getPointerDiffType();
9048  break;
9049  case 'P':
9050  Type = Context.getFILEType();
9051  if (Type.isNull()) {
9053  return QualType();
9054  }
9055  break;
9056  case 'J':
9057  if (Signed)
9058  Type = Context.getsigjmp_bufType();
9059  else
9060  Type = Context.getjmp_bufType();
9061 
9062  if (Type.isNull()) {
9064  return QualType();
9065  }
9066  break;
9067  case 'K':
9068  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!");
9069  Type = Context.getucontext_tType();
9070 
9071  if (Type.isNull()) {
9073  return QualType();
9074  }
9075  break;
9076  case 'p':
9077  Type = Context.getProcessIDType();
9078  break;
9079  }
9080 
9081  // If there are modifiers and if we're allowed to parse them, go for it.
9082  Done = !AllowTypeModifiers;
9083  while (!Done) {
9084  switch (char c = *Str++) {
9085  default: Done = true; --Str; break;
9086  case '*':
9087  case '&': {
9088  // Both pointers and references can have their pointee types
9089  // qualified with an address space.
9090  char *End;
9091  unsigned AddrSpace = strtoul(Str, &End, 10);
9092  if (End != Str && AddrSpace != 0) {
9093  Type = Context.getAddrSpaceQualType(Type,
9094  getLangASFromTargetAS(AddrSpace));
9095  Str = End;
9096  }
9097  if (c == '*')
9098  Type = Context.getPointerType(Type);
9099  else
9100  Type = Context.getLValueReferenceType(Type);
9101  break;
9102  }
9103  // FIXME: There's no way to have a built-in with an rvalue ref arg.
9104  case 'C':
9105  Type = Type.withConst();
9106  break;
9107  case 'D':
9108  Type = Context.getVolatileType(Type);
9109  break;
9110  case 'R':
9111  Type = Type.withRestrict();
9112  break;
9113  }
9114  }
9115 
9116  assert((!RequiresICE || Type->isIntegralOrEnumerationType()) &&
9117  "Integer constant 'I' type must be an integer");
9118 
9119  return Type;
9120 }
9121 
9122 /// GetBuiltinType - Return the type for the specified builtin.
9125  unsigned *IntegerConstantArgs) const {
9126  const char *TypeStr = BuiltinInfo.getTypeString(Id);
9127 
9128  SmallVector<QualType, 8> ArgTypes;
9129 
9130  bool RequiresICE = false;
9131  Error = GE_None;
9132  QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error,
9133  RequiresICE, true);
9134  if (Error != GE_None)
9135  return QualType();
9136 
9137  assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE");
9138 
9139  while (TypeStr[0] && TypeStr[0] != '.') {
9140  QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true);
9141  if (Error != GE_None)
9142  return QualType();
9143 
9144  // If this argument is required to be an IntegerConstantExpression and the
9145  // caller cares, fill in the bitmask we return.
9146  if (RequiresICE && IntegerConstantArgs)
9147  *IntegerConstantArgs |= 1 << ArgTypes.size();
9148 
9149  // Do array -> pointer decay. The builtin should use the decayed type.
9150  if (Ty->isArrayType())
9151  Ty = getArrayDecayedType(Ty);
9152 
9153  ArgTypes.push_back(Ty);
9154  }
9155 
9156  if (Id == Builtin::BI__GetExceptionInfo)
9157  return QualType();
9158 
9159  assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&
9160  "'.' should only occur at end of builtin type list!");
9161 
9163  if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true);
9164 
9165  bool Variadic = (TypeStr[0] == '.');
9166 
9167  // We really shouldn't be making a no-proto type here.
9168  if (ArgTypes.empty() && Variadic && !getLangOpts().CPlusPlus)
9169  return getFunctionNoProtoType(ResType, EI);
9170 
9172  EPI.ExtInfo = EI;
9173  EPI.Variadic = Variadic;
9174  if (getLangOpts().CPlusPlus && BuiltinInfo.isNoThrow(Id))
9175  EPI.ExceptionSpec.Type =
9176  getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
9177 
9178  return getFunctionType(ResType, ArgTypes, EPI);
9179 }
9180 
9182  const FunctionDecl *FD) {
9183  if (!FD->isExternallyVisible())
9184  return GVA_Internal;
9185 
9186  // Non-user-provided functions get emitted as weak definitions with every
9187  // use, no matter whether they've been explicitly instantiated etc.
9188  if (auto *MD = dyn_cast<CXXMethodDecl>(FD))
9189  if (!MD->isUserProvided())
9190  return GVA_DiscardableODR;
9191 
9192  GVALinkage External;
9193  switch (FD->getTemplateSpecializationKind()) {
9194  case TSK_Undeclared:
9196  External = GVA_StrongExternal;
9197  break;
9198 
9200  return GVA_StrongODR;
9201 
9202  // C++11 [temp.explicit]p10:
9203  // [ Note: The intent is that an inline function that is the subject of
9204  // an explicit instantiation declaration will still be implicitly
9205  // instantiated when used so that the body can be considered for
9206  // inlining, but that no out-of-line copy of the inline function would be
9207  // generated in the translation unit. -- end note ]
9209  return GVA_AvailableExternally;
9210 
9212  External = GVA_DiscardableODR;
9213  break;
9214  }
9215 
9216  if (!FD->isInlined())
9217  return External;
9218 
9219  if ((!Context.getLangOpts().CPlusPlus &&
9220  !Context.getTargetInfo().getCXXABI().isMicrosoft() &&
9221  !FD->hasAttr<DLLExportAttr>()) ||
9222  FD->hasAttr<GNUInlineAttr>()) {
9223  // FIXME: This doesn't match gcc's behavior for dllexport inline functions.
9224 
9225  // GNU or C99 inline semantics. Determine whether this symbol should be
9226  // externally visible.
9228  return External;
9229 
9230  // C99 inline semantics, where the symbol is not externally visible.
9231  return GVA_AvailableExternally;
9232  }
9233 
9234  // Functions specified with extern and inline in -fms-compatibility mode
9235  // forcibly get emitted. While the body of the function cannot be later
9236  // replaced, the function definition cannot be discarded.
9237  if (FD->isMSExternInline())
9238  return GVA_StrongODR;
9239 
9240  return GVA_DiscardableODR;
9241 }
9242 
9244  const Decl *D, GVALinkage L) {
9245  // See http://msdn.microsoft.com/en-us/library/xa0d9ste.aspx
9246  // dllexport/dllimport on inline functions.
9247  if (D->hasAttr<DLLImportAttr>()) {
9248  if (L == GVA_DiscardableODR || L == GVA_StrongODR)
9249  return GVA_AvailableExternally;
9250  } else if (D->hasAttr<DLLExportAttr>()) {
9251  if (L == GVA_DiscardableODR)
9252  return GVA_StrongODR;
9253  } else if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice &&
9254  D->hasAttr<CUDAGlobalAttr>()) {
9255  // Device-side functions with __global__ attribute must always be
9256  // visible externally so they can be launched from host.
9257  if (L == GVA_DiscardableODR || L == GVA_Internal)
9258  return GVA_StrongODR;
9259  }
9260  return L;
9261 }
9262 
9263 /// Adjust the GVALinkage for a declaration based on what an external AST source
9264 /// knows about whether there can be other definitions of this declaration.
9265 static GVALinkage
9267  GVALinkage L) {
9268  ExternalASTSource *Source = Ctx.getExternalSource();
9269  if (!Source)
9270  return L;
9271 
9272  switch (Source->hasExternalDefinitions(D)) {
9274  // Other translation units rely on us to provide the definition.
9275  if (L == GVA_DiscardableODR)
9276  return GVA_StrongODR;
9277  break;
9278 
9280  return GVA_AvailableExternally;
9281 
9283  break;
9284  }
9285  return L;
9286 }
9287 
9291  basicGVALinkageForFunction(*this, FD)));
9292 }
9293 
9295  const VarDecl *VD) {
9296  if (!VD->isExternallyVisible())
9297  return GVA_Internal;
9298 
9299  if (VD->isStaticLocal()) {
9300  const DeclContext *LexicalContext = VD->getParentFunctionOrMethod();
9301  while (LexicalContext && !isa<FunctionDecl>(LexicalContext))
9302  LexicalContext = LexicalContext->getLexicalParent();
9303 
9304  // ObjC Blocks can create local variables that don't have a FunctionDecl
9305  // LexicalContext.
9306  if (!LexicalContext)
9307  return GVA_DiscardableODR;
9308 
9309  // Otherwise, let the static local variable inherit its linkage from the
9310  // nearest enclosing function.
9311  auto StaticLocalLinkage =
9312  Context.GetGVALinkageForFunction(cast<FunctionDecl>(LexicalContext));
9313 
9314  // Itanium ABI 5.2.2: "Each COMDAT group [for a static local variable] must
9315  // be emitted in any object with references to the symbol for the object it
9316  // contains, whether inline or out-of-line."
9317  // Similar behavior is observed with MSVC. An alternative ABI could use
9318  // StrongODR/AvailableExternally to match the function, but none are
9319  // known/supported currently.
9320  if (StaticLocalLinkage == GVA_StrongODR ||
9321  StaticLocalLinkage == GVA_AvailableExternally)
9322  return GVA_DiscardableODR;
9323  return StaticLocalLinkage;
9324  }
9325 
9326  // MSVC treats in-class initialized static data members as definitions.
9327  // By giving them non-strong linkage, out-of-line definitions won't
9328  // cause link errors.
9329  if (Context.isMSStaticDataMemberInlineDefinition(VD))
9330  return GVA_DiscardableODR;
9331 
9332  // Most non-template variables have strong linkage; inline variables are
9333  // linkonce_odr or (occasionally, for compatibility) weak_odr.
9334  GVALinkage StrongLinkage;
9335  switch (Context.getInlineVariableDefinitionKind(VD)) {
9337  StrongLinkage = GVA_StrongExternal;
9338  break;
9341  StrongLinkage = GVA_DiscardableODR;
9342  break;
9344  StrongLinkage = GVA_StrongODR;
9345  break;
9346  }
9347 
9348  switch (VD->getTemplateSpecializationKind()) {
9349  case TSK_Undeclared:
9350  return StrongLinkage;
9351 
9353  return Context.getTargetInfo().getCXXABI().isMicrosoft() &&
9354  VD->isStaticDataMember()
9355  ? GVA_StrongODR
9356  : StrongLinkage;
9357 
9359  return GVA_StrongODR;
9360 
9362  return GVA_AvailableExternally;
9363 
9365  return GVA_DiscardableODR;
9366  }
9367 
9368  llvm_unreachable("Invalid Linkage!");
9369 }
9370 
9374  basicGVALinkageForVariable(*this, VD)));
9375 }
9376 
9377 bool ASTContext::DeclMustBeEmitted(const Decl *D) {
9378  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
9379  if (!VD->isFileVarDecl())
9380  return false;
9381  // Global named register variables (GNU extension) are never emitted.
9382  if (VD->getStorageClass() == SC_Register)
9383  return false;
9384  if (VD->getDescribedVarTemplate() ||
9385  isa<VarTemplatePartialSpecializationDecl>(VD))
9386  return false;
9387  } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
9388  // We never need to emit an uninstantiated function template.
9389  if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
9390  return false;
9391  } else if (isa<PragmaCommentDecl>(D))
9392  return true;
9393  else if (isa<OMPThreadPrivateDecl>(D) ||
9394  D->hasAttr<OMPDeclareTargetDeclAttr>())
9395  return true;
9396  else if (isa<PragmaDetectMismatchDecl>(D))
9397  return true;
9398  else if (isa<OMPThreadPrivateDecl>(D))
9399  return !D->getDeclContext()->isDependentContext();
9400  else if (isa<OMPDeclareReductionDecl>(D))
9401  return !D->getDeclContext()->isDependentContext();
9402  else if (isa<ImportDecl>(D))
9403  return true;
9404  else
9405  return false;
9406 
9407  // If this is a member of a class template, we do not need to emit it.
9408  if (D->getDeclContext()->isDependentContext())
9409  return false;
9410 
9411  // Weak references don't produce any output by themselves.
9412  if (D->hasAttr<WeakRefAttr>())
9413  return false;
9414 
9415  // Aliases and used decls are required.
9416  if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>())
9417  return true;
9418 
9419  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
9420  // Forward declarations aren't required.
9421  if (!FD->doesThisDeclarationHaveABody())
9422  return FD->doesDeclarationForceExternallyVisibleDefinition();
9423 
9424  // Constructors and destructors are required.
9425  if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>())
9426  return true;
9427 
9428  // The key function for a class is required. This rule only comes
9429  // into play when inline functions can be key functions, though.
9430  if (getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
9431  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
9432  const CXXRecordDecl *RD = MD->getParent();
9433  if (MD->isOutOfLine() && RD->isDynamicClass()) {
9434  const CXXMethodDecl *KeyFunc = getCurrentKeyFunction(RD);
9435  if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl())
9436  return true;
9437  }
9438  }
9439  }
9440 
9442 
9443  // static, static inline, always_inline, and extern inline functions can
9444  // always be deferred. Normal inline functions can be deferred in C99/C++.
9445  // Implicit template instantiations can also be deferred in C++.
9446  return !isDiscardableGVALinkage(Linkage);
9447  }
9448 
9449  const VarDecl *VD = cast<VarDecl>(D);
9450  assert(VD->isFileVarDecl() && "Expected file scoped var");
9451 
9454  return false;
9455 
9456  // Variables that can be needed in other TUs are required.
9457  auto Linkage = GetGVALinkageForVariable(VD);
9459  return true;
9460 
9461  // We never need to emit a variable that is available in another TU.
9463  return false;
9464 
9465  // Variables that have destruction with side-effects are required.
9466  if (VD->getType().isDestructedType())
9467  return true;
9468 
9469  // Variables that have initialization with side-effects are required.
9470  if (VD->getInit() && VD->getInit()->HasSideEffects(*this) &&
9471  // We can get a value-dependent initializer during error recovery.
9472  (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
9473  return true;
9474 
9475  // Likewise, variables with tuple-like bindings are required if their
9476  // bindings have side-effects.
9477  if (auto *DD = dyn_cast<DecompositionDecl>(VD))
9478  for (auto *BD : DD->bindings())
9479  if (auto *BindingVD = BD->getHoldingVar())
9480  if (DeclMustBeEmitted(BindingVD))
9481  return true;
9482 
9483  return false;
9484 }
9485 
9487  bool IsCXXMethod) const {
9488  // Pass through to the C++ ABI object
9489  if (IsCXXMethod)
9490  return ABI->getDefaultMethodCallConv(IsVariadic);
9491 
9492  switch (LangOpts.getDefaultCallingConv()) {
9493  case LangOptions::DCC_None:
9494  break;
9496  return CC_C;
9498  if (getTargetInfo().hasFeature("sse2") && !IsVariadic)
9499  return CC_X86FastCall;
9500  break;
9502  if (!IsVariadic)
9503  return CC_X86StdCall;
9504  break;
9506  // __vectorcall cannot be applied to variadic functions.
9507  if (!IsVariadic)
9508  return CC_X86VectorCall;
9509  break;
9511  // __regcall cannot be applied to variadic functions.
9512  if (!IsVariadic)
9513  return CC_X86RegCall;
9514  break;
9515  }
9517 }
9518 
9520  // Pass through to the C++ ABI object
9521  return ABI->isNearlyEmpty(RD);
9522 }
9523 
9525  if (!VTContext.get()) {
9526  if (Target->getCXXABI().isMicrosoft())
9527  VTContext.reset(new MicrosoftVTableContext(*this));
9528  else
9529  VTContext.reset(new ItaniumVTableContext(*this));
9530  }
9531  return VTContext.get();
9532 }
9533 
9535  switch (Target->getCXXABI().getKind()) {
9540  case TargetCXXABI::iOS:
9541  case TargetCXXABI::iOS64:
9543  case TargetCXXABI::WatchOS:
9547  }
9548  llvm_unreachable("Unsupported ABI");
9549 }
9550 
9551 CXXABI::~CXXABI() = default;
9552 
9554  return ASTRecordLayouts.getMemorySize() +
9555  llvm::capacity_in_bytes(ObjCLayouts) +
9556  llvm::capacity_in_bytes(KeyFunctions) +
9557  llvm::capacity_in_bytes(ObjCImpls) +
9558  llvm::capacity_in_bytes(BlockVarCopyInits) +
9559  llvm::capacity_in_bytes(DeclAttrs) +
9560  llvm::capacity_in_bytes(TemplateOrInstantiation) +
9561  llvm::capacity_in_bytes(InstantiatedFromUsingDecl) +
9562  llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) +
9563  llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) +
9564  llvm::capacity_in_bytes(OverriddenMethods) +
9565  llvm::capacity_in_bytes(Types) +
9566  llvm::capacity_in_bytes(VariableArrayTypes) +
9567  llvm::capacity_in_bytes(ClassScopeSpecializationPattern);
9568 }
9569 
9570 /// getIntTypeForBitwidth -
9571 /// sets integer QualTy according to specified details:
9572 /// bitwidth, signed/unsigned.
9573 /// Returns empty type if there is no appropriate target types.
9575  unsigned Signed) const {
9576  TargetInfo::IntType Ty = getTargetInfo().getIntTypeByWidth(DestWidth, Signed);
9577  CanQualType QualTy = getFromTargetType(Ty);
9578  if (!QualTy && DestWidth == 128)
9579  return Signed ? Int128Ty : UnsignedInt128Ty;
9580  return QualTy;
9581 }
9582 
9583 /// getRealTypeForBitwidth -
9584 /// sets floating point QualTy according to specified bitwidth.
9585 /// Returns empty type if there is no appropriate target types.
9588  switch (Ty) {
9589  case TargetInfo::Float:
9590  return FloatTy;
9591  case TargetInfo::Double:
9592  return DoubleTy;
9594  return LongDoubleTy;
9595  case TargetInfo::Float128:
9596  return Float128Ty;
9597  case TargetInfo::NoFloat:
9598  return QualType();
9599  }
9600 
9601  llvm_unreachable("Unhandled TargetInfo::RealType value");
9602 }
9603 
9604 void ASTContext::setManglingNumber(const NamedDecl *ND, unsigned Number) {
9605  if (Number > 1)
9606  MangleNumbers[ND] = Number;
9607 }
9608 
9609 unsigned ASTContext::getManglingNumber(const NamedDecl *ND) const {
9610  auto I = MangleNumbers.find(ND);
9611  return I != MangleNumbers.end() ? I->second : 1;
9612 }
9613 
9614 void ASTContext::setStaticLocalNumber(const VarDecl *VD, unsigned Number) {
9615  if (Number > 1)
9616  StaticLocalNumbers[VD] = Number;
9617 }
9618 
9619 unsigned ASTContext::getStaticLocalNumber(const VarDecl *VD) const {
9620  auto I = StaticLocalNumbers.find(VD);
9621  return I != StaticLocalNumbers.end() ? I->second : 1;
9622 }
9623 
9626  assert(LangOpts.CPlusPlus); // We don't need mangling numbers for plain C.
9627  std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
9628  if (!MCtx)
9630  return *MCtx;
9631 }
9632 
9633 std::unique_ptr<MangleNumberingContext>
9635  return ABI->createMangleNumberingContext();
9636 }
9637 
9638 const CXXConstructorDecl *
9640  return ABI->getCopyConstructorForExceptionObject(
9641  cast<CXXRecordDecl>(RD->getFirstDecl()));
9642 }
9643 
9645  CXXConstructorDecl *CD) {
9646  return ABI->addCopyConstructorForExceptionObject(
9647  cast<CXXRecordDecl>(RD->getFirstDecl()),
9648  cast<CXXConstructorDecl>(CD->getFirstDecl()));
9649 }
9650 
9652  TypedefNameDecl *DD) {
9653  return ABI->addTypedefNameForUnnamedTagDecl(TD, DD);
9654 }
9655 
9658  return ABI->getTypedefNameForUnnamedTagDecl(TD);
9659 }
9660 
9662  DeclaratorDecl *DD) {
9663  return ABI->addDeclaratorForUnnamedTagDecl(TD, DD);
9664 }
9665 
9667  return ABI->getDeclaratorForUnnamedTagDecl(TD);
9668 }
9669 
9670 void ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) {
9671  ParamIndices[D] = index;
9672 }
9673 
9674 unsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const {
9675  ParameterIndexTable::const_iterator I = ParamIndices.find(D);
9676  assert(I != ParamIndices.end() &&
9677  "ParmIndices lacks entry set by ParmVarDecl");
9678  return I->second;
9679 }
9680 
9681 APValue *
9683  bool MayCreate) {
9684  assert(E && E->getStorageDuration() == SD_Static &&
9685  "don't need to cache the computed value for this temporary");
9686  if (MayCreate) {
9687  APValue *&MTVI = MaterializedTemporaryValues[E];
9688  if (!MTVI)
9689  MTVI = new (*this) APValue;
9690  return MTVI;
9691  }
9692 
9693  return MaterializedTemporaryValues.lookup(E);
9694 }
9695 
9697  const llvm::Triple &T = getTargetInfo().getTriple();
9698  if (!T.isOSDarwin())
9699  return false;
9700 
9701  if (!(T.isiOS() && T.isOSVersionLT(7)) &&
9702  !(T.isMacOSX() && T.isOSVersionLT(10, 9)))
9703  return false;
9704 
9705  QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
9706  CharUnits sizeChars = getTypeSizeInChars(AtomicTy);
9707  uint64_t Size = sizeChars.getQuantity();
9708  CharUnits alignChars = getTypeAlignInChars(AtomicTy);
9709  unsigned Align = alignChars.getQuantity();
9710  unsigned MaxInlineWidthInBits = getTargetInfo().getMaxAtomicInlineWidth();
9711  return (Size != Align || toBits(sizeChars) > MaxInlineWidthInBits);
9712 }
9713 
9715  ASTContext::ParentMapPointers::mapped_type U) {
9716  if (const auto *D = U.dyn_cast<const Decl *>())
9718  if (const auto *S = U.dyn_cast<const Stmt *>())
9720  return *U.get<ast_type_traits::DynTypedNode *>();
9721 }
9722 
9723 namespace {
9724 
9725 /// Template specializations to abstract away from pointers and TypeLocs.
9726 /// @{
9727 template <typename T>
9728 ast_type_traits::DynTypedNode createDynTypedNode(const T &Node) {
9730 }
9731 template <>
9732 ast_type_traits::DynTypedNode createDynTypedNode(const TypeLoc &Node) {
9734 }
9735 template <>
9737 createDynTypedNode(const NestedNameSpecifierLoc &Node) {
9739 }
9740 /// @}
9741 
9742  /// \brief A \c RecursiveASTVisitor that builds a map from nodes to their
9743  /// parents as defined by the \c RecursiveASTVisitor.
9744  ///
9745  /// Note that the relationship described here is purely in terms of AST
9746  /// traversal - there are other relationships (for example declaration context)
9747  /// in the AST that are better modeled by special matchers.
9748  ///
9749  /// FIXME: Currently only builds up the map using \c Stmt and \c Decl nodes.
9750  class ParentMapASTVisitor : public RecursiveASTVisitor<ParentMapASTVisitor> {
9751  public:
9752  /// \brief Builds and returns the translation unit's parent map.
9753  ///
9754  /// The caller takes ownership of the returned \c ParentMap.
9755  static std::pair<ASTContext::ParentMapPointers *,
9757  buildMap(TranslationUnitDecl &TU) {
9758  ParentMapASTVisitor Visitor(new ASTContext::ParentMapPointers,
9760  Visitor.TraverseDecl(&TU);
9761  return std::make_pair(Visitor.Parents, Visitor.OtherParents);
9762  }
9763 
9764  private:
9765  friend class RecursiveASTVisitor<ParentMapASTVisitor>;
9766 
9767  using VisitorBase = RecursiveASTVisitor<ParentMapASTVisitor>;
9768 
9769  ParentMapASTVisitor(ASTContext::ParentMapPointers *Parents,
9770  ASTContext::ParentMapOtherNodes *OtherParents)
9771  : Parents(Parents), OtherParents(OtherParents) {}
9772 
9773  bool shouldVisitTemplateInstantiations() const {
9774  return true;
9775  }
9776 
9777  bool shouldVisitImplicitCode() const {
9778  return true;
9779  }
9780 
9781  template <typename T, typename MapNodeTy, typename BaseTraverseFn,
9782  typename MapTy>
9783  bool TraverseNode(T Node, MapNodeTy MapNode,
9784  BaseTraverseFn BaseTraverse, MapTy *Parents) {
9785  if (!Node)
9786  return true;
9787  if (ParentStack.size() > 0) {
9788  // FIXME: Currently we add the same parent multiple times, but only
9789  // when no memoization data is available for the type.
9790  // For example when we visit all subexpressions of template
9791  // instantiations; this is suboptimal, but benign: the only way to
9792  // visit those is with hasAncestor / hasParent, and those do not create
9793  // new matches.
9794  // The plan is to enable DynTypedNode to be storable in a map or hash
9795  // map. The main problem there is to implement hash functions /
9796  // comparison operators for all types that DynTypedNode supports that
9797  // do not have pointer identity.
9798  auto &NodeOrVector = (*Parents)[MapNode];
9799  if (NodeOrVector.isNull()) {
9800  if (const auto *D = ParentStack.back().get<Decl>())
9801  NodeOrVector = D;
9802  else if (const auto *S = ParentStack.back().get<Stmt>())
9803  NodeOrVector = S;
9804  else
9805  NodeOrVector =
9806  new ast_type_traits::DynTypedNode(ParentStack.back());
9807  } else {
9808  if (!NodeOrVector.template is<ASTContext::ParentVector *>()) {
9809  auto *Vector = new ASTContext::ParentVector(
9810  1, getSingleDynTypedNodeFromParentMap(NodeOrVector));
9811  delete NodeOrVector
9812  .template dyn_cast<ast_type_traits::DynTypedNode *>();
9813  NodeOrVector = Vector;
9814  }
9815 
9816  auto *Vector =
9817  NodeOrVector.template get<ASTContext::ParentVector *>();
9818  // Skip duplicates for types that have memoization data.
9819  // We must check that the type has memoization data before calling
9820  // std::find() because DynTypedNode::operator== can't compare all
9821  // types.
9822  bool Found = ParentStack.back().getMemoizationData() &&
9823  std::find(Vector->begin(), Vector->end(),
9824  ParentStack.back()) != Vector->end();
9825  if (!Found)
9826  Vector->push_back(ParentStack.back());
9827  }
9828  }
9829  ParentStack.push_back(createDynTypedNode(Node));
9830  bool Result = BaseTraverse();
9831  ParentStack.pop_back();
9832  return Result;
9833  }
9834 
9835  bool TraverseDecl(Decl *DeclNode) {
9836  return TraverseNode(DeclNode, DeclNode,
9837  [&] { return VisitorBase::TraverseDecl(DeclNode); },
9838  Parents);
9839  }
9840 
9841  bool TraverseStmt(Stmt *StmtNode) {
9842  return TraverseNode(StmtNode, StmtNode,
9843  [&] { return VisitorBase::TraverseStmt(StmtNode); },
9844  Parents);
9845  }
9846 
9847  bool TraverseTypeLoc(TypeLoc TypeLocNode) {
9848  return TraverseNode(
9849  TypeLocNode, ast_type_traits::DynTypedNode::create(TypeLocNode),
9850  [&] { return VisitorBase::TraverseTypeLoc(TypeLocNode); },
9851  OtherParents);
9852  }
9853 
9854  bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLocNode) {
9855  return TraverseNode(
9856  NNSLocNode, ast_type_traits::DynTypedNode::create(NNSLocNode),
9857  [&] {
9858  return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode);
9859  },
9860  OtherParents);
9861  }
9862 
9863  ASTContext::ParentMapPointers *Parents;
9864  ASTContext::ParentMapOtherNodes *OtherParents;
9866  };
9867 
9868 } // namespace
9869 
9870 template <typename NodeTy, typename MapTy>
9872  const MapTy &Map) {
9873  auto I = Map.find(Node);
9874  if (I == Map.end()) {
9876  }
9877  if (auto *V = I->second.template dyn_cast<ASTContext::ParentVector *>()) {
9878  return llvm::makeArrayRef(*V);
9879  }
9880  return getSingleDynTypedNodeFromParentMap(I->second);
9881 }
9882 
9885  if (!PointerParents) {
9886  // We always need to run over the whole translation unit, as
9887  // hasAncestor can escape any subtree.
9888  auto Maps = ParentMapASTVisitor::buildMap(*getTranslationUnitDecl());
9889  PointerParents.reset(Maps.first);
9890  OtherParents.reset(Maps.second);
9891  }
9892  if (Node.getNodeKind().hasPointerIdentity())
9893  return getDynNodeFromMap(Node.getMemoizationData(), *PointerParents);
9894  return getDynNodeFromMap(Node, *OtherParents);
9895 }
9896 
9897 bool
9899  const ObjCMethodDecl *MethodImpl) {
9900  // No point trying to match an unavailable/deprecated mothod.
9901  if (MethodDecl->hasAttr<UnavailableAttr>()
9902  || MethodDecl->hasAttr<DeprecatedAttr>())
9903  return false;
9904  if (MethodDecl->getObjCDeclQualifier() !=
9905  MethodImpl->getObjCDeclQualifier())
9906  return false;
9907  if (!hasSameType(MethodDecl->getReturnType(), MethodImpl->getReturnType()))
9908  return false;
9909 
9910  if (MethodDecl->param_size() != MethodImpl->param_size())
9911  return false;
9912 
9913  for (ObjCMethodDecl::param_const_iterator IM = MethodImpl->param_begin(),
9914  IF = MethodDecl->param_begin(), EM = MethodImpl->param_end(),
9915  EF = MethodDecl->param_end();
9916  IM != EM && IF != EF; ++IM, ++IF) {
9917  const ParmVarDecl *DeclVar = (*IF);
9918  const ParmVarDecl *ImplVar = (*IM);
9919  if (ImplVar->getObjCDeclQualifier() != DeclVar->getObjCDeclQualifier())
9920  return false;
9921  if (!hasSameType(DeclVar->getType(), ImplVar->getType()))
9922  return false;
9923  }
9924 
9925  return (MethodDecl->isVariadic() == MethodImpl->isVariadic());
9926 }
9927 
9929  LangAS AS;
9931  AS = LangAS::Default;
9932  else
9933  AS = QT->getPointeeType().getAddressSpace();
9934 
9935  return getTargetInfo().getNullPointerValue(AS);
9936 }
9937 
9939  if (isTargetAddressSpace(AS))
9940  return toTargetAddressSpace(AS);
9941  else
9942  return (*AddrSpaceMap)[(unsigned)AS];
9943 }
9944 
9945 // Explicitly instantiate this in case a Redeclarable<T> is used from a TU that
9946 // doesn't include ASTContext.h
9947 template
9949  const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::ValueType
9951  const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::makeValue(
9952  const clang::ASTContext &Ctx, Decl *Value);
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=TTK_Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
static CanQual< Type > CreateUnsafe(QualType Other)
Builds a canonical type from a QualType.
static TypedefDecl * CreateAArch64ABIBuiltinVaListDecl(const ASTContext *Context)
Internal representation of canonical, dependent typeof(expr) types.
Definition: Type.h:3808
QualType getDecltypeType(Expr *e, QualType UnderlyingType) const
C++11 decltype.
MemberSpecializationInfo * getInstantiatedFromStaticDataMember(const VarDecl *Var)
If this variable is an instantiated static data member of a class template specialization, returns the templated static data member from which it was instantiated.
void setExternalSource(IntrusiveRefCntPtr< ExternalASTSource > Source)
Attach an external AST source to the AST context.
Definition: ASTContext.cpp:861
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl)
Definition: DeclCXX.cpp:2307
static bool canAssignObjCObjectTypes(ASTContext &ctx, QualType lhs, QualType rhs)
Determine whether the first type is a subtype of the second.
TypedefDecl * getObjCInstanceTypeDecl()
Retrieve the typedef declaration corresponding to the Objective-C "instancetype" type.
TemplateTemplateParmDecl * getParameterPack() const
Retrieve the template template parameter pack being substituted.
Definition: TemplateName.h:135
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1507
static void EncodeBitField(const ASTContext *Ctx, std::string &S, QualType T, const FieldDecl *FD)
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Defines the clang::ASTContext interface.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
void setTemplateOrSpecializationInfo(VarDecl *Inst, TemplateOrSpecializationInfo TSI)
const BlockDecl * getBlockDecl() const
Definition: Expr.h:4865
bool hasDefinition() const
Determine whether this class has been defined.
Definition: DeclObjC.h:1554
QualType getDeducedType() const
Get the type deduced for this placeholder type, or null if it&#39;s either not been deduced or was deduce...
Definition: Type.h:4387
The generic AArch64 ABI is also a modified version of the Itanium ABI, but it has fewer divergences t...
Definition: TargetCXXABI.h:84
static ast_type_traits::DynTypedNode getSingleDynTypedNodeFromParentMap(ASTContext::ParentMapPointers::mapped_type U)
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:4784
ASTMutationListener * Listener
Definition: ASTContext.h:542
IntType getInt64Type() const
Definition: TargetInfo.h:262
unsigned getHalfWidth() const
getHalfWidth/Align/Format - Return the size/align/format of &#39;half&#39;.
Definition: TargetInfo.h:404
QualType withConst() const
Retrieves a version of this type with const applied.
const Type * Ty
The locally-unqualified type.
Definition: Type.h:594
static bool isTypeTypedefedAsBOOL(QualType T)
static unsigned getFullDataSizeForType(QualType Ty)
Returns the size of type source info data block for the given type.
Definition: TypeLoc.cpp:92
QualType getObjCObjectType(QualType Base, ObjCProtocolDecl *const *Protocols, unsigned NumProtocols) const
Legacy interface: cannot provide type arguments or __kindof.
QualType getVariableArrayDecayedType(QualType Ty) const
Returns a vla type where known sizes are replaced with [*].
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition: Type.h:4587
CanQualType LongLongTy
Definition: ASTContext.h:1004
static const Decl * getCanonicalDecl(const Decl *D)
void setImplicit(bool I=true)
Definition: DeclBase.h:552
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Note that the static data member Inst is an instantiation of the static data member template Tmpl of ...
AttrVec & getDeclAttrs(const Decl *D)
Retrieve the attributes for the given declaration.
unsigned getFloatWidth() const
getFloatWidth/Align/Format - Return the size/align/format of &#39;float&#39;.
Definition: TargetInfo.h:409
CanQualType WIntTy
Definition: ASTContext.h:1001
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
Definition: Type.h:5301
CXXABI * CreateMicrosoftCXXABI(ASTContext &Ctx)
const Decl * CommentDecl
Declaration the comment is actually attached to (in the source).
Definition: Comment.h:989
bool isObjCQualifiedIdType() const
True if this is equivalent to &#39;id.
Definition: Type.h:5519
SplitQualType split() const
no exception specification
CanQualType OCLQueueTy
Definition: ASTContext.h:1022
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1800
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
Holds information about both target-independent and target-specific builtins, allowing easy queries b...
Definition: Builtins.h:68
TypedefDecl * getCFConstantStringDecl() const
unsigned getRawEncoding() const
When a SourceLocation itself cannot be used, this returns an (opaque) 32-bit integer encoding for it...
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2283
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
Definition: Type.h:5295
CanQualType LongDoubleComplexTy
Definition: ASTContext.h:1010
void * getAsVoidPointer() const
Retrieve the template name as a void pointer.
Definition: TemplateName.h:310
QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false)
QualType getPointeeType() const
Definition: Type.h:2296
CanQualType VoidPtrTy
Definition: ASTContext.h:1012
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:3727
A (possibly-)qualified type.
Definition: Type.h:653
The iOS 64-bit ABI is follows ARM&#39;s published 64-bit ABI more closely, but we don&#39;t guarantee to foll...
Definition: TargetCXXABI.h:71
int getIntegerTypeOrder(QualType LHS, QualType RHS) const
Return the highest ranked integer type, see C99 6.3.1.8p1.
bool isBlockPointerType() const
Definition: Type.h:5950
Static storage duration.
Definition: Specifiers.h:277
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
OverloadedOperatorKind getOperator() const
Return the overloaded operator to which this template name refers.
Definition: TemplateName.h:494
base_class_range bases()
Definition: DeclCXX.h:773
bool isArrayType() const
Definition: Type.h:5991
bool isNull() const
Definition: CanonicalType.h:98
bool isMemberPointerType() const
Definition: Type.h:5973
unsigned param_size() const
Definition: DeclObjC.h:379
ASTContext(LangOptions &LOpts, SourceManager &SM, IdentifierTable &idents, SelectorTable &sels, Builtin::Context &builtins)
Definition: ASTContext.cpp:783
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
Definition: ASTContext.h:1855
unsigned getBoolWidth() const
Return the size of &#39;_Bool&#39; and C++ &#39;bool&#39; for this target, in bits.
Definition: TargetInfo.h:328
unsigned getLongWidth() const
getLongWidth/Align - Return the size of &#39;signed long&#39; and &#39;unsigned long&#39; for this target...
Definition: TargetInfo.h:351
static unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built...
Definition: ASTContext.h:2712
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2846
static MicrosoftMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags)
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: Type.h:1286
CanQualType Char32Ty
Definition: ASTContext.h:1003
QualType getPointerDiffType() const
Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.
static unsigned NumImplicitDefaultConstructors
The number of implicitly-declared default constructors.
Definition: ASTContext.h:2680
unsigned getMaxVectorAlign() const
Return the maximum vector alignment supported for the given target.
Definition: TargetInfo.h:466
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
AutoTypeKeyword
Which keyword(s) were used to create an AutoType.
Definition: Type.h:1314
Stmt - This represents one statement.
Definition: Stmt.h:66
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1637
virtual void DeducedReturnType(const FunctionDecl *FD, QualType ReturnType)
A function&#39;s return type has been deduced.
std::string getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const
Emit the encoded type for the function Decl into S.
Kind getKind() const
Definition: Type.h:2164
Internal representation of canonical, dependent __underlying_type(type) types.
Definition: Type.h:3936
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3056
unsigned getLargeArrayAlign() const
Definition: TargetInfo.h:444
bool CommentsLoaded
True if comments are already loaded from ExternalASTSource.
Definition: ASTContext.h:708
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:456
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:5035
unsigned getFloat128Align() const
Definition: TargetInfo.h:429
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:790
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type...
Definition: Type.h:3668
__builtin_va_list as defined by the PNaCl ABI: http://www.chromium.org/nativeclient/pnacl/bitcode-abi...
Definition: TargetInfo.h:165
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:223
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1893
unsigned overridden_methods_size(const CXXMethodDecl *Method) const
TypedefDecl - Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier...
Definition: Decl.h:2898
C Language Family Type Representation.
unsigned getLongAlign() const
Definition: TargetInfo.h:352
Defines the SourceManager interface.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2963
CharUnits getAlignOfGlobalVarInChars(QualType T) const
Return the alignment in characters that should be given to a global variable with type T...
Microsoft&#39;s &#39;__super&#39; specifier, stored as a CXXRecordDecl* of the class it appeared in...
static unsigned NumImplicitMoveAssignmentOperators
The number of implicitly-declared move assignment operators.
Definition: ASTContext.h:2708
const AstTypeMatcher< TagType > tagType
Matches tag types (record and enum types).
Represents a qualified type name for which the type name is dependent.
Definition: Type.h:4849
static TypedefDecl * CreateSystemZBuiltinVaListDecl(const ASTContext *Context)
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:87
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3179
bool isRecordType() const
Definition: Type.h:6015
unsigned getTypeAlignIfKnown(QualType T) const
Return the ABI-specified alignment of a type, in bits, or 0 if the type is incomplete and we cannot d...
CanQualType FloatComplexTy
Definition: ASTContext.h:1010
static TemplateTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation L, unsigned D, unsigned P, bool ParameterPack, IdentifierInfo *Id, TemplateParameterList *Params)
const ASTRecordLayout & getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const
Get or compute information about the layout of the specified Objective-C implementation.
RawCommentList Comments
All comments in this translation unit.
Definition: ASTContext.h:705
const T * get() const
Retrieve the stored node as type T.
static int CmpProtocolNames(ObjCProtocolDecl *const *LHS, ObjCProtocolDecl *const *RHS)
CmpProtocolNames - Comparison predicate for sorting protocols alphabetically.
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1880
QualType getEnumType(const EnumDecl *Decl) const
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
const Type * getTypeForDecl() const
Definition: Decl.h:2784
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
static QualType getFunctionTypeWithExceptionSpec(ASTContext &Context, QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI)
Get a function type and produce the equivalent function type with the specified exception specificati...
bool isVariadic() const
Definition: Type.h:3615
TagDecl * getDecl() const
Definition: Type.cpp:3037
EnumDecl * getPreviousDecl()
Definition: Decl.h:3294
CanQualType ObjCBuiltinSelTy
Definition: ASTContext.h:1016
bool isDiscardableGVALinkage(GVALinkage L)
Definition: Linkage.h:83
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
CanQualType getCanonicalFunctionResultType(QualType ResultType) const
Adjust the given function result type.
Defines the C++ template declaration subclasses.
StringRef P
ivar_range ivars() const
Definition: DeclObjC.h:1477
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4401
Kind getKind() const
Definition: TargetCXXABI.h:132
unsigned getFieldIndex() const
getFieldIndex - Returns the index of this field within its record, as appropriate for passing to ASTR...
Definition: Decl.cpp:3661
A class providing a concrete implementation of ObjCObjectType, so as to not increase the footprint of...
Definition: Type.h:5337
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition: Type.cpp:2946
unsigned getDefaultAlignForAttributeAligned() const
Return the default alignment for attribute((aligned)) on this target, to be used if no alignment valu...
Definition: TargetInfo.h:373
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
Definition: DeclObjC.cpp:301
Defines types useful for describing an Objective-C runtime.
CanQualType ARCUnbridgedCastTy
Definition: ASTContext.h:1015
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this field is ...
Definition: Decl.h:2648
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
The base class of the type hierarchy.
Definition: Type.h:1351
void setParameterIndex(const ParmVarDecl *D, unsigned index)
Used by ParmVarDecl to store on the side the index of the parameter when it exceeds the size of the n...
The parameter is covariant, e.g., X<T> is a subtype of X<U> when the type parameter is covariant and ...
QualType getsigjmp_bufType() const
Retrieve the C sigjmp_buf type.
Definition: ASTContext.h:1717
static bool areSortedAndUniqued(ArrayRef< ObjCProtocolDecl *> Protocols)
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CanQualType LongTy
Definition: ASTContext.h:1004
DiagnosticsEngine & getDiagnostics() const
virtual LangAS getOpenCLTypeAddrSpace(OpenCLTypeKind TK) const
Get address space for OpenCL type.
Definition: TargetInfo.cpp:359
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2558
QualType getCorrespondingUnsignedType(QualType T) const
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:64
CharUnits getObjCEncodingTypeSize(QualType T) const
Return the size of type T for Objective-C encoding purpose, in characters.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2241
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:505
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1567
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
Definition: Expr.h:395
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2405
virtual void completeDefinition()
completeDefinition - Notes that the definition of this type is now complete.
Definition: Decl.cpp:3969
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
QualType withConst() const
Definition: Type.h:818
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:671
A container of type source information.
Definition: Decl.h:86
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5629
llvm::DenseMap< Stmt *, Stmt * > MapTy
Definition: ParentMap.cpp:22
CharUnits getAlignment() const
getAlignment - Get the record alignment in characters.
Definition: RecordLayout.h:171
static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod, SmallVectorImpl< const NamedDecl *> &Redeclared)
Definition: ASTContext.cpp:451
FieldDecl * getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field)
__builtin_va_list as defined by the x86-64 ABI: http://refspecs.linuxbase.org/elf/x86_64-abi-0.21.pdf
Definition: TargetInfo.h:174
const Expr * getRequiresClause() const
Get the constraint-expression from the associated requires-clause (if any)
Definition: DeclTemplate.h:440
QualType getAtomicType(QualType T) const
Return the uniqued reference to the atomic type for the specified type.
param_const_iterator param_end() const
Definition: DeclObjC.h:390
unsigned getCharWidth() const
Definition: TargetInfo.h:333
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2397
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4035
CanQualType WideCharTy
Definition: ASTContext.h:1000
const DeclContext * getParentFunctionOrMethod() const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext...
Definition: DeclBase.cpp:256
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:206
CanQualType HalfTy
Definition: ASTContext.h:1008
ExtParameterInfo withIsNoEscape(bool NoEscape) const
Definition: Type.h:3339
QualType getElementType() const
Definition: Type.h:2593
unsigned getLargeArrayMinWidth() const
Definition: TargetInfo.h:443
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:491
StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const
Return a StringRef to the source buffer data for the specified FileID.
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
Definition: ASTContext.h:2028
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Definition: TemplateName.h:484
void Profile(llvm::FoldingSetNodeID &ID, ASTContext &Context)
ArrayRef< RawComment * > getComments() const
An identifier, stored as an IdentifierInfo*.
bool isUnsignedIntegerType() const
Return true if this is an integer type that is unsigned, according to C99 6.2.5p6 [which returns true...
Definition: Type.cpp:1840
unsigned getDepth() const
Get the nesting depth of the template parameter.
static const Type * getIntegerTypeForEnum(const EnumType *ET)
CanQualType getCanonicalParamType(QualType T) const
Return the canonical parameter type corresponding to the specific potentially non-canonical one...
const RawComment * getRaw() const LLVM_READONLY
Definition: ASTContext.h:743
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
QualType getCFConstantStringType() const
Return the C structure type used to represent constant CFStrings.
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
void removeObjCLifetime()
Definition: Type.h:347
QualType getReturnType() const
Definition: Decl.h:2207
LangAS getLangASFromTargetAS(unsigned TargetAS)
Definition: AddressSpaces.h:67
void initialize(ASTContext &Context, SourceLocation Loc) const
Initializes this to state that every location in this type is the given location. ...
Definition: TypeLoc.h:191
RecordDecl * getPreviousDecl()
Definition: Decl.h:3526
llvm::SmallVector< ast_type_traits::DynTypedNode, 2 > ParentVector
Contains parents of a node.
Definition: ASTContext.h:545
unsigned getNumParams() const
Definition: Type.h:3489
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3426
NamedDecl *const * const_iterator
Iterates through the template parameters in this list.
Definition: DeclTemplate.h:117
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6305
void setClassScopeSpecializationPattern(FunctionDecl *FD, FunctionDecl *Pattern)
CanQualType Float128Ty
Definition: ASTContext.h:1007
virtual void CompleteRedeclChain(const Decl *D)
Gives the external AST source an opportunity to complete the redeclaration chain for a declaration...
MangleContext * createMangleContext()
unsigned getCharAlign() const
Definition: TargetInfo.h:334
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:57
Extra information about a function prototype.
Definition: Type.h:3387
unsigned getWCharAlign() const
Definition: TargetInfo.h:391
Declaration context for names declared as extern "C" in C++.
Definition: Decl.h:221
const llvm::fltSemantics & getHalfFormat() const
Definition: TargetInfo.h:406
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:26
Represents a C++17 deduced template specialization type.
Definition: Type.h:4437
__builtin_va_list as defined by the AArch64 ABI http://infocenter.arm.com/help/topic/com.arm.doc.ihi0055a/IHI0055A_aapcs64.pdf
Definition: TargetInfo.h:161
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:422
ObjCImplementationDecl * getObjCImplementation(ObjCInterfaceDecl *D)
Get the implementation of the ObjCInterfaceDecl D, or nullptr if none exists.
bool field_empty() const
Definition: Decl.h:3628
A namespace, stored as a NamespaceDecl*.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
bool ClassImplementsProtocol(ObjCProtocolDecl *lProto, bool lookupCategory, bool RHSIsQualifiedID=false)
ClassImplementsProtocol - Checks that &#39;lProto&#39; protocol has been implemented in IDecl class...
Definition: DeclObjC.cpp:1667
void setRaw(const RawComment *RC)
Definition: ASTContext.h:747
bool isInvalidDecl() const
Definition: DeclBase.h:546
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
TemplateName getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, TemplateName replacement) const
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
protocol_range protocols() const
Definition: DeclObjC.h:2148
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1513
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4256
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2317
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:25
Defines the clang::Expr interface and subclasses for C++ expressions.
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:315
static TypedefDecl * CreatePNaClABIBuiltinVaListDecl(const ASTContext *Context)
Represents the builtin template declaration which is used to implement __make_integer_seq and other b...
The collection of all-type qualifiers we support.
Definition: Type.h:152
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
Definition: Expr.cpp:3433
PipeType - OpenCL20.
Definition: Type.h:5648
static void getIntersectionOfProtocols(ASTContext &Context, const ObjCInterfaceDecl *CommonBase, const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT, SmallVectorImpl< ObjCProtocolDecl *> &IntersectionSet)
getIntersectionOfProtocols - This routine finds the intersection of set of protocols inherited from t...
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2811
Qualifiers getQualifiers() const
Retrieve all qualifiers.
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm() const
Retrieve the substituted template template parameter, if known.
CanQualType OCLSamplerTy
Definition: ASTContext.h:1021
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:265
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3488
unsigned getLongDoubleAlign() const
Definition: TargetInfo.h:421
TemplateArgument getCanonicalTemplateArgument(const TemplateArgument &Arg) const
Retrieve the "canonical" template argument.
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1279
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:311
RecordDecl * getCFConstantStringTagDecl() const
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
QualType getSubstTemplateTypeParmType(const TemplateTypeParmType *Replaced, QualType Replacement) const
Retrieve a substitution-result type.
TypedefDecl * getObjCIdDecl() const
Retrieve the typedef corresponding to the predefined id type in Objective-C.
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3388
bool isComplete() const
Returns true if this can be considered a complete type.
Definition: Decl.h:3431
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:859
bool isObjCQualifiedClass() const
Definition: Type.h:5267
This table allows us to fully hide how we implement multi-keyword caching.
unsigned getIntAlign() const
Definition: TargetInfo.h:347
unsigned getRegParm() const
Definition: Type.h:3131
IntType getUnsignedPtrDiffType(unsigned AddrSpace) const
Definition: TargetInfo.h:251
Represents a class type in Objective C.
Definition: Type.h:5184
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
Definition: Decl.cpp:3922
QualType getPointeeType() const
Definition: Type.h:2400
void setManglingNumber(const NamedDecl *ND, unsigned Number)
CXXRecordDecl * getPreviousDecl()
Definition: DeclCXX.h:713
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
static unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
Definition: ASTContext.h:2698
A C++ nested-name-specifier augmented with source location information.
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:422
QualType getObjCSuperType() const
Returns the C struct type for objc_super.
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3496
ArrayRef< ExtParameterInfo > getExtParameterInfos() const
Definition: Type.h:3669
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:381
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:3020
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:72
void setObjCConstantStringInterface(ObjCInterfaceDecl *Decl)
void setArgLocInfo(unsigned i, TemplateArgumentLocInfo AI)
Definition: TypeLoc.h:1653
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
Missing a type from <ucontext.h>
Definition: ASTContext.h:1954
static bool isCanonicalExceptionSpecification(const FunctionProtoType::ExceptionSpecInfo &ESI, bool NoexceptInType)
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3609
unsigned getChar32Width() const
getChar32Width/Align - Return the size of &#39;char32_t&#39; for this target, in bits.
Definition: TargetInfo.h:400
The parameter is contravariant, e.g., X<T> is a subtype of X<U> when the type parameter is covariant ...
bool isCharType() const
Definition: Type.cpp:1750
bool isSpelledAsLValue() const
Definition: Type.h:2435
field_range fields() const
Definition: Decl.h:3619
static GVALinkage adjustGVALinkageForAttributes(const ASTContext &Context, const Decl *D, GVALinkage L)
QualType getDependentNameType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, QualType Canon=QualType()) const
std::unique_ptr< MangleNumberingContext > createMangleNumberingContext() const
SetterKind getSetterKind() const
getSetterKind - Return the method used for doing assignment in the property setter.
Definition: DeclObjC.h:911
bool isObjCIdType() const
Definition: Type.h:6068
The generic Mips ABI is a modified version of the Itanium ABI.
Definition: TargetCXXABI.h:90
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2467
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
Definition: Type.h:1639
DynTypedNodeList getParents(const NodeT &Node)
Returns the parents of the given node.
Definition: ASTContext.h:629
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType) const
unsigned getStaticLocalNumber(const VarDecl *VD) const
const char * getTypeString(unsigned ID) const
Get the type descriptor string for the specified builtin.
Definition: Builtins.h:91
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
Definition: DeclBase.h:772
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2542
const ObjCObjectPointerType * getAsObjCQualifiedIdType() const
Definition: Type.cpp:1539
void addLazyModuleInitializers(Module *M, ArrayRef< uint32_t > IDs)
Definition: ASTContext.cpp:992
void setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern)
Remember that the using decl Inst is an instantiation of the using decl Pattern of a class template...
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3725
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2046
CanQualType OCLEventTy
Definition: ASTContext.h:1021
Optional< unsigned > getNumTemplateExpansions() const
Retrieve the number of expansions that a template template argument expansion will produce...
Interesting information about a specific parameter that can&#39;t simply be reflected in parameter&#39;s type...
Definition: Type.h:3289
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4312
IntType getSizeType() const
Definition: TargetInfo.h:229
Container for either a single DynTypedNode or for an ArrayRef to DynTypedNode.
Definition: ASTContext.h:566
void setStaticLocalNumber(const VarDecl *VD, unsigned Number)
unsigned getPosition() const
Get the position of the template parameter within its parameter list.
TemplateName getOverloadedTemplateName(UnresolvedSetIterator Begin, UnresolvedSetIterator End) const
Retrieve the template name that corresponds to a non-empty lookup.
std::string getObjCEncodingForBlock(const BlockExpr *blockExpr) const
Return the encoded type for this block declaration.
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6136
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
qual_iterator qual_begin() const
Definition: Type.h:5085
bool isObjCSelType() const
Definition: Type.h:6080
RawComment * getRawCommentForDeclNoCache(const Decl *D) const
Return the documentation comment attached to a given declaration, without looking into cache...
Definition: ASTContext.cpp:113
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:231
unsigned IsFilled
If false, only CommentDecl is valid.
Definition: Comment.h:1064
uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID, const ObjCImplementationDecl *ID, const ObjCIvarDecl *Ivar) const
Get the offset of an ObjCIvarDecl in bits.
static TypedefDecl * CreatePowerABIBuiltinVaListDecl(const ASTContext *Context)
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1022
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
QualType getUnsignedPointerDiffType() const
Return the unique unsigned counterpart of "ptrdiff_t" integer type.
const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const
Get or compute information about the layout of the specified Objective-C interface.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:5668
static TypedefDecl * CreateCharPtrNamedVaListDecl(const ASTContext *Context, StringRef Name)
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6219
QualType getParamTypeForDecl() const
Definition: TemplateBase.h:269
Describes a module or submodule.
Definition: Module.h:65
IdentifierTable & Idents
Definition: ASTContext.h:537
bool ObjCObjectAdoptsQTypeProtocols(QualType QT, ObjCInterfaceDecl *Decl)
ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC&#39;s protocol list adopt all protocols in Q...
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:5737
static bool hasAnyPackExpansions(ArrayRef< TemplateArgument > Args)
const ObjCObjectPointerType * stripObjCKindOfTypeAndQuals(const ASTContext &ctx) const
Strip off the Objective-C "kindof" type and (with it) any protocol qualifiers.
Definition: Type.cpp:692
bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto, ObjCProtocolDecl *rProto) const
ProtocolCompatibleWithProtocol - return &#39;true&#39; if &#39;lProto&#39; is in the inheritance hierarchy of &#39;rProto...
TypeSourceInfo * getTemplateSpecializationTypeInfo(TemplateName T, SourceLocation TLoc, const TemplateArgumentListInfo &Args, QualType Canon=QualType()) const
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2167
bool getProducesResult() const
Definition: Type.h:3127
QualType mergeObjCGCQualifiers(QualType, QualType)
mergeObjCGCQualifiers - This routine merges ObjC&#39;s GC attribute of &#39;LHS&#39; and &#39;RHS&#39; attributes and ret...
static bool isTypeSigned(IntType T)
Returns true if the type is signed; false otherwise.
Definition: TargetInfo.cpp:269
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2856
uint64_t getConstantArrayElementCount(const ConstantArrayType *CA) const
Return number of constant array elements.
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2484
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2545
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
qual_iterator qual_end() const
Definition: Type.h:5086
A qualified template name, where the qualification is kept to describe the source code as written...
Definition: TemplateName.h:198
unsigned getAlignOfGlobalVar(QualType T) const
Return the alignment in bits that should be given to a global variable with type T.
static bool unionHasUniqueObjectRepresentations(const ASTContext &Context, const RecordDecl *RD)
static ObjCInterfaceDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation atLoc, IdentifierInfo *Id, ObjCTypeParamList *typeParamList, ObjCInterfaceDecl *PrevDecl, SourceLocation ClassLoc=SourceLocation(), bool isInternal=false)
Definition: DeclObjC.cpp:1417
const LangASMap & getAddressSpaceMap() const
Definition: TargetInfo.h:983
bool UnwrapSimilarPointerTypes(QualType &T1, QualType &T2)
UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that may be similar (C++ 4...
static int compareObjCProtocolsByName(ObjCProtocolDecl *const *lhs, ObjCProtocolDecl *const *rhs)
Comparison routine for Objective-C protocols to be used with llvm::array_pod_sort.
static llvm::Optional< int64_t > structHasUniqueObjectRepresentations(const ASTContext &Context, const RecordDecl *RD)
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:986
static ItaniumMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags)
QualType getOriginalType() const
Definition: Decl.cpp:2464
void addObjCGCAttr(GC type)
Definition: Type.h:325
static ExternCContextDecl * Create(const ASTContext &C, TranslationUnitDecl *TU)
Definition: Decl.cpp:4167
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
Microsoft throw(...) extension.
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
uint32_t Offset
Definition: CacheTokens.cpp:43
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments of this object type (semantically).
Definition: Type.cpp:637
QualType getVolatileType(QualType T) const
Return the uniqued reference to the type for a volatile qualified type.
Definition: ASTContext.h:1142
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const
Return one of the GCNone, Weak or Strong Objective-C garbage collection attributes.
Expr * getPtr() const
Definition: Expr.h:5135
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2166
The Microsoft ABI is the ABI used by Microsoft Visual Studio (and compatible compilers).
Definition: TargetCXXABI.h:113
TypedefDecl * getObjCSelDecl() const
Retrieve the typedef corresponding to the predefined &#39;SEL&#39; type in Objective-C.
bool hasAddressSpace() const
Definition: Type.h:366
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
Keeps track of the mangled names of lambda expressions and block literals within a particular context...
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type...
Definition: Type.h:6354
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
Definition: TemplateBase.h:275
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
PropertyAttributeKind getPropertyAttributes() const
Definition: DeclObjC.h:857
unsigned toTargetAddressSpace(LangAS AS)
Definition: AddressSpaces.h:62
NamespaceAliasDecl * getAsNamespaceAlias() const
Retrieve the namespace alias stored in this nested name specifier.
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:147
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:3782
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:635
static const Decl * adjustDeclToTemplate(const Decl *D)
If we have a &#39;templated&#39; declaration for a template, adjust &#39;D&#39; to refer to the actual template...
Definition: ASTContext.cpp:312
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1633
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2377
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack)
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2760
CanQualType PseudoObjectTy
Definition: ASTContext.h:1015
LangAS getAddressSpace() const
Definition: Type.h:367
QualType getExceptionObjectType(QualType T) const
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
const Type * getClass() const
Definition: Type.h:2536
CXXMethodVector::const_iterator overridden_cxx_method_iterator
Definition: ASTContext.h:908
bool isReadOnly() const
isReadOnly - Return true iff the property has a setter.
Definition: DeclObjC.h:880
unsigned getShortWidth() const
Return the size of &#39;signed short&#39; and &#39;unsigned short&#39; for this target, in bits.
Definition: TargetInfo.h:338
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4821
void getObjCEncodingForPropertyType(QualType T, std::string &S) const
Emit the Objective-C property type encoding for the given type T into S.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
CanQualType LongDoubleTy
Definition: ASTContext.h:1007
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2465
static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI, const LangOptions &LangOpts)
Definition: ASTContext.cpp:770
Expr * getSizeExpr() const
Definition: Type.h:2737
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
unsigned getChar16Align() const
Definition: TargetInfo.h:396
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5718
unsigned Align
Definition: ASTContext.h:139
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3656
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1153
void getOverriddenMethods(SmallVectorImpl< const ObjCMethodDecl *> &Overridden) const
Return overridden methods for the given Method.
Definition: DeclObjC.cpp:1244
bool AlignIsRequired
Definition: ASTContext.h:140
overridden_cxx_method_iterator overridden_methods_end(const CXXMethodDecl *Method) const
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
void eraseDeclAttrs(const Decl *D)
Erase the attributes corresponding to the given declaration.
bool isInlineDefinitionExternallyVisible() const
For an inline function definition in C, or for a gnu_inline function in C++, determine whether the de...
Definition: Decl.cpp:3123
Defines the Linkage enumeration and various utility functions.
DiagnosticsEngine & getDiagnostics() const
unsigned LangASMap[(unsigned) LangAS::FirstTargetAddressSpace]
The type of a lookup table which maps from language-specific address spaces to target-specific ones...
Definition: AddressSpaces.h:54
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2083
static unsigned NumImplicitDefaultConstructorsDeclared
The number of implicitly-declared default constructors for which declarations were built...
Definition: ASTContext.h:2684
TemplateTemplateParmDecl * getParameter() const
Definition: TemplateName.h:338
QualType mergeTransparentUnionType(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false)
mergeTransparentUnionType - if T is a transparent union type and a member of T is compatible with Sub...
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:167
bool isAlignmentRequired(const Type *T) const
Determine if the alignment the type has was required using an alignment attribute.
CXXABI * CreateItaniumCXXABI(ASTContext &Ctx)
Creates an instance of a C++ ABI class.
void * getAsOpaquePtr() const
Definition: Type.h:699
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization, retrieves the function from which it was instantiated.
Definition: Decl.cpp:3204
SmallVector< BoundNodes, 1 > match(MatcherT Matcher, const NodeT &Node, ASTContext &Context)
Returns the results of matching Matcher on Node.
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
Represents an ObjC class declaration.
Definition: DeclObjC.h:1191
const Type * getUnqualifiedDesugaredType() const
Return the specified type with any "sugar" removed from the type, removing any typedefs, typeofs, etc., as well as any qualifiers.
Definition: Type.cpp:379
QualType getReturnType() const
Definition: DeclObjC.h:361
unsigned getLongLongAlign() const
Definition: TargetInfo.h:357
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5419
bool getNoReturn() const
Definition: Type.h:3126
bool isKindOfType() const
Whether this is a "__kindof" type.
Definition: Type.h:5530
const T * getTypePtr() const
Retrieve the underlying type pointer, which refers to a canonical type.
Definition: CanonicalType.h:84
bool isParameterPack() const
Whether this template template parameter is a template parameter pack.
SplitQualType getSplitDesugaredType() const
Definition: Type.h:950
The iOS ABI is a partial implementation of the ARM ABI.
Definition: TargetCXXABI.h:63
IntrusiveRefCntPtr< ExternalASTSource > ExternalSource
Definition: ASTContext.h:541
CanQualType UnsignedCharTy
Definition: ASTContext.h:1005
Expr * getSizeExpr() const
Definition: Type.h:2794
bool getNoCallerSavedRegs() const
Definition: Type.h:3128
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:869
unsigned getNumProtocols() const
Return the number of qualifying protocols in this type, or 0 if there are none.
Definition: Type.h:5092
llvm::iterator_range< overridden_cxx_method_iterator > overridden_method_range
Definition: ASTContext.h:918
static char getObjCEncodingForPrimitiveKind(const ASTContext *C, BuiltinType::Kind kind)
std::string getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, bool Extended=false) const
Emit the encoded type for the method declaration Decl into S.
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:2874
This object can be modified without requiring retains or releases.
Definition: Type.h:173
void Profile(llvm::FoldingSetNodeID &ID)
Definition: TemplateName.h:500
static bool isCanonicalResultType(QualType T)
Determine whether T is canonical as the result type of a function.
Represents a K&R-style &#39;int foo()&#39; function, which has no information available about its arguments...
Definition: Type.h:3233
CanQualType Float128ComplexTy
Definition: ASTContext.h:1011
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2778
Expr * getAddrSpaceExpr() const
Definition: Type.h:2845
NodeId Parent
Definition: ASTDiff.cpp:192
Provides definitions for the various language-specific address spaces.
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4882
QualType getBlockDescriptorExtendedType() const
Gets the struct used to keep track of the extended descriptor for pointer to blocks.
bool hasAttr() const
Definition: DeclBase.h:535
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5247
unsigned getTargetDefaultAlignForAttributeAligned() const
Return the default alignment for attribute((aligned)) on this target, to be used if no alignment valu...
QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType, UnaryTransformType::UTTKind UKind) const
Unary type transforms.
unsigned getMinGlobalAlign() const
getMinGlobalAlign - Return the minimum alignment of a global variable, unless its alignment is explic...
Definition: TargetInfo.h:379
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2271
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2381
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3268
bool isFileVarDecl() const
isFileVarDecl - Returns true for file scoped variable declaration.
Definition: Decl.h:1186
The generic ARM ABI is a modified version of the Itanium ABI proposed by ARM for use on ARM-based pla...
Definition: TargetCXXABI.h:52
bool isDynamicClass() const
Definition: DeclCXX.h:751
QualType getDependentAddressSpaceType(QualType PointeeType, Expr *AddrSpaceExpr, SourceLocation AttrLoc) const
QualType applyObjCProtocolQualifiers(QualType type, ArrayRef< ObjCProtocolDecl *> protocols, bool &hasError, bool allowOnPointerType=false) const
Apply Objective-C protocol qualifiers to the given type.
const llvm::fltSemantics & getDoubleFormat() const
Definition: TargetInfo.h:416
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:438
static unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
Definition: ASTContext.h:2687
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:680
qual_range quals() const
Definition: Type.h:5084
A dependent template name that has not been resolved to a template (or set of templates).
Definition: TemplateName.h:202
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:540
comments::FullComment * cloneFullComment(comments::FullComment *FC, const Decl *D) const
Definition: ASTContext.cpp:468
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type...
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition: Type.h:2564
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:5793
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
QualType getAutoRRefDeductType() const
C++11 deduction pattern for &#39;auto &&&#39; type.
void setCFConstantStringType(QualType T)
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:264
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3248
void DeepCollectObjCIvars(const ObjCInterfaceDecl *OI, bool leafClass, SmallVectorImpl< const ObjCIvarDecl *> &Ivars) const
DeepCollectObjCIvars - This routine first collects all declared, but not synthesized, ivars in super class and then collects all ivars, including those synthesized for current class.
bool ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl, const ObjCMethodDecl *MethodImp)
QualType getPromotedIntegerType(QualType PromotableType) const
Return the type that PromotableType will promote to: C99 6.3.1.1p2, assuming that PromotableType is a...
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
const llvm::fltSemantics & getLongDoubleFormat() const
Definition: TargetInfo.h:422
typedef void* __builtin_va_list;
Definition: TargetInfo.h:157
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Definition: Expr.cpp:2942
bool hasPointerIdentity() const
Check if the given ASTNodeKind identifies a type that offers pointer identity.
Exposes information about the current target.
Definition: TargetInfo.h:54
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:2772
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we&#39;re targeting...
CommentOptions CommentOpts
Options for parsing comments.
Definition: LangOptions.h:140
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
bool isNoReturn(unsigned ID) const
Return true if we know this builtin never returns.
Definition: Builtins.h:117
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:1351
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:875
QualType getElementType() const
Definition: Type.h:2236
bool isGNUFamily() const
Is this runtime basically of the GNU family of runtimes?
Definition: ObjCRuntime.h:117
QualType getVectorType(QualType VectorType, unsigned NumElts, VectorType::VectorKind VecKind) const
Return the unique reference to a vector type of the specified element type and size.
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3695
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:627
Expr - This represents one expression.
Definition: Expr.h:106
Defines the clang::LangOptions interface.
QualType getPointeeType() const
Definition: Type.h:2440
SourceLocation End
IntType getSignedSizeType() const
Definition: TargetInfo.h:230
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
known_extensions_range known_extensions() const
Definition: DeclObjC.h:1780
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:4723
bool isPositive() const
isPositive - Test whether the quantity is greater than zero.
Definition: CharUnits.h:122
Selector getSetterName() const
Definition: DeclObjC.h:931
QualType getucontext_tType() const
Retrieve the C ucontext_t type.
Definition: ASTContext.h:1729
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
static const LangASMap * getAddressSpaceMap(const TargetInfo &T, const LangOptions &LOpts)
Definition: ASTContext.cpp:748
static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y)
unsigned getAsOpaqueValue() const
Definition: Type.h:265
void ResetObjCLayout(const ObjCContainerDecl *CD)
int Id
Definition: ASTDiff.cpp:191
static Kind getNullabilityAttrKind(NullabilityKind kind)
Retrieve the attribute kind corresponding to the given nullability kind.
Definition: Type.h:4134
const FunctionProtoType * T
static std::pair< CharUnits, CharUnits > getConstantArrayInfoInChars(const ASTContext &Context, const ConstantArrayType *CAT)
getConstantArrayInfoInChars - Performing the computation in CharUnits instead of in bits prevents ove...
unsigned getIntWidth() const
getIntWidth/Align - Return the size of &#39;signed int&#39; and &#39;unsigned int&#39; for this target, in bits.
Definition: TargetInfo.h:346
QualType getCanonicalTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args) const
Declaration of a template type parameter.
Internal representation of canonical, dependent decltype(expr) types.
Definition: Type.h:3880
TypedefDecl * buildImplicitTypedef(QualType T, StringRef Name) const
Create a new implicit TU-level typedef declaration.
Defines the clang::CommentOptions interface.
Implements an efficient mapping from strings to IdentifierInfo nodes.
bool getHasRegParm() const
Definition: Type.h:3129
bool isObjCBuiltinType() const
Definition: Type.h:6086
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6368
std::string getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, const Decl *Container) const
getObjCEncodingForPropertyDecl - Return the encoded type for this method declaration.
void setObjCMethodRedeclaration(const ObjCMethodDecl *MD, const ObjCMethodDecl *Redecl)
ElaboratedTypeKeyword
The elaboration keyword that precedes a qualified type name or introduces an elaborated-type-specifie...
Definition: Type.h:4705
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:68
bool isNearlyEmpty(const CXXRecordDecl *RD) const
bool isObjCRetainableType() const
Definition: Type.cpp:3824
Inits[]
Definition: OpenMPClause.h:140
QualType getTypeOfExprType(Expr *e) const
GCC extension.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4159
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:4851
Qualifiers::GC getObjCGCAttr() const
Returns gc attribute of this type.
Definition: Type.h:5839
QualType getParenType(QualType NamedType) const
CanQualType OMPArraySectionTy
Definition: ASTContext.h:1023
static TypedefDecl * CreateX86_64ABIBuiltinVaListDecl(const ASTContext *Context)
const Decl * getDecl() const LLVM_READONLY
Definition: Comment.h:1125
static unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
Definition: ASTContext.h:2694
static TypedefDecl * CreateMSVaListDecl(const ASTContext *Context)
bool hasUniqueObjectRepresentations(QualType Ty) const
Return true if the specified type has unique object representations according to (C++17 [meta...
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:551
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
static std::string charUnitsToString(const CharUnits &CU)
void Profile(llvm::FoldingSetNodeID &ID)
bool isNullPtrType() const
Definition: Type.h:6182
unsigned getFastQualifiers() const
Definition: Type.h:401
ExtProtoInfo withExceptionSpec(const ExceptionSpecInfo &O)
Definition: Type.h:3402
ObjCLifetime getObjCLifetime() const
Definition: Type.h:341
void removeFastQualifiers(unsigned mask)
Definition: Type.h:406
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
bool isObjCClassType() const
Definition: Type.h:6074
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2353
DeclContext * getDeclContext()
Definition: DeclBase.h:425
A structure for storing the information associated with a substituted template template parameter...
Definition: TemplateName.h:325
bool isObjCIdType() const
True if this is equivalent to the &#39;id&#39; type, i.e.
Definition: Type.h:5502
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:330
SourceLocation Begin
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3886
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
CanQualType ShortTy
Definition: ASTContext.h:1004
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
internal::Matcher< T > id(StringRef ID, const internal::BindableMatcher< T > &InnerMatcher)
If the provided matcher matches a node, binds the node to ID.
Definition: ASTMatchers.h:137
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:264
TypedefDecl * getInt128Decl() const
Retrieve the declaration for the 128-bit signed integer type.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack...
Definition: DeclBase.cpp:201
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
Represents the type decltype(expr) (C++11).
Definition: Type.h:3852
static TypedefDecl * CreateAAPCSABIBuiltinVaListDecl(const ASTContext *Context)
char __ovld __cnfn min(char x, char y)
Returns y if y < x, otherwise it returns x.
QualType getFILEType() const
Retrieve the C FILE type.
Definition: ASTContext.h:1693
llvm::PointerUnion< ClassTemplateDecl *, ClassTemplatePartialSpecializationDecl * > getSpecializedTemplateOrPartial() const
Retrieve the class template or class template partial specialization which was specialized by this...
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy)
Print a template argument list, including the &#39;<&#39; and &#39;>&#39; enclosing the template arguments.
Defines the clang::TypeLoc interface and its subclasses.
A namespace alias, stored as a NamespaceAliasDecl*.
bool isIdentifier() const
Determine whether this template name refers to an identifier.
Definition: TemplateName.h:481
int Depth
Definition: ASTDiff.cpp:191
TemplateOrSpecializationInfo getTemplateOrSpecializationInfo(const VarDecl *Var)
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
void setObjCImplementation(ObjCInterfaceDecl *IFaceD, ObjCImplementationDecl *ImplD)
Set the implementation of ObjCInterfaceDecl.
virtual void RedefinedHiddenDefinition(const NamedDecl *D, Module *M)
A definition has been made visible by being redefined locally.
const TemplateParameterList * TemplateParameters
Template parameters that can be referenced by \tparam if CommentDecl is a template (IsTemplateDecl or...
Definition: Comment.h:1012
CanQualType UnsignedInt128Ty
Definition: ASTContext.h:1006
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:702
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:592
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1800
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
QualType getType() const
Definition: Expr.h:128
A unary type transform, which is a type constructed from another.
Definition: Type.h:3895
const ObjCMethodDecl * getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const
Get the duplicate declaration of a ObjCMethod in the same interface, or null if none exists...
overridden_method_range overridden_methods(const CXXMethodDecl *Method) const
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:117
propimpl_range property_impls() const
Definition: DeclObjC.h:2486
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
Qualifiers Quals
The local qualifiers.
Definition: Type.h:597
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl, 0 if there are none.
Definition: DeclBase.cpp:386
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1335
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:4079
void setAddressSpace(LangAS space)
Definition: Type.h:387
unsigned getShortAlign() const
Return the alignment of &#39;signed short&#39; and &#39;unsigned short&#39; for this target.
Definition: TargetInfo.h:342
QualType getRecordType(const RecordDecl *Decl) const
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
bool isInstanceMethod() const
Definition: DeclObjC.h:452
QualType getBlockDescriptorType() const
Gets the struct used to keep track of the descriptor for pointer to blocks.
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1333
Represents a GCC generic vector type.
Definition: Type.h:2914
ArraySizeModifier getSizeModifier() const
Definition: Type.h:2595
struct CXXOpName CXXOperatorName
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2466
TypedefDecl * getBuiltinVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_va_list type...
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
void addDeclaratorForUnnamedTagDecl(TagDecl *TD, DeclaratorDecl *DD)
QualType getSubstTemplateTypeParmPackType(const TemplateTypeParmType *Replaced, const TemplateArgument &ArgPack)
Retrieve a.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1041
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4361
Implements C++ ABI-specific semantic analysis functions.
Definition: CXXABI.h:30
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6263
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2209
unsigned getParameterIndex(const ParmVarDecl *D) const
Used by ParmVarDecl to retrieve on the side the index of the parameter when it exceeds the size of th...
NamedDecl * getInstantiatedFromUsingDecl(NamedDecl *Inst)
If the given using decl Inst is an instantiation of a (possibly unresolved) using decl from a templat...
void deduplicateMergedDefinitonsFor(NamedDecl *ND)
Clean up the merged definition list.
Definition: ASTContext.cpp:936
void CollectInheritedProtocols(const Decl *CDecl, llvm::SmallPtrSet< ObjCProtocolDecl *, 8 > &Protocols)
CollectInheritedProtocols - Collect all protocols in current class and those inherited by it...
unsigned getDoubleAlign() const
Definition: TargetInfo.h:415
Selector getSelector() const
Definition: DeclObjC.h:359
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1347
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:149
bool ObjCQualifiedClassTypesAreCompatible(QualType LHS, QualType RHS)
ObjCQualifiedClassTypesAreCompatible - compare Class<pr,...> and Class<pr1, ...>. ...
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
bool useAddressSpaceMapMangling() const
Specify if mangling based on address space map should be used or not for language specific address sp...
Definition: TargetInfo.h:572
QualType getType() const
Definition: DeclObjC.h:846
IntType getUIntMaxType() const
Definition: TargetInfo.h:245
const SourceManager & SM
Definition: Format.cpp:1337
void setOriginalDecl(const Decl *Orig)
Definition: ASTContext.h:755
unsigned getDoubleWidth() const
getDoubleWidth/Align/Format - Return the size/align/format of &#39;double&#39;.
Definition: TargetInfo.h:414
comments::FullComment * parse(const ASTContext &Context, const Preprocessor *PP, const Decl *D) const
Parse the comment, assuming it is attached to decl D.
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Definition: DeclBase.cpp:297
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:233
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3942
CanQualType SignedCharTy
Definition: ASTContext.h:1004
LangAS getOpenCLTypeAddrSpace(const Type *T) const
Get address space for OpenCL type.
static TemplateParameterList * Create(const ASTContext &C, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ArrayRef< NamedDecl *> Params, SourceLocation RAngleLoc, Expr *RequiresClause)
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:220
static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)
Definition: DeclCXX.cpp:122
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
virtual bool allowsLargerPreferedTypeAlignment() const
Whether target allows to overalign ABI-specified preferred alignment.
Definition: TargetInfo.h:1045
ExtInfo withNoReturn(bool noReturn) const
Definition: Type.h:3150
std::pair< CharUnits, CharUnits > getTypeInfoDataSizeInChars(QualType T) const
WatchOS is a modernisation of the iOS ABI, which roughly means it&#39;s the iOS64 ABI ported to 32-bits...
Definition: TargetCXXABI.h:76
bool isVoidPointerType() const
Definition: Type.cpp:426
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:5777
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:3894
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent) const
C++11 deduced auto type.
SplitQualType split() const
Divides a QualType into its unqualified type and a set of local qualifiers.
Definition: Type.h:5726
unsigned getWCharWidth() const
getWCharWidth/Align - Return the size of &#39;wchar_t&#39; for this target, in bits.
Definition: TargetInfo.h:390
RecordDecl * getDecl() const
Definition: Type.h:3986
QualType getPackExpansionType(QualType Pattern, Optional< unsigned > NumExpansions)
CanQualType getUIntMaxType() const
Return the unique type for "uintmax_t" (C99 7.18.1.5), defined in <stdint.h>.
Abstract interface for external sources of AST nodes.
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:181
SourceLocation getLocStart() const LLVM_READONLY
Definition: DeclBase.h:408
QualType getWideCharType() const
Return the type of wide characters.
Definition: ASTContext.h:1516
IntType getPtrDiffType(unsigned AddrSpace) const
Definition: TargetInfo.h:248
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:211
CanQualType OverloadTy
Definition: ASTContext.h:1013
There is no lifetime qualification on this type.
Definition: Type.h:169
Compare comments&#39; source locations.
static unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
Definition: ASTContext.h:2719
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
void PrintStats() const
Definition: ASTContext.cpp:865
std::string getAsString() const
Derive the full selector name (e.g.
is AltiVec &#39;vector Pixel&#39;
Definition: Type.h:2924
CanQualType BuiltinFnTy
Definition: ASTContext.h:1014
This declaration does not have an attached comment, and we have searched the redeclaration chain...
Definition: ASTContext.h:732
TemplateName getDependentTemplateName(NestedNameSpecifier *NNS, const IdentifierInfo *Name) const
Retrieve the template name that represents a dependent template name such as MetaFun::template apply...
SelectorTable & Selectors
Definition: ASTContext.h:538
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:180
Kind
bool QIdProtocolsAdoptObjCObjectProtocols(QualType QT, ObjCInterfaceDecl *IDecl)
QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in QT&#39;s qualified-id protocol list adopt...
QualType getCanonicalType() const
Definition: Type.h:5757
bool isBuiltinType() const
Helper methods to distinguish type categories.
Definition: Type.h:6011
not a target-specific vector type
Definition: Type.h:2918
llvm::PointerUnion< VarTemplateDecl *, MemberSpecializationInfo * > TemplateOrSpecializationInfo
A type synonym for the TemplateOrInstantiation mapping.
Definition: ASTContext.h:393
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3365
Expr * getBlockVarCopyInits(const VarDecl *VD)
Get the copy initialization expression of the VarDecl VD, or nullptr if none exists.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:191
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:208
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:3684
bool isSpecialized() const
Determine whether this object type is "specialized", meaning that it has type arguments.
Definition: Type.cpp:619
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3500
static GVALinkage basicGVALinkageForFunction(const ASTContext &Context, const FunctionDecl *FD)
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:299
QualType getSignatureParameterType(QualType T) const
Retrieve the parameter type as adjusted for use in the signature of a function, decaying array and fu...
const ExtParameterInfo * ExtParameterInfos
Definition: Type.h:3394
unsigned getMaxAtomicInlineWidth() const
Return the maximum width lock-free atomic operation which can be inlined given the supported features...
Definition: TargetInfo.h:451
void AddDeallocation(void(*Callback)(void *), void *Data)
Add a deallocation callback that will be invoked when the ASTContext is destroyed.
Definition: ASTContext.cpp:856
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant...
Definition: Expr.cpp:3276
Encodes a location in the source.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5397
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
Sugar for parentheses used when specifying types.
Definition: Type.h:2253
QualType getReturnType() const
Definition: Type.h:3201
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4002
bool hasSameTemplateName(TemplateName X, TemplateName Y)
Determine whether the given template names refer to the same template.
bool qual_empty() const
Definition: Type.h:5573
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:5834
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
unsigned getOpenMPDefaultSimdAlign(QualType T) const
Get default simd alignment of the specified complete type in bits.
CanQualType Int128Ty
Definition: ASTContext.h:1004
Represents typeof(type), a GCC extension.
Definition: Type.h:3825
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5384
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:1874
bool isObjCQualifiedClassType() const
True if this is equivalent to &#39;Class.
Definition: Type.h:5525
This names the __make_integer_seq BuiltinTemplateDecl.
Definition: Builtins.h:232
unsigned getManglingNumber(const NamedDecl *ND) const
A structure for storing an already-substituted template template parameter pack.
Definition: TemplateName.h:121
std::string getNameAsString() const
getNameAsString - Get a human-readable name for the declaration, even if it is one of the special kin...
Definition: Decl.h:285
static unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built...
Definition: ASTContext.h:2705
Kind getKind() const LLVM_READONLY
Definition: ASTContext.h:735
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2944
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
size_t getSideTableAllocatedMemory() const
Return the total memory used for various side tables.
unsigned getChar16Width() const
getChar16Width/Align - Return the size of &#39;char16_t&#39; for this target, in bits.
Definition: TargetInfo.h:395
unsigned getLongLongWidth() const
getLongLongWidth/Align - Return the size of &#39;signed long long&#39; and &#39;unsigned long long&#39; for this targ...
Definition: TargetInfo.h:356
CallingConv getCC() const
Definition: Type.h:3138
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2650
QualType getElementType() const
Definition: Type.h:2949
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C &#39;SEL&#39; type.
Definition: ASTContext.h:1810
ObjCInterfaceDecl * getObjCProtocolDecl() const
Retrieve the Objective-C class declaration corresponding to the predefined Protocol class...
QualType getWritePipeType(QualType T) const
Return a write_only pipe type for the specified type.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: TemplateName.h:402
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
Definition: Mangle.h:42
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1964
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2321
IntType getIntMaxType() const
Definition: TargetInfo.h:244
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3529
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
DeclarationNameInfo getNameForTemplate(TemplateName Name, SourceLocation NameLoc) const
Weak for now, might become strong later in this TU.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4284
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
CanQualType FloatTy
Definition: ASTContext.h:1007
unsigned getLineNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const
Given a SourceLocation, return the spelling line number for the position indicated.
unsigned getFloat128Width() const
getFloat128Width/Align/Format - Return the size/align/format of &#39;__float128&#39;.
Definition: TargetInfo.h:428
This file defines OpenMP nodes for declarative directives.
overridden_cxx_method_iterator overridden_methods_begin(const CXXMethodDecl *Method) const
DeclarationName getIdentifier(const IdentifierInfo *ID)
getIdentifier - Create a declaration name that is a simple identifier.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2299
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:360
BuiltinTemplateKind
Kinds of BuiltinTemplateDecl.
Definition: Builtins.h:230
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>, and corresponding __opencl_atomic_* for OpenCL 2.0.
Definition: Expr.h:5103
unsigned getHalfAlign() const
Definition: TargetInfo.h:405
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
CanQualType VoidTy
Definition: ASTContext.h:996
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3415
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
CanQualType Float16Ty
Definition: ASTContext.h:1009
CanQualType getSignedSizeType() const
Return the unique signed counterpart of the integer type corresponding to size_t. ...
QualType getObjCTypeParamType(const ObjCTypeParamDecl *Decl, ArrayRef< ObjCProtocolDecl *> protocols, QualType Canonical=QualType()) const
bool isObjCObjectPointerType() const
Definition: Type.h:6039
bool isAnyPointerType() const
Definition: Type.h:5946
This declaration is only a declaration.
Definition: Decl.h:1138
is AltiVec &#39;vector bool ...&#39;
Definition: Type.h:2927
virtual BuiltinVaListKind getBuiltinVaListKind() const =0
Returns the kind of __builtin_va_list type that should be used with this target.
SplitQualType getSplitUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5805
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:746
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:694
__builtin_va_list as defined by the Power ABI: https://www.power.org /resources/downloads/Power-Arch-...
Definition: TargetInfo.h:170
bool canBindObjCObjectType(QualType To, QualType From)
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1096
We have found a comment attached to this particular declaration.
Definition: ASTContext.h:722
The generic Itanium ABI is the standard ABI of most open-source and Unix-like platforms.
Definition: TargetCXXABI.h:34
void getOverriddenMethods(const NamedDecl *Method, SmallVectorImpl< const NamedDecl *> &Overridden) const
Return C++ or ObjC overridden methods for the given Method.
void InitBuiltinTypes(const TargetInfo &Target, const TargetInfo *AuxTarget=nullptr)
Initialize built-in types.
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
Definition: DeclObjC.h:1829
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2599
TypeClass getTypeClass() const
Definition: Type.h:1613
QualType getAttributedType(AttributedType::Kind attrKind, QualType modifiedType, QualType equivalentType)
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:161
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:146
bool typesAreBlockPointerCompatible(QualType, QualType)
CharUnits getDataSize() const
getDataSize() - Get the record data size, which is the record size without tail padding, in characters.
Definition: RecordLayout.h:187
QualType getSuperClassType() const
Retrieve the type of the superclass of this object type.
Definition: Type.h:5312
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclObjC.h:299
bool isTargetAddressSpace(LangAS AS)
Definition: AddressSpaces.h:58
EnumDecl * getDecl() const
Definition: Type.h:4009
bool isVectorType() const
Definition: Type.h:6027
ObjCPropertyImplDecl * getObjCPropertyImplDeclForPropertyDecl(const ObjCPropertyDecl *PD, const Decl *Container) const
FunctionDecl * getClassScopeSpecializationPattern(const FunctionDecl *FD)
Assigning into this object requires a lifetime extension.
Definition: Type.h:186
QualType AutoDeductTy
Definition: ASTContext.h:1026
SourceRange getBracketsRange() const
Definition: Type.h:2800
unsigned getPreferredTypeAlign(const Type *T) const
Return the "preferred" alignment of the specified type T for the current target, in bits...
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1513
llvm::DenseMap< const Decl *, RawCommentAndCacheFlags > RedeclComments
Mapping from declarations to comments attached to any redeclaration.
Definition: ASTContext.h:769
static DynTypedNode create(const T &Node)
Creates a DynTypedNode from Node.
comments::FullComment * getCommentForDecl(const Decl *D, const Preprocessor *PP) const
Return parsed documentation comment attached to a given declaration.
Definition: ASTContext.cpp:488
bool isCanonical() const
Definition: Type.h:5762
bool hasFlexibleArrayMember() const
Definition: Decl.h:3541
unsigned getLongDoubleWidth() const
getLongDoubleWidth/Align/Format - Return the size/align/format of &#39;long double&#39;.
Definition: TargetInfo.h:420
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2214
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
__builtin_va_list as defined by ARM AAPCS ABI http://infocenter.arm.com
Definition: TargetInfo.h:179
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:5601
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:3971
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2368
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
The WebAssembly ABI is a modified version of the Itanium ABI.
Definition: TargetCXXABI.h:105
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4633
const llvm::fltSemantics & getFloatTypeSemantics(QualType T) const
Return the APFloat &#39;semantics&#39; for the specified scalar floating point type.
Represents a pack expansion of types.
Definition: Type.h:4994
std::pair< CharUnits, CharUnits > getTypeInfoInChars(const Type *T) const
static QualType mergeEnumWithInteger(ASTContext &Context, const EnumType *ET, QualType other, bool isBlockReturnType)
Given that we have an enum type and a non-enum type, try to merge them.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:354
ast_type_traits::DynTypedNode DynTypedNode
Defines various enumerations that describe declaration and type specifiers.
DeclarationNameLoc - Additional source/type location info for a declaration name. ...
void setTemplateKeywordLoc(SourceLocation Loc)
Definition: TypeLoc.h:1629
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:650
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1570
ArrayRef< Decl * > getModuleInitializers(Module *M)
Get the initializations to perform when importing a module, if any.
const llvm::fltSemantics & getFloat128Format() const
Definition: TargetInfo.h:430
CanQualType UnsignedShortTy
Definition: ASTContext.h:1005
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1997
CallingConv getDefaultCallingConvention(bool IsVariadic, bool IsCXXMethod) const
Retrieves the default calling convention for the current target.
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Canon=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2802
ast_type_traits::DynTypedNode Node
CanQualType CharTy
Definition: ASTContext.h:998
bool propertyTypesAreCompatible(QualType, QualType)
Represents a template argument.
Definition: TemplateBase.h:51
static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context, ASTContext::GetBuiltinTypeError &Error, bool &RequiresICE, bool AllowTypeModifiers)
DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the pointer over the consume...
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
Represents a type which was implicitly adjusted by the semantic engine for arbitrary reasons...
Definition: Type.h:2331
IntType
===-— Target Data Type Query Methods ----------------------------—===//
Definition: TargetInfo.h:128
QualType withRestrict() const
Definition: Type.h:834
Represents a template name that was expressed as a qualified name.
Definition: TemplateName.h:366
TagTypeKind
The kind of a tag type.
Definition: Type.h:4686
RealType getRealTypeByWidth(unsigned BitWidth) const
Return floating point type with specified width.
Definition: TargetInfo.cpp:226
QualType getDecayedType(QualType T) const
Return the uniqued reference to the decayed version of the given type.
QualType getTypeOfType(QualType t) const
getTypeOfType - Unlike many "get<Type>" functions, we don&#39;t unique TypeOfType nodes.
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2459
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:940
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:1016
void getLegacyIntegralTypeEncoding(QualType &t) const
getLegacyIntegralTypeEncoding - Another legacy compatibility encoding: 32-bit longs are encoded as &#39;l...
GC getObjCGCAttr() const
Definition: Type.h:320
Dataflow Directional Tag Classes.
int getFloatingTypeOrder(QualType LHS, QualType RHS) const
Compare the rank of the two specified floating point types, ignoring the domain of the type (i...
void getInjectedTemplateArgs(const TemplateParameterList *Params, SmallVectorImpl< TemplateArgument > &Args)
Get a template argument list with one argument per template parameter in a template parameter list...
TemplateName getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param, const TemplateArgument &ArgPack) const
CharUnits getSize() const
getSize - Get the record size in characters.
Definition: RecordLayout.h:174
ExtInfo getExtInfo() const
Definition: Type.h:3212
TargetInfo::OpenCLTypeKind getOpenCLTypeKind(const Type *T) const
Map an AST Type to an OpenCLTypeKind enum value.
not evaluated yet, for special member function
static NonTypeTemplateParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id, QualType T, bool ParameterPack, TypeSourceInfo *TInfo)
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:5685
QualType mergeTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false, bool BlockReturnType=false)
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1256
CanQualType NullPtrTy
Definition: ASTContext.h:1012
bool isSentinelNullExpr(const Expr *E)
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
CanQualType DoubleComplexTy
Definition: ASTContext.h:1010
static GVALinkage adjustGVALinkageForExternalDefinitionKind(const ASTContext &Ctx, const Decl *D, GVALinkage L)
Adjust the GVALinkage for a declaration based on what an external AST source knows about whether ther...
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
void addCopyConstructorForExceptionObject(CXXRecordDecl *RD, CXXConstructorDecl *CD)
typedef char* __builtin_va_list;
Definition: TargetInfo.h:154
static FloatingRank getFloatingRank(QualType T)
getFloatingRank - Return a relative rank for floating point types.
static BuiltinTemplateDecl * Create(const ASTContext &C, DeclContext *DC, DeclarationName Name, BuiltinTemplateKind BTK)
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:80
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:3430
bool isObjCClassType() const
True if this is equivalent to the &#39;Class&#39; type, i.e.
Definition: Type.h:5508
static bool areCompatVectorTypes(const VectorType *LHS, const VectorType *RHS)
areCompatVectorTypes - Return true if the two specified vector types are compatible.
QualType getUnderlyingType() const
Definition: Decl.h:2853
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1006
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
const Expr * getInit() const
Definition: Decl.h:1212
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition: DeclObjC.h:1568
NamespaceDecl * getOriginalNamespace()
Get the original (first) namespace declaration.
Definition: DeclCXX.cpp:2320
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
Definition: Type.h:756
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:157
QualType getProcessIDType() const
Return the unique type for "pid_t" defined in <sys/types.h>.
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3590
bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const
Returns true if this is an inline-initialized static data member which is treated as a definition for...
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3301
DeclarationName - The name of a declaration.
VectorKind getVectorKind() const
Definition: Type.h:2959
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:576
bool isBooleanType() const
Definition: Type.h:6232
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:5692
const CXXRecordDecl * getBaseSharingVBPtr() const
Definition: RecordLayout.h:301
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3652
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like &#39;int()&#39;.
static ASTContext::DynTypedNodeList getDynNodeFromMap(const NodeTy &Node, const MapTy &Map)
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2900
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3316
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5481
bool isKindOfType() const
Whether this ia a "__kindof" type (semantically).
Definition: Type.cpp:655
EnumDecl - Represents an enum.
Definition: Decl.h:3239
FunctionType::ExtInfo getFunctionExtInfo(const Type &t)
Definition: Type.h:5843
Information about the declaration, useful to clients of FullComment.
Definition: Comment.h:986
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2448
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2502
const FunctionType * adjustFunctionType(const FunctionType *Fn, FunctionType::ExtInfo EInfo)
Change the ExtInfo on a function type.
This names the __type_pack_element BuiltinTemplateDecl.
Definition: Builtins.h:235
bool canAssignObjCInterfacesInBlockPointer(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT, bool BlockReturnType)
canAssignObjCInterfacesInBlockPointer - This routine is specifically written for providing type-safet...
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:143
bool hasObjCLifetime() const
Definition: Type.h:340
QualType AutoRRefDeductTy
Definition: ASTContext.h:1027
virtual ~CXXABI()
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:574
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
A type that was preceded by the &#39;template&#39; keyword, stored as a Type*.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1048
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:340
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
Definition: TargetInfo.h:919
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS)
QualType getUnsignedWCharType() const
Return the type of "unsigned wchar_t".
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4231
static unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
Definition: ASTContext.h:2701
void addConsistentQualifiers(Qualifiers qs)
Add the qualifiers from the given set to this set, given that they don&#39;t conflict.
Definition: Type.h:467
bool isObjCUnqualifiedIdOrClass() const
Definition: Type.h:5259
bool isMacroID() const
GVALinkage GetGVALinkageForVariable(const VarDecl *VD)
A dynamically typed AST node container.
const Decl * getOriginalDecl() const LLVM_READONLY
Definition: ASTContext.h:751
virtual IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return integer type with specified width.
Definition: TargetInfo.cpp:196
Represents a pointer to an Objective C object.
Definition: Type.h:5440
Pointer to a block type.
Definition: Type.h:2385
CanQualType ObjCBuiltinBoolTy
Definition: ASTContext.h:1017
unsigned getIntWidth(QualType T) const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2571
QualType getDependentSizedArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a dependently-sized array of the specified element type...
CharUnits getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const
Loading virtual member pointers using the virtual inheritance model always results in an adjustment u...
virtual ExtKind hasExternalDefinitions(const Decl *D)
bool isIncompleteArrayType() const
Definition: Type.h:5999
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3976
StringRef getObjCRuntimeNameAsString() const
Produce a name to be used for class&#39;s metadata.
Definition: DeclObjC.cpp:1497
Complex values, per C99 6.2.5p11.
Definition: Type.h:2223
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
BuiltinTemplateDecl * getTypePackElementDecl() const
unsigned getIndexTypeCVRQualifiers() const
Definition: Type.h:2603
bool isMacroArgExpansion(SourceLocation Loc, SourceLocation *StartLoc=nullptr) const
Tests whether the given source location represents a macro argument&#39;s expansion into the function-lik...
bool isObjCQualifiedId() const
Definition: Type.h:5266
CanQualType UnknownAnyTy
Definition: ASTContext.h:1013
bool empty() const
Definition: Type.h:429
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6.7.5p3.
Definition: Type.cpp:1976
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface...
Definition: Type.h:5496
comments::FullComment * getLocalCommentForDeclUncached(const Decl *D) const
Return parsed documentation comment attached to a given declaration.
Definition: ASTContext.cpp:483
QualType getCanonicalTypeInternal() const
Definition: Type.h:2107
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6191
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:153
CanQualType UnsignedLongTy
Definition: ASTContext.h:1005
bool areCompatibleVectorTypes(QualType FirstVec, QualType SecondVec)
Return true if the given vector types are of the same unqualified type or if they are equivalent to t...
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2690
const llvm::APInt & getSize() const
Definition: Type.h:2636
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2011
CanQualType DependentTy
Definition: ASTContext.h:1013
QualType getFloatingTypeOfSizeWithinDomain(QualType typeSize, QualType typeDomain) const
Return a real floating point or a complex type (based on typeDomain/typeSize).
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
CanQualType WCharTy
Definition: ASTContext.h:999
bool isFunctionType() const
Definition: Type.h:5938
bool hasNonFastQualifiers() const
Return true if the set contains any qualifiers which require an ExtQuals node to be allocated...
Definition: Type.h:420
bool isAddressSpaceSupersetOf(Qualifiers other) const
Returns true if this address space is a superset of the other one.
Definition: Type.h:484
unsigned getBoolAlign() const
Return the alignment of &#39;_Bool&#39; and C++ &#39;bool&#39; for this target.
Definition: TargetInfo.h:331
bool isStaticLocal() const
isStaticLocal - Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1049
bool isObjCQualifiedIdType() const
Definition: Type.h:6056
static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET)
static GVALinkage basicGVALinkageForVariable(const ASTContext &Context, const VarDecl *VD)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:707
bool isMSExternInline() const
The combination of the extern and inline keywords under MSVC forces the function to be required...
Definition: Decl.cpp:2947
ExtVectorType - Extended vector type.
Definition: Type.h:2988
CanQualType ObjCBuiltinClassTy
Definition: ASTContext.h:1016
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
param_const_iterator param_begin() const
Definition: DeclObjC.h:386
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2419
SourceRange getBracketsRange() const
Definition: Type.h:2743
virtual uint64_t getMaxPointerWidth() const
Return the maximum width of pointers on this target.
Definition: TargetInfo.h:319
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2190
CanQualType BoundMemberTy
Definition: ASTContext.h:1013
static TypedefDecl * CreateCharPtrBuiltinVaListDecl(const ASTContext *Context)
QualType getAutoDeductType() const
C++11 deduction pattern for &#39;auto&#39; type.
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
Definition: DeclObjC.h:1934
llvm::DenseMap< const Decl *, comments::FullComment * > ParsedComments
Mapping from declarations to parsed comments attached to any redeclaration.
Definition: ASTContext.h:773
The template argument is a type.
Definition: TemplateBase.h:60
qual_range quals() const
Definition: Type.h:5563
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1425
bool canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
canAssignObjCInterfaces - Return true if the two interface types are compatible for assignment from R...
TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl)
void setBlockVarCopyInits(VarDecl *VD, Expr *Init)
Set the copy inialization expression of a block var decl.
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3597
The template argument is actually a parameter pack.
Definition: TemplateBase.h:91
void getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT, std::string &S) const
Put the string version of the type qualifiers QT into S.
BuiltinVaListKind
The different kinds of __builtin_va_list types defined by the target implementation.
Definition: TargetInfo.h:152
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
const Expr * Replacement
Definition: AttributeList.h:59
char __ovld __cnfn max(char x, char y)
Returns y if x < y, otherwise it returns x.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2007
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3368
virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const
Gets the default calling convention for the given target and declaration context. ...
Definition: TargetInfo.h:1012
bool isObjCObjectType() const
Definition: Type.h:6043
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1986
bool hasObjCGCAttr() const
Definition: Type.h:319
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2257
ASTMutationListener * getASTMutationListener() const
Retrieve a pointer to the AST mutation listener associated with this AST context, if any...
Definition: ASTContext.h:1063
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2174
A template argument list.
Definition: DeclTemplate.h:210
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
BuiltinTemplateDecl * buildBuiltinTemplateDecl(BuiltinTemplateKind BTK, const IdentifierInfo *II) const
static TypedefDecl * CreateVaListDecl(const ASTContext *Context, TargetInfo::BuiltinVaListKind Kind)
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
void mergeDefinitionIntoModule(NamedDecl *ND, Module *M, bool NotifyListeners=true)
Note that the definition ND has been merged into module M, and should be visible whenever M is visibl...
Definition: ASTContext.cpp:924
bool isNoThrow(unsigned ID) const
Return true if we know this builtin never throws an exception.
Definition: Builtins.h:112
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1378
TypedefNameDecl * getDecl() const
Definition: Type.h:3773
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13010
pack_iterator pack_end() const
Iterator referencing one past the last argument of a template argument pack.
Definition: TemplateBase.h:347
unsigned getFloatAlign() const
Definition: TargetInfo.h:410
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Reading or writing from this object requires a barrier call.
Definition: Type.h:183
ExternCContextDecl * getExternCContextDecl() const
Expr * NoexceptExpr
Noexcept expression, if this is EST_ComputedNoexcept.
Definition: Type.h:3371
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:235
An attributed type is a type to which a type attribute has been applied.
Definition: Type.h:4031
const ObjCPropertyDecl * findPropertyDecl(bool CheckOverrides=true) const
Returns the property associated with this method&#39;s selector.
Definition: DeclObjC.cpp:1261
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
QualType getParamType(unsigned i) const
Definition: Type.h:3491
QualType getTemplateTypeParmType(unsigned Depth, unsigned Index, bool ParameterPack, TemplateTypeParmDecl *ParmDecl=nullptr) const
Retrieve the template type parameter type for a template parameter or parameter pack with the given d...
Represents a type parameter type in Objective C.
Definition: Type.h:5110
bool typesAreCompatible(QualType T1, QualType T2, bool CompareUnqualified=false)
Compatibility predicates used to check assignment expressions.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:989
Defines the clang::SourceLocation class and associated facilities.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4457
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5798
bool hasUnaligned() const
Definition: Type.h:312
bool mergeExtParameterInfo(const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType, bool &CanUseFirst, bool &CanUseSecond, SmallVectorImpl< FunctionProtoType::ExtParameterInfo > &NewParamInfos)
This function merges the ExtParameterInfo lists of two functions.
llvm::DenseMap< const void *, llvm::PointerUnion4< const Decl *, const Stmt *, ast_type_traits::DynTypedNode *, ParentVector * > > ParentMapPointers
Maps from a node to its parents.
Definition: ASTContext.h:554
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
Definition: ASTContext.cpp:966
const CXXMethodDecl * getCurrentKeyFunction(const CXXRecordDecl *RD)
Get our current best idea for the key function of the given record decl, or nullptr if there isn&#39;t on...
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g., it is an signed integer type or a vector.
Definition: Type.cpp:1830
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization, returns the templated static data member from which it was instantiated.
Definition: Decl.cpp:2370
IdentifierInfo * getTypePackElementName() const
Definition: ASTContext.h:1673
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4901
const llvm::fltSemantics & getFloatFormat() const
Definition: TargetInfo.h:411
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:76
ObjCDeclQualifier
ObjCDeclQualifier - &#39;Qualifiers&#39; written next to the return and parameter types in method declaration...
Definition: DeclBase.h:195
Represents a C array with an unspecified size.
Definition: Type.h:2672
VTableContextBase * getVTableContext()
TemplateName getCanonicalTemplateName(TemplateName Name) const
Retrieves the "canonical" template name that refers to a given template.
Missing a type from <stdio.h>
Definition: ASTContext.h:1948
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member...
Definition: Decl.cpp:2140
static TranslationUnitDecl * Create(ASTContext &C)
Definition: Decl.cpp:4114
static void SortAndUniqueProtocols(SmallVectorImpl< ObjCProtocolDecl *> &Protocols)
IdentifierInfo * getMakeIntegerSeqName() const
Definition: ASTContext.h:1667
const ObjCInterfaceDecl * getObjContainingInterface(const NamedDecl *ND) const
Returns the Objective-C interface that ND belongs to if it is an Objective-C method/property/ivar etc...
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5745
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1964
static int compare(DeclarationName LHS, DeclarationName RHS)
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4327
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:607
CanQualType Char16Ty
Definition: ASTContext.h:1002
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that&#39;s ...
A structure for storing the information associated with an overloaded template name.
Definition: TemplateName.h:95
void getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, QualType T, std::string &S, bool Extended) const
getObjCEncodingForMethodParameter - Return the encoded type for a single method parameter or return t...
We searched for a comment attached to the particular declaration, but didn&#39;t find any...
Definition: ASTContext.h:717
static unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
Definition: ASTContext.h:2691
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:539
Weak definition of inline variable.
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
Definition: RecordLayout.h:193
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3816
Declaration of a class template.
Stores a list of Objective-C type parameters for a parameterized class or a category/extension thereo...
Definition: DeclObjC.h:654
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2143
bool isVariadic() const
Definition: DeclObjC.h:454
TypedefDecl * getObjCClassDecl() const
Retrieve the typedef declaration corresponding to the predefined Objective-C &#39;Class&#39; type...
QualType GetBuiltinType(unsigned ID, GetBuiltinTypeError &Error, unsigned *IntegerConstantArgs=nullptr) const
Return the type for the specified builtin.
param_const_iterator sel_param_end() const
Definition: DeclObjC.h:399
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
uint64_t getPointerAlign(unsigned AddrSpace) const
Definition: TargetInfo.h:314
static TypedefDecl * CreateVoidPtrBuiltinVaListDecl(const ASTContext *Context)
Defines the clang::TargetInfo interface.
bool hasSameFunctionTypeIgnoringExceptionSpec(QualType T, QualType U)
Determine whether two function types are the same, ignoring exception specifications in cases where t...
unsigned getSimdDefaultAlign() const
Return default simd alignment for the given target.
Definition: TargetInfo.h:470
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const
QualType getIntegerType() const
getIntegerType - Return the integer type this enum decl corresponds to.
Definition: Decl.h:3364
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1645
unsigned getCVRQualifiers() const
Definition: Type.h:291
Qualifiers::ObjCLifetime getInnerObjCOwnership(QualType T) const
Recurses in pointer/array types until it finds an Objective-C retainable type and returns its ownersh...
SourceLocation getLAngleLoc() const
Definition: TemplateBase.h:562
void adjustExceptionSpec(FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI, bool AsWritten=false)
Change the exception specification on a function once it is delay-parsed, instantiated, or computed.
bool isDocumentation() const LLVM_READONLY
Returns true if this comment any kind of a documentation comment.
const VariableArrayType * getAsVariableArrayType(QualType T) const
Definition: ASTContext.h:2324
uint64_t Width
Definition: ASTContext.h:138
static bool sameObjCTypeArgs(ASTContext &ctx, const ObjCInterfaceDecl *iface, ArrayRef< QualType > lhsArgs, ArrayRef< QualType > rhsArgs, bool stripKindOf)
QualType getjmp_bufType() const
Retrieve the C jmp_buf type.
Definition: ASTContext.h:1705
NameKind getKind() const
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:930
CanQualType IntTy
Definition: ASTContext.h:1004
QualType getSignedWCharType() const
Return the type of "signed wchar_t".
unsigned getNumElements() const
Definition: Type.h:2950
IntType getIntPtrType() const
Definition: TargetInfo.h:254
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:230
static bool NeedsInjectedClassNameType(const RecordDecl *D)
TranslationUnitDecl - The top declaration context.
Definition: Decl.h:107
uint64_t getTargetNullPointerValue(QualType QT) const
Get target-dependent integer value for null pointer which is used for constant folding.
QualType getRealTypeForBitwidth(unsigned DestWidth) const
getRealTypeForBitwidth - sets floating point QualTy according to specified bitwidth.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1858
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:257
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:956
QualType getIntPtrType() const
Return a type compatible with "intptr_t" (C99 7.18.1.4), as defined by the target.
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:2832
bool isUnion() const
Definition: Decl.h:3165
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4493
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:3780
ObjCTypeParamVariance getVariance() const
Determine the variance of this type parameter.
Definition: DeclObjC.h:619
GVALinkage
A more specific kind of linkage than enum Linkage.
Definition: Linkage.h:75
A lazy value (of type T) that is within an AST node of type Owner, where the value might change in la...
bool isPointerType() const
Definition: Type.h:5942
llvm::DenseMap< ast_type_traits::DynTypedNode, llvm::PointerUnion4< const Decl *, const Stmt *, ast_type_traits::DynTypedNode *, ParentVector * > > ParentMapOtherNodes
Parent map for nodes without pointer identity.
Definition: ASTContext.h:562
QualType mergeFunctionParameterTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false)
mergeFunctionParameterTypes - merge two types which appear as function parameter types ...
const DeclInfo * getDeclInfo() const LLVM_READONLY
Definition: Comment.h:1129
void addAddressSpace(LangAS space)
Definition: Type.h:393
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
StringRef Text
Definition: Format.cpp:1346
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
Definition: Decl.cpp:1980
QualType getDependentTemplateSpecializationType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, const IdentifierInfo *Name, const TemplateArgumentListInfo &Args) const
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1126
We can encode up to four bits in the low bits of a type pointer, but there are many more type qualifi...
Definition: Type.h:1239
QualType getType() const
Definition: Decl.h:638
TemplateArgument getArgumentPack() const
Retrieve the template template argument pack with which this parameter was substituted.
A set of overloaded template declarations.
Definition: TemplateName.h:194
unsigned getChar32Align() const
Definition: TargetInfo.h:401
A trivial tuple used to represent a source range.
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1556
ArrayRef< BlockContentComment * > getBlocks() const
Definition: Comment.h:1135
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:75
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:455
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2717
CanQualType BoolTy
Definition: ASTContext.h:997
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1669
void addOverriddenMethod(const CXXMethodDecl *Method, const CXXMethodDecl *Overridden)
Note that the given C++ Method overrides the given Overridden method.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen&#39;ed or deserialized from PCH lazily, only when used; this is onl...
const CXXConstructorDecl * getCopyConstructorForExceptionObject(CXXRecordDecl *RD)
No keyword precedes the qualified type name.
Definition: Type.h:4726
QualType getVariableArrayType(QualType EltTy, Expr *NumElts, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals, SourceRange Brackets) const
Return a non-unique reference to the type for a variable array of the specified element type...
bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS, bool ForCompare)
ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an ObjCQualifiedIDType.
FloatingRank
Definition: ASTContext.cpp:109
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1348
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:5634
CanQualType getIntMaxType() const
Return the unique type for "intmax_t" (C99 7.18.1.5), defined in <stdint.h>.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:281
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2407
bool isPropertyAccessor() const
Definition: DeclObjC.h:459
CanQualType DoubleTy
Definition: ASTContext.h:1007
Selector getGetterName() const
Definition: DeclObjC.h:923
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition: Type.h:4956
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
Definition: ASTContext.h:1987
SourceLocation getRAngleLoc() const
Definition: TemplateBase.h:563
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition: Decl.cpp:3631
void addedLocalImportDecl(ImportDecl *Import)
Notify the AST context that a new import declaration has been parsed or implicitly created within thi...
virtual uint64_t getNullPointerValue(LangAS AddrSpace) const
Get integer value for null pointer.
Definition: TargetInfo.h:325
The global specifier &#39;::&#39;. There is no stored value.
static bool isStructEmpty(QualType Ty)
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
Definition: TemplateBase.h:288
Missing a type from <setjmp.h>
Definition: ASTContext.h:1951
void setType(QualType newType)
Definition: Decl.h:639
void removeAddressSpace()
Definition: Type.h:392
IntType getProcessIDType() const
Definition: TargetInfo.h:267
bool hasInit() const
Definition: Decl.cpp:2115
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
const LangOptions & getLangOpts() const
Definition: ASTContext.h:688
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2518
No in-class initializer.
Definition: Specifiers.h:227
bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const
base_class_range vbases()
Definition: DeclCXX.h:790
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2618
This class handles loading and caching of source files into memory.
The parameter is invariant: must match exactly.
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3393
QualType isPromotableBitField(Expr *E) const
Whether this is a promotable bitfield reference according to C99 6.3.1.1p2, bullet 2 (and GCC extensi...
Defines enum values for all the target-independent builtin functions.
QualType getAdjustedType(QualType Orig, QualType New) const
Return the uniqued reference to a type adjusted from the original type to a new type.
Declaration of a template function.
Definition: DeclTemplate.h:967
const void * getMemoizationData() const
Returns a pointer that identifies the stored AST node.
A class which abstracts out some details necessary for making a call.
Definition: Type.h:3081
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
TemplateName getQualifiedTemplateName(NestedNameSpecifier *NNS, bool TemplateKeyword, TemplateDecl *Template) const
Retrieve the template name that represents a qualified template name such as std::vector.
bool BlockRequiresCopying(QualType Ty, const VarDecl *D)
Returns true iff we need copy/dispose helpers for the given type.
InlineVariableDefinitionKind getInlineVariableDefinitionKind(const VarDecl *VD) const
Determine whether a definition of this inline variable should be treated as a weak or strong definiti...
SourceLocation getLocation() const
Definition: DeclBase.h:416
QualType getPointeeType() const
Definition: Type.h:2522
const RawComment * getRawCommentForAnyRedecl(const Decl *D, const Decl **OriginalDecl=nullptr) const
Return the documentation comment attached to a given declaration.
Definition: ASTContext.cpp:380
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3066
bool isExternallyVisible() const
Definition: Decl.h:370
A full comment attached to a declaration, contains block content.
Definition: Comment.h:1097
APValue * getMaterializedTemporaryValue(const MaterializeTemporaryExpr *E, bool MayCreate)
Get the storage for the constant value of a materialized temporary of static storage duration...
A single template declaration.
Definition: TemplateName.h:191
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4420
CanQualType OCLClkEventTy
Definition: ASTContext.h:1021
bool getByrefLifetime(QualType Ty, Qualifiers::ObjCLifetime &Lifetime, bool &HasByrefExtendedLayout) const
Returns true, if given type has a known lifetime.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.
QualType getComplexType(QualType T) const
Return the uniqued reference to the type for a complex number with the specified element type...
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth, signed/unsigned.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
CanQualType UnsignedIntTy
Definition: ASTContext.h:1005
QualType getIncompleteArrayType(QualType EltTy, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return a unique reference to the type for an incomplete array of the specified element type...
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
bool ParseAllComments
Treat ordinary comments as documentation comments.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1070
static unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
Definition: ASTContext.h:2715
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5456