clang  8.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/FixedPoint.h"
53 #include "clang/Basic/LLVM.h"
55 #include "clang/Basic/Linkage.h"
60 #include "clang/Basic/Specifiers.h"
62 #include "clang/Basic/TargetInfo.h"
63 #include "clang/Basic/XRayLists.h"
64 #include "llvm/ADT/APInt.h"
65 #include "llvm/ADT/APSInt.h"
66 #include "llvm/ADT/ArrayRef.h"
67 #include "llvm/ADT/DenseMap.h"
68 #include "llvm/ADT/DenseSet.h"
69 #include "llvm/ADT/FoldingSet.h"
70 #include "llvm/ADT/None.h"
71 #include "llvm/ADT/Optional.h"
72 #include "llvm/ADT/PointerUnion.h"
73 #include "llvm/ADT/STLExtras.h"
74 #include "llvm/ADT/SmallPtrSet.h"
75 #include "llvm/ADT/SmallVector.h"
76 #include "llvm/ADT/StringExtras.h"
77 #include "llvm/ADT/StringRef.h"
78 #include "llvm/ADT/Triple.h"
79 #include "llvm/Support/Capacity.h"
80 #include "llvm/Support/Casting.h"
81 #include "llvm/Support/Compiler.h"
82 #include "llvm/Support/ErrorHandling.h"
83 #include "llvm/Support/MathExtras.h"
84 #include "llvm/Support/raw_ostream.h"
85 #include <algorithm>
86 #include <cassert>
87 #include <cstddef>
88 #include <cstdint>
89 #include <cstdlib>
90 #include <map>
91 #include <memory>
92 #include <string>
93 #include <tuple>
94 #include <utility>
95 
96 using namespace clang;
97 
110 
113 };
114 
116  if (!CommentsLoaded && ExternalSource) {
117  ExternalSource->ReadComments();
118 
119 #ifndef NDEBUG
121  assert(std::is_sorted(RawComments.begin(), RawComments.end(),
122  BeforeThanCompare<RawComment>(SourceMgr)));
123 #endif
124 
125  CommentsLoaded = true;
126  }
127 
128  assert(D);
129 
130  // User can not attach documentation to implicit declarations.
131  if (D->isImplicit())
132  return nullptr;
133 
134  // User can not attach documentation to implicit instantiations.
135  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
136  if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
137  return nullptr;
138  }
139 
140  if (const auto *VD = dyn_cast<VarDecl>(D)) {
141  if (VD->isStaticDataMember() &&
142  VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
143  return nullptr;
144  }
145 
146  if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
147  if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
148  return nullptr;
149  }
150 
151  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
152  TemplateSpecializationKind TSK = CTSD->getSpecializationKind();
153  if (TSK == TSK_ImplicitInstantiation ||
154  TSK == TSK_Undeclared)
155  return nullptr;
156  }
157 
158  if (const auto *ED = dyn_cast<EnumDecl>(D)) {
159  if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
160  return nullptr;
161  }
162  if (const auto *TD = dyn_cast<TagDecl>(D)) {
163  // When tag declaration (but not definition!) is part of the
164  // decl-specifier-seq of some other declaration, it doesn't get comment
165  if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
166  return nullptr;
167  }
168  // TODO: handle comments for function parameters properly.
169  if (isa<ParmVarDecl>(D))
170  return nullptr;
171 
172  // TODO: we could look up template parameter documentation in the template
173  // documentation.
174  if (isa<TemplateTypeParmDecl>(D) ||
175  isa<NonTypeTemplateParmDecl>(D) ||
176  isa<TemplateTemplateParmDecl>(D))
177  return nullptr;
178 
180 
181  // If there are no comments anywhere, we won't find anything.
182  if (RawComments.empty())
183  return nullptr;
184 
185  // Find declaration location.
186  // For Objective-C declarations we generally don't expect to have multiple
187  // declarators, thus use declaration starting location as the "declaration
188  // location".
189  // For all other declarations multiple declarators are used quite frequently,
190  // so we use the location of the identifier as the "declaration location".
191  SourceLocation DeclLoc;
192  if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) ||
193  isa<ObjCPropertyDecl>(D) ||
194  isa<RedeclarableTemplateDecl>(D) ||
195  isa<ClassTemplateSpecializationDecl>(D))
196  DeclLoc = D->getBeginLoc();
197  else {
198  DeclLoc = D->getLocation();
199  if (DeclLoc.isMacroID()) {
200  if (isa<TypedefDecl>(D)) {
201  // If location of the typedef name is in a macro, it is because being
202  // declared via a macro. Try using declaration's starting location as
203  // the "declaration location".
204  DeclLoc = D->getBeginLoc();
205  } else if (const auto *TD = dyn_cast<TagDecl>(D)) {
206  // If location of the tag decl is inside a macro, but the spelling of
207  // the tag name comes from a macro argument, it looks like a special
208  // macro like NS_ENUM is being used to define the tag decl. In that
209  // case, adjust the source location to the expansion loc so that we can
210  // attach the comment to the tag decl.
211  if (SourceMgr.isMacroArgExpansion(DeclLoc) &&
212  TD->isCompleteDefinition())
213  DeclLoc = SourceMgr.getExpansionLoc(DeclLoc);
214  }
215  }
216  }
217 
218  // If the declaration doesn't map directly to a location in a file, we
219  // can't find the comment.
220  if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
221  return nullptr;
222 
223  // Find the comment that occurs just after this declaration.
225  {
226  // When searching for comments during parsing, the comment we are looking
227  // for is usually among the last two comments we parsed -- check them
228  // first.
229  RawComment CommentAtDeclLoc(
230  SourceMgr, SourceRange(DeclLoc), LangOpts.CommentOpts, false);
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() || LangOpts.CommentOpts.ParseAllComments)
257  && (*Comment)->isTrailingComment() &&
258  (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D) ||
259  isa<ObjCMethodDecl>(D) || isa<ObjCPropertyDecl>(D))) {
260  std::pair<FileID, unsigned> CommentBeginDecomp
261  = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getBegin());
262  // Check that Doxygen trailing comment comes after the declaration, starts
263  // on the same line and in the same file as the declaration.
264  if (DeclLocDecomp.first == CommentBeginDecomp.first &&
265  SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second)
266  == SourceMgr.getLineNumber(CommentBeginDecomp.first,
267  CommentBeginDecomp.second)) {
268  return *Comment;
269  }
270  }
271 
272  // The comment just after the declaration was not a trailing comment.
273  // Let's look at the previous comment.
274  if (Comment == RawComments.begin())
275  return nullptr;
276  --Comment;
277 
278  // Check that we actually have a non-member Doxygen comment.
279  if (!((*Comment)->isDocumentation() ||
280  LangOpts.CommentOpts.ParseAllComments) ||
281  (*Comment)->isTrailingComment())
282  return nullptr;
283 
284  // Decompose the end of the comment.
285  std::pair<FileID, unsigned> CommentEndDecomp
286  = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getEnd());
287 
288  // If the comment and the declaration aren't in the same file, then they
289  // aren't related.
290  if (DeclLocDecomp.first != CommentEndDecomp.first)
291  return nullptr;
292 
293  // Get the corresponding buffer.
294  bool Invalid = false;
295  const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,
296  &Invalid).data();
297  if (Invalid)
298  return nullptr;
299 
300  // Extract text between the comment and declaration.
301  StringRef Text(Buffer + CommentEndDecomp.second,
302  DeclLocDecomp.second - CommentEndDecomp.second);
303 
304  // There should be no other declarations or preprocessor directives between
305  // comment and declaration.
306  if (Text.find_first_of(";{}#@") != StringRef::npos)
307  return nullptr;
308 
309  return *Comment;
310 }
311 
312 /// If we have a 'templated' declaration for a template, adjust 'D' to
313 /// refer to the actual template.
314 /// If we have an implicit instantiation, adjust 'D' to refer to template.
315 static const Decl *adjustDeclToTemplate(const Decl *D) {
316  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
317  // Is this function declaration part of a function template?
318  if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
319  return FTD;
320 
321  // Nothing to do if function is not an implicit instantiation.
322  if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
323  return D;
324 
325  // Function is an implicit instantiation of a function template?
326  if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())
327  return FTD;
328 
329  // Function is instantiated from a member definition of a class template?
330  if (const FunctionDecl *MemberDecl =
332  return MemberDecl;
333 
334  return D;
335  }
336  if (const auto *VD = dyn_cast<VarDecl>(D)) {
337  // Static data member is instantiated from a member definition of a class
338  // template?
339  if (VD->isStaticDataMember())
340  if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember())
341  return MemberDecl;
342 
343  return D;
344  }
345  if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
346  // Is this class declaration part of a class template?
347  if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate())
348  return CTD;
349 
350  // Class is an implicit instantiation of a class template or partial
351  // specialization?
352  if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
353  if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation)
354  return D;
355  llvm::PointerUnion<ClassTemplateDecl *,
357  PU = CTSD->getSpecializedTemplateOrPartial();
358  return PU.is<ClassTemplateDecl*>() ?
359  static_cast<const Decl*>(PU.get<ClassTemplateDecl *>()) :
360  static_cast<const Decl*>(
362  }
363 
364  // Class is instantiated from a member definition of a class template?
365  if (const MemberSpecializationInfo *Info =
366  CRD->getMemberSpecializationInfo())
367  return Info->getInstantiatedFrom();
368 
369  return D;
370  }
371  if (const auto *ED = dyn_cast<EnumDecl>(D)) {
372  // Enum is instantiated from a member definition of a class template?
373  if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum())
374  return MemberDecl;
375 
376  return D;
377  }
378  // FIXME: Adjust alias templates?
379  return D;
380 }
381 
383  const Decl *D,
384  const Decl **OriginalDecl) const {
385  D = adjustDeclToTemplate(D);
386 
387  // Check whether we have cached a comment for this declaration already.
388  {
389  llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
390  RedeclComments.find(D);
391  if (Pos != RedeclComments.end()) {
392  const RawCommentAndCacheFlags &Raw = Pos->second;
394  if (OriginalDecl)
395  *OriginalDecl = Raw.getOriginalDecl();
396  return Raw.getRaw();
397  }
398  }
399  }
400 
401  // Search for comments attached to declarations in the redeclaration chain.
402  const RawComment *RC = nullptr;
403  const Decl *OriginalDeclForRC = nullptr;
404  for (auto I : D->redecls()) {
405  llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
406  RedeclComments.find(I);
407  if (Pos != RedeclComments.end()) {
408  const RawCommentAndCacheFlags &Raw = Pos->second;
410  RC = Raw.getRaw();
411  OriginalDeclForRC = Raw.getOriginalDecl();
412  break;
413  }
414  } else {
416  OriginalDeclForRC = I;
418  if (RC) {
419  // Call order swapped to work around ICE in VS2015 RTM (Release Win32)
420  // https://connect.microsoft.com/VisualStudio/feedback/details/1741530
422  Raw.setRaw(RC);
423  } else
425  Raw.setOriginalDecl(I);
426  RedeclComments[I] = Raw;
427  if (RC)
428  break;
429  }
430  }
431 
432  // If we found a comment, it should be a documentation comment.
433  assert(!RC || RC->isDocumentation() || LangOpts.CommentOpts.ParseAllComments);
434 
435  if (OriginalDecl)
436  *OriginalDecl = OriginalDeclForRC;
437 
438  // Update cache for every declaration in the redeclaration chain.
440  Raw.setRaw(RC);
442  Raw.setOriginalDecl(OriginalDeclForRC);
443 
444  for (auto I : D->redecls()) {
447  R = Raw;
448  }
449 
450  return RC;
451 }
452 
453 static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod,
455  const DeclContext *DC = ObjCMethod->getDeclContext();
456  if (const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {
457  const ObjCInterfaceDecl *ID = IMD->getClassInterface();
458  if (!ID)
459  return;
460  // Add redeclared method here.
461  for (const auto *Ext : ID->known_extensions()) {
462  if (ObjCMethodDecl *RedeclaredMethod =
463  Ext->getMethod(ObjCMethod->getSelector(),
464  ObjCMethod->isInstanceMethod()))
465  Redeclared.push_back(RedeclaredMethod);
466  }
467  }
468 }
469 
471  const Decl *D) const {
472  auto *ThisDeclInfo = new (*this) comments::DeclInfo;
473  ThisDeclInfo->CommentDecl = D;
474  ThisDeclInfo->IsFilled = false;
475  ThisDeclInfo->fill();
476  ThisDeclInfo->CommentDecl = FC->getDecl();
477  if (!ThisDeclInfo->TemplateParameters)
478  ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;
479  comments::FullComment *CFC =
480  new (*this) comments::FullComment(FC->getBlocks(),
481  ThisDeclInfo);
482  return CFC;
483 }
484 
487  return RC ? RC->parse(*this, nullptr, D) : nullptr;
488 }
489 
491  const Decl *D,
492  const Preprocessor *PP) const {
493  if (D->isInvalidDecl())
494  return nullptr;
495  D = adjustDeclToTemplate(D);
496 
497  const Decl *Canonical = D->getCanonicalDecl();
498  llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
499  ParsedComments.find(Canonical);
500 
501  if (Pos != ParsedComments.end()) {
502  if (Canonical != D) {
503  comments::FullComment *FC = Pos->second;
505  return CFC;
506  }
507  return Pos->second;
508  }
509 
510  const Decl *OriginalDecl;
511 
512  const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);
513  if (!RC) {
514  if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
516  const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
517  if (OMD && OMD->isPropertyAccessor())
518  if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
519  if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))
520  return cloneFullComment(FC, D);
521  if (OMD)
522  addRedeclaredMethods(OMD, Overridden);
523  getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden);
524  for (unsigned i = 0, e = Overridden.size(); i < e; i++)
525  if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP))
526  return cloneFullComment(FC, D);
527  }
528  else if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
529  // Attach any tag type's documentation to its typedef if latter
530  // does not have one of its own.
531  QualType QT = TD->getUnderlyingType();
532  if (const auto *TT = QT->getAs<TagType>())
533  if (const Decl *TD = TT->getDecl())
534  if (comments::FullComment *FC = getCommentForDecl(TD, PP))
535  return cloneFullComment(FC, D);
536  }
537  else if (const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
538  while (IC->getSuperClass()) {
539  IC = IC->getSuperClass();
540  if (comments::FullComment *FC = getCommentForDecl(IC, PP))
541  return cloneFullComment(FC, D);
542  }
543  }
544  else if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {
545  if (const ObjCInterfaceDecl *IC = CD->getClassInterface())
546  if (comments::FullComment *FC = getCommentForDecl(IC, PP))
547  return cloneFullComment(FC, D);
548  }
549  else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
550  if (!(RD = RD->getDefinition()))
551  return nullptr;
552  // Check non-virtual bases.
553  for (const auto &I : RD->bases()) {
554  if (I.isVirtual() || (I.getAccessSpecifier() != AS_public))
555  continue;
556  QualType Ty = I.getType();
557  if (Ty.isNull())
558  continue;
559  if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) {
560  if (!(NonVirtualBase= NonVirtualBase->getDefinition()))
561  continue;
562 
563  if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP))
564  return cloneFullComment(FC, D);
565  }
566  }
567  // Check virtual bases.
568  for (const auto &I : RD->vbases()) {
569  if (I.getAccessSpecifier() != AS_public)
570  continue;
571  QualType Ty = I.getType();
572  if (Ty.isNull())
573  continue;
574  if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) {
575  if (!(VirtualBase= VirtualBase->getDefinition()))
576  continue;
577  if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP))
578  return cloneFullComment(FC, D);
579  }
580  }
581  }
582  return nullptr;
583  }
584 
585  // If the RawComment was attached to other redeclaration of this Decl, we
586  // should parse the comment in context of that other Decl. This is important
587  // because comments can contain references to parameter names which can be
588  // different across redeclarations.
589  if (D != OriginalDecl)
590  return getCommentForDecl(OriginalDecl, PP);
591 
592  comments::FullComment *FC = RC->parse(*this, PP, D);
593  ParsedComments[Canonical] = FC;
594  return FC;
595 }
596 
597 void
598 ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
599  TemplateTemplateParmDecl *Parm) {
600  ID.AddInteger(Parm->getDepth());
601  ID.AddInteger(Parm->getPosition());
602  ID.AddBoolean(Parm->isParameterPack());
603 
605  ID.AddInteger(Params->size());
607  PEnd = Params->end();
608  P != PEnd; ++P) {
609  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
610  ID.AddInteger(0);
611  ID.AddBoolean(TTP->isParameterPack());
612  continue;
613  }
614 
615  if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
616  ID.AddInteger(1);
617  ID.AddBoolean(NTTP->isParameterPack());
618  ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
619  if (NTTP->isExpandedParameterPack()) {
620  ID.AddBoolean(true);
621  ID.AddInteger(NTTP->getNumExpansionTypes());
622  for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
623  QualType T = NTTP->getExpansionType(I);
624  ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
625  }
626  } else
627  ID.AddBoolean(false);
628  continue;
629  }
630 
631  auto *TTP = cast<TemplateTemplateParmDecl>(*P);
632  ID.AddInteger(2);
633  Profile(ID, TTP);
634  }
635 }
636 
638 ASTContext::getCanonicalTemplateTemplateParmDecl(
639  TemplateTemplateParmDecl *TTP) const {
640  // Check if we already have a canonical template template parameter.
641  llvm::FoldingSetNodeID ID;
642  CanonicalTemplateTemplateParm::Profile(ID, TTP);
643  void *InsertPos = nullptr;
644  CanonicalTemplateTemplateParm *Canonical
645  = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
646  if (Canonical)
647  return Canonical->getParam();
648 
649  // Build a canonical template parameter list.
651  SmallVector<NamedDecl *, 4> CanonParams;
652  CanonParams.reserve(Params->size());
654  PEnd = Params->end();
655  P != PEnd; ++P) {
656  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P))
657  CanonParams.push_back(
659  SourceLocation(),
660  SourceLocation(),
661  TTP->getDepth(),
662  TTP->getIndex(), nullptr, false,
663  TTP->isParameterPack()));
664  else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
665  QualType T = getCanonicalType(NTTP->getType());
668  if (NTTP->isExpandedParameterPack()) {
669  SmallVector<QualType, 2> ExpandedTypes;
670  SmallVector<TypeSourceInfo *, 2> ExpandedTInfos;
671  for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
672  ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I)));
673  ExpandedTInfos.push_back(
674  getTrivialTypeSourceInfo(ExpandedTypes.back()));
675  }
676 
678  SourceLocation(),
679  SourceLocation(),
680  NTTP->getDepth(),
681  NTTP->getPosition(), nullptr,
682  T,
683  TInfo,
684  ExpandedTypes,
685  ExpandedTInfos);
686  } else {
688  SourceLocation(),
689  SourceLocation(),
690  NTTP->getDepth(),
691  NTTP->getPosition(), nullptr,
692  T,
693  NTTP->isParameterPack(),
694  TInfo);
695  }
696  CanonParams.push_back(Param);
697 
698  } else
699  CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
700  cast<TemplateTemplateParmDecl>(*P)));
701  }
702 
703  assert(!TTP->getRequiresClause() &&
704  "Unexpected requires-clause on template template-parameter");
705  Expr *const CanonRequiresClause = nullptr;
706 
707  TemplateTemplateParmDecl *CanonTTP
709  SourceLocation(), TTP->getDepth(),
710  TTP->getPosition(),
711  TTP->isParameterPack(),
712  nullptr,
714  SourceLocation(),
715  CanonParams,
716  SourceLocation(),
717  CanonRequiresClause));
718 
719  // Get the new insert position for the node we care about.
720  Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
721  assert(!Canonical && "Shouldn't be in the map!");
722  (void)Canonical;
723 
724  // Create the canonical template template parameter entry.
725  Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);
726  CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
727  return CanonTTP;
728 }
729 
730 CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
731  if (!LangOpts.CPlusPlus) return nullptr;
732 
733  switch (T.getCXXABI().getKind()) {
734  case TargetCXXABI::GenericARM: // Same as Itanium at this level
735  case TargetCXXABI::iOS:
736  case TargetCXXABI::iOS64:
742  return CreateItaniumCXXABI(*this);
744  return CreateMicrosoftCXXABI(*this);
745  }
746  llvm_unreachable("Invalid CXXABI type!");
747 }
748 
749 static const LangASMap *getAddressSpaceMap(const TargetInfo &T,
750  const LangOptions &LOpts) {
751  if (LOpts.FakeAddressSpaceMap) {
752  // The fake address space map must have a distinct entry for each
753  // language-specific address space.
754  static const unsigned FakeAddrSpaceMap[] = {
755  0, // Default
756  1, // opencl_global
757  3, // opencl_local
758  2, // opencl_constant
759  0, // opencl_private
760  4, // opencl_generic
761  5, // cuda_device
762  6, // cuda_constant
763  7 // cuda_shared
764  };
765  return &FakeAddrSpaceMap;
766  } else {
767  return &T.getAddressSpaceMap();
768  }
769 }
770 
772  const LangOptions &LangOpts) {
773  switch (LangOpts.getAddressSpaceMapMangling()) {
775  return TI.useAddressSpaceMapMangling();
777  return true;
779  return false;
780  }
781  llvm_unreachable("getAddressSpaceMapMangling() doesn't cover anything.");
782 }
783 
785  IdentifierTable &idents, SelectorTable &sels,
786  Builtin::Context &builtins)
787  : FunctionProtoTypes(this_()), TemplateSpecializationTypes(this_()),
788  DependentTemplateSpecializationTypes(this_()),
789  SubstTemplateTemplateParmPacks(this_()), SourceMgr(SM), LangOpts(LOpts),
790  SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
791  XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
792  LangOpts.XRayNeverInstrumentFiles,
793  LangOpts.XRayAttrListFiles, SM)),
794  PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
795  BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
796  CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
797  CompCategories(this_()), LastSDM(nullptr, 0) {
798  TUDecl = TranslationUnitDecl::Create(*this);
799  TraversalScope = {TUDecl};
800 }
801 
803  // Release the DenseMaps associated with DeclContext objects.
804  // FIXME: Is this the ideal solution?
805  ReleaseDeclContextMaps();
806 
807  // Call all of the deallocation functions on all of their targets.
808  for (auto &Pair : Deallocations)
809  (Pair.first)(Pair.second);
810 
811  // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed
812  // because they can contain DenseMaps.
813  for (llvm::DenseMap<const ObjCContainerDecl*,
814  const ASTRecordLayout*>::iterator
815  I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
816  // Increment in loop to prevent using deallocated memory.
817  if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
818  R->Destroy(*this);
819 
820  for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
821  I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
822  // Increment in loop to prevent using deallocated memory.
823  if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
824  R->Destroy(*this);
825  }
826 
827  for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
828  AEnd = DeclAttrs.end();
829  A != AEnd; ++A)
830  A->second->~AttrVec();
831 
832  for (std::pair<const MaterializeTemporaryExpr *, APValue *> &MTVPair :
833  MaterializedTemporaryValues)
834  MTVPair.second->~APValue();
835 
836  for (const auto &Value : ModuleInitializers)
837  Value.second->~PerModuleInitializers();
838 }
839 
841  /// Contains parents of a node.
843 
844  /// Maps from a node to its parents. This is used for nodes that have
845  /// pointer identity only, which are more common and we can save space by
846  /// only storing a unique pointer to them.
847  using ParentMapPointers = llvm::DenseMap<
848  const void *,
849  llvm::PointerUnion4<const Decl *, const Stmt *,
851 
852  /// Parent map for nodes without pointer identity. We store a full
853  /// DynTypedNode for all keys.
854  using ParentMapOtherNodes = llvm::DenseMap<
856  llvm::PointerUnion4<const Decl *, const Stmt *,
857  ast_type_traits::DynTypedNode *, ParentVector *>>;
858 
859  ParentMapPointers PointerParents;
860  ParentMapOtherNodes OtherParents;
861  class ASTVisitor;
862 
863  static ast_type_traits::DynTypedNode
864  getSingleDynTypedNodeFromParentMap(ParentMapPointers::mapped_type U) {
865  if (const auto *D = U.dyn_cast<const Decl *>())
867  if (const auto *S = U.dyn_cast<const Stmt *>())
869  return *U.get<ast_type_traits::DynTypedNode *>();
870  }
871 
872  template <typename NodeTy, typename MapTy>
873  static ASTContext::DynTypedNodeList getDynNodeFromMap(const NodeTy &Node,
874  const MapTy &Map) {
875  auto I = Map.find(Node);
876  if (I == Map.end()) {
878  }
879  if (const auto *V = I->second.template dyn_cast<ParentVector *>()) {
880  return llvm::makeArrayRef(*V);
881  }
882  return getSingleDynTypedNodeFromParentMap(I->second);
883  }
884 
885 public:
886  ParentMap(ASTContext &Ctx);
888  for (const auto &Entry : PointerParents) {
889  if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
890  delete Entry.second.get<ast_type_traits::DynTypedNode *>();
891  } else if (Entry.second.is<ParentVector *>()) {
892  delete Entry.second.get<ParentVector *>();
893  }
894  }
895  for (const auto &Entry : OtherParents) {
896  if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
897  delete Entry.second.get<ast_type_traits::DynTypedNode *>();
898  } else if (Entry.second.is<ParentVector *>()) {
899  delete Entry.second.get<ParentVector *>();
900  }
901  }
902  }
903 
904  DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node) {
905  if (Node.getNodeKind().hasPointerIdentity())
906  return getDynNodeFromMap(Node.getMemoizationData(), PointerParents);
907  return getDynNodeFromMap(Node, OtherParents);
908  }
909 };
910 
911 void ASTContext::setTraversalScope(const std::vector<Decl *> &TopLevelDecls) {
912  TraversalScope = TopLevelDecls;
913  Parents.reset();
914 }
915 
916 void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) {
917  Deallocations.push_back({Callback, Data});
918 }
919 
920 void
922  ExternalSource = std::move(Source);
923 }
924 
926  llvm::errs() << "\n*** AST Context Stats:\n";
927  llvm::errs() << " " << Types.size() << " types total.\n";
928 
929  unsigned counts[] = {
930 #define TYPE(Name, Parent) 0,
931 #define ABSTRACT_TYPE(Name, Parent)
932 #include "clang/AST/TypeNodes.def"
933  0 // Extra
934  };
935 
936  for (unsigned i = 0, e = Types.size(); i != e; ++i) {
937  Type *T = Types[i];
938  counts[(unsigned)T->getTypeClass()]++;
939  }
940 
941  unsigned Idx = 0;
942  unsigned TotalBytes = 0;
943 #define TYPE(Name, Parent) \
944  if (counts[Idx]) \
945  llvm::errs() << " " << counts[Idx] << " " << #Name \
946  << " types, " << sizeof(Name##Type) << " each " \
947  << "(" << counts[Idx] * sizeof(Name##Type) \
948  << " bytes)\n"; \
949  TotalBytes += counts[Idx] * sizeof(Name##Type); \
950  ++Idx;
951 #define ABSTRACT_TYPE(Name, Parent)
952 #include "clang/AST/TypeNodes.def"
953 
954  llvm::errs() << "Total bytes = " << TotalBytes << "\n";
955 
956  // Implicit special member functions.
957  llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/"
959  << " implicit default constructors created\n";
960  llvm::errs() << NumImplicitCopyConstructorsDeclared << "/"
962  << " implicit copy constructors created\n";
963  if (getLangOpts().CPlusPlus)
964  llvm::errs() << NumImplicitMoveConstructorsDeclared << "/"
966  << " implicit move constructors created\n";
967  llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/"
969  << " implicit copy assignment operators created\n";
970  if (getLangOpts().CPlusPlus)
971  llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/"
973  << " implicit move assignment operators created\n";
974  llvm::errs() << NumImplicitDestructorsDeclared << "/"
976  << " implicit destructors created\n";
977 
978  if (ExternalSource) {
979  llvm::errs() << "\n";
980  ExternalSource->PrintStats();
981  }
982 
983  BumpAlloc.PrintStats();
984 }
985 
987  bool NotifyListeners) {
988  if (NotifyListeners)
989  if (auto *Listener = getASTMutationListener())
991 
992  MergedDefModules[cast<NamedDecl>(ND->getCanonicalDecl())].push_back(M);
993 }
994 
996  auto It = MergedDefModules.find(cast<NamedDecl>(ND->getCanonicalDecl()));
997  if (It == MergedDefModules.end())
998  return;
999 
1000  auto &Merged = It->second;
1002  for (Module *&M : Merged)
1003  if (!Found.insert(M).second)
1004  M = nullptr;
1005  Merged.erase(std::remove(Merged.begin(), Merged.end(), nullptr), Merged.end());
1006 }
1007 
1008 void ASTContext::PerModuleInitializers::resolve(ASTContext &Ctx) {
1009  if (LazyInitializers.empty())
1010  return;
1011 
1012  auto *Source = Ctx.getExternalSource();
1013  assert(Source && "lazy initializers but no external source");
1014 
1015  auto LazyInits = std::move(LazyInitializers);
1016  LazyInitializers.clear();
1017 
1018  for (auto ID : LazyInits)
1019  Initializers.push_back(Source->GetExternalDecl(ID));
1020 
1021  assert(LazyInitializers.empty() &&
1022  "GetExternalDecl for lazy module initializer added more inits");
1023 }
1024 
1026  // One special case: if we add a module initializer that imports another
1027  // module, and that module's only initializer is an ImportDecl, simplify.
1028  if (const auto *ID = dyn_cast<ImportDecl>(D)) {
1029  auto It = ModuleInitializers.find(ID->getImportedModule());
1030 
1031  // Maybe the ImportDecl does nothing at all. (Common case.)
1032  if (It == ModuleInitializers.end())
1033  return;
1034 
1035  // Maybe the ImportDecl only imports another ImportDecl.
1036  auto &Imported = *It->second;
1037  if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
1038  Imported.resolve(*this);
1039  auto *OnlyDecl = Imported.Initializers.front();
1040  if (isa<ImportDecl>(OnlyDecl))
1041  D = OnlyDecl;
1042  }
1043  }
1044 
1045  auto *&Inits = ModuleInitializers[M];
1046  if (!Inits)
1047  Inits = new (*this) PerModuleInitializers;
1048  Inits->Initializers.push_back(D);
1049 }
1050 
1052  auto *&Inits = ModuleInitializers[M];
1053  if (!Inits)
1054  Inits = new (*this) PerModuleInitializers;
1055  Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
1056  IDs.begin(), IDs.end());
1057 }
1058 
1060  auto It = ModuleInitializers.find(M);
1061  if (It == ModuleInitializers.end())
1062  return None;
1063 
1064  auto *Inits = It->second;
1065  Inits->resolve(*this);
1066  return Inits->Initializers;
1067 }
1068 
1070  if (!ExternCContext)
1071  ExternCContext = ExternCContextDecl::Create(*this, getTranslationUnitDecl());
1072 
1073  return ExternCContext;
1074 }
1075 
1078  const IdentifierInfo *II) const {
1079  auto *BuiltinTemplate = BuiltinTemplateDecl::Create(*this, TUDecl, II, BTK);
1080  BuiltinTemplate->setImplicit();
1081  TUDecl->addDecl(BuiltinTemplate);
1082 
1083  return BuiltinTemplate;
1084 }
1085 
1088  if (!MakeIntegerSeqDecl)
1089  MakeIntegerSeqDecl = buildBuiltinTemplateDecl(BTK__make_integer_seq,
1091  return MakeIntegerSeqDecl;
1092 }
1093 
1096  if (!TypePackElementDecl)
1097  TypePackElementDecl = buildBuiltinTemplateDecl(BTK__type_pack_element,
1099  return TypePackElementDecl;
1100 }
1101 
1103  RecordDecl::TagKind TK) const {
1104  SourceLocation Loc;
1105  RecordDecl *NewDecl;
1106  if (getLangOpts().CPlusPlus)
1107  NewDecl = CXXRecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc,
1108  Loc, &Idents.get(Name));
1109  else
1110  NewDecl = RecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc, Loc,
1111  &Idents.get(Name));
1112  NewDecl->setImplicit();
1113  NewDecl->addAttr(TypeVisibilityAttr::CreateImplicit(
1114  const_cast<ASTContext &>(*this), TypeVisibilityAttr::Default));
1115  return NewDecl;
1116 }
1117 
1119  StringRef Name) const {
1121  TypedefDecl *NewDecl = TypedefDecl::Create(
1122  const_cast<ASTContext &>(*this), getTranslationUnitDecl(),
1123  SourceLocation(), SourceLocation(), &Idents.get(Name), TInfo);
1124  NewDecl->setImplicit();
1125  return NewDecl;
1126 }
1127 
1129  if (!Int128Decl)
1130  Int128Decl = buildImplicitTypedef(Int128Ty, "__int128_t");
1131  return Int128Decl;
1132 }
1133 
1135  if (!UInt128Decl)
1136  UInt128Decl = buildImplicitTypedef(UnsignedInt128Ty, "__uint128_t");
1137  return UInt128Decl;
1138 }
1139 
1140 void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
1141  auto *Ty = new (*this, TypeAlignment) BuiltinType(K);
1142  R = CanQualType::CreateUnsafe(QualType(Ty, 0));
1143  Types.push_back(Ty);
1144 }
1145 
1147  const TargetInfo *AuxTarget) {
1148  assert((!this->Target || this->Target == &Target) &&
1149  "Incorrect target reinitialization");
1150  assert(VoidTy.isNull() && "Context reinitialized?");
1151 
1152  this->Target = &Target;
1153  this->AuxTarget = AuxTarget;
1154 
1155  ABI.reset(createCXXABI(Target));
1156  AddrSpaceMap = getAddressSpaceMap(Target, LangOpts);
1157  AddrSpaceMapMangling = isAddrSpaceMapManglingEnabled(Target, LangOpts);
1158 
1159  // C99 6.2.5p19.
1160  InitBuiltinType(VoidTy, BuiltinType::Void);
1161 
1162  // C99 6.2.5p2.
1163  InitBuiltinType(BoolTy, BuiltinType::Bool);
1164  // C99 6.2.5p3.
1165  if (LangOpts.CharIsSigned)
1166  InitBuiltinType(CharTy, BuiltinType::Char_S);
1167  else
1168  InitBuiltinType(CharTy, BuiltinType::Char_U);
1169  // C99 6.2.5p4.
1170  InitBuiltinType(SignedCharTy, BuiltinType::SChar);
1171  InitBuiltinType(ShortTy, BuiltinType::Short);
1172  InitBuiltinType(IntTy, BuiltinType::Int);
1173  InitBuiltinType(LongTy, BuiltinType::Long);
1174  InitBuiltinType(LongLongTy, BuiltinType::LongLong);
1175 
1176  // C99 6.2.5p6.
1177  InitBuiltinType(UnsignedCharTy, BuiltinType::UChar);
1178  InitBuiltinType(UnsignedShortTy, BuiltinType::UShort);
1179  InitBuiltinType(UnsignedIntTy, BuiltinType::UInt);
1180  InitBuiltinType(UnsignedLongTy, BuiltinType::ULong);
1181  InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong);
1182 
1183  // C99 6.2.5p10.
1184  InitBuiltinType(FloatTy, BuiltinType::Float);
1185  InitBuiltinType(DoubleTy, BuiltinType::Double);
1186  InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble);
1187 
1188  // GNU extension, __float128 for IEEE quadruple precision
1189  InitBuiltinType(Float128Ty, BuiltinType::Float128);
1190 
1191  // C11 extension ISO/IEC TS 18661-3
1192  InitBuiltinType(Float16Ty, BuiltinType::Float16);
1193 
1194  // ISO/IEC JTC1 SC22 WG14 N1169 Extension
1195  InitBuiltinType(ShortAccumTy, BuiltinType::ShortAccum);
1196  InitBuiltinType(AccumTy, BuiltinType::Accum);
1197  InitBuiltinType(LongAccumTy, BuiltinType::LongAccum);
1198  InitBuiltinType(UnsignedShortAccumTy, BuiltinType::UShortAccum);
1199  InitBuiltinType(UnsignedAccumTy, BuiltinType::UAccum);
1200  InitBuiltinType(UnsignedLongAccumTy, BuiltinType::ULongAccum);
1201  InitBuiltinType(ShortFractTy, BuiltinType::ShortFract);
1202  InitBuiltinType(FractTy, BuiltinType::Fract);
1203  InitBuiltinType(LongFractTy, BuiltinType::LongFract);
1204  InitBuiltinType(UnsignedShortFractTy, BuiltinType::UShortFract);
1205  InitBuiltinType(UnsignedFractTy, BuiltinType::UFract);
1206  InitBuiltinType(UnsignedLongFractTy, BuiltinType::ULongFract);
1207  InitBuiltinType(SatShortAccumTy, BuiltinType::SatShortAccum);
1208  InitBuiltinType(SatAccumTy, BuiltinType::SatAccum);
1209  InitBuiltinType(SatLongAccumTy, BuiltinType::SatLongAccum);
1210  InitBuiltinType(SatUnsignedShortAccumTy, BuiltinType::SatUShortAccum);
1211  InitBuiltinType(SatUnsignedAccumTy, BuiltinType::SatUAccum);
1212  InitBuiltinType(SatUnsignedLongAccumTy, BuiltinType::SatULongAccum);
1213  InitBuiltinType(SatShortFractTy, BuiltinType::SatShortFract);
1214  InitBuiltinType(SatFractTy, BuiltinType::SatFract);
1215  InitBuiltinType(SatLongFractTy, BuiltinType::SatLongFract);
1216  InitBuiltinType(SatUnsignedShortFractTy, BuiltinType::SatUShortFract);
1217  InitBuiltinType(SatUnsignedFractTy, BuiltinType::SatUFract);
1218  InitBuiltinType(SatUnsignedLongFractTy, BuiltinType::SatULongFract);
1219 
1220  // GNU extension, 128-bit integers.
1221  InitBuiltinType(Int128Ty, BuiltinType::Int128);
1222  InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128);
1223 
1224  // C++ 3.9.1p5
1225  if (TargetInfo::isTypeSigned(Target.getWCharType()))
1226  InitBuiltinType(WCharTy, BuiltinType::WChar_S);
1227  else // -fshort-wchar makes wchar_t be unsigned.
1228  InitBuiltinType(WCharTy, BuiltinType::WChar_U);
1229  if (LangOpts.CPlusPlus && LangOpts.WChar)
1230  WideCharTy = WCharTy;
1231  else {
1232  // C99 (or C++ using -fno-wchar).
1233  WideCharTy = getFromTargetType(Target.getWCharType());
1234  }
1235 
1236  WIntTy = getFromTargetType(Target.getWIntType());
1237 
1238  // C++20 (proposed)
1239  InitBuiltinType(Char8Ty, BuiltinType::Char8);
1240 
1241  if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
1242  InitBuiltinType(Char16Ty, BuiltinType::Char16);
1243  else // C99
1244  Char16Ty = getFromTargetType(Target.getChar16Type());
1245 
1246  if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
1247  InitBuiltinType(Char32Ty, BuiltinType::Char32);
1248  else // C99
1249  Char32Ty = getFromTargetType(Target.getChar32Type());
1250 
1251  // Placeholder type for type-dependent expressions whose type is
1252  // completely unknown. No code should ever check a type against
1253  // DependentTy and users should never see it; however, it is here to
1254  // help diagnose failures to properly check for type-dependent
1255  // expressions.
1256  InitBuiltinType(DependentTy, BuiltinType::Dependent);
1257 
1258  // Placeholder type for functions.
1259  InitBuiltinType(OverloadTy, BuiltinType::Overload);
1260 
1261  // Placeholder type for bound members.
1262  InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember);
1263 
1264  // Placeholder type for pseudo-objects.
1265  InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject);
1266 
1267  // "any" type; useful for debugger-like clients.
1268  InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny);
1269 
1270  // Placeholder type for unbridged ARC casts.
1271  InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast);
1272 
1273  // Placeholder type for builtin functions.
1274  InitBuiltinType(BuiltinFnTy, BuiltinType::BuiltinFn);
1275 
1276  // Placeholder type for OMP array sections.
1277  if (LangOpts.OpenMP)
1278  InitBuiltinType(OMPArraySectionTy, BuiltinType::OMPArraySection);
1279 
1280  // C99 6.2.5p11.
1285 
1286  // Builtin types for 'id', 'Class', and 'SEL'.
1287  InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
1288  InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
1289  InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);
1290 
1291  if (LangOpts.OpenCL) {
1292 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1293  InitBuiltinType(SingletonId, BuiltinType::Id);
1294 #include "clang/Basic/OpenCLImageTypes.def"
1295 
1296  InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler);
1297  InitBuiltinType(OCLEventTy, BuiltinType::OCLEvent);
1298  InitBuiltinType(OCLClkEventTy, BuiltinType::OCLClkEvent);
1299  InitBuiltinType(OCLQueueTy, BuiltinType::OCLQueue);
1300  InitBuiltinType(OCLReserveIDTy, BuiltinType::OCLReserveID);
1301 
1302 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1303  InitBuiltinType(Id##Ty, BuiltinType::Id);
1304 #include "clang/Basic/OpenCLExtensionTypes.def"
1305  }
1306 
1307  // Builtin type for __objc_yes and __objc_no
1308  ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ?
1309  SignedCharTy : BoolTy);
1310 
1311  ObjCConstantStringType = QualType();
1312 
1313  ObjCSuperType = QualType();
1314 
1315  // void * type
1316  if (LangOpts.OpenCLVersion >= 200) {
1317  auto Q = VoidTy.getQualifiers();
1321  } else {
1323  }
1324 
1325  // nullptr type (C++0x 2.14.7)
1326  InitBuiltinType(NullPtrTy, BuiltinType::NullPtr);
1327 
1328  // half type (OpenCL 6.1.1.1) / ARM NEON __fp16
1329  InitBuiltinType(HalfTy, BuiltinType::Half);
1330 
1331  // Builtin type used to help define __builtin_va_list.
1332  VaListTagDecl = nullptr;
1333 }
1334 
1336  return SourceMgr.getDiagnostics();
1337 }
1338 
1340  AttrVec *&Result = DeclAttrs[D];
1341  if (!Result) {
1342  void *Mem = Allocate(sizeof(AttrVec));
1343  Result = new (Mem) AttrVec;
1344  }
1345 
1346  return *Result;
1347 }
1348 
1349 /// Erase the attributes corresponding to the given declaration.
1351  llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
1352  if (Pos != DeclAttrs.end()) {
1353  Pos->second->~AttrVec();
1354  DeclAttrs.erase(Pos);
1355  }
1356 }
1357 
1358 // FIXME: Remove ?
1361  assert(Var->isStaticDataMember() && "Not a static data member");
1363  .dyn_cast<MemberSpecializationInfo *>();
1364 }
1365 
1368  llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
1369  TemplateOrInstantiation.find(Var);
1370  if (Pos == TemplateOrInstantiation.end())
1371  return {};
1372 
1373  return Pos->second;
1374 }
1375 
1376 void
1379  SourceLocation PointOfInstantiation) {
1380  assert(Inst->isStaticDataMember() && "Not a static data member");
1381  assert(Tmpl->isStaticDataMember() && "Not a static data member");
1383  Tmpl, TSK, PointOfInstantiation));
1384 }
1385 
1386 void
1389  assert(!TemplateOrInstantiation[Inst] &&
1390  "Already noted what the variable was instantiated from");
1391  TemplateOrInstantiation[Inst] = TSI;
1392 }
1393 
1395  const FunctionDecl *FD){
1396  assert(FD && "Specialization is 0");
1397  llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos
1398  = ClassScopeSpecializationPattern.find(FD);
1399  if (Pos == ClassScopeSpecializationPattern.end())
1400  return nullptr;
1401 
1402  return Pos->second;
1403 }
1404 
1406  FunctionDecl *Pattern) {
1407  assert(FD && "Specialization is 0");
1408  assert(Pattern && "Class scope specialization pattern is 0");
1409  ClassScopeSpecializationPattern[FD] = Pattern;
1410 }
1411 
1412 NamedDecl *
1414  auto Pos = InstantiatedFromUsingDecl.find(UUD);
1415  if (Pos == InstantiatedFromUsingDecl.end())
1416  return nullptr;
1417 
1418  return Pos->second;
1419 }
1420 
1421 void
1423  assert((isa<UsingDecl>(Pattern) ||
1424  isa<UnresolvedUsingValueDecl>(Pattern) ||
1425  isa<UnresolvedUsingTypenameDecl>(Pattern)) &&
1426  "pattern decl is not a using decl");
1427  assert((isa<UsingDecl>(Inst) ||
1428  isa<UnresolvedUsingValueDecl>(Inst) ||
1429  isa<UnresolvedUsingTypenameDecl>(Inst)) &&
1430  "instantiation did not produce a using decl");
1431  assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists");
1432  InstantiatedFromUsingDecl[Inst] = Pattern;
1433 }
1434 
1437  llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
1438  = InstantiatedFromUsingShadowDecl.find(Inst);
1439  if (Pos == InstantiatedFromUsingShadowDecl.end())
1440  return nullptr;
1441 
1442  return Pos->second;
1443 }
1444 
1445 void
1447  UsingShadowDecl *Pattern) {
1448  assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists");
1449  InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1450 }
1451 
1453  llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
1454  = InstantiatedFromUnnamedFieldDecl.find(Field);
1455  if (Pos == InstantiatedFromUnnamedFieldDecl.end())
1456  return nullptr;
1457 
1458  return Pos->second;
1459 }
1460 
1462  FieldDecl *Tmpl) {
1463  assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed");
1464  assert(!Tmpl->getDeclName() && "Template field decl is not unnamed");
1465  assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&
1466  "Already noted what unnamed field was instantiated from");
1467 
1468  InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1469 }
1470 
1473  return overridden_methods(Method).begin();
1474 }
1475 
1478  return overridden_methods(Method).end();
1479 }
1480 
1481 unsigned
1483  auto Range = overridden_methods(Method);
1484  return Range.end() - Range.begin();
1485 }
1486 
1489  llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
1490  OverriddenMethods.find(Method->getCanonicalDecl());
1491  if (Pos == OverriddenMethods.end())
1492  return overridden_method_range(nullptr, nullptr);
1493  return overridden_method_range(Pos->second.begin(), Pos->second.end());
1494 }
1495 
1497  const CXXMethodDecl *Overridden) {
1498  assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl());
1499  OverriddenMethods[Method].push_back(Overridden);
1500 }
1501 
1503  const NamedDecl *D,
1504  SmallVectorImpl<const NamedDecl *> &Overridden) const {
1505  assert(D);
1506 
1507  if (const auto *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
1508  Overridden.append(overridden_methods_begin(CXXMethod),
1509  overridden_methods_end(CXXMethod));
1510  return;
1511  }
1512 
1513  const auto *Method = dyn_cast<ObjCMethodDecl>(D);
1514  if (!Method)
1515  return;
1516 
1518  Method->getOverriddenMethods(OverDecls);
1519  Overridden.append(OverDecls.begin(), OverDecls.end());
1520 }
1521 
1523  assert(!Import->NextLocalImport && "Import declaration already in the chain");
1524  assert(!Import->isFromASTFile() && "Non-local import declaration");
1525  if (!FirstLocalImport) {
1526  FirstLocalImport = Import;
1527  LastLocalImport = Import;
1528  return;
1529  }
1530 
1531  LastLocalImport->NextLocalImport = Import;
1532  LastLocalImport = Import;
1533 }
1534 
1535 //===----------------------------------------------------------------------===//
1536 // Type Sizing and Analysis
1537 //===----------------------------------------------------------------------===//
1538 
1539 /// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
1540 /// scalar floating point type.
1541 const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
1542  const auto *BT = T->getAs<BuiltinType>();
1543  assert(BT && "Not a floating point type!");
1544  switch (BT->getKind()) {
1545  default: llvm_unreachable("Not a floating point type!");
1546  case BuiltinType::Float16:
1547  case BuiltinType::Half:
1548  return Target->getHalfFormat();
1549  case BuiltinType::Float: return Target->getFloatFormat();
1550  case BuiltinType::Double: return Target->getDoubleFormat();
1551  case BuiltinType::LongDouble: return Target->getLongDoubleFormat();
1552  case BuiltinType::Float128: return Target->getFloat128Format();
1553  }
1554 }
1555 
1556 CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
1557  unsigned Align = Target->getCharWidth();
1558 
1559  bool UseAlignAttrOnly = false;
1560  if (unsigned AlignFromAttr = D->getMaxAlignment()) {
1561  Align = AlignFromAttr;
1562 
1563  // __attribute__((aligned)) can increase or decrease alignment
1564  // *except* on a struct or struct member, where it only increases
1565  // alignment unless 'packed' is also specified.
1566  //
1567  // It is an error for alignas to decrease alignment, so we can
1568  // ignore that possibility; Sema should diagnose it.
1569  if (isa<FieldDecl>(D)) {
1570  UseAlignAttrOnly = D->hasAttr<PackedAttr>() ||
1571  cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1572  } else {
1573  UseAlignAttrOnly = true;
1574  }
1575  }
1576  else if (isa<FieldDecl>(D))
1577  UseAlignAttrOnly =
1578  D->hasAttr<PackedAttr>() ||
1579  cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1580 
1581  // If we're using the align attribute only, just ignore everything
1582  // else about the declaration and its type.
1583  if (UseAlignAttrOnly) {
1584  // do nothing
1585  } else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
1586  QualType T = VD->getType();
1587  if (const auto *RT = T->getAs<ReferenceType>()) {
1588  if (ForAlignof)
1589  T = RT->getPointeeType();
1590  else
1591  T = getPointerType(RT->getPointeeType());
1592  }
1593  QualType BaseT = getBaseElementType(T);
1594  if (T->isFunctionType())
1595  Align = getTypeInfoImpl(T.getTypePtr()).Align;
1596  else if (!BaseT->isIncompleteType()) {
1597  // Adjust alignments of declarations with array type by the
1598  // large-array alignment on the target.
1599  if (const ArrayType *arrayType = getAsArrayType(T)) {
1600  unsigned MinWidth = Target->getLargeArrayMinWidth();
1601  if (!ForAlignof && MinWidth) {
1602  if (isa<VariableArrayType>(arrayType))
1603  Align = std::max(Align, Target->getLargeArrayAlign());
1604  else if (isa<ConstantArrayType>(arrayType) &&
1605  MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType)))
1606  Align = std::max(Align, Target->getLargeArrayAlign());
1607  }
1608  }
1609  Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
1610  if (BaseT.getQualifiers().hasUnaligned())
1611  Align = Target->getCharWidth();
1612  if (const auto *VD = dyn_cast<VarDecl>(D)) {
1613  if (VD->hasGlobalStorage() && !ForAlignof)
1614  Align = std::max(Align, getTargetInfo().getMinGlobalAlign());
1615  }
1616  }
1617 
1618  // Fields can be subject to extra alignment constraints, like if
1619  // the field is packed, the struct is packed, or the struct has a
1620  // a max-field-alignment constraint (#pragma pack). So calculate
1621  // the actual alignment of the field within the struct, and then
1622  // (as we're expected to) constrain that by the alignment of the type.
1623  if (const auto *Field = dyn_cast<FieldDecl>(VD)) {
1624  const RecordDecl *Parent = Field->getParent();
1625  // We can only produce a sensible answer if the record is valid.
1626  if (!Parent->isInvalidDecl()) {
1627  const ASTRecordLayout &Layout = getASTRecordLayout(Parent);
1628 
1629  // Start with the record's overall alignment.
1630  unsigned FieldAlign = toBits(Layout.getAlignment());
1631 
1632  // Use the GCD of that and the offset within the record.
1633  uint64_t Offset = Layout.getFieldOffset(Field->getFieldIndex());
1634  if (Offset > 0) {
1635  // Alignment is always a power of 2, so the GCD will be a power of 2,
1636  // which means we get to do this crazy thing instead of Euclid's.
1637  uint64_t LowBitOfOffset = Offset & (~Offset + 1);
1638  if (LowBitOfOffset < FieldAlign)
1639  FieldAlign = static_cast<unsigned>(LowBitOfOffset);
1640  }
1641 
1642  Align = std::min(Align, FieldAlign);
1643  }
1644  }
1645  }
1646 
1647  return toCharUnitsFromBits(Align);
1648 }
1649 
1650 // getTypeInfoDataSizeInChars - Return the size of a type, in
1651 // chars. If the type is a record, its data size is returned. This is
1652 // the size of the memcpy that's performed when assigning this type
1653 // using a trivial copy/move assignment operator.
1654 std::pair<CharUnits, CharUnits>
1656  std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T);
1657 
1658  // In C++, objects can sometimes be allocated into the tail padding
1659  // of a base-class subobject. We decide whether that's possible
1660  // during class layout, so here we can just trust the layout results.
1661  if (getLangOpts().CPlusPlus) {
1662  if (const auto *RT = T->getAs<RecordType>()) {
1663  const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl());
1664  sizeAndAlign.first = layout.getDataSize();
1665  }
1666  }
1667 
1668  return sizeAndAlign;
1669 }
1670 
1671 /// getConstantArrayInfoInChars - Performing the computation in CharUnits
1672 /// instead of in bits prevents overflowing the uint64_t for some large arrays.
1673 std::pair<CharUnits, CharUnits>
1675  const ConstantArrayType *CAT) {
1676  std::pair<CharUnits, CharUnits> EltInfo =
1677  Context.getTypeInfoInChars(CAT->getElementType());
1678  uint64_t Size = CAT->getSize().getZExtValue();
1679  assert((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <=
1680  (uint64_t)(-1)/Size) &&
1681  "Overflow in array type char size evaluation");
1682  uint64_t Width = EltInfo.first.getQuantity() * Size;
1683  unsigned Align = EltInfo.second.getQuantity();
1684  if (!Context.getTargetInfo().getCXXABI().isMicrosoft() ||
1685  Context.getTargetInfo().getPointerWidth(0) == 64)
1686  Width = llvm::alignTo(Width, Align);
1687  return std::make_pair(CharUnits::fromQuantity(Width),
1688  CharUnits::fromQuantity(Align));
1689 }
1690 
1691 std::pair<CharUnits, CharUnits>
1693  if (const auto *CAT = dyn_cast<ConstantArrayType>(T))
1694  return getConstantArrayInfoInChars(*this, CAT);
1695  TypeInfo Info = getTypeInfo(T);
1696  return std::make_pair(toCharUnitsFromBits(Info.Width),
1697  toCharUnitsFromBits(Info.Align));
1698 }
1699 
1700 std::pair<CharUnits, CharUnits>
1702  return getTypeInfoInChars(T.getTypePtr());
1703 }
1704 
1706  return getTypeInfo(T).AlignIsRequired;
1707 }
1708 
1710  return isAlignmentRequired(T.getTypePtr());
1711 }
1712 
1714  // An alignment on a typedef overrides anything else.
1715  if (const auto *TT = T->getAs<TypedefType>())
1716  if (unsigned Align = TT->getDecl()->getMaxAlignment())
1717  return Align;
1718 
1719  // If we have an (array of) complete type, we're done.
1720  T = getBaseElementType(T);
1721  if (!T->isIncompleteType())
1722  return getTypeAlign(T);
1723 
1724  // If we had an array type, its element type might be a typedef
1725  // type with an alignment attribute.
1726  if (const auto *TT = T->getAs<TypedefType>())
1727  if (unsigned Align = TT->getDecl()->getMaxAlignment())
1728  return Align;
1729 
1730  // Otherwise, see if the declaration of the type had an attribute.
1731  if (const auto *TT = T->getAs<TagType>())
1732  return TT->getDecl()->getMaxAlignment();
1733 
1734  return 0;
1735 }
1736 
1738  TypeInfoMap::iterator I = MemoizedTypeInfo.find(T);
1739  if (I != MemoizedTypeInfo.end())
1740  return I->second;
1741 
1742  // This call can invalidate MemoizedTypeInfo[T], so we need a second lookup.
1743  TypeInfo TI = getTypeInfoImpl(T);
1744  MemoizedTypeInfo[T] = TI;
1745  return TI;
1746 }
1747 
1748 /// getTypeInfoImpl - Return the size of the specified type, in bits. This
1749 /// method does not work on incomplete types.
1750 ///
1751 /// FIXME: Pointers into different addr spaces could have different sizes and
1752 /// alignment requirements: getPointerInfo should take an AddrSpace, this
1753 /// should take a QualType, &c.
1754 TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
1755  uint64_t Width = 0;
1756  unsigned Align = 8;
1757  bool AlignIsRequired = false;
1758  unsigned AS = 0;
1759  switch (T->getTypeClass()) {
1760 #define TYPE(Class, Base)
1761 #define ABSTRACT_TYPE(Class, Base)
1762 #define NON_CANONICAL_TYPE(Class, Base)
1763 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
1764 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \
1765  case Type::Class: \
1766  assert(!T->isDependentType() && "should not see dependent types here"); \
1767  return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
1768 #include "clang/AST/TypeNodes.def"
1769  llvm_unreachable("Should not see dependent types");
1770 
1771  case Type::FunctionNoProto:
1772  case Type::FunctionProto:
1773  // GCC extension: alignof(function) = 32 bits
1774  Width = 0;
1775  Align = 32;
1776  break;
1777 
1778  case Type::IncompleteArray:
1779  case Type::VariableArray:
1780  Width = 0;
1781  Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
1782  break;
1783 
1784  case Type::ConstantArray: {
1785  const auto *CAT = cast<ConstantArrayType>(T);
1786 
1787  TypeInfo EltInfo = getTypeInfo(CAT->getElementType());
1788  uint64_t Size = CAT->getSize().getZExtValue();
1789  assert((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&
1790  "Overflow in array type bit size evaluation");
1791  Width = EltInfo.Width * Size;
1792  Align = EltInfo.Align;
1793  if (!getTargetInfo().getCXXABI().isMicrosoft() ||
1794  getTargetInfo().getPointerWidth(0) == 64)
1795  Width = llvm::alignTo(Width, Align);
1796  break;
1797  }
1798  case Type::ExtVector:
1799  case Type::Vector: {
1800  const auto *VT = cast<VectorType>(T);
1801  TypeInfo EltInfo = getTypeInfo(VT->getElementType());
1802  Width = EltInfo.Width * VT->getNumElements();
1803  Align = Width;
1804  // If the alignment is not a power of 2, round up to the next power of 2.
1805  // This happens for non-power-of-2 length vectors.
1806  if (Align & (Align-1)) {
1807  Align = llvm::NextPowerOf2(Align);
1808  Width = llvm::alignTo(Width, Align);
1809  }
1810  // Adjust the alignment based on the target max.
1811  uint64_t TargetVectorAlign = Target->getMaxVectorAlign();
1812  if (TargetVectorAlign && TargetVectorAlign < Align)
1813  Align = TargetVectorAlign;
1814  break;
1815  }
1816 
1817  case Type::Builtin:
1818  switch (cast<BuiltinType>(T)->getKind()) {
1819  default: llvm_unreachable("Unknown builtin type!");
1820  case BuiltinType::Void:
1821  // GCC extension: alignof(void) = 8 bits.
1822  Width = 0;
1823  Align = 8;
1824  break;
1825  case BuiltinType::Bool:
1826  Width = Target->getBoolWidth();
1827  Align = Target->getBoolAlign();
1828  break;
1829  case BuiltinType::Char_S:
1830  case BuiltinType::Char_U:
1831  case BuiltinType::UChar:
1832  case BuiltinType::SChar:
1833  case BuiltinType::Char8:
1834  Width = Target->getCharWidth();
1835  Align = Target->getCharAlign();
1836  break;
1837  case BuiltinType::WChar_S:
1838  case BuiltinType::WChar_U:
1839  Width = Target->getWCharWidth();
1840  Align = Target->getWCharAlign();
1841  break;
1842  case BuiltinType::Char16:
1843  Width = Target->getChar16Width();
1844  Align = Target->getChar16Align();
1845  break;
1846  case BuiltinType::Char32:
1847  Width = Target->getChar32Width();
1848  Align = Target->getChar32Align();
1849  break;
1850  case BuiltinType::UShort:
1851  case BuiltinType::Short:
1852  Width = Target->getShortWidth();
1853  Align = Target->getShortAlign();
1854  break;
1855  case BuiltinType::UInt:
1856  case BuiltinType::Int:
1857  Width = Target->getIntWidth();
1858  Align = Target->getIntAlign();
1859  break;
1860  case BuiltinType::ULong:
1861  case BuiltinType::Long:
1862  Width = Target->getLongWidth();
1863  Align = Target->getLongAlign();
1864  break;
1865  case BuiltinType::ULongLong:
1866  case BuiltinType::LongLong:
1867  Width = Target->getLongLongWidth();
1868  Align = Target->getLongLongAlign();
1869  break;
1870  case BuiltinType::Int128:
1871  case BuiltinType::UInt128:
1872  Width = 128;
1873  Align = 128; // int128_t is 128-bit aligned on all targets.
1874  break;
1875  case BuiltinType::ShortAccum:
1876  case BuiltinType::UShortAccum:
1877  case BuiltinType::SatShortAccum:
1878  case BuiltinType::SatUShortAccum:
1879  Width = Target->getShortAccumWidth();
1880  Align = Target->getShortAccumAlign();
1881  break;
1882  case BuiltinType::Accum:
1883  case BuiltinType::UAccum:
1884  case BuiltinType::SatAccum:
1885  case BuiltinType::SatUAccum:
1886  Width = Target->getAccumWidth();
1887  Align = Target->getAccumAlign();
1888  break;
1889  case BuiltinType::LongAccum:
1890  case BuiltinType::ULongAccum:
1891  case BuiltinType::SatLongAccum:
1892  case BuiltinType::SatULongAccum:
1893  Width = Target->getLongAccumWidth();
1894  Align = Target->getLongAccumAlign();
1895  break;
1896  case BuiltinType::ShortFract:
1897  case BuiltinType::UShortFract:
1898  case BuiltinType::SatShortFract:
1899  case BuiltinType::SatUShortFract:
1900  Width = Target->getShortFractWidth();
1901  Align = Target->getShortFractAlign();
1902  break;
1903  case BuiltinType::Fract:
1904  case BuiltinType::UFract:
1905  case BuiltinType::SatFract:
1906  case BuiltinType::SatUFract:
1907  Width = Target->getFractWidth();
1908  Align = Target->getFractAlign();
1909  break;
1910  case BuiltinType::LongFract:
1911  case BuiltinType::ULongFract:
1912  case BuiltinType::SatLongFract:
1913  case BuiltinType::SatULongFract:
1914  Width = Target->getLongFractWidth();
1915  Align = Target->getLongFractAlign();
1916  break;
1917  case BuiltinType::Float16:
1918  case BuiltinType::Half:
1919  Width = Target->getHalfWidth();
1920  Align = Target->getHalfAlign();
1921  break;
1922  case BuiltinType::Float:
1923  Width = Target->getFloatWidth();
1924  Align = Target->getFloatAlign();
1925  break;
1926  case BuiltinType::Double:
1927  Width = Target->getDoubleWidth();
1928  Align = Target->getDoubleAlign();
1929  break;
1930  case BuiltinType::LongDouble:
1931  Width = Target->getLongDoubleWidth();
1932  Align = Target->getLongDoubleAlign();
1933  break;
1934  case BuiltinType::Float128:
1935  Width = Target->getFloat128Width();
1936  Align = Target->getFloat128Align();
1937  break;
1938  case BuiltinType::NullPtr:
1939  Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
1940  Align = Target->getPointerAlign(0); // == sizeof(void*)
1941  break;
1942  case BuiltinType::ObjCId:
1943  case BuiltinType::ObjCClass:
1944  case BuiltinType::ObjCSel:
1945  Width = Target->getPointerWidth(0);
1946  Align = Target->getPointerAlign(0);
1947  break;
1948  case BuiltinType::OCLSampler:
1949  case BuiltinType::OCLEvent:
1950  case BuiltinType::OCLClkEvent:
1951  case BuiltinType::OCLQueue:
1952  case BuiltinType::OCLReserveID:
1953 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1954  case BuiltinType::Id:
1955 #include "clang/Basic/OpenCLImageTypes.def"
1956 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
1957  case BuiltinType::Id:
1958 #include "clang/Basic/OpenCLExtensionTypes.def"
1959  AS = getTargetAddressSpace(
1960  Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T)));
1961  Width = Target->getPointerWidth(AS);
1962  Align = Target->getPointerAlign(AS);
1963  break;
1964  }
1965  break;
1966  case Type::ObjCObjectPointer:
1967  Width = Target->getPointerWidth(0);
1968  Align = Target->getPointerAlign(0);
1969  break;
1970  case Type::BlockPointer:
1971  AS = getTargetAddressSpace(cast<BlockPointerType>(T)->getPointeeType());
1972  Width = Target->getPointerWidth(AS);
1973  Align = Target->getPointerAlign(AS);
1974  break;
1975  case Type::LValueReference:
1976  case Type::RValueReference:
1977  // alignof and sizeof should never enter this code path here, so we go
1978  // the pointer route.
1979  AS = getTargetAddressSpace(cast<ReferenceType>(T)->getPointeeType());
1980  Width = Target->getPointerWidth(AS);
1981  Align = Target->getPointerAlign(AS);
1982  break;
1983  case Type::Pointer:
1984  AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType());
1985  Width = Target->getPointerWidth(AS);
1986  Align = Target->getPointerAlign(AS);
1987  break;
1988  case Type::MemberPointer: {
1989  const auto *MPT = cast<MemberPointerType>(T);
1990  CXXABI::MemberPointerInfo MPI = ABI->getMemberPointerInfo(MPT);
1991  Width = MPI.Width;
1992  Align = MPI.Align;
1993  break;
1994  }
1995  case Type::Complex: {
1996  // Complex types have the same alignment as their elements, but twice the
1997  // size.
1998  TypeInfo EltInfo = getTypeInfo(cast<ComplexType>(T)->getElementType());
1999  Width = EltInfo.Width * 2;
2000  Align = EltInfo.Align;
2001  break;
2002  }
2003  case Type::ObjCObject:
2004  return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr());
2005  case Type::Adjusted:
2006  case Type::Decayed:
2007  return getTypeInfo(cast<AdjustedType>(T)->getAdjustedType().getTypePtr());
2008  case Type::ObjCInterface: {
2009  const auto *ObjCI = cast<ObjCInterfaceType>(T);
2010  const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
2011  Width = toBits(Layout.getSize());
2012  Align = toBits(Layout.getAlignment());
2013  break;
2014  }
2015  case Type::Record:
2016  case Type::Enum: {
2017  const auto *TT = cast<TagType>(T);
2018 
2019  if (TT->getDecl()->isInvalidDecl()) {
2020  Width = 8;
2021  Align = 8;
2022  break;
2023  }
2024 
2025  if (const auto *ET = dyn_cast<EnumType>(TT)) {
2026  const EnumDecl *ED = ET->getDecl();
2027  TypeInfo Info =
2029  if (unsigned AttrAlign = ED->getMaxAlignment()) {
2030  Info.Align = AttrAlign;
2031  Info.AlignIsRequired = true;
2032  }
2033  return Info;
2034  }
2035 
2036  const auto *RT = cast<RecordType>(TT);
2037  const RecordDecl *RD = RT->getDecl();
2038  const ASTRecordLayout &Layout = getASTRecordLayout(RD);
2039  Width = toBits(Layout.getSize());
2040  Align = toBits(Layout.getAlignment());
2041  AlignIsRequired = RD->hasAttr<AlignedAttr>();
2042  break;
2043  }
2044 
2045  case Type::SubstTemplateTypeParm:
2046  return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
2047  getReplacementType().getTypePtr());
2048 
2049  case Type::Auto:
2050  case Type::DeducedTemplateSpecialization: {
2051  const auto *A = cast<DeducedType>(T);
2052  assert(!A->getDeducedType().isNull() &&
2053  "cannot request the size of an undeduced or dependent auto type");
2054  return getTypeInfo(A->getDeducedType().getTypePtr());
2055  }
2056 
2057  case Type::Paren:
2058  return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr());
2059 
2060  case Type::ObjCTypeParam:
2061  return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr());
2062 
2063  case Type::Typedef: {
2064  const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl();
2065  TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
2066  // If the typedef has an aligned attribute on it, it overrides any computed
2067  // alignment we have. This violates the GCC documentation (which says that
2068  // attribute(aligned) can only round up) but matches its implementation.
2069  if (unsigned AttrAlign = Typedef->getMaxAlignment()) {
2070  Align = AttrAlign;
2071  AlignIsRequired = true;
2072  } else {
2073  Align = Info.Align;
2074  AlignIsRequired = Info.AlignIsRequired;
2075  }
2076  Width = Info.Width;
2077  break;
2078  }
2079 
2080  case Type::Elaborated:
2081  return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr());
2082 
2083  case Type::Attributed:
2084  return getTypeInfo(
2085  cast<AttributedType>(T)->getEquivalentType().getTypePtr());
2086 
2087  case Type::Atomic: {
2088  // Start with the base type information.
2089  TypeInfo Info = getTypeInfo(cast<AtomicType>(T)->getValueType());
2090  Width = Info.Width;
2091  Align = Info.Align;
2092 
2093  if (!Width) {
2094  // An otherwise zero-sized type should still generate an
2095  // atomic operation.
2096  Width = Target->getCharWidth();
2097  assert(Align);
2098  } else if (Width <= Target->getMaxAtomicPromoteWidth()) {
2099  // If the size of the type doesn't exceed the platform's max
2100  // atomic promotion width, make the size and alignment more
2101  // favorable to atomic operations:
2102 
2103  // Round the size up to a power of 2.
2104  if (!llvm::isPowerOf2_64(Width))
2105  Width = llvm::NextPowerOf2(Width);
2106 
2107  // Set the alignment equal to the size.
2108  Align = static_cast<unsigned>(Width);
2109  }
2110  }
2111  break;
2112 
2113  case Type::Pipe:
2114  Width = Target->getPointerWidth(getTargetAddressSpace(LangAS::opencl_global));
2115  Align = Target->getPointerAlign(getTargetAddressSpace(LangAS::opencl_global));
2116  break;
2117  }
2118 
2119  assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2");
2120  return TypeInfo(Width, Align, AlignIsRequired);
2121 }
2122 
2123 unsigned ASTContext::getTypeUnadjustedAlign(const Type *T) const {
2124  UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(T);
2125  if (I != MemoizedUnadjustedAlign.end())
2126  return I->second;
2127 
2128  unsigned UnadjustedAlign;
2129  if (const auto *RT = T->getAs<RecordType>()) {
2130  const RecordDecl *RD = RT->getDecl();
2131  const ASTRecordLayout &Layout = getASTRecordLayout(RD);
2132  UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
2133  } else if (const auto *ObjCI = T->getAs<ObjCInterfaceType>()) {
2134  const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
2135  UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
2136  } else {
2137  UnadjustedAlign = getTypeAlign(T);
2138  }
2139 
2140  MemoizedUnadjustedAlign[T] = UnadjustedAlign;
2141  return UnadjustedAlign;
2142 }
2143 
2145  unsigned SimdAlign = getTargetInfo().getSimdDefaultAlign();
2146  // Target ppc64 with QPX: simd default alignment for pointer to double is 32.
2147  if ((getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64 ||
2148  getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64le) &&
2149  getTargetInfo().getABI() == "elfv1-qpx" &&
2150  T->isSpecificBuiltinType(BuiltinType::Double))
2151  SimdAlign = 256;
2152  return SimdAlign;
2153 }
2154 
2155 /// toCharUnitsFromBits - Convert a size in bits to a size in characters.
2157  return CharUnits::fromQuantity(BitSize / getCharWidth());
2158 }
2159 
2160 /// toBits - Convert a size in characters to a size in characters.
2161 int64_t ASTContext::toBits(CharUnits CharSize) const {
2162  return CharSize.getQuantity() * getCharWidth();
2163 }
2164 
2165 /// getTypeSizeInChars - Return the size of the specified type, in characters.
2166 /// This method does not work on incomplete types.
2168  return getTypeInfoInChars(T).first;
2169 }
2171  return getTypeInfoInChars(T).first;
2172 }
2173 
2174 /// getTypeAlignInChars - Return the ABI-specified alignment of a type, in
2175 /// characters. This method does not work on incomplete types.
2177  return toCharUnitsFromBits(getTypeAlign(T));
2178 }
2180  return toCharUnitsFromBits(getTypeAlign(T));
2181 }
2182 
2183 /// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a
2184 /// type, in characters, before alignment adustments. This method does
2185 /// not work on incomplete types.
2188 }
2191 }
2192 
2193 /// getPreferredTypeAlign - Return the "preferred" alignment of the specified
2194 /// type for the current target in bits. This can be different than the ABI
2195 /// alignment in cases where it is beneficial for performance to overalign
2196 /// a data type.
2197 unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
2198  TypeInfo TI = getTypeInfo(T);
2199  unsigned ABIAlign = TI.Align;
2200 
2201  T = T->getBaseElementTypeUnsafe();
2202 
2203  // The preferred alignment of member pointers is that of a pointer.
2204  if (T->isMemberPointerType())
2206 
2207  if (!Target->allowsLargerPreferedTypeAlignment())
2208  return ABIAlign;
2209 
2210  // Double and long long should be naturally aligned if possible.
2211  if (const auto *CT = T->getAs<ComplexType>())
2212  T = CT->getElementType().getTypePtr();
2213  if (const auto *ET = T->getAs<EnumType>())
2214  T = ET->getDecl()->getIntegerType().getTypePtr();
2215  if (T->isSpecificBuiltinType(BuiltinType::Double) ||
2216  T->isSpecificBuiltinType(BuiltinType::LongLong) ||
2217  T->isSpecificBuiltinType(BuiltinType::ULongLong))
2218  // Don't increase the alignment if an alignment attribute was specified on a
2219  // typedef declaration.
2220  if (!TI.AlignIsRequired)
2221  return std::max(ABIAlign, (unsigned)getTypeSize(T));
2222 
2223  return ABIAlign;
2224 }
2225 
2226 /// getTargetDefaultAlignForAttributeAligned - Return the default alignment
2227 /// for __attribute__((aligned)) on this target, to be used if no alignment
2228 /// value is specified.
2231 }
2232 
2233 /// getAlignOfGlobalVar - Return the alignment in bits that should be given
2234 /// to a global variable of the specified type.
2236  return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign());
2237 }
2238 
2239 /// getAlignOfGlobalVarInChars - Return the alignment in characters that
2240 /// should be given to a global variable of the specified type.
2243 }
2244 
2247  const ASTRecordLayout *Layout = &getASTRecordLayout(RD);
2248  while (const CXXRecordDecl *Base = Layout->getBaseSharingVBPtr()) {
2249  Offset += Layout->getBaseClassOffset(Base);
2250  Layout = &getASTRecordLayout(Base);
2251  }
2252  return Offset;
2253 }
2254 
2255 /// DeepCollectObjCIvars -
2256 /// This routine first collects all declared, but not synthesized, ivars in
2257 /// super class and then collects all ivars, including those synthesized for
2258 /// current class. This routine is used for implementation of current class
2259 /// when all ivars, declared and synthesized are known.
2261  bool leafClass,
2262  SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const {
2263  if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
2264  DeepCollectObjCIvars(SuperClass, false, Ivars);
2265  if (!leafClass) {
2266  for (const auto *I : OI->ivars())
2267  Ivars.push_back(I);
2268  } else {
2269  auto *IDecl = const_cast<ObjCInterfaceDecl *>(OI);
2270  for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
2271  Iv= Iv->getNextIvar())
2272  Ivars.push_back(Iv);
2273  }
2274 }
2275 
2276 /// CollectInheritedProtocols - Collect all protocols in current class and
2277 /// those inherited by it.
2279  llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
2280  if (const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2281  // We can use protocol_iterator here instead of
2282  // all_referenced_protocol_iterator since we are walking all categories.
2283  for (auto *Proto : OI->all_referenced_protocols()) {
2284  CollectInheritedProtocols(Proto, Protocols);
2285  }
2286 
2287  // Categories of this Interface.
2288  for (const auto *Cat : OI->visible_categories())
2289  CollectInheritedProtocols(Cat, Protocols);
2290 
2291  if (ObjCInterfaceDecl *SD = OI->getSuperClass())
2292  while (SD) {
2293  CollectInheritedProtocols(SD, Protocols);
2294  SD = SD->getSuperClass();
2295  }
2296  } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2297  for (auto *Proto : OC->protocols()) {
2298  CollectInheritedProtocols(Proto, Protocols);
2299  }
2300  } else if (const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
2301  // Insert the protocol.
2302  if (!Protocols.insert(
2303  const_cast<ObjCProtocolDecl *>(OP->getCanonicalDecl())).second)
2304  return;
2305 
2306  for (auto *Proto : OP->protocols())
2307  CollectInheritedProtocols(Proto, Protocols);
2308  }
2309 }
2310 
2312  const RecordDecl *RD) {
2313  assert(RD->isUnion() && "Must be union type");
2314  CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());
2315 
2316  for (const auto *Field : RD->fields()) {
2317  if (!Context.hasUniqueObjectRepresentations(Field->getType()))
2318  return false;
2319  CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
2320  if (FieldSize != UnionSize)
2321  return false;
2322  }
2323  return !RD->field_empty();
2324 }
2325 
2326 static bool isStructEmpty(QualType Ty) {
2327  const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();
2328 
2329  if (!RD->field_empty())
2330  return false;
2331 
2332  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD))
2333  return ClassDecl->isEmpty();
2334 
2335  return true;
2336 }
2337 
2340  const RecordDecl *RD) {
2341  assert(!RD->isUnion() && "Must be struct/class type");
2342  const auto &Layout = Context.getASTRecordLayout(RD);
2343 
2344  int64_t CurOffsetInBits = 0;
2345  if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2346  if (ClassDecl->isDynamicClass())
2347  return llvm::None;
2348 
2350  for (const auto Base : ClassDecl->bases()) {
2351  // Empty types can be inherited from, and non-empty types can potentially
2352  // have tail padding, so just make sure there isn't an error.
2353  if (!isStructEmpty(Base.getType())) {
2355  Context, Base.getType()->getAs<RecordType>()->getDecl());
2356  if (!Size)
2357  return llvm::None;
2358  Bases.emplace_back(Base.getType(), Size.getValue());
2359  }
2360  }
2361 
2362  llvm::sort(Bases, [&](const std::pair<QualType, int64_t> &L,
2363  const std::pair<QualType, int64_t> &R) {
2364  return Layout.getBaseClassOffset(L.first->getAsCXXRecordDecl()) <
2365  Layout.getBaseClassOffset(R.first->getAsCXXRecordDecl());
2366  });
2367 
2368  for (const auto Base : Bases) {
2369  int64_t BaseOffset = Context.toBits(
2370  Layout.getBaseClassOffset(Base.first->getAsCXXRecordDecl()));
2371  int64_t BaseSize = Base.second;
2372  if (BaseOffset != CurOffsetInBits)
2373  return llvm::None;
2374  CurOffsetInBits = BaseOffset + BaseSize;
2375  }
2376  }
2377 
2378  for (const auto *Field : RD->fields()) {
2379  if (!Field->getType()->isReferenceType() &&
2380  !Context.hasUniqueObjectRepresentations(Field->getType()))
2381  return llvm::None;
2382 
2383  int64_t FieldSizeInBits =
2384  Context.toBits(Context.getTypeSizeInChars(Field->getType()));
2385  if (Field->isBitField()) {
2386  int64_t BitfieldSize = Field->getBitWidthValue(Context);
2387 
2388  if (BitfieldSize > FieldSizeInBits)
2389  return llvm::None;
2390  FieldSizeInBits = BitfieldSize;
2391  }
2392 
2393  int64_t FieldOffsetInBits = Context.getFieldOffset(Field);
2394 
2395  if (FieldOffsetInBits != CurOffsetInBits)
2396  return llvm::None;
2397 
2398  CurOffsetInBits = FieldSizeInBits + FieldOffsetInBits;
2399  }
2400 
2401  return CurOffsetInBits;
2402 }
2403 
2405  // C++17 [meta.unary.prop]:
2406  // The predicate condition for a template specialization
2407  // has_unique_object_representations<T> shall be
2408  // satisfied if and only if:
2409  // (9.1) - T is trivially copyable, and
2410  // (9.2) - any two objects of type T with the same value have the same
2411  // object representation, where two objects
2412  // of array or non-union class type are considered to have the same value
2413  // if their respective sequences of
2414  // direct subobjects have the same values, and two objects of union type
2415  // are considered to have the same
2416  // value if they have the same active member and the corresponding members
2417  // have the same value.
2418  // The set of scalar types for which this condition holds is
2419  // implementation-defined. [ Note: If a type has padding
2420  // bits, the condition does not hold; otherwise, the condition holds true
2421  // for unsigned integral types. -- end note ]
2422  assert(!Ty.isNull() && "Null QualType sent to unique object rep check");
2423 
2424  // Arrays are unique only if their element type is unique.
2425  if (Ty->isArrayType())
2427 
2428  // (9.1) - T is trivially copyable...
2429  if (!Ty.isTriviallyCopyableType(*this))
2430  return false;
2431 
2432  // All integrals and enums are unique.
2433  if (Ty->isIntegralOrEnumerationType())
2434  return true;
2435 
2436  // All other pointers are unique.
2437  if (Ty->isPointerType())
2438  return true;
2439 
2440  if (Ty->isMemberPointerType()) {
2441  const auto *MPT = Ty->getAs<MemberPointerType>();
2442  return !ABI->getMemberPointerInfo(MPT).HasPadding;
2443  }
2444 
2445  if (Ty->isRecordType()) {
2446  const RecordDecl *Record = Ty->getAs<RecordType>()->getDecl();
2447 
2448  if (Record->isInvalidDecl())
2449  return false;
2450 
2451  if (Record->isUnion())
2452  return unionHasUniqueObjectRepresentations(*this, Record);
2453 
2454  Optional<int64_t> StructSize =
2455  structHasUniqueObjectRepresentations(*this, Record);
2456 
2457  return StructSize &&
2458  StructSize.getValue() == static_cast<int64_t>(getTypeSize(Ty));
2459  }
2460 
2461  // FIXME: More cases to handle here (list by rsmith):
2462  // vectors (careful about, eg, vector of 3 foo)
2463  // _Complex int and friends
2464  // _Atomic T
2465  // Obj-C block pointers
2466  // Obj-C object pointers
2467  // and perhaps OpenCL's various builtin types (pipe, sampler_t, event_t,
2468  // clk_event_t, queue_t, reserve_id_t)
2469  // There're also Obj-C class types and the Obj-C selector type, but I think it
2470  // makes sense for those to return false here.
2471 
2472  return false;
2473 }
2474 
2476  unsigned count = 0;
2477  // Count ivars declared in class extension.
2478  for (const auto *Ext : OI->known_extensions())
2479  count += Ext->ivar_size();
2480 
2481  // Count ivar defined in this class's implementation. This
2482  // includes synthesized ivars.
2483  if (ObjCImplementationDecl *ImplDecl = OI->getImplementation())
2484  count += ImplDecl->ivar_size();
2485 
2486  return count;
2487 }
2488 
2490  if (!E)
2491  return false;
2492 
2493  // nullptr_t is always treated as null.
2494  if (E->getType()->isNullPtrType()) return true;
2495 
2496  if (E->getType()->isAnyPointerType() &&
2499  return true;
2500 
2501  // Unfortunately, __null has type 'int'.
2502  if (isa<GNUNullExpr>(E)) return true;
2503 
2504  return false;
2505 }
2506 
2507 /// Get the implementation of ObjCInterfaceDecl, or nullptr if none
2508 /// exists.
2510  llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2511  I = ObjCImpls.find(D);
2512  if (I != ObjCImpls.end())
2513  return cast<ObjCImplementationDecl>(I->second);
2514  return nullptr;
2515 }
2516 
2517 /// Get the implementation of ObjCCategoryDecl, or nullptr if none
2518 /// exists.
2520  llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2521  I = ObjCImpls.find(D);
2522  if (I != ObjCImpls.end())
2523  return cast<ObjCCategoryImplDecl>(I->second);
2524  return nullptr;
2525 }
2526 
2527 /// Set the implementation of ObjCInterfaceDecl.
2529  ObjCImplementationDecl *ImplD) {
2530  assert(IFaceD && ImplD && "Passed null params");
2531  ObjCImpls[IFaceD] = ImplD;
2532 }
2533 
2534 /// Set the implementation of ObjCCategoryDecl.
2536  ObjCCategoryImplDecl *ImplD) {
2537  assert(CatD && ImplD && "Passed null params");
2538  ObjCImpls[CatD] = ImplD;
2539 }
2540 
2541 const ObjCMethodDecl *
2543  return ObjCMethodRedecls.lookup(MD);
2544 }
2545 
2547  const ObjCMethodDecl *Redecl) {
2548  assert(!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration");
2549  ObjCMethodRedecls[MD] = Redecl;
2550 }
2551 
2553  const NamedDecl *ND) const {
2554  if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext()))
2555  return ID;
2556  if (const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext()))
2557  return CD->getClassInterface();
2558  if (const auto *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext()))
2559  return IMD->getClassInterface();
2560 
2561  return nullptr;
2562 }
2563 
2564 /// Get the copy initialization expression of VarDecl, or nullptr if
2565 /// none exists.
2568  assert(VD && "Passed null params");
2569  assert(VD->hasAttr<BlocksAttr>() &&
2570  "getBlockVarCopyInits - not __block var");
2571  auto I = BlockVarCopyInits.find(VD);
2572  if (I != BlockVarCopyInits.end())
2573  return I->second;
2574  return {nullptr, false};
2575 }
2576 
2577 /// Set the copy inialization expression of a block var decl.
2579  bool CanThrow) {
2580  assert(VD && CopyExpr && "Passed null params");
2581  assert(VD->hasAttr<BlocksAttr>() &&
2582  "setBlockVarCopyInits - not __block var");
2583  BlockVarCopyInits[VD].setExprAndFlag(CopyExpr, CanThrow);
2584 }
2585 
2587  unsigned DataSize) const {
2588  if (!DataSize)
2589  DataSize = TypeLoc::getFullDataSizeForType(T);
2590  else
2591  assert(DataSize == TypeLoc::getFullDataSizeForType(T) &&
2592  "incorrect data size provided to CreateTypeSourceInfo!");
2593 
2594  auto *TInfo =
2595  (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
2596  new (TInfo) TypeSourceInfo(T);
2597  return TInfo;
2598 }
2599 
2601  SourceLocation L) const {
2603  DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L);
2604  return DI;
2605 }
2606 
2607 const ASTRecordLayout &
2609  return getObjCLayout(D, nullptr);
2610 }
2611 
2612 const ASTRecordLayout &
2614  const ObjCImplementationDecl *D) const {
2615  return getObjCLayout(D->getClassInterface(), D);
2616 }
2617 
2618 //===----------------------------------------------------------------------===//
2619 // Type creation/memoization methods
2620 //===----------------------------------------------------------------------===//
2621 
2622 QualType
2623 ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
2624  unsigned fastQuals = quals.getFastQualifiers();
2625  quals.removeFastQualifiers();
2626 
2627  // Check if we've already instantiated this type.
2628  llvm::FoldingSetNodeID ID;
2629  ExtQuals::Profile(ID, baseType, quals);
2630  void *insertPos = nullptr;
2631  if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
2632  assert(eq->getQualifiers() == quals);
2633  return QualType(eq, fastQuals);
2634  }
2635 
2636  // If the base type is not canonical, make the appropriate canonical type.
2637  QualType canon;
2638  if (!baseType->isCanonicalUnqualified()) {
2639  SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split();
2640  canonSplit.Quals.addConsistentQualifiers(quals);
2641  canon = getExtQualType(canonSplit.Ty, canonSplit.Quals);
2642 
2643  // Re-find the insert position.
2644  (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
2645  }
2646 
2647  auto *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
2648  ExtQualNodes.InsertNode(eq, insertPos);
2649  return QualType(eq, fastQuals);
2650 }
2651 
2653  LangAS AddressSpace) const {
2654  QualType CanT = getCanonicalType(T);
2655  if (CanT.getAddressSpace() == AddressSpace)
2656  return T;
2657 
2658  // If we are composing extended qualifiers together, merge together
2659  // into one ExtQuals node.
2660  QualifierCollector Quals;
2661  const Type *TypeNode = Quals.strip(T);
2662 
2663  // If this type already has an address space specified, it cannot get
2664  // another one.
2665  assert(!Quals.hasAddressSpace() &&
2666  "Type cannot be in multiple addr spaces!");
2667  Quals.addAddressSpace(AddressSpace);
2668 
2669  return getExtQualType(TypeNode, Quals);
2670 }
2671 
2673  // If we are composing extended qualifiers together, merge together
2674  // into one ExtQuals node.
2675  QualifierCollector Quals;
2676  const Type *TypeNode = Quals.strip(T);
2677 
2678  // If the qualifier doesn't have an address space just return it.
2679  if (!Quals.hasAddressSpace())
2680  return T;
2681 
2682  Quals.removeAddressSpace();
2683 
2684  // Removal of the address space can mean there are no longer any
2685  // non-fast qualifiers, so creating an ExtQualType isn't possible (asserts)
2686  // or required.
2687  if (Quals.hasNonFastQualifiers())
2688  return getExtQualType(TypeNode, Quals);
2689  else
2690  return QualType(TypeNode, Quals.getFastQualifiers());
2691 }
2692 
2694  Qualifiers::GC GCAttr) const {
2695  QualType CanT = getCanonicalType(T);
2696  if (CanT.getObjCGCAttr() == GCAttr)
2697  return T;
2698 
2699  if (const auto *ptr = T->getAs<PointerType>()) {
2700  QualType Pointee = ptr->getPointeeType();
2701  if (Pointee->isAnyPointerType()) {
2702  QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
2703  return getPointerType(ResultType);
2704  }
2705  }
2706 
2707  // If we are composing extended qualifiers together, merge together
2708  // into one ExtQuals node.
2709  QualifierCollector Quals;
2710  const Type *TypeNode = Quals.strip(T);
2711 
2712  // If this type already has an ObjCGC specified, it cannot get
2713  // another one.
2714  assert(!Quals.hasObjCGCAttr() &&
2715  "Type cannot have multiple ObjCGCs!");
2716  Quals.addObjCGCAttr(GCAttr);
2717 
2718  return getExtQualType(TypeNode, Quals);
2719 }
2720 
2722  FunctionType::ExtInfo Info) {
2723  if (T->getExtInfo() == Info)
2724  return T;
2725 
2726  QualType Result;
2727  if (const auto *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
2728  Result = getFunctionNoProtoType(FNPT->getReturnType(), Info);
2729  } else {
2730  const auto *FPT = cast<FunctionProtoType>(T);
2731  FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
2732  EPI.ExtInfo = Info;
2733  Result = getFunctionType(FPT->getReturnType(), FPT->getParamTypes(), EPI);
2734  }
2735 
2736  return cast<FunctionType>(Result.getTypePtr());
2737 }
2738 
2740  QualType ResultType) {
2741  FD = FD->getMostRecentDecl();
2742  while (true) {
2743  const auto *FPT = FD->getType()->castAs<FunctionProtoType>();
2744  FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
2745  FD->setType(getFunctionType(ResultType, FPT->getParamTypes(), EPI));
2746  if (FunctionDecl *Next = FD->getPreviousDecl())
2747  FD = Next;
2748  else
2749  break;
2750  }
2752  L->DeducedReturnType(FD, ResultType);
2753 }
2754 
2755 /// Get a function type and produce the equivalent function type with the
2756 /// specified exception specification. Type sugar that can be present on a
2757 /// declaration of a function with an exception specification is permitted
2758 /// and preserved. Other type sugar (for instance, typedefs) is not.
2761  // Might have some parens.
2762  if (const auto *PT = dyn_cast<ParenType>(Orig))
2763  return getParenType(
2764  getFunctionTypeWithExceptionSpec(PT->getInnerType(), ESI));
2765 
2766  // Might have a calling-convention attribute.
2767  if (const auto *AT = dyn_cast<AttributedType>(Orig))
2768  return getAttributedType(
2769  AT->getAttrKind(),
2770  getFunctionTypeWithExceptionSpec(AT->getModifiedType(), ESI),
2771  getFunctionTypeWithExceptionSpec(AT->getEquivalentType(), ESI));
2772 
2773  // Anything else must be a function type. Rebuild it with the new exception
2774  // specification.
2775  const auto *Proto = cast<FunctionProtoType>(Orig);
2776  return getFunctionType(
2777  Proto->getReturnType(), Proto->getParamTypes(),
2778  Proto->getExtProtoInfo().withExceptionSpec(ESI));
2779 }
2780 
2782  QualType U) {
2783  return hasSameType(T, U) ||
2784  (getLangOpts().CPlusPlus17 &&
2787 }
2788 
2791  bool AsWritten) {
2792  // Update the type.
2793  QualType Updated =
2795  FD->setType(Updated);
2796 
2797  if (!AsWritten)
2798  return;
2799 
2800  // Update the type in the type source information too.
2801  if (TypeSourceInfo *TSInfo = FD->getTypeSourceInfo()) {
2802  // If the type and the type-as-written differ, we may need to update
2803  // the type-as-written too.
2804  if (TSInfo->getType() != FD->getType())
2805  Updated = getFunctionTypeWithExceptionSpec(TSInfo->getType(), ESI);
2806 
2807  // FIXME: When we get proper type location information for exceptions,
2808  // we'll also have to rebuild the TypeSourceInfo. For now, we just patch
2809  // up the TypeSourceInfo;
2810  assert(TypeLoc::getFullDataSizeForType(Updated) ==
2811  TypeLoc::getFullDataSizeForType(TSInfo->getType()) &&
2812  "TypeLoc size mismatch from updating exception specification");
2813  TSInfo->overrideType(Updated);
2814  }
2815 }
2816 
2817 /// getComplexType - Return the uniqued reference to the type for a complex
2818 /// number with the specified element type.
2820  // Unique pointers, to guarantee there is only one pointer of a particular
2821  // structure.
2822  llvm::FoldingSetNodeID ID;
2823  ComplexType::Profile(ID, T);
2824 
2825  void *InsertPos = nullptr;
2826  if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
2827  return QualType(CT, 0);
2828 
2829  // If the pointee type isn't canonical, this won't be a canonical type either,
2830  // so fill in the canonical type field.
2831  QualType Canonical;
2832  if (!T.isCanonical()) {
2833  Canonical = getComplexType(getCanonicalType(T));
2834 
2835  // Get the new insert position for the node we care about.
2836  ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
2837  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2838  }
2839  auto *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
2840  Types.push_back(New);
2841  ComplexTypes.InsertNode(New, InsertPos);
2842  return QualType(New, 0);
2843 }
2844 
2845 /// getPointerType - Return the uniqued reference to the type for a pointer to
2846 /// the specified type.
2848  // Unique pointers, to guarantee there is only one pointer of a particular
2849  // structure.
2850  llvm::FoldingSetNodeID ID;
2851  PointerType::Profile(ID, T);
2852 
2853  void *InsertPos = nullptr;
2854  if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2855  return QualType(PT, 0);
2856 
2857  // If the pointee type isn't canonical, this won't be a canonical type either,
2858  // so fill in the canonical type field.
2859  QualType Canonical;
2860  if (!T.isCanonical()) {
2861  Canonical = getPointerType(getCanonicalType(T));
2862 
2863  // Get the new insert position for the node we care about.
2864  PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2865  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2866  }
2867  auto *New = new (*this, TypeAlignment) PointerType(T, Canonical);
2868  Types.push_back(New);
2869  PointerTypes.InsertNode(New, InsertPos);
2870  return QualType(New, 0);
2871 }
2872 
2874  llvm::FoldingSetNodeID ID;
2875  AdjustedType::Profile(ID, Orig, New);
2876  void *InsertPos = nullptr;
2877  AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2878  if (AT)
2879  return QualType(AT, 0);
2880 
2881  QualType Canonical = getCanonicalType(New);
2882 
2883  // Get the new insert position for the node we care about.
2884  AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2885  assert(!AT && "Shouldn't be in the map!");
2886 
2887  AT = new (*this, TypeAlignment)
2888  AdjustedType(Type::Adjusted, Orig, New, Canonical);
2889  Types.push_back(AT);
2890  AdjustedTypes.InsertNode(AT, InsertPos);
2891  return QualType(AT, 0);
2892 }
2893 
2895  assert((T->isArrayType() || T->isFunctionType()) && "T does not decay");
2896 
2897  QualType Decayed;
2898 
2899  // C99 6.7.5.3p7:
2900  // A declaration of a parameter as "array of type" shall be
2901  // adjusted to "qualified pointer to type", where the type
2902  // qualifiers (if any) are those specified within the [ and ] of
2903  // the array type derivation.
2904  if (T->isArrayType())
2905  Decayed = getArrayDecayedType(T);
2906 
2907  // C99 6.7.5.3p8:
2908  // A declaration of a parameter as "function returning type"
2909  // shall be adjusted to "pointer to function returning type", as
2910  // in 6.3.2.1.
2911  if (T->isFunctionType())
2912  Decayed = getPointerType(T);
2913 
2914  llvm::FoldingSetNodeID ID;
2915  AdjustedType::Profile(ID, T, Decayed);
2916  void *InsertPos = nullptr;
2917  AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2918  if (AT)
2919  return QualType(AT, 0);
2920 
2921  QualType Canonical = getCanonicalType(Decayed);
2922 
2923  // Get the new insert position for the node we care about.
2924  AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2925  assert(!AT && "Shouldn't be in the map!");
2926 
2927  AT = new (*this, TypeAlignment) DecayedType(T, Decayed, Canonical);
2928  Types.push_back(AT);
2929  AdjustedTypes.InsertNode(AT, InsertPos);
2930  return QualType(AT, 0);
2931 }
2932 
2933 /// getBlockPointerType - Return the uniqued reference to the type for
2934 /// a pointer to the specified block.
2936  assert(T->isFunctionType() && "block of function types only");
2937  // Unique pointers, to guarantee there is only one block of a particular
2938  // structure.
2939  llvm::FoldingSetNodeID ID;
2941 
2942  void *InsertPos = nullptr;
2943  if (BlockPointerType *PT =
2944  BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2945  return QualType(PT, 0);
2946 
2947  // If the block pointee type isn't canonical, this won't be a canonical
2948  // type either so fill in the canonical type field.
2949  QualType Canonical;
2950  if (!T.isCanonical()) {
2951  Canonical = getBlockPointerType(getCanonicalType(T));
2952 
2953  // Get the new insert position for the node we care about.
2954  BlockPointerType *NewIP =
2955  BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2956  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2957  }
2958  auto *New = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
2959  Types.push_back(New);
2960  BlockPointerTypes.InsertNode(New, InsertPos);
2961  return QualType(New, 0);
2962 }
2963 
2964 /// getLValueReferenceType - Return the uniqued reference to the type for an
2965 /// lvalue reference to the specified type.
2966 QualType
2967 ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const {
2968  assert(getCanonicalType(T) != OverloadTy &&
2969  "Unresolved overloaded function type");
2970 
2971  // Unique pointers, to guarantee there is only one pointer of a particular
2972  // structure.
2973  llvm::FoldingSetNodeID ID;
2974  ReferenceType::Profile(ID, T, SpelledAsLValue);
2975 
2976  void *InsertPos = nullptr;
2977  if (LValueReferenceType *RT =
2978  LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2979  return QualType(RT, 0);
2980 
2981  const auto *InnerRef = T->getAs<ReferenceType>();
2982 
2983  // If the referencee type isn't canonical, this won't be a canonical type
2984  // either, so fill in the canonical type field.
2985  QualType Canonical;
2986  if (!SpelledAsLValue || InnerRef || !T.isCanonical()) {
2987  QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2988  Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
2989 
2990  // Get the new insert position for the node we care about.
2991  LValueReferenceType *NewIP =
2992  LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
2993  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
2994  }
2995 
2996  auto *New = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
2997  SpelledAsLValue);
2998  Types.push_back(New);
2999  LValueReferenceTypes.InsertNode(New, InsertPos);
3000 
3001  return QualType(New, 0);
3002 }
3003 
3004 /// getRValueReferenceType - Return the uniqued reference to the type for an
3005 /// rvalue reference to the specified type.
3007  // Unique pointers, to guarantee there is only one pointer of a particular
3008  // structure.
3009  llvm::FoldingSetNodeID ID;
3010  ReferenceType::Profile(ID, T, false);
3011 
3012  void *InsertPos = nullptr;
3013  if (RValueReferenceType *RT =
3014  RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
3015  return QualType(RT, 0);
3016 
3017  const auto *InnerRef = T->getAs<ReferenceType>();
3018 
3019  // If the referencee type isn't canonical, this won't be a canonical type
3020  // either, so fill in the canonical type field.
3021  QualType Canonical;
3022  if (InnerRef || !T.isCanonical()) {
3023  QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
3024  Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
3025 
3026  // Get the new insert position for the node we care about.
3027  RValueReferenceType *NewIP =
3028  RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
3029  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3030  }
3031 
3032  auto *New = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
3033  Types.push_back(New);
3034  RValueReferenceTypes.InsertNode(New, InsertPos);
3035  return QualType(New, 0);
3036 }
3037 
3038 /// getMemberPointerType - Return the uniqued reference to the type for a
3039 /// member pointer to the specified type, in the specified class.
3041  // Unique pointers, to guarantee there is only one pointer of a particular
3042  // structure.
3043  llvm::FoldingSetNodeID ID;
3044  MemberPointerType::Profile(ID, T, Cls);
3045 
3046  void *InsertPos = nullptr;
3047  if (MemberPointerType *PT =
3048  MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
3049  return QualType(PT, 0);
3050 
3051  // If the pointee or class type isn't canonical, this won't be a canonical
3052  // type either, so fill in the canonical type field.
3053  QualType Canonical;
3054  if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
3056 
3057  // Get the new insert position for the node we care about.
3058  MemberPointerType *NewIP =
3059  MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
3060  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3061  }
3062  auto *New = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
3063  Types.push_back(New);
3064  MemberPointerTypes.InsertNode(New, InsertPos);
3065  return QualType(New, 0);
3066 }
3067 
3068 /// getConstantArrayType - Return the unique reference to the type for an
3069 /// array of the specified element type.
3071  const llvm::APInt &ArySizeIn,
3073  unsigned IndexTypeQuals) const {
3074  assert((EltTy->isDependentType() ||
3075  EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&
3076  "Constant array of VLAs is illegal!");
3077 
3078  // Convert the array size into a canonical width matching the pointer size for
3079  // the target.
3080  llvm::APInt ArySize(ArySizeIn);
3081  ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());
3082 
3083  llvm::FoldingSetNodeID ID;
3084  ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals);
3085 
3086  void *InsertPos = nullptr;
3087  if (ConstantArrayType *ATP =
3088  ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
3089  return QualType(ATP, 0);
3090 
3091  // If the element type isn't canonical or has qualifiers, this won't
3092  // be a canonical type either, so fill in the canonical type field.
3093  QualType Canon;
3094  if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
3095  SplitQualType canonSplit = getCanonicalType(EltTy).split();
3096  Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize,
3097  ASM, IndexTypeQuals);
3098  Canon = getQualifiedType(Canon, canonSplit.Quals);
3099 
3100  // Get the new insert position for the node we care about.
3101  ConstantArrayType *NewIP =
3102  ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
3103  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3104  }
3105 
3106  auto *New = new (*this,TypeAlignment)
3107  ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals);
3108  ConstantArrayTypes.InsertNode(New, InsertPos);
3109  Types.push_back(New);
3110  return QualType(New, 0);
3111 }
3112 
3113 /// getVariableArrayDecayedType - Turns the given type, which may be
3114 /// variably-modified, into the corresponding type with all the known
3115 /// sizes replaced with [*].
3117  // Vastly most common case.
3118  if (!type->isVariablyModifiedType()) return type;
3119 
3120  QualType result;
3121 
3122  SplitQualType split = type.getSplitDesugaredType();
3123  const Type *ty = split.Ty;
3124  switch (ty->getTypeClass()) {
3125 #define TYPE(Class, Base)
3126 #define ABSTRACT_TYPE(Class, Base)
3127 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3128 #include "clang/AST/TypeNodes.def"
3129  llvm_unreachable("didn't desugar past all non-canonical types?");
3130 
3131  // These types should never be variably-modified.
3132  case Type::Builtin:
3133  case Type::Complex:
3134  case Type::Vector:
3135  case Type::DependentVector:
3136  case Type::ExtVector:
3137  case Type::DependentSizedExtVector:
3138  case Type::DependentAddressSpace:
3139  case Type::ObjCObject:
3140  case Type::ObjCInterface:
3141  case Type::ObjCObjectPointer:
3142  case Type::Record:
3143  case Type::Enum:
3144  case Type::UnresolvedUsing:
3145  case Type::TypeOfExpr:
3146  case Type::TypeOf:
3147  case Type::Decltype:
3148  case Type::UnaryTransform:
3149  case Type::DependentName:
3150  case Type::InjectedClassName:
3151  case Type::TemplateSpecialization:
3152  case Type::DependentTemplateSpecialization:
3153  case Type::TemplateTypeParm:
3154  case Type::SubstTemplateTypeParmPack:
3155  case Type::Auto:
3156  case Type::DeducedTemplateSpecialization:
3157  case Type::PackExpansion:
3158  llvm_unreachable("type should never be variably-modified");
3159 
3160  // These types can be variably-modified but should never need to
3161  // further decay.
3162  case Type::FunctionNoProto:
3163  case Type::FunctionProto:
3164  case Type::BlockPointer:
3165  case Type::MemberPointer:
3166  case Type::Pipe:
3167  return type;
3168 
3169  // These types can be variably-modified. All these modifications
3170  // preserve structure except as noted by comments.
3171  // TODO: if we ever care about optimizing VLAs, there are no-op
3172  // optimizations available here.
3173  case Type::Pointer:
3175  cast<PointerType>(ty)->getPointeeType()));
3176  break;
3177 
3178  case Type::LValueReference: {
3179  const auto *lv = cast<LValueReferenceType>(ty);
3180  result = getLValueReferenceType(
3181  getVariableArrayDecayedType(lv->getPointeeType()),
3182  lv->isSpelledAsLValue());
3183  break;
3184  }
3185 
3186  case Type::RValueReference: {
3187  const auto *lv = cast<RValueReferenceType>(ty);
3188  result = getRValueReferenceType(
3189  getVariableArrayDecayedType(lv->getPointeeType()));
3190  break;
3191  }
3192 
3193  case Type::Atomic: {
3194  const auto *at = cast<AtomicType>(ty);
3195  result = getAtomicType(getVariableArrayDecayedType(at->getValueType()));
3196  break;
3197  }
3198 
3199  case Type::ConstantArray: {
3200  const auto *cat = cast<ConstantArrayType>(ty);
3201  result = getConstantArrayType(
3202  getVariableArrayDecayedType(cat->getElementType()),
3203  cat->getSize(),
3204  cat->getSizeModifier(),
3205  cat->getIndexTypeCVRQualifiers());
3206  break;
3207  }
3208 
3209  case Type::DependentSizedArray: {
3210  const auto *dat = cast<DependentSizedArrayType>(ty);
3211  result = getDependentSizedArrayType(
3212  getVariableArrayDecayedType(dat->getElementType()),
3213  dat->getSizeExpr(),
3214  dat->getSizeModifier(),
3215  dat->getIndexTypeCVRQualifiers(),
3216  dat->getBracketsRange());
3217  break;
3218  }
3219 
3220  // Turn incomplete types into [*] types.
3221  case Type::IncompleteArray: {
3222  const auto *iat = cast<IncompleteArrayType>(ty);
3223  result = getVariableArrayType(
3224  getVariableArrayDecayedType(iat->getElementType()),
3225  /*size*/ nullptr,
3227  iat->getIndexTypeCVRQualifiers(),
3228  SourceRange());
3229  break;
3230  }
3231 
3232  // Turn VLA types into [*] types.
3233  case Type::VariableArray: {
3234  const auto *vat = cast<VariableArrayType>(ty);
3235  result = getVariableArrayType(
3236  getVariableArrayDecayedType(vat->getElementType()),
3237  /*size*/ nullptr,
3239  vat->getIndexTypeCVRQualifiers(),
3240  vat->getBracketsRange());
3241  break;
3242  }
3243  }
3244 
3245  // Apply the top-level qualifiers from the original.
3246  return getQualifiedType(result, split.Quals);
3247 }
3248 
3249 /// getVariableArrayType - Returns a non-unique reference to the type for a
3250 /// variable array of the specified element type.
3252  Expr *NumElts,
3254  unsigned IndexTypeQuals,
3255  SourceRange Brackets) const {
3256  // Since we don't unique expressions, it isn't possible to unique VLA's
3257  // that have an expression provided for their size.
3258  QualType Canon;
3259 
3260  // Be sure to pull qualifiers off the element type.
3261  if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
3262  SplitQualType canonSplit = getCanonicalType(EltTy).split();
3263  Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM,
3264  IndexTypeQuals, Brackets);
3265  Canon = getQualifiedType(Canon, canonSplit.Quals);
3266  }
3267 
3268  auto *New = new (*this, TypeAlignment)
3269  VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);
3270 
3271  VariableArrayTypes.push_back(New);
3272  Types.push_back(New);
3273  return QualType(New, 0);
3274 }
3275 
3276 /// getDependentSizedArrayType - Returns a non-unique reference to
3277 /// the type for a dependently-sized array of the specified element
3278 /// type.
3280  Expr *numElements,
3282  unsigned elementTypeQuals,
3283  SourceRange brackets) const {
3284  assert((!numElements || numElements->isTypeDependent() ||
3285  numElements->isValueDependent()) &&
3286  "Size must be type- or value-dependent!");
3287 
3288  // Dependently-sized array types that do not have a specified number
3289  // of elements will have their sizes deduced from a dependent
3290  // initializer. We do no canonicalization here at all, which is okay
3291  // because they can't be used in most locations.
3292  if (!numElements) {
3293  auto *newType
3294  = new (*this, TypeAlignment)
3295  DependentSizedArrayType(*this, elementType, QualType(),
3296  numElements, ASM, elementTypeQuals,
3297  brackets);
3298  Types.push_back(newType);
3299  return QualType(newType, 0);
3300  }
3301 
3302  // Otherwise, we actually build a new type every time, but we
3303  // also build a canonical type.
3304 
3305  SplitQualType canonElementType = getCanonicalType(elementType).split();
3306 
3307  void *insertPos = nullptr;
3308  llvm::FoldingSetNodeID ID;
3310  QualType(canonElementType.Ty, 0),
3311  ASM, elementTypeQuals, numElements);
3312 
3313  // Look for an existing type with these properties.
3314  DependentSizedArrayType *canonTy =
3315  DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3316 
3317  // If we don't have one, build one.
3318  if (!canonTy) {
3319  canonTy = new (*this, TypeAlignment)
3320  DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0),
3321  QualType(), numElements, ASM, elementTypeQuals,
3322  brackets);
3323  DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
3324  Types.push_back(canonTy);
3325  }
3326 
3327  // Apply qualifiers from the element type to the array.
3328  QualType canon = getQualifiedType(QualType(canonTy,0),
3329  canonElementType.Quals);
3330 
3331  // If we didn't need extra canonicalization for the element type or the size
3332  // expression, then just use that as our result.
3333  if (QualType(canonElementType.Ty, 0) == elementType &&
3334  canonTy->getSizeExpr() == numElements)
3335  return canon;
3336 
3337  // Otherwise, we need to build a type which follows the spelling
3338  // of the element type.
3339  auto *sugaredType
3340  = new (*this, TypeAlignment)
3341  DependentSizedArrayType(*this, elementType, canon, numElements,
3342  ASM, elementTypeQuals, brackets);
3343  Types.push_back(sugaredType);
3344  return QualType(sugaredType, 0);
3345 }
3346 
3349  unsigned elementTypeQuals) const {
3350  llvm::FoldingSetNodeID ID;
3351  IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals);
3352 
3353  void *insertPos = nullptr;
3354  if (IncompleteArrayType *iat =
3355  IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
3356  return QualType(iat, 0);
3357 
3358  // If the element type isn't canonical, this won't be a canonical type
3359  // either, so fill in the canonical type field. We also have to pull
3360  // qualifiers off the element type.
3361  QualType canon;
3362 
3363  if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) {
3364  SplitQualType canonSplit = getCanonicalType(elementType).split();
3365  canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0),
3366  ASM, elementTypeQuals);
3367  canon = getQualifiedType(canon, canonSplit.Quals);
3368 
3369  // Get the new insert position for the node we care about.
3370  IncompleteArrayType *existing =
3371  IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3372  assert(!existing && "Shouldn't be in the map!"); (void) existing;
3373  }
3374 
3375  auto *newType = new (*this, TypeAlignment)
3376  IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);
3377 
3378  IncompleteArrayTypes.InsertNode(newType, insertPos);
3379  Types.push_back(newType);
3380  return QualType(newType, 0);
3381 }
3382 
3383 /// getVectorType - Return the unique reference to a vector type of
3384 /// the specified element type and size. VectorType must be a built-in type.
3385 QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts,
3386  VectorType::VectorKind VecKind) const {
3387  assert(vecType->isBuiltinType());
3388 
3389  // Check if we've already instantiated a vector of this type.
3390  llvm::FoldingSetNodeID ID;
3391  VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind);
3392 
3393  void *InsertPos = nullptr;
3394  if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3395  return QualType(VTP, 0);
3396 
3397  // If the element type isn't canonical, this won't be a canonical type either,
3398  // so fill in the canonical type field.
3399  QualType Canonical;
3400  if (!vecType.isCanonical()) {
3401  Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind);
3402 
3403  // Get the new insert position for the node we care about.
3404  VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3405  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3406  }
3407  auto *New = new (*this, TypeAlignment)
3408  VectorType(vecType, NumElts, Canonical, VecKind);
3409  VectorTypes.InsertNode(New, InsertPos);
3410  Types.push_back(New);
3411  return QualType(New, 0);
3412 }
3413 
3414 QualType
3416  SourceLocation AttrLoc,
3417  VectorType::VectorKind VecKind) const {
3418  llvm::FoldingSetNodeID ID;
3419  DependentVectorType::Profile(ID, *this, getCanonicalType(VecType), SizeExpr,
3420  VecKind);
3421  void *InsertPos = nullptr;
3422  DependentVectorType *Canon =
3423  DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3424  DependentVectorType *New;
3425 
3426  if (Canon) {
3427  New = new (*this, TypeAlignment) DependentVectorType(
3428  *this, VecType, QualType(Canon, 0), SizeExpr, AttrLoc, VecKind);
3429  } else {
3430  QualType CanonVecTy = getCanonicalType(VecType);
3431  if (CanonVecTy == VecType) {
3432  New = new (*this, TypeAlignment) DependentVectorType(
3433  *this, VecType, QualType(), SizeExpr, AttrLoc, VecKind);
3434 
3435  DependentVectorType *CanonCheck =
3436  DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3437  assert(!CanonCheck &&
3438  "Dependent-sized vector_size canonical type broken");
3439  (void)CanonCheck;
3440  DependentVectorTypes.InsertNode(New, InsertPos);
3441  } else {
3442  QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
3443  SourceLocation());
3444  New = new (*this, TypeAlignment) DependentVectorType(
3445  *this, VecType, Canon, SizeExpr, AttrLoc, VecKind);
3446  }
3447  }
3448 
3449  Types.push_back(New);
3450  return QualType(New, 0);
3451 }
3452 
3453 /// getExtVectorType - Return the unique reference to an extended vector type of
3454 /// the specified element type and size. VectorType must be a built-in type.
3455 QualType
3456 ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const {
3457  assert(vecType->isBuiltinType() || vecType->isDependentType());
3458 
3459  // Check if we've already instantiated a vector of this type.
3460  llvm::FoldingSetNodeID ID;
3461  VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
3463  void *InsertPos = nullptr;
3464  if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3465  return QualType(VTP, 0);
3466 
3467  // If the element type isn't canonical, this won't be a canonical type either,
3468  // so fill in the canonical type field.
3469  QualType Canonical;
3470  if (!vecType.isCanonical()) {
3471  Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
3472 
3473  // Get the new insert position for the node we care about.
3474  VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3475  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3476  }
3477  auto *New = new (*this, TypeAlignment)
3478  ExtVectorType(vecType, NumElts, Canonical);
3479  VectorTypes.InsertNode(New, InsertPos);
3480  Types.push_back(New);
3481  return QualType(New, 0);
3482 }
3483 
3484 QualType
3486  Expr *SizeExpr,
3487  SourceLocation AttrLoc) const {
3488  llvm::FoldingSetNodeID ID;
3490  SizeExpr);
3491 
3492  void *InsertPos = nullptr;
3494  = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3496  if (Canon) {
3497  // We already have a canonical version of this array type; use it as
3498  // the canonical type for a newly-built type.
3499  New = new (*this, TypeAlignment)
3500  DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
3501  SizeExpr, AttrLoc);
3502  } else {
3503  QualType CanonVecTy = getCanonicalType(vecType);
3504  if (CanonVecTy == vecType) {
3505  New = new (*this, TypeAlignment)
3506  DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
3507  AttrLoc);
3508 
3509  DependentSizedExtVectorType *CanonCheck
3510  = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3511  assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken");
3512  (void)CanonCheck;
3513  DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
3514  } else {
3515  QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
3516  SourceLocation());
3517  New = new (*this, TypeAlignment)
3518  DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc);
3519  }
3520  }
3521 
3522  Types.push_back(New);
3523  return QualType(New, 0);
3524 }
3525 
3527  Expr *AddrSpaceExpr,
3528  SourceLocation AttrLoc) const {
3529  assert(AddrSpaceExpr->isInstantiationDependent());
3530 
3531  QualType canonPointeeType = getCanonicalType(PointeeType);
3532 
3533  void *insertPos = nullptr;
3534  llvm::FoldingSetNodeID ID;
3535  DependentAddressSpaceType::Profile(ID, *this, canonPointeeType,
3536  AddrSpaceExpr);
3537 
3538  DependentAddressSpaceType *canonTy =
3539  DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
3540 
3541  if (!canonTy) {
3542  canonTy = new (*this, TypeAlignment)
3543  DependentAddressSpaceType(*this, canonPointeeType,
3544  QualType(), AddrSpaceExpr, AttrLoc);
3545  DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
3546  Types.push_back(canonTy);
3547  }
3548 
3549  if (canonPointeeType == PointeeType &&
3550  canonTy->getAddrSpaceExpr() == AddrSpaceExpr)
3551  return QualType(canonTy, 0);
3552 
3553  auto *sugaredType
3554  = new (*this, TypeAlignment)
3555  DependentAddressSpaceType(*this, PointeeType, QualType(canonTy, 0),
3556  AddrSpaceExpr, AttrLoc);
3557  Types.push_back(sugaredType);
3558  return QualType(sugaredType, 0);
3559 }
3560 
3561 /// Determine whether \p T is canonical as the result type of a function.
3563  return T.isCanonical() &&
3566 }
3567 
3568 /// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
3569 QualType
3571  const FunctionType::ExtInfo &Info) const {
3572  // Unique functions, to guarantee there is only one function of a particular
3573  // structure.
3574  llvm::FoldingSetNodeID ID;
3575  FunctionNoProtoType::Profile(ID, ResultTy, Info);
3576 
3577  void *InsertPos = nullptr;
3578  if (FunctionNoProtoType *FT =
3579  FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
3580  return QualType(FT, 0);
3581 
3582  QualType Canonical;
3583  if (!isCanonicalResultType(ResultTy)) {
3584  Canonical =
3586 
3587  // Get the new insert position for the node we care about.
3588  FunctionNoProtoType *NewIP =
3589  FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3590  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3591  }
3592 
3593  auto *New = new (*this, TypeAlignment)
3594  FunctionNoProtoType(ResultTy, Canonical, Info);
3595  Types.push_back(New);
3596  FunctionNoProtoTypes.InsertNode(New, InsertPos);
3597  return QualType(New, 0);
3598 }
3599 
3602  CanQualType CanResultType = getCanonicalType(ResultType);
3603 
3604  // Canonical result types do not have ARC lifetime qualifiers.
3605  if (CanResultType.getQualifiers().hasObjCLifetime()) {
3606  Qualifiers Qs = CanResultType.getQualifiers();
3607  Qs.removeObjCLifetime();
3609  getQualifiedType(CanResultType.getUnqualifiedType(), Qs));
3610  }
3611 
3612  return CanResultType;
3613 }
3614 
3616  const FunctionProtoType::ExceptionSpecInfo &ESI, bool NoexceptInType) {
3617  if (ESI.Type == EST_None)
3618  return true;
3619  if (!NoexceptInType)
3620  return false;
3621 
3622  // C++17 onwards: exception specification is part of the type, as a simple
3623  // boolean "can this function type throw".
3624  if (ESI.Type == EST_BasicNoexcept)
3625  return true;
3626 
3627  // A noexcept(expr) specification is (possibly) canonical if expr is
3628  // value-dependent.
3629  if (ESI.Type == EST_DependentNoexcept)
3630  return true;
3631 
3632  // A dynamic exception specification is canonical if it only contains pack
3633  // expansions (so we can't tell whether it's non-throwing) and all its
3634  // contained types are canonical.
3635  if (ESI.Type == EST_Dynamic) {
3636  bool AnyPackExpansions = false;
3637  for (QualType ET : ESI.Exceptions) {
3638  if (!ET.isCanonical())
3639  return false;
3640  if (ET->getAs<PackExpansionType>())
3641  AnyPackExpansions = true;
3642  }
3643  return AnyPackExpansions;
3644  }
3645 
3646  return false;
3647 }
3648 
3649 QualType ASTContext::getFunctionTypeInternal(
3650  QualType ResultTy, ArrayRef<QualType> ArgArray,
3651  const FunctionProtoType::ExtProtoInfo &EPI, bool OnlyWantCanonical) const {
3652  size_t NumArgs = ArgArray.size();
3653 
3654  // Unique functions, to guarantee there is only one function of a particular
3655  // structure.
3656  llvm::FoldingSetNodeID ID;
3657  FunctionProtoType::Profile(ID, ResultTy, ArgArray.begin(), NumArgs, EPI,
3658  *this, true);
3659 
3660  QualType Canonical;
3661  bool Unique = false;
3662 
3663  void *InsertPos = nullptr;
3664  if (FunctionProtoType *FPT =
3665  FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
3666  QualType Existing = QualType(FPT, 0);
3667 
3668  // If we find a pre-existing equivalent FunctionProtoType, we can just reuse
3669  // it so long as our exception specification doesn't contain a dependent
3670  // noexcept expression, or we're just looking for a canonical type.
3671  // Otherwise, we're going to need to create a type
3672  // sugar node to hold the concrete expression.
3673  if (OnlyWantCanonical || !isComputedNoexcept(EPI.ExceptionSpec.Type) ||
3674  EPI.ExceptionSpec.NoexceptExpr == FPT->getNoexceptExpr())
3675  return Existing;
3676 
3677  // We need a new type sugar node for this one, to hold the new noexcept
3678  // expression. We do no canonicalization here, but that's OK since we don't
3679  // expect to see the same noexcept expression much more than once.
3680  Canonical = getCanonicalType(Existing);
3681  Unique = true;
3682  }
3683 
3684  bool NoexceptInType = getLangOpts().CPlusPlus17;
3685  bool IsCanonicalExceptionSpec =
3686  isCanonicalExceptionSpecification(EPI.ExceptionSpec, NoexceptInType);
3687 
3688  // Determine whether the type being created is already canonical or not.
3689  bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
3690  isCanonicalResultType(ResultTy) && !EPI.HasTrailingReturn;
3691  for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
3692  if (!ArgArray[i].isCanonicalAsParam())
3693  isCanonical = false;
3694 
3695  if (OnlyWantCanonical)
3696  assert(isCanonical &&
3697  "given non-canonical parameters constructing canonical type");
3698 
3699  // If this type isn't canonical, get the canonical version of it if we don't
3700  // already have it. The exception spec is only partially part of the
3701  // canonical type, and only in C++17 onwards.
3702  if (!isCanonical && Canonical.isNull()) {
3703  SmallVector<QualType, 16> CanonicalArgs;
3704  CanonicalArgs.reserve(NumArgs);
3705  for (unsigned i = 0; i != NumArgs; ++i)
3706  CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));
3707 
3708  llvm::SmallVector<QualType, 8> ExceptionTypeStorage;
3709  FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
3710  CanonicalEPI.HasTrailingReturn = false;
3711 
3712  if (IsCanonicalExceptionSpec) {
3713  // Exception spec is already OK.
3714  } else if (NoexceptInType) {
3715  switch (EPI.ExceptionSpec.Type) {
3717  // We don't know yet. It shouldn't matter what we pick here; no-one
3718  // should ever look at this.
3719  LLVM_FALLTHROUGH;
3720  case EST_None: case EST_MSAny: case EST_NoexceptFalse:
3721  CanonicalEPI.ExceptionSpec.Type = EST_None;
3722  break;
3723 
3724  // A dynamic exception specification is almost always "not noexcept",
3725  // with the exception that a pack expansion might expand to no types.
3726  case EST_Dynamic: {
3727  bool AnyPacks = false;
3728  for (QualType ET : EPI.ExceptionSpec.Exceptions) {
3729  if (ET->getAs<PackExpansionType>())
3730  AnyPacks = true;
3731  ExceptionTypeStorage.push_back(getCanonicalType(ET));
3732  }
3733  if (!AnyPacks)
3734  CanonicalEPI.ExceptionSpec.Type = EST_None;
3735  else {
3736  CanonicalEPI.ExceptionSpec.Type = EST_Dynamic;
3737  CanonicalEPI.ExceptionSpec.Exceptions = ExceptionTypeStorage;
3738  }
3739  break;
3740  }
3741 
3743  CanonicalEPI.ExceptionSpec.Type = EST_BasicNoexcept;
3744  break;
3745 
3746  case EST_DependentNoexcept:
3747  llvm_unreachable("dependent noexcept is already canonical");
3748  }
3749  } else {
3751  }
3752 
3753  // Adjust the canonical function result type.
3754  CanQualType CanResultTy = getCanonicalFunctionResultType(ResultTy);
3755  Canonical =
3756  getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI, true);
3757 
3758  // Get the new insert position for the node we care about.
3759  FunctionProtoType *NewIP =
3760  FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3761  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
3762  }
3763 
3764  // Compute the needed size to hold this FunctionProtoType and the
3765  // various trailing objects.
3766  auto ESH = FunctionProtoType::getExceptionSpecSize(
3767  EPI.ExceptionSpec.Type, EPI.ExceptionSpec.Exceptions.size());
3768  size_t Size = FunctionProtoType::totalSizeToAlloc<
3771  FunctionProtoType::ExtParameterInfo, Qualifiers>(
3772  NumArgs, FunctionProtoType::hasExtraBitfields(EPI.ExceptionSpec.Type),
3773  ESH.NumExceptionType, ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
3774  EPI.ExtParameterInfos ? NumArgs : 0,
3775  EPI.TypeQuals.hasNonFastQualifiers() ? 1 : 0);
3776 
3777  auto *FTP = (FunctionProtoType *)Allocate(Size, TypeAlignment);
3778  FunctionProtoType::ExtProtoInfo newEPI = EPI;
3779  new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
3780  Types.push_back(FTP);
3781  if (!Unique)
3782  FunctionProtoTypes.InsertNode(FTP, InsertPos);
3783  return QualType(FTP, 0);
3784 }
3785 
3786 QualType ASTContext::getPipeType(QualType T, bool ReadOnly) const {
3787  llvm::FoldingSetNodeID ID;
3788  PipeType::Profile(ID, T, ReadOnly);
3789 
3790  void *InsertPos = nullptr;
3791  if (PipeType *PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))
3792  return QualType(PT, 0);
3793 
3794  // If the pipe element type isn't canonical, this won't be a canonical type
3795  // either, so fill in the canonical type field.
3796  QualType Canonical;
3797  if (!T.isCanonical()) {
3798  Canonical = getPipeType(getCanonicalType(T), ReadOnly);
3799 
3800  // Get the new insert position for the node we care about.
3801  PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);
3802  assert(!NewIP && "Shouldn't be in the map!");
3803  (void)NewIP;
3804  }
3805  auto *New = new (*this, TypeAlignment) PipeType(T, Canonical, ReadOnly);
3806  Types.push_back(New);
3807  PipeTypes.InsertNode(New, InsertPos);
3808  return QualType(New, 0);
3809 }
3810 
3812  // OpenCL v1.1 s6.5.3: a string literal is in the constant address space.
3813  return LangOpts.OpenCL ? getAddrSpaceQualType(Ty, LangAS::opencl_constant)
3814  : Ty;
3815 }
3816 
3818  return getPipeType(T, true);
3819 }
3820 
3822  return getPipeType(T, false);
3823 }
3824 
3825 #ifndef NDEBUG
3827  if (!isa<CXXRecordDecl>(D)) return false;
3828  const auto *RD = cast<CXXRecordDecl>(D);
3829  if (isa<ClassTemplatePartialSpecializationDecl>(RD))
3830  return true;
3831  if (RD->getDescribedClassTemplate() &&
3832  !isa<ClassTemplateSpecializationDecl>(RD))
3833  return true;
3834  return false;
3835 }
3836 #endif
3837 
3838 /// getInjectedClassNameType - Return the unique reference to the
3839 /// injected class name type for the specified templated declaration.
3841  QualType TST) const {
3842  assert(NeedsInjectedClassNameType(Decl));
3843  if (Decl->TypeForDecl) {
3844  assert(isa<InjectedClassNameType>(Decl->TypeForDecl));
3845  } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) {
3846  assert(PrevDecl->TypeForDecl && "previous declaration has no type");
3847  Decl->TypeForDecl = PrevDecl->TypeForDecl;
3848  assert(isa<InjectedClassNameType>(Decl->TypeForDecl));
3849  } else {
3850  Type *newType =
3851  new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
3852  Decl->TypeForDecl = newType;
3853  Types.push_back(newType);
3854  }
3855  return QualType(Decl->TypeForDecl, 0);
3856 }
3857 
3858 /// getTypeDeclType - Return the unique reference to the type for the
3859 /// specified type declaration.
3860 QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const {
3861  assert(Decl && "Passed null for Decl param");
3862  assert(!Decl->TypeForDecl && "TypeForDecl present in slow case");
3863 
3864  if (const auto *Typedef = dyn_cast<TypedefNameDecl>(Decl))
3865  return getTypedefType(Typedef);
3866 
3867  assert(!isa<TemplateTypeParmDecl>(Decl) &&
3868  "Template type parameter types are always available.");
3869 
3870  if (const auto *Record = dyn_cast<RecordDecl>(Decl)) {
3871  assert(Record->isFirstDecl() && "struct/union has previous declaration");
3872  assert(!NeedsInjectedClassNameType(Record));
3873  return getRecordType(Record);
3874  } else if (const auto *Enum = dyn_cast<EnumDecl>(Decl)) {
3875  assert(Enum->isFirstDecl() && "enum has previous declaration");
3876  return getEnumType(Enum);
3877  } else if (const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
3878  Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using);
3879  Decl->TypeForDecl = newType;
3880  Types.push_back(newType);
3881  } else
3882  llvm_unreachable("TypeDecl without a type?");
3883 
3884  return QualType(Decl->TypeForDecl, 0);
3885 }
3886 
3887 /// getTypedefType - Return the unique reference to the type for the
3888 /// specified typedef name decl.
3889 QualType
3891  QualType Canonical) const {
3892  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3893 
3894  if (Canonical.isNull())
3895  Canonical = getCanonicalType(Decl->getUnderlyingType());
3896  auto *newType = new (*this, TypeAlignment)
3897  TypedefType(Type::Typedef, Decl, Canonical);
3898  Decl->TypeForDecl = newType;
3899  Types.push_back(newType);
3900  return QualType(newType, 0);
3901 }
3902 
3904  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3905 
3906  if (const RecordDecl *PrevDecl = Decl->getPreviousDecl())
3907  if (PrevDecl->TypeForDecl)
3908  return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3909 
3910  auto *newType = new (*this, TypeAlignment) RecordType(Decl);
3911  Decl->TypeForDecl = newType;
3912  Types.push_back(newType);
3913  return QualType(newType, 0);
3914 }
3915 
3917  if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3918 
3919  if (const EnumDecl *PrevDecl = Decl->getPreviousDecl())
3920  if (PrevDecl->TypeForDecl)
3921  return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3922 
3923  auto *newType = new (*this, TypeAlignment) EnumType(Decl);
3924  Decl->TypeForDecl = newType;
3925  Types.push_back(newType);
3926  return QualType(newType, 0);
3927 }
3928 
3930  QualType modifiedType,
3931  QualType equivalentType) {
3932  llvm::FoldingSetNodeID id;
3933  AttributedType::Profile(id, attrKind, modifiedType, equivalentType);
3934 
3935  void *insertPos = nullptr;
3936  AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos);
3937  if (type) return QualType(type, 0);
3938 
3939  QualType canon = getCanonicalType(equivalentType);
3940  type = new (*this, TypeAlignment)
3941  AttributedType(canon, attrKind, modifiedType, equivalentType);
3942 
3943  Types.push_back(type);
3944  AttributedTypes.InsertNode(type, insertPos);
3945 
3946  return QualType(type, 0);
3947 }
3948 
3949 /// Retrieve a substitution-result type.
3950 QualType
3952  QualType Replacement) const {
3953  assert(Replacement.isCanonical()
3954  && "replacement types must always be canonical");
3955 
3956  llvm::FoldingSetNodeID ID;
3957  SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
3958  void *InsertPos = nullptr;
3959  SubstTemplateTypeParmType *SubstParm
3960  = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3961 
3962  if (!SubstParm) {
3963  SubstParm = new (*this, TypeAlignment)
3964  SubstTemplateTypeParmType(Parm, Replacement);
3965  Types.push_back(SubstParm);
3966  SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
3967  }
3968 
3969  return QualType(SubstParm, 0);
3970 }
3971 
3972 /// Retrieve a
3974  const TemplateTypeParmType *Parm,
3975  const TemplateArgument &ArgPack) {
3976 #ifndef NDEBUG
3977  for (const auto &P : ArgPack.pack_elements()) {
3978  assert(P.getKind() == TemplateArgument::Type &&"Pack contains a non-type");
3979  assert(P.getAsType().isCanonical() && "Pack contains non-canonical type");
3980  }
3981 #endif
3982 
3983  llvm::FoldingSetNodeID ID;
3984  SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack);
3985  void *InsertPos = nullptr;
3986  if (SubstTemplateTypeParmPackType *SubstParm
3987  = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
3988  return QualType(SubstParm, 0);
3989 
3990  QualType Canon;
3991  if (!Parm->isCanonicalUnqualified()) {
3992  Canon = getCanonicalType(QualType(Parm, 0));
3993  Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon),
3994  ArgPack);
3995  SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
3996  }
3997 
3998  auto *SubstParm
3999  = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon,
4000  ArgPack);
4001  Types.push_back(SubstParm);
4002  SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
4003  return QualType(SubstParm, 0);
4004 }
4005 
4006 /// Retrieve the template type parameter type for a template
4007 /// parameter or parameter pack with the given depth, index, and (optionally)
4008 /// name.
4010  bool ParameterPack,
4011  TemplateTypeParmDecl *TTPDecl) const {
4012  llvm::FoldingSetNodeID ID;
4013  TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
4014  void *InsertPos = nullptr;
4015  TemplateTypeParmType *TypeParm
4016  = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
4017 
4018  if (TypeParm)
4019  return QualType(TypeParm, 0);
4020 
4021  if (TTPDecl) {
4022  QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
4023  TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon);
4024 
4025  TemplateTypeParmType *TypeCheck
4026  = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
4027  assert(!TypeCheck && "Template type parameter canonical type broken");
4028  (void)TypeCheck;
4029  } else
4030  TypeParm = new (*this, TypeAlignment)
4031  TemplateTypeParmType(Depth, Index, ParameterPack);
4032 
4033  Types.push_back(TypeParm);
4034  TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
4035 
4036  return QualType(TypeParm, 0);
4037 }
4038 
4041  SourceLocation NameLoc,
4042  const TemplateArgumentListInfo &Args,
4043  QualType Underlying) const {
4044  assert(!Name.getAsDependentTemplateName() &&
4045  "No dependent template names here!");
4046  QualType TST = getTemplateSpecializationType(Name, Args, Underlying);
4047 
4052  TL.setTemplateNameLoc(NameLoc);
4053  TL.setLAngleLoc(Args.getLAngleLoc());
4054  TL.setRAngleLoc(Args.getRAngleLoc());
4055  for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
4056  TL.setArgLocInfo(i, Args[i].getLocInfo());
4057  return DI;
4058 }
4059 
4060 QualType
4062  const TemplateArgumentListInfo &Args,
4063  QualType Underlying) const {
4064  assert(!Template.getAsDependentTemplateName() &&
4065  "No dependent template names here!");
4066 
4068  ArgVec.reserve(Args.size());
4069  for (const TemplateArgumentLoc &Arg : Args.arguments())
4070  ArgVec.push_back(Arg.getArgument());
4071 
4072  return getTemplateSpecializationType(Template, ArgVec, Underlying);
4073 }
4074 
4075 #ifndef NDEBUG
4077  for (const TemplateArgument &Arg : Args)
4078  if (Arg.isPackExpansion())
4079  return true;
4080 
4081  return true;
4082 }
4083 #endif
4084 
4085 QualType
4088  QualType Underlying) const {
4089  assert(!Template.getAsDependentTemplateName() &&
4090  "No dependent template names here!");
4091  // Look through qualified template names.
4092  if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
4093  Template = TemplateName(QTN->getTemplateDecl());
4094 
4095  bool IsTypeAlias =
4096  Template.getAsTemplateDecl() &&
4097  isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
4098  QualType CanonType;
4099  if (!Underlying.isNull())
4100  CanonType = getCanonicalType(Underlying);
4101  else {
4102  // We can get here with an alias template when the specialization contains
4103  // a pack expansion that does not match up with a parameter pack.
4104  assert((!IsTypeAlias || hasAnyPackExpansions(Args)) &&
4105  "Caller must compute aliased type");
4106  IsTypeAlias = false;
4107  CanonType = getCanonicalTemplateSpecializationType(Template, Args);
4108  }
4109 
4110  // Allocate the (non-canonical) template specialization type, but don't
4111  // try to unique it: these types typically have location information that
4112  // we don't unique and don't want to lose.
4113  void *Mem = Allocate(sizeof(TemplateSpecializationType) +
4114  sizeof(TemplateArgument) * Args.size() +
4115  (IsTypeAlias? sizeof(QualType) : 0),
4116  TypeAlignment);
4117  auto *Spec
4118  = new (Mem) TemplateSpecializationType(Template, Args, CanonType,
4119  IsTypeAlias ? Underlying : QualType());
4120 
4121  Types.push_back(Spec);
4122  return QualType(Spec, 0);
4123 }
4124 
4126  TemplateName Template, ArrayRef<TemplateArgument> Args) const {
4127  assert(!Template.getAsDependentTemplateName() &&
4128  "No dependent template names here!");
4129 
4130  // Look through qualified template names.
4131  if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
4132  Template = TemplateName(QTN->getTemplateDecl());
4133 
4134  // Build the canonical template specialization type.
4135  TemplateName CanonTemplate = getCanonicalTemplateName(Template);
4137  unsigned NumArgs = Args.size();
4138  CanonArgs.reserve(NumArgs);
4139  for (const TemplateArgument &Arg : Args)
4140  CanonArgs.push_back(getCanonicalTemplateArgument(Arg));
4141 
4142  // Determine whether this canonical template specialization type already
4143  // exists.
4144  llvm::FoldingSetNodeID ID;
4145  TemplateSpecializationType::Profile(ID, CanonTemplate,
4146  CanonArgs, *this);
4147 
4148  void *InsertPos = nullptr;
4150  = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4151 
4152  if (!Spec) {
4153  // Allocate a new canonical template specialization type.
4154  void *Mem = Allocate((sizeof(TemplateSpecializationType) +
4155  sizeof(TemplateArgument) * NumArgs),
4156  TypeAlignment);
4157  Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
4158  CanonArgs,
4159  QualType(), QualType());
4160  Types.push_back(Spec);
4161  TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
4162  }
4163 
4164  assert(Spec->isDependentType() &&
4165  "Non-dependent template-id type must have a canonical type");
4166  return QualType(Spec, 0);
4167 }
4168 
4170  NestedNameSpecifier *NNS,
4171  QualType NamedType,
4172  TagDecl *OwnedTagDecl) const {
4173  llvm::FoldingSetNodeID ID;
4174  ElaboratedType::Profile(ID, Keyword, NNS, NamedType, OwnedTagDecl);
4175 
4176  void *InsertPos = nullptr;
4177  ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
4178  if (T)
4179  return QualType(T, 0);
4180 
4181  QualType Canon = NamedType;
4182  if (!Canon.isCanonical()) {
4183  Canon = getCanonicalType(NamedType);
4184  ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
4185  assert(!CheckT && "Elaborated canonical type broken");
4186  (void)CheckT;
4187  }
4188 
4189  void *Mem = Allocate(ElaboratedType::totalSizeToAlloc<TagDecl *>(!!OwnedTagDecl),
4190  TypeAlignment);
4191  T = new (Mem) ElaboratedType(Keyword, NNS, NamedType, Canon, OwnedTagDecl);
4192 
4193  Types.push_back(T);
4194  ElaboratedTypes.InsertNode(T, InsertPos);
4195  return QualType(T, 0);
4196 }
4197 
4198 QualType
4200  llvm::FoldingSetNodeID ID;
4201  ParenType::Profile(ID, InnerType);
4202 
4203  void *InsertPos = nullptr;
4204  ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4205  if (T)
4206  return QualType(T, 0);
4207 
4208  QualType Canon = InnerType;
4209  if (!Canon.isCanonical()) {
4210  Canon = getCanonicalType(InnerType);
4211  ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4212  assert(!CheckT && "Paren canonical type broken");
4213  (void)CheckT;
4214  }
4215 
4216  T = new (*this, TypeAlignment) ParenType(InnerType, Canon);
4217  Types.push_back(T);
4218  ParenTypes.InsertNode(T, InsertPos);
4219  return QualType(T, 0);
4220 }
4221 
4223  NestedNameSpecifier *NNS,
4224  const IdentifierInfo *Name,
4225  QualType Canon) const {
4226  if (Canon.isNull()) {
4228  if (CanonNNS != NNS)
4229  Canon = getDependentNameType(Keyword, CanonNNS, Name);
4230  }
4231 
4232  llvm::FoldingSetNodeID ID;
4233  DependentNameType::Profile(ID, Keyword, NNS, Name);
4234 
4235  void *InsertPos = nullptr;
4237  = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
4238  if (T)
4239  return QualType(T, 0);
4240 
4241  T = new (*this, TypeAlignment) DependentNameType(Keyword, NNS, Name, Canon);
4242  Types.push_back(T);
4243  DependentNameTypes.InsertNode(T, InsertPos);
4244  return QualType(T, 0);
4245 }
4246 
4247 QualType
4249  ElaboratedTypeKeyword Keyword,
4250  NestedNameSpecifier *NNS,
4251  const IdentifierInfo *Name,
4252  const TemplateArgumentListInfo &Args) const {
4253  // TODO: avoid this copy
4255  for (unsigned I = 0, E = Args.size(); I != E; ++I)
4256  ArgCopy.push_back(Args[I].getArgument());
4257  return getDependentTemplateSpecializationType(Keyword, NNS, Name, ArgCopy);
4258 }
4259 
4260 QualType
4262  ElaboratedTypeKeyword Keyword,
4263  NestedNameSpecifier *NNS,
4264  const IdentifierInfo *Name,
4265  ArrayRef<TemplateArgument> Args) const {
4266  assert((!NNS || NNS->isDependent()) &&
4267  "nested-name-specifier must be dependent");
4268 
4269  llvm::FoldingSetNodeID ID;
4270  DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
4271  Name, Args);
4272 
4273  void *InsertPos = nullptr;
4275  = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4276  if (T)
4277  return QualType(T, 0);
4278 
4280 
4281  ElaboratedTypeKeyword CanonKeyword = Keyword;
4282  if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
4283 
4284  bool AnyNonCanonArgs = false;
4285  unsigned NumArgs = Args.size();
4286  SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
4287  for (unsigned I = 0; I != NumArgs; ++I) {
4288  CanonArgs[I] = getCanonicalTemplateArgument(Args[I]);
4289  if (!CanonArgs[I].structurallyEquals(Args[I]))
4290  AnyNonCanonArgs = true;
4291  }
4292 
4293  QualType Canon;
4294  if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
4295  Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
4296  Name,
4297  CanonArgs);
4298 
4299  // Find the insert position again.
4300  DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4301  }
4302 
4303  void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
4304  sizeof(TemplateArgument) * NumArgs),
4305  TypeAlignment);
4306  T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
4307  Name, Args, Canon);
4308  Types.push_back(T);
4309  DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
4310  return QualType(T, 0);
4311 }
4312 
4314  TemplateArgument Arg;
4315  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
4316  QualType ArgType = getTypeDeclType(TTP);
4317  if (TTP->isParameterPack())
4318  ArgType = getPackExpansionType(ArgType, None);
4319 
4320  Arg = TemplateArgument(ArgType);
4321  } else if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4322  Expr *E = new (*this) DeclRefExpr(
4323  *this, NTTP, /*enclosing*/ false,
4324  NTTP->getType().getNonLValueExprType(*this),
4325  Expr::getValueKindForType(NTTP->getType()), NTTP->getLocation());
4326 
4327  if (NTTP->isParameterPack())
4328  E = new (*this) PackExpansionExpr(DependentTy, E, NTTP->getLocation(),
4329  None);
4330  Arg = TemplateArgument(E);
4331  } else {
4332  auto *TTP = cast<TemplateTemplateParmDecl>(Param);
4333  if (TTP->isParameterPack())
4335  else
4336  Arg = TemplateArgument(TemplateName(TTP));
4337  }
4338 
4339  if (Param->isTemplateParameterPack())
4340  Arg = TemplateArgument::CreatePackCopy(*this, Arg);
4341 
4342  return Arg;
4343 }
4344 
4345 void
4348  Args.reserve(Args.size() + Params->size());
4349 
4350  for (NamedDecl *Param : *Params)
4351  Args.push_back(getInjectedTemplateArg(Param));
4352 }
4353 
4355  Optional<unsigned> NumExpansions) {
4356  llvm::FoldingSetNodeID ID;
4357  PackExpansionType::Profile(ID, Pattern, NumExpansions);
4358 
4359  assert(Pattern->containsUnexpandedParameterPack() &&
4360  "Pack expansions must expand one or more parameter packs");
4361  void *InsertPos = nullptr;
4363  = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4364  if (T)
4365  return QualType(T, 0);
4366 
4367  QualType Canon;
4368  if (!Pattern.isCanonical()) {
4369  Canon = getCanonicalType(Pattern);
4370  // The canonical type might not contain an unexpanded parameter pack, if it
4371  // contains an alias template specialization which ignores one of its
4372  // parameters.
4373  if (Canon->containsUnexpandedParameterPack()) {
4374  Canon = getPackExpansionType(Canon, NumExpansions);
4375 
4376  // Find the insert position again, in case we inserted an element into
4377  // PackExpansionTypes and invalidated our insert position.
4378  PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4379  }
4380  }
4381 
4382  T = new (*this, TypeAlignment)
4383  PackExpansionType(Pattern, Canon, NumExpansions);
4384  Types.push_back(T);
4385  PackExpansionTypes.InsertNode(T, InsertPos);
4386  return QualType(T, 0);
4387 }
4388 
4389 /// CmpProtocolNames - Comparison predicate for sorting protocols
4390 /// alphabetically.
4391 static int CmpProtocolNames(ObjCProtocolDecl *const *LHS,
4392  ObjCProtocolDecl *const *RHS) {
4393  return DeclarationName::compare((*LHS)->getDeclName(), (*RHS)->getDeclName());
4394 }
4395 
4397  if (Protocols.empty()) return true;
4398 
4399  if (Protocols[0]->getCanonicalDecl() != Protocols[0])
4400  return false;
4401 
4402  for (unsigned i = 1; i != Protocols.size(); ++i)
4403  if (CmpProtocolNames(&Protocols[i - 1], &Protocols[i]) >= 0 ||
4404  Protocols[i]->getCanonicalDecl() != Protocols[i])
4405  return false;
4406  return true;
4407 }
4408 
4409 static void
4411  // Sort protocols, keyed by name.
4412  llvm::array_pod_sort(Protocols.begin(), Protocols.end(), CmpProtocolNames);
4413 
4414  // Canonicalize.
4415  for (ObjCProtocolDecl *&P : Protocols)
4416  P = P->getCanonicalDecl();
4417 
4418  // Remove duplicates.
4419  auto ProtocolsEnd = std::unique(Protocols.begin(), Protocols.end());
4420  Protocols.erase(ProtocolsEnd, Protocols.end());
4421 }
4422 
4424  ObjCProtocolDecl * const *Protocols,
4425  unsigned NumProtocols) const {
4426  return getObjCObjectType(BaseType, {},
4427  llvm::makeArrayRef(Protocols, NumProtocols),
4428  /*isKindOf=*/false);
4429 }
4430 
4432  QualType baseType,
4433  ArrayRef<QualType> typeArgs,
4434  ArrayRef<ObjCProtocolDecl *> protocols,
4435  bool isKindOf) const {
4436  // If the base type is an interface and there aren't any protocols or
4437  // type arguments to add, then the interface type will do just fine.
4438  if (typeArgs.empty() && protocols.empty() && !isKindOf &&
4439  isa<ObjCInterfaceType>(baseType))
4440  return baseType;
4441 
4442  // Look in the folding set for an existing type.
4443  llvm::FoldingSetNodeID ID;
4444  ObjCObjectTypeImpl::Profile(ID, baseType, typeArgs, protocols, isKindOf);
4445  void *InsertPos = nullptr;
4446  if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
4447  return QualType(QT, 0);
4448 
4449  // Determine the type arguments to be used for canonicalization,
4450  // which may be explicitly specified here or written on the base
4451  // type.
4452  ArrayRef<QualType> effectiveTypeArgs = typeArgs;
4453  if (effectiveTypeArgs.empty()) {
4454  if (const auto *baseObject = baseType->getAs<ObjCObjectType>())
4455  effectiveTypeArgs = baseObject->getTypeArgs();
4456  }
4457 
4458  // Build the canonical type, which has the canonical base type and a
4459  // sorted-and-uniqued list of protocols and the type arguments
4460  // canonicalized.
4461  QualType canonical;
4462  bool typeArgsAreCanonical = std::all_of(effectiveTypeArgs.begin(),
4463  effectiveTypeArgs.end(),
4464  [&](QualType type) {
4465  return type.isCanonical();
4466  });
4467  bool protocolsSorted = areSortedAndUniqued(protocols);
4468  if (!typeArgsAreCanonical || !protocolsSorted || !baseType.isCanonical()) {
4469  // Determine the canonical type arguments.
4470  ArrayRef<QualType> canonTypeArgs;
4471  SmallVector<QualType, 4> canonTypeArgsVec;
4472  if (!typeArgsAreCanonical) {
4473  canonTypeArgsVec.reserve(effectiveTypeArgs.size());
4474  for (auto typeArg : effectiveTypeArgs)
4475  canonTypeArgsVec.push_back(getCanonicalType(typeArg));
4476  canonTypeArgs = canonTypeArgsVec;
4477  } else {
4478  canonTypeArgs = effectiveTypeArgs;
4479  }
4480 
4481  ArrayRef<ObjCProtocolDecl *> canonProtocols;
4482  SmallVector<ObjCProtocolDecl*, 8> canonProtocolsVec;
4483  if (!protocolsSorted) {
4484  canonProtocolsVec.append(protocols.begin(), protocols.end());
4485  SortAndUniqueProtocols(canonProtocolsVec);
4486  canonProtocols = canonProtocolsVec;
4487  } else {
4488  canonProtocols = protocols;
4489  }
4490 
4491  canonical = getObjCObjectType(getCanonicalType(baseType), canonTypeArgs,
4492  canonProtocols, isKindOf);
4493 
4494  // Regenerate InsertPos.
4495  ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
4496  }
4497 
4498  unsigned size = sizeof(ObjCObjectTypeImpl);
4499  size += typeArgs.size() * sizeof(QualType);
4500  size += protocols.size() * sizeof(ObjCProtocolDecl *);
4501  void *mem = Allocate(size, TypeAlignment);
4502  auto *T =
4503  new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
4504  isKindOf);
4505 
4506  Types.push_back(T);
4507  ObjCObjectTypes.InsertNode(T, InsertPos);
4508  return QualType(T, 0);
4509 }
4510 
4511 /// Apply Objective-C protocol qualifiers to the given type.
4512 /// If this is for the canonical type of a type parameter, we can apply
4513 /// protocol qualifiers on the ObjCObjectPointerType.
4514 QualType
4516  ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
4517  bool allowOnPointerType) const {
4518  hasError = false;
4519 
4520  if (const auto *objT = dyn_cast<ObjCTypeParamType>(type.getTypePtr())) {
4521  return getObjCTypeParamType(objT->getDecl(), protocols);
4522  }
4523 
4524  // Apply protocol qualifiers to ObjCObjectPointerType.
4525  if (allowOnPointerType) {
4526  if (const auto *objPtr =
4527  dyn_cast<ObjCObjectPointerType>(type.getTypePtr())) {
4528  const ObjCObjectType *objT = objPtr->getObjectType();
4529  // Merge protocol lists and construct ObjCObjectType.
4530  SmallVector<ObjCProtocolDecl*, 8> protocolsVec;
4531  protocolsVec.append(objT->qual_begin(),
4532  objT->qual_end());
4533  protocolsVec.append(protocols.begin(), protocols.end());
4534  ArrayRef<ObjCProtocolDecl *> protocols = protocolsVec;
4535  type = getObjCObjectType(
4536  objT->getBaseType(),
4537  objT->getTypeArgsAsWritten(),
4538  protocols,
4539  objT->isKindOfTypeAsWritten());
4540  return getObjCObjectPointerType(type);
4541  }
4542  }
4543 
4544  // Apply protocol qualifiers to ObjCObjectType.
4545  if (const auto *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){
4546  // FIXME: Check for protocols to which the class type is already
4547  // known to conform.
4548 
4549  return getObjCObjectType(objT->getBaseType(),
4550  objT->getTypeArgsAsWritten(),
4551  protocols,
4552  objT->isKindOfTypeAsWritten());
4553  }
4554 
4555  // If the canonical type is ObjCObjectType, ...
4556  if (type->isObjCObjectType()) {
4557  // Silently overwrite any existing protocol qualifiers.
4558  // TODO: determine whether that's the right thing to do.
4559 
4560  // FIXME: Check for protocols to which the class type is already
4561  // known to conform.
4562  return getObjCObjectType(type, {}, protocols, false);
4563  }
4564 
4565  // id<protocol-list>
4566  if (type->isObjCIdType()) {
4567  const auto *objPtr = type->castAs<ObjCObjectPointerType>();
4568  type = getObjCObjectType(ObjCBuiltinIdTy, {}, protocols,
4569  objPtr->isKindOfType());
4570  return getObjCObjectPointerType(type);
4571  }
4572 
4573  // Class<protocol-list>
4574  if (type->isObjCClassType()) {
4575  const auto *objPtr = type->castAs<ObjCObjectPointerType>();
4576  type = getObjCObjectType(ObjCBuiltinClassTy, {}, protocols,
4577  objPtr->isKindOfType());
4578  return getObjCObjectPointerType(type);
4579  }
4580 
4581  hasError = true;
4582  return type;
4583 }
4584 
4585 QualType
4587  ArrayRef<ObjCProtocolDecl *> protocols,
4588  QualType Canonical) const {
4589  // Look in the folding set for an existing type.
4590  llvm::FoldingSetNodeID ID;
4591  ObjCTypeParamType::Profile(ID, Decl, protocols);
4592  void *InsertPos = nullptr;
4593  if (ObjCTypeParamType *TypeParam =
4594  ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
4595  return QualType(TypeParam, 0);
4596 
4597  if (Canonical.isNull()) {
4598  // We canonicalize to the underlying type.
4599  Canonical = getCanonicalType(Decl->getUnderlyingType());
4600  if (!protocols.empty()) {
4601  // Apply the protocol qualifers.
4602  bool hasError;
4604  Canonical, protocols, hasError, true /*allowOnPointerType*/));
4605  assert(!hasError && "Error when apply protocol qualifier to bound type");
4606  }
4607  }
4608 
4609  unsigned size = sizeof(ObjCTypeParamType);
4610  size += protocols.size() * sizeof(ObjCProtocolDecl *);
4611  void *mem = Allocate(size, TypeAlignment);
4612  auto *newType = new (mem) ObjCTypeParamType(Decl, Canonical, protocols);
4613 
4614  Types.push_back(newType);
4615  ObjCTypeParamTypes.InsertNode(newType, InsertPos);
4616  return QualType(newType, 0);
4617 }
4618 
4619 /// ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC's
4620 /// protocol list adopt all protocols in QT's qualified-id protocol
4621 /// list.
4623  ObjCInterfaceDecl *IC) {
4624  if (!QT->isObjCQualifiedIdType())
4625  return false;
4626 
4627  if (const auto *OPT = QT->getAs<ObjCObjectPointerType>()) {
4628  // If both the right and left sides have qualifiers.
4629  for (auto *Proto : OPT->quals()) {
4630  if (!IC->ClassImplementsProtocol(Proto, false))
4631  return false;
4632  }
4633  return true;
4634  }
4635  return false;
4636 }
4637 
4638 /// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
4639 /// QT's qualified-id protocol list adopt all protocols in IDecl's list
4640 /// of protocols.
4642  ObjCInterfaceDecl *IDecl) {
4643  if (!QT->isObjCQualifiedIdType())
4644  return false;
4645  const auto *OPT = QT->getAs<ObjCObjectPointerType>();
4646  if (!OPT)
4647  return false;
4648  if (!IDecl->hasDefinition())
4649  return false;
4650  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols;
4651  CollectInheritedProtocols(IDecl, InheritedProtocols);
4652  if (InheritedProtocols.empty())
4653  return false;
4654  // Check that if every protocol in list of id<plist> conforms to a protocol
4655  // of IDecl's, then bridge casting is ok.
4656  bool Conforms = false;
4657  for (auto *Proto : OPT->quals()) {
4658  Conforms = false;
4659  for (auto *PI : InheritedProtocols) {
4660  if (ProtocolCompatibleWithProtocol(Proto, PI)) {
4661  Conforms = true;
4662  break;
4663  }
4664  }
4665  if (!Conforms)
4666  break;
4667  }
4668  if (Conforms)
4669  return true;
4670 
4671  for (auto *PI : InheritedProtocols) {
4672  // If both the right and left sides have qualifiers.
4673  bool Adopts = false;
4674  for (auto *Proto : OPT->quals()) {
4675  // return 'true' if 'PI' is in the inheritance hierarchy of Proto
4676  if ((Adopts = ProtocolCompatibleWithProtocol(PI, Proto)))
4677  break;
4678  }
4679  if (!Adopts)
4680  return false;
4681  }
4682  return true;
4683 }
4684 
4685 /// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
4686 /// the given object type.
4688  llvm::FoldingSetNodeID ID;
4689  ObjCObjectPointerType::Profile(ID, ObjectT);
4690 
4691  void *InsertPos = nullptr;
4692  if (ObjCObjectPointerType *QT =
4693  ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
4694  return QualType(QT, 0);
4695 
4696  // Find the canonical object type.
4697  QualType Canonical;
4698  if (!ObjectT.isCanonical()) {
4699  Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));
4700 
4701  // Regenerate InsertPos.
4702  ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
4703  }
4704 
4705  // No match.
4706  void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
4707  auto *QType =
4708  new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
4709 
4710  Types.push_back(QType);
4711  ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
4712  return QualType(QType, 0);
4713 }
4714 
4715 /// getObjCInterfaceType - Return the unique reference to the type for the
4716 /// specified ObjC interface decl. The list of protocols is optional.
4718  ObjCInterfaceDecl *PrevDecl) const {
4719  if (Decl->TypeForDecl)
4720  return QualType(Decl->TypeForDecl, 0);
4721 
4722  if (PrevDecl) {
4723  assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl");
4724  Decl->TypeForDecl = PrevDecl->TypeForDecl;
4725  return QualType(PrevDecl->TypeForDecl, 0);
4726  }
4727 
4728  // Prefer the definition, if there is one.
4729  if (const ObjCInterfaceDecl *Def = Decl->getDefinition())
4730  Decl = Def;
4731 
4732  void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
4733  auto *T = new (Mem) ObjCInterfaceType(Decl);
4734  Decl->TypeForDecl = T;
4735  Types.push_back(T);
4736  return QualType(T, 0);
4737 }
4738 
4739 /// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
4740 /// TypeOfExprType AST's (since expression's are never shared). For example,
4741 /// multiple declarations that refer to "typeof(x)" all contain different
4742 /// DeclRefExpr's. This doesn't effect the type checker, since it operates
4743 /// on canonical type's (which are always unique).
4745  TypeOfExprType *toe;
4746  if (tofExpr->isTypeDependent()) {
4747  llvm::FoldingSetNodeID ID;
4748  DependentTypeOfExprType::Profile(ID, *this, tofExpr);
4749 
4750  void *InsertPos = nullptr;
4752  = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
4753  if (Canon) {
4754  // We already have a "canonical" version of an identical, dependent
4755  // typeof(expr) type. Use that as our canonical type.
4756  toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
4757  QualType((TypeOfExprType*)Canon, 0));
4758  } else {
4759  // Build a new, canonical typeof(expr) type.
4760  Canon
4761  = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
4762  DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
4763  toe = Canon;
4764  }
4765  } else {
4766  QualType Canonical = getCanonicalType(tofExpr->getType());
4767  toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
4768  }
4769  Types.push_back(toe);
4770  return QualType(toe, 0);
4771 }
4772 
4773 /// getTypeOfType - Unlike many "get<Type>" functions, we don't unique
4774 /// TypeOfType nodes. The only motivation to unique these nodes would be
4775 /// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
4776 /// an issue. This doesn't affect the type checker, since it operates
4777 /// on canonical types (which are always unique).
4779  QualType Canonical = getCanonicalType(tofType);
4780  auto *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
4781  Types.push_back(tot);
4782  return QualType(tot, 0);
4783 }
4784 
4785 /// Unlike many "get<Type>" functions, we don't unique DecltypeType
4786 /// nodes. This would never be helpful, since each such type has its own
4787 /// expression, and would not give a significant memory saving, since there
4788 /// is an Expr tree under each such type.
4790  DecltypeType *dt;
4791 
4792  // C++11 [temp.type]p2:
4793  // If an expression e involves a template parameter, decltype(e) denotes a
4794  // unique dependent type. Two such decltype-specifiers refer to the same
4795  // type only if their expressions are equivalent (14.5.6.1).
4796  if (e->isInstantiationDependent()) {
4797  llvm::FoldingSetNodeID ID;
4798  DependentDecltypeType::Profile(ID, *this, e);
4799 
4800  void *InsertPos = nullptr;
4801  DependentDecltypeType *Canon
4802  = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
4803  if (!Canon) {
4804  // Build a new, canonical decltype(expr) type.
4805  Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
4806  DependentDecltypeTypes.InsertNode(Canon, InsertPos);
4807  }
4808  dt = new (*this, TypeAlignment)
4809  DecltypeType(e, UnderlyingType, QualType((DecltypeType *)Canon, 0));
4810  } else {
4811  dt = new (*this, TypeAlignment)
4812  DecltypeType(e, UnderlyingType, getCanonicalType(UnderlyingType));
4813  }
4814  Types.push_back(dt);
4815  return QualType(dt, 0);
4816 }
4817 
4818 /// getUnaryTransformationType - We don't unique these, since the memory
4819 /// savings are minimal and these are rare.
4821  QualType UnderlyingType,
4823  const {
4824  UnaryTransformType *ut = nullptr;
4825 
4826  if (BaseType->isDependentType()) {
4827  // Look in the folding set for an existing type.
4828  llvm::FoldingSetNodeID ID;
4830 
4831  void *InsertPos = nullptr;
4833  = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
4834 
4835  if (!Canon) {
4836  // Build a new, canonical __underlying_type(type) type.
4837  Canon = new (*this, TypeAlignment)
4839  Kind);
4840  DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);
4841  }
4842  ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4843  QualType(), Kind,
4844  QualType(Canon, 0));
4845  } else {
4846  QualType CanonType = getCanonicalType(UnderlyingType);
4847  ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4848  UnderlyingType, Kind,
4849  CanonType);
4850  }
4851  Types.push_back(ut);
4852  return QualType(ut, 0);
4853 }
4854 
4855 /// getAutoType - Return the uniqued reference to the 'auto' type which has been
4856 /// deduced to the given type, or to the canonical undeduced 'auto' type, or the
4857 /// canonical deduced-but-dependent 'auto' type.
4859  bool IsDependent) const {
4860  if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto && !IsDependent)
4861  return getAutoDeductType();
4862 
4863  // Look in the folding set for an existing type.
4864  void *InsertPos = nullptr;
4865  llvm::FoldingSetNodeID ID;
4866  AutoType::Profile(ID, DeducedType, Keyword, IsDependent);
4867  if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
4868  return QualType(AT, 0);
4869 
4870  auto *AT = new (*this, TypeAlignment)
4871  AutoType(DeducedType, Keyword, IsDependent);
4872  Types.push_back(AT);
4873  if (InsertPos)
4874  AutoTypes.InsertNode(AT, InsertPos);
4875  return QualType(AT, 0);
4876 }
4877 
4878 /// Return the uniqued reference to the deduced template specialization type
4879 /// which has been deduced to the given type, or to the canonical undeduced
4880 /// such type, or the canonical deduced-but-dependent such type.
4882  TemplateName Template, QualType DeducedType, bool IsDependent) const {
4883  // Look in the folding set for an existing type.
4884  void *InsertPos = nullptr;
4885  llvm::FoldingSetNodeID ID;
4886  DeducedTemplateSpecializationType::Profile(ID, Template, DeducedType,
4887  IsDependent);
4889  DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
4890  return QualType(DTST, 0);
4891 
4892  auto *DTST = new (*this, TypeAlignment)
4893  DeducedTemplateSpecializationType(Template, DeducedType, IsDependent);
4894  Types.push_back(DTST);
4895  if (InsertPos)
4896  DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
4897  return QualType(DTST, 0);
4898 }
4899 
4900 /// getAtomicType - Return the uniqued reference to the atomic type for
4901 /// the given value type.
4903  // Unique pointers, to guarantee there is only one pointer of a particular
4904  // structure.
4905  llvm::FoldingSetNodeID ID;
4906  AtomicType::Profile(ID, T);
4907 
4908  void *InsertPos = nullptr;
4909  if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
4910  return QualType(AT, 0);
4911 
4912  // If the atomic value type isn't canonical, this won't be a canonical type
4913  // either, so fill in the canonical type field.
4914  QualType Canonical;
4915  if (!T.isCanonical()) {
4916  Canonical = getAtomicType(getCanonicalType(T));
4917 
4918  // Get the new insert position for the node we care about.
4919  AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
4920  assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
4921  }
4922  auto *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
4923  Types.push_back(New);
4924  AtomicTypes.InsertNode(New, InsertPos);
4925  return QualType(New, 0);
4926 }
4927 
4928 /// getAutoDeductType - Get type pattern for deducing against 'auto'.
4930  if (AutoDeductTy.isNull())
4933  /*dependent*/false),
4934  0);
4935  return AutoDeductTy;
4936 }
4937 
4938 /// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'.
4940  if (AutoRRefDeductTy.isNull())
4942  assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern");
4943  return AutoRRefDeductTy;
4944 }
4945 
4946 /// getTagDeclType - Return the unique reference to the type for the
4947 /// specified TagDecl (struct/union/class/enum) decl.
4949  assert(Decl);
4950  // FIXME: What is the design on getTagDeclType when it requires casting
4951  // away const? mutable?
4952  return getTypeDeclType(const_cast<TagDecl*>(Decl));
4953 }
4954 
4955 /// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
4956 /// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
4957 /// needs to agree with the definition in <stddef.h>.
4959  return getFromTargetType(Target->getSizeType());
4960 }
4961 
4962 /// Return the unique signed counterpart of the integer type
4963 /// corresponding to size_t.
4965  return getFromTargetType(Target->getSignedSizeType());
4966 }
4967 
4968 /// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5).
4970  return getFromTargetType(Target->getIntMaxType());
4971 }
4972 
4973 /// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5).
4975  return getFromTargetType(Target->getUIntMaxType());
4976 }
4977 
4978 /// getSignedWCharType - Return the type of "signed wchar_t".
4979 /// Used when in C++, as a GCC extension.
4981  // FIXME: derive from "Target" ?
4982  return WCharTy;
4983 }
4984 
4985 /// getUnsignedWCharType - Return the type of "unsigned wchar_t".
4986 /// Used when in C++, as a GCC extension.
4988  // FIXME: derive from "Target" ?
4989  return UnsignedIntTy;
4990 }
4991 
4993  return getFromTargetType(Target->getIntPtrType());
4994 }
4995 
4998 }
4999 
5000 /// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17)
5001 /// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
5003  return getFromTargetType(Target->getPtrDiffType(0));
5004 }
5005 
5006 /// Return the unique unsigned counterpart of "ptrdiff_t"
5007 /// integer type. The standard (C11 7.21.6.1p7) refers to this type
5008 /// in the definition of %tu format specifier.
5010  return getFromTargetType(Target->getUnsignedPtrDiffType(0));
5011 }
5012 
5013 /// Return the unique type for "pid_t" defined in
5014 /// <sys/types.h>. We need this to compute the correct type for vfork().
5016  return getFromTargetType(Target->getProcessIDType());
5017 }
5018 
5019 //===----------------------------------------------------------------------===//
5020 // Type Operators
5021 //===----------------------------------------------------------------------===//
5022 
5024  // Push qualifiers into arrays, and then discard any remaining
5025  // qualifiers.
5026  T = getCanonicalType(T);
5028  const Type *Ty = T.getTypePtr();
5029  QualType Result;
5030  if (isa<ArrayType>(Ty)) {
5031  Result = getArrayDecayedType(QualType(Ty,0));
5032  } else if (isa<FunctionType>(Ty)) {
5033  Result = getPointerType(QualType(Ty, 0));
5034  } else {
5035  Result = QualType(Ty, 0);
5036  }
5037 
5038  return CanQualType::CreateUnsafe(Result);
5039 }
5040 
5042  Qualifiers &quals) {
5043  SplitQualType splitType = type.getSplitUnqualifiedType();
5044 
5045  // FIXME: getSplitUnqualifiedType() actually walks all the way to
5046  // the unqualified desugared type and then drops it on the floor.
5047  // We then have to strip that sugar back off with
5048  // getUnqualifiedDesugaredType(), which is silly.
5049  const auto *AT =
5050  dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType());
5051 
5052  // If we don't have an array, just use the results in splitType.
5053  if (!AT) {
5054  quals = splitType.Quals;
5055  return QualType(splitType.Ty, 0);
5056  }
5057 
5058  // Otherwise, recurse on the array's element type.
5059  QualType elementType = AT->getElementType();
5060  QualType unqualElementType = getUnqualifiedArrayType(elementType, quals);
5061 
5062  // If that didn't change the element type, AT has no qualifiers, so we
5063  // can just use the results in splitType.
5064  if (elementType == unqualElementType) {
5065  assert(quals.empty()); // from the recursive call
5066  quals = splitType.Quals;
5067  return QualType(splitType.Ty, 0);
5068  }
5069 
5070  // Otherwise, add in the qualifiers from the outermost type, then
5071  // build the type back up.
5072  quals.addConsistentQualifiers(splitType.Quals);
5073 
5074  if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
5075  return getConstantArrayType(unqualElementType, CAT->getSize(),
5076  CAT->getSizeModifier(), 0);
5077  }
5078 
5079  if (const auto *IAT = dyn_cast<IncompleteArrayType>(AT)) {
5080  return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0);
5081  }
5082 
5083  if (const auto *VAT = dyn_cast<VariableArrayType>(AT)) {
5084  return getVariableArrayType(unqualElementType,
5085  VAT->getSizeExpr(),
5086  VAT->getSizeModifier(),
5087  VAT->getIndexTypeCVRQualifiers(),
5088  VAT->getBracketsRange());
5089  }
5090 
5091  const auto *DSAT = cast<DependentSizedArrayType>(AT);
5092  return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(),
5093  DSAT->getSizeModifier(), 0,
5094  SourceRange());
5095 }
5096 
5097 /// Attempt to unwrap two types that may both be array types with the same bound
5098 /// (or both be array types of unknown bound) for the purpose of comparing the
5099 /// cv-decomposition of two types per C++ [conv.qual].
5101  bool UnwrappedAny = false;
5102  while (true) {
5103  auto *AT1 = getAsArrayType(T1);
5104  if (!AT1) return UnwrappedAny;
5105 
5106  auto *AT2 = getAsArrayType(T2);
5107  if (!AT2) return UnwrappedAny;
5108 
5109  // If we don't have two array types with the same constant bound nor two
5110  // incomplete array types, we've unwrapped everything we can.
5111  if (auto *CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
5112  auto *CAT2 = dyn_cast<ConstantArrayType>(AT2);
5113  if (!CAT2 || CAT1->getSize() != CAT2->getSize())
5114  return UnwrappedAny;
5115  } else if (!isa<IncompleteArrayType>(AT1) ||
5116  !isa<IncompleteArrayType>(AT2)) {
5117  return UnwrappedAny;
5118  }
5119 
5120  T1 = AT1->getElementType();
5121  T2 = AT2->getElementType();
5122  UnwrappedAny = true;
5123  }
5124 }
5125 
5126 /// Attempt to unwrap two types that may be similar (C++ [conv.qual]).
5127 ///
5128 /// If T1 and T2 are both pointer types of the same kind, or both array types
5129 /// with the same bound, unwraps layers from T1 and T2 until a pointer type is
5130 /// unwrapped. Top-level qualifiers on T1 and T2 are ignored.
5131 ///
5132 /// This function will typically be called in a loop that successively
5133 /// "unwraps" pointer and pointer-to-member types to compare them at each
5134 /// level.
5135 ///
5136 /// \return \c true if a pointer type was unwrapped, \c false if we reached a
5137 /// pair of types that can't be unwrapped further.
5139  UnwrapSimilarArrayTypes(T1, T2);
5140 
5141  const auto *T1PtrType = T1->getAs<PointerType>();
5142  const auto *T2PtrType = T2->getAs<PointerType>();
5143  if (T1PtrType && T2PtrType) {
5144  T1 = T1PtrType->getPointeeType();
5145  T2 = T2PtrType->getPointeeType();
5146  return true;
5147  }
5148 
5149  const auto *T1MPType = T1->getAs<MemberPointerType>();
5150  const auto *T2MPType = T2->getAs<MemberPointerType>();
5151  if (T1MPType && T2MPType &&
5152  hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
5153  QualType(T2MPType->getClass(), 0))) {
5154  T1 = T1MPType->getPointeeType();
5155  T2 = T2MPType->getPointeeType();
5156  return true;
5157  }
5158 
5159  if (getLangOpts().ObjC) {
5160  const auto *T1OPType = T1->getAs<ObjCObjectPointerType>();
5161  const auto *T2OPType = T2->getAs<ObjCObjectPointerType>();
5162  if (T1OPType && T2OPType) {
5163  T1 = T1OPType->getPointeeType();
5164  T2 = T2OPType->getPointeeType();
5165  return true;
5166  }
5167  }
5168 
5169  // FIXME: Block pointers, too?
5170 
5171  return false;
5172 }
5173 
5175  while (true) {
5176  Qualifiers Quals;
5177  T1 = getUnqualifiedArrayType(T1, Quals);
5178  T2 = getUnqualifiedArrayType(T2, Quals);
5179  if (hasSameType(T1, T2))
5180  return true;
5181  if (!UnwrapSimilarTypes(T1, T2))
5182  return false;
5183  }
5184 }
5185 
5187  while (true) {
5188  Qualifiers Quals1, Quals2;
5189  T1 = getUnqualifiedArrayType(T1, Quals1);
5190  T2 = getUnqualifiedArrayType(T2, Quals2);
5191 
5192  Quals1.removeCVRQualifiers();
5193  Quals2.removeCVRQualifiers();
5194  if (Quals1 != Quals2)
5195  return false;
5196 
5197  if (hasSameType(T1, T2))
5198  return true;
5199 
5200  if (!UnwrapSimilarTypes(T1, T2))
5201  return false;
5202  }
5203 }
5204 
5207  SourceLocation NameLoc) const {
5208  switch (Name.getKind()) {
5211  // DNInfo work in progress: CHECKME: what about DNLoc?
5213  NameLoc);
5214 
5217  // DNInfo work in progress: CHECKME: what about DNLoc?
5218  return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc);
5219  }
5220 
5223  DeclarationName DName;
5224  if (DTN->isIdentifier()) {
5226  return DeclarationNameInfo(DName, NameLoc);
5227  } else {
5229  // DNInfo work in progress: FIXME: source locations?
5230  DeclarationNameLoc DNLoc;
5233  return DeclarationNameInfo(DName, NameLoc, DNLoc);
5234  }
5235  }
5236 
5240  return DeclarationNameInfo(subst->getParameter()->getDeclName(),
5241  NameLoc);
5242  }
5243 
5248  NameLoc);
5249  }
5250  }
5251 
5252  llvm_unreachable("bad template name kind!");
5253 }
5254 
5256  switch (Name.getKind()) {
5258  case TemplateName::Template: {
5259  TemplateDecl *Template = Name.getAsTemplateDecl();
5260  if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template))
5261  Template = getCanonicalTemplateTemplateParmDecl(TTP);
5262 
5263  // The canonical template name is the canonical template declaration.
5264  return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
5265  }
5266 
5268  llvm_unreachable("cannot canonicalize overloaded template");
5269 
5272  assert(DTN && "Non-dependent template names must refer to template decls.");
5273  return DTN->CanonicalTemplateName;
5274  }
5275 
5279  return getCanonicalTemplateName(subst->getReplacement());
5280  }
5281 
5285  TemplateTemplateParmDecl *canonParameter
5286  = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
5287  TemplateArgument canonArgPack
5289  return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
5290  }
5291  }
5292 
5293  llvm_unreachable("bad template name!");
5294 }
5295 
5297  X = getCanonicalTemplateName(X);
5298  Y = getCanonicalTemplateName(Y);
5299  return X.getAsVoidPointer() == Y.getAsVoidPointer();
5300 }
5301 
5304  switch (Arg.getKind()) {
5306  return Arg;
5307 
5309  return Arg;
5310 
5312  auto *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
5313  return TemplateArgument(D, Arg.getParamTypeForDecl());
5314  }
5315 
5318  /*isNullPtr*/true);
5319 
5322 
5326  Arg.getNumTemplateExpansions());
5327 
5330 
5333 
5334  case TemplateArgument::Pack: {
5335  if (Arg.pack_size() == 0)
5336  return Arg;
5337 
5338  auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
5339  unsigned Idx = 0;
5341  AEnd = Arg.pack_end();
5342  A != AEnd; (void)++A, ++Idx)
5343  CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
5344 
5345  return TemplateArgument(llvm::makeArrayRef(CanonArgs, Arg.pack_size()));
5346  }
5347  }
5348 
5349  // Silence GCC warning
5350  llvm_unreachable("Unhandled template argument kind");
5351 }
5352 
5355  if (!NNS)
5356  return nullptr;
5357 
5358  switch (NNS->getKind()) {
5360  // Canonicalize the prefix but keep the identifier the same.
5361  return NestedNameSpecifier::Create(*this,
5363  NNS->getAsIdentifier());
5364 
5366  // A namespace is canonical; build a nested-name-specifier with
5367  // this namespace and no prefix.
5368  return NestedNameSpecifier::Create(*this, nullptr,
5370 
5372  // A namespace is canonical; build a nested-name-specifier with
5373  // this namespace and no prefix.
5374  return NestedNameSpecifier::Create(*this, nullptr,
5376  ->getOriginalNamespace());
5377 
5380  QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
5381 
5382  // If we have some kind of dependent-named type (e.g., "typename T::type"),
5383  // break it apart into its prefix and identifier, then reconsititute those
5384  // as the canonical nested-name-specifier. This is required to canonicalize
5385  // a dependent nested-name-specifier involving typedefs of dependent-name
5386  // types, e.g.,
5387  // typedef typename T::type T1;
5388  // typedef typename T1::type T2;
5389  if (const auto *DNT = T->getAs<DependentNameType>())
5390  return NestedNameSpecifier::Create(*this, DNT->getQualifier(),
5391  const_cast<IdentifierInfo *>(DNT->getIdentifier()));
5392 
5393  // Otherwise, just canonicalize the type, and force it to be a TypeSpec.
5394  // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the
5395  // first place?
5396  return NestedNameSpecifier::Create(*this, nullptr, false,
5397  const_cast<Type *>(T.getTypePtr()));
5398  }
5399 
5402  // The global specifier and __super specifer are canonical and unique.
5403  return NNS;
5404  }
5405 
5406  llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
5407 }
5408 
5410  // Handle the non-qualified case efficiently.
5411  if (!T.hasLocalQualifiers()) {
5412  // Handle the common positive case fast.
5413  if (const auto *AT = dyn_cast<ArrayType>(T))
5414  return AT;
5415  }
5416 
5417  // Handle the common negative case fast.
5418  if (!isa<ArrayType>(T.getCanonicalType()))
5419  return nullptr;
5420 
5421  // Apply any qualifiers from the array type to the element type. This
5422  // implements C99 6.7.3p8: "If the specification of an array type includes
5423  // any type qualifiers, the element type is so qualified, not the array type."
5424 
5425  // If we get here, we either have type qualifiers on the type, or we have
5426  // sugar such as a typedef in the way. If we have type qualifiers on the type
5427  // we must propagate them down into the element type.
5428 
5430  Qualifiers qs = split.Quals;
5431 
5432  // If we have a simple case, just return now.
5433  const auto *ATy = dyn_cast<ArrayType>(split.Ty);
5434  if (!ATy || qs.empty())
5435  return ATy;
5436 
5437  // Otherwise, we have an array and we have qualifiers on it. Push the
5438  // qualifiers into the array element type and return a new array type.
5439  QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs);
5440 
5441  if (const auto *CAT = dyn_cast<ConstantArrayType>(ATy))
5442  return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
5443  CAT->getSizeModifier(),
5444  CAT->getIndexTypeCVRQualifiers()));
5445  if (const auto *IAT = dyn_cast<IncompleteArrayType>(ATy))
5446  return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
5447  IAT->getSizeModifier(),
5448  IAT->getIndexTypeCVRQualifiers()));
5449 
5450  if (const auto *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
5451  return cast<ArrayType>(
5452  getDependentSizedArrayType(NewEltTy,
5453  DSAT->getSizeExpr(),
5454  DSAT->getSizeModifier(),
5455  DSAT->getIndexTypeCVRQualifiers(),
5456  DSAT->getBracketsRange()));
5457 
5458  const auto *VAT = cast<VariableArrayType>(ATy);
5459  return cast<ArrayType>(getVariableArrayType(NewEltTy,
5460  VAT->getSizeExpr(),
5461  VAT->getSizeModifier(),
5462  VAT->getIndexTypeCVRQualifiers(),
5463  VAT->getBracketsRange()));
5464 }
5465 
5467  if (T->isArrayType() || T->isFunctionType())
5468  return getDecayedType(T);
5469  return T;
5470 }
5471 
5474  T = getAdjustedParameterType(T);
5475  return T.getUnqualifiedType();
5476 }
5477 
5479  // C++ [except.throw]p3:
5480  // A throw-expression initializes a temporary object, called the exception
5481  // object, the type of which is determined by removing any top-level
5482  // cv-qualifiers from the static type of the operand of throw and adjusting
5483  // the type from "array of T" or "function returning T" to "pointer to T"
5484  // or "pointer to function returning T", [...]
5486  if (T->isArrayType() || T->isFunctionType())
5487  T = getDecayedType(T);
5488  return T.getUnqualifiedType();
5489 }
5490 
5491 /// getArrayDecayedType - Return the properly qualified result of decaying the
5492 /// specified array type to a pointer. This operation is non-trivial when
5493 /// handling typedefs etc. The canonical type of "T" must be an array type,
5494 /// this returns a pointer to a properly qualified element of the array.
5495 ///
5496 /// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
5498  // Get the element type with 'getAsArrayType' so that we don't lose any
5499  // typedefs in the element type of the array. This also handles propagation
5500  // of type qualifiers from the array type into the element type if present
5501  // (C99 6.7.3p8).
5502  const ArrayType *PrettyArrayType = getAsArrayType(Ty);
5503  assert(PrettyArrayType && "Not an array type!");
5504 
5505  QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
5506 
5507  // int x[restrict 4] -> int *restrict
5509  PrettyArrayType->getIndexTypeQualifiers());
5510 
5511  // int x[_Nullable] -> int * _Nullable
5512  if (auto Nullability = Ty->getNullability(*this)) {
5513  Result = const_cast<ASTContext *>(this)->getAttributedType(
5515  }
5516  return Result;
5517 }
5518 
5520  return getBaseElementType(array->getElementType());
5521 }
5522 
5524  Qualifiers qs;
5525  while (true) {
5526  SplitQualType split = type.getSplitDesugaredType();
5527  const ArrayType *array = split.Ty->getAsArrayTypeUnsafe();
5528  if (!array) break;
5529 
5530  type = array->getElementType();
5531  qs.addConsistentQualifiers(split.Quals);
5532  }
5533 
5534  return getQualifiedType(type, qs);
5535 }
5536 
5537 /// getConstantArrayElementCount - Returns number of constant array elements.
5538 uint64_t
5540  uint64_t ElementCount = 1;
5541  do {
5542  ElementCount *= CA->getSize().getZExtValue();
5543  CA = dyn_cast_or_null<ConstantArrayType>(
5545  } while (CA);
5546  return ElementCount;
5547 }
5548 
5549 /// getFloatingRank - Return a relative rank for floating point types.
5550 /// This routine will assert if passed a built-in type that isn't a float.
5552  if (const auto *CT = T->getAs<ComplexType>())
5553  return getFloatingRank(CT->getElementType());
5554 
5555  assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type");
5556  switch (T->getAs<BuiltinType>()->getKind()) {
5557  default: llvm_unreachable("getFloatingRank(): not a floating type");
5558  case BuiltinType::Float16: return Float16Rank;
5559  case BuiltinType::Half: return HalfRank;
5560  case BuiltinType::Float: return FloatRank;
5561  case BuiltinType::Double: return DoubleRank;
5562  case BuiltinType::LongDouble: return LongDoubleRank;
5563  case BuiltinType::Float128: return Float128Rank;
5564  }
5565 }
5566 
5567 /// getFloatingTypeOfSizeWithinDomain - Returns a real floating
5568 /// point or a complex type (based on typeDomain/typeSize).
5569 /// 'typeDomain' is a real floating point or complex type.
5570 /// 'typeSize' is a real floating point or complex type.
5572  QualType Domain) const {
5573  FloatingRank EltRank = getFloatingRank(Size);
5574  if (Domain->isComplexType()) {
5575  switch (EltRank) {
5576  case Float16Rank:
5577  case HalfRank: llvm_unreachable("Complex half is not supported");
5578  case FloatRank: return FloatComplexTy;
5579  case DoubleRank: return DoubleComplexTy;
5580  case LongDoubleRank: return LongDoubleComplexTy;
5581  case Float128Rank: return Float128ComplexTy;
5582  }
5583  }
5584 
5585  assert(Domain->isRealFloatingType() && "Unknown domain!");
5586  switch (EltRank) {
5587  case Float16Rank: return HalfTy;
5588  case HalfRank: return HalfTy;
5589  case FloatRank: return FloatTy;
5590  case DoubleRank: return DoubleTy;
5591  case LongDoubleRank: return LongDoubleTy;
5592  case Float128Rank: return Float128Ty;
5593  }
5594  llvm_unreachable("getFloatingRank(): illegal value for rank");
5595 }
5596 
5597 /// getFloatingTypeOrder - Compare the rank of the two specified floating
5598 /// point types, ignoring the domain of the type (i.e. 'double' ==
5599 /// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
5600 /// LHS < RHS, return -1.
5602  FloatingRank LHSR = getFloatingRank(LHS);
5603  FloatingRank RHSR = getFloatingRank(RHS);
5604 
5605  if (LHSR == RHSR)
5606  return 0;
5607  if (LHSR > RHSR)
5608  return 1;
5609  return -1;
5610 }
5611 
5612 /// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
5613 /// routine will assert if passed a built-in type that isn't an integer or enum,
5614 /// or if it is not canonicalized.
5615 unsigned ASTContext::getIntegerRank(const Type *T) const {
5616  assert(T->isCanonicalUnqualified() && "T should be canonicalized");
5617 
5618  switch (cast<BuiltinType>(T)->getKind()) {
5619  default: llvm_unreachable("getIntegerRank(): not a built-in integer");
5620  case BuiltinType::Bool:
5621  return 1 + (getIntWidth(BoolTy) << 3);
5622  case BuiltinType::Char_S:
5623  case BuiltinType::Char_U:
5624  case BuiltinType::SChar:
5625  case BuiltinType::UChar:
5626  return 2 + (getIntWidth(CharTy) << 3);
5627  case BuiltinType::Short:
5628  case BuiltinType::UShort:
5629  return 3 + (getIntWidth(ShortTy) << 3);
5630  case BuiltinType::Int:
5631  case BuiltinType::UInt:
5632  return 4 + (getIntWidth(IntTy) << 3);
5633  case BuiltinType::Long:
5634  case BuiltinType::ULong:
5635  return 5 + (getIntWidth(LongTy) << 3);
5636  case BuiltinType::LongLong:
5637  case BuiltinType::ULongLong:
5638  return 6 + (getIntWidth(LongLongTy) << 3);
5639  case BuiltinType::Int128:
5640  case BuiltinType::UInt128:
5641  return 7 + (getIntWidth(Int128Ty) << 3);
5642  }
5643 }
5644 
5645 /// Whether this is a promotable bitfield reference according
5646 /// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
5647 ///
5648 /// \returns the type this bit-field will promote to, or NULL if no
5649 /// promotion occurs.
5651  if (E->isTypeDependent() || E->isValueDependent())
5652  return {};
5653 
5654  // C++ [conv.prom]p5:
5655  // If the bit-field has an enumerated type, it is treated as any other
5656  // value of that type for promotion purposes.
5657  if (getLangOpts().CPlusPlus && E->getType()->isEnumeralType())
5658  return {};
5659 
5660  // FIXME: We should not do this unless E->refersToBitField() is true. This
5661  // matters in C where getSourceBitField() will find bit-fields for various
5662  // cases where the source expression is not a bit-field designator.
5663 
5664  FieldDecl *Field = E->getSourceBitField(); // FIXME: conditional bit-fields?
5665  if (!Field)
5666  return {};
5667 
5668  QualType FT = Field->getType();
5669 
5670  uint64_t BitWidth = Field->getBitWidthValue(*this);
5671  uint64_t IntSize = getTypeSize(IntTy);
5672  // C++ [conv.prom]p5:
5673  // A prvalue for an integral bit-field can be converted to a prvalue of type
5674  // int if int can represent all the values of the bit-field; otherwise, it
5675  // can be converted to unsigned int if unsigned int can represent all the
5676  // values of the bit-field. If the bit-field is larger yet, no integral
5677  // promotion applies to it.
5678  // C11 6.3.1.1/2:
5679  // [For a bit-field of type _Bool, int, signed int, or unsigned int:]
5680  // If an int can represent all values of the original type (as restricted by
5681  // the width, for a bit-field), the value is converted to an int; otherwise,
5682  // it is converted to an unsigned int.
5683  //
5684  // FIXME: C does not permit promotion of a 'long : 3' bitfield to int.
5685  // We perform that promotion here to match GCC and C++.
5686  // FIXME: C does not permit promotion of an enum bit-field whose rank is
5687  // greater than that of 'int'. We perform that promotion to match GCC.
5688  if (BitWidth < IntSize)
5689  return IntTy;
5690 
5691  if (BitWidth == IntSize)
5692  return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy;
5693 
5694  // Bit-fields wider than int are not subject to promotions, and therefore act
5695  // like the base type. GCC has some weird bugs in this area that we
5696  // deliberately do not follow (GCC follows a pre-standard resolution to
5697  // C's DR315 which treats bit-width as being part of the type, and this leaks
5698  // into their semantics in some cases).
5699  return {};
5700 }
5701 
5702 /// getPromotedIntegerType - Returns the type that Promotable will
5703 /// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
5704 /// integer type.
5706  assert(!Promotable.isNull());
5707  assert(Promotable->isPromotableIntegerType());
5708  if (const auto *ET = Promotable->getAs<EnumType>())
5709  return ET->getDecl()->getPromotionType();
5710 
5711  if (const auto *BT = Promotable->getAs<BuiltinType>()) {
5712  // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t
5713  // (3.9.1) can be converted to a prvalue of the first of the following
5714  // types that can represent all the values of its underlying type:
5715  // int, unsigned int, long int, unsigned long int, long long int, or
5716  // unsigned long long int [...]
5717  // FIXME: Is there some better way to compute this?
5718  if (BT->getKind() == BuiltinType::WChar_S ||
5719  BT->getKind() == BuiltinType::WChar_U ||
5720  BT->getKind() == BuiltinType::Char8 ||
5721  BT->getKind() == BuiltinType::Char16 ||
5722  BT->getKind() == BuiltinType::Char32) {
5723  bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
5724  uint64_t FromSize = getTypeSize(BT);
5725  QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy,
5727  for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) {
5728  uint64_t ToSize = getTypeSize(PromoteTypes[Idx]);
5729  if (FromSize < ToSize ||
5730  (FromSize == ToSize &&
5731  FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType()))
5732  return PromoteTypes[Idx];
5733  }
5734  llvm_unreachable("char type should fit into long long");
5735  }
5736  }
5737 
5738  // At this point, we should have a signed or unsigned integer type.
5739  if (Promotable->isSignedIntegerType())
5740  return IntTy;
5741  uint64_t PromotableSize = getIntWidth(Promotable);
5742  uint64_t IntSize = getIntWidth(IntTy);
5743  assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize);
5744  return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
5745 }
5746 
5747 /// Recurses in pointer/array types until it finds an objc retainable
5748 /// type and returns its ownership.
5750  while (!T.isNull()) {
5752  return T.getObjCLifetime();
5753  if (T->isArrayType())
5754  T = getBaseElementType(T);
5755  else if (const auto *PT = T->getAs<PointerType>())
5756  T = PT->getPointeeType();
5757  else if (const auto *RT = T->getAs<ReferenceType>())
5758  T = RT->getPointeeType();
5759  else
5760  break;
5761  }
5762 
5763  return Qualifiers::OCL_None;
5764 }
5765 
5766 static const Type *getIntegerTypeForEnum(const EnumType *ET) {
5767  // Incomplete enum types are not treated as integer types.
5768  // FIXME: In C++, enum types are never integer types.
5769  if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
5770  return ET->getDecl()->getIntegerType().getTypePtr();
5771  return nullptr;
5772 }
5773 
5774 /// getIntegerTypeOrder - Returns the highest ranked integer type:
5775 /// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
5776 /// LHS < RHS, return -1.
5778  const Type *LHSC = getCanonicalType(LHS).getTypePtr();
5779  const Type *RHSC = getCanonicalType(RHS).getTypePtr();
5780 
5781  // Unwrap enums to their underlying type.
5782  if (const auto *ET = dyn_cast<EnumType>(LHSC))
5783  LHSC = getIntegerTypeForEnum(ET);
5784  if (const auto *ET = dyn_cast<EnumType>(RHSC))
5785  RHSC = getIntegerTypeForEnum(ET);
5786 
5787  if (LHSC == RHSC) return 0;
5788 
5789  bool LHSUnsigned = LHSC->isUnsignedIntegerType();
5790  bool RHSUnsigned = RHSC->isUnsignedIntegerType();
5791 
5792  unsigned LHSRank = getIntegerRank(LHSC);
5793  unsigned RHSRank = getIntegerRank(RHSC);
5794 
5795  if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
5796  if (LHSRank == RHSRank) return 0;
5797  return LHSRank > RHSRank ? 1 : -1;
5798  }
5799 
5800  // Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
5801  if (LHSUnsigned) {
5802  // If the unsigned [LHS] type is larger, return it.
5803  if (LHSRank >= RHSRank)
5804  return 1;
5805 
5806  // If the signed type can represent all values of the unsigned type, it
5807  // wins. Because we are dealing with 2's complement and types that are
5808  // powers of two larger than each other, this is always safe.
5809  return -1;
5810  }
5811 
5812  // If the unsigned [RHS] type is larger, return it.
5813  if (RHSRank >= LHSRank)
5814  return -1;
5815 
5816  // If the signed type can represent all values of the unsigned type, it
5817  // wins. Because we are dealing with 2's complement and types that are
5818  // powers of two larger than each other, this is always safe.
5819  return 1;
5820 }
5821 
5823  if (CFConstantStringTypeDecl)
5824  return CFConstantStringTypeDecl;
5825 
5826  assert(!CFConstantStringTagDecl &&
5827  "tag and typedef should be initialized together");
5828  CFConstantStringTagDecl = buildImplicitRecord("__NSConstantString_tag");
5829  CFConstantStringTagDecl->startDefinition();
5830 
5831  struct {
5832  QualType Type;
5833  const char *Name;
5834  } Fields[5];
5835  unsigned Count = 0;
5836 
5837  /// Objective-C ABI
5838  ///
5839  /// typedef struct __NSConstantString_tag {
5840  /// const int *isa;
5841  /// int flags;
5842  /// const char *str;
5843  /// long length;
5844  /// } __NSConstantString;
5845  ///
5846  /// Swift ABI (4.1, 4.2)
5847  ///
5848  /// typedef struct __NSConstantString_tag {
5849  /// uintptr_t _cfisa;
5850  /// uintptr_t _swift_rc;
5851  /// _Atomic(uint64_t) _cfinfoa;
5852  /// const char *_ptr;
5853  /// uint32_t _length;
5854  /// } __NSConstantString;
5855  ///
5856  /// Swift ABI (5.0)
5857  ///
5858  /// typedef struct __NSConstantString_tag {
5859  /// uintptr_t _cfisa;
5860  /// uintptr_t _swift_rc;
5861  /// _Atomic(uint64_t) _cfinfoa;
5862  /// const char *_ptr;
5863  /// uintptr_t _length;
5864  /// } __NSConstantString;
5865 
5866  const auto CFRuntime = getLangOpts().CFRuntime;
5867  if (static_cast<unsigned>(CFRuntime) <
5868  static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift)) {
5869  Fields[Count++] = { getPointerType(IntTy.withConst()), "isa" };
5870  Fields[Count++] = { IntTy, "flags" };
5871  Fields[Count++] = { getPointerType(CharTy.withConst()), "str" };
5872  Fields[Count++] = { LongTy, "length" };
5873  } else {
5874  Fields[Count++] = { getUIntPtrType(), "_cfisa" };
5875  Fields[Count++] = { getUIntPtrType(), "_swift_rc" };
5876  Fields[Count++] = { getFromTargetType(Target->getUInt64Type()), "_swift_rc" };
5877  Fields[Count++] = { getPointerType(CharTy.withConst()), "_ptr" };
5878  if (CFRuntime == LangOptions::CoreFoundationABI::Swift4_1 ||
5880  Fields[Count++] = { IntTy, "_ptr" };
5881  else
5882  Fields[Count++] = { getUIntPtrType(), "_ptr" };
5883  }
5884 
5885  // Create fields
5886  for (unsigned i = 0; i < Count; ++i) {
5887  FieldDecl *Field =
5888  FieldDecl::Create(*this, CFConstantStringTagDecl, SourceLocation(),
5889  SourceLocation(), &Idents.get(Fields[i].Name),
5890  Fields[i].Type, /*TInfo=*/nullptr,
5891  /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
5892  Field->setAccess(AS_public);
5893  CFConstantStringTagDecl->addDecl(Field);
5894  }
5895 
5896  CFConstantStringTagDecl->completeDefinition();
5897  // This type is designed to be compatible with NSConstantString, but cannot
5898  // use the same name, since NSConstantString is an interface.
5899  auto tagType = getTagDeclType(CFConstantStringTagDecl);
5900  CFConstantStringTypeDecl =
5901  buildImplicitTypedef(tagType, "__NSConstantString");
5902 
5903  return CFConstantStringTypeDecl;
5904 }
5905 
5907  if (!CFConstantStringTagDecl)
5908  getCFConstantStringDecl(); // Build the tag and the typedef.
5909  return CFConstantStringTagDecl;
5910 }
5911 
5912 // getCFConstantStringType - Return the type used for constant CFStrings.
5915 }
5916 
5918  if (ObjCSuperType.isNull()) {
5919  RecordDecl *ObjCSuperTypeDecl = buildImplicitRecord("objc_super");
5920  TUDecl->addDecl(ObjCSuperTypeDecl);
5921  ObjCSuperType = getTagDeclType(ObjCSuperTypeDecl);
5922  }
5923  return ObjCSuperType;
5924 }
5925 
5927  const auto *TD = T->getAs<TypedefType>();
5928  assert(TD && "Invalid CFConstantStringType");
5929  CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());
5930  const auto *TagType =
5931  CFConstantStringTypeDecl->getUnderlyingType()->getAs<RecordType>();
5932  assert(TagType && "Invalid CFConstantStringType");
5933  CFConstantStringTagDecl = TagType->getDecl();
5934 }
5935 
5937  if (BlockDescriptorType)
5938  return getTagDeclType(BlockDescriptorType);
5939 
5940  RecordDecl *RD;
5941  // FIXME: Needs the FlagAppleBlock bit.
5942  RD = buildImplicitRecord("__block_descriptor");
5943  RD->startDefinition();
5944 
5945  QualType FieldTypes[] = {
5948  };
5949 
5950  static const char *const FieldNames[] = {
5951  "reserved",
5952  "Size"
5953  };
5954 
5955  for (size_t i = 0; i < 2; ++i) {
5956  FieldDecl *Field = FieldDecl::Create(
5957  *this, RD, SourceLocation(), SourceLocation(),
5958  &Idents.get(FieldNames[i]), FieldTypes[i], /*TInfo=*/nullptr,
5959  /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
5960  Field->setAccess(AS_public);
5961  RD->addDecl(Field);
5962  }
5963 
5964  RD->completeDefinition();
5965 
5966  BlockDescriptorType = RD;
5967 
5968  return getTagDeclType(BlockDescriptorType);
5969 }
5970 
5972  if (BlockDescriptorExtendedType)
5973  return getTagDeclType(BlockDescriptorExtendedType);
5974 
5975  RecordDecl *RD;
5976  // FIXME: Needs the FlagAppleBlock bit.
5977  RD = buildImplicitRecord("__block_descriptor_withcopydispose");
5978  RD->startDefinition();
5979 
5980  QualType FieldTypes[] = {
5985  };
5986 
5987  static const char *const FieldNames[] = {
5988  "reserved",
5989  "Size",
5990  "CopyFuncPtr",
5991  "DestroyFuncPtr"
5992  };
5993 
5994  for (size_t i = 0; i < 4; ++i) {
5995  FieldDecl *Field = FieldDecl::Create(
5996  *this, RD, SourceLocation(), SourceLocation(),
5997  &Idents.get(FieldNames[i]), FieldTypes[i], /*TInfo=*/nullptr,
5998  /*BitWidth=*/nullptr,
5999  /*Mutable=*/false, ICIS_NoInit);
6000  Field->setAccess(AS_public);
6001  RD->addDecl(Field);
6002  }
6003 
6004  RD->completeDefinition();
6005 
6006  BlockDescriptorExtendedType = RD;
6007  return getTagDeclType(BlockDescriptorExtendedType);
6008 }
6009 
6011  const auto *BT = dyn_cast<BuiltinType>(T);
6012 
6013  if (!BT) {
6014  if (isa<PipeType>(T))
6015  return TargetInfo::OCLTK_Pipe;
6016 
6018  }
6019 
6020  switch (BT->getKind()) {
6021 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6022  case BuiltinType::Id: \
6023  return TargetInfo::OCLTK_Image;
6024 #include "clang/Basic/OpenCLImageTypes.def"
6025 
6026  case BuiltinType::OCLClkEvent:
6028 
6029  case BuiltinType::OCLEvent:
6030  return TargetInfo::OCLTK_Event;
6031 
6032  case BuiltinType::OCLQueue:
6033  return TargetInfo::OCLTK_Queue;
6034 
6035  case BuiltinType::OCLReserveID:
6037 
6038  case BuiltinType::OCLSampler:
6040 
6041  default:
6043  }
6044 }
6045 
6047  return Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T));
6048 }
6049 
6050 /// BlockRequiresCopying - Returns true if byref variable "D" of type "Ty"
6051 /// requires copy/dispose. Note that this must match the logic
6052 /// in buildByrefHelpers.
6054  const VarDecl *D) {
6055  if (const CXXRecordDecl *record = Ty->getAsCXXRecordDecl()) {
6056  const Expr *copyExpr = getBlockVarCopyInit(D).getCopyExpr();
6057  if (!copyExpr && record->hasTrivialDestructor()) return false;
6058 
6059  return true;
6060  }
6061 
6062  // The block needs copy/destroy helpers if Ty is non-trivial to destructively
6063  // move or destroy.
6065  return true;
6066 
6067  if (!Ty->isObjCRetainableType()) return false;
6068 
6069  Qualifiers qs = Ty.getQualifiers();
6070 
6071  // If we have lifetime, that dominates.
6072  if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) {
6073  switch (lifetime) {
6074  case Qualifiers::OCL_None: llvm_unreachable("impossible");
6075 
6076  // These are just bits as far as the runtime is concerned.
6079  return false;
6080 
6081  // These cases should have been taken care of when checking the type's
6082  // non-triviality.
6083  case Qualifiers::OCL_Weak:
6085  llvm_unreachable("impossible");
6086  }
6087  llvm_unreachable("fell out of lifetime switch!");
6088  }
6089  return (Ty->isBlockPointerType() || isObjCNSObjectType(Ty) ||
6090  Ty->isObjCObjectPointerType());
6091 }
6092 
6094  Qualifiers::ObjCLifetime &LifeTime,
6095  bool &HasByrefExtendedLayout) const {
6096  if (!getLangOpts().ObjC ||
6097  getLangOpts().getGC() != LangOptions::NonGC)
6098  return false;
6099 
6100  HasByrefExtendedLayout = false;
6101  if (Ty->isRecordType()) {
6102  HasByrefExtendedLayout = true;
6103  LifeTime = Qualifiers::OCL_None;
6104  } else if ((LifeTime = Ty.getObjCLifetime())) {
6105  // Honor the ARC qualifiers.
6106  } else if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) {
6107  // The MRR rule.
6108  LifeTime = Qualifiers::OCL_ExplicitNone;
6109  } else {
6110  LifeTime = Qualifiers::OCL_None;
6111  }
6112  return true;
6113 }
6114 
6116  if (!ObjCInstanceTypeDecl)
6117  ObjCInstanceTypeDecl =
6118  buildImplicitTypedef(getObjCIdType(), "instancetype");
6119  return ObjCInstanceTypeDecl;
6120 }
6121 
6122 // This returns true if a type has been typedefed to BOOL:
6123 // typedef <type> BOOL;
6125  if (const auto *TT = dyn_cast<TypedefType>(T))
6126  if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
6127  return II->isStr("BOOL");
6128 
6129  return false;
6130 }
6131 
6132 /// getObjCEncodingTypeSize returns size of type for objective-c encoding
6133 /// purpose.
6135  if (!type->isIncompleteArrayType() && type->isIncompleteType())
6136  return CharUnits::Zero();
6137 
6138  CharUnits sz = getTypeSizeInChars(type);
6139 
6140  // Make all integer and enum types at least as large as an int
6141  if (sz.isPositive() && type->isIntegralOrEnumerationType())
6142  sz = std::max(sz, getTypeSizeInChars(IntTy));
6143  // Treat arrays as pointers, since that's how they're passed in.
6144  else if (type->isArrayType())
6146  return sz;
6147 }
6148 
6150  return getTargetInfo().getCXXABI().isMicrosoft() &&
6151  VD->isStaticDataMember() &&
6153  !VD->getFirstDecl()->isOutOfLine() && VD->getFirstDecl()->hasInit();
6154 }
6155 
6158  if (!VD->isInline())
6160 
6161  // In almost all cases, it's a weak definition.
6162  auto *First = VD->getFirstDecl();
6163  if (First->isInlineSpecified() || !First->isStaticDataMember())
6165 
6166  // If there's a file-context declaration in this translation unit, it's a
6167  // non-discardable definition.
6168  for (auto *D : VD->redecls())
6169  if (D->getLexicalDeclContext()->isFileContext() &&
6170  !D->isInlineSpecified() && (D->isConstexpr() || First->isConstexpr()))
6172 
6173  // If we've not seen one yet, we don't know.
6175 }
6176 
6177 static std::string charUnitsToString(const CharUnits &CU) {
6178  return llvm::itostr(CU.getQuantity());
6179 }
6180 
6181 /// getObjCEncodingForBlock - Return the encoded type for this block
6182 /// declaration.
6184  std::string S;
6185 
6186  const BlockDecl *Decl = Expr->getBlockDecl();
6187  QualType BlockTy =
6188  Expr->getType()->getAs<BlockPointerType>()->getPointeeType();
6189  // Encode result type.
6190  if (getLangOpts().EncodeExtendedBlockSig)
6193  true /*Extended*/);
6194  else
6196  // Compute size of all parameters.
6197  // Start with computing size of a pointer in number of bytes.
6198  // FIXME: There might(should) be a better way of doing this computation!
6200  CharUnits ParmOffset = PtrSize;
6201  for (auto PI : Decl->parameters()) {
6202  QualType PType = PI->getType();
6203  CharUnits sz = getObjCEncodingTypeSize(PType);
6204  if (sz.isZero())
6205  continue;
6206  assert(sz.isPositive() && "BlockExpr - Incomplete param type");
6207  ParmOffset += sz;
6208  }
6209  // Size of the argument frame
6210  S += charUnitsToString(ParmOffset);
6211  // Block pointer and offset.
6212  S += "@?0";
6213 
6214  // Argument types.
6215  ParmOffset = PtrSize;
6216  for (auto PVDecl : Decl->parameters()) {
6217  QualType PType = PVDecl->getOriginalType();
6218  if (const auto *AT =
6219  dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
6220  // Use array's original type only if it has known number of
6221  // elements.
6222  if (!isa<ConstantArrayType>(AT))
6223  PType = PVDecl->getType();
6224  } else if (PType->isFunctionType())
6225  PType = PVDecl->getType();
6226  if (getLangOpts().EncodeExtendedBlockSig)
6228  S, true /*Extended*/);
6229  else
6230  getObjCEncodingForType(PType, S);
6231  S += charUnitsToString(ParmOffset);
6232  ParmOffset += getObjCEncodingTypeSize(PType);
6233  }
6234 
6235  return S;
6236 }
6237 
6238 std::string
6240  std::string S;
6241  // Encode result type.
6243  CharUnits ParmOffset;
6244  // Compute size of all parameters.
6245  for (auto PI : Decl->parameters()) {
6246  QualType PType = PI->getType();
6247  CharUnits sz = getObjCEncodingTypeSize(PType);
6248  if (sz.isZero())
6249  continue;
6250 
6251  assert(sz.isPositive() &&
6252  "getObjCEncodingForFunctionDecl - Incomplete param type");
6253  ParmOffset += sz;
6254  }
6255  S += charUnitsToString(ParmOffset);
6256  ParmOffset = CharUnits::Zero();
6257 
6258  // Argument types.
6259  for (auto PVDecl : Decl->parameters()) {
6260  QualType PType = PVDecl->getOriginalType();
6261  if (const auto *AT =
6262  dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
6263  // Use array's original type only if it has known number of
6264  // elements.
6265  if (!isa<ConstantArrayType>(AT))
6266  PType = PVDecl->getType();
6267  } else if (PType->isFunctionType())
6268  PType = PVDecl->getType();
6269  getObjCEncodingForType(PType, S);
6270  S += charUnitsToString(ParmOffset);
6271  ParmOffset += getObjCEncodingTypeSize(PType);
6272  }
6273 
6274  return S;
6275 }
6276 
6277 /// getObjCEncodingForMethodParameter - Return the encoded type for a single
6278 /// method parameter or return type. If Extended, include class names and
6279 /// block object types.
6281  QualType T, std::string& S,
6282  bool Extended) const {
6283  // Encode type qualifer, 'in', 'inout', etc. for the parameter.
6285  // Encode parameter type.
6286  getObjCEncodingForTypeImpl(T, S, true, true, nullptr,
6287  true /*OutermostType*/,
6288  false /*EncodingProperty*/,
6289  false /*StructField*/,
6290  Extended /*EncodeBlockParameters*/,
6291  Extended /*EncodeClassNames*/);
6292 }
6293 
6294 /// getObjCEncodingForMethodDecl - Return the encoded type for this method
6295 /// declaration.
6297  bool Extended) const {
6298  // FIXME: This is not very efficient.
6299  // Encode return type.
6300  std::string S;
6302  Decl->getReturnType(), S, Extended);
6303  // Compute size of all parameters.
6304  // Start with computing size of a pointer in number of bytes.
6305  // FIXME: There might(should) be a better way of doing this computation!
6307  // The first two arguments (self and _cmd) are pointers; account for
6308  // their size.
6309  CharUnits ParmOffset = 2 * PtrSize;
6311  E = Decl->sel_param_end(); PI != E; ++PI) {
6312  QualType PType = (*PI)->getType();
6313  CharUnits sz = getObjCEncodingTypeSize(PType);
6314  if (sz.isZero())
6315  continue;
6316 
6317  assert(sz.isPositive() &&
6318  "getObjCEncodingForMethodDecl - Incomplete param type");
6319  ParmOffset += sz;
6320  }
6321  S += charUnitsToString(ParmOffset);
6322  S += "@0:";
6323  S += charUnitsToString(PtrSize);
6324 
6325  // Argument types.
6326  ParmOffset = 2 * PtrSize;
6328  E = Decl->sel_param_end(); PI != E; ++PI) {
6329  const ParmVarDecl *PVDecl = *PI;
6330  QualType PType = PVDecl->getOriginalType();
6331  if (const auto *AT =
6332  dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
6333  // Use array's original type only if it has known number of
6334  // elements.
6335  if (!isa<ConstantArrayType>(AT))
6336  PType = PVDecl->getType();
6337  } else if (PType->isFunctionType())
6338  PType = PVDecl->getType();
6340  PType, S, Extended);
6341  S += charUnitsToString(ParmOffset);
6342  ParmOffset += getObjCEncodingTypeSize(PType);
6343  }
6344 
6345  return S;
6346 }
6347 
6350  const ObjCPropertyDecl *PD,
6351  const Decl *Container) const {
6352  if (!Container)
6353  return nullptr;
6354  if (const auto *CID = dyn_cast<ObjCCategoryImplDecl>(Container)) {
6355  for (auto *PID : CID->property_impls())
6356  if (PID->getPropertyDecl() == PD)
6357  return PID;
6358  } else {
6359  const auto *OID = cast<ObjCImplementationDecl>(Container);
6360  for (auto *PID : OID->property_impls())
6361  if (PID->getPropertyDecl() == PD)
6362  return PID;
6363  }
6364  return nullptr;
6365 }
6366 
6367 /// getObjCEncodingForPropertyDecl - Return the encoded type for this
6368 /// property declaration. If non-NULL, Container must be either an
6369 /// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be
6370 /// NULL when getting encodings for protocol properties.
6371 /// Property attributes are stored as a comma-delimited C string. The simple
6372 /// attributes readonly and bycopy are encoded as single characters. The
6373 /// parametrized attributes, getter=name, setter=name, and ivar=name, are
6374 /// encoded as single characters, followed by an identifier. Property types
6375 /// are also encoded as a parametrized attribute. The characters used to encode
6376 /// these attributes are defined by the following enumeration:
6377 /// @code
6378 /// enum PropertyAttributes {
6379 /// kPropertyReadOnly = 'R', // property is read-only.
6380 /// kPropertyBycopy = 'C', // property is a copy of the value last assigned
6381 /// kPropertyByref = '&', // property is a reference to the value last assigned
6382 /// kPropertyDynamic = 'D', // property is dynamic
6383 /// kPropertyGetter = 'G', // followed by getter selector name
6384 /// kPropertySetter = 'S', // followed by setter selector name
6385 /// kPropertyInstanceVariable = 'V' // followed by instance variable name
6386 /// kPropertyType = 'T' // followed by old-style type encoding.
6387 /// kPropertyWeak = 'W' // 'weak' property
6388 /// kPropertyStrong = 'P' // property GC'able
6389 /// kPropertyNonAtomic = 'N' // property non-atomic
6390 /// };
6391 /// @endcode
6392 std::string
6394  const Decl *Container) const {
6395  // Collect information from the property implementation decl(s).
6396  bool Dynamic = false;
6397  ObjCPropertyImplDecl *SynthesizePID = nullptr;
6398 
6399  if (ObjCPropertyImplDecl *PropertyImpDecl =
6400  getObjCPropertyImplDeclForPropertyDecl(PD, Container)) {
6401  if (PropertyImpDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
6402  Dynamic = true;
6403  else
6404  SynthesizePID = PropertyImpDecl;
6405  }
6406 
6407  // FIXME: This is not very efficient.
6408  std::string S = "T";
6409 
6410  // Encode result type.
6411  // GCC has some special rules regarding encoding of properties which
6412  // closely resembles encoding of ivars.
6414 
6415  if (PD->isReadOnly()) {
6416  S += ",R";
6418  S += ",C";
6420  S += ",&";
6422  S += ",W";
6423  } else {
6424  switch (PD->getSetterKind()) {
6425  case ObjCPropertyDecl::Assign: break;
6426  case ObjCPropertyDecl::Copy: S += ",C"; break;
6427  case ObjCPropertyDecl::Retain: S += ",&"; break;
6428  case ObjCPropertyDecl::Weak: S += ",W"; break;
6429  }
6430  }
6431 
6432  // It really isn't clear at all what this means, since properties
6433  // are "dynamic by default".
6434  if (Dynamic)
6435  S += ",D";
6436 
6438  S += ",N";
6439 
6441  S += ",G";
6442  S += PD->getGetterName().getAsString();
6443  }
6444 
6446  S += ",S";
6447  S += PD->getSetterName().getAsString();
6448  }
6449 
6450  if (SynthesizePID) {
6451  const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
6452  S += ",V";
6453  S += OID->getNameAsString();
6454  }
6455 
6456  // FIXME: OBJCGC: weak & strong
6457  return S;
6458 }
6459 
6460 /// getLegacyIntegralTypeEncoding -
6461 /// Another legacy compatibility encoding: 32-bit longs are encoded as
6462 /// 'l' or 'L' , but not always. For typedefs, we need to use
6463 /// 'i' or 'I' instead if encoding a struct field, or a pointer!
6465  if (isa<TypedefType>(PointeeTy.getTypePtr())) {
6466  if (const auto *BT = PointeeTy->getAs<BuiltinType>()) {
6467  if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32)
6468  PointeeTy = UnsignedIntTy;
6469  else
6470  if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32)
6471  PointeeTy = IntTy;
6472  }
6473  }
6474 }
6475 
6477  const FieldDecl *Field,
6478  QualType *NotEncodedT) const {
6479  // We follow the behavior of gcc, expanding structures which are
6480  // directly pointed to, and expanding embedded structures. Note that
6481  // these rules are sufficient to prevent recursive encoding of the
6482  // same type.
6483  getObjCEncodingForTypeImpl(T, S, true, true, Field,
6484  true /* outermost type */, false, false,
6485  false, false, false, NotEncodedT);
6486 }
6487 
6489  std::string& S) const {
6490  // Encode result type.
6491  // GCC has some special rules regarding encoding of properties which
6492  // closely resembles encoding of ivars.
6493  getObjCEncodingForTypeImpl(T, S, true, true, nullptr,
6494  true /* outermost type */,
6495  true /* encoding property */);
6496 }
6497 
6500  switch (kind) {
6501  case BuiltinType::Void: return 'v';
6502  case BuiltinType::Bool: return 'B';
6503  case BuiltinType::Char8:
6504  case BuiltinType::Char_U:
6505  case BuiltinType::UChar: return 'C';
6506  case BuiltinType::Char16:
6507  case BuiltinType::UShort: return 'S';
6508  case BuiltinType::Char32:
6509  case BuiltinType::UInt: return 'I';
6510  case BuiltinType::ULong:
6511  return C->getTargetInfo().getLongWidth() == 32 ? 'L' : 'Q';
6512  case BuiltinType::UInt128: return 'T';
6513  case BuiltinType::ULongLong: return 'Q';
6514  case BuiltinType::Char_S:
6515  case BuiltinType::SChar: return 'c';
6516  case BuiltinType::Short: return 's';
6517  case BuiltinType::WChar_S:
6518  case BuiltinType::WChar_U:
6519  case BuiltinType::Int: return 'i';
6520  case BuiltinType::Long:
6521  return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
6522  case BuiltinType::LongLong: return 'q';
6523  case BuiltinType::Int128: return 't';
6524  case BuiltinType::Float: return 'f';
6525  case BuiltinType::Double: return 'd';
6526  case BuiltinType::LongDouble: return 'D';
6527  case BuiltinType::NullPtr: return '*'; // like char*
6528 
6529  case BuiltinType::Float16:
6530  case BuiltinType::Float128:
6531  case BuiltinType::Half:
6532  case BuiltinType::ShortAccum:
6533  case BuiltinType::Accum:
6534  case BuiltinType::LongAccum:
6535  case BuiltinType::UShortAccum:
6536  case BuiltinType::UAccum:
6537  case BuiltinType::ULongAccum:
6538  case BuiltinType::ShortFract:
6539  case BuiltinType::Fract:
6540  case BuiltinType::LongFract:
6541  case BuiltinType::UShortFract:
6542  case BuiltinType::UFract:
6543  case BuiltinType::ULongFract:
6544  case BuiltinType::SatShortAccum:
6545  case BuiltinType::SatAccum:
6546  case BuiltinType::SatLongAccum:
6547  case BuiltinType::SatUShortAccum:
6548  case BuiltinType::SatUAccum:
6549  case BuiltinType::SatULongAccum:
6550  case BuiltinType::SatShortFract:
6551  case BuiltinType::SatFract:
6552  case BuiltinType::SatLongFract:
6553  case BuiltinType::SatUShortFract:
6554  case BuiltinType::SatUFract:
6555  case BuiltinType::SatULongFract:
6556  // FIXME: potentially need @encodes for these!
6557  return ' ';
6558 
6559  case BuiltinType::ObjCId:
6560  case BuiltinType::ObjCClass:
6561  case BuiltinType::ObjCSel:
6562  llvm_unreachable("@encoding ObjC primitive type");
6563 
6564  // OpenCL and placeholder types don't need @encodings.
6565 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6566  case BuiltinType::Id:
6567 #include "clang/Basic/OpenCLImageTypes.def"
6568 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
6569  case BuiltinType::Id:
6570 #include "clang/Basic/OpenCLExtensionTypes.def"
6571  case BuiltinType::OCLEvent:
6572  case BuiltinType::OCLClkEvent:
6573  case BuiltinType::OCLQueue:
6574  case BuiltinType::OCLReserveID:
6575  case BuiltinType::OCLSampler:
6576  case BuiltinType::Dependent:
6577 #define BUILTIN_TYPE(KIND, ID)
6578 #define PLACEHOLDER_TYPE(KIND, ID) \
6579  case BuiltinType::KIND:
6580 #include "clang/AST/BuiltinTypes.def"
6581  llvm_unreachable("invalid builtin type for @encode");
6582  }
6583  llvm_unreachable("invalid BuiltinType::Kind value");
6584 }
6585 
6586 static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) {
6587  EnumDecl *Enum = ET->getDecl();
6588 
6589  // The encoding of an non-fixed enum type is always 'i', regardless of size.
6590  if (!Enum->isFixed())
6591  return 'i';
6592 
6593  // The encoding of a fixed enum type matches its fixed underlying type.
6594  const auto *BT = Enum->getIntegerType()->castAs<BuiltinType>();
6595  return getObjCEncodingForPrimitiveKind(C, BT->getKind());
6596 }
6597 
6598 static void EncodeBitField(const ASTContext *Ctx, std::string& S,
6599  QualType T, const FieldDecl *FD) {
6600  assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl");
6601  S += 'b';
6602  // The NeXT runtime encodes bit fields as b followed by the number of bits.
6603  // The GNU runtime requires more information; bitfields are encoded as b,
6604  // then the offset (in bits) of the first element, then the type of the
6605  // bitfield, then the size in bits. For example, in this structure:
6606  //
6607  // struct
6608  // {
6609  // int integer;
6610  // int flags:2;
6611  // };
6612  // On a 32-bit system, the encoding for flags would be b2 for the NeXT
6613  // runtime, but b32i2 for the GNU runtime. The reason for this extra
6614  // information is not especially sensible, but we're stuck with it for
6615  // compatibility with GCC, although providing it breaks anything that
6616  // actually uses runtime introspection and wants to work on both runtimes...
6617  if (Ctx->getLangOpts().ObjCRuntime.isGNUFamily()) {
6618  uint64_t Offset;
6619 
6620  if (const auto *IVD = dyn_cast<ObjCIvarDecl>(FD)) {
6621  Offset = Ctx->lookupFieldBitOffset(IVD->getContainingInterface(), nullptr,
6622  IVD);
6623  } else {
6624  const RecordDecl *RD = FD->getParent();
6625  const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD);
6626  Offset = RL.getFieldOffset(FD->getFieldIndex());
6627  }
6628 
6629  S += llvm::utostr(Offset);
6630 
6631  if (const auto *ET = T->getAs<EnumType>())
6632  S += ObjCEncodingForEnumType(Ctx, ET);
6633  else {
6634  const auto *BT = T->castAs<BuiltinType>();
6635  S += getObjCEncodingForPrimitiveKind(Ctx, BT->getKind());
6636  }
6637  }
6638  S += llvm::utostr(FD->getBitWidthValue(*Ctx));
6639 }
6640 
6641 // FIXME: Use SmallString for accumulating string.
6642 void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S,
6643  bool ExpandPointedToStructures,
6644  bool ExpandStructures,
6645  const FieldDecl *FD,
6646  bool OutermostType,
6647  bool EncodingProperty,
6648  bool StructField,
6649  bool EncodeBlockParameters,
6650  bool EncodeClassNames,
6651  bool EncodePointerToObjCTypedef,
6652  QualType *NotEncodedT) const {
6653  CanQualType CT = getCanonicalType(T);
6654  switch (CT->getTypeClass()) {
6655  case Type::Builtin:
6656  case Type::Enum:
6657  if (FD && FD->isBitField())
6658  return EncodeBitField(this, S, T, FD);
6659  if (const auto *BT = dyn_cast<BuiltinType>(CT))
6660  S += getObjCEncodingForPrimitiveKind(this, BT->getKind());
6661  else
6662  S += ObjCEncodingForEnumType(this, cast<EnumType>(CT));
6663  return;
6664 
6665  case Type::Complex: {
6666  const auto *CT = T->castAs<ComplexType>();
6667  S += 'j';
6668  getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, nullptr);
6669  return;
6670  }
6671 
6672  case Type::Atomic: {
6673  const auto *AT = T->castAs<AtomicType>();
6674  S += 'A';
6675  getObjCEncodingForTypeImpl(AT->getValueType(), S, false, false, nullptr);
6676  return;
6677  }
6678 
6679  // encoding for pointer or reference types.
6680  case Type::Pointer:
6681  case Type::LValueReference:
6682  case Type::RValueReference: {
6683  QualType PointeeTy;
6684  if (isa<PointerType>(CT)) {
6685  const auto *PT = T->castAs<PointerType>();
6686  if (PT->isObjCSelType()) {
6687  S += ':';
6688  return;
6689  }
6690  PointeeTy = PT->getPointeeType();
6691  } else {
6692  PointeeTy = T->castAs<ReferenceType>()->getPointeeType();
6693  }
6694 
6695  bool isReadOnly = false;
6696  // For historical/compatibility reasons, the read-only qualifier of the
6697  // pointee gets emitted _before_ the '^'. The read-only qualifier of
6698  // the pointer itself gets ignored, _unless_ we are looking at a typedef!
6699  // Also, do not emit the 'r' for anything but the outermost type!
6700  if (isa<TypedefType>(T.getTypePtr())) {
6701  if (OutermostType && T.isConstQualified()) {
6702  isReadOnly = true;
6703  S += 'r';
6704  }
6705  } else if (OutermostType) {
6706  QualType P = PointeeTy;
6707  while (P->getAs<PointerType>())
6708  P = P->getAs<PointerType>()->getPointeeType();
6709  if (P.isConstQualified()) {
6710  isReadOnly = true;
6711  S += 'r';
6712  }
6713  }
6714  if (isReadOnly) {
6715  // Another legacy compatibility encoding. Some ObjC qualifier and type
6716  // combinations need to be rearranged.
6717  // Rewrite "in const" from "nr" to "rn"
6718  if (StringRef(S).endswith("nr"))
6719  S.replace(S.end()-2, S.end(), "rn");
6720  }
6721 
6722  if (PointeeTy->isCharType()) {
6723  // char pointer types should be encoded as '*' unless it is a
6724  // type that has been typedef'd to 'BOOL'.
6725  if (!isTypeTypedefedAsBOOL(PointeeTy)) {
6726  S += '*';
6727  return;
6728  }
6729  } else if (const auto *RTy = PointeeTy->getAs<RecordType>()) {
6730  // GCC binary compat: Need to convert "struct objc_class *" to "#".
6731  if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
6732  S += '#';
6733  return;
6734  }
6735  // GCC binary compat: Need to convert "struct objc_object *" to "@".
6736  if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
6737  S += '@';
6738  return;
6739  }
6740  // fall through...
6741  }
6742  S += '^';
6743  getLegacyIntegralTypeEncoding(PointeeTy);
6744 
6745  getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures,
6746  nullptr, false, false, false, false, false, false,
6747  NotEncodedT);
6748  return;
6749  }
6750 
6751  case Type::ConstantArray:
6752  case Type::IncompleteArray:
6753  case Type::VariableArray: {
6754  const auto *AT = cast<ArrayType>(CT);
6755 
6756  if (isa<IncompleteArrayType>(AT) && !StructField) {
6757  // Incomplete arrays are encoded as a pointer to the array element.
6758  S += '^';
6759 
6760  getObjCEncodingForTypeImpl(AT->getElementType(), S,
6761  false, ExpandStructures, FD);
6762  } else {
6763  S += '[';
6764 
6765  if (const auto *CAT = dyn_cast<ConstantArrayType>(AT))
6766  S += llvm::utostr(CAT->getSize().getZExtValue());
6767  else {
6768  //Variable length arrays are encoded as a regular array with 0 elements.
6769  assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) &&
6770  "Unknown array type!");
6771  S += '0';
6772  }
6773 
6774  getObjCEncodingForTypeImpl(AT->getElementType(), S,
6775  false, ExpandStructures, FD,
6776  false, false, false, false, false, false,
6777  NotEncodedT);
6778  S += ']';
6779  }
6780  return;
6781  }
6782 
6783  case Type::FunctionNoProto:
6784  case Type::FunctionProto:
6785  S += '?';
6786  return;
6787 
6788  case Type::Record: {
6789  RecordDecl *RDecl = cast<RecordType>(CT)->getDecl();
6790  S += RDecl->isUnion() ? '(' : '{';
6791  // Anonymous structures print as '?'
6792  if (const IdentifierInfo *II = RDecl->getIdentifier()) {
6793  S += II->getName();
6794  if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
6795  const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
6796  llvm::raw_string_ostream OS(S);
6797  printTemplateArgumentList(OS, TemplateArgs.asArray(),
6798  getPrintingPolicy());
6799  }
6800  } else {
6801  S += '?';
6802  }
6803  if (ExpandStructures) {
6804  S += '=';
6805  if (!RDecl->isUnion()) {
6806  getObjCEncodingForStructureImpl(RDecl, S, FD, true, NotEncodedT);
6807  } else {
6808  for (const auto *Field : RDecl->fields()) {
6809  if (FD) {
6810  S += '"';
6811  S += Field->getNameAsString();
6812  S += '"';
6813  }
6814 
6815  // Special case bit-fields.
6816  if (Field->isBitField()) {
6817  getObjCEncodingForTypeImpl(Field->getType(), S, false, true,
6818  Field);
6819  } else {
6820  QualType qt = Field->getType();
6822  getObjCEncodingForTypeImpl(qt, S, false, true,
6823  FD, /*OutermostType*/false,
6824  /*EncodingProperty*/false,
6825  /*StructField*/true,
6826  false, false, false, NotEncodedT);
6827  }
6828  }
6829  }
6830  }
6831  S += RDecl->isUnion() ? ')' : '}';
6832  return;
6833  }
6834 
6835  case Type::BlockPointer: {
6836  const auto *BT = T->castAs<BlockPointerType>();
6837  S += "@?"; // Unlike a pointer-to-function, which is "^?".
6838  if (EncodeBlockParameters) {
6839  const auto *FT = BT->getPointeeType()->castAs<FunctionType>();
6840 
6841  S += '<';
6842  // Block return type
6843  getObjCEncodingForTypeImpl(
6844  FT->getReturnType(), S, ExpandPointedToStructures, ExpandStructures,
6845  FD, false /* OutermostType */, EncodingProperty,
6846  false /* StructField */, EncodeBlockParameters, EncodeClassNames, false,
6847  NotEncodedT);
6848  // Block self
6849  S += "@?";
6850  // Block parameters
6851  if (const auto *FPT = dyn_cast<FunctionProtoType>(FT)) {
6852  for (const auto &I : FPT->param_types())
6853  getObjCEncodingForTypeImpl(
6854  I, S, ExpandPointedToStructures, ExpandStructures, FD,
6855  false /* OutermostType */, EncodingProperty,
6856  false /* StructField */, EncodeBlockParameters, EncodeClassNames,
6857  false, NotEncodedT);
6858  }
6859  S += '>';
6860  }
6861  return;
6862  }
6863 
6864  case Type::ObjCObject: {
6865  // hack to match legacy encoding of *id and *Class
6867  if (Ty->isObjCIdType()) {
6868  S += "{objc_object=}";
6869  return;
6870  }
6871  else if (Ty->isObjCClassType()) {
6872  S += "{objc_class=}";
6873  return;
6874  }
6875  // TODO: Double check to make sure this intentionally falls through.
6876  LLVM_FALLTHROUGH;
6877  }
6878 
6879  case Type::ObjCInterface: {
6880  // Ignore protocol qualifiers when mangling at this level.
6881  // @encode(class_name)
6882  ObjCInterfaceDecl *OI = T->castAs<ObjCObjectType>()->getInterface();
6883  S += '{';
6884  S += OI->getObjCRuntimeNameAsString();
6885  if (ExpandStructures) {
6886  S += '=';
6888  DeepCollectObjCIvars(OI, true, Ivars);
6889  for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
6890  const FieldDecl *Field = Ivars[i];
6891  if (Field->isBitField())
6892  getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field);
6893  else
6894  getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD,
6895  false, false, false, false, false,
6896  EncodePointerToObjCTypedef,
6897  NotEncodedT);
6898  }
6899  }
6900  S += '}';
6901  return;
6902  }
6903 
6904  case Type::ObjCObjectPointer: {
6905  const auto *OPT = T->castAs<ObjCObjectPointerType>();
6906  if (OPT->isObjCIdType()) {
6907  S += '@';
6908  return;
6909  }
6910 
6911  if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
6912  // FIXME: Consider if we need to output qualifiers for 'Class<p>'.
6913  // Since this is a binary compatibility issue, need to consult with runtime
6914  // folks. Fortunately, this is a *very* obscure construct.
6915  S += '#';
6916  return;
6917  }
6918 
6919  if (OPT->isObjCQualifiedIdType()) {
6920  getObjCEncodingForTypeImpl(getObjCIdType(), S,
6921  ExpandPointedToStructures,
6922  ExpandStructures, FD);
6923  if (FD || EncodingProperty || EncodeClassNames) {
6924  // Note that we do extended encoding of protocol qualifer list
6925  // Only when doing ivar or property encoding.
6926  S += '"';
6927  for (const auto *I : OPT->quals()) {
6928  S += '<';
6929  S += I->getObjCRuntimeNameAsString();
6930  S += '>';
6931  }
6932  S += '"';
6933  }
6934  return;
6935  }
6936 
6937  QualType PointeeTy = OPT->getPointeeType();
6938  if (!EncodingProperty &&
6939  isa<TypedefType>(PointeeTy.getTypePtr()) &&
6940  !EncodePointerToObjCTypedef) {
6941  // Another historical/compatibility reason.
6942  // We encode the underlying type which comes out as
6943  // {...};
6944  S += '^';
6945  if (FD && OPT->getInterfaceDecl()) {
6946  // Prevent recursive encoding of fields in some rare cases.
6947  ObjCInterfaceDecl *OI = OPT->getInterfaceDecl();
6949  DeepCollectObjCIvars(OI, true, Ivars);
6950  for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
6951  if (Ivars[i] == FD) {
6952  S += '{';
6953  S += OI->getObjCRuntimeNameAsString();
6954  S += '}';
6955  return;
6956  }
6957  }
6958  }
6959  getObjCEncodingForTypeImpl(PointeeTy, S,
6960  false, ExpandPointedToStructures,
6961  nullptr,
6962  false, false, false, false, false,
6963  /*EncodePointerToObjCTypedef*/true);
6964  return;
6965  }
6966 
6967  S += '@';
6968  if (OPT->getInterfaceDecl() &&
6969  (FD || EncodingProperty || EncodeClassNames)) {
6970  S += '"';
6971  S += OPT->getInterfaceDecl()->getObjCRuntimeNameAsString();
6972  for (const auto *I : OPT->quals()) {
6973  S += '<';
6974  S += I->getObjCRuntimeNameAsString();
6975  S += '>';
6976  }
6977  S += '"';
6978  }
6979  return;
6980  }
6981 
6982  // gcc just blithely ignores member pointers.
6983  // FIXME: we shoul do better than that. 'M' is available.
6984  case Type::MemberPointer:
6985  // This matches gcc's encoding, even though technically it is insufficient.
6986  //FIXME. We should do a better job than gcc.
6987  case Type::Vector:
6988  case Type::ExtVector:
6989  // Until we have a coherent encoding of these three types, issue warning.
6990  if (NotEncodedT)
6991  *NotEncodedT = T;
6992  return;
6993 
6994  // We could see an undeduced auto type here during error recovery.
6995  // Just ignore it.
6996  case Type::Auto:
6997  case Type::DeducedTemplateSpecialization:
6998  return;
6999 
7000  case Type::Pipe:
7001 #define ABSTRACT_TYPE(KIND, BASE)
7002 #define TYPE(KIND, BASE)
7003 #define DEPENDENT_TYPE(KIND, BASE) \
7004  case Type::KIND:
7005 #define NON_CANONICAL_TYPE(KIND, BASE) \
7006  case Type::KIND:
7007 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \
7008  case Type::KIND:
7009 #include "clang/AST/TypeNodes.def"
7010  llvm_unreachable("@encode for dependent type!");
7011  }
7012  llvm_unreachable("bad type kind!");
7013 }
7014 
7015 void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl,
7016  std::string &S,
7017  const FieldDecl *FD,
7018  bool includeVBases,
7019  QualType *NotEncodedT) const {
7020  assert(RDecl && "Expected non-null RecordDecl");
7021  assert(!RDecl->isUnion() && "Should not be called for unions");
7022  if (!RDecl->getDefinition() || RDecl->getDefinition()->isInvalidDecl())
7023  return;
7024 
7025  const auto *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
7026  std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;
7027  const ASTRecordLayout &layout = getASTRecordLayout(RDecl);
7028 
7029  if (CXXRec) {
7030  for (const auto &BI : CXXRec->bases()) {
7031  if (!BI.isVirtual()) {
7032  CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
7033  if (base->isEmpty())
7034  continue;
7035  uint64_t offs = toBits(layout.getBaseClassOffset(base));
7036  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
7037  std::make_pair(offs, base));
7038  }
7039  }
7040  }
7041 
7042  unsigned i = 0;
7043  for (auto *Field : RDecl->fields()) {
7044  uint64_t offs = layout.getFieldOffset(i);
7045  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
7046  std::make_pair(offs, Field));
7047  ++i;
7048  }
7049 
7050  if (CXXRec && includeVBases) {
7051  for (const auto &BI : CXXRec->vbases()) {
7052  CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
7053  if (base->isEmpty())
7054  continue;
7055  uint64_t offs = toBits(layout.getVBaseClassOffset(base));
7056  if (offs >= uint64_t(toBits(layout.getNonVirtualSize())) &&
7057  FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end())
7058  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(),
7059  std::make_pair(offs, base));
7060  }
7061  }
7062 
7063  CharUnits size;
7064  if (CXXRec) {
7065  size = includeVBases ? layout.getSize() : layout.getNonVirtualSize();
7066  } else {
7067  size = layout.getSize();
7068  }
7069 
7070 #ifndef NDEBUG
7071  uint64_t CurOffs = 0;
7072 #endif
7073  std::multimap<uint64_t, NamedDecl *>::iterator
7074  CurLayObj = FieldOrBaseOffsets.begin();
7075 
7076  if (CXXRec && CXXRec->isDynamicClass() &&
7077  (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
7078  if (FD) {
7079  S += "\"_vptr$";
7080  std::string recname = CXXRec->getNameAsString();
7081  if (recname.empty()) recname = "?";
7082  S += recname;
7083  S += '"';
7084  }
7085  S += "^^?";
7086 #ifndef NDEBUG
7087  CurOffs += getTypeSize(VoidPtrTy);
7088 #endif
7089  }
7090 
7091  if (!RDecl->hasFlexibleArrayMember()) {
7092  // Mark the end of the structure.
7093  uint64_t offs = toBits(size);
7094  FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
7095  std::make_pair(offs, nullptr));
7096  }
7097 
7098  for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {
7099 #ifndef NDEBUG
7100  assert(CurOffs <= CurLayObj->first);
7101  if (CurOffs < CurLayObj->first) {
7102  uint64_t padding = CurLayObj->first - CurOffs;
7103  // FIXME: There doesn't seem to be a way to indicate in the encoding that
7104  // packing/alignment of members is different that normal, in which case
7105  // the encoding will be out-of-sync with the real layout.
7106  // If the runtime switches to just consider the size of types without
7107  // taking into account alignment, we could make padding explicit in the
7108  // encoding (e.g. using arrays of chars). The encoding strings would be
7109  // longer then though.
7110  CurOffs += padding;
7111  }
7112 #endif
7113 
7114  NamedDecl *dcl = CurLayObj->second;
7115  if (!dcl)
7116  break; // reached end of structure.
7117 
7118  if (auto *base = dyn_cast<CXXRecordDecl>(dcl)) {
7119  // We expand the bases without their virtual bases since those are going
7120  // in the initial structure. Note that this differs from gcc which
7121  // expands virtual bases each time one is encountered in the hierarchy,
7122  // making the encoding type bigger than it really is.
7123  getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false,
7124  NotEncodedT);
7125  assert(!base->isEmpty());
7126 #ifndef NDEBUG
7127  CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize());
7128 #endif
7129  } else {
7130  const auto *field = cast<FieldDecl>(dcl);
7131  if (FD) {
7132  S += '"';
7133  S += field->getNameAsString();
7134  S += '"';
7135  }
7136 
7137  if (field->isBitField()) {
7138  EncodeBitField(this, S, field->getType(), field);
7139 #ifndef NDEBUG
7140  CurOffs += field->getBitWidthValue(*this);
7141 #endif
7142  } else {
7143  QualType qt = field->getType();
7145  getObjCEncodingForTypeImpl(qt, S, false, true, FD,
7146  /*OutermostType*/false,
7147  /*EncodingProperty*/false,
7148  /*StructField*/true,
7149  false, false, false, NotEncodedT);
7150 #ifndef NDEBUG
7151  CurOffs += getTypeSize(field->getType());
7152 #endif
7153  }
7154  }
7155  }
7156 }
7157 
7159  std::string& S) const {
7160  if (QT & Decl::OBJC_TQ_In)
7161  S += 'n';
7162  if (QT & Decl::OBJC_TQ_Inout)
7163  S += 'N';
7164  if (QT & Decl::OBJC_TQ_Out)
7165  S += 'o';
7166  if (QT & Decl::OBJC_TQ_Bycopy)
7167  S += 'O';
7168  if (QT & Decl::OBJC_TQ_Byref)
7169  S += 'R';
7170  if (QT & Decl::OBJC_TQ_Oneway)
7171  S += 'V';
7172 }
7173 
7175  if (!ObjCIdDecl) {
7177  T = getObjCObjectPointerType(T);
7178  ObjCIdDecl = buildImplicitTypedef(T, "id");
7179  }
7180  return ObjCIdDecl;
7181 }
7182 
7184  if (!ObjCSelDecl) {
7186  ObjCSelDecl = buildImplicitTypedef(T, "SEL");
7187  }
7188  return ObjCSelDecl;
7189 }
7190 
7192  if (!ObjCClassDecl) {
7194  T = getObjCObjectPointerType(T);
7195  ObjCClassDecl = buildImplicitTypedef(T, "Class");
7196  }
7197  return ObjCClassDecl;
7198 }
7199 
7201  if (!ObjCProtocolClassDecl) {
7202  ObjCProtocolClassDecl
7204  SourceLocation(),
7205  &Idents.get("Protocol"),
7206  /*typeParamList=*/nullptr,
7207  /*PrevDecl=*/nullptr,
7208  SourceLocation(), true);
7209  }
7210 
7211  return ObjCProtocolClassDecl;
7212 }
7213 
7214 //===----------------------------------------------------------------------===//
7215 // __builtin_va_list Construction Functions
7216 //===----------------------------------------------------------------------===//
7217 
7219  StringRef Name) {
7220  // typedef char* __builtin[_ms]_va_list;
7221  QualType T = Context->getPointerType(Context->CharTy);
7222  return Context->buildImplicitTypedef(T, Name);
7223 }
7224 
7225 static TypedefDecl *CreateMSVaListDecl(const ASTContext *Context) {
7226  return CreateCharPtrNamedVaListDecl(Context, "__builtin_ms_va_list");
7227 }
7228 
7230  return CreateCharPtrNamedVaListDecl(Context, "__builtin_va_list");
7231 }
7232 
7234  // typedef void* __builtin_va_list;
7235  QualType T = Context->getPointerType(Context->VoidTy);
7236  return Context->buildImplicitTypedef(T, "__builtin_va_list");
7237 }
7238 
7239 static TypedefDecl *
7241  // struct __va_list
7242  RecordDecl *VaListTagDecl = Context->buildImplicitRecord("__va_list");
7243  if (Context->getLangOpts().CPlusPlus) {
7244  // namespace std { struct __va_list {
7245  NamespaceDecl *NS;
7246  NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
7247  Context->getTranslationUnitDecl(),
7248  /*Inline*/ false, SourceLocation(),
7249  SourceLocation(), &Context->Idents.get("std"),
7250  /*PrevDecl*/ nullptr);
7251  NS->setImplicit();
7252  VaListTagDecl->setDeclContext(NS);
7253  }
7254 
7255  VaListTagDecl->startDefinition();
7256 
7257  const size_t NumFields = 5;
7258  QualType FieldTypes[NumFields];
7259  const char *FieldNames[NumFields];
7260 
7261  // void *__stack;
7262  FieldTypes[0] = Context->getPointerType(Context->VoidTy);
7263  FieldNames[0] = "__stack";
7264 
7265  // void *__gr_top;
7266  FieldTypes[1] = Context->getPointerType(Context->VoidTy);
7267  FieldNames[1] = "__gr_top";
7268 
7269  // void *__vr_top;
7270  FieldTypes[2] = Context->getPointerType(Context->VoidTy);
7271  FieldNames[2] = "__vr_top";
7272 
7273  // int __gr_offs;
7274  FieldTypes[3] = Context->IntTy;
7275  FieldNames[3] = "__gr_offs";
7276 
7277  // int __vr_offs;
7278  FieldTypes[4] = Context->IntTy;
7279  FieldNames[4] = "__vr_offs";
7280 
7281  // Create fields
7282  for (unsigned i = 0; i < NumFields; ++i) {
7283  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7284  VaListTagDecl,
7285  SourceLocation(),
7286  SourceLocation(),
7287  &Context->Idents.get(FieldNames[i]),
7288  FieldTypes[i], /*TInfo=*/nullptr,
7289  /*BitWidth=*/nullptr,
7290  /*Mutable=*/false,
7291  ICIS_NoInit);
7292  Field->setAccess(AS_public);
7293  VaListTagDecl->addDecl(Field);
7294  }
7295  VaListTagDecl->completeDefinition();
7296  Context->VaListTagDecl = VaListTagDecl;
7297  QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7298 
7299  // } __builtin_va_list;
7300  return Context->buildImplicitTypedef(VaListTagType, "__builtin_va_list");
7301 }
7302 
7304  // typedef struct __va_list_tag {
7306 
7307  VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
7308  VaListTagDecl->startDefinition();
7309 
7310  const size_t NumFields = 5;
7311  QualType FieldTypes[NumFields];
7312  const char *FieldNames[NumFields];
7313 
7314  // unsigned char gpr;
7315  FieldTypes[0] = Context->UnsignedCharTy;
7316  FieldNames[0] = "gpr";
7317 
7318  // unsigned char fpr;
7319  FieldTypes[1] = Context->UnsignedCharTy;
7320  FieldNames[1] = "fpr";
7321 
7322  // unsigned short reserved;
7323  FieldTypes[2] = Context->UnsignedShortTy;
7324  FieldNames[2] = "reserved";
7325 
7326  // void* overflow_arg_area;
7327  FieldTypes[3] = Context->getPointerType(Context->VoidTy);
7328  FieldNames[3] = "overflow_arg_area";
7329 
7330  // void* reg_save_area;
7331  FieldTypes[4] = Context->getPointerType(Context->VoidTy);
7332  FieldNames[4] = "reg_save_area";
7333 
7334  // Create fields
7335  for (unsigned i = 0; i < NumFields; ++i) {
7336  FieldDecl *Field = FieldDecl::Create(*Context, VaListTagDecl,
7337  SourceLocation(),
7338  SourceLocation(),
7339  &Context->Idents.get(FieldNames[i]),
7340  FieldTypes[i], /*TInfo=*/nullptr,
7341  /*BitWidth=*/nullptr,
7342  /*Mutable=*/false,
7343  ICIS_NoInit);
7344  Field->setAccess(AS_public);
7345  VaListTagDecl->addDecl(Field);
7346  }
7347  VaListTagDecl->completeDefinition();
7348  Context->VaListTagDecl = VaListTagDecl;
7349  QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7350 
7351  // } __va_list_tag;
7352  TypedefDecl *VaListTagTypedefDecl =
7353  Context->buildImplicitTypedef(VaListTagType, "__va_list_tag");
7354 
7355  QualType VaListTagTypedefType =
7356  Context->getTypedefType(VaListTagTypedefDecl);
7357 
7358  // typedef __va_list_tag __builtin_va_list[1];
7359  llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
7360  QualType VaListTagArrayType
7361  = Context->getConstantArrayType(VaListTagTypedefType,
7362  Size, ArrayType::Normal, 0);
7363  return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7364 }
7365 
7366 static TypedefDecl *
7368  // struct __va_list_tag {
7370  VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
7371  VaListTagDecl->startDefinition();
7372 
7373  const size_t NumFields = 4;
7374  QualType FieldTypes[NumFields];
7375  const char *FieldNames[NumFields];
7376 
7377  // unsigned gp_offset;
7378  FieldTypes[0] = Context->UnsignedIntTy;
7379  FieldNames[0] = "gp_offset";
7380 
7381  // unsigned fp_offset;
7382  FieldTypes[1] = Context->UnsignedIntTy;
7383  FieldNames[1] = "fp_offset";
7384 
7385  // void* overflow_arg_area;
7386  FieldTypes[2] = Context->getPointerType(Context->VoidTy);
7387  FieldNames[2] = "overflow_arg_area";
7388 
7389  // void* reg_save_area;
7390  FieldTypes[3] = Context->getPointerType(Context->VoidTy);
7391  FieldNames[3] = "reg_save_area";
7392 
7393  // Create fields
7394  for (unsigned i = 0; i < NumFields; ++i) {
7395  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7396  VaListTagDecl,
7397  SourceLocation(),
7398  SourceLocation(),
7399  &Context->Idents.get(FieldNames[i]),
7400  FieldTypes[i], /*TInfo=*/nullptr,
7401  /*BitWidth=*/nullptr,
7402  /*Mutable=*/false,
7403  ICIS_NoInit);
7404  Field->setAccess(AS_public);
7405  VaListTagDecl->addDecl(Field);
7406  }
7407  VaListTagDecl->completeDefinition();
7408  Context->VaListTagDecl = VaListTagDecl;
7409  QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7410 
7411  // };
7412 
7413  // typedef struct __va_list_tag __builtin_va_list[1];
7414  llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
7415  QualType VaListTagArrayType =
7416  Context->getConstantArrayType(VaListTagType, Size, ArrayType::Normal, 0);
7417  return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7418 }
7419 
7421  // typedef int __builtin_va_list[4];
7422  llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 4);
7423  QualType IntArrayType =
7424  Context->getConstantArrayType(Context->IntTy, Size, ArrayType::Normal, 0);
7425  return Context->buildImplicitTypedef(IntArrayType, "__builtin_va_list");
7426 }
7427 
7428 static TypedefDecl *
7430  // struct __va_list
7431  RecordDecl *VaListDecl = Context->buildImplicitRecord("__va_list");
7432  if (Context->getLangOpts().CPlusPlus) {
7433  // namespace std { struct __va_list {
7434  NamespaceDecl *NS;
7435  NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
7436  Context->getTranslationUnitDecl(),
7437  /*Inline*/false, SourceLocation(),
7438  SourceLocation(), &Context->Idents.get("std"),
7439  /*PrevDecl*/ nullptr);
7440  NS->setImplicit();
7441  VaListDecl->setDeclContext(NS);
7442  }
7443 
7444  VaListDecl->startDefinition();
7445 
7446  // void * __ap;
7447  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7448  VaListDecl,
7449  SourceLocation(),
7450  SourceLocation(),
7451  &Context->Idents.get("__ap"),
7452  Context->getPointerType(Context->VoidTy),
7453  /*TInfo=*/nullptr,
7454  /*BitWidth=*/nullptr,
7455  /*Mutable=*/false,
7456  ICIS_NoInit);
7457  Field->setAccess(AS_public);
7458  VaListDecl->addDecl(Field);
7459 
7460  // };
7461  VaListDecl->completeDefinition();
7462  Context->VaListTagDecl = VaListDecl;
7463 
7464  // typedef struct __va_list __builtin_va_list;
7465  QualType T = Context->getRecordType(VaListDecl);
7466  return Context->buildImplicitTypedef(T, "__builtin_va_list");
7467 }
7468 
7469 static TypedefDecl *
7471  // struct __va_list_tag {
7473  VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
7474  VaListTagDecl->startDefinition();
7475 
7476  const size_t NumFields = 4;
7477  QualType FieldTypes[NumFields];
7478  const char *FieldNames[NumFields];
7479 
7480  // long __gpr;
7481  FieldTypes[0] = Context->LongTy;
7482  FieldNames[0] = "__gpr";
7483 
7484  // long __fpr;
7485  FieldTypes[1] = Context->LongTy;
7486  FieldNames[1] = "__fpr";
7487 
7488  // void *__overflow_arg_area;
7489  FieldTypes[2] = Context->getPointerType(Context->VoidTy);
7490  FieldNames[2] = "__overflow_arg_area";
7491 
7492  // void *__reg_save_area;
7493  FieldTypes[3] = Context->getPointerType(Context->VoidTy);
7494  FieldNames[3] = "__reg_save_area";
7495 
7496  // Create fields
7497  for (unsigned i = 0; i < NumFields; ++i) {
7498  FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7499  VaListTagDecl,
7500  SourceLocation(),
7501  SourceLocation(),
7502  &Context->Idents.get(FieldNames[i]),
7503  FieldTypes[i], /*TInfo=*/nullptr,
7504  /*BitWidth=*/nullptr,
7505  /*Mutable=*/false,
7506  ICIS_NoInit);
7507  Field->setAccess(AS_public);
7508  VaListTagDecl->addDecl(Field);
7509  }
7510  VaListTagDecl->completeDefinition();
7511  Context->VaListTagDecl = VaListTagDecl;
7512  QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7513 
7514  // };
7515 
7516  // typedef __va_list_tag __builtin_va_list[1];
7517  llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
7518  QualType VaListTagArrayType =
7519  Context->getConstantArrayType(VaListTagType, Size, ArrayType::Normal, 0);
7520 
7521  return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7522 }
7523 
7524 static TypedefDecl *CreateVaListDecl(const ASTContext *Context,
7526  switch (Kind) {
7528  return CreateCharPtrBuiltinVaListDecl(Context);
7530  return CreateVoidPtrBuiltinVaListDecl(Context);
7532  return CreateAArch64ABIBuiltinVaListDecl(Context);
7534  return CreatePowerABIBuiltinVaListDecl(Context);
7536  return CreateX86_64ABIBuiltinVaListDecl(Context);
7538  return CreatePNaClABIBuiltinVaListDecl(Context);
7540  return CreateAAPCSABIBuiltinVaListDecl(Context);
7542  return CreateSystemZBuiltinVaListDecl(Context);
7543  }
7544 
7545  llvm_unreachable("Unhandled __builtin_va_list type kind");
7546 }
7547 
7549  if (!BuiltinVaListDecl) {
7550  BuiltinVaListDecl = CreateVaListDecl(this, Target->getBuiltinVaListKind());
7551  assert(BuiltinVaListDecl->isImplicit());
7552  }
7553 
7554  return BuiltinVaListDecl;
7555 }
7556 
7558  // Force the creation of VaListTagDecl by building the __builtin_va_list
7559  // declaration.
7560  if (!VaListTagDecl)
7561  (void)getBuiltinVaListDecl();
7562 
7563  return VaListTagDecl;
7564 }
7565 
7567  if (!BuiltinMSVaListDecl)
7568  BuiltinMSVaListDecl = CreateMSVaListDecl(this);
7569 
7570  return BuiltinMSVaListDecl;
7571 }
7572 
7575 }
7576 
7578  assert(ObjCConstantStringType.isNull() &&
7579  "'NSConstantString' type already set!");
7580 
7581  ObjCConstantStringType = getObjCInterfaceType(Decl);
7582 }
7583 
7584 /// Retrieve the template name that corresponds to a non-empty
7585 /// lookup.
7588  UnresolvedSetIterator End) const {
7589  unsigned size = End - Begin;
7590  assert(size > 1 && "set is not overloaded!");
7591 
7592  void *memory = Allocate(sizeof(OverloadedTemplateStorage) +
7593  size * sizeof(FunctionTemplateDecl*));
7594  auto *OT = new (memory) OverloadedTemplateStorage(size);
7595 
7596  NamedDecl **Storage = OT->getStorage();
7597  for (UnresolvedSetIterator I = Begin; I != End; ++I) {
7598  NamedDecl *D = *I;
7599  assert(isa<FunctionTemplateDecl>(D) ||
7600  isa<UnresolvedUsingValueDecl>(D) ||
7601  (isa<UsingShadowDecl>(D) &&
7602  isa<FunctionTemplateDecl>(D->getUnderlyingDecl())));
7603  *Storage++ = D;
7604  }
7605 
7606  return TemplateName(OT);
7607 }
7608 
7609 /// Retrieve the template name that represents a qualified
7610 /// template name such as \c std::vector.
7613  bool TemplateKeyword,
7614  TemplateDecl *Template) const {
7615  assert(NNS && "Missing nested-name-specifier in qualified template name");
7616 
7617  // FIXME: Canonicalization?
7618  llvm::FoldingSetNodeID ID;
7619  QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
7620 
7621  void *InsertPos = nullptr;
7622  QualifiedTemplateName *QTN =
7623  QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7624  if (!QTN) {
7625  QTN = new (*this, alignof(QualifiedTemplateName))
7626  QualifiedTemplateName(NNS, TemplateKeyword, Template);
7627  QualifiedTemplateNames.InsertNode(QTN, InsertPos);
7628  }
7629 
7630  return TemplateName(QTN);
7631 }
7632 
7633 /// Retrieve the template name that represents a dependent
7634 /// template name such as \c MetaFun::template apply.
7637  const IdentifierInfo *Name) const {
7638  assert((!NNS || NNS->isDependent()) &&
7639  "Nested name specifier must be dependent");
7640 
7641  llvm::FoldingSetNodeID ID;
7642  DependentTemplateName::Profile(ID, NNS, Name);
7643 
7644  void *InsertPos = nullptr;
7645  DependentTemplateName *QTN =
7646  DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7647 
7648  if (QTN)
7649  return TemplateName(QTN);
7650 
7652  if (CanonNNS == NNS) {
7653  QTN = new (*this, alignof(DependentTemplateName))
7654  DependentTemplateName(NNS, Name);
7655  } else {
7656  TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
7657  QTN = new (*this, alignof(DependentTemplateName))
7658  DependentTemplateName(NNS, Name, Canon);
7659  DependentTemplateName *CheckQTN =
7660  DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7661  assert(!CheckQTN && "Dependent type name canonicalization broken");
7662  (void)CheckQTN;
7663  }
7664 
7665  DependentTemplateNames.InsertNode(QTN, InsertPos);
7666  return TemplateName(QTN);
7667 }
7668 
7669 /// Retrieve the template name that represents a dependent
7670 /// template name such as \c MetaFun::template operator+.
7673  OverloadedOperatorKind Operator) const {
7674  assert((!NNS || NNS->isDependent()) &&
7675  "Nested name specifier must be dependent");
7676 
7677  llvm::FoldingSetNodeID ID;
7678  DependentTemplateName::Profile(ID, NNS, Operator);
7679 
7680  void *InsertPos = nullptr;
7682  = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7683 
7684  if (QTN)
7685  return TemplateName(QTN);
7686 
7688  if (CanonNNS == NNS) {
7689  QTN = new (*this, alignof(DependentTemplateName))
7690  DependentTemplateName(NNS, Operator);
7691  } else {
7692  TemplateName Canon = getDependentTemplateName(CanonNNS, Operator);
7693  QTN = new (*this, alignof(DependentTemplateName))
7694  DependentTemplateName(NNS, Operator, Canon);
7695 
7696  DependentTemplateName *CheckQTN
7697  = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7698  assert(!CheckQTN && "Dependent template name canonicalization broken");
7699  (void)CheckQTN;
7700  }
7701 
7702  DependentTemplateNames.InsertNode(QTN, InsertPos);
7703  return TemplateName(QTN);
7704 }
7705 
7708  TemplateName replacement) const {
7709  llvm::FoldingSetNodeID ID;
7710  SubstTemplateTemplateParmStorage::Profile(ID, param, replacement);
7711 
7712  void *insertPos = nullptr;
7714  = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);
7715 
7716  if (!subst) {
7717  subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement);
7718  SubstTemplateTemplateParms.InsertNode(subst, insertPos);
7719  }
7720 
7721  return TemplateName(subst);
7722 }
7723 
7726  const TemplateArgument &ArgPack) const {
7727  auto &Self = const_cast<ASTContext &>(*this);
7728  llvm::FoldingSetNodeID ID;
7729  SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack);
7730 
7731  void *InsertPos = nullptr;
7733  = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);
7734 
7735  if (!Subst) {
7736  Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param,
7737  ArgPack.pack_size(),
7738  ArgPack.pack_begin());
7739  SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
7740  }
7741 
7742  return TemplateName(Subst);
7743 }
7744 
7745 /// getFromTargetType - Given one of the integer types provided by
7746 /// TargetInfo, produce the corresponding type. The unsigned @p Type
7747 /// is actually a value of type @c TargetInfo::IntType.
7748 CanQualType ASTContext::getFromTargetType(unsigned Type) const {
7749  switch (Type) {
7750  case TargetInfo::NoInt: return {};
7751  case TargetInfo::SignedChar: return SignedCharTy;
7753  case TargetInfo::SignedShort: return ShortTy;
7755  case TargetInfo::SignedInt: return IntTy;
7757  case TargetInfo::SignedLong: return LongTy;
7761  }
7762 
7763  llvm_unreachable("Unhandled TargetInfo::IntType value");
7764 }
7765 
7766 //===----------------------------------------------------------------------===//
7767 // Type Predicates.
7768 //===----------------------------------------------------------------------===//
7769 
7770 /// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
7771 /// garbage collection attribute.
7772 ///
7774  if (getLangOpts().getGC() == LangOptions::NonGC)
7775  return Qualifiers::GCNone;
7776 
7777  assert(getLangOpts().ObjC);
7778  Qualifiers::GC GCAttrs = Ty.getObjCGCAttr();
7779 
7780  // Default behaviour under objective-C's gc is for ObjC pointers
7781  // (or pointers to them) be treated as though they were declared
7782  // as __strong.
7783  if (GCAttrs == Qualifiers::GCNone) {
7784  if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType())
7785  return Qualifiers::Strong;
7786  else if (Ty->isPointerType())
7788  } else {
7789  // It's not valid to set GC attributes on anything that isn't a
7790  // pointer.
7791 #ifndef NDEBUG
7793  while (const auto *AT = dyn_cast<ArrayType>(CT))
7794  CT = AT->getElementType();
7795  assert(CT->isAnyPointerType() || CT->isBlockPointerType());
7796 #endif
7797  }
7798  return GCAttrs;
7799 }
7800 
7801 //===----------------------------------------------------------------------===//
7802 // Type Compatibility Testing
7803 //===----------------------------------------------------------------------===//
7804 
7805 /// areCompatVectorTypes - Return true if the two specified vector types are
7806 /// compatible.
7807 static bool areCompatVectorTypes(const VectorType *LHS,
7808  const VectorType *RHS) {
7809  assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified());
7810  return LHS->getElementType() == RHS->getElementType() &&
7811  LHS->getNumElements() == RHS->getNumElements();
7812 }
7813 
7815  QualType SecondVec) {
7816  assert(FirstVec->isVectorType() && "FirstVec should be a vector type");
7817  assert(SecondVec->isVectorType() && "SecondVec should be a vector type");
7818 
7819  if (hasSameUnqualifiedType(FirstVec, SecondVec))
7820  return true;
7821 
7822  // Treat Neon vector types and most AltiVec vector types as if they are the
7823  // equivalent GCC vector types.
7824  const auto *First = FirstVec->getAs<VectorType>();
7825  const auto *Second = SecondVec->getAs<VectorType>();
7826  if (First->getNumElements() == Second->getNumElements() &&
7827  hasSameType(First->getElementType(), Second->getElementType()) &&
7828  First->getVectorKind() != VectorType::AltiVecPixel &&
7829  First->getVectorKind() != VectorType::AltiVecBool &&
7830  Second->getVectorKind() != VectorType::AltiVecPixel &&
7832  return true;
7833 
7834  return false;
7835 }
7836 
7837 //===----------------------------------------------------------------------===//
7838 // ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
7839 //===----------------------------------------------------------------------===//
7840 
7841 /// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
7842 /// inheritance hierarchy of 'rProto'.
7843 bool
7845  ObjCProtocolDecl *rProto) const {
7846  if (declaresSameEntity(lProto, rProto))
7847  return true;
7848  for (auto *PI : rProto->protocols())
7849  if (ProtocolCompatibleWithProtocol(lProto, PI))
7850  return true;
7851  return false;
7852 }
7853 
7854 /// ObjCQualifiedClassTypesAreCompatible - compare Class<pr,...> and
7855 /// Class<pr1, ...>.
7857  QualType rhs) {
7858  const auto *lhsQID = lhs->getAs<ObjCObjectPointerType>();
7859  const auto *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
7860  assert((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible");
7861 
7862  for (auto *lhsProto : lhsQID->quals()) {
7863  bool match = false;
7864  for (auto *rhsProto : rhsOPT->quals()) {
7865  if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) {
7866  match = true;
7867  break;
7868  }
7869  }
7870  if (!match)
7871  return false;
7872  }
7873  return true;
7874 }
7875 
7876 /// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
7877 /// ObjCQualifiedIDType.
7879  bool compare) {
7880  // Allow id<P..> and an 'id' or void* type in all cases.
7881  if (lhs->isVoidPointerType() ||
7882  lhs->isObjCIdType() || lhs->isObjCClassType())
7883  return true;
7884  else if (rhs->isVoidPointerType() ||
7885  rhs->isObjCIdType() || rhs->isObjCClassType())
7886  return true;
7887 
7888  if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) {
7889  const auto *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
7890 
7891  if (!rhsOPT) return false;
7892 
7893  if (rhsOPT->qual_empty()) {
7894  // If the RHS is a unqualified interface pointer "NSString*",
7895  // make sure we check the class hierarchy.
7896  if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
7897  for (auto *I : lhsQID->quals()) {
7898  // when comparing an id<P> on lhs with a static type on rhs,
7899  // see if static class implements all of id's protocols, directly or
7900  // through its super class and categories.
7901  if (!rhsID->ClassImplementsProtocol(I, true))
7902  return false;
7903  }
7904  }
7905  // If there are no qualifiers and no interface, we have an 'id'.
7906  return true;
7907  }
7908  // Both the right and left sides have qualifiers.
7909  for (auto *lhsProto : lhsQID->quals()) {
7910  bool match = false;
7911 
7912  // when comparing an id<P> on lhs with a static type on rhs,
7913  // see if static class implements all of id's protocols, directly or
7914  // through its super class and categories.
7915  for (auto *rhsProto : rhsOPT->quals()) {
7916  if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
7917  (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
7918  match = true;
7919  break;
7920  }
7921  }
7922  // If the RHS is a qualified interface pointer "NSString<P>*",
7923  // make sure we check the class hierarchy.
7924  if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
7925  for (auto *I : lhsQID->quals()) {
7926  // when comparing an id<P> on lhs with a static type on rhs,
7927  // see if static class implements all of id's protocols, directly or
7928  // through its super class and categories.
7929  if (rhsID->ClassImplementsProtocol(I, true)) {
7930  match = true;
7931  break;
7932  }
7933  }
7934  }
7935  if (!match)
7936  return false;
7937  }
7938 
7939  return true;
7940  }
7941 
7942  const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType();
7943  assert(rhsQID && "One of the LHS/RHS should be id<x>");
7944 
7945  if (const ObjCObjectPointerType *lhsOPT =
7947  // If both the right and left sides have qualifiers.
7948  for (auto *lhsProto : lhsOPT->quals()) {
7949  bool match = false;
7950 
7951  // when comparing an id<P> on rhs with a static type on lhs,
7952  // see if static class implements all of id's protocols, directly or
7953  // through its super class and categories.
7954  // First, lhs protocols in the qualifier list must be found, direct
7955  // or indirect in rhs's qualifier list or it is a mismatch.
7956  for (auto *rhsProto : rhsQID->quals()) {
7957  if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
7958  (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
7959  match = true;
7960  break;
7961  }
7962  }
7963  if (!match)
7964  return false;
7965  }
7966 
7967  // Static class's protocols, or its super class or category protocols
7968  // must be found, direct or indirect in rhs's qualifier list or it is a mismatch.
7969  if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) {
7970  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
7971  CollectInheritedProtocols(lhsID, LHSInheritedProtocols);
7972  // This is rather dubious but matches gcc's behavior. If lhs has
7973  // no type qualifier and its class has no static protocol(s)
7974  // assume that it is mismatch.
7975  if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty())
7976  return false;
7977  for (auto *lhsProto : LHSInheritedProtocols) {
7978  bool match = false;
7979  for (auto *rhsProto : rhsQID->quals()) {
7980  if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
7981  (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
7982  match = true;
7983  break;
7984  }
7985  }
7986  if (!match)
7987  return false;
7988  }
7989  }
7990  return true;
7991  }
7992  return false;
7993 }
7994 
7995 /// canAssignObjCInterfaces - Return true if the two interface types are
7996 /// compatible for assignment from RHS to LHS. This handles validation of any
7997 /// protocol qualifiers on the LHS or RHS.
7999  const ObjCObjectPointerType *RHSOPT) {
8000  const ObjCObjectType* LHS = LHSOPT->getObjectType();
8001  const ObjCObjectType* RHS = RHSOPT->getObjectType();
8002 
8003  // If either type represents the built-in 'id' or 'Class' types, return true.
8004  if (LHS->isObjCUnqualifiedIdOrClass() ||
8006  return true;
8007 
8008  // Function object that propagates a successful result or handles
8009  // __kindof types.
8010  auto finish = [&](bool succeeded) -> bool {
8011  if (succeeded)
8012  return true;
8013 
8014  if (!RHS->isKindOfType())
8015  return false;
8016 
8017  // Strip off __kindof and protocol qualifiers, then check whether
8018  // we can assign the other way.
8020  LHSOPT->stripObjCKindOfTypeAndQuals(*this));
8021  };
8022 
8023  if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) {
8024  return finish(ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
8025  QualType(RHSOPT,0),
8026  false));
8027  }
8028 
8029  if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) {
8030  return finish(ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0),
8031  QualType(RHSOPT,0)));
8032  }
8033 
8034  // If we have 2 user-defined types, fall into that path.
8035  if (LHS->getInterface() && RHS->getInterface()) {
8036  return finish(canAssignObjCInterfaces(LHS, RHS));
8037  }
8038 
8039  return false;
8040 }
8041 
8042 /// canAssignObjCInterfacesInBlockPointer - This routine is specifically written
8043 /// for providing type-safety for objective-c pointers used to pass/return
8044 /// arguments in block literals. When passed as arguments, passing 'A*' where
8045 /// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is
8046 /// not OK. For the return type, the opposite is not OK.
8048  const ObjCObjectPointerType *LHSOPT,
8049  const ObjCObjectPointerType *RHSOPT,
8050  bool BlockReturnType) {
8051 
8052  // Function object that propagates a successful result or handles
8053  // __kindof types.
8054  auto finish = [&](bool succeeded) -> bool {
8055  if (succeeded)
8056  return true;
8057 
8058  const ObjCObjectPointerType *Expected = BlockReturnType ? RHSOPT : LHSOPT;
8059  if (!Expected->isKindOfType())
8060  return false;
8061 
8062  // Strip off __kindof and protocol qualifiers, then check whether
8063  // we can assign the other way.
8065  RHSOPT->stripObjCKindOfTypeAndQuals(*this),
8066  LHSOPT->stripObjCKindOfTypeAndQuals(*this),
8067  BlockReturnType);
8068  };
8069 
8070  if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType())
8071  return true;
8072 
8073  if (LHSOPT->isObjCBuiltinType()) {
8074  return finish(RHSOPT->isObjCBuiltinType() ||
8075  RHSOPT->isObjCQualifiedIdType());
8076  }
8077 
8078  if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
8079  return finish(ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
8080  QualType(RHSOPT,0),
8081  false));
8082 
8083  const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
8084  const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
8085  if (LHS && RHS) { // We have 2 user-defined types.
8086  if (LHS != RHS) {
8087  if (LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
8088  return finish(BlockReturnType);
8089  if (RHS->getDecl()->isSuperClassOf(LHS->getDecl()))
8090  return finish(!BlockReturnType);
8091  }
8092  else
8093  return true;
8094  }
8095  return false;
8096 }
8097 
8098 /// Comparison routine for Objective-C protocols to be used with
8099 /// llvm::array_pod_sort.
8101  ObjCProtocolDecl * const *rhs) {
8102  return (*lhs)->getName().compare((*rhs)->getName());
8103 }
8104 
8105 /// getIntersectionOfProtocols - This routine finds the intersection of set
8106 /// of protocols inherited from two distinct objective-c pointer objects with
8107 /// the given common base.
8108 /// It is used to build composite qualifier list of the composite type of
8109 /// the conditional expression involving two objective-c pointer objects.
8110 static
8113  const ObjCObjectPointerType *LHSOPT,
8114  const ObjCObjectPointerType *RHSOPT,
8115  SmallVectorImpl<ObjCProtocolDecl *> &IntersectionSet) {
8116 
8117  const ObjCObjectType* LHS = LHSOPT->getObjectType();
8118  const ObjCObjectType* RHS = RHSOPT->getObjectType();
8119  assert(LHS->getInterface() && "LHS must have an interface base");
8120  assert(RHS->getInterface() && "RHS must have an interface base");
8121 
8122  // Add all of the protocols for the LHS.
8123  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSProtocolSet;
8124 
8125  // Start with the protocol qualifiers.
8126  for (auto proto : LHS->quals()) {
8127  Context.CollectInheritedProtocols(proto, LHSProtocolSet);
8128  }
8129 
8130  // Also add the protocols associated with the LHS interface.
8131  Context.CollectInheritedProtocols(LHS->getInterface(), LHSProtocolSet);
8132 
8133  // Add all of the protocols for the RHS.
8134  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSProtocolSet;
8135 
8136  // Start with the protocol qualifiers.
8137  for (auto proto : RHS->quals()) {
8138  Context.CollectInheritedProtocols(proto, RHSProtocolSet);
8139  }
8140 
8141  // Also add the protocols associated with the RHS interface.
8142  Context.CollectInheritedProtocols(RHS->getInterface(), RHSProtocolSet);
8143 
8144  // Compute the intersection of the collected protocol sets.
8145  for (auto proto : LHSProtocolSet) {
8146  if (RHSProtocolSet.count(proto))
8147  IntersectionSet.push_back(proto);
8148  }
8149 
8150  // Compute the set of protocols that is implied by either the common type or
8151  // the protocols within the intersection.
8152  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> ImpliedProtocols;
8153  Context.CollectInheritedProtocols(CommonBase, ImpliedProtocols);
8154 
8155  // Remove any implied protocols from the list of inherited protocols.
8156  if (!ImpliedProtocols.empty()) {
8157  IntersectionSet.erase(
8158  std::remove_if(IntersectionSet.begin(),
8159  IntersectionSet.end(),
8160  [&](ObjCProtocolDecl *proto) -> bool {
8161  return ImpliedProtocols.count(proto) > 0;
8162  }),
8163  IntersectionSet.end());
8164  }
8165 
8166  // Sort the remaining protocols by name.
8167  llvm::array_pod_sort(IntersectionSet.begin(), IntersectionSet.end(),
8169 }
8170 
8171 /// Determine whether the first type is a subtype of the second.
8173  QualType rhs) {
8174  // Common case: two object pointers.
8175  const auto *lhsOPT = lhs->getAs<ObjCObjectPointerType>();
8176  const auto *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
8177  if (lhsOPT && rhsOPT)
8178  return ctx.canAssignObjCInterfaces(lhsOPT, rhsOPT);
8179 
8180  // Two block pointers.
8181  const auto *lhsBlock = lhs->getAs<BlockPointerType>();
8182  const auto *rhsBlock = rhs->getAs<BlockPointerType>();
8183  if (lhsBlock && rhsBlock)
8184  return ctx.typesAreBlockPointerCompatible(lhs, rhs);
8185 
8186  // If either is an unqualified 'id' and the other is a block, it's
8187  // acceptable.
8188  if ((lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||
8189  (rhsOPT && rhsOPT->isObjCIdType() && lhsBlock))
8190  return true;
8191 
8192  return false;
8193 }
8194 
8195 // Check that the given Objective-C type argument lists are equivalent.
8196 static bool sameObjCTypeArgs(ASTContext &ctx,
8197  const ObjCInterfaceDecl *iface,
8198  ArrayRef<QualType> lhsArgs,
8199  ArrayRef<QualType> rhsArgs,
8200  bool stripKindOf) {
8201  if (lhsArgs.size() != rhsArgs.size())
8202  return false;
8203 
8204  ObjCTypeParamList *typeParams = iface->getTypeParamList();
8205  for (unsigned i = 0, n = lhsArgs.size(); i != n; ++i) {
8206  if (ctx.hasSameType(lhsArgs[i], rhsArgs[i]))
8207  continue;
8208 
8209  switch (typeParams->begin()[i]->getVariance()) {
8211  if (!stripKindOf ||
8212  !ctx.hasSameType(lhsArgs[i].stripObjCKindOfType(ctx),
8213  rhsArgs[i].stripObjCKindOfType(ctx))) {
8214  return false;
8215  }
8216  break;
8217 
8219  if (!canAssignObjCObjectTypes(ctx, lhsArgs[i], rhsArgs[i]))
8220  return false;
8221  break;
8222 
8224  if (!canAssignObjCObjectTypes(ctx, rhsArgs[i], lhsArgs[i]))
8225  return false;
8226  break;
8227  }
8228  }
8229 
8230  return true;
8231 }
8232 
8234  const ObjCObjectPointerType *Lptr,
8235  const ObjCObjectPointerType *Rptr) {
8236  const ObjCObjectType *LHS = Lptr->getObjectType();
8237  const ObjCObjectType *RHS = Rptr->getObjectType();
8238  const ObjCInterfaceDecl* LDecl = LHS->getInterface();
8239  const ObjCInterfaceDecl* RDecl = RHS->getInterface();
8240 
8241  if (!LDecl || !RDecl)
8242  return {};
8243 
8244  // When either LHS or RHS is a kindof type, we should return a kindof type.
8245  // For example, for common base of kindof(ASub1) and kindof(ASub2), we return
8246  // kindof(A).
8247  bool anyKindOf = LHS->isKindOfType() || RHS->isKindOfType();
8248 
8249  // Follow the left-hand side up the class hierarchy until we either hit a
8250  // root or find the RHS. Record the ancestors in case we don't find it.
8251  llvm::SmallDenseMap<const ObjCInterfaceDecl *, const ObjCObjectType *, 4>
8252  LHSAncestors;
8253  while (true) {
8254  // Record this ancestor. We'll need this if the common type isn't in the
8255  // path from the LHS to the root.
8256  LHSAncestors[LHS->getInterface()->getCanonicalDecl()] = LHS;
8257 
8258  if (declaresSameEntity(LHS->getInterface(), RDecl)) {
8259  // Get the type arguments.
8260  ArrayRef<QualType> LHSTypeArgs = LHS->getTypeArgsAsWritten();
8261  bool anyChanges = false;
8262  if (LHS->isSpecialized() && RHS->isSpecialized()) {
8263  // Both have type arguments, compare them.
8264  if (!sameObjCTypeArgs(*this, LHS->getInterface(),
8265  LHS->getTypeArgs(), RHS->getTypeArgs(),
8266  /*stripKindOf=*/true))
8267  return {};
8268  } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
8269  // If only one has type arguments, the result will not have type
8270  // arguments.
8271  LHSTypeArgs = {};
8272  anyChanges = true;
8273  }
8274 
8275  // Compute the intersection of protocols.
8277  getIntersectionOfProtocols(*this, LHS->getInterface(), Lptr, Rptr,
8278  Protocols);
8279  if (!Protocols.empty())
8280  anyChanges = true;
8281 
8282  // If anything in the LHS will have changed, build a new result type.
8283  // If we need to return a kindof type but LHS is not a kindof type, we
8284  // build a new result type.
8285  if (anyChanges || LHS->isKindOfType() != anyKindOf) {
8287  Result = getObjCObjectType(Result, LHSTypeArgs, Protocols,
8288  anyKindOf || LHS->isKindOfType());
8289  return getObjCObjectPointerType(Result);
8290  }
8291 
8292  return getObjCObjectPointerType(QualType(LHS, 0));
8293  }
8294 
8295  // Find the superclass.
8296  QualType LHSSuperType = LHS->getSuperClassType();
8297  if (LHSSuperType.isNull())
8298  break;
8299 
8300  LHS = LHSSuperType->castAs<ObjCObjectType>();
8301  }
8302 
8303  // We didn't find anything by following the LHS to its root; now check
8304  // the RHS against the cached set of ancestors.
8305  while (true) {
8306  auto KnownLHS = LHSAncestors.find(RHS->getInterface()->getCanonicalDecl());
8307  if (KnownLHS != LHSAncestors.end()) {
8308  LHS = KnownLHS->second;
8309 
8310  // Get the type arguments.
8311  ArrayRef<QualType> RHSTypeArgs = RHS->getTypeArgsAsWritten();
8312  bool anyChanges = false;
8313  if (LHS->isSpecialized() && RHS->isSpecialized()) {
8314  // Both have type arguments, compare them.
8315  if (!sameObjCTypeArgs(*this, LHS->getInterface(),
8316  LHS->getTypeArgs(), RHS->getTypeArgs(),
8317  /*stripKindOf=*/true))
8318  return {};
8319  } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
8320  // If only one has type arguments, the result will not have type
8321  // arguments.
8322  RHSTypeArgs = {};
8323  anyChanges = true;
8324  }
8325 
8326  // Compute the intersection of protocols.
8328  getIntersectionOfProtocols(*this, RHS->getInterface(), Lptr, Rptr,
8329  Protocols);
8330  if (!Protocols.empty())
8331  anyChanges = true;
8332 
8333  // If we need to return a kindof type but RHS is not a kindof type, we
8334  // build a new result type.
8335  if (anyChanges || RHS->isKindOfType() != anyKindOf) {
8337  Result = getObjCObjectType(Result, RHSTypeArgs, Protocols,
8338  anyKindOf || RHS->isKindOfType());
8339  return getObjCObjectPointerType(Result);
8340  }
8341 
8342  return getObjCObjectPointerType(QualType(RHS, 0));
8343  }
8344 
8345  // Find the superclass of the RHS.
8346  QualType RHSSuperType = RHS->getSuperClassType();
8347  if (RHSSuperType.isNull())
8348  break;
8349 
8350  RHS = RHSSuperType->castAs<ObjCObjectType>();
8351  }
8352 
8353  return {};
8354 }
8355 
8357  const ObjCObjectType *RHS) {
8358  assert(LHS->getInterface() && "LHS is not an interface type");
8359  assert(RHS->getInterface() && "RHS is not an interface type");
8360 
8361  // Verify that the base decls are compatible: the RHS must be a subclass of
8362  // the LHS.
8363  ObjCInterfaceDecl *LHSInterface = LHS->getInterface();
8364  bool IsSuperClass = LHSInterface->isSuperClassOf(RHS->getInterface());
8365  if (!IsSuperClass)
8366  return false;
8367 
8368  // If the LHS has protocol qualifiers, determine whether all of them are
8369  // satisfied by the RHS (i.e., the RHS has a superset of the protocols in the
8370  // LHS).
8371  if (LHS->getNumProtocols() > 0) {
8372  // OK if conversion of LHS to SuperClass results in narrowing of types
8373  // ; i.e., SuperClass may implement at least one of the protocols
8374  // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok.
8375  // But not SuperObj<P1,P2,P3> = lhs<P1,P2>.
8376  llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols;
8377  CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols);
8378  // Also, if RHS has explicit quelifiers, include them for comparing with LHS's
8379  // qualifiers.
8380  for (auto *RHSPI : RHS->quals())
8381  CollectInheritedProtocols(RHSPI, SuperClassInheritedProtocols);
8382  // If there is no protocols associated with RHS, it is not a match.
8383  if (SuperClassInheritedProtocols.empty())
8384  return false;
8385 
8386  for (const auto *LHSProto : LHS->quals()) {
8387  bool SuperImplementsProtocol = false;
8388  for (auto *SuperClassProto : SuperClassInheritedProtocols)
8389  if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {
8390  SuperImplementsProtocol = true;
8391  break;
8392  }
8393  if (!SuperImplementsProtocol)
8394  return false;
8395  }
8396  }
8397 
8398  // If the LHS is specialized, we may need to check type arguments.
8399  if (LHS->isSpecialized()) {
8400  // Follow the superclass chain until we've matched the LHS class in the
8401  // hierarchy. This substitutes type arguments through.
8402  const ObjCObjectType *RHSSuper = RHS;
8403  while (!declaresSameEntity(RHSSuper->getInterface(), LHSInterface))
8404  RHSSuper = RHSSuper->getSuperClassType()->castAs<ObjCObjectType>();
8405 
8406  // If the RHS is specializd, compare type arguments.
8407  if (RHSSuper->isSpecialized() &&
8408  !sameObjCTypeArgs(*this, LHS->getInterface(),
8409  LHS->getTypeArgs(), RHSSuper->getTypeArgs(),
8410  /*stripKindOf=*/true)) {
8411  return false;
8412  }
8413  }
8414 
8415  return true;
8416 }
8417 
8419  // get the "pointed to" types
8420  const auto *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
8421  const auto *RHSOPT = RHS->getAs<ObjCObjectPointerType>();
8422 
8423  if (!LHSOPT || !RHSOPT)
8424  return false;
8425 
8426  return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
8427  canAssignObjCInterfaces(RHSOPT, LHSOPT);
8428 }
8429 
8431  return canAssignObjCInterfaces(
8432  getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(),
8433  getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>());
8434 }
8435 
8436 /// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,
8437 /// both shall have the identically qualified version of a compatible type.
8438 /// C99 6.2.7p1: Two types have compatible types if their types are the
8439 /// same. See 6.7.[2,3,5] for additional rules.
8441  bool CompareUnqualified) {
8442  if (getLangOpts().CPlusPlus)
8443  return hasSameType(LHS, RHS);
8444 
8445  return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull();
8446 }
8447 
8449  return typesAreCompatible(LHS, RHS);
8450 }
8451 
8453  return !mergeTypes(LHS, RHS, true).isNull();
8454 }
8455 
8456 /// mergeTransparentUnionType - if T is a transparent union type and a member
8457 /// of T is compatible with SubType, return the merged type, else return
8458 /// QualType()
8460  bool OfBlockPointer,
8461  bool Unqualified) {
8462  if (const RecordType *UT = T->getAsUnionType()) {
8463  RecordDecl *UD = UT->getDecl();
8464  if (UD->hasAttr<TransparentUnionAttr>()) {
8465  for (const auto *I : UD->fields()) {
8466  QualType ET = I->getType().getUnqualifiedType();
8467  QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified);
8468  if (!MT.isNull())
8469  return MT;
8470  }
8471  }
8472  }
8473 
8474  return {};
8475 }
8476 
8477 /// mergeFunctionParameterTypes - merge two types which appear as function
8478 /// parameter types
8480  bool OfBlockPointer,
8481  bool Unqualified) {
8482  // GNU extension: two types are compatible if they appear as a function
8483  // argument, one of the types is a transparent union type and the other
8484  // type is compatible with a union member
8485  QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer,
8486  Unqualified);
8487  if (!lmerge.isNull())
8488  return lmerge;
8489 
8490  QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer,
8491  Unqualified);
8492  if (!rmerge.isNull())
8493  return rmerge;
8494 
8495  return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified);
8496 }
8497 
8499  bool OfBlockPointer,
8500  bool Unqualified) {
8501  const auto *lbase = lhs->getAs<FunctionType>();
8502  const auto *rbase = rhs->getAs<FunctionType>();
8503  const auto *lproto = dyn_cast<FunctionProtoType>(lbase);
8504  const auto *rproto = dyn_cast<FunctionProtoType>(rbase);
8505  bool allLTypes = true;
8506  bool allRTypes = true;
8507 
8508  // Check return type
8509  QualType retType;
8510  if (OfBlockPointer) {
8511  QualType RHS = rbase->getReturnType();
8512  QualType LHS = lbase->getReturnType();
8513  bool UnqualifiedResult = Unqualified;
8514  if (!UnqualifiedResult)
8515  UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers());
8516  retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true);
8517  }
8518  else
8519  retType = mergeTypes(lbase->getReturnType(), rbase->getReturnType(), false,
8520  Unqualified);
8521  if (retType.isNull())
8522  return {};
8523 
8524  if (Unqualified)
8525  retType = retType.getUnqualifiedType();
8526 
8527  CanQualType LRetType = getCanonicalType(lbase->getReturnType());
8528  CanQualType RRetType = getCanonicalType(rbase->getReturnType());
8529  if (Unqualified) {
8530  LRetType = LRetType.getUnqualifiedType();
8531  RRetType = RRetType.getUnqualifiedType();
8532  }
8533 
8534  if (getCanonicalType(retType) != LRetType)
8535  allLTypes = false;
8536  if (getCanonicalType(retType) != RRetType)
8537  allRTypes = false;
8538 
8539  // FIXME: double check this
8540  // FIXME: should we error if lbase->getRegParmAttr() != 0 &&
8541  // rbase->getRegParmAttr() != 0 &&
8542  // lbase->getRegParmAttr() != rbase->getRegParmAttr()?
8543  FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo();
8544  FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo();
8545 
8546  // Compatible functions must have compatible calling conventions
8547  if (lbaseInfo.getCC() != rbaseInfo.getCC())
8548  return {};
8549 
8550  // Regparm is part of the calling convention.
8551  if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm())
8552  return {};
8553  if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm())
8554  return {};
8555 
8556  if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult())
8557  return {};
8558  if (lbaseInfo.getNoCallerSavedRegs() != rbaseInfo.getNoCallerSavedRegs())
8559  return {};
8560  if (lbaseInfo.getNoCfCheck() != rbaseInfo.getNoCfCheck())
8561  return {};
8562 
8563  // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'.
8564  bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn();
8565 
8566  if (lbaseInfo.getNoReturn() != NoReturn)
8567  allLTypes = false;
8568  if (rbaseInfo.getNoReturn() != NoReturn)
8569  allRTypes = false;
8570 
8571  FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn);
8572 
8573  if (lproto && rproto) { // two C99 style function prototypes
8574  assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&
8575  "C++ shouldn't be here");
8576  // Compatible functions must have the same number of parameters
8577  if (lproto->getNumParams() != rproto->getNumParams())
8578  return {};
8579 
8580  // Variadic and non-variadic functions aren't compatible
8581  if (lproto->isVariadic() != rproto->isVariadic())
8582  return {};
8583 
8584  if (lproto->getTypeQuals() != rproto->getTypeQuals())
8585  return {};
8586 
8588  bool canUseLeft, canUseRight;
8589  if (!mergeExtParameterInfo(lproto, rproto, canUseLeft, canUseRight,
8590  newParamInfos))
8591  return {};
8592 
8593  if (!canUseLeft)
8594  allLTypes = false;
8595  if (!canUseRight)
8596  allRTypes = false;
8597 
8598  // Check parameter type compatibility
8600  for (unsigned i = 0, n = lproto->getNumParams(); i < n; i++) {
8601  QualType lParamType = lproto->getParamType(i).getUnqualifiedType();
8602  QualType rParamType = rproto->getParamType(i).getUnqualifiedType();
8604  lParamType, rParamType, OfBlockPointer, Unqualified);
8605  if (paramType.isNull())
8606  return {};
8607 
8608  if (Unqualified)
8609  paramType = paramType.getUnqualifiedType();
8610 
8611  types.push_back(paramType);
8612  if (Unqualified) {
8613  lParamType = lParamType.getUnqualifiedType();
8614  rParamType = rParamType.getUnqualifiedType();
8615  }
8616 
8617  if (getCanonicalType(paramType) != getCanonicalType(lParamType))
8618  allLTypes = false;
8619  if (getCanonicalType(paramType) != getCanonicalType(rParamType))
8620  allRTypes = false;
8621  }
8622 
8623  if (allLTypes) return lhs;
8624  if (allRTypes) return rhs;
8625 
8626  FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo();
8627  EPI.ExtInfo = einfo;
8628  EPI.ExtParameterInfos =
8629  newParamInfos.empty() ? nullptr : newParamInfos.data();
8630  return getFunctionType(retType, types, EPI);
8631  }
8632 
8633  if (lproto) allRTypes = false;
8634  if (rproto) allLTypes = false;
8635 
8636  const FunctionProtoType *proto = lproto ? lproto : rproto;
8637  if (proto) {
8638  assert(!proto->hasExceptionSpec() && "C++ shouldn't be here");
8639  if (proto->isVariadic())
8640  return {};
8641  // Check that the types are compatible with the types that
8642  // would result from default argument promotions (C99 6.7.5.3p15).
8643  // The only types actually affected are promotable integer
8644  // types and floats, which would be passed as a different
8645  // type depending on whether the prototype is visible.
8646  for (unsigned i = 0, n = proto->getNumParams(); i < n; ++i) {
8647  QualType paramTy = proto->getParamType(i);
8648 
8649  // Look at the converted type of enum types, since that is the type used
8650  // to pass enum values.
8651  if (const auto *Enum = paramTy->getAs<EnumType>()) {
8652  paramTy = Enum->getDecl()->getIntegerType();
8653  if (paramTy.isNull())
8654  return {};
8655  }
8656 
8657  if (paramTy->isPromotableIntegerType() ||
8659  return {};
8660  }
8661 
8662  if (allLTypes) return lhs;
8663  if (allRTypes) return rhs;
8664 
8666  EPI.ExtInfo = einfo;
8667  return getFunctionType(retType, proto->getParamTypes(), EPI);
8668  }
8669 
8670  if (allLTypes) return lhs;
8671  if (allRTypes) return rhs;
8672  return getFunctionNoProtoType(retType, einfo);
8673 }
8674 
8675 /// Given that we have an enum type and a non-enum type, try to merge them.
8677  QualType other, bool isBlockReturnType) {
8678  // C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
8679  // a signed integer type, or an unsigned integer type.
8680  // Compatibility is based on the underlying type, not the promotion
8681  // type.
8682  QualType underlyingType = ET->getDecl()->getIntegerType();
8683  if (underlyingType.isNull())
8684  return {};
8685  if (Context.hasSameType(underlyingType, other))
8686  return other;
8687 
8688  // In block return types, we're more permissive and accept any
8689  // integral type of the same size.
8690  if (isBlockReturnType && other->isIntegerType() &&
8691  Context.getTypeSize(underlyingType) == Context.getTypeSize(other))
8692  return other;
8693 
8694  return {};
8695 }
8696 
8698  bool OfBlockPointer,
8699  bool Unqualified, bool BlockReturnType) {
8700  // C++ [expr]: If an expression initially has the type "reference to T", the
8701  // type is adjusted to "T" prior to any further analysis, the expression
8702  // designates the object or function denoted by the reference, and the
8703  // expression is an lvalue unless the reference is an rvalue reference and
8704  // the expression is a function call (possibly inside parentheses).
8705  assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?");
8706  assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?");
8707 
8708  if (Unqualified) {
8709  LHS = LHS.getUnqualifiedType();
8710  RHS = RHS.getUnqualifiedType();
8711  }
8712 
8713  QualType LHSCan = getCanonicalType(LHS),
8714  RHSCan = getCanonicalType(RHS);
8715 
8716  // If two types are identical, they are compatible.
8717  if (LHSCan == RHSCan)
8718  return LHS;
8719 
8720  // If the qualifiers are different, the types aren't compatible... mostly.
8721  Qualifiers LQuals = LHSCan.getLocalQualifiers();
8722  Qualifiers RQuals = RHSCan.getLocalQualifiers();
8723  if (LQuals != RQuals) {
8724  // If any of these qualifiers are different, we have a type
8725  // mismatch.
8726  if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
8727  LQuals.getAddressSpace() != RQuals.getAddressSpace() ||
8728  LQuals.getObjCLifetime() != RQuals.getObjCLifetime() ||
8729  LQuals.hasUnaligned() != RQuals.hasUnaligned())
8730  return {};
8731 
8732  // Exactly one GC qualifier difference is allowed: __strong is
8733  // okay if the other type has no GC qualifier but is an Objective
8734  // C object pointer (i.e. implicitly strong by default). We fix
8735  // this by pretending that the unqualified type was actually
8736  // qualified __strong.
8737  Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
8738  Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
8739  assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements");
8740 
8741  if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
8742  return {};
8743 
8744  if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) {
8745  return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong));
8746  }
8747  if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) {
8748  return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS);
8749  }
8750  return {};
8751  }
8752 
8753  // Okay, qualifiers are equal.
8754 
8755  Type::TypeClass LHSClass = LHSCan->getTypeClass();
8756  Type::TypeClass RHSClass = RHSCan->getTypeClass();
8757 
8758  // We want to consider the two function types to be the same for these
8759  // comparisons, just force one to the other.
8760  if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
8761  if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
8762 
8763  // Same as above for arrays
8764  if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
8765  LHSClass = Type::ConstantArray;
8766  if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
8767  RHSClass = Type::ConstantArray;
8768 
8769  // ObjCInterfaces are just specialized ObjCObjects.
8770  if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
8771  if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
8772 
8773  // Canonicalize ExtVector -> Vector.
8774  if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
8775  if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
8776 
8777  // If the canonical type classes don't match.
8778  if (LHSClass != RHSClass) {
8779  // Note that we only have special rules for turning block enum
8780  // returns into block int returns, not vice-versa.
8781  if (const auto *ETy = LHS->getAs<EnumType>()) {
8782  return mergeEnumWithInteger(*this, ETy, RHS, false);
8783  }
8784  if (const EnumType* ETy = RHS->getAs<EnumType>()) {
8785  return mergeEnumWithInteger(*this, ETy, LHS, BlockReturnType);
8786  }
8787  // allow block pointer type to match an 'id' type.
8788  if (OfBlockPointer && !BlockReturnType) {
8789  if (LHS->isObjCIdType() && RHS->isBlockPointerType())
8790  return LHS;
8791  if (RHS->isObjCIdType() && LHS->isBlockPointerType())
8792  return RHS;
8793  }
8794 
8795  return {};
8796  }
8797 
8798  // The canonical type classes match.
8799  switch (LHSClass) {
8800 #define TYPE(Class, Base)
8801 #define ABSTRACT_TYPE(Class, Base)
8802 #define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
8803 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
8804 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
8805 #include "clang/AST/TypeNodes.def"
8806  llvm_unreachable("Non-canonical and dependent types shouldn't get here");
8807 
8808  case Type::Auto:
8809  case Type::DeducedTemplateSpecialization:
8810  case Type::LValueReference:
8811  case Type::RValueReference:
8812  case Type::MemberPointer:
8813  llvm_unreachable("C++ should never be in mergeTypes");
8814 
8815  case Type::ObjCInterface:
8816  case Type::IncompleteArray:
8817  case Type::VariableArray:
8818  case Type::FunctionProto:
8819  case Type::ExtVector:
8820  llvm_unreachable("Types are eliminated above");
8821 
8822  case Type::Pointer:
8823  {
8824  // Merge two pointer types, while trying to preserve typedef info
8825  QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType();
8826  QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType();
8827  if (Unqualified) {
8828  LHSPointee = LHSPointee.getUnqualifiedType();
8829  RHSPointee = RHSPointee.getUnqualifiedType();
8830  }
8831  QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false,
8832  Unqualified);
8833  if (ResultType.isNull())
8834  return {};
8835  if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
8836  return LHS;
8837  if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
8838  return RHS;
8839  return getPointerType(ResultType);
8840  }
8841  case Type::BlockPointer:
8842  {
8843  // Merge two block pointer types, while trying to preserve typedef info
8844  QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType();
8845  QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType();
8846  if (Unqualified) {
8847  LHSPointee = LHSPointee.getUnqualifiedType();
8848  RHSPointee = RHSPointee.getUnqualifiedType();
8849  }
8850  if (getLangOpts().OpenCL) {
8851  Qualifiers LHSPteeQual = LHSPointee.getQualifiers();
8852  Qualifiers RHSPteeQual = RHSPointee.getQualifiers();
8853  // Blocks can't be an expression in a ternary operator (OpenCL v2.0
8854  // 6.12.5) thus the following check is asymmetric.
8855  if (!LHSPteeQual.isAddressSpaceSupersetOf(RHSPteeQual))
8856  return {};
8857  LHSPteeQual.removeAddressSpace();
8858  RHSPteeQual.removeAddressSpace();
8859  LHSPointee =
8860  QualType(LHSPointee.getTypePtr(), LHSPteeQual.getAsOpaqueValue());
8861  RHSPointee =
8862  QualType(RHSPointee.getTypePtr(), RHSPteeQual.getAsOpaqueValue());
8863  }
8864  QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer,
8865  Unqualified);
8866  if (ResultType.isNull())
8867  return {};
8868  if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
8869  return LHS;
8870  if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
8871  return RHS;
8872  return getBlockPointerType(ResultType);
8873  }
8874  case Type::Atomic:
8875  {
8876  // Merge two pointer types, while trying to preserve typedef info
8877  QualType LHSValue = LHS->getAs<AtomicType>()->getValueType();
8878  QualType RHSValue = RHS->getAs<AtomicType>()->getValueType();
8879  if (Unqualified) {
8880  LHSValue = LHSValue.getUnqualifiedType();
8881  RHSValue = RHSValue.getUnqualifiedType();
8882  }
8883  QualType ResultType = mergeTypes(LHSValue, RHSValue, false,
8884  Unqualified);
8885  if (ResultType.isNull())
8886  return {};
8887  if (getCanonicalType(LHSValue) == getCanonicalType(ResultType))
8888  return LHS;
8889  if (getCanonicalType(RHSValue) == getCanonicalType(ResultType))
8890  return RHS;
8891  return getAtomicType(ResultType);
8892  }
8893  case Type::ConstantArray:
8894  {
8895  const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
8896  const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
8897  if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
8898  return {};
8899 
8900  QualType LHSElem = getAsArrayType(LHS)->getElementType();
8901  QualType RHSElem = getAsArrayType(RHS)->getElementType();
8902  if (Unqualified) {
8903  LHSElem = LHSElem.getUnqualifiedType();
8904  RHSElem = RHSElem.getUnqualifiedType();
8905  }
8906 
8907  QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified);
8908  if (ResultType.isNull())
8909  return {};
8910 
8911  const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
8912  const VariableArrayType* RVAT = getAsVariableArrayType(RHS);
8913 
8914  // If either side is a variable array, and both are complete, check whether
8915  // the current dimension is definite.
8916  if (LVAT || RVAT) {
8917  auto SizeFetch = [this](const VariableArrayType* VAT,
8918  const ConstantArrayType* CAT)
8919  -> std::pair<bool,llvm::APInt> {
8920  if (VAT) {
8921  llvm::APSInt TheInt;
8922  Expr *E = VAT->getSizeExpr();
8923  if (E && E->isIntegerConstantExpr(TheInt, *this))
8924  return std::make_pair(true, TheInt);
8925  else
8926  return std::make_pair(false, TheInt);
8927  } else if (CAT) {
8928  return std::make_pair(true, CAT->getSize());
8929  } else {
8930  return std::make_pair(false, llvm::APInt());
8931  }
8932  };
8933 
8934  bool HaveLSize, HaveRSize;
8935  llvm::APInt LSize, RSize;
8936  std::tie(HaveLSize, LSize) = SizeFetch(LVAT, LCAT);
8937  std::tie(HaveRSize, RSize) = SizeFetch(RVAT, RCAT);
8938  if (HaveLSize && HaveRSize && !llvm::APInt::isSameValue(LSize, RSize))
8939  return {}; // Definite, but unequal, array dimension
8940  }
8941 
8942  if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
8943  return LHS;
8944  if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
8945  return RHS;
8946  if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(),
8948  if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(),
8950  if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
8951  return LHS;
8952  if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
8953  return RHS;
8954  if (LVAT) {
8955  // FIXME: This isn't correct! But tricky to implement because
8956  // the array's size has to be the size of LHS, but the type
8957  // has to be different.
8958  return LHS;
8959  }
8960  if (RVAT) {
8961  // FIXME: This isn't correct! But tricky to implement because
8962  // the array's size has to be the size of RHS, but the type
8963  // has to be different.
8964  return RHS;
8965  }
8966  if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
8967  if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
8968  return getIncompleteArrayType(ResultType,
8970  }
8971  case Type::FunctionNoProto:
8972  return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified);
8973  case Type::Record:
8974  case Type::Enum:
8975  return {};
8976  case Type::Builtin:
8977  // Only exactly equal builtin types are compatible, which is tested above.
8978  return {};
8979  case Type::Complex:
8980  // Distinct complex types are incompatible.
8981  return {};
8982  case Type::Vector:
8983  // FIXME: The merged type should be an ExtVector!
8984  if (areCompatVectorTypes(LHSCan->getAs<VectorType>(),
8985  RHSCan->getAs<VectorType>()))
8986  return LHS;
8987  return {};
8988  case Type::ObjCObject: {
8989  // Check if the types are assignment compatible.
8990  // FIXME: This should be type compatibility, e.g. whether
8991  // "LHS x; RHS x;" at global scope is legal.
8992  const auto *LHSIface = LHS->getAs<ObjCObjectType>();
8993  const auto *RHSIface = RHS->getAs<ObjCObjectType>();
8994  if (canAssignObjCInterfaces(LHSIface, RHSIface))
8995  return LHS;
8996 
8997  return {};
8998  }
8999  case Type::ObjCObjectPointer:
9000  if (OfBlockPointer) {
9002  LHS->getAs<ObjCObjectPointerType>(),
9003  RHS->getAs<ObjCObjectPointerType>(),
9004  BlockReturnType))
9005  return LHS;
9006  return {};
9007  }
9009  RHS->getAs<ObjCObjectPointerType>()))
9010  return LHS;
9011 
9012  return {};
9013  case Type::Pipe:
9014  assert(LHS != RHS &&
9015  "Equivalent pipe types should have already been handled!");
9016  return {};
9017  }
9018 
9019  llvm_unreachable("Invalid Type::Class!");
9020 }
9021 
9023  const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType,
9024  bool &CanUseFirst, bool &CanUseSecond,
9026  assert(NewParamInfos.empty() && "param info list not empty");
9027  CanUseFirst = CanUseSecond = true;
9028  bool FirstHasInfo = FirstFnType->hasExtParameterInfos();
9029  bool SecondHasInfo = SecondFnType->hasExtParameterInfos();
9030 
9031  // Fast path: if the first type doesn't have ext parameter infos,
9032  // we match if and only if the second type also doesn't have them.
9033  if (!FirstHasInfo && !SecondHasInfo)
9034  return true;
9035 
9036  bool NeedParamInfo = false;
9037  size_t E = FirstHasInfo ? FirstFnType->getExtParameterInfos().size()
9038  : SecondFnType->getExtParameterInfos().size();
9039 
9040  for (size_t I = 0; I < E; ++I) {
9041  FunctionProtoType::ExtParameterInfo FirstParam, SecondParam;
9042  if (FirstHasInfo)
9043  FirstParam = FirstFnType->getExtParameterInfo(I);
9044  if (SecondHasInfo)
9045  SecondParam = SecondFnType->getExtParameterInfo(I);
9046 
9047  // Cannot merge unless everything except the noescape flag matches.
9048  if (FirstParam.withIsNoEscape(false) != SecondParam.withIsNoEscape(false))
9049  return false;
9050 
9051  bool FirstNoEscape = FirstParam.isNoEscape();
9052  bool SecondNoEscape = SecondParam.isNoEscape();
9053  bool IsNoEscape = FirstNoEscape && SecondNoEscape;
9054  NewParamInfos.push_back(FirstParam.withIsNoEscape(IsNoEscape));
9055  if (NewParamInfos.back().getOpaqueValue())
9056  NeedParamInfo = true;
9057  if (FirstNoEscape != IsNoEscape)
9058  CanUseFirst = false;
9059  if (SecondNoEscape != IsNoEscape)
9060  CanUseSecond = false;
9061  }
9062 
9063  if (!NeedParamInfo)
9064  NewParamInfos.clear();
9065 
9066  return true;
9067 }
9068 
9070  ObjCLayouts[CD] = nullptr;
9071 }
9072 
9073 /// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and
9074 /// 'RHS' attributes and returns the merged version; including for function
9075 /// return types.
9077  QualType LHSCan = getCanonicalType(LHS),
9078  RHSCan = getCanonicalType(RHS);
9079  // If two types are identical, they are compatible.
9080  if (LHSCan == RHSCan)
9081  return LHS;
9082  if (RHSCan->isFunctionType()) {
9083  if (!LHSCan->isFunctionType())
9084  return {};
9085  QualType OldReturnType =
9086  cast<FunctionType>(RHSCan.getTypePtr())->getReturnType();
9087  QualType NewReturnType =
9088  cast<FunctionType>(LHSCan.getTypePtr())->getReturnType();
9089  QualType ResReturnType =
9090  mergeObjCGCQualifiers(NewReturnType, OldReturnType);
9091  if (ResReturnType.isNull())
9092  return {};
9093  if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
9094  // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo();
9095  // In either case, use OldReturnType to build the new function type.
9096  const auto *F = LHS->getAs<FunctionType>();
9097  if (const auto *FPT = cast<FunctionProtoType>(F)) {
9098  FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
9099  EPI.ExtInfo = getFunctionExtInfo(LHS);
9100  QualType ResultType =
9101  getFunctionType(OldReturnType, FPT->getParamTypes(), EPI);
9102  return ResultType;
9103  }
9104  }
9105  return {};
9106  }
9107 
9108  // If the qualifiers are different, the types can still be merged.
9109  Qualifiers LQuals = LHSCan.getLocalQualifiers();
9110  Qualifiers RQuals = RHSCan.getLocalQualifiers();
9111  if (LQuals != RQuals) {
9112  // If any of these qualifiers are different, we have a type mismatch.
9113  if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
9114  LQuals.getAddressSpace() != RQuals.getAddressSpace())
9115  return {};
9116 
9117  // Exactly one GC qualifier difference is allowed: __strong is
9118  // okay if the other type has no GC qualifier but is an Objective
9119  // C object pointer (i.e. implicitly strong by default). We fix
9120  // this by pretending that the unqualified type was actually
9121  // qualified __strong.
9122  Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
9123  Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
9124  assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements");
9125 
9126  if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
9127  return {};
9128 
9129  if (GC_L == Qualifiers::Strong)
9130  return LHS;
9131  if (GC_R == Qualifiers::Strong)
9132  return RHS;
9133  return {};
9134  }
9135 
9136  if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) {
9137  QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType();
9138  QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType();
9139  QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT);
9140  if (ResQT == LHSBaseQT)
9141  return LHS;
9142  if (ResQT == RHSBaseQT)
9143  return RHS;
9144  }
9145  return {};
9146 }
9147 
9148 //===----------------------------------------------------------------------===//
9149 // Integer Predicates
9150 //===----------------------------------------------------------------------===//
9151 
9153  if (const auto *ET = T->getAs<EnumType>())
9154  T = ET->getDecl()->getIntegerType();
9155  if (T->isBooleanType())
9156  return 1;
9157  // For builtin types, just use the standard type sizing method
9158  return (unsigned)getTypeSize(T);
9159 }
9160 
9163  "Unexpected type");
9164 
9165  // Turn <4 x signed int> -> <4 x unsigned int>
9166  if (const auto *VTy = T->getAs<VectorType>())
9167  return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()),
9168  VTy->getNumElements(), VTy->getVectorKind());
9169 
9170  // For enums, we return the unsigned version of the base type.
9171  if (const auto *ETy = T->getAs<EnumType>())
9172  T = ETy->getDecl()->getIntegerType();
9173 
9174  const auto *BTy = T->getAs<BuiltinType>();
9175  assert(BTy && "Unexpected signed integer or fixed point type");
9176  switch (BTy->getKind()) {
9177  case BuiltinType::Char_S:
9178  case BuiltinType::SChar:
9179  return UnsignedCharTy;
9180  case BuiltinType::Short:
9181  return UnsignedShortTy;
9182  case BuiltinType::Int:
9183  return UnsignedIntTy;
9184  case BuiltinType::Long:
9185  return UnsignedLongTy;
9186  case BuiltinType::LongLong:
9187  return UnsignedLongLongTy;
9188  case BuiltinType::Int128:
9189  return UnsignedInt128Ty;
9190 
9191  case BuiltinType::ShortAccum:
9192  return UnsignedShortAccumTy;
9193  case BuiltinType::Accum:
9194  return UnsignedAccumTy;
9195  case BuiltinType::LongAccum:
9196  return UnsignedLongAccumTy;
9197  case BuiltinType::SatShortAccum:
9198  return SatUnsignedShortAccumTy;
9199  case BuiltinType::SatAccum:
9200  return SatUnsignedAccumTy;
9201  case BuiltinType::SatLongAccum:
9202  return SatUnsignedLongAccumTy;
9203  case BuiltinType::ShortFract:
9204  return UnsignedShortFractTy;
9205  case BuiltinType::Fract:
9206  return UnsignedFractTy;
9207  case BuiltinType::LongFract:
9208  return UnsignedLongFractTy;
9209  case BuiltinType::SatShortFract:
9210  return SatUnsignedShortFractTy;
9211  case BuiltinType::SatFract:
9212  return SatUnsignedFractTy;
9213  case BuiltinType::SatLongFract:
9214  return SatUnsignedLongFractTy;
9215  default:
9216  llvm_unreachable("Unexpected signed integer or fixed point type");
9217  }
9218 }
9219 
9221 
9223  QualType ReturnType) {}
9224 
9225 //===----------------------------------------------------------------------===//
9226 // Builtin Type Computation
9227 //===----------------------------------------------------------------------===//
9228 
9229 /// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
9230 /// pointer over the consumed characters. This returns the resultant type. If
9231 /// AllowTypeModifiers is false then modifier like * are not parsed, just basic
9232 /// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of
9233 /// a vector of "i*".
9234 ///
9235 /// RequiresICE is filled in on return to indicate whether the value is required
9236 /// to be an Integer Constant Expression.
9237 static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context,
9239  bool &RequiresICE,
9240  bool AllowTypeModifiers) {
9241  // Modifiers.
9242  int HowLong = 0;
9243  bool Signed = false, Unsigned = false;
9244  RequiresICE = false;
9245 
9246  // Read the prefixed modifiers first.
9247  bool Done = false;
9248  #ifndef NDEBUG
9249  bool IsSpecialLong = false;
9250  #endif
9251  while (!Done) {
9252  switch (*Str++) {
9253  default: Done = true; --Str; break;
9254  case 'I':
9255  RequiresICE = true;
9256  break;
9257  case 'S':
9258  assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!");
9259  assert(!Signed && "Can't use 'S' modifier multiple times!");
9260  Signed = true;
9261  break;
9262  case 'U':
9263  assert(!Signed && "Can't use both 'S' and 'U' modifiers!");
9264  assert(!Unsigned && "Can't use 'U' modifier multiple times!");
9265  Unsigned = true;
9266  break;
9267  case 'L':
9268  assert(!IsSpecialLong && "Can't use 'L' with 'W' or 'N' modifiers");
9269  assert(HowLong <= 2 && "Can't have LLLL modifier");
9270  ++HowLong;
9271  break;
9272  case 'N':
9273  // 'N' behaves like 'L' for all non LP64 targets and 'int' otherwise.
9274  assert(!IsSpecialLong && "Can't use two 'N' or 'W' modifiers!");
9275  assert(HowLong == 0 && "Can't use both 'L' and 'N' modifiers!");
9276  #ifndef NDEBUG
9277  IsSpecialLong = true;
9278  #endif
9279  if (Context.getTargetInfo().getLongWidth() == 32)
9280  ++HowLong;
9281  break;
9282  case 'W':
9283  // This modifier represents int64 type.
9284  assert(!IsSpecialLong && "Can't use two 'N' or 'W' modifiers!");
9285  assert(HowLong == 0 && "Can't use both 'L' and 'W' modifiers!");
9286  #ifndef NDEBUG
9287  IsSpecialLong = true;
9288  #endif
9289  switch (Context.getTargetInfo().getInt64Type()) {
9290  default:
9291  llvm_unreachable("Unexpected integer type");
9293  HowLong = 1;
9294  break;
9296  HowLong = 2;
9297  break;
9298  }
9299  break;
9300  }
9301  }
9302 
9303  QualType Type;
9304 
9305  // Read the base type.
9306  switch (*Str++) {
9307  default: llvm_unreachable("Unknown builtin type letter!");
9308  case 'v':
9309  assert(HowLong == 0 && !Signed && !Unsigned &&
9310  "Bad modifiers used with 'v'!");
9311  Type = Context.VoidTy;
9312  break;
9313  case 'h':
9314  assert(HowLong == 0 && !Signed && !Unsigned &&
9315  "Bad modifiers used with 'h'!");
9316  Type = Context.HalfTy;
9317  break;
9318  case 'f':
9319  assert(HowLong == 0 && !Signed && !Unsigned &&
9320  "Bad modifiers used with 'f'!");
9321  Type = Context.FloatTy;
9322  break;
9323  case 'd':
9324  assert(HowLong < 3 && !Signed && !Unsigned &&
9325  "Bad modifiers used with 'd'!");
9326  if (HowLong == 1)
9327  Type = Context.LongDoubleTy;
9328  else if (HowLong == 2)
9329  Type = Context.Float128Ty;
9330  else
9331  Type = Context.DoubleTy;
9332  break;
9333  case 's':
9334  assert(HowLong == 0 && "Bad modifiers used with 's'!");
9335  if (Unsigned)
9336  Type = Context.UnsignedShortTy;
9337  else
9338  Type = Context.ShortTy;
9339  break;
9340  case 'i':
9341  if (HowLong == 3)
9342  Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
9343  else if (HowLong == 2)
9344  Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
9345  else if (HowLong == 1)
9346  Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
9347  else
9348  Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
9349  break;
9350  case 'c':
9351  assert(HowLong == 0 && "Bad modifiers used with 'c'!");
9352  if (Signed)
9353  Type = Context.SignedCharTy;
9354  else if (Unsigned)
9355  Type = Context.UnsignedCharTy;
9356  else
9357  Type = Context.CharTy;
9358  break;
9359  case 'b': // boolean
9360  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!");
9361  Type = Context.BoolTy;
9362  break;
9363  case 'z': // size_t.
9364  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!");
9365  Type = Context.getSizeType();
9366  break;
9367  case 'w': // wchar_t.
9368  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'w'!");
9369  Type = Context.getWideCharType();
9370  break;
9371  case 'F':
9372  Type = Context.getCFConstantStringType();
9373  break;
9374  case 'G':
9375  Type = Context.getObjCIdType();
9376  break;
9377  case 'H':
9378  Type = Context.getObjCSelType();
9379  break;
9380  case 'M':
9381  Type = Context.getObjCSuperType();
9382  break;
9383  case 'a':
9384  Type = Context.getBuiltinVaListType();
9385  assert(!Type.isNull() && "builtin va list type not initialized!");
9386  break;
9387  case 'A':
9388  // This is a "reference" to a va_list; however, what exactly
9389  // this means depends on how va_list is defined. There are two
9390  // different kinds of va_list: ones passed by value, and ones
9391  // passed by reference. An example of a by-value va_list is
9392  // x86, where va_list is a char*. An example of by-ref va_list
9393  // is x86-64, where va_list is a __va_list_tag[1]. For x86,
9394  // we want this argument to be a char*&; for x86-64, we want
9395  // it to be a __va_list_tag*.
9396  Type = Context.getBuiltinVaListType();
9397  assert(!Type.isNull() && "builtin va list type not initialized!");
9398  if (Type->isArrayType())
9399  Type = Context.getArrayDecayedType(Type);
9400  else
9401  Type = Context.getLValueReferenceType(Type);
9402  break;
9403  case 'V': {
9404  char *End;
9405  unsigned NumElements = strtoul(Str, &End, 10);
9406  assert(End != Str && "Missing vector size");
9407  Str = End;
9408 
9409  QualType ElementType = DecodeTypeFromStr(Str, Context, Error,
9410  RequiresICE, false);
9411  assert(!RequiresICE && "Can't require vector ICE");
9412 
9413  // TODO: No way to make AltiVec vectors in builtins yet.
9414  Type = Context.getVectorType(ElementType, NumElements,
9416  break;
9417  }
9418  case 'E': {
9419  char *End;
9420 
9421  unsigned NumElements = strtoul(Str, &End, 10);
9422  assert(End != Str && "Missing vector size");
9423 
9424  Str = End;
9425 
9426  QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
9427  false);
9428  Type = Context.getExtVectorType(ElementType, NumElements);
9429  break;
9430  }
9431  case 'X': {
9432  QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
9433  false);
9434  assert(!RequiresICE && "Can't require complex ICE");
9435  Type = Context.getComplexType(ElementType);
9436  break;
9437  }
9438  case 'Y':
9439  Type = Context.getPointerDiffType();
9440  break;
9441  case 'P':
9442  Type = Context.getFILEType();
9443  if (Type.isNull()) {
9445  return {};
9446  }
9447  break;
9448  case 'J':
9449  if (Signed)
9450  Type = Context.getsigjmp_bufType();
9451  else
9452  Type = Context.getjmp_bufType();
9453 
9454  if (Type.isNull()) {
9456  return {};
9457  }
9458  break;
9459  case 'K':
9460  assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!");
9461  Type = Context.getucontext_tType();
9462 
9463  if (Type.isNull()) {
9465  return {};
9466  }
9467  break;
9468  case 'p':
9469  Type = Context.getProcessIDType();
9470  break;
9471  }
9472 
9473  // If there are modifiers and if we're allowed to parse them, go for it.
9474  Done = !AllowTypeModifiers;
9475  while (!Done) {
9476  switch (char c = *Str++) {
9477  default: Done = true; --Str; break;
9478  case '*':
9479  case '&': {
9480  // Both pointers and references can have their pointee types
9481  // qualified with an address space.
9482  char *End;
9483  unsigned AddrSpace = strtoul(Str, &End, 10);
9484  if (End != Str) {
9485  // Note AddrSpace == 0 is not the same as an unspecified address space.
9486  Type = Context.getAddrSpaceQualType(
9487  Type,
9488  Context.getLangASForBuiltinAddressSpace(AddrSpace));
9489  Str = End;
9490  }
9491  if (c == '*')
9492  Type = Context.getPointerType(Type);
9493  else
9494  Type = Context.getLValueReferenceType(Type);
9495  break;
9496  }
9497  // FIXME: There's no way to have a built-in with an rvalue ref arg.
9498  case 'C':
9499  Type = Type.withConst();
9500  break;
9501  case 'D':
9502  Type = Context.getVolatileType(Type);
9503  break;
9504  case 'R':
9505  Type = Type.withRestrict();
9506  break;
9507  }
9508  }
9509 
9510  assert((!RequiresICE || Type->isIntegralOrEnumerationType()) &&
9511  "Integer constant 'I' type must be an integer");
9512 
9513  return Type;
9514 }
9515 
9516 /// GetBuiltinType - Return the type for the specified builtin.
9519  unsigned *IntegerConstantArgs) const {
9520  const char *TypeStr = BuiltinInfo.getTypeString(Id);
9521 
9522  SmallVector<QualType, 8> ArgTypes;
9523 
9524  bool RequiresICE = false;
9525  Error = GE_None;
9526  QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error,
9527  RequiresICE, true);
9528  if (Error != GE_None)
9529  return {};
9530 
9531  assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE");
9532 
9533  while (TypeStr[0] && TypeStr[0] != '.') {
9534  QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true);
9535  if (Error != GE_None)
9536  return {};
9537 
9538  // If this argument is required to be an IntegerConstantExpression and the
9539  // caller cares, fill in the bitmask we return.
9540  if (RequiresICE && IntegerConstantArgs)
9541  *IntegerConstantArgs |= 1 << ArgTypes.size();
9542 
9543  // Do array -> pointer decay. The builtin should use the decayed type.
9544  if (Ty->isArrayType())
9545  Ty = getArrayDecayedType(Ty);
9546 
9547  ArgTypes.push_back(Ty);
9548  }
9549 
9550  if (Id == Builtin::BI__GetExceptionInfo)
9551  return {};
9552 
9553  assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&
9554  "'.' should only occur at end of builtin type list!");
9555 
9557  if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true);
9558 
9559  bool Variadic = (TypeStr[0] == '.');
9560 
9561  // We really shouldn't be making a no-proto type here.
9562  if (ArgTypes.empty() && Variadic && !getLangOpts().CPlusPlus)
9563  return getFunctionNoProtoType(ResType, EI);
9564 
9566  EPI.ExtInfo = EI;
9567  EPI.Variadic = Variadic;
9568  if (getLangOpts().CPlusPlus && BuiltinInfo.isNoThrow(Id))
9569  EPI.ExceptionSpec.Type =
9570  getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
9571 
9572  return getFunctionType(ResType, ArgTypes, EPI);
9573 }
9574 
9576  const FunctionDecl *FD) {
9577  if (!FD->isExternallyVisible())
9578  return GVA_Internal;
9579 
9580  // Non-user-provided functions get emitted as weak definitions with every
9581  // use, no matter whether they've been explicitly instantiated etc.
9582  if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
9583  if (!MD->isUserProvided())
9584  return GVA_DiscardableODR;
9585 
9586  GVALinkage External;
9587  switch (FD->getTemplateSpecializationKind()) {
9588  case TSK_Undeclared:
9590  External = GVA_StrongExternal;
9591  break;
9592 
9594  return GVA_StrongODR;
9595 
9596  // C++11 [temp.explicit]p10:
9597  // [ Note: The intent is that an inline function that is the subject of
9598  // an explicit instantiation declaration will still be implicitly
9599  // instantiated when used so that the body can be considered for
9600  // inlining, but that no out-of-line copy of the inline function would be
9601  // generated in the translation unit. -- end note ]
9603  return GVA_AvailableExternally;
9604 
9606  External = GVA_DiscardableODR;
9607  break;
9608  }
9609 
9610  if (!FD->isInlined())
9611  return External;
9612 
9613  if ((!Context.getLangOpts().CPlusPlus &&
9614  !Context.getTargetInfo().getCXXABI().isMicrosoft() &&
9615  !FD->hasAttr<DLLExportAttr>()) ||
9616  FD->hasAttr<GNUInlineAttr>()) {
9617  // FIXME: This doesn't match gcc's behavior for dllexport inline functions.
9618 
9619  // GNU or C99 inline semantics. Determine whether this symbol should be
9620  // externally visible.
9622  return External;
9623 
9624  // C99 inline semantics, where the symbol is not externally visible.
9625  return GVA_AvailableExternally;
9626  }
9627 
9628  // Functions specified with extern and inline in -fms-compatibility mode
9629  // forcibly get emitted. While the body of the function cannot be later
9630  // replaced, the function definition cannot be discarded.
9631  if (FD->isMSExternInline())
9632  return GVA_StrongODR;
9633 
9634  return GVA_DiscardableODR;
9635 }
9636 
9638  const Decl *D, GVALinkage L) {
9639  // See http://msdn.microsoft.com/en-us/library/xa0d9ste.aspx
9640  // dllexport/dllimport on inline functions.
9641  if (D->hasAttr<DLLImportAttr>()) {
9642  if (L == GVA_DiscardableODR || L == GVA_StrongODR)
9643  return GVA_AvailableExternally;
9644  } else if (D->hasAttr<DLLExportAttr>()) {
9645  if (L == GVA_DiscardableODR)
9646  return GVA_StrongODR;
9647  } else if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice &&
9648  D->hasAttr<CUDAGlobalAttr>()) {
9649  // Device-side functions with __global__ attribute must always be
9650  // visible externally so they can be launched from host.
9651  if (L == GVA_DiscardableODR || L == GVA_Internal)
9652  return GVA_StrongODR;
9653  }
9654  return L;
9655 }
9656 
9657 /// Adjust the GVALinkage for a declaration based on what an external AST source
9658 /// knows about whether there can be other definitions of this declaration.
9659 static GVALinkage
9661  GVALinkage L) {
9662  ExternalASTSource *Source = Ctx.getExternalSource();
9663  if (!Source)
9664  return L;
9665 
9666  switch (Source->hasExternalDefinitions(D)) {
9668  // Other translation units rely on us to provide the definition.
9669  if (L == GVA_DiscardableODR)
9670  return GVA_StrongODR;
9671  break;
9672 
9674  return GVA_AvailableExternally;
9675 
9677  break;
9678  }
9679  return L;
9680 }
9681 
9685  basicGVALinkageForFunction(*this, FD)));
9686 }
9687 
9689  const VarDecl *VD) {
9690  if (!VD->isExternallyVisible())
9691  return GVA_Internal;
9692 
9693  if (VD->isStaticLocal()) {
9694  const DeclContext *LexicalContext = VD->getParentFunctionOrMethod();
9695  while (LexicalContext && !isa<FunctionDecl>(LexicalContext))
9696  LexicalContext = LexicalContext->getLexicalParent();
9697 
9698  // ObjC Blocks can create local variables that don't have a FunctionDecl
9699  // LexicalContext.
9700  if (!LexicalContext)
9701  return GVA_DiscardableODR;
9702 
9703  // Otherwise, let the static local variable inherit its linkage from the
9704  // nearest enclosing function.
9705  auto StaticLocalLinkage =
9706  Context.GetGVALinkageForFunction(cast<FunctionDecl>(LexicalContext));
9707 
9708  // Itanium ABI 5.2.2: "Each COMDAT group [for a static local variable] must
9709  // be emitted in any object with references to the symbol for the object it
9710  // contains, whether inline or out-of-line."
9711  // Similar behavior is observed with MSVC. An alternative ABI could use
9712  // StrongODR/AvailableExternally to match the function, but none are
9713  // known/supported currently.
9714  if (StaticLocalLinkage == GVA_StrongODR ||
9715  StaticLocalLinkage == GVA_AvailableExternally)
9716  return GVA_DiscardableODR;
9717  return StaticLocalLinkage;
9718  }
9719 
9720  // MSVC treats in-class initialized static data members as definitions.
9721  // By giving them non-strong linkage, out-of-line definitions won't
9722  // cause link errors.
9723  if (Context.isMSStaticDataMemberInlineDefinition(VD))
9724  return GVA_DiscardableODR;
9725 
9726  // Most non-template variables have strong linkage; inline variables are
9727  // linkonce_odr or (occasionally, for compatibility) weak_odr.
9728  GVALinkage StrongLinkage;
9729  switch (Context.getInlineVariableDefinitionKind(VD)) {
9731  StrongLinkage = GVA_StrongExternal;
9732  break;
9735  StrongLinkage = GVA_DiscardableODR;
9736  break;
9738  StrongLinkage = GVA_StrongODR;
9739  break;
9740  }
9741 
9742  switch (VD->getTemplateSpecializationKind()) {
9743  case TSK_Undeclared:
9744  return StrongLinkage;
9745 
9747  return Context.getTargetInfo().getCXXABI().isMicrosoft() &&
9748  VD->isStaticDataMember()
9749  ? GVA_StrongODR
9750  : StrongLinkage;
9751 
9753  return GVA_StrongODR;
9754 
9756  return GVA_AvailableExternally;
9757 
9759  return GVA_DiscardableODR;
9760  }
9761 
9762  llvm_unreachable("Invalid Linkage!");
9763 }
9764 
9768  basicGVALinkageForVariable(*this, VD)));
9769 }
9770 
9771 bool ASTContext::DeclMustBeEmitted(const Decl *D) {
9772  if (const auto *VD = dyn_cast<VarDecl>(D)) {
9773  if (!VD->isFileVarDecl())
9774  return false;
9775  // Global named register variables (GNU extension) are never emitted.
9776  if (VD->getStorageClass() == SC_Register)
9777  return false;
9778  if (VD->getDescribedVarTemplate() ||
9779  isa<VarTemplatePartialSpecializationDecl>(VD))
9780  return false;
9781  } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
9782  // We never need to emit an uninstantiated function template.
9783  if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
9784  return false;
9785  } else if (isa<PragmaCommentDecl>(D))
9786  return true;
9787  else if (isa<OMPThreadPrivateDecl>(D))
9788  return true;
9789  else if (isa<PragmaDetectMismatchDecl>(D))
9790  return true;
9791  else if (isa<OMPThreadPrivateDecl>(D))
9792  return !D->getDeclContext()->isDependentContext();
9793  else if (isa<OMPDeclareReductionDecl>(D))
9794  return !D->getDeclContext()->isDependentContext();
9795  else if (isa<ImportDecl>(D))
9796  return true;
9797  else
9798  return false;
9799 
9800  if (D->isFromASTFile() && !LangOpts.BuildingPCHWithObjectFile) {
9801  assert(getExternalSource() && "It's from an AST file; must have a source.");
9802  // On Windows, PCH files are built together with an object file. If this
9803  // declaration comes from such a PCH and DeclMustBeEmitted would return
9804  // true, it would have returned true and the decl would have been emitted
9805  // into that object file, so it doesn't need to be emitted here.
9806  // Note that decls are still emitted if they're referenced, as usual;
9807  // DeclMustBeEmitted is used to decide whether a decl must be emitted even
9808  // if it's not referenced.
9809  //
9810  // Explicit template instantiation definitions are tricky. If there was an
9811  // explicit template instantiation decl in the PCH before, it will look like
9812  // the definition comes from there, even if that was just the declaration.
9813  // (Explicit instantiation defs of variable templates always get emitted.)
9814  bool IsExpInstDef =
9815  isa<FunctionDecl>(D) &&
9816  cast<FunctionDecl>(D)->getTemplateSpecializationKind() ==
9818 
9819  // Implicit member function definitions, such as operator= might not be
9820  // marked as template specializations, since they're not coming from a
9821  // template but synthesized directly on the class.
9822  IsExpInstDef |=
9823  isa<CXXMethodDecl>(D) &&
9824  cast<CXXMethodDecl>(D)->getParent()->getTemplateSpecializationKind() ==
9826 
9827  if (getExternalSource()->DeclIsFromPCHWithObjectFile(D) && !IsExpInstDef)
9828  return false;
9829  }
9830 
9831  // If this is a member of a class template, we do not need to emit it.
9832  if (D->getDeclContext()->isDependentContext())
9833  return false;
9834 
9835  // Weak references don't produce any output by themselves.
9836  if (D->hasAttr<WeakRefAttr>())
9837  return false;
9838 
9839  // Aliases and used decls are required.
9840  if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>())
9841  return true;
9842 
9843  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
9844  // Forward declarations aren't required.
9845  if (!FD->doesThisDeclarationHaveABody())
9846  return FD->doesDeclarationForceExternallyVisibleDefinition();
9847 
9848  // Constructors and destructors are required.
9849  if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>())
9850  return true;
9851 
9852  // The key function for a class is required. This rule only comes
9853  // into play when inline functions can be key functions, though.
9854  if (getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
9855  if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
9856  const CXXRecordDecl *RD = MD->getParent();
9857  if (MD->isOutOfLine() && RD->isDynamicClass()) {
9858  const CXXMethodDecl *KeyFunc = getCurrentKeyFunction(RD);
9859  if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl())
9860  return true;
9861  }
9862  }
9863  }
9864 
9866 
9867  // static, static inline, always_inline, and extern inline functions can
9868  // always be deferred. Normal inline functions can be deferred in C99/C++.
9869  // Implicit template instantiations can also be deferred in C++.
9870  return !isDiscardableGVALinkage(Linkage);
9871  }
9872 
9873  const auto *VD = cast<VarDecl>(D);
9874  assert(VD->isFileVarDecl() && "Expected file scoped var");
9875 
9876  // If the decl is marked as `declare target to`, it should be emitted for the
9877  // host and for the device.
9878  if (LangOpts.OpenMP &&
9879  OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
9880  return true;
9881 
9882  if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly &&
9884  return false;
9885 
9886  // Variables that can be needed in other TUs are required.
9887  auto Linkage = GetGVALinkageForVariable(VD);
9889  return true;
9890 
9891  // We never need to emit a variable that is available in another TU.
9893  return false;
9894 
9895  // Variables that have destruction with side-effects are required.
9896  if (VD->getType().isDestructedType())
9897  return true;
9898 
9899  // Variables that have initialization with side-effects are required.
9900  if (VD->getInit() && VD->getInit()->HasSideEffects(*this) &&
9901  // We can get a value-dependent initializer during error recovery.
9902  (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
9903  return true;
9904 
9905  // Likewise, variables with tuple-like bindings are required if their
9906  // bindings have side-effects.
9907  if (const auto *DD = dyn_cast<DecompositionDecl>(VD))
9908  for (const auto *BD : DD->bindings())
9909  if (const auto *BindingVD = BD->getHoldingVar())
9910  if (DeclMustBeEmitted(BindingVD))
9911  return true;
9912 
9913  return false;
9914 }
9915 
9917  const FunctionDecl *FD,
9918  llvm::function_ref<void(FunctionDecl *)> Pred) const {
9919  assert(FD->isMultiVersion() && "Only valid for multiversioned functions");
9920  llvm::SmallDenseSet<const FunctionDecl*, 4> SeenDecls;
9921  FD = FD->getMostRecentDecl();
9922  for (auto *CurDecl :
9924  FunctionDecl *CurFD = CurDecl->getAsFunction()->getMostRecentDecl();
9925  if (CurFD && hasSameType(CurFD->getType(), FD->getType()) &&
9926  std::end(SeenDecls) == llvm::find(SeenDecls, CurFD)) {
9927  SeenDecls.insert(CurFD);
9928  Pred(CurFD);
9929  }
9930  }
9931 }
9932 
9934  bool IsCXXMethod) const {
9935  // Pass through to the C++ ABI object
9936  if (IsCXXMethod)
9937  return ABI->getDefaultMethodCallConv(IsVariadic);
9938 
9939  switch (LangOpts.getDefaultCallingConv()) {
9940  case LangOptions::DCC_None:
9941  break;
9943  return CC_C;
9945  if (getTargetInfo().hasFeature("sse2") && !IsVariadic)
9946  return CC_X86FastCall;
9947  break;
9949  if (!IsVariadic)
9950  return CC_X86StdCall;
9951  break;
9953  // __vectorcall cannot be applied to variadic functions.
9954  if (!IsVariadic)
9955  return CC_X86VectorCall;
9956  break;
9958  // __regcall cannot be applied to variadic functions.
9959  if (!IsVariadic)
9960  return CC_X86RegCall;
9961  break;
9962  }
9963  return Target->getDefaultCallingConv(TargetInfo::CCMT_Unknown);
9964 }
9965 
9967  // Pass through to the C++ ABI object
9968  return ABI->isNearlyEmpty(RD);
9969 }
9970 
9972  if (!VTContext.get()) {
9973  if (Target->getCXXABI().isMicrosoft())
9974  VTContext.reset(new MicrosoftVTableContext(*this));
9975  else
9976  VTContext.reset(new ItaniumVTableContext(*this));
9977  }
9978  return VTContext.get();
9979 }
9980 
9982  switch (Target->getCXXABI().getKind()) {
9987  case TargetCXXABI::iOS:
9988  case TargetCXXABI::iOS64:
9990  case TargetCXXABI::WatchOS:
9994  }
9995  llvm_unreachable("Unsupported ABI");
9996 }
9997 
9998 CXXABI::~CXXABI() = default;
9999 
10001  return ASTRecordLayouts.getMemorySize() +
10002  llvm::capacity_in_bytes(ObjCLayouts) +
10003  llvm::capacity_in_bytes(KeyFunctions) +
10004  llvm::capacity_in_bytes(ObjCImpls) +
10005  llvm::capacity_in_bytes(BlockVarCopyInits) +
10006  llvm::capacity_in_bytes(DeclAttrs) +
10007  llvm::capacity_in_bytes(TemplateOrInstantiation) +
10008  llvm::capacity_in_bytes(InstantiatedFromUsingDecl) +
10009  llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) +
10010  llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) +
10011  llvm::capacity_in_bytes(OverriddenMethods) +
10012  llvm::capacity_in_bytes(Types) +
10013  llvm::capacity_in_bytes(VariableArrayTypes) +
10014  llvm::capacity_in_bytes(ClassScopeSpecializationPattern);
10015 }
10016 
10017 /// getIntTypeForBitwidth -
10018 /// sets integer QualTy according to specified details:
10019 /// bitwidth, signed/unsigned.
10020 /// Returns empty type if there is no appropriate target types.
10022  unsigned Signed) const {
10023  TargetInfo::IntType Ty = getTargetInfo().getIntTypeByWidth(DestWidth, Signed);
10024  CanQualType QualTy = getFromTargetType(Ty);
10025  if (!QualTy && DestWidth == 128)
10026  return Signed ? Int128Ty : UnsignedInt128Ty;
10027  return QualTy;
10028 }
10029 
10030 /// getRealTypeForBitwidth -
10031 /// sets floating point QualTy according to specified bitwidth.
10032 /// Returns empty type if there is no appropriate target types.
10035  switch (Ty) {
10036  case TargetInfo::Float:
10037  return FloatTy;
10038  case TargetInfo::Double:
10039  return DoubleTy;
10041  return LongDoubleTy;
10042  case TargetInfo::Float128:
10043  return Float128Ty;
10044  case TargetInfo::NoFloat:
10045  return {};
10046  }
10047 
10048  llvm_unreachable("Unhandled TargetInfo::RealType value");
10049 }
10050 
10051 void ASTContext::setManglingNumber(const NamedDecl *ND, unsigned Number) {
10052  if (Number > 1)
10053  MangleNumbers[ND] = Number;
10054 }
10055 
10056 unsigned ASTContext::getManglingNumber(const NamedDecl *ND) const {
10057  auto I = MangleNumbers.find(ND);
10058  return I != MangleNumbers.end() ? I->second : 1;
10059 }
10060 
10061 void ASTContext::setStaticLocalNumber(const VarDecl *VD, unsigned Number) {
10062  if (Number > 1)
10063  StaticLocalNumbers[VD] = Number;
10064 }
10065 
10066 unsigned ASTContext::getStaticLocalNumber(const VarDecl *VD) const {
10067  auto I = StaticLocalNumbers.find(VD);
10068  return I != StaticLocalNumbers.end() ? I->second : 1;
10069 }
10070 
10073  assert(LangOpts.CPlusPlus); // We don't need mangling numbers for plain C.
10074  std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
10075  if (!MCtx)
10077  return *MCtx;
10078 }
10079 
10080 std::unique_ptr<MangleNumberingContext>
10082  return ABI->createMangleNumberingContext();
10083 }
10084 
10085 const CXXConstructorDecl *
10087  return ABI->getCopyConstructorForExceptionObject(
10088  cast<CXXRecordDecl>(RD->getFirstDecl()));
10089 }
10090 
10092  CXXConstructorDecl *CD) {
10093  return ABI->addCopyConstructorForExceptionObject(
10094  cast<CXXRecordDecl>(RD->getFirstDecl()),
10095  cast<CXXConstructorDecl>(CD->getFirstDecl()));
10096 }
10097 
10099  TypedefNameDecl *DD) {
10100  return ABI->addTypedefNameForUnnamedTagDecl(TD, DD);
10101 }
10102 
10105  return ABI->getTypedefNameForUnnamedTagDecl(TD);
10106 }
10107 
10109  DeclaratorDecl *DD) {
10110  return ABI->addDeclaratorForUnnamedTagDecl(TD, DD);
10111 }
10112 
10114  return ABI->getDeclaratorForUnnamedTagDecl(TD);
10115 }
10116 
10117 void ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) {
10118  ParamIndices[D] = index;
10119 }
10120 
10121 unsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const {
10122  ParameterIndexTable::const_iterator I = ParamIndices.find(D);
10123  assert(I != ParamIndices.end() &&
10124  "ParmIndices lacks entry set by ParmVarDecl");
10125  return I->second;
10126 }
10127 
10128 APValue *
10130  bool MayCreate) {
10131  assert(E && E->getStorageDuration() == SD_Static &&
10132  "don't need to cache the computed value for this temporary");
10133  if (MayCreate) {
10134  APValue *&MTVI = MaterializedTemporaryValues[E];
10135  if (!MTVI)
10136  MTVI = new (*this) APValue;
10137  return MTVI;
10138  }
10139 
10140  return MaterializedTemporaryValues.lookup(E);
10141 }
10142 
10144  const llvm::Triple &T = getTargetInfo().getTriple();
10145  if (!T.isOSDarwin())
10146  return false;
10147 
10148  if (!(T.isiOS() && T.isOSVersionLT(7)) &&
10149  !(T.isMacOSX() && T.isOSVersionLT(10, 9)))
10150  return false;
10151 
10152  QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
10153  CharUnits sizeChars = getTypeSizeInChars(AtomicTy);
10154  uint64_t Size = sizeChars.getQuantity();
10155  CharUnits alignChars = getTypeAlignInChars(AtomicTy);
10156  unsigned Align = alignChars.getQuantity();
10157  unsigned MaxInlineWidthInBits = getTargetInfo().getMaxAtomicInlineWidth();
10158  return (Size != Align || toBits(sizeChars) > MaxInlineWidthInBits);
10159 }
10160 
10161 /// Template specializations to abstract away from pointers and TypeLocs.
10162 /// @{
10163 template <typename T>
10166 }
10167 template <>
10170 }
10171 template <>
10175 }
10176 /// @}
10177 
10178 /// A \c RecursiveASTVisitor that builds a map from nodes to their
10179 /// parents as defined by the \c RecursiveASTVisitor.
10180 ///
10181 /// Note that the relationship described here is purely in terms of AST
10182 /// traversal - there are other relationships (for example declaration context)
10183 /// in the AST that are better modeled by special matchers.
10184 ///
10185 /// FIXME: Currently only builds up the map using \c Stmt and \c Decl nodes.
10187  : public RecursiveASTVisitor<ASTVisitor> {
10188 public:
10189  ASTVisitor(ParentMap &Map) : Map(Map) {}
10190 
10191 private:
10193 
10195 
10196  bool shouldVisitTemplateInstantiations() const { return true; }
10197 
10198  bool shouldVisitImplicitCode() const { return true; }
10199 
10200  template <typename T, typename MapNodeTy, typename BaseTraverseFn,
10201  typename MapTy>
10202  bool TraverseNode(T Node, MapNodeTy MapNode, BaseTraverseFn BaseTraverse,
10203  MapTy *Parents) {
10204  if (!Node)
10205  return true;
10206  if (ParentStack.size() > 0) {
10207  // FIXME: Currently we add the same parent multiple times, but only
10208  // when no memoization data is available for the type.
10209  // For example when we visit all subexpressions of template
10210  // instantiations; this is suboptimal, but benign: the only way to
10211  // visit those is with hasAncestor / hasParent, and those do not create
10212  // new matches.
10213  // The plan is to enable DynTypedNode to be storable in a map or hash
10214  // map. The main problem there is to implement hash functions /
10215  // comparison operators for all types that DynTypedNode supports that
10216  // do not have pointer identity.
10217  auto &NodeOrVector = (*Parents)[MapNode];
10218  if (NodeOrVector.isNull()) {
10219  if (const auto *D = ParentStack.back().get<Decl>())
10220  NodeOrVector = D;
10221  else if (const auto *S = ParentStack.back().get<Stmt>())
10222  NodeOrVector = S;
10223  else
10224  NodeOrVector = new ast_type_traits::DynTypedNode(ParentStack.back());
10225  } else {
10226  if (!NodeOrVector.template is<ParentVector *>()) {
10227  auto *Vector = new ParentVector(
10228  1, getSingleDynTypedNodeFromParentMap(NodeOrVector));
10229  delete NodeOrVector
10230  .template dyn_cast<ast_type_traits::DynTypedNode *>();
10231  NodeOrVector = Vector;
10232  }
10233 
10234  auto *Vector = NodeOrVector.template get<ParentVector *>();
10235  // Skip duplicates for types that have memoization data.
10236  // We must check that the type has memoization data before calling
10237  // std::find() because DynTypedNode::operator== can't compare all
10238  // types.
10239  bool Found = ParentStack.back().getMemoizationData() &&
10240  std::find(Vector->begin(), Vector->end(),
10241  ParentStack.back()) != Vector->end();
10242  if (!Found)
10243  Vector->push_back(ParentStack.back());
10244  }
10245  }
10246  ParentStack.push_back(createDynTypedNode(Node));
10247  bool Result = BaseTraverse();
10248  ParentStack.pop_back();
10249  return Result;
10250  }
10251 
10252  bool TraverseDecl(Decl *DeclNode) {
10253  return TraverseNode(
10254  DeclNode, DeclNode, [&] { return VisitorBase::TraverseDecl(DeclNode); },
10255  &Map.PointerParents);
10256  }
10257 
10258  bool TraverseStmt(Stmt *StmtNode) {
10259  return TraverseNode(
10260  StmtNode, StmtNode, [&] { return VisitorBase::TraverseStmt(StmtNode); },
10261  &Map.PointerParents);
10262  }
10263 
10264  bool TraverseTypeLoc(TypeLoc TypeLocNode) {
10265  return TraverseNode(
10266  TypeLocNode, ast_type_traits::DynTypedNode::create(TypeLocNode),
10267  [&] { return VisitorBase::TraverseTypeLoc(TypeLocNode); },
10268  &Map.OtherParents);
10269  }
10270 
10271  bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLocNode) {
10272  return TraverseNode(
10273  NNSLocNode, ast_type_traits::DynTypedNode::create(NNSLocNode),
10274  [&] { return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode); },
10275  &Map.OtherParents);
10276  }
10277 
10278  ParentMap &Map;
10280 };
10281 
10283  ASTVisitor(*this).TraverseAST(Ctx);
10284 }
10285 
10288  if (!Parents)
10289  // We build the parent map for the traversal scope (usually whole TU), as
10290  // hasAncestor can escape any subtree.
10291  Parents = llvm::make_unique<ParentMap>(*this);
10292  return Parents->getParents(Node);
10293 }
10294 
10295 bool
10297  const ObjCMethodDecl *MethodImpl) {
10298  // No point trying to match an unavailable/deprecated mothod.
10299  if (MethodDecl->hasAttr<UnavailableAttr>()
10300  || MethodDecl->hasAttr<DeprecatedAttr>())
10301  return false;
10302  if (MethodDecl->getObjCDeclQualifier() !=
10303  MethodImpl->getObjCDeclQualifier())
10304  return false;
10305  if (!hasSameType(MethodDecl->getReturnType(), MethodImpl->getReturnType()))
10306  return false;
10307 
10308  if (MethodDecl->param_size() != MethodImpl->param_size())
10309  return false;
10310 
10311  for (ObjCMethodDecl::param_const_iterator IM = MethodImpl->param_begin(),
10312  IF = MethodDecl->param_begin(), EM = MethodImpl->param_end(),
10313  EF = MethodDecl->param_end();
10314  IM != EM && IF != EF; ++IM, ++IF) {
10315  const ParmVarDecl *DeclVar = (*IF);
10316  const ParmVarDecl *ImplVar = (*IM);
10317  if (ImplVar->getObjCDeclQualifier() != DeclVar->getObjCDeclQualifier())
10318  return false;
10319  if (!hasSameType(DeclVar->getType(), ImplVar->getType()))
10320  return false;
10321  }
10322 
10323  return (MethodDecl->isVariadic() == MethodImpl->isVariadic());
10324 }
10325 
10327  LangAS AS;
10329  AS = LangAS::Default;
10330  else
10331  AS = QT->getPointeeType().getAddressSpace();
10332 
10333  return getTargetInfo().getNullPointerValue(AS);
10334 }
10335 
10337  if (isTargetAddressSpace(AS))
10338  return toTargetAddressSpace(AS);
10339  else
10340  return (*AddrSpaceMap)[(unsigned)AS];
10341 }
10342 
10344  assert(Ty->isFixedPointType());
10345 
10346  if (Ty->isSaturatedFixedPointType()) return Ty;
10347 
10348  const auto &BT = Ty->getAs<BuiltinType>();
10349  switch (BT->getKind()) {
10350  default:
10351  llvm_unreachable("Not a fixed point type!");
10352  case BuiltinType::ShortAccum:
10353  return SatShortAccumTy;
10354  case BuiltinType::Accum:
10355  return SatAccumTy;
10356  case BuiltinType::LongAccum:
10357  return SatLongAccumTy;
10358  case BuiltinType::UShortAccum:
10359  return SatUnsignedShortAccumTy;
10360  case BuiltinType::UAccum:
10361  return SatUnsignedAccumTy;
10362  case BuiltinType::ULongAccum:
10363  return SatUnsignedLongAccumTy;
10364  case BuiltinType::ShortFract:
10365  return SatShortFractTy;
10366  case BuiltinType::Fract:
10367  return SatFractTy;
10368  case BuiltinType::LongFract:
10369  return SatLongFractTy;
10370  case BuiltinType::UShortFract:
10371  return SatUnsignedShortFractTy;
10372  case BuiltinType::UFract:
10373  return SatUnsignedFractTy;
10374  case BuiltinType::ULongFract:
10375  return SatUnsignedLongFractTy;
10376  }
10377 }
10378 
10380  if (LangOpts.OpenCL)
10382 
10383  if (LangOpts.CUDA)
10385 
10386  return getLangASFromTargetAS(AS);
10387 }
10388 
10389 // Explicitly instantiate this in case a Redeclarable<T> is used from a TU that
10390 // doesn't include ASTContext.h
10391 template
10393  const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::ValueType
10395  const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::makeValue(
10396  const clang::ASTContext &Ctx, Decl *Value);
10397 
10398 unsigned char ASTContext::getFixedPointScale(QualType Ty) const {
10399  assert(Ty->isFixedPointType());
10400 
10401  const auto *BT = Ty->getAs<BuiltinType>();
10402  const TargetInfo &Target = getTargetInfo();
10403  switch (BT->getKind()) {
10404  default:
10405  llvm_unreachable("Not a fixed point type!");
10406  case BuiltinType::ShortAccum:
10407  case BuiltinType::SatShortAccum:
10408  return Target.getShortAccumScale();
10409  case BuiltinType::Accum:
10410  case BuiltinType::SatAccum:
10411  return Target.getAccumScale();
10412  case BuiltinType::LongAccum:
10413  case BuiltinType::SatLongAccum:
10414  return Target.getLongAccumScale();
10415  case BuiltinType::UShortAccum:
10416  case BuiltinType::SatUShortAccum:
10417  return Target.getUnsignedShortAccumScale();
10418  case BuiltinType::UAccum:
10419  case BuiltinType::SatUAccum:
10420  return Target.getUnsignedAccumScale();
10421  case BuiltinType::ULongAccum:
10422  case BuiltinType::SatULongAccum:
10423  return Target.getUnsignedLongAccumScale();
10424  case BuiltinType::ShortFract:
10425  case BuiltinType::SatShortFract:
10426  return Target.getShortFractScale();
10427  case BuiltinType::Fract:
10428  case BuiltinType::SatFract:
10429  return Target.getFractScale();
10430  case BuiltinType::LongFract:
10431  case BuiltinType::SatLongFract:
10432  return Target.getLongFractScale();
10433  case BuiltinType::UShortFract:
10434  case BuiltinType::SatUShortFract:
10435  return Target.getUnsignedShortFractScale();
10436  case BuiltinType::UFract:
10437  case BuiltinType::SatUFract:
10438  return Target.getUnsignedFractScale();
10439  case BuiltinType::ULongFract:
10440  case BuiltinType::SatULongFract:
10441  return Target.getUnsignedLongFractScale();
10442  }
10443 }
10444 
10445 unsigned char ASTContext::getFixedPointIBits(QualType Ty) const {
10446  assert(Ty->isFixedPointType());
10447 
10448  const auto *BT = Ty->getAs<BuiltinType>();
10449  const TargetInfo &Target = getTargetInfo();
10450  switch (BT->getKind()) {
10451  default:
10452  llvm_unreachable("Not a fixed point type!");
10453  case BuiltinType::ShortAccum:
10454  case BuiltinType::SatShortAccum:
10455  return Target.getShortAccumIBits();
10456  case BuiltinType::Accum:
10457  case BuiltinType::SatAccum:
10458  return Target.getAccumIBits();
10459  case BuiltinType::LongAccum:
10460  case BuiltinType::SatLongAccum:
10461  return Target.getLongAccumIBits();
10462  case BuiltinType::UShortAccum:
10463  case BuiltinType::SatUShortAccum:
10464  return Target.getUnsignedShortAccumIBits();
10465  case BuiltinType::UAccum:
10466  case BuiltinType::SatUAccum:
10467  return Target.getUnsignedAccumIBits();
10468  case BuiltinType::ULongAccum:
10469  case BuiltinType::SatULongAccum:
10470  return Target.getUnsignedLongAccumIBits();
10471  case BuiltinType::ShortFract:
10472  case BuiltinType::SatShortFract:
10473  case BuiltinType::Fract:
10474  case BuiltinType::SatFract:
10475  case BuiltinType::LongFract:
10476  case BuiltinType::SatLongFract:
10477  case BuiltinType::UShortFract:
10478  case BuiltinType::SatUShortFract:
10479  case BuiltinType::UFract:
10480  case BuiltinType::SatUFract:
10481  case BuiltinType::ULongFract:
10482  case BuiltinType::SatULongFract:
10483  return 0;
10484  }
10485 }
10486 
10488  assert(Ty->isFixedPointType());
10489  bool isSigned = Ty->isSignedFixedPointType();
10490  return FixedPointSemantics(
10491  static_cast<unsigned>(getTypeSize(Ty)), getFixedPointScale(Ty), isSigned,
10494 }
10495 
10497  assert(Ty->isFixedPointType());
10499 }
10500 
10502  assert(Ty->isFixedPointType());
10504 }
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:4202
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:921
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl)
Definition: DeclCXX.cpp:2584
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.
CanQualType SatShortAccumTy
Definition: ASTContext.h:1034
TemplateTemplateParmDecl * getParameterPack() const
Retrieve the template template parameter pack being substituted.
Definition: TemplateName.h:136
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition: Type.cpp:1530
static void EncodeBitField(const ASTContext *Ctx, std::string &S, QualType T, const FieldDecl *FD)
CanQualType SatUnsignedLongFractTy
Definition: ASTContext.h:1038
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:5191
bool hasDefinition() const
Determine whether this class has been defined.
Definition: DeclObjC.h:1535
The generic AArch64 ABI is also a modified version of the Itanium ABI, but it has fewer divergences t...
Definition: TargetCXXABI.h:84
Represents a type that was referred to using an elaborated type keyword, e.g., struct S...
Definition: Type.h:5129
ASTMutationListener * Listener
Definition: ASTContext.h:571
IntType getInt64Type() const
Definition: TargetInfo.h:292
QualType withConst() const
Retrieves a version of this type with const applied.
const Type * Ty
The locally-unqualified type.
Definition: Type.h:579
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
static APFixedPoint getMax(const FixedPointSemantics &Sema)
Definition: FixedPoint.cpp:102
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:4932
CanQualType LongLongTy
Definition: ASTContext.h:1025
static const Decl * getCanonicalDecl(const Decl *D)
void setImplicit(bool I=true)
Definition: DeclBase.h:548
Represents a function declaration or definition.
Definition: Decl.h:1738
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.
bool isFixedPointType() const
Return true if this is a fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169.
Definition: Type.h:6591
CanQualType WIntTy
Definition: ASTContext.h:1021
bool isKindOfTypeAsWritten() const
Whether this is a "__kindof" type as written.
Definition: Type.h:5655
CXXABI * CreateMicrosoftCXXABI(ASTContext &Ctx)
const Decl * CommentDecl
Declaration the comment is actually attached to (in the source).
Definition: Comment.h:984
bool isObjCQualifiedIdType() const
True if this is equivalent to &#39;id.
Definition: Type.h:5873
SplitQualType split() const
CanQualType AccumTy
Definition: ASTContext.h:1029
no exception specification
unsigned char getFixedPointIBits(QualType Ty) const
CanQualType OCLQueueTy
Definition: ASTContext.h:1054
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1849
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
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
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:2537
ArrayRef< QualType > getTypeArgsAsWritten() const
Retrieve the type arguments of this object type as they were written.
Definition: Type.h:5649
CanQualType LongDoubleComplexTy
Definition: ASTContext.h:1042
void * getAsVoidPointer() const
Retrieve the template name as a void pointer.
Definition: TemplateName.h:311
QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false)
QualType getPointeeType() const
Definition: Type.h:2550
CanQualType VoidPtrTy
Definition: ASTContext.h:1044
Represents the dependent type named by a dependently-scoped typename using declaration, e.g.
Definition: Type.h:4121
A (possibly-)qualified type.
Definition: Type.h:638
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:6304
Static storage duration.
Definition: Specifiers.h:281
QualType areCommonBaseCompatible(const ObjCObjectPointerType *LHSOPT, const ObjCObjectPointerType *RHSOPT)
OverloadedOperatorKind getOperator() const
Return the overloaded operator to which this template name refers.
Definition: TemplateName.h:495
bool isArrayType() const
Definition: Type.h:6345
bool getNoCfCheck() const
Definition: Type.h:3515
bool isNull() const
Definition: CanonicalType.h:98
bool isMemberPointerType() const
Definition: Type.h:6327
bool canBuiltinBeRedeclared(const FunctionDecl *) const
Return whether a declaration to a builtin is allowed to be overloaded/redeclared. ...
unsigned param_size() const
Definition: DeclObjC.h:341
unsigned char getFixedPointScale(QualType Ty) const
ASTContext(LangOptions &LOpts, SourceManager &SM, IdentifierTable &idents, SelectorTable &sels, Builtin::Context &builtins)
Definition: ASTContext.cpp:784
CanQualType UnsignedLongFractTy
Definition: ASTContext.h:1033
QualType getBuiltinVaListType() const
Retrieve the type of the __builtin_va_list type.
Definition: ASTContext.h:1904
unsigned getLongWidth() const
getLongWidth/Align - Return the size of &#39;signed long&#39; and &#39;unsigned long&#39; for this target...
Definition: TargetInfo.h:389
static unsigned NumImplicitMoveAssignmentOperatorsDeclared
The number of implicitly-declared move assignment operators for which declarations were built...
Definition: ASTContext.h:2820
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2827
CanQualType FractTy
Definition: ASTContext.h:1032
static MicrosoftMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags)
void Profile(llvm::FoldingSetNodeID &ID) const
Definition: Type.h:1342
CanQualType Char32Ty
Definition: ASTContext.h:1024
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:2788
BlockVarCopyInit getBlockVarCopyInit(const VarDecl *VD) const
Get the copy initialization expression of the VarDecl VD, or nullptr if none exists.
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:1370
Stmt - This represents one statement.
Definition: Stmt.h:66
void setLAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1568
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:2418
Internal representation of canonical, dependent __underlying_type(type) types.
Definition: Type.h:4330
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3355
bool CommentsLoaded
True if comments are already loaded from ExternalASTSource.
Definition: ASTContext.h:727
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:505
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:5389
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:953
bool hasExtParameterInfos() const
Is there any interesting extra information for any of the parameters of this function type...
Definition: Type.h:4059
__builtin_va_list as defined by the PNaCl ABI: http://www.chromium.org/nativeclient/pnacl/bitcode-abi...
Definition: TargetInfo.h:195
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:233
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:1937
unsigned overridden_methods_size(const CXXMethodDecl *Method) const
The fixed point semantics work similarly to llvm::fltSemantics.
Definition: FixedPoint.h:32
Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier.
Definition: Decl.h:3018
C Language Family Type Representation.
Defines the SourceManager interface.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3217
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:2816
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:5212
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:3276
bool isRecordType() const
Definition: Type.h:6369
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:1042
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:724
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:1933
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:2898
CoreFoundationABI CFRuntime
Definition: LangOptions.h:209
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4002
EnumDecl * getPreviousDecl()
Definition: Decl.h:3412
CanQualType ObjCBuiltinSelTy
Definition: ASTContext.h:1048
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:410
bool isDiscardableGVALinkage(GVALinkage L)
Definition: Linkage.h:82
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:1458
Represents a C++11 auto or C++14 decltype(auto) type.
Definition: Type.h:4749
Kind getKind() const
Definition: TargetCXXABI.h:132
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
Definition: Decl.cpp:3797
A class providing a concrete implementation of ObjCObjectType, so as to not increase the footprint of...
Definition: Type.h:5691
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx)
Definition: Type.cpp:3075
unsigned getDefaultAlignForAttributeAligned() const
Return the default alignment for attribute((aligned)) on this target, to be used if no alignment valu...
Definition: TargetInfo.h:530
ObjCTypeParamList * getTypeParamList() const
Retrieve the type parameters of this class.
Definition: DeclObjC.cpp:308
Defines types useful for describing an Objective-C runtime.
QualType getDependentVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc, VectorType::VectorKind VecKind) const
Return the unique reference to the type for a dependently sized vector of the specified element type...
CanQualType ARCUnbridgedCastTy
Definition: ASTContext.h:1047
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
Definition: Decl.h:2763
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:1407
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...
CanQualType SatUnsignedAccumTy
Definition: ASTContext.h:1035
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:1766
static bool areSortedAndUniqued(ArrayRef< ObjCProtocolDecl *> Protocols)
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
CanQualType LongTy
Definition: ASTContext.h:1025
DiagnosticsEngine & getDiagnostics() const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2812
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:2495
Represent a C++ namespace.
Definition: Decl.h:515
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1590
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:2659
virtual void completeDefinition()
Note that the definition of this type is now complete.
Definition: Decl.cpp:4154
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
QualType withConst() const
Definition: Type.h:810
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:690
QualType adjustStringLiteralBaseType(QualType StrLTy) const
A container of type source information.
Definition: Decl.h:87
llvm::DenseMap< Stmt *, Stmt * > MapTy
Definition: ParentMap.cpp:23
CharUnits getAlignment() const
getAlignment - Get the record alignment in characters.
Definition: RecordLayout.h:177
static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod, SmallVectorImpl< const NamedDecl *> &Redeclared)
Definition: ASTContext.cpp:453
Interoperability with the latest known version of the Swift runtime.
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:204
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:352
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2484
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4156
CanQualType WideCharTy
Definition: ASTContext.h:1020
const DeclContext * getParentFunctionOrMethod() const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext...
Definition: DeclBase.cpp:254
A template template parameter that has been substituted for some other template name.
Definition: TemplateName.h:207
CanQualType HalfTy
Definition: ASTContext.h:1040
QualType getElementType() const
Definition: Type.h:2847
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition: Type.cpp:540
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:2091
const IdentifierInfo * getIdentifier() const
Returns the identifier to which this template name refers.
Definition: TemplateName.h:485
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:1884
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:762
Represents a variable declaration or definition.
Definition: Decl.h:813
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:332
QualType getReturnType() const
Definition: Decl.h:2302
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:190
RecordDecl * getPreviousDecl()
Definition: Decl.h:3632
unsigned getNumParams() const
Definition: Type.h:3888
bool isEnumeralType() const
Definition: Type.h:6373
APFixedPoint getFixedPointMax(QualType Ty) const
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3529
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:6748
void setClassScopeSpecializationPattern(FunctionDecl *FD, FunctionDecl *Pattern)
CanQualType Float128Ty
Definition: ASTContext.h:1028
virtual void CompleteRedeclChain(const Decl *D)
Gives the external AST source an opportunity to complete the redeclaration chain for a declaration...
MangleContext * createMangleContext()
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:3767
CanQualType ShortAccumTy
Definition: ASTContext.h:1029
Declaration context for names declared as extern "C" in C++.
Definition: Decl.h:222
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:4785
__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:191
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:432
ObjCImplementationDecl * getObjCImplementation(ObjCInterfaceDecl *D)
Get the implementation of the ObjCInterfaceDecl D, or nullptr if none exists.
bool field_empty() const
Definition: Decl.h:3792
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:1703
void setRaw(const RawComment *RC)
Definition: ASTContext.h:766
bool isInvalidDecl() const
Definition: DeclBase.h:542
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
static ObjCPropertyDecl * findPropertyDecl(const DeclContext *DC, const IdentifierInfo *propertyID, ObjCPropertyQueryKind queryKind)
Lookup a property by name in the specified DeclContext.
Definition: DeclObjC.cpp:177
TemplateName getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param, TemplateName replacement) const
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
CanQualType ShortFractTy
Definition: ASTContext.h:1032
SpecifierKind getKind() const
Determine what kind of nested name specifier is stored.
protocol_range protocols() const
Definition: DeclObjC.h:2129
Decl * getVaListTagDecl() const
Retrieve the C type declaration corresponding to the predefined __va_list_tag type used to help defin...
Represents a parameter to a function.
Definition: Decl.h:1550
Represents the result of substituting a type for a template type parameter.
Definition: Type.h:4603
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2571
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:24
Defines the clang::Expr interface and subclasses for C++ expressions.
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:315
noexcept(expression), value-dependent
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:141
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
Definition: Expr.cpp:3595
PipeType - OpenCL20.
Definition: Type.h:6002
bool UnwrapSimilarTypes(QualType &T1, QualType &T2)
Attempt to unwrap two types that may be similar (C++ [conv.qual]).
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:3065
Qualifiers getQualifiers() const
Retrieve all qualifiers.
SubstTemplateTemplateParmStorage * getAsSubstTemplateTemplateParm() const
Retrieve the substituted template template parameter, if known.
CanQualType OCLSamplerTy
Definition: ASTContext.h:1053
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:57
Represents a struct/union/class.
Definition: Decl.h:3593
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:1327
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:349
RecordDecl * getCFConstantStringTagDecl() const
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:298
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:3768
bool isComplete() const
Returns true if this can be considered a complete type.
Definition: Decl.h:3534
One of these records is kept for each identifier that is lexed.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1022
bool isObjCQualifiedClass() const
Definition: Type.h:5621
This table allows us to fully hide how we implement multi-keyword caching.
unsigned getRegParm() const
Definition: Type.h:3518
Represents a class type in Objective C.
Definition: Type.h:5538
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
Definition: Decl.cpp:4107
QualType getPointeeType() const
Definition: Type.h:2654
void setManglingNumber(const NamedDecl *ND, unsigned Number)
CXXRecordDecl * getPreviousDecl()
Definition: DeclCXX.h:736
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
static unsigned NumImplicitMoveConstructorsDeclared
The number of implicitly-declared move constructors for which declarations were built.
Definition: ASTContext.h:2806
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:423
QualType getObjCSuperType() const
Returns the C struct type for objc_super.
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3895
ArrayRef< ExtParameterInfo > getExtParameterInfos() const
Definition: Type.h:4063
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:343
NamespaceDecl * getNamespace()
Retrieve the namespace declaration aliased by this directive.
Definition: DeclCXX.h:3093
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:1584
void setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst, FieldDecl *Tmpl)
Missing a type from <ucontext.h>
Definition: ASTContext.h:2013
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...
CanQualType UnsignedFractTy
Definition: ASTContext.h:1033
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3774
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:1787
field_range fields() const
Definition: Decl.h:3784
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:894
bool isObjCIdType() const
Definition: Type.h:6422
The generic Mips ABI is a modified version of the Itanium ABI.
Definition: TargetCXXABI.h:90
Represents a member of a struct/union/class.
Definition: Decl.h:2579
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
static CGCXXABI * createCXXABI(CodeGenModule &CGM)
bool isCanonicalUnqualified() const
Determines if this type would be canonical if it had no further qualification.
Definition: Type.h:1837
DynTypedNodeList getParents(const NodeT &Node)
Returns the parents of the given node (within the traversal scope).
Definition: ASTContext.h:648
SubstTemplateTemplateParmPackStorage * getAsSubstTemplateTemplateParmPack() const
Retrieve the substituted template template parameter pack, if known.
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
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 Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2796
const ObjCObjectPointerType * getAsObjCQualifiedIdType() const
Definition: Type.cpp:1562
void addLazyModuleInitializers(Module *M, ArrayRef< uint32_t > IDs)
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:3877
CanQualType LongAccumTy
Definition: ASTContext.h:1029
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2127
CanQualType OCLEventTy
Definition: ASTContext.h:1053
Optional< unsigned > getNumTemplateExpansions() const
Retrieve the number of expansions that a template template argument expansion will produce...
CharUnits getTypeUnadjustedAlignInChars(QualType T) const
getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a type, in characters, before alignment adjustments.
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
Interoperability with the Swift 4.1 runtime.
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4659
Container for either a single DynTypedNode or for an ArrayRef to DynTypedNode.
Definition: ASTContext.h:575
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:6511
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
qual_iterator qual_begin() const
Definition: Type.h:5439
RawComment * getRawCommentForDeclNoCache(const Decl *D) const
Return the documentation comment attached to a given declaration, without looking into cache...
Definition: ASTContext.cpp:115
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:241
uint64_t lookupFieldBitOffset(const ObjCInterfaceDecl *OID, const ObjCImplementationDecl *ID, const ObjCIvarDecl *Ivar) const
Get the offset of an ObjCIvarDecl in bits.
static ast_type_traits::DynTypedNode createDynTypedNode(const T &Node)
Template specializations to abstract away from pointers and TypeLocs.
static TypedefDecl * CreatePowerABIBuiltinVaListDecl(const ASTContext *Context)
CanQualType OCLReserveIDTy
Definition: ASTContext.h:1054
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
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:6022
static TypedefDecl * CreateCharPtrNamedVaListDecl(const ASTContext *Context, StringRef Name)
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6644
QualType getParamTypeForDecl() const
Definition: TemplateBase.h:269
Describes a module or submodule.
Definition: Module.h:65
IdentifierTable & Idents
Definition: ASTContext.h:566
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:6091
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:717
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:2262
CanQualType LongFractTy
Definition: ASTContext.h:1032
bool getProducesResult() const
Definition: Type.h:3513
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:303
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3110
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:2738
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2657
static APFixedPoint getMin(const FixedPointSemantics &Sema)
Definition: FixedPoint.cpp:110
IdentifierInfo * getAsIdentifier() const
Retrieve the identifier stored in this nested name specifier.
qual_iterator qual_end() const
Definition: Type.h:5440
A qualified template name, where the qualification is kept to describe the source code as written...
Definition: TemplateName.h:199
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:1456
const LangASMap & getAddressSpaceMap() const
Definition: TargetInfo.h:1187
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:969
static ItaniumMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags)
QualType getOriginalType() const
Definition: Decl.cpp:2544
void addObjCGCAttr(GC type)
Definition: Type.h:310
static ExternCContextDecl * Create(const ASTContext &C, TranslationUnitDecl *TU)
Definition: Decl.cpp:4361
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:555
CanQualType SatShortFractTy
Definition: ASTContext.h:1037
ArrayRef< QualType > getTypeArgs() const
Retrieve the type arguments of this object type (semantically).
Definition: Type.cpp:664
QualType getVolatileType(QualType T) const
Return the uniqued reference to the type for a volatile qualified type.
Definition: ASTContext.h:1177
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:5465
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2205
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:351
CanQualType SatUnsignedShortAccumTy
Definition: ASTContext.h:1035
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:6797
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:840
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:149
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4176
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:654
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:315
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1831
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:2434
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack)
Represents a declaration of a type.
Definition: Decl.h:2874
CanQualType PseudoObjectTy
Definition: ASTContext.h:1047
LangAS getAddressSpace() const
Definition: Type.h:352
QualType getExceptionObjectType(QualType T) const
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
const Type * getClass() const
Definition: Type.h:2790
CXXMethodVector::const_iterator overridden_cxx_method_iterator
Definition: ASTContext.h:927
bool isReadOnly() const
isReadOnly - Return true iff the property has a setter.
Definition: DeclObjC.h:863
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:5184
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:1028
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2595
static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI, const LangOptions &LangOpts)
Definition: ASTContext.cpp:771
Expr * getSizeExpr() const
Definition: Type.h:2991
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6072
unsigned Align
Definition: ASTContext.h:145
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3787
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1158
bool AlignIsRequired
Definition: ASTContext.h:146
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:3251
Defines the Linkage enumeration and various utility functions.
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2064
static unsigned NumImplicitDefaultConstructorsDeclared
The number of implicitly-declared default constructors for which declarations were built...
Definition: ASTContext.h:2792
TemplateTemplateParmDecl * getParameter() const
Definition: TemplateName.h:339
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:683
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:3332
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...
unsigned getTypeUnadjustedAlign(QualType T) const
Return the ABI-specified natural alignment of a (complete) type T, before alignment adjustments...
Definition: ASTContext.h:2099
Represents an ObjC class declaration.
Definition: DeclObjC.h:1172
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:419
QualType getReturnType() const
Definition: DeclObjC.h:323
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5773
bool getNoReturn() const
Definition: Type.h:3512
bool isKindOfType() const
Whether this is a "__kindof" type.
Definition: Type.h:5884
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:942
The iOS ABI is a partial implementation of the ARM ABI.
Definition: TargetCXXABI.h:63
IntrusiveRefCntPtr< ExternalASTSource > ExternalSource
Definition: ASTContext.h:570
CanQualType UnsignedCharTy
Definition: ASTContext.h:1026
Expr * getSizeExpr() const
Definition: Type.h:3048
bool getNoCallerSavedRegs() const
Definition: Type.h:3514
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:870
unsigned getNumProtocols() const
Return the number of qualifying protocols in this type, or 0 if there are none.
Definition: Type.h:5446
llvm::iterator_range< overridden_cxx_method_iterator > overridden_method_range
Definition: ASTContext.h:937
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:3128
This object can be modified without requiring retains or releases.
Definition: Type.h:162
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1595
The APFixedPoint class works similarly to APInt/APSInt in that it is a functional replacement for a s...
Definition: FixedPoint.h:74
void Profile(llvm::FoldingSetNodeID &ID)
Definition: TemplateName.h:501
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:3650
CanQualType Float128ComplexTy
Definition: ASTContext.h:1043
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2759
Expr * getAddrSpaceExpr() const
Definition: Type.h:3099
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:5245
QualType getBlockDescriptorExtendedType() const
Gets the struct used to keep track of the extended descriptor for pointer to blocks.
bool hasAttr() const
Definition: DeclBase.h:531
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5601
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.
QualType getCorrespondingSaturatedType(QualType Ty) const
unsigned getMinGlobalAlign() const
getMinGlobalAlign - Return the minimum alignment of a global variable, unless its alignment is explic...
Definition: TargetInfo.h:536
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2525
bool isPromotableIntegerType() const
More type predicates useful for type checking/promotion.
Definition: Type.cpp:2455
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1613
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3687
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:789
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.
bool isComplexType() const
isComplexType() does not include complex integers (a GCC extension).
Definition: Type.cpp:481
static unsigned NumImplicitCopyConstructors
The number of implicitly-declared copy constructors.
Definition: ASTContext.h:2795
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:689
qual_range quals() const
Definition: Type.h:5438
A dependent template name that has not been resolved to a template (or set of templates).
Definition: TemplateName.h:203
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:569
comments::FullComment * cloneFullComment(comments::FullComment *FC, const Decl *D) const
Definition: ASTContext.cpp:470
TypedefDecl * getBuiltinMSVaListDecl() const
Retrieve the C type declaration corresponding to the predefined __builtin_ms_va_list type...
bool UnwrapSimilarArrayTypes(QualType &T1, QualType &T2)
Attempt to unwrap two types that may both be array types with the same bound (or both be array types ...
ArraySizeModifier
Capture whether this is a normal array (e.g.
Definition: Type.h:2818
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:6147
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
bool isSaturatedFixedPointType() const
Return true if this is a saturated fixed point type according to ISO/IEC JTC1 SC22 WG14 N1169...
Definition: Type.h:6599
CanQualType UnsignedAccumTy
Definition: ASTContext.h:1031
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3665
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...
unsigned Offset
Definition: Format.cpp:1631
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
typedef void* __builtin_va_list;
Definition: TargetInfo.h:187
bool hasPointerIdentity() const
Check if the given ASTNodeKind identifies a type that offers pointer identity.
CanQualType UnsignedShortFractTy
Definition: ASTContext.h:1033
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:3026
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:236
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition: Type.cpp:2283
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:1768
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:876
bool isGNUFamily() const
Is this runtime basically of the GNU family of runtimes?
Definition: ObjCRuntime.h:119
ExtParameterInfo withIsNoEscape(bool NoEscape) const
Definition: Type.h:3421
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.
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3858
NamespaceDecl * getAsNamespace() const
Retrieve the namespace stored in this nested name specifier.
bool isMultiVersion() const
True if this function is considered a multiversioned function.
Definition: Decl.h:2225
This represents one expression.
Definition: Expr.h:106
Defines the clang::LangOptions interface.
SourceLocation End
void setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst, UsingShadowDecl *Pattern)
known_extensions_range known_extensions() const
Definition: DeclObjC.h:1761
The "typename" keyword precedes the qualified type name, e.g., typename T::type.
Definition: Type.h:5068
bool isPositive() const
isPositive - Test whether the quantity is greater than zero.
Definition: CharUnits.h:122
Selector getSetterName() const
Definition: DeclObjC.h:914
QualType getucontext_tType() const
Retrieve the C ucontext_t type.
Definition: ASTContext.h:1778
void addTypedefNameForUnnamedTagDecl(TagDecl *TD, TypedefNameDecl *TND)
static const LangASMap * getAddressSpaceMap(const TargetInfo &T, const LangOptions &LOpts)
Definition: ASTContext.cpp:749
static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y)
unsigned getAsOpaqueValue() const
Definition: Type.h:254
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:4481
static std::pair< CharUnits, CharUnits > getConstantArrayInfoInChars(const ASTContext &Context, const ConstantArrayType *CAT)
getConstantArrayInfoInChars - Performing the computation in CharUnits instead of in bits prevents ove...
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:4274
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:3516
bool isObjCBuiltinType() const
Definition: Type.h:6440
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6811
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:5050
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:3921
Inits[]
Definition: OpenMPClause.h:151
QualType getTypeOfExprType(Expr *e) const
GCC extension.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4506
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5177
Qualifiers::GC getObjCGCAttr() const
Returns gc attribute of this type.
Definition: Type.h:6193
QualType getParenType(QualType NamedType) const
CanQualType OMPArraySectionTy
Definition: ASTContext.h:1055
static TypedefDecl * CreateX86_64ABIBuiltinVaListDecl(const ASTContext *Context)
const Decl * getDecl() const LLVM_READONLY
Definition: Comment.h:1120
static unsigned NumImplicitMoveConstructors
The number of implicitly-declared move constructors.
Definition: ASTContext.h:2802
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:547
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:6569
unsigned getFastQualifiers() const
Definition: Type.h:386
bool canBeRedeclared(unsigned ID) const
Returns true if this is a builtin that can be redeclared.
Definition: Builtins.cpp:159
ObjCLifetime getObjCLifetime() const
Definition: Type.h:326
void removeFastQualifiers(unsigned mask)
Definition: Type.h:391
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
void setBlockVarCopyInit(const VarDecl *VD, Expr *CopyExpr, bool CanThrow)
Set the copy inialization expression of a block var decl.
bool isObjCClassType() const
Definition: Type.h:6428
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2607
DeclContext * getDeclContext()
Definition: DeclBase.h:427
A structure for storing the information associated with a substituted template template parameter...
Definition: TemplateName.h:326
bool isObjCIdType() const
True if this is equivalent to the &#39;id&#39; type, i.e.
Definition: Type.h:5856
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:338
SourceLocation Begin
UsingShadowDecl * getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst)
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4280
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
CanQualType ShortTy
Definition: ASTContext.h:1025
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:179
Represents the type decltype(expr) (C++11).
Definition: Type.h:4246
static TypedefDecl * CreateAAPCSABIBuiltinVaListDecl(const ASTContext *Context)
LangAS getLangASForBuiltinAddressSpace(unsigned AS) const
QualType getFILEType() const
Retrieve the C FILE type.
Definition: ASTContext.h:1742
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:482
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:1007
bool TraverseAST(ASTContext &AST)
Recursively visits an entire AST, starting from the top-level Decls in the AST traversal scope (by de...
CanQualType UnsignedInt128Ty
Definition: ASTContext.h:1027
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
Definition: Expr.h:715
A std::pair-like structure for storing a qualified type split into its local qualifiers and its local...
Definition: Type.h:577
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:1844
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3272
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:4289
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:207
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...
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
Qualifiers Quals
The local qualifiers.
Definition: Type.h:582
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl, 0 if there are none.
Definition: DeclBase.cpp:384
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1752
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: ExprCXX.h:4200
void setAddressSpace(LangAS space)
Definition: Type.h:372
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...
QualType getFunctionTypeWithExceptionSpec(QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI)
Get a function type and produce the equivalent function type with the specified exception specificati...
bool isInstanceMethod() const
Definition: DeclObjC.h:422
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:1380
Represents a GCC generic vector type.
Definition: Type.h:3168
struct CXXOpName CXXOperatorName
static bool CanThrow(Expr *E, ASTContext &Ctx)
Definition: CFG.cpp:2407
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2720
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:1078
CanQualType SatLongAccumTy
Definition: ASTContext.h:1034
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4709
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:6688
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:995
void CollectInheritedProtocols(const Decl *CDecl, llvm::SmallPtrSet< ObjCProtocolDecl *, 8 > &Protocols)
CollectInheritedProtocols - Collect all protocols in current class and those inherited by it...
Selector getSelector() const
Definition: DeclObjC.h:321
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:1396
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:152
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:703
QualType getDependentSizedExtVectorType(QualType VectorType, Expr *SizeExpr, SourceLocation AttrLoc) const
void removeCVRQualifiers(unsigned mask)
Definition: Type.h:281
bool useAddressSpaceMapMangling() const
Specify if mangling based on address space map should be used or not for language specific address sp...
Definition: TargetInfo.h:729
QualType getType() const
Definition: DeclObjC.h:829
const SourceManager & SM
Definition: Format.cpp:1490
void setOriginalDecl(const Decl *Orig)
Definition: ASTContext.h:774
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:295
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:236
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4336
CanQualType SignedCharTy
Definition: ASTContext.h:1025
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:216
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:124
bool isSignedFixedPointType() const
Return true if this is a fixed point type that is signed according to ISO/IEC JTC1 SC22 WG14 N1169...
Definition: Type.h:6611
QualType getObjCGCQualType(QualType T, Qualifiers::GC gcAttr) const
Return the uniqued reference to the type for an Objective-C gc-qualified type.
QualType getAttributedType(attr::Kind attrKind, QualType modifiedType, QualType equivalentType)
ExtInfo withNoReturn(bool noReturn) const
Definition: Type.h:3537
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:469
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6131
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:4061
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:6080
noexcept(expression), evals to &#39;false&#39;
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:191
QualType getWideCharType() const
Return the type of wide characters.
Definition: ASTContext.h:1565
A template template parameter pack that has been substituted for a template template argument pack...
Definition: TemplateName.h:212
bool isComputedNoexcept(ExceptionSpecificationType ESpecType)
CanQualType OverloadTy
Definition: ASTContext.h:1045
There is no lifetime qualification on this type.
Definition: Type.h:158
Compare comments&#39; source locations.
static unsigned NumImplicitDestructorsDeclared
The number of implicitly-declared destructors for which declarations were built.
Definition: ASTContext.h:2827
OverloadedTemplateStorage * getAsOverloadedTemplate() const
Retrieve the underlying, overloaded function template.
void PrintStats() const
Definition: ASTContext.cpp:925
std::string getAsString() const
Derive the full selector name (e.g.
is AltiVec &#39;vector Pixel&#39;
Definition: Type.h:3178
CanQualType BuiltinFnTy
Definition: ASTContext.h:1046
This declaration does not have an attached comment, and we have searched the redeclaration chain...
Definition: ASTContext.h:751
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:567
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:169
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:6111
bool isBuiltinType() const
Helper methods to distinguish type categories.
Definition: Type.h:6365
not a target-specific vector type
Definition: Type.h:3172
llvm::PointerUnion< VarTemplateDecl *, MemberSpecializationInfo * > TemplateOrSpecializationInfo
A type synonym for the TemplateOrInstantiation mapping.
Definition: ASTContext.h:422
ExceptionSpecificationType Type
The kind of exception specification this is.
Definition: Type.h:3743
QualType getElaboratedType(ElaboratedTypeKeyword Keyword, NestedNameSpecifier *NNS, QualType NamedType, TagDecl *OwnedTagDecl=nullptr) const
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:204
ExtParameterInfo getExtParameterInfo(unsigned I) const
Definition: Type.h:4078
bool isSpecialized() const
Determine whether this object type is "specialized", meaning that it has type arguments.
Definition: Type.cpp:646
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3899
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
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:295
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:3774
unsigned getMaxAtomicInlineWidth() const
Return the maximum width lock-free atomic operation which can be inlined given the supported features...
Definition: TargetInfo.h:608
void AddDeallocation(void(*Callback)(void *), void *Data)
Add a deallocation callback that will be invoked when the ASTContext is destroyed.
Definition: ASTContext.cpp:916
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:3438
Encodes a location in the source.
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5751
TypedefDecl * getUInt128Decl() const
Retrieve the declaration for the 128-bit unsigned integer type.
Sugar for parentheses used when specifying types.
Definition: Type.h:2507
QualType getReturnType() const
Definition: Type.h:3613
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:4396
bool hasSameTemplateName(TemplateName X, TemplateName Y)
Determine whether the given template names refer to the same template.
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6188
QualType getUIntPtrType() const
Return a type compatible with "uintptr_t" (C99 7.18.1.4), as defined by the target.
CanQualType UnsignedLongAccumTy
Definition: ASTContext.h:1031
unsigned getOpenMPDefaultSimdAlign(QualType T) const
Get default simd alignment of the specified complete type in bits.
CanQualType Int128Ty
Definition: ASTContext.h:1025
Represents typeof(type), a GCC extension.
Definition: Type.h:4219
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5738
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2095
This names the __make_integer_seq BuiltinTemplateDecl.
Definition: Builtins.h:245
unsigned getManglingNumber(const NamedDecl *ND) const
A structure for storing an already-substituted template template parameter pack.
Definition: TemplateName.h:122
A simple holder for various uncommon bits which do not fit in FunctionTypeBitfields.
Definition: Type.h:3589
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
Definition: Decl.h:292
static unsigned NumImplicitCopyAssignmentOperatorsDeclared
The number of implicitly-declared copy assignment operators for which declarations were built...
Definition: ASTContext.h:2813
Kind getKind() const LLVM_READONLY
Definition: ASTContext.h:754
CanQualType SatFractTy
Definition: ASTContext.h:1037
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3064
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.
virtual LangAS getOpenCLBuiltinAddressSpace(unsigned AS) const
Map from the address space field in builtin description strings to the language address space...
Definition: TargetInfo.h:1191
CallingConv getCC() const
Definition: Type.h:3525
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2904
QualType getElementType() const
Definition: Type.h:3203
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C &#39;SEL&#39; type.
Definition: ASTContext.h:1859
Represents a vector type where either the type or size is dependent.
Definition: Type.h:3245
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:403
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:44
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2041
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2413
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3928
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:4631
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
CanQualType FloatTy
Definition: ASTContext.h:1028
unsigned getLineNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const
Given a SourceLocation, return the spelling line number for the position indicated.
This file defines OpenMP nodes for declarative directives.
overridden_cxx_method_iterator overridden_methods_begin(const CXXMethodDecl *Method) const
CanQualType SatUnsignedLongAccumTy
Definition: ASTContext.h:1035
DeclarationName getIdentifier(const IdentifierInfo *ID)
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:2280
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:243
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:5433
CanQualType VoidTy
Definition: ASTContext.h:1016
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3520
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:149
CanQualType Float16Ty
Definition: ASTContext.h:1041
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:6393
bool isAnyPointerType() const
Definition: Type.h:6300
CanQualType SatLongFractTy
Definition: ASTContext.h:1037
This declaration is only a declaration.
Definition: Decl.h:1147
is AltiVec &#39;vector bool ...&#39;
Definition: Type.h:3181
SplitQualType getSplitUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6159
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:729
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:695
__builtin_va_list as defined by the Power ABI: https://www.power.org /resources/downloads/Power-Arch-...
Definition: TargetInfo.h:200
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:1152
We have found a comment attached to this particular declaration.
Definition: ASTContext.h:741
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:1810
Qualifiers getIndexTypeQualifiers() const
Definition: Type.h:2853
TypeClass getTypeClass() const
Definition: Type.h:1811
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:164
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:149
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:197
QualType getSuperClassType() const
Retrieve the type of the superclass of this object type.
Definition: Type.h:5666
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclObjC.h:247
bool isTargetAddressSpace(LangAS AS)
Definition: AddressSpaces.h:58
EnumDecl * getDecl() const
Definition: Type.h:4403
bool isVectorType() const
Definition: Type.h:6381
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:175
QualType AutoDeductTy
Definition: ASTContext.h:1061
CanQualType SatUnsignedFractTy
Definition: ASTContext.h:1038
unsigned getPreferredTypeAlign(const Type *T) const
Return the "preferred" alignment of the specified type T for the current target, in bits...
FixedPointSemantics getFixedPointSemantics(QualType Ty) const
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1549
llvm::DenseMap< const Decl *, RawCommentAndCacheFlags > RedeclComments
Mapping from declarations to comments attached to any redeclaration.
Definition: ASTContext.h:788
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:490
bool isCanonical() const
Definition: Type.h:6116
CanQualType SatUnsignedShortFractTy
Definition: ASTContext.h:1038
bool hasFlexibleArrayMember() const
Definition: Decl.h:3647
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2293
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:209
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:5955
Defines the fixed point number interface.
CharUnits getUnadjustedAlignment() const
getUnadjustedAlignment - Get the record alignment in characters, before alignment adjustement...
Definition: RecordLayout.h:181
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:4149
Represents a pointer type decayed from an array or function type.
Definition: Type.h:2622
void setTraversalScope(const std::vector< Decl *> &)
Definition: ASTContext.cpp:911
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
CanQualType SatAccumTy
Definition: ASTContext.h:1034
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4978
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:5355
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:1560
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:669
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1607
ArrayRef< Decl * > getModuleInitializers(Module *M)
Get the initializations to perform when importing a module, if any.
CanQualType UnsignedShortTy
Definition: ASTContext.h:1026
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1978
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:2916
ast_type_traits::DynTypedNode Node
CanQualType CharTy
Definition: ASTContext.h:1018
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:2585
IntType
===-— Target Data Type Query Methods ----------------------------—===//
Definition: TargetInfo.h:158
QualType withRestrict() const
Definition: Type.h:826
Represents a template name that was expressed as a qualified name.
Definition: TemplateName.h:367
TagTypeKind
The kind of a tag type.
Definition: Type.h:5031
RealType getRealTypeByWidth(unsigned BitWidth) const
Return floating point type with specified width.
Definition: TargetInfo.cpp:260
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:2440
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:941
CanQualType ObjCBuiltinIdTy
Definition: ASTContext.h:1048
void getLegacyIntegralTypeEncoding(QualType &t) const
getLegacyIntegralTypeEncoding - Another legacy compatibility encoding: 32-bit longs are encoded as &#39;l...
GC getObjCGCAttr() const
Definition: Type.h:305
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:184
A RecursiveASTVisitor that builds a map from nodes to their parents as defined by the RecursiveASTVis...
ExtInfo getExtInfo() const
Definition: Type.h:3624
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:6039
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:1262
CanQualType NullPtrTy
Definition: ASTContext.h:1044
void forEachMultiversionedFunctionVersion(const FunctionDecl *FD, llvm::function_ref< void(FunctionDecl *)> Pred) const
Visits all versions of a multiversioned function with the passed predicate.
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:1042
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:184
static FloatingRank getFloatingRank(QualType T)
getFloatingRank - Return a relative rank for floating point types.
APFixedPoint getFixedPointMin(QualType Ty) const
CanQualType UnsignedShortAccumTy
Definition: ASTContext.h:1031
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:3558
unsigned[(unsigned) LangAS::FirstTargetAddressSpace] LangASMap
The type of a lookup table which maps from language-specific address spaces to target-specific ones...
Definition: AddressSpaces.h:54
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:2971
Interesting information about a specific parameter that can&#39;t simply be reflected in parameter&#39;s type...
Definition: Type.h:3381
CanQualType UnsignedLongLongTy
Definition: ASTContext.h:1027
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition: DeclObjC.h:1549
bool hasCvrSimilarType(QualType T1, QualType T2)
Determine if two types are similar, ignoring only CVR qualifiers.
NamespaceDecl * getOriginalNamespace()
Get the original (first) namespace declaration.
Definition: DeclCXX.cpp:2597
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
Definition: Type.h:740
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:160
QualType getProcessIDType() const
Return the unique type for "pid_t" defined in <sys/types.h>.
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:3399
The name of a declaration.
VectorKind getVectorKind() const
Definition: Type.h:3213
Represents the declaration of an Objective-C type parameter.
Definition: DeclObjC.h:559
bool isBooleanType() const
Definition: Type.h:6657
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:6046
const CXXRecordDecl * getBaseSharingVBPtr() const
Definition: RecordLayout.h:311
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3772
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like &#39;int()&#39;.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:3154
MangleNumberingContext & getManglingNumberContext(const DeclContext *DC)
Retrieve the context for computing mangling numbers in the given DeclContext.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.cpp:3414
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5835
bool isKindOfType() const
Whether this ia a "__kindof" type (semantically).
Definition: Type.cpp:682
Represents an enum.
Definition: Decl.h:3326
FunctionType::ExtInfo getFunctionExtInfo(const Type &t)
Definition: Type.h:6197
Information about the declaration, useful to clients of FullComment.
Definition: Comment.h:981
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:2702
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2756
bool isIntegerConstantExpr(llvm::APSInt &Result, const ASTContext &Ctx, SourceLocation *Loc=nullptr, bool isEvaluated=true) const
isIntegerConstantExpr - Return true if this expression is a valid integer constant expression...
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:248
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:146
bool hasObjCLifetime() const
Definition: Type.h:325
QualType AutoRRefDeductTy
Definition: ASTContext.h:1062
virtual ~CXXABI()
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:583
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:1083
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:1085
bool areComparableObjCPointerTypes(QualType LHS, QualType RHS)
QualType getUnsignedWCharType() const
Return the type of "unsigned wchar_t".
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4578
static unsigned NumImplicitCopyAssignmentOperators
The number of implicitly-declared copy assignment operators.
Definition: ASTContext.h:2809
void addConsistentQualifiers(Qualifiers qs)
Add the qualifiers from the given set to this set, given that they don&#39;t conflict.
Definition: Type.h:452
bool isObjCUnqualifiedIdOrClass() const
Definition: Type.h:5613
GVALinkage GetGVALinkageForVariable(const VarDecl *VD)
A dynamically typed AST node container.
const Decl * getOriginalDecl() const LLVM_READONLY
Definition: ASTContext.h:770
virtual IntType getIntTypeByWidth(unsigned BitWidth, bool IsSigned) const
Return integer type with specified width.
Definition: TargetInfo.cpp:230
Represents a pointer to an Objective C object.
Definition: Type.h:5794
Copy initialization expr of a __block variable and a boolean flag that indicates whether the expressi...
Definition: ASTContext.h:159
Pointer to a block type.
Definition: Type.h:2639
CanQualType ObjCBuiltinBoolTy
Definition: ASTContext.h:1049
unsigned getIntWidth(QualType T) const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2552
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:6353
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4370
StringRef getObjCRuntimeNameAsString() const
Produce a name to be used for class&#39;s metadata.
Definition: DeclObjC.cpp:1533
Complex values, per C99 6.2.5p11.
Definition: Type.h:2477
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:450
BuiltinTemplateDecl * getTypePackElementDecl() const
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:5620
CanQualType UnknownAnyTy
Definition: ASTContext.h:1045
bool empty() const
Definition: Type.h:414
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:2021
bool doUnsignedFixedPointTypesHavePadding() const
In the event this target uses the same number of fractional bits for its unsigned types as it does wi...
Definition: TargetInfo.h:320
comments::FullComment * getLocalCommentForDeclUncached(const Decl *D) const
Return parsed documentation comment attached to a given declaration.
Definition: ASTContext.cpp:485
QualType getCanonicalTypeInternal() const
Definition: Type.h:2355
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6578
This template specialization was declared or defined by an explicit specialization (C++ [temp...
Definition: Specifiers.h:156
CanQualType UnsignedLongTy
Definition: ASTContext.h:1026
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:2944
const llvm::APInt & getSize() const
Definition: Type.h:2890
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2074
CanQualType DependentTy
Definition: ASTContext.h:1045
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:1019
bool isFunctionType() const
Definition: Type.h:6292
bool hasNonFastQualifiers() const
Return true if the set contains any qualifiers which require an ExtQuals node to be allocated...
Definition: Type.h:405
bool isAddressSpaceSupersetOf(Qualifiers other) const
Returns true if this address space is a superset of the other one.
Definition: Type.h:469
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1060
bool isObjCQualifiedIdType() const
Definition: Type.h:6410
static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET)
static GVALinkage basicGVALinkageForVariable(const ASTContext &Context, const VarDecl *VD)
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:716
bool isMSExternInline() const
The combination of the extern and inline keywords under MSVC forces the function to be required...
Definition: Decl.cpp:3092
ExtVectorType - Extended vector type.
Definition: Type.h:3287
CanQualType ObjCBuiltinClassTy
Definition: ASTContext.h:1048
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
param_const_iterator param_begin() const
Definition: DeclObjC.h:348
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2673
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1730
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2269
CanQualType BoundMemberTy
Definition: ASTContext.h:1045
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:1915
llvm::DenseMap< const Decl *, comments::FullComment * > ParsedComments
Mapping from declarations to parsed comments attached to any redeclaration.
Definition: ASTContext.h:792
The template argument is a type.
Definition: TemplateBase.h:60
qual_range quals() const
Definition: Type.h:5917
Holds information about the various types of exception specification.
Definition: Type.h:3741
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1507
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)
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3696
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:182
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2070
ArrayRef< QualType > Exceptions
Explicitly-specified list of exception types.
Definition: Type.h:3746
bool isObjCObjectType() const
Definition: Type.h:6397
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:2031
bool hasObjCGCAttr() const
Definition: Type.h:304
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2356
CanQualType Char8Ty
Definition: ASTContext.h:1022
DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node)
Definition: ASTContext.cpp:904
ASTMutationListener * getASTMutationListener() const
Retrieve a pointer to the AST mutation listener associated with this AST context, if any...
Definition: ASTContext.h:1098
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2253
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:238
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:986
bool isNoThrow(unsigned ID) const
Return true if we know this builtin never throws an exception.
Definition: Builtins.h:112
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13954
pack_iterator pack_end() const
Iterator referencing one past the last argument of a template argument pack.
Definition: TemplateBase.h:347
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:172
ExternCContextDecl * getExternCContextDecl() const
bool hasSimilarType(QualType T1, QualType T2)
Determine if two types are similar, according to the C++ rules.
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:4425
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:3890
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:5464
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:1009
Defines the clang::SourceLocation class and associated facilities.
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4805
Interoperability with the Swift 4.2 runtime.
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6152
bool hasUnaligned() const
Definition: Type.h:297
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.
void addModuleInitializer(Module *M, Decl *Init)
Add a declaration to the list of declarations that are initialized for a module.
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:1874
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
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:2427
IdentifierInfo * getTypePackElementName() const
Definition: ASTContext.h:1722
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5264
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
unsigned getBuiltinID() const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:2994
ObjCDeclQualifier
ObjCDeclQualifier - &#39;Qualifiers&#39; written next to the return and parameter types in method declaration...
Definition: DeclBase.h:196
Represents a C array with an unspecified size.
Definition: Type.h:2926
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:2007
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:2189
static TranslationUnitDecl * Create(ASTContext &C)
Definition: Decl.cpp:4308
static void SortAndUniqueProtocols(SmallVectorImpl< ObjCProtocolDecl *> &Protocols)
IdentifierInfo * getMakeIntegerSeqName() const
Definition: ASTContext.h:1716
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:6099
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1945
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:4521
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:608
CanQualType Char16Ty
Definition: ASTContext.h:1023
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:96
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:736
static unsigned NumImplicitCopyConstructorsDeclared
The number of implicitly-declared copy constructors for which declarations were built.
Definition: ASTContext.h:2799
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:568
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:203
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4210
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:637
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:2391
bool isVariadic() const
Definition: DeclObjC.h:427
virtual LangAS getCUDABuiltinAddressSpace(unsigned AS) const
Map from the address space field in builtin description strings to the language address space...
Definition: TargetInfo.h:1197
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:361
QualType getInjectedClassNameType(CXXRecordDecl *Decl, QualType TST) const
getInjectedClassNameType - Return the unique reference to the injected class name type for the specif...
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:627
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
unsigned CountNonClassIvars(const ObjCInterfaceDecl *OI) const
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition: Decl.h:3480
void setRAngleLoc(SourceLocation Loc)
Definition: TypeLoc.h:1576
unsigned getCVRQualifiers() const
Definition: Type.h:274
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:571
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:2416
uint64_t Width
Definition: ASTContext.h:144
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:1754
__DEVICE__ int max(int __a, int __b)
NameKind getKind() const
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:954
CanQualType IntTy
Definition: ASTContext.h:1025
QualType getSignedWCharType() const
Return the type of "signed wchar_t".
unsigned getNumElements() const
Definition: Type.h:3204
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:226
static bool NeedsInjectedClassNameType(const RecordDecl *D)
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:2079
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:1041
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:3086
bool isUnion() const
Definition: Decl.h:3252
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4841
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:3944
ObjCTypeParamVariance getVariance() const
Determine the variance of this type parameter.
Definition: DeclObjC.h:602
GVALinkage
A more specific kind of linkage than enum Linkage.
Definition: Linkage.h:74
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:6296
QualType mergeFunctionParameterTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified=false)
mergeFunctionParameterTypes - merge two types which appear as function parameter types ...
__DEVICE__ int min(int __a, int __b)
const DeclInfo * getDeclInfo() const LLVM_READONLY
Definition: Comment.h:1124
void addAddressSpace(LangAS space)
Definition: Type.h:378
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
StringRef Text
Definition: Format.cpp:1630
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:1135
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:1295
QualType getType() const
Definition: Decl.h:648
TemplateArgument getArgumentPack() const
Retrieve the template template argument pack with which this parameter was substituted.
A set of overloaded template declarations.
Definition: TemplateName.h:195
A trivial tuple used to represent a source range.
This represents a decl that may have a name.
Definition: Decl.h:249
ArrayRef< BlockContentComment * > getBlocks() const
Definition: Comment.h:1130
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
A simple holder for a QualType representing a type in an exception specification. ...
Definition: Type.h:3583
T castAs() const
Convert to the specified TypeLoc type, asserting that this TypeLoc is of the desired type...
Definition: TypeLoc.h:76
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:457
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2971
CanQualType BoolTy
Definition: ASTContext.h:1017
void setTemplateNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:1600
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:5071
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:111
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1364
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:5988
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:2499
CanQualType DoubleTy
Definition: ASTContext.h:1028
Selector getGetterName() const
Definition: DeclObjC.h:906
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context)
Definition: Type.h:5317
static bool isObjCNSObjectType(QualType Ty)
Return true if this is an NSObject object with its NSObject attribute set.
Definition: ASTContext.h:2050
SourceLocation getRAngleLoc() const
Definition: TemplateBase.h:572
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:3762
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:363
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:2010
void setType(QualType newType)
Definition: Decl.h:649
void removeAddressSpace()
Definition: Type.h:377
bool hasInit() const
Definition: Decl.cpp:2164
QualType getReadPipeType(QualType T) const
Return a read_only pipe type for the specified type.
const LangOptions & getLangOpts() const
Definition: ASTContext.h:707
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2499
No in-class initializer.
Definition: Specifiers.h:230
bool AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2872
This class handles loading and caching of source files into memory.
The parameter is invariant: must match exactly.
ExceptionSpecInfo ExceptionSpec
Definition: Type.h:3773
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:969
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:3466
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:418
QualType getPointeeType() const
Definition: Type.h:2776
const RawComment * getRawCommentForAnyRedecl(const Decl *D, const Decl **OriginalDecl=nullptr) const
Return the documentation comment attached to a given declaration.
Definition: ASTContext.cpp:382
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3139
bool isExternallyVisible() const
Definition: Decl.h:380
A full comment attached to a declaration, contains block content.
Definition: Comment.h:1092
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:192
void Profile(llvm::FoldingSetNodeID &ID)
Definition: Type.h:4768
CanQualType OCLClkEventTy
Definition: ASTContext.h:1053
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.
noexcept(expression), evals to &#39;true&#39;
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:125
CanQualType UnsignedIntTy
Definition: ASTContext.h:1026
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:1058
static unsigned NumImplicitDestructors
The number of implicitly-declared destructors.
Definition: ASTContext.h:2823
BuiltinTemplateDecl * getMakeIntegerSeqDecl() const
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5810
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>, including the values return by builtin <=> operators.
Definition: ASTContext.h:2026