Bug Summary

File:tools/clang/lib/AST/ASTContext.cpp
Warning:line 9834, column 7
Potential memory leak

Annotated Source Code

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