Bug Summary

File:tools/clang/lib/AST/ASTContext.cpp
Warning:line 10150, column 15
Potential leak of memory pointed to by 'Vector'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ASTContext.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/lib/gcc/x86_64-linux-gnu/8/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/lib/AST -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp -faddrsig
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/ExceptionSpecificationType.h"
51#include "clang/Basic/IdentifierTable.h"
52#include "clang/Basic/LLVM.h"
53#include "clang/Basic/LangOptions.h"
54#include "clang/Basic/Linkage.h"
55#include "clang/Basic/ObjCRuntime.h"
56#include "clang/Basic/SanitizerBlacklist.h"
57#include "clang/Basic/SourceLocation.h"
58#include "clang/Basic/SourceManager.h"
59#include "clang/Basic/Specifiers.h"
60#include "clang/Basic/TargetCXXABI.h"
61#include "clang/Basic/TargetInfo.h"
62#include "clang/Basic/XRayLists.h"
63#include "llvm/ADT/APInt.h"
64#include "llvm/ADT/APSInt.h"
65#include "llvm/ADT/ArrayRef.h"
66#include "llvm/ADT/DenseMap.h"
67#include "llvm/ADT/DenseSet.h"
68#include "llvm/ADT/FoldingSet.h"
69#include "llvm/ADT/None.h"
70#include "llvm/ADT/Optional.h"
71#include "llvm/ADT/PointerUnion.h"
72#include "llvm/ADT/STLExtras.h"
73#include "llvm/ADT/SmallPtrSet.h"
74#include "llvm/ADT/SmallVector.h"
75#include "llvm/ADT/StringExtras.h"
76#include "llvm/ADT/StringRef.h"
77#include "llvm/ADT/Triple.h"
78#include "llvm/Support/Capacity.h"
79#include "llvm/Support/Casting.h"
80#include "llvm/Support/Compiler.h"
81#include "llvm/Support/ErrorHandling.h"
82#include "llvm/Support/MathExtras.h"
83#include "llvm/Support/raw_ostream.h"
84#include <algorithm>
85#include <cassert>
86#include <cstddef>
87#include <cstdint>
88#include <cstdlib>
89#include <map>
90#include <memory>
91#include <string>
92#include <tuple>
93#include <utility>
94
95using namespace clang;
96
97unsigned ASTContext::NumImplicitDefaultConstructors;
98unsigned ASTContext::NumImplicitDefaultConstructorsDeclared;
99unsigned ASTContext::NumImplicitCopyConstructors;
100unsigned ASTContext::NumImplicitCopyConstructorsDeclared;
101unsigned ASTContext::NumImplicitMoveConstructors;
102unsigned ASTContext::NumImplicitMoveConstructorsDeclared;
103unsigned ASTContext::NumImplicitCopyAssignmentOperators;
104unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
105unsigned ASTContext::NumImplicitMoveAssignmentOperators;
106unsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
107unsigned ASTContext::NumImplicitDestructors;
108unsigned ASTContext::NumImplicitDestructorsDeclared;
109
110enum FloatingRank {
111 Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank
112};
113
114RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
115 if (!CommentsLoaded && ExternalSource) {
116 ExternalSource->ReadComments();
117
118#ifndef NDEBUG
119 ArrayRef<RawComment *> RawComments = Comments.getComments();
120 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 121, __extension__ __PRETTY_FUNCTION__))
121 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 121, __extension__ __PRETTY_FUNCTION__))
;
122#endif
123
124 CommentsLoaded = true;
125 }
126
127 assert(D)(static_cast <bool> (D) ? void (0) : __assert_fail ("D"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 127, __extension__ __PRETTY_FUNCTION__))
;
128
129 // User can not attach documentation to implicit declarations.
130 if (D->isImplicit())
131 return nullptr;
132
133 // User can not attach documentation to implicit instantiations.
134 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
135 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
136 return nullptr;
137 }
138
139 if (const auto *VD = dyn_cast<VarDecl>(D)) {
140 if (VD->isStaticDataMember() &&
141 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
142 return nullptr;
143 }
144
145 if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
146 if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
147 return nullptr;
148 }
149
150 if (const auto *CTSD = 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 auto *ED = dyn_cast<EnumDecl>(D)) {
158 if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
159 return nullptr;
160 }
161 if (const auto *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 auto *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), LangOpts.CommentOpts, false);
230 BeforeThanCompare<RawComment> Compare(SourceMgr);
231 ArrayRef<RawComment *>::iterator MaybeBeforeDecl = RawComments.end() - 1;
232 bool Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
233 if (!Found && RawComments.size() >= 2) {
234 MaybeBeforeDecl--;
235 Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
236 }
237
238 if (Found) {
239 Comment = MaybeBeforeDecl + 1;
240 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 241, __extension__ __PRETTY_FUNCTION__))
241 &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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 241, __extension__ __PRETTY_FUNCTION__))
;
242 } else {
243 // Slow path.
244 Comment = std::lower_bound(RawComments.begin(), RawComments.end(),
245 &CommentAtDeclLoc, Compare);
246 }
247 }
248
249 // Decompose the location for the declaration and find the beginning of the
250 // file buffer.
251 std::pair<FileID, unsigned> DeclLocDecomp = SourceMgr.getDecomposedLoc(DeclLoc);
252
253 // First check whether we have a trailing comment.
254 if (Comment != RawComments.end() &&
255 ((*Comment)->isDocumentation() || LangOpts.CommentOpts.ParseAllComments)
256 && (*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() ||
279 LangOpts.CommentOpts.ParseAllComments) ||
280 (*Comment)->isTrailingComment())
281 return nullptr;
282
283 // Decompose the end of the comment.
284 std::pair<FileID, unsigned> CommentEndDecomp
285 = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getEnd());
286
287 // If the comment and the declaration aren't in the same file, then they
288 // aren't related.
289 if (DeclLocDecomp.first != CommentEndDecomp.first)
290 return nullptr;
291
292 // Get the corresponding buffer.
293 bool Invalid = false;
294 const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,
295 &Invalid).data();
296 if (Invalid)
297 return nullptr;
298
299 // Extract text between the comment and declaration.
300 StringRef Text(Buffer + CommentEndDecomp.second,
301 DeclLocDecomp.second - CommentEndDecomp.second);
302
303 // There should be no other declarations or preprocessor directives between
304 // comment and declaration.
305 if (Text.find_first_of(";{}#@") != StringRef::npos)
306 return nullptr;
307
308 return *Comment;
309}
310
311/// If we have a 'templated' declaration for a template, adjust 'D' to
312/// refer to the actual template.
313/// If we have an implicit instantiation, adjust 'D' to refer to template.
314static const Decl *adjustDeclToTemplate(const Decl *D) {
315 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
316 // Is this function declaration part of a function template?
317 if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
318 return FTD;
319
320 // Nothing to do if function is not an implicit instantiation.
321 if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
322 return D;
323
324 // Function is an implicit instantiation of a function template?
325 if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())
326 return FTD;
327
328 // Function is instantiated from a member definition of a class template?
329 if (const FunctionDecl *MemberDecl =
330 FD->getInstantiatedFromMemberFunction())
331 return MemberDecl;
332
333 return D;
334 }
335 if (const auto *VD = dyn_cast<VarDecl>(D)) {
336 // Static data member is instantiated from a member definition of a class
337 // template?
338 if (VD->isStaticDataMember())
339 if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember())
340 return MemberDecl;
341
342 return D;
343 }
344 if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
345 // Is this class declaration part of a class template?
346 if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate())
347 return CTD;
348
349 // Class is an implicit instantiation of a class template or partial
350 // specialization?
351 if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
352 if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation)
353 return D;
354 llvm::PointerUnion<ClassTemplateDecl *,
355 ClassTemplatePartialSpecializationDecl *>
356 PU = CTSD->getSpecializedTemplateOrPartial();
357 return PU.is<ClassTemplateDecl*>() ?
358 static_cast<const Decl*>(PU.get<ClassTemplateDecl *>()) :
359 static_cast<const Decl*>(
360 PU.get<ClassTemplatePartialSpecializationDecl *>());
361 }
362
363 // Class is instantiated from a member definition of a class template?
364 if (const MemberSpecializationInfo *Info =
365 CRD->getMemberSpecializationInfo())
366 return Info->getInstantiatedFrom();
367
368 return D;
369 }
370 if (const auto *ED = dyn_cast<EnumDecl>(D)) {
371 // Enum is instantiated from a member definition of a class template?
372 if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum())
373 return MemberDecl;
374
375 return D;
376 }
377 // FIXME: Adjust alias templates?
378 return D;
379}
380
381const RawComment *ASTContext::getRawCommentForAnyRedecl(
382 const Decl *D,
383 const Decl **OriginalDecl) const {
384 D = adjustDeclToTemplate(D);
385
386 // Check whether we have cached a comment for this declaration already.
387 {
388 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
389 RedeclComments.find(D);
390 if (Pos != RedeclComments.end()) {
391 const RawCommentAndCacheFlags &Raw = Pos->second;
392 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) {
393 if (OriginalDecl)
394 *OriginalDecl = Raw.getOriginalDecl();
395 return Raw.getRaw();
396 }
397 }
398 }
399
400 // Search for comments attached to declarations in the redeclaration chain.
401 const RawComment *RC = nullptr;
402 const Decl *OriginalDeclForRC = nullptr;
403 for (auto I : D->redecls()) {
404 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
405 RedeclComments.find(I);
406 if (Pos != RedeclComments.end()) {
407 const RawCommentAndCacheFlags &Raw = Pos->second;
408 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) {
409 RC = Raw.getRaw();
410 OriginalDeclForRC = Raw.getOriginalDecl();
411 break;
412 }
413 } else {
414 RC = getRawCommentForDeclNoCache(I);
415 OriginalDeclForRC = I;
416 RawCommentAndCacheFlags Raw;
417 if (RC) {
418 // Call order swapped to work around ICE in VS2015 RTM (Release Win32)
419 // https://connect.microsoft.com/VisualStudio/feedback/details/1741530
420 Raw.setKind(RawCommentAndCacheFlags::FromDecl);
421 Raw.setRaw(RC);
422 } else
423 Raw.setKind(RawCommentAndCacheFlags::NoCommentInDecl);
424 Raw.setOriginalDecl(I);
425 RedeclComments[I] = Raw;
426 if (RC)
427 break;
428 }
429 }
430
431 // If we found a comment, it should be a documentation comment.
432 assert(!RC || RC->isDocumentation() || LangOpts.CommentOpts.ParseAllComments)(static_cast <bool> (!RC || RC->isDocumentation() ||
LangOpts.CommentOpts.ParseAllComments) ? void (0) : __assert_fail
("!RC || RC->isDocumentation() || LangOpts.CommentOpts.ParseAllComments"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 432, __extension__ __PRETTY_FUNCTION__))
;
433
434 if (OriginalDecl)
435 *OriginalDecl = OriginalDeclForRC;
436
437 // Update cache for every declaration in the redeclaration chain.
438 RawCommentAndCacheFlags Raw;
439 Raw.setRaw(RC);
440 Raw.setKind(RawCommentAndCacheFlags::FromRedecl);
441 Raw.setOriginalDecl(OriginalDeclForRC);
442
443 for (auto I : D->redecls()) {
444 RawCommentAndCacheFlags &R = RedeclComments[I];
445 if (R.getKind() == RawCommentAndCacheFlags::NoCommentInDecl)
446 R = Raw;
447 }
448
449 return RC;
450}
451
452static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod,
453 SmallVectorImpl<const NamedDecl *> &Redeclared) {
454 const DeclContext *DC = ObjCMethod->getDeclContext();
455 if (const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {
456 const ObjCInterfaceDecl *ID = IMD->getClassInterface();
457 if (!ID)
458 return;
459 // Add redeclared method here.
460 for (const auto *Ext : ID->known_extensions()) {
461 if (ObjCMethodDecl *RedeclaredMethod =
462 Ext->getMethod(ObjCMethod->getSelector(),
463 ObjCMethod->isInstanceMethod()))
464 Redeclared.push_back(RedeclaredMethod);
465 }
466 }
467}
468
469comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC,
470 const Decl *D) const {
471 auto *ThisDeclInfo = new (*this) comments::DeclInfo;
472 ThisDeclInfo->CommentDecl = D;
473 ThisDeclInfo->IsFilled = false;
474 ThisDeclInfo->fill();
475 ThisDeclInfo->CommentDecl = FC->getDecl();
476 if (!ThisDeclInfo->TemplateParameters)
477 ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;
478 comments::FullComment *CFC =
479 new (*this) comments::FullComment(FC->getBlocks(),
480 ThisDeclInfo);
481 return CFC;
482}
483
484comments::FullComment *ASTContext::getLocalCommentForDeclUncached(const Decl *D) const {
485 const RawComment *RC = getRawCommentForDeclNoCache(D);
486 return RC ? RC->parse(*this, nullptr, D) : nullptr;
487}
488
489comments::FullComment *ASTContext::getCommentForDecl(
490 const Decl *D,
491 const Preprocessor *PP) const {
492 if (D->isInvalidDecl())
493 return nullptr;
494 D = adjustDeclToTemplate(D);
495
496 const Decl *Canonical = D->getCanonicalDecl();
497 llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
498 ParsedComments.find(Canonical);
499
500 if (Pos != ParsedComments.end()) {
501 if (Canonical != D) {
502 comments::FullComment *FC = Pos->second;
503 comments::FullComment *CFC = cloneFullComment(FC, D);
504 return CFC;
505 }
506 return Pos->second;
507 }
508
509 const Decl *OriginalDecl;
510
511 const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);
512 if (!RC) {
513 if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
514 SmallVector<const NamedDecl*, 8> Overridden;
515 const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
516 if (OMD && OMD->isPropertyAccessor())
517 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
518 if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))
519 return cloneFullComment(FC, D);
520 if (OMD)
521 addRedeclaredMethods(OMD, Overridden);
522 getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden);
523 for (unsigned i = 0, e = Overridden.size(); i < e; i++)
524 if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP))
525 return cloneFullComment(FC, D);
526 }
527 else if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
528 // Attach any tag type's documentation to its typedef if latter
529 // does not have one of its own.
530 QualType QT = TD->getUnderlyingType();
531 if (const auto *TT = QT->getAs<TagType>())
532 if (const Decl *TD = TT->getDecl())
533 if (comments::FullComment *FC = getCommentForDecl(TD, PP))
534 return cloneFullComment(FC, D);
535 }
536 else if (const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
537 while (IC->getSuperClass()) {
538 IC = IC->getSuperClass();
539 if (comments::FullComment *FC = getCommentForDecl(IC, PP))
540 return cloneFullComment(FC, D);
541 }
542 }
543 else if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {
544 if (const ObjCInterfaceDecl *IC = CD->getClassInterface())
545 if (comments::FullComment *FC = getCommentForDecl(IC, PP))
546 return cloneFullComment(FC, D);
547 }
548 else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
549 if (!(RD = RD->getDefinition()))
550 return nullptr;
551 // Check non-virtual bases.
552 for (const auto &I : RD->bases()) {
553 if (I.isVirtual() || (I.getAccessSpecifier() != AS_public))
554 continue;
555 QualType Ty = I.getType();
556 if (Ty.isNull())
557 continue;
558 if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) {
559 if (!(NonVirtualBase= NonVirtualBase->getDefinition()))
560 continue;
561
562 if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP))
563 return cloneFullComment(FC, D);
564 }
565 }
566 // Check virtual bases.
567 for (const auto &I : RD->vbases()) {
568 if (I.getAccessSpecifier() != AS_public)
569 continue;
570 QualType Ty = I.getType();
571 if (Ty.isNull())
572 continue;
573 if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) {
574 if (!(VirtualBase= VirtualBase->getDefinition()))
575 continue;
576 if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP))
577 return cloneFullComment(FC, D);
578 }
579 }
580 }
581 return nullptr;
582 }
583
584 // If the RawComment was attached to other redeclaration of this Decl, we
585 // should parse the comment in context of that other Decl. This is important
586 // because comments can contain references to parameter names which can be
587 // different across redeclarations.
588 if (D != OriginalDecl)
589 return getCommentForDecl(OriginalDecl, PP);
590
591 comments::FullComment *FC = RC->parse(*this, PP, D);
592 ParsedComments[Canonical] = FC;
593 return FC;
594}
595
596void
597ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
598 TemplateTemplateParmDecl *Parm) {
599 ID.AddInteger(Parm->getDepth());
600 ID.AddInteger(Parm->getPosition());
601 ID.AddBoolean(Parm->isParameterPack());
602
603 TemplateParameterList *Params = Parm->getTemplateParameters();
604 ID.AddInteger(Params->size());
605 for (TemplateParameterList::const_iterator P = Params->begin(),
606 PEnd = Params->end();
607 P != PEnd; ++P) {
608 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
609 ID.AddInteger(0);
610 ID.AddBoolean(TTP->isParameterPack());
611 continue;
612 }
613
614 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
615 ID.AddInteger(1);
616 ID.AddBoolean(NTTP->isParameterPack());
617 ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
618 if (NTTP->isExpandedParameterPack()) {
619 ID.AddBoolean(true);
620 ID.AddInteger(NTTP->getNumExpansionTypes());
621 for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
622 QualType T = NTTP->getExpansionType(I);
623 ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
624 }
625 } else
626 ID.AddBoolean(false);
627 continue;
628 }
629
630 auto *TTP = cast<TemplateTemplateParmDecl>(*P);
631 ID.AddInteger(2);
632 Profile(ID, TTP);
633 }
634}
635
636TemplateTemplateParmDecl *
637ASTContext::getCanonicalTemplateTemplateParmDecl(
638 TemplateTemplateParmDecl *TTP) const {
639 // Check if we already have a canonical template template parameter.
640 llvm::FoldingSetNodeID ID;
641 CanonicalTemplateTemplateParm::Profile(ID, TTP);
642 void *InsertPos = nullptr;
643 CanonicalTemplateTemplateParm *Canonical
644 = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
645 if (Canonical)
646 return Canonical->getParam();
647
648 // Build a canonical template parameter list.
649 TemplateParameterList *Params = TTP->getTemplateParameters();
650 SmallVector<NamedDecl *, 4> CanonParams;
651 CanonParams.reserve(Params->size());
652 for (TemplateParameterList::const_iterator P = Params->begin(),
653 PEnd = Params->end();
654 P != PEnd; ++P) {
655 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P))
656 CanonParams.push_back(
657 TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(),
658 SourceLocation(),
659 SourceLocation(),
660 TTP->getDepth(),
661 TTP->getIndex(), nullptr, false,
662 TTP->isParameterPack()));
663 else if (const auto *NTTP = 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-7~svn338205/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-7~svn338205/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-7~svn338205/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-7~svn338205/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-7~svn338205/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,
792 LangOpts.XRayAttrListFiles, SM)),
793 PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
794 BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
795 CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
796 CompCategories(this_()), LastSDM(nullptr, 0) {
797 TUDecl = TranslationUnitDecl::Create(*this);
798}
799
800ASTContext::~ASTContext() {
801 ReleaseParentMapEntries();
802
803 // Release the DenseMaps associated with DeclContext objects.
804 // FIXME: Is this the ideal solution?
805 ReleaseDeclContextMaps();
806
807 // Call all of the deallocation functions on all of their targets.
808 for (auto &Pair : Deallocations)
809 (Pair.first)(Pair.second);
810
811 // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed
812 // because they can contain DenseMaps.
813 for (llvm::DenseMap<const ObjCContainerDecl*,
814 const ASTRecordLayout*>::iterator
815 I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
816 // Increment in loop to prevent using deallocated memory.
817 if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
818 R->Destroy(*this);
819
820 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
821 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
822 // Increment in loop to prevent using deallocated memory.
823 if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
824 R->Destroy(*this);
825 }
826
827 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
828 AEnd = DeclAttrs.end();
829 A != AEnd; ++A)
830 A->second->~AttrVec();
831
832 for (std::pair<const MaterializeTemporaryExpr *, APValue *> &MTVPair :
833 MaterializedTemporaryValues)
834 MTVPair.second->~APValue();
835
836 for (const auto &Value : ModuleInitializers)
837 Value.second->~PerModuleInitializers();
838}
839
840void ASTContext::ReleaseParentMapEntries() {
841 if (!PointerParents) return;
842 for (const auto &Entry : *PointerParents) {
843 if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
844 delete Entry.second.get<ast_type_traits::DynTypedNode *>();
845 } else if (Entry.second.is<ParentVector *>()) {
846 delete Entry.second.get<ParentVector *>();
847 }
848 }
849 for (const auto &Entry : *OtherParents) {
850 if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
851 delete Entry.second.get<ast_type_traits::DynTypedNode *>();
852 } else if (Entry.second.is<ParentVector *>()) {
853 delete Entry.second.get<ParentVector *>();
854 }
855 }
856}
857
858void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) {
859 Deallocations.push_back({Callback, Data});
860}
861
862void
863ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) {
864 ExternalSource = std::move(Source);
865}
866
867void ASTContext::PrintStats() const {
868 llvm::errs() << "\n*** AST Context Stats:\n";
869 llvm::errs() << " " << Types.size() << " types total.\n";
870
871 unsigned counts[] = {
872#define TYPE(Name, Parent) 0,
873#define ABSTRACT_TYPE(Name, Parent)
874#include "clang/AST/TypeNodes.def"
875 0 // Extra
876 };
877
878 for (unsigned i = 0, e = Types.size(); i != e; ++i) {
879 Type *T = Types[i];
880 counts[(unsigned)T->getTypeClass()]++;
881 }
882
883 unsigned Idx = 0;
884 unsigned TotalBytes = 0;
885#define TYPE(Name, Parent) \
886 if (counts[Idx]) \
887 llvm::errs() << " " << counts[Idx] << " " << #Name \
888 << " types\n"; \
889 TotalBytes += counts[Idx] * sizeof(Name##Type); \
890 ++Idx;
891#define ABSTRACT_TYPE(Name, Parent)
892#include "clang/AST/TypeNodes.def"
893
894 llvm::errs() << "Total bytes = " << TotalBytes << "\n";
895
896 // Implicit special member functions.
897 llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/"
898 << NumImplicitDefaultConstructors
899 << " implicit default constructors created\n";
900 llvm::errs() << NumImplicitCopyConstructorsDeclared << "/"
901 << NumImplicitCopyConstructors
902 << " implicit copy constructors created\n";
903 if (getLangOpts().CPlusPlus)
904 llvm::errs() << NumImplicitMoveConstructorsDeclared << "/"
905 << NumImplicitMoveConstructors
906 << " implicit move constructors created\n";
907 llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/"
908 << NumImplicitCopyAssignmentOperators
909 << " implicit copy assignment operators created\n";
910 if (getLangOpts().CPlusPlus)
911 llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/"
912 << NumImplicitMoveAssignmentOperators
913 << " implicit move assignment operators created\n";
914 llvm::errs() << NumImplicitDestructorsDeclared << "/"
915 << NumImplicitDestructors
916 << " implicit destructors created\n";
917
918 if (ExternalSource) {
919 llvm::errs() << "\n";
920 ExternalSource->PrintStats();
921 }
922
923 BumpAlloc.PrintStats();
924}
925
926void ASTContext::mergeDefinitionIntoModule(NamedDecl *ND, Module *M,
927 bool NotifyListeners) {
928 if (NotifyListeners)
929 if (auto *Listener = getASTMutationListener())
930 Listener->RedefinedHiddenDefinition(ND, M);
931
932 if (getLangOpts().ModulesLocalVisibility)
933 MergedDefModules[ND].push_back(M);
934 else
935 ND->setVisibleDespiteOwningModule();
936}
937
938void ASTContext::deduplicateMergedDefinitonsFor(NamedDecl *ND) {
939 auto It = MergedDefModules.find(ND);
940 if (It == MergedDefModules.end())
941 return;
942
943 auto &Merged = It->second;
944 llvm::DenseSet<Module*> Found;
945 for (Module *&M : Merged)
946 if (!Found.insert(M).second)
947 M = nullptr;
948 Merged.erase(std::remove(Merged.begin(), Merged.end(), nullptr), Merged.end());
949}
950
951void ASTContext::PerModuleInitializers::resolve(ASTContext &Ctx) {
952 if (LazyInitializers.empty())
953 return;
954
955 auto *Source = Ctx.getExternalSource();
956 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 956, __extension__ __PRETTY_FUNCTION__))
;
957
958 auto LazyInits = std::move(LazyInitializers);
959 LazyInitializers.clear();
960
961 for (auto ID : LazyInits)
962 Initializers.push_back(Source->GetExternalDecl(ID));
963
964 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 965, __extension__ __PRETTY_FUNCTION__))
965 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 965, __extension__ __PRETTY_FUNCTION__))
;
966}
967
968void ASTContext::addModuleInitializer(Module *M, Decl *D) {
969 // One special case: if we add a module initializer that imports another
970 // module, and that module's only initializer is an ImportDecl, simplify.
971 if (const auto *ID = dyn_cast<ImportDecl>(D)) {
972 auto It = ModuleInitializers.find(ID->getImportedModule());
973
974 // Maybe the ImportDecl does nothing at all. (Common case.)
975 if (It == ModuleInitializers.end())
976 return;
977
978 // Maybe the ImportDecl only imports another ImportDecl.
979 auto &Imported = *It->second;
980 if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
981 Imported.resolve(*this);
982 auto *OnlyDecl = Imported.Initializers.front();
983 if (isa<ImportDecl>(OnlyDecl))
984 D = OnlyDecl;
985 }
986 }
987
988 auto *&Inits = ModuleInitializers[M];
989 if (!Inits)
990 Inits = new (*this) PerModuleInitializers;
991 Inits->Initializers.push_back(D);
992}
993
994void ASTContext::addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs) {
995 auto *&Inits = ModuleInitializers[M];
996 if (!Inits)
997 Inits = new (*this) PerModuleInitializers;
998 Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
999 IDs.begin(), IDs.end());
1000}
1001
1002ArrayRef<Decl *> ASTContext::getModuleInitializers(Module *M) {
1003 auto It = ModuleInitializers.find(M);
1004 if (It == ModuleInitializers.end())
1005 return None;
1006
1007 auto *Inits = It->second;
1008 Inits->resolve(*this);
1009 return Inits->Initializers;
1010}
1011
1012ExternCContextDecl *ASTContext::getExternCContextDecl() const {
1013 if (!ExternCContext)
1014 ExternCContext = ExternCContextDecl::Create(*this, getTranslationUnitDecl());
1015
1016 return ExternCContext;
1017}
1018
1019BuiltinTemplateDecl *
1020ASTContext::buildBuiltinTemplateDecl(BuiltinTemplateKind BTK,
1021 const IdentifierInfo *II) const {
1022 auto *BuiltinTemplate = BuiltinTemplateDecl::Create(*this, TUDecl, II, BTK);
1023 BuiltinTemplate->setImplicit();
1024 TUDecl->addDecl(BuiltinTemplate);
1025
1026 return BuiltinTemplate;
1027}
1028
1029BuiltinTemplateDecl *
1030ASTContext::getMakeIntegerSeqDecl() const {
1031 if (!MakeIntegerSeqDecl)
1032 MakeIntegerSeqDecl = buildBuiltinTemplateDecl(BTK__make_integer_seq,
1033 getMakeIntegerSeqName());
1034 return MakeIntegerSeqDecl;
1035}
1036
1037BuiltinTemplateDecl *
1038ASTContext::getTypePackElementDecl() const {
1039 if (!TypePackElementDecl)
1040 TypePackElementDecl = buildBuiltinTemplateDecl(BTK__type_pack_element,
1041 getTypePackElementName());
1042 return TypePackElementDecl;
1043}
1044
1045RecordDecl *ASTContext::buildImplicitRecord(StringRef Name,
1046 RecordDecl::TagKind TK) const {
1047 SourceLocation Loc;
1048 RecordDecl *NewDecl;
1049 if (getLangOpts().CPlusPlus)
1050 NewDecl = CXXRecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc,
1051 Loc, &Idents.get(Name));
1052 else
1053 NewDecl = RecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc, Loc,
1054 &Idents.get(Name));
1055 NewDecl->setImplicit();
1056 NewDecl->addAttr(TypeVisibilityAttr::CreateImplicit(
1057 const_cast<ASTContext &>(*this), TypeVisibilityAttr::Default));
1058 return NewDecl;
1059}
1060
1061TypedefDecl *ASTContext::buildImplicitTypedef(QualType T,
1062 StringRef Name) const {
1063 TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
1064 TypedefDecl *NewDecl = TypedefDecl::Create(
1065 const_cast<ASTContext &>(*this), getTranslationUnitDecl(),
1066 SourceLocation(), SourceLocation(), &Idents.get(Name), TInfo);
1067 NewDecl->setImplicit();
1068 return NewDecl;
1069}
1070
1071TypedefDecl *ASTContext::getInt128Decl() const {
1072 if (!Int128Decl)
1073 Int128Decl = buildImplicitTypedef(Int128Ty, "__int128_t");
1074 return Int128Decl;
1075}
1076
1077TypedefDecl *ASTContext::getUInt128Decl() const {
1078 if (!UInt128Decl)
1079 UInt128Decl = buildImplicitTypedef(UnsignedInt128Ty, "__uint128_t");
1080 return UInt128Decl;
1081}
1082
1083void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
1084 auto *Ty = new (*this, TypeAlignment) BuiltinType(K);
1085 R = CanQualType::CreateUnsafe(QualType(Ty, 0));
1086 Types.push_back(Ty);
1087}
1088
1089void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
1090 const TargetInfo *AuxTarget) {
1091 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1092, __extension__ __PRETTY_FUNCTION__))
1092 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1092, __extension__ __PRETTY_FUNCTION__))
;
1093 assert(VoidTy.isNull() && "Context reinitialized?")(static_cast <bool> (VoidTy.isNull() && "Context reinitialized?"
) ? void (0) : __assert_fail ("VoidTy.isNull() && \"Context reinitialized?\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1093, __extension__ __PRETTY_FUNCTION__))
;
1094
1095 this->Target = &Target;
1096 this->AuxTarget = AuxTarget;
1097
1098 ABI.reset(createCXXABI(Target));
1099 AddrSpaceMap = getAddressSpaceMap(Target, LangOpts);
1100 AddrSpaceMapMangling = isAddrSpaceMapManglingEnabled(Target, LangOpts);
1101
1102 // C99 6.2.5p19.
1103 InitBuiltinType(VoidTy, BuiltinType::Void);
1104
1105 // C99 6.2.5p2.
1106 InitBuiltinType(BoolTy, BuiltinType::Bool);
1107 // C99 6.2.5p3.
1108 if (LangOpts.CharIsSigned)
1109 InitBuiltinType(CharTy, BuiltinType::Char_S);
1110 else
1111 InitBuiltinType(CharTy, BuiltinType::Char_U);
1112 // C99 6.2.5p4.
1113 InitBuiltinType(SignedCharTy, BuiltinType::SChar);
1114 InitBuiltinType(ShortTy, BuiltinType::Short);
1115 InitBuiltinType(IntTy, BuiltinType::Int);
1116 InitBuiltinType(LongTy, BuiltinType::Long);
1117 InitBuiltinType(LongLongTy, BuiltinType::LongLong);
1118
1119 // C99 6.2.5p6.
1120 InitBuiltinType(UnsignedCharTy, BuiltinType::UChar);
1121 InitBuiltinType(UnsignedShortTy, BuiltinType::UShort);
1122 InitBuiltinType(UnsignedIntTy, BuiltinType::UInt);
1123 InitBuiltinType(UnsignedLongTy, BuiltinType::ULong);
1124 InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong);
1125
1126 // C99 6.2.5p10.
1127 InitBuiltinType(FloatTy, BuiltinType::Float);
1128 InitBuiltinType(DoubleTy, BuiltinType::Double);
1129 InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble);
1130
1131 // GNU extension, __float128 for IEEE quadruple precision
1132 InitBuiltinType(Float128Ty, BuiltinType::Float128);
1133
1134 // C11 extension ISO/IEC TS 18661-3
1135 InitBuiltinType(Float16Ty, BuiltinType::Float16);
1136
1137 // ISO/IEC JTC1 SC22 WG14 N1169 Extension
1138 InitBuiltinType(ShortAccumTy, BuiltinType::ShortAccum);
1139 InitBuiltinType(AccumTy, BuiltinType::Accum);
1140 InitBuiltinType(LongAccumTy, BuiltinType::LongAccum);
1141 InitBuiltinType(UnsignedShortAccumTy, BuiltinType::UShortAccum);
1142 InitBuiltinType(UnsignedAccumTy, BuiltinType::UAccum);
1143 InitBuiltinType(UnsignedLongAccumTy, BuiltinType::ULongAccum);
1144 InitBuiltinType(ShortFractTy, BuiltinType::ShortFract);
1145 InitBuiltinType(FractTy, BuiltinType::Fract);
1146 InitBuiltinType(LongFractTy, BuiltinType::LongFract);
1147 InitBuiltinType(UnsignedShortFractTy, BuiltinType::UShortFract);
1148 InitBuiltinType(UnsignedFractTy, BuiltinType::UFract);
1149 InitBuiltinType(UnsignedLongFractTy, BuiltinType::ULongFract);
1150 InitBuiltinType(SatShortAccumTy, BuiltinType::SatShortAccum);
1151 InitBuiltinType(SatAccumTy, BuiltinType::SatAccum);
1152 InitBuiltinType(SatLongAccumTy, BuiltinType::SatLongAccum);
1153 InitBuiltinType(SatUnsignedShortAccumTy, BuiltinType::SatUShortAccum);
1154 InitBuiltinType(SatUnsignedAccumTy, BuiltinType::SatUAccum);
1155 InitBuiltinType(SatUnsignedLongAccumTy, BuiltinType::SatULongAccum);
1156 InitBuiltinType(SatShortFractTy, BuiltinType::SatShortFract);
1157 InitBuiltinType(SatFractTy, BuiltinType::SatFract);
1158 InitBuiltinType(SatLongFractTy, BuiltinType::SatLongFract);
1159 InitBuiltinType(SatUnsignedShortFractTy, BuiltinType::SatUShortFract);
1160 InitBuiltinType(SatUnsignedFractTy, BuiltinType::SatUFract);
1161 InitBuiltinType(SatUnsignedLongFractTy, BuiltinType::SatULongFract);
1162
1163 // GNU extension, 128-bit integers.
1164 InitBuiltinType(Int128Ty, BuiltinType::Int128);
1165 InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128);
1166
1167 // C++ 3.9.1p5
1168 if (TargetInfo::isTypeSigned(Target.getWCharType()))
1169 InitBuiltinType(WCharTy, BuiltinType::WChar_S);
1170 else // -fshort-wchar makes wchar_t be unsigned.
1171 InitBuiltinType(WCharTy, BuiltinType::WChar_U);
1172 if (LangOpts.CPlusPlus && LangOpts.WChar)
1173 WideCharTy = WCharTy;
1174 else {
1175 // C99 (or C++ using -fno-wchar).
1176 WideCharTy = getFromTargetType(Target.getWCharType());
1177 }
1178
1179 WIntTy = getFromTargetType(Target.getWIntType());
1180
1181 // C++20 (proposed)
1182 InitBuiltinType(Char8Ty, BuiltinType::Char8);
1183
1184 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
1185 InitBuiltinType(Char16Ty, BuiltinType::Char16);
1186 else // C99
1187 Char16Ty = getFromTargetType(Target.getChar16Type());
1188
1189 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
1190 InitBuiltinType(Char32Ty, BuiltinType::Char32);
1191 else // C99
1192 Char32Ty = getFromTargetType(Target.getChar32Type());
1193
1194 // Placeholder type for type-dependent expressions whose type is
1195 // completely unknown. No code should ever check a type against
1196 // DependentTy and users should never see it; however, it is here to
1197 // help diagnose failures to properly check for type-dependent
1198 // expressions.
1199 InitBuiltinType(DependentTy, BuiltinType::Dependent);
1200
1201 // Placeholder type for functions.
1202 InitBuiltinType(OverloadTy, BuiltinType::Overload);
1203
1204 // Placeholder type for bound members.
1205 InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember);
1206
1207 // Placeholder type for pseudo-objects.
1208 InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject);
1209
1210 // "any" type; useful for debugger-like clients.
1211 InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny);
1212
1213 // Placeholder type for unbridged ARC casts.
1214 InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast);
1215
1216 // Placeholder type for builtin functions.
1217 InitBuiltinType(BuiltinFnTy, BuiltinType::BuiltinFn);
1218
1219 // Placeholder type for OMP array sections.
1220 if (LangOpts.OpenMP)
1221 InitBuiltinType(OMPArraySectionTy, BuiltinType::OMPArraySection);
1222
1223 // C99 6.2.5p11.
1224 FloatComplexTy = getComplexType(FloatTy);
1225 DoubleComplexTy = getComplexType(DoubleTy);
1226 LongDoubleComplexTy = getComplexType(LongDoubleTy);
1227 Float128ComplexTy = getComplexType(Float128Ty);
1228
1229 // Builtin types for 'id', 'Class', and 'SEL'.
1230 InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
1231 InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
1232 InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);
1233
1234 if (LangOpts.OpenCL) {
1235#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1236 InitBuiltinType(SingletonId, BuiltinType::Id);
1237#include "clang/Basic/OpenCLImageTypes.def"
1238
1239 InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler);
1240 InitBuiltinType(OCLEventTy, BuiltinType::OCLEvent);
1241 InitBuiltinType(OCLClkEventTy, BuiltinType::OCLClkEvent);
1242 InitBuiltinType(OCLQueueTy, BuiltinType::OCLQueue);
1243 InitBuiltinType(OCLReserveIDTy, BuiltinType::OCLReserveID);
1244 }
1245
1246 // Builtin type for __objc_yes and __objc_no
1247 ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ?
1248 SignedCharTy : BoolTy);
1249
1250 ObjCConstantStringType = QualType();
1251
1252 ObjCSuperType = QualType();
1253
1254 // void * type
1255 if (LangOpts.OpenCLVersion >= 200) {
1256 auto Q = VoidTy.getQualifiers();
1257 Q.setAddressSpace(LangAS::opencl_generic);
1258 VoidPtrTy = getPointerType(getCanonicalType(
1259 getQualifiedType(VoidTy.getUnqualifiedType(), Q)));
1260 } else {
1261 VoidPtrTy = getPointerType(VoidTy);
1262 }
1263
1264 // nullptr type (C++0x 2.14.7)
1265 InitBuiltinType(NullPtrTy, BuiltinType::NullPtr);
1266
1267 // half type (OpenCL 6.1.1.1) / ARM NEON __fp16
1268 InitBuiltinType(HalfTy, BuiltinType::Half);
1269
1270 // Builtin type used to help define __builtin_va_list.
1271 VaListTagDecl = nullptr;
1272}
1273
1274DiagnosticsEngine &ASTContext::getDiagnostics() const {
1275 return SourceMgr.getDiagnostics();
1276}
1277
1278AttrVec& ASTContext::getDeclAttrs(const Decl *D) {
1279 AttrVec *&Result = DeclAttrs[D];
1280 if (!Result) {
1281 void *Mem = Allocate(sizeof(AttrVec));
1282 Result = new (Mem) AttrVec;
1283 }
1284
1285 return *Result;
1286}
1287
1288/// Erase the attributes corresponding to the given declaration.
1289void ASTContext::eraseDeclAttrs(const Decl *D) {
1290 llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
1291 if (Pos != DeclAttrs.end()) {
1292 Pos->second->~AttrVec();
1293 DeclAttrs.erase(Pos);
1294 }
1295}
1296
1297// FIXME: Remove ?
1298MemberSpecializationInfo *
1299ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) {
1300 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1300, __extension__ __PRETTY_FUNCTION__))
;
1301 return getTemplateOrSpecializationInfo(Var)
1302 .dyn_cast<MemberSpecializationInfo *>();
1303}
1304
1305ASTContext::TemplateOrSpecializationInfo
1306ASTContext::getTemplateOrSpecializationInfo(const VarDecl *Var) {
1307 llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
1308 TemplateOrInstantiation.find(Var);
1309 if (Pos == TemplateOrInstantiation.end())
1310 return {};
1311
1312 return Pos->second;
1313}
1314
1315void
1316ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
1317 TemplateSpecializationKind TSK,
1318 SourceLocation PointOfInstantiation) {
1319 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1319, __extension__ __PRETTY_FUNCTION__))
;
1320 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1320, __extension__ __PRETTY_FUNCTION__))
;
1321 setTemplateOrSpecializationInfo(Inst, new (*this) MemberSpecializationInfo(
1322 Tmpl, TSK, PointOfInstantiation));
1323}
1324
1325void
1326ASTContext::setTemplateOrSpecializationInfo(VarDecl *Inst,
1327 TemplateOrSpecializationInfo TSI) {
1328 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1329, __extension__ __PRETTY_FUNCTION__))
1329 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1329, __extension__ __PRETTY_FUNCTION__))
;
1330 TemplateOrInstantiation[Inst] = TSI;
1331}
1332
1333FunctionDecl *ASTContext::getClassScopeSpecializationPattern(
1334 const FunctionDecl *FD){
1335 assert(FD && "Specialization is 0")(static_cast <bool> (FD && "Specialization is 0"
) ? void (0) : __assert_fail ("FD && \"Specialization is 0\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1335, __extension__ __PRETTY_FUNCTION__))
;
1336 llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos
1337 = ClassScopeSpecializationPattern.find(FD);
1338 if (Pos == ClassScopeSpecializationPattern.end())
1339 return nullptr;
1340
1341 return Pos->second;
1342}
1343
1344void ASTContext::setClassScopeSpecializationPattern(FunctionDecl *FD,
1345 FunctionDecl *Pattern) {
1346 assert(FD && "Specialization is 0")(static_cast <bool> (FD && "Specialization is 0"
) ? void (0) : __assert_fail ("FD && \"Specialization is 0\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1346, __extension__ __PRETTY_FUNCTION__))
;
1347 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1347, __extension__ __PRETTY_FUNCTION__))
;
1348 ClassScopeSpecializationPattern[FD] = Pattern;
1349}
1350
1351NamedDecl *
1352ASTContext::getInstantiatedFromUsingDecl(NamedDecl *UUD) {
1353 auto Pos = InstantiatedFromUsingDecl.find(UUD);
1354 if (Pos == InstantiatedFromUsingDecl.end())
1355 return nullptr;
1356
1357 return Pos->second;
1358}
1359
1360void
1361ASTContext::setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern) {
1362 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __extension__ __PRETTY_FUNCTION__))
1363 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __extension__ __PRETTY_FUNCTION__))
1364 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __extension__ __PRETTY_FUNCTION__))
1365 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __extension__ __PRETTY_FUNCTION__))
;
1366 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __extension__ __PRETTY_FUNCTION__))
1367 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __extension__ __PRETTY_FUNCTION__))
1368 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __extension__ __PRETTY_FUNCTION__))
1369 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __extension__ __PRETTY_FUNCTION__))
;
1370 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1370, __extension__ __PRETTY_FUNCTION__))
;
1371 InstantiatedFromUsingDecl[Inst] = Pattern;
1372}
1373
1374UsingShadowDecl *
1375ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) {
1376 llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
1377 = InstantiatedFromUsingShadowDecl.find(Inst);
1378 if (Pos == InstantiatedFromUsingShadowDecl.end())
1379 return nullptr;
1380
1381 return Pos->second;
1382}
1383
1384void
1385ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
1386 UsingShadowDecl *Pattern) {
1387 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1387, __extension__ __PRETTY_FUNCTION__))
;
1388 InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1389}
1390
1391FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) {
1392 llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
1393 = InstantiatedFromUnnamedFieldDecl.find(Field);
1394 if (Pos == InstantiatedFromUnnamedFieldDecl.end())
1395 return nullptr;
1396
1397 return Pos->second;
1398}
1399
1400void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst,
1401 FieldDecl *Tmpl) {
1402 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1402, __extension__ __PRETTY_FUNCTION__))
;
1403 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1403, __extension__ __PRETTY_FUNCTION__))
;
1404 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1405, __extension__ __PRETTY_FUNCTION__))
1405 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1405, __extension__ __PRETTY_FUNCTION__))
;
1406
1407 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1408}
1409
1410ASTContext::overridden_cxx_method_iterator
1411ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const {
1412 return overridden_methods(Method).begin();
1413}
1414
1415ASTContext::overridden_cxx_method_iterator
1416ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const {
1417 return overridden_methods(Method).end();
1418}
1419
1420unsigned
1421ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const {
1422 auto Range = overridden_methods(Method);
1423 return Range.end() - Range.begin();
1424}
1425
1426ASTContext::overridden_method_range
1427ASTContext::overridden_methods(const CXXMethodDecl *Method) const {
1428 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
1429 OverriddenMethods.find(Method->getCanonicalDecl());
1430 if (Pos == OverriddenMethods.end())
1431 return overridden_method_range(nullptr, nullptr);
1432 return overridden_method_range(Pos->second.begin(), Pos->second.end());
1433}
1434
1435void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method,
1436 const CXXMethodDecl *Overridden) {
1437 assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl())(static_cast <bool> (Method->isCanonicalDecl() &&
Overridden->isCanonicalDecl()) ? void (0) : __assert_fail
("Method->isCanonicalDecl() && Overridden->isCanonicalDecl()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1437, __extension__ __PRETTY_FUNCTION__))
;
1438 OverriddenMethods[Method].push_back(Overridden);
1439}
1440
1441void ASTContext::getOverriddenMethods(
1442 const NamedDecl *D,
1443 SmallVectorImpl<const NamedDecl *> &Overridden) const {
1444 assert(D)(static_cast <bool> (D) ? void (0) : __assert_fail ("D"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1444, __extension__ __PRETTY_FUNCTION__))
;
1445
1446 if (const auto *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
1447 Overridden.append(overridden_methods_begin(CXXMethod),
1448 overridden_methods_end(CXXMethod));
1449 return;
1450 }
1451
1452 const auto *Method = dyn_cast<ObjCMethodDecl>(D);
1453 if (!Method)
1454 return;
1455
1456 SmallVector<const ObjCMethodDecl *, 8> OverDecls;
1457 Method->getOverriddenMethods(OverDecls);
1458 Overridden.append(OverDecls.begin(), OverDecls.end());
1459}
1460
1461void ASTContext::addedLocalImportDecl(ImportDecl *Import) {
1462 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1462, __extension__ __PRETTY_FUNCTION__))
;
1463 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1463, __extension__ __PRETTY_FUNCTION__))
;
1464 if (!FirstLocalImport) {
1465 FirstLocalImport = Import;
1466 LastLocalImport = Import;
1467 return;
1468 }
1469
1470 LastLocalImport->NextLocalImport = Import;
1471 LastLocalImport = Import;
1472}
1473
1474//===----------------------------------------------------------------------===//
1475// Type Sizing and Analysis
1476//===----------------------------------------------------------------------===//
1477
1478/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
1479/// scalar floating point type.
1480const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
1481 const auto *BT = T->getAs<BuiltinType>();
1482 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1482, __extension__ __PRETTY_FUNCTION__))
;
1483 switch (BT->getKind()) {
1484 default: llvm_unreachable("Not a floating point type!")::llvm::llvm_unreachable_internal("Not a floating point type!"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1484)
;
1485 case BuiltinType::Float16:
1486 case BuiltinType::Half:
1487 return Target->getHalfFormat();
1488 case BuiltinType::Float: return Target->getFloatFormat();
1489 case BuiltinType::Double: return Target->getDoubleFormat();
1490 case BuiltinType::LongDouble: return Target->getLongDoubleFormat();
1491 case BuiltinType::Float128: return Target->getFloat128Format();
1492 }
1493}
1494
1495CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
1496 unsigned Align = Target->getCharWidth();
1497
1498 bool UseAlignAttrOnly = false;
1499 if (unsigned AlignFromAttr = D->getMaxAlignment()) {
1500 Align = AlignFromAttr;
1501
1502 // __attribute__((aligned)) can increase or decrease alignment
1503 // *except* on a struct or struct member, where it only increases
1504 // alignment unless 'packed' is also specified.
1505 //
1506 // It is an error for alignas to decrease alignment, so we can
1507 // ignore that possibility; Sema should diagnose it.
1508 if (isa<FieldDecl>(D)) {
1509 UseAlignAttrOnly = D->hasAttr<PackedAttr>() ||
1510 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1511 } else {
1512 UseAlignAttrOnly = true;
1513 }
1514 }
1515 else if (isa<FieldDecl>(D))
1516 UseAlignAttrOnly =
1517 D->hasAttr<PackedAttr>() ||
1518 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1519
1520 // If we're using the align attribute only, just ignore everything
1521 // else about the declaration and its type.
1522 if (UseAlignAttrOnly) {
1523 // do nothing
1524 } else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
1525 QualType T = VD->getType();
1526 if (const auto *RT = T->getAs<ReferenceType>()) {
1527 if (ForAlignof)
1528 T = RT->getPointeeType();
1529 else
1530 T = getPointerType(RT->getPointeeType());
1531 }
1532 QualType BaseT = getBaseElementType(T);
1533 if (T->isFunctionType())
1534 Align = getTypeInfoImpl(T.getTypePtr()).Align;
1535 else if (!BaseT->isIncompleteType()) {
1536 // Adjust alignments of declarations with array type by the
1537 // large-array alignment on the target.
1538 if (const ArrayType *arrayType = getAsArrayType(T)) {
1539 unsigned MinWidth = Target->getLargeArrayMinWidth();
1540 if (!ForAlignof && MinWidth) {
1541 if (isa<VariableArrayType>(arrayType))
1542 Align = std::max(Align, Target->getLargeArrayAlign());
1543 else if (isa<ConstantArrayType>(arrayType) &&
1544 MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType)))
1545 Align = std::max(Align, Target->getLargeArrayAlign());
1546 }
1547 }
1548 Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
1549 if (BaseT.getQualifiers().hasUnaligned())
1550 Align = Target->getCharWidth();
1551 if (const auto *VD = dyn_cast<VarDecl>(D)) {
1552 if (VD->hasGlobalStorage() && !ForAlignof)
1553 Align = std::max(Align, getTargetInfo().getMinGlobalAlign());
1554 }
1555 }
1556
1557 // Fields can be subject to extra alignment constraints, like if
1558 // the field is packed, the struct is packed, or the struct has a
1559 // a max-field-alignment constraint (#pragma pack). So calculate
1560 // the actual alignment of the field within the struct, and then
1561 // (as we're expected to) constrain that by the alignment of the type.
1562 if (const auto *Field = dyn_cast<FieldDecl>(VD)) {
1563 const RecordDecl *Parent = Field->getParent();
1564 // We can only produce a sensible answer if the record is valid.
1565 if (!Parent->isInvalidDecl()) {
1566 const ASTRecordLayout &Layout = getASTRecordLayout(Parent);
1567
1568 // Start with the record's overall alignment.
1569 unsigned FieldAlign = toBits(Layout.getAlignment());
1570
1571 // Use the GCD of that and the offset within the record.
1572 uint64_t Offset = Layout.getFieldOffset(Field->getFieldIndex());
1573 if (Offset > 0) {
1574 // Alignment is always a power of 2, so the GCD will be a power of 2,
1575 // which means we get to do this crazy thing instead of Euclid's.
1576 uint64_t LowBitOfOffset = Offset & (~Offset + 1);
1577 if (LowBitOfOffset < FieldAlign)
1578 FieldAlign = static_cast<unsigned>(LowBitOfOffset);
1579 }
1580
1581 Align = std::min(Align, FieldAlign);
1582 }
1583 }
1584 }
1585
1586 return toCharUnitsFromBits(Align);
1587}
1588
1589// getTypeInfoDataSizeInChars - Return the size of a type, in
1590// chars. If the type is a record, its data size is returned. This is
1591// the size of the memcpy that's performed when assigning this type
1592// using a trivial copy/move assignment operator.
1593std::pair<CharUnits, CharUnits>
1594ASTContext::getTypeInfoDataSizeInChars(QualType T) const {
1595 std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T);
1596
1597 // In C++, objects can sometimes be allocated into the tail padding
1598 // of a base-class subobject. We decide whether that's possible
1599 // during class layout, so here we can just trust the layout results.
1600 if (getLangOpts().CPlusPlus) {
1601 if (const auto *RT = T->getAs<RecordType>()) {
1602 const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl());
1603 sizeAndAlign.first = layout.getDataSize();
1604 }
1605 }
1606
1607 return sizeAndAlign;
1608}
1609
1610/// getConstantArrayInfoInChars - Performing the computation in CharUnits
1611/// instead of in bits prevents overflowing the uint64_t for some large arrays.
1612std::pair<CharUnits, CharUnits>
1613static getConstantArrayInfoInChars(const ASTContext &Context,
1614 const ConstantArrayType *CAT) {
1615 std::pair<CharUnits, CharUnits> EltInfo =
1616 Context.getTypeInfoInChars(CAT->getElementType());
1617 uint64_t Size = CAT->getSize().getZExtValue();
1618 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1620, __extension__ __PRETTY_FUNCTION__))
1619 (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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1620, __extension__ __PRETTY_FUNCTION__))
1620 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1620, __extension__ __PRETTY_FUNCTION__))
;
1621 uint64_t Width = EltInfo.first.getQuantity() * Size;
1622 unsigned Align = EltInfo.second.getQuantity();
1623 if (!Context.getTargetInfo().getCXXABI().isMicrosoft() ||
1624 Context.getTargetInfo().getPointerWidth(0) == 64)
1625 Width = llvm::alignTo(Width, Align);
1626 return std::make_pair(CharUnits::fromQuantity(Width),
1627 CharUnits::fromQuantity(Align));
1628}
1629
1630std::pair<CharUnits, CharUnits>
1631ASTContext::getTypeInfoInChars(const Type *T) const {
1632 if (const auto *CAT = dyn_cast<ConstantArrayType>(T))
1633 return getConstantArrayInfoInChars(*this, CAT);
1634 TypeInfo Info = getTypeInfo(T);
1635 return std::make_pair(toCharUnitsFromBits(Info.Width),
1636 toCharUnitsFromBits(Info.Align));
1637}
1638
1639std::pair<CharUnits, CharUnits>
1640ASTContext::getTypeInfoInChars(QualType T) const {
1641 return getTypeInfoInChars(T.getTypePtr());
1642}
1643
1644bool ASTContext::isAlignmentRequired(const Type *T) const {
1645 return getTypeInfo(T).AlignIsRequired;
1646}
1647
1648bool ASTContext::isAlignmentRequired(QualType T) const {
1649 return isAlignmentRequired(T.getTypePtr());
1650}
1651
1652unsigned ASTContext::getTypeAlignIfKnown(QualType T) const {
1653 // An alignment on a typedef overrides anything else.
1654 if (const auto *TT = T->getAs<TypedefType>())
1655 if (unsigned Align = TT->getDecl()->getMaxAlignment())
1656 return Align;
1657
1658 // If we have an (array of) complete type, we're done.
1659 T = getBaseElementType(T);
1660 if (!T->isIncompleteType())
1661 return getTypeAlign(T);
1662
1663 // If we had an array type, its element type might be a typedef
1664 // type with an alignment attribute.
1665 if (const auto *TT = T->getAs<TypedefType>())
1666 if (unsigned Align = TT->getDecl()->getMaxAlignment())
1667 return Align;
1668
1669 // Otherwise, see if the declaration of the type had an attribute.
1670 if (const auto *TT = T->getAs<TagType>())
1671 return TT->getDecl()->getMaxAlignment();
1672
1673 return 0;
1674}
1675
1676TypeInfo ASTContext::getTypeInfo(const Type *T) const {
1677 TypeInfoMap::iterator I = MemoizedTypeInfo.find(T);
1678 if (I != MemoizedTypeInfo.end())
1679 return I->second;
1680
1681 // This call can invalidate MemoizedTypeInfo[T], so we need a second lookup.
1682 TypeInfo TI = getTypeInfoImpl(T);
1683 MemoizedTypeInfo[T] = TI;
1684 return TI;
1685}
1686
1687/// getTypeInfoImpl - Return the size of the specified type, in bits. This
1688/// method does not work on incomplete types.
1689///
1690/// FIXME: Pointers into different addr spaces could have different sizes and
1691/// alignment requirements: getPointerInfo should take an AddrSpace, this
1692/// should take a QualType, &c.
1693TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
1694 uint64_t Width = 0;
1695 unsigned Align = 8;
1696 bool AlignIsRequired = false;
1697 unsigned AS = 0;
1698 switch (T->getTypeClass()) {
1699#define TYPE(Class, Base)
1700#define ABSTRACT_TYPE(Class, Base)
1701#define NON_CANONICAL_TYPE(Class, Base)
1702#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1703#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \
1704 case Type::Class: \
1705 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1705, __extension__ __PRETTY_FUNCTION__))
; \
1706 return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
1707#include "clang/AST/TypeNodes.def"
1708 llvm_unreachable("Should not see dependent types")::llvm::llvm_unreachable_internal("Should not see dependent types"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1708)
;
1709
1710 case Type::FunctionNoProto:
1711 case Type::FunctionProto:
1712 // GCC extension: alignof(function) = 32 bits
1713 Width = 0;
1714 Align = 32;
1715 break;
1716
1717 case Type::IncompleteArray:
1718 case Type::VariableArray:
1719 Width = 0;
1720 Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
1721 break;
1722
1723 case Type::ConstantArray: {
1724 const auto *CAT = cast<ConstantArrayType>(T);
1725
1726 TypeInfo EltInfo = getTypeInfo(CAT->getElementType());
1727 uint64_t Size = CAT->getSize().getZExtValue();
1728 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1729, __extension__ __PRETTY_FUNCTION__))
1729 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1729, __extension__ __PRETTY_FUNCTION__))
;
1730 Width = EltInfo.Width * Size;
1731 Align = EltInfo.Align;
1732 if (!getTargetInfo().getCXXABI().isMicrosoft() ||
1733 getTargetInfo().getPointerWidth(0) == 64)
1734 Width = llvm::alignTo(Width, Align);
1735 break;
1736 }
1737 case Type::ExtVector:
1738 case Type::Vector: {
1739 const auto *VT = cast<VectorType>(T);
1740 TypeInfo EltInfo = getTypeInfo(VT->getElementType());
1741 Width = EltInfo.Width * VT->getNumElements();
1742 Align = Width;
1743 // If the alignment is not a power of 2, round up to the next power of 2.
1744 // This happens for non-power-of-2 length vectors.
1745 if (Align & (Align-1)) {
1746 Align = llvm::NextPowerOf2(Align);
1747 Width = llvm::alignTo(Width, Align);
1748 }
1749 // Adjust the alignment based on the target max.
1750 uint64_t TargetVectorAlign = Target->getMaxVectorAlign();
1751 if (TargetVectorAlign && TargetVectorAlign < Align)
1752 Align = TargetVectorAlign;
1753 break;
1754 }
1755
1756 case Type::Builtin:
1757 switch (cast<BuiltinType>(T)->getKind()) {
1758 default: llvm_unreachable("Unknown builtin type!")::llvm::llvm_unreachable_internal("Unknown builtin type!", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1758)
;
1759 case BuiltinType::Void:
1760 // GCC extension: alignof(void) = 8 bits.
1761 Width = 0;
1762 Align = 8;
1763 break;
1764 case BuiltinType::Bool:
1765 Width = Target->getBoolWidth();
1766 Align = Target->getBoolAlign();
1767 break;
1768 case BuiltinType::Char_S:
1769 case BuiltinType::Char_U:
1770 case BuiltinType::UChar:
1771 case BuiltinType::SChar:
1772 case BuiltinType::Char8:
1773 Width = Target->getCharWidth();
1774 Align = Target->getCharAlign();
1775 break;
1776 case BuiltinType::WChar_S:
1777 case BuiltinType::WChar_U:
1778 Width = Target->getWCharWidth();
1779 Align = Target->getWCharAlign();
1780 break;
1781 case BuiltinType::Char16:
1782 Width = Target->getChar16Width();
1783 Align = Target->getChar16Align();
1784 break;
1785 case BuiltinType::Char32:
1786 Width = Target->getChar32Width();
1787 Align = Target->getChar32Align();
1788 break;
1789 case BuiltinType::UShort:
1790 case BuiltinType::Short:
1791 Width = Target->getShortWidth();
1792 Align = Target->getShortAlign();
1793 break;
1794 case BuiltinType::UInt:
1795 case BuiltinType::Int:
1796 Width = Target->getIntWidth();
1797 Align = Target->getIntAlign();
1798 break;
1799 case BuiltinType::ULong:
1800 case BuiltinType::Long:
1801 Width = Target->getLongWidth();
1802 Align = Target->getLongAlign();
1803 break;
1804 case BuiltinType::ULongLong:
1805 case BuiltinType::LongLong:
1806 Width = Target->getLongLongWidth();
1807 Align = Target->getLongLongAlign();
1808 break;
1809 case BuiltinType::Int128:
1810 case BuiltinType::UInt128:
1811 Width = 128;
1812 Align = 128; // int128_t is 128-bit aligned on all targets.
1813 break;
1814 case BuiltinType::ShortAccum:
1815 case BuiltinType::UShortAccum:
1816 case BuiltinType::SatShortAccum:
1817 case BuiltinType::SatUShortAccum:
1818 Width = Target->getShortAccumWidth();
1819 Align = Target->getShortAccumAlign();
1820 break;
1821 case BuiltinType::Accum:
1822 case BuiltinType::UAccum:
1823 case BuiltinType::SatAccum:
1824 case BuiltinType::SatUAccum:
1825 Width = Target->getAccumWidth();
1826 Align = Target->getAccumAlign();
1827 break;
1828 case BuiltinType::LongAccum:
1829 case BuiltinType::ULongAccum:
1830 case BuiltinType::SatLongAccum:
1831 case BuiltinType::SatULongAccum:
1832 Width = Target->getLongAccumWidth();
1833 Align = Target->getLongAccumAlign();
1834 break;
1835 case BuiltinType::ShortFract:
1836 case BuiltinType::UShortFract:
1837 case BuiltinType::SatShortFract:
1838 case BuiltinType::SatUShortFract:
1839 Width = Target->getShortFractWidth();
1840 Align = Target->getShortFractAlign();
1841 break;
1842 case BuiltinType::Fract:
1843 case BuiltinType::UFract:
1844 case BuiltinType::SatFract:
1845 case BuiltinType::SatUFract:
1846 Width = Target->getFractWidth();
1847 Align = Target->getFractAlign();
1848 break;
1849 case BuiltinType::LongFract:
1850 case BuiltinType::ULongFract:
1851 case BuiltinType::SatLongFract:
1852 case BuiltinType::SatULongFract:
1853 Width = Target->getLongFractWidth();
1854 Align = Target->getLongFractAlign();
1855 break;
1856 case BuiltinType::Float16:
1857 case BuiltinType::Half:
1858 Width = Target->getHalfWidth();
1859 Align = Target->getHalfAlign();
1860 break;
1861 case BuiltinType::Float:
1862 Width = Target->getFloatWidth();
1863 Align = Target->getFloatAlign();
1864 break;
1865 case BuiltinType::Double:
1866 Width = Target->getDoubleWidth();
1867 Align = Target->getDoubleAlign();
1868 break;
1869 case BuiltinType::LongDouble:
1870 Width = Target->getLongDoubleWidth();
1871 Align = Target->getLongDoubleAlign();
1872 break;
1873 case BuiltinType::Float128:
1874 Width = Target->getFloat128Width();
1875 Align = Target->getFloat128Align();
1876 break;
1877 case BuiltinType::NullPtr:
1878 Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
1879 Align = Target->getPointerAlign(0); // == sizeof(void*)
1880 break;
1881 case BuiltinType::ObjCId:
1882 case BuiltinType::ObjCClass:
1883 case BuiltinType::ObjCSel:
1884 Width = Target->getPointerWidth(0);
1885 Align = Target->getPointerAlign(0);
1886 break;
1887 case BuiltinType::OCLSampler:
1888 case BuiltinType::OCLEvent:
1889 case BuiltinType::OCLClkEvent:
1890 case BuiltinType::OCLQueue:
1891 case BuiltinType::OCLReserveID:
1892#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1893 case BuiltinType::Id:
1894#include "clang/Basic/OpenCLImageTypes.def"
1895 AS = getTargetAddressSpace(
1896 Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T)));
1897 Width = Target->getPointerWidth(AS);
1898 Align = Target->getPointerAlign(AS);
1899 break;
1900 }
1901 break;
1902 case Type::ObjCObjectPointer:
1903 Width = Target->getPointerWidth(0);
1904 Align = Target->getPointerAlign(0);
1905 break;
1906 case Type::BlockPointer:
1907 AS = getTargetAddressSpace(cast<BlockPointerType>(T)->getPointeeType());
1908 Width = Target->getPointerWidth(AS);
1909 Align = Target->getPointerAlign(AS);
1910 break;
1911 case Type::LValueReference:
1912 case Type::RValueReference:
1913 // alignof and sizeof should never enter this code path here, so we go
1914 // the pointer route.
1915 AS = getTargetAddressSpace(cast<ReferenceType>(T)->getPointeeType());
1916 Width = Target->getPointerWidth(AS);
1917 Align = Target->getPointerAlign(AS);
1918 break;
1919 case Type::Pointer:
1920 AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType());
1921 Width = Target->getPointerWidth(AS);
1922 Align = Target->getPointerAlign(AS);
1923 break;
1924 case Type::MemberPointer: {
1925 const auto *MPT = cast<MemberPointerType>(T);
1926 CXXABI::MemberPointerInfo MPI = ABI->getMemberPointerInfo(MPT);
1927 Width = MPI.Width;
1928 Align = MPI.Align;
1929 break;
1930 }
1931 case Type::Complex: {
1932 // Complex types have the same alignment as their elements, but twice the
1933 // size.
1934 TypeInfo EltInfo = getTypeInfo(cast<ComplexType>(T)->getElementType());
1935 Width = EltInfo.Width * 2;
1936 Align = EltInfo.Align;
1937 break;
1938 }
1939 case Type::ObjCObject:
1940 return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr());
1941 case Type::Adjusted:
1942 case Type::Decayed:
1943 return getTypeInfo(cast<AdjustedType>(T)->getAdjustedType().getTypePtr());
1944 case Type::ObjCInterface: {
1945 const auto *ObjCI = cast<ObjCInterfaceType>(T);
1946 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
1947 Width = toBits(Layout.getSize());
1948 Align = toBits(Layout.getAlignment());
1949 break;
1950 }
1951 case Type::Record:
1952 case Type::Enum: {
1953 const auto *TT = cast<TagType>(T);
1954
1955 if (TT->getDecl()->isInvalidDecl()) {
1956 Width = 8;
1957 Align = 8;
1958 break;
1959 }
1960
1961 if (const auto *ET = dyn_cast<EnumType>(TT)) {
1962 const EnumDecl *ED = ET->getDecl();
1963 TypeInfo Info =
1964 getTypeInfo(ED->getIntegerType()->getUnqualifiedDesugaredType());
1965 if (unsigned AttrAlign = ED->getMaxAlignment()) {
1966 Info.Align = AttrAlign;
1967 Info.AlignIsRequired = true;
1968 }
1969 return Info;
1970 }
1971
1972 const auto *RT = cast<RecordType>(TT);
1973 const RecordDecl *RD = RT->getDecl();
1974 const ASTRecordLayout &Layout = getASTRecordLayout(RD);
1975 Width = toBits(Layout.getSize());
1976 Align = toBits(Layout.getAlignment());
1977 AlignIsRequired = RD->hasAttr<AlignedAttr>();
1978 break;
1979 }
1980
1981 case Type::SubstTemplateTypeParm:
1982 return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
1983 getReplacementType().getTypePtr());
1984
1985 case Type::Auto:
1986 case Type::DeducedTemplateSpecialization: {
1987 const auto *A = cast<DeducedType>(T);
1988 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1989, __extension__ __PRETTY_FUNCTION__))
1989 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 1989, __extension__ __PRETTY_FUNCTION__))
;
1990 return getTypeInfo(A->getDeducedType().getTypePtr());
1991 }
1992
1993 case Type::Paren:
1994 return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr());
1995
1996 case Type::ObjCTypeParam:
1997 return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr());
1998
1999 case Type::Typedef: {
2000 const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl();
2001 TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
2002 // If the typedef has an aligned attribute on it, it overrides any computed
2003 // alignment we have. This violates the GCC documentation (which says that
2004 // attribute(aligned) can only round up) but matches its implementation.
2005 if (unsigned AttrAlign = Typedef->getMaxAlignment()) {
2006 Align = AttrAlign;
2007 AlignIsRequired = true;
2008 } else {
2009 Align = Info.Align;
2010 AlignIsRequired = Info.AlignIsRequired;
2011 }
2012 Width = Info.Width;
2013 break;
2014 }
2015
2016 case Type::Elaborated:
2017 return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr());
2018
2019 case Type::Attributed:
2020 return getTypeInfo(
2021 cast<AttributedType>(T)->getEquivalentType().getTypePtr());
2022
2023 case Type::Atomic: {
2024 // Start with the base type information.
2025 TypeInfo Info = getTypeInfo(cast<AtomicType>(T)->getValueType());
2026 Width = Info.Width;
2027 Align = Info.Align;
2028
2029 if (!Width) {
2030 // An otherwise zero-sized type should still generate an
2031 // atomic operation.
2032 Width = Target->getCharWidth();
2033 assert(Align)(static_cast <bool> (Align) ? void (0) : __assert_fail (
"Align", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2033, __extension__ __PRETTY_FUNCTION__))
;
2034 } else if (Width <= Target->getMaxAtomicPromoteWidth()) {
2035 // If the size of the type doesn't exceed the platform's max
2036 // atomic promotion width, make the size and alignment more
2037 // favorable to atomic operations:
2038
2039 // Round the size up to a power of 2.
2040 if (!llvm::isPowerOf2_64(Width))
2041 Width = llvm::NextPowerOf2(Width);
2042
2043 // Set the alignment equal to the size.
2044 Align = static_cast<unsigned>(Width);
2045 }
2046 }
2047 break;
2048
2049 case Type::Pipe:
2050 Width = Target->getPointerWidth(getTargetAddressSpace(LangAS::opencl_global));
2051 Align = Target->getPointerAlign(getTargetAddressSpace(LangAS::opencl_global));
2052 break;
2053 }
2054
2055 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2055, __extension__ __PRETTY_FUNCTION__))
;
2056 return TypeInfo(Width, Align, AlignIsRequired);
2057}
2058
2059unsigned ASTContext::getOpenMPDefaultSimdAlign(QualType T) const {
2060 unsigned SimdAlign = getTargetInfo().getSimdDefaultAlign();
2061 // Target ppc64 with QPX: simd default alignment for pointer to double is 32.
2062 if ((getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64 ||
2063 getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64le) &&
2064 getTargetInfo().getABI() == "elfv1-qpx" &&
2065 T->isSpecificBuiltinType(BuiltinType::Double))
2066 SimdAlign = 256;
2067 return SimdAlign;
2068}
2069
2070/// toCharUnitsFromBits - Convert a size in bits to a size in characters.
2071CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const {
2072 return CharUnits::fromQuantity(BitSize / getCharWidth());
2073}
2074
2075/// toBits - Convert a size in characters to a size in characters.
2076int64_t ASTContext::toBits(CharUnits CharSize) const {
2077 return CharSize.getQuantity() * getCharWidth();
2078}
2079
2080/// getTypeSizeInChars - Return the size of the specified type, in characters.
2081/// This method does not work on incomplete types.
2082CharUnits ASTContext::getTypeSizeInChars(QualType T) const {
2083 return getTypeInfoInChars(T).first;
2084}
2085CharUnits ASTContext::getTypeSizeInChars(const Type *T) const {
2086 return getTypeInfoInChars(T).first;
2087}
2088
2089/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in
2090/// characters. This method does not work on incomplete types.
2091CharUnits ASTContext::getTypeAlignInChars(QualType T) const {
2092 return toCharUnitsFromBits(getTypeAlign(T));
2093}
2094CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
2095 return toCharUnitsFromBits(getTypeAlign(T));
2096}
2097
2098/// getPreferredTypeAlign - Return the "preferred" alignment of the specified
2099/// type for the current target in bits. This can be different than the ABI
2100/// alignment in cases where it is beneficial for performance to overalign
2101/// a data type.
2102unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
2103 TypeInfo TI = getTypeInfo(T);
2104 unsigned ABIAlign = TI.Align;
2105
2106 T = T->getBaseElementTypeUnsafe();
2107
2108 // The preferred alignment of member pointers is that of a pointer.
2109 if (T->isMemberPointerType())
2110 return getPreferredTypeAlign(getPointerDiffType().getTypePtr());
2111
2112 if (!Target->allowsLargerPreferedTypeAlignment())
2113 return ABIAlign;
2114
2115 // Double and long long should be naturally aligned if possible.
2116 if (const auto *CT = T->getAs<ComplexType>())
2117 T = CT->getElementType().getTypePtr();
2118 if (const auto *ET = T->getAs<EnumType>())
2119 T = ET->getDecl()->getIntegerType().getTypePtr();
2120 if (T->isSpecificBuiltinType(BuiltinType::Double) ||
2121 T->isSpecificBuiltinType(BuiltinType::LongLong) ||
2122 T->isSpecificBuiltinType(BuiltinType::ULongLong))
2123 // Don't increase the alignment if an alignment attribute was specified on a
2124 // typedef declaration.
2125 if (!TI.AlignIsRequired)
2126 return std::max(ABIAlign, (unsigned)getTypeSize(T));
2127
2128 return ABIAlign;
2129}
2130
2131/// getTargetDefaultAlignForAttributeAligned - Return the default alignment
2132/// for __attribute__((aligned)) on this target, to be used if no alignment
2133/// value is specified.
2134unsigned ASTContext::getTargetDefaultAlignForAttributeAligned() const {
2135 return getTargetInfo().getDefaultAlignForAttributeAligned();
2136}
2137
2138/// getAlignOfGlobalVar - Return the alignment in bits that should be given
2139/// to a global variable of the specified type.
2140unsigned ASTContext::getAlignOfGlobalVar(QualType T) const {
2141 return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign());
2142}
2143
2144/// getAlignOfGlobalVarInChars - Return the alignment in characters that
2145/// should be given to a global variable of the specified type.
2146CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T) const {
2147 return toCharUnitsFromBits(getAlignOfGlobalVar(T));
2148}
2149
2150CharUnits ASTContext::getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const {
2151 CharUnits Offset = CharUnits::Zero();
2152 const ASTRecordLayout *Layout = &getASTRecordLayout(RD);
2153 while (const CXXRecordDecl *Base = Layout->getBaseSharingVBPtr()) {
2154 Offset += Layout->getBaseClassOffset(Base);
2155 Layout = &getASTRecordLayout(Base);
2156 }
2157 return Offset;
2158}
2159
2160/// DeepCollectObjCIvars -
2161/// This routine first collects all declared, but not synthesized, ivars in
2162/// super class and then collects all ivars, including those synthesized for
2163/// current class. This routine is used for implementation of current class
2164/// when all ivars, declared and synthesized are known.
2165void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI,
2166 bool leafClass,
2167 SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const {
2168 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
2169 DeepCollectObjCIvars(SuperClass, false, Ivars);
2170 if (!leafClass) {
2171 for (const auto *I : OI->ivars())
2172 Ivars.push_back(I);
2173 } else {
2174 auto *IDecl = const_cast<ObjCInterfaceDecl *>(OI);
2175 for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
2176 Iv= Iv->getNextIvar())
2177 Ivars.push_back(Iv);
2178 }
2179}
2180
2181/// CollectInheritedProtocols - Collect all protocols in current class and
2182/// those inherited by it.
2183void ASTContext::CollectInheritedProtocols(const Decl *CDecl,
2184 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
2185 if (const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2186 // We can use protocol_iterator here instead of
2187 // all_referenced_protocol_iterator since we are walking all categories.
2188 for (auto *Proto : OI->all_referenced_protocols()) {
2189 CollectInheritedProtocols(Proto, Protocols);
2190 }
2191
2192 // Categories of this Interface.
2193 for (const auto *Cat : OI->visible_categories())
2194 CollectInheritedProtocols(Cat, Protocols);
2195
2196 if (ObjCInterfaceDecl *SD = OI->getSuperClass())
2197 while (SD) {
2198 CollectInheritedProtocols(SD, Protocols);
2199 SD = SD->getSuperClass();
2200 }
2201 } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2202 for (auto *Proto : OC->protocols()) {
2203 CollectInheritedProtocols(Proto, Protocols);
2204 }
2205 } else if (const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
2206 // Insert the protocol.
2207 if (!Protocols.insert(
2208 const_cast<ObjCProtocolDecl *>(OP->getCanonicalDecl())).second)
2209 return;
2210
2211 for (auto *Proto : OP->protocols())
2212 CollectInheritedProtocols(Proto, Protocols);
2213 }
2214}
2215
2216static bool unionHasUniqueObjectRepresentations(const ASTContext &Context,
2217 const RecordDecl *RD) {
2218 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2218, __extension__ __PRETTY_FUNCTION__))
;
2219 CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());
2220
2221 for (const auto *Field : RD->fields()) {
2222 if (!Context.hasUniqueObjectRepresentations(Field->getType()))
2223 return false;
2224 CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
2225 if (FieldSize != UnionSize)
2226 return false;
2227 }
2228 return !RD->field_empty();
2229}
2230
2231static bool isStructEmpty(QualType Ty) {
2232 const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();
2233
2234 if (!RD->field_empty())
2235 return false;
2236
2237 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD))
2238 return ClassDecl->isEmpty();
2239
2240 return true;
2241}
2242
2243static llvm::Optional<int64_t>
2244structHasUniqueObjectRepresentations(const ASTContext &Context,
2245 const RecordDecl *RD) {
2246 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2246, __extension__ __PRETTY_FUNCTION__))
;
2247 const auto &Layout = Context.getASTRecordLayout(RD);
2248
2249 int64_t CurOffsetInBits = 0;
2250 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2251 if (ClassDecl->isDynamicClass())
2252 return llvm::None;
2253
2254 SmallVector<std::pair<QualType, int64_t>, 4> Bases;
2255 for (const auto Base : ClassDecl->bases()) {
2256 // Empty types can be inherited from, and non-empty types can potentially
2257 // have tail padding, so just make sure there isn't an error.
2258 if (!isStructEmpty(Base.getType())) {
2259 llvm::Optional<int64_t> Size = structHasUniqueObjectRepresentations(
2260 Context, Base.getType()->getAs<RecordType>()->getDecl());
2261 if (!Size)
2262 return llvm::None;
2263 Bases.emplace_back(Base.getType(), Size.getValue());
2264 }
2265 }
2266
2267 llvm::sort(
2268 Bases.begin(), Bases.end(), [&](const std::pair<QualType, int64_t> &L,
2269 const std::pair<QualType, int64_t> &R) {
2270 return Layout.getBaseClassOffset(L.first->getAsCXXRecordDecl()) <
2271 Layout.getBaseClassOffset(R.first->getAsCXXRecordDecl());
2272 });
2273
2274 for (const auto Base : Bases) {
2275 int64_t BaseOffset = Context.toBits(
2276 Layout.getBaseClassOffset(Base.first->getAsCXXRecordDecl()));
2277 int64_t BaseSize = Base.second;
2278 if (BaseOffset != CurOffsetInBits)
2279 return llvm::None;
2280 CurOffsetInBits = BaseOffset + BaseSize;
2281 }
2282 }
2283
2284 for (const auto *Field : RD->fields()) {
2285 if (!Field->getType()->isReferenceType() &&
2286 !Context.hasUniqueObjectRepresentations(Field->getType()))
2287 return llvm::None;
2288
2289 int64_t FieldSizeInBits =
2290 Context.toBits(Context.getTypeSizeInChars(Field->getType()));
2291 if (Field->isBitField()) {
2292 int64_t BitfieldSize = Field->getBitWidthValue(Context);
2293
2294 if (BitfieldSize > FieldSizeInBits)
2295 return llvm::None;
2296 FieldSizeInBits = BitfieldSize;
2297 }
2298
2299 int64_t FieldOffsetInBits = Context.getFieldOffset(Field);
2300
2301 if (FieldOffsetInBits != CurOffsetInBits)
2302 return llvm::None;
2303
2304 CurOffsetInBits = FieldSizeInBits + FieldOffsetInBits;
2305 }
2306
2307 return CurOffsetInBits;
2308}
2309
2310bool ASTContext::hasUniqueObjectRepresentations(QualType Ty) const {
2311 // C++17 [meta.unary.prop]:
2312 // The predicate condition for a template specialization
2313 // has_unique_object_representations<T> shall be
2314 // satisfied if and only if:
2315 // (9.1) - T is trivially copyable, and
2316 // (9.2) - any two objects of type T with the same value have the same
2317 // object representation, where two objects
2318 // of array or non-union class type are considered to have the same value
2319 // if their respective sequences of
2320 // direct subobjects have the same values, and two objects of union type
2321 // are considered to have the same
2322 // value if they have the same active member and the corresponding members
2323 // have the same value.
2324 // The set of scalar types for which this condition holds is
2325 // implementation-defined. [ Note: If a type has padding
2326 // bits, the condition does not hold; otherwise, the condition holds true
2327 // for unsigned integral types. -- end note ]
2328 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2328, __extension__ __PRETTY_FUNCTION__))
;
2329
2330 // Arrays are unique only if their element type is unique.
2331 if (Ty->isArrayType())
2332 return hasUniqueObjectRepresentations(getBaseElementType(Ty));
2333
2334 // (9.1) - T is trivially copyable...
2335 if (!Ty.isTriviallyCopyableType(*this))
2336 return false;
2337
2338 // All integrals and enums are unique.
2339 if (Ty->isIntegralOrEnumerationType())
2340 return true;
2341
2342 // All other pointers are unique.
2343 if (Ty->isPointerType())
2344 return true;
2345
2346 if (Ty->isMemberPointerType()) {
2347 const auto *MPT = Ty->getAs<MemberPointerType>();
2348 return !ABI->getMemberPointerInfo(MPT).HasPadding;
2349 }
2350
2351 if (Ty->isRecordType()) {
2352 const RecordDecl *Record = Ty->getAs<RecordType>()->getDecl();
2353
2354 if (Record->isInvalidDecl())
2355 return false;
2356
2357 if (Record->isUnion())
2358 return unionHasUniqueObjectRepresentations(*this, Record);
2359
2360 Optional<int64_t> StructSize =
2361 structHasUniqueObjectRepresentations(*this, Record);
2362
2363 return StructSize &&
2364 StructSize.getValue() == static_cast<int64_t>(getTypeSize(Ty));
2365 }
2366
2367 // FIXME: More cases to handle here (list by rsmith):
2368 // vectors (careful about, eg, vector of 3 foo)
2369 // _Complex int and friends
2370 // _Atomic T
2371 // Obj-C block pointers
2372 // Obj-C object pointers
2373 // and perhaps OpenCL's various builtin types (pipe, sampler_t, event_t,
2374 // clk_event_t, queue_t, reserve_id_t)
2375 // There're also Obj-C class types and the Obj-C selector type, but I think it
2376 // makes sense for those to return false here.
2377
2378 return false;
2379}
2380
2381unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const {
2382 unsigned count = 0;
2383 // Count ivars declared in class extension.
2384 for (const auto *Ext : OI->known_extensions())
2385 count += Ext->ivar_size();
2386
2387 // Count ivar defined in this class's implementation. This
2388 // includes synthesized ivars.
2389 if (ObjCImplementationDecl *ImplDecl = OI->getImplementation())
2390 count += ImplDecl->ivar_size();
2391
2392 return count;
2393}
2394
2395bool ASTContext::isSentinelNullExpr(const Expr *E) {
2396 if (!E)
2397 return false;
2398
2399 // nullptr_t is always treated as null.
2400 if (E->getType()->isNullPtrType()) return true;
2401
2402 if (E->getType()->isAnyPointerType() &&
2403 E->IgnoreParenCasts()->isNullPointerConstant(*this,
2404 Expr::NPC_ValueDependentIsNull))
2405 return true;
2406
2407 // Unfortunately, __null has type 'int'.
2408 if (isa<GNUNullExpr>(E)) return true;
2409
2410 return false;
2411}
2412
2413/// Get the implementation of ObjCInterfaceDecl, or nullptr if none
2414/// exists.
2415ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
2416 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2417 I = ObjCImpls.find(D);
2418 if (I != ObjCImpls.end())
2419 return cast<ObjCImplementationDecl>(I->second);
2420 return nullptr;
2421}
2422
2423/// Get the implementation of ObjCCategoryDecl, or nullptr if none
2424/// exists.
2425ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) {
2426 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2427 I = ObjCImpls.find(D);
2428 if (I != ObjCImpls.end())
2429 return cast<ObjCCategoryImplDecl>(I->second);
2430 return nullptr;
2431}
2432
2433/// Set the implementation of ObjCInterfaceDecl.
2434void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD,
2435 ObjCImplementationDecl *ImplD) {
2436 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2436, __extension__ __PRETTY_FUNCTION__))
;
2437 ObjCImpls[IFaceD] = ImplD;
2438}
2439
2440/// Set the implementation of ObjCCategoryDecl.
2441void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD,
2442 ObjCCategoryImplDecl *ImplD) {
2443 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2443, __extension__ __PRETTY_FUNCTION__))
;
2444 ObjCImpls[CatD] = ImplD;
2445}
2446
2447const ObjCMethodDecl *
2448ASTContext::getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const {
2449 return ObjCMethodRedecls.lookup(MD);
2450}
2451
2452void ASTContext::setObjCMethodRedeclaration(const ObjCMethodDecl *MD,
2453 const ObjCMethodDecl *Redecl) {
2454 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2454, __extension__ __PRETTY_FUNCTION__))
;
2455 ObjCMethodRedecls[MD] = Redecl;
2456}
2457
2458const ObjCInterfaceDecl *ASTContext::getObjContainingInterface(
2459 const NamedDecl *ND) const {
2460 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext()))
2461 return ID;
2462 if (const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext()))
2463 return CD->getClassInterface();
2464 if (const auto *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext()))
2465 return IMD->getClassInterface();
2466
2467 return nullptr;
2468}
2469
2470/// Get the copy initialization expression of VarDecl, or nullptr if
2471/// none exists.
2472Expr *ASTContext::getBlockVarCopyInits(const VarDecl*VD) {
2473 assert(VD && "Passed null params")(static_cast <bool> (VD && "Passed null params"
) ? void (0) : __assert_fail ("VD && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2473, __extension__ __PRETTY_FUNCTION__))
;
2474 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2475, __extension__ __PRETTY_FUNCTION__))
2475 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2475, __extension__ __PRETTY_FUNCTION__))
;
2476 llvm::DenseMap<const VarDecl*, Expr*>::iterator
2477 I = BlockVarCopyInits.find(VD);
2478 return (I != BlockVarCopyInits.end()) ? I->second : nullptr;
2479}
2480
2481/// Set the copy inialization expression of a block var decl.
2482void ASTContext::setBlockVarCopyInits(VarDecl*VD, Expr* Init) {
2483 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2483, __extension__ __PRETTY_FUNCTION__))
;
2484 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2485, __extension__ __PRETTY_FUNCTION__))
2485 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2485, __extension__ __PRETTY_FUNCTION__))
;
2486 BlockVarCopyInits[VD] = Init;
2487}
2488
2489TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T,
2490 unsigned DataSize) const {
2491 if (!DataSize)
2492 DataSize = TypeLoc::getFullDataSizeForType(T);
2493 else
2494 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2495, __extension__ __PRETTY_FUNCTION__))
2495 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2495, __extension__ __PRETTY_FUNCTION__))
;
2496
2497 auto *TInfo =
2498 (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
2499 new (TInfo) TypeSourceInfo(T);
2500 return TInfo;
2501}
2502
2503TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T,
2504 SourceLocation L) const {
2505 TypeSourceInfo *DI = CreateTypeSourceInfo(T);
2506 DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L);
2507 return DI;
2508}
2509
2510const ASTRecordLayout &
2511ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const {
2512 return getObjCLayout(D, nullptr);
2513}
2514
2515const ASTRecordLayout &
2516ASTContext::getASTObjCImplementationLayout(
2517 const ObjCImplementationDecl *D) const {
2518 return getObjCLayout(D->getClassInterface(), D);
2519}
2520
2521//===----------------------------------------------------------------------===//
2522// Type creation/memoization methods
2523//===----------------------------------------------------------------------===//
2524
2525QualType
2526ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
2527 unsigned fastQuals = quals.getFastQualifiers();
2528 quals.removeFastQualifiers();
2529
2530 // Check if we've already instantiated this type.
2531 llvm::FoldingSetNodeID ID;
2532 ExtQuals::Profile(ID, baseType, quals);
2533 void *insertPos = nullptr;
2534 if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
2535 assert(eq->getQualifiers() == quals)(static_cast <bool> (eq->getQualifiers() == quals) ?
void (0) : __assert_fail ("eq->getQualifiers() == quals",
"/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2535, __extension__ __PRETTY_FUNCTION__))
;
2536 return QualType(eq, fastQuals);
2537 }
2538
2539 // If the base type is not canonical, make the appropriate canonical type.
2540 QualType canon;
2541 if (!baseType->isCanonicalUnqualified()) {
2542 SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split();
2543 canonSplit.Quals.addConsistentQualifiers(quals);
2544 canon = getExtQualType(canonSplit.Ty, canonSplit.Quals);
2545
2546 // Re-find the insert position.
2547 (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
2548 }
2549
2550 auto *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
2551 ExtQualNodes.InsertNode(eq, insertPos);
2552 return QualType(eq, fastQuals);
2553}
2554
2555QualType ASTContext::getAddrSpaceQualType(QualType T,
2556 LangAS AddressSpace) const {
2557 QualType CanT = getCanonicalType(T);
2558 if (CanT.getAddressSpace() == AddressSpace)
2559 return T;
2560
2561 // If we are composing extended qualifiers together, merge together
2562 // into one ExtQuals node.
2563 QualifierCollector Quals;
2564 const Type *TypeNode = Quals.strip(T);
2565
2566 // If this type already has an address space specified, it cannot get
2567 // another one.
2568 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2569, __extension__ __PRETTY_FUNCTION__))
2569 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2569, __extension__ __PRETTY_FUNCTION__))
;
2570 Quals.addAddressSpace(AddressSpace);
2571
2572 return getExtQualType(TypeNode, Quals);
2573}
2574
2575QualType ASTContext::removeAddrSpaceQualType(QualType T) const {
2576 // If we are composing extended qualifiers together, merge together
2577 // into one ExtQuals node.
2578 QualifierCollector Quals;
2579 const Type *TypeNode = Quals.strip(T);
2580
2581 // If the qualifier doesn't have an address space just return it.
2582 if (!Quals.hasAddressSpace())
2583 return T;
2584
2585 Quals.removeAddressSpace();
2586
2587 // Removal of the address space can mean there are no longer any
2588 // non-fast qualifiers, so creating an ExtQualType isn't possible (asserts)
2589 // or required.
2590 if (Quals.hasNonFastQualifiers())
2591 return getExtQualType(TypeNode, Quals);
2592 else
2593 return QualType(TypeNode, Quals.getFastQualifiers());
2594}
2595
2596QualType ASTContext::getObjCGCQualType(QualType T,
2597 Qualifiers::GC GCAttr) const {
2598 QualType CanT = getCanonicalType(T);
2599 if (CanT.getObjCGCAttr() == GCAttr)
2600 return T;
2601
2602 if (const auto *ptr = T->getAs<PointerType>()) {
2603 QualType Pointee = ptr->getPointeeType();
2604 if (Pointee->isAnyPointerType()) {
2605 QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
2606 return getPointerType(ResultType);
2607 }
2608 }
2609
2610 // If we are composing extended qualifiers together, merge together
2611 // into one ExtQuals node.
2612 QualifierCollector Quals;
2613 const Type *TypeNode = Quals.strip(T);
2614
2615 // If this type already has an ObjCGC specified, it cannot get
2616 // another one.
2617 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2618, __extension__ __PRETTY_FUNCTION__))
2618 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2618, __extension__ __PRETTY_FUNCTION__))
;
2619 Quals.addObjCGCAttr(GCAttr);
2620
2621 return getExtQualType(TypeNode, Quals);
2622}
2623
2624const FunctionType *ASTContext::adjustFunctionType(const FunctionType *T,
2625 FunctionType::ExtInfo Info) {
2626 if (T->getExtInfo() == Info)
2627 return T;
2628
2629 QualType Result;
2630 if (const auto *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
2631 Result = getFunctionNoProtoType(FNPT->getReturnType(), Info);
2632 } else {
2633 const auto *FPT = cast<FunctionProtoType>(T);
2634 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
2635 EPI.ExtInfo = Info;
2636 Result = getFunctionType(FPT->getReturnType(), FPT->getParamTypes(), EPI);
2637 }
2638
2639 return cast<FunctionType>(Result.getTypePtr());
2640}
2641
2642void ASTContext::adjustDeducedFunctionResultType(FunctionDecl *FD,
2643 QualType ResultType) {
2644 FD = FD->getMostRecentDecl();
2645 while (true) {
2646 const auto *FPT = FD->getType()->castAs<FunctionProtoType>();
2647 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
2648 FD->setType(getFunctionType(ResultType, FPT->getParamTypes(), EPI));
2649 if (FunctionDecl *Next = FD->getPreviousDecl())
2650 FD = Next;
2651 else
2652 break;
2653 }
2654 if (ASTMutationListener *L = getASTMutationListener())
2655 L->DeducedReturnType(FD, ResultType);
2656}
2657
2658/// Get a function type and produce the equivalent function type with the
2659/// specified exception specification. Type sugar that can be present on a
2660/// declaration of a function with an exception specification is permitted
2661/// and preserved. Other type sugar (for instance, typedefs) is not.
2662QualType ASTContext::getFunctionTypeWithExceptionSpec(
2663 QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) {
2664 // Might have some parens.
2665 if (const auto *PT = dyn_cast<ParenType>(Orig))
2666 return getParenType(
2667 getFunctionTypeWithExceptionSpec(PT->getInnerType(), ESI));
2668
2669 // Might have a calling-convention attribute.
2670 if (const auto *AT = dyn_cast<AttributedType>(Orig))
2671 return getAttributedType(
2672 AT->getAttrKind(),
2673 getFunctionTypeWithExceptionSpec(AT->getModifiedType(), ESI),
2674 getFunctionTypeWithExceptionSpec(AT->getEquivalentType(), ESI));
2675
2676 // Anything else must be a function type. Rebuild it with the new exception
2677 // specification.
2678 const auto *Proto = cast<FunctionProtoType>(Orig);
2679 return getFunctionType(
2680 Proto->getReturnType(), Proto->getParamTypes(),
2681 Proto->getExtProtoInfo().withExceptionSpec(ESI));
2682}
2683
2684bool ASTContext::hasSameFunctionTypeIgnoringExceptionSpec(QualType T,
2685 QualType U) {
2686 return hasSameType(T, U) ||
2687 (getLangOpts().CPlusPlus17 &&
2688 hasSameType(getFunctionTypeWithExceptionSpec(T, EST_None),
2689 getFunctionTypeWithExceptionSpec(U, EST_None)));
2690}
2691
2692void ASTContext::adjustExceptionSpec(
2693 FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI,
2694 bool AsWritten) {
2695 // Update the type.
2696 QualType Updated =
2697 getFunctionTypeWithExceptionSpec(FD->getType(), ESI);
2698 FD->setType(Updated);
2699
2700 if (!AsWritten)
2701 return;
2702
2703 // Update the type in the type source information too.
2704 if (TypeSourceInfo *TSInfo = FD->getTypeSourceInfo()) {
2705 // If the type and the type-as-written differ, we may need to update
2706 // the type-as-written too.
2707 if (TSInfo->getType() != FD->getType())
2708 Updated = getFunctionTypeWithExceptionSpec(TSInfo->getType(), ESI);
2709
2710 // FIXME: When we get proper type location information for exceptions,
2711 // we'll also have to rebuild the TypeSourceInfo. For now, we just patch
2712 // up the TypeSourceInfo;
2713 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2715, __extension__ __PRETTY_FUNCTION__))
2714 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2715, __extension__ __PRETTY_FUNCTION__))
2715 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2715, __extension__ __PRETTY_FUNCTION__))
;
2716 TSInfo->overrideType(Updated);
2717 }
2718}
2719
2720/// getComplexType - Return the uniqued reference to the type for a complex
2721/// number with the specified element type.
2722QualType ASTContext::getComplexType(QualType T) const {
2723 // Unique pointers, to guarantee there is only one pointer of a particular
2724 // structure.
2725 llvm::FoldingSetNodeID ID;
2726 ComplexType::Profile(ID, T);
2727
2728 void *InsertPos = nullptr;
2729 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
2730 return QualType(CT, 0);
2731
2732 // If the pointee type isn't canonical, this won't be a canonical type either,
2733 // so fill in the canonical type field.
2734 QualType Canonical;
2735 if (!T.isCanonical()) {
2736 Canonical = getComplexType(getCanonicalType(T));
2737
2738 // Get the new insert position for the node we care about.
2739 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
2740 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2740, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
2741 }
2742 auto *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
2743 Types.push_back(New);
2744 ComplexTypes.InsertNode(New, InsertPos);
2745 return QualType(New, 0);
2746}
2747
2748/// getPointerType - Return the uniqued reference to the type for a pointer to
2749/// the specified type.
2750QualType ASTContext::getPointerType(QualType T) const {
2751 // Unique pointers, to guarantee there is only one pointer of a particular
2752 // structure.
2753 llvm::FoldingSetNodeID ID;
2754 PointerType::Profile(ID, T);
2755
2756 void *InsertPos = nullptr;
2757 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2758 return QualType(PT, 0);
2759
2760 // If the pointee type isn't canonical, this won't be a canonical type either,
2761 // so fill in the canonical type field.
2762 QualType Canonical;
2763 if (!T.isCanonical()) {
2764 Canonical = getPointerType(getCanonicalType(T));
2765
2766 // Get the new insert position for the node we care about.
2767 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2768 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2768, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
2769 }
2770 auto *New = new (*this, TypeAlignment) PointerType(T, Canonical);
2771 Types.push_back(New);
2772 PointerTypes.InsertNode(New, InsertPos);
2773 return QualType(New, 0);
2774}
2775
2776QualType ASTContext::getAdjustedType(QualType Orig, QualType New) const {
2777 llvm::FoldingSetNodeID ID;
2778 AdjustedType::Profile(ID, Orig, New);
2779 void *InsertPos = nullptr;
2780 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2781 if (AT)
2782 return QualType(AT, 0);
2783
2784 QualType Canonical = getCanonicalType(New);
2785
2786 // Get the new insert position for the node we care about.
2787 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2788 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2788, __extension__ __PRETTY_FUNCTION__))
;
2789
2790 AT = new (*this, TypeAlignment)
2791 AdjustedType(Type::Adjusted, Orig, New, Canonical);
2792 Types.push_back(AT);
2793 AdjustedTypes.InsertNode(AT, InsertPos);
2794 return QualType(AT, 0);
2795}
2796
2797QualType ASTContext::getDecayedType(QualType T) const {
2798 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2798, __extension__ __PRETTY_FUNCTION__))
;
2799
2800 QualType Decayed;
2801
2802 // C99 6.7.5.3p7:
2803 // A declaration of a parameter as "array of type" shall be
2804 // adjusted to "qualified pointer to type", where the type
2805 // qualifiers (if any) are those specified within the [ and ] of
2806 // the array type derivation.
2807 if (T->isArrayType())
2808 Decayed = getArrayDecayedType(T);
2809
2810 // C99 6.7.5.3p8:
2811 // A declaration of a parameter as "function returning type"
2812 // shall be adjusted to "pointer to function returning type", as
2813 // in 6.3.2.1.
2814 if (T->isFunctionType())
2815 Decayed = getPointerType(T);
2816
2817 llvm::FoldingSetNodeID ID;
2818 AdjustedType::Profile(ID, T, Decayed);
2819 void *InsertPos = nullptr;
2820 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2821 if (AT)
2822 return QualType(AT, 0);
2823
2824 QualType Canonical = getCanonicalType(Decayed);
2825
2826 // Get the new insert position for the node we care about.
2827 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2828 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2828, __extension__ __PRETTY_FUNCTION__))
;
2829
2830 AT = new (*this, TypeAlignment) DecayedType(T, Decayed, Canonical);
2831 Types.push_back(AT);
2832 AdjustedTypes.InsertNode(AT, InsertPos);
2833 return QualType(AT, 0);
2834}
2835
2836/// getBlockPointerType - Return the uniqued reference to the type for
2837/// a pointer to the specified block.
2838QualType ASTContext::getBlockPointerType(QualType T) const {
2839 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2839, __extension__ __PRETTY_FUNCTION__))
;
2840 // Unique pointers, to guarantee there is only one block of a particular
2841 // structure.
2842 llvm::FoldingSetNodeID ID;
2843 BlockPointerType::Profile(ID, T);
2844
2845 void *InsertPos = nullptr;
2846 if (BlockPointerType *PT =
2847 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2848 return QualType(PT, 0);
2849
2850 // If the block pointee type isn't canonical, this won't be a canonical
2851 // type either so fill in the canonical type field.
2852 QualType Canonical;
2853 if (!T.isCanonical()) {
2854 Canonical = getBlockPointerType(getCanonicalType(T));
2855
2856 // Get the new insert position for the node we care about.
2857 BlockPointerType *NewIP =
2858 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2859 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2859, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
2860 }
2861 auto *New = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
2862 Types.push_back(New);
2863 BlockPointerTypes.InsertNode(New, InsertPos);
2864 return QualType(New, 0);
2865}
2866
2867/// getLValueReferenceType - Return the uniqued reference to the type for an
2868/// lvalue reference to the specified type.
2869QualType
2870ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const {
2871 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2872, __extension__ __PRETTY_FUNCTION__))
2872 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2872, __extension__ __PRETTY_FUNCTION__))
;
2873
2874 // Unique pointers, to guarantee there is only one pointer of a particular
2875 // structure.
2876 llvm::FoldingSetNodeID ID;
2877 ReferenceType::Profile(ID, T, SpelledAsLValue);
2878
2879 void *InsertPos = nullptr;
2880 if (LValueReferenceType *RT =
2881 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2882 return QualType(RT, 0);
2883
2884 const auto *InnerRef = T->getAs<ReferenceType>();
2885
2886 // If the referencee type isn't canonical, this won't be a canonical type
2887 // either, so fill in the canonical type field.
2888 QualType Canonical;
2889 if (!SpelledAsLValue || InnerRef || !T.isCanonical()) {
2890 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2891 Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
2892
2893 // Get the new insert position for the node we care about.
2894 LValueReferenceType *NewIP =
2895 LValueReferenceTypes.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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2896, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
2897 }
2898
2899 auto *New = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
2900 SpelledAsLValue);
2901 Types.push_back(New);
2902 LValueReferenceTypes.InsertNode(New, InsertPos);
2903
2904 return QualType(New, 0);
2905}
2906
2907/// getRValueReferenceType - Return the uniqued reference to the type for an
2908/// rvalue reference to the specified type.
2909QualType ASTContext::getRValueReferenceType(QualType T) const {
2910 // Unique pointers, to guarantee there is only one pointer of a particular
2911 // structure.
2912 llvm::FoldingSetNodeID ID;
2913 ReferenceType::Profile(ID, T, false);
2914
2915 void *InsertPos = nullptr;
2916 if (RValueReferenceType *RT =
2917 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2918 return QualType(RT, 0);
2919
2920 const auto *InnerRef = T->getAs<ReferenceType>();
2921
2922 // If the referencee type isn't canonical, this won't be a canonical type
2923 // either, so fill in the canonical type field.
2924 QualType Canonical;
2925 if (InnerRef || !T.isCanonical()) {
2926 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2927 Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
2928
2929 // Get the new insert position for the node we care about.
2930 RValueReferenceType *NewIP =
2931 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
2932 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2932, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
2933 }
2934
2935 auto *New = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
2936 Types.push_back(New);
2937 RValueReferenceTypes.InsertNode(New, InsertPos);
2938 return QualType(New, 0);
2939}
2940
2941/// getMemberPointerType - Return the uniqued reference to the type for a
2942/// member pointer to the specified type, in the specified class.
2943QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const {
2944 // Unique pointers, to guarantee there is only one pointer of a particular
2945 // structure.
2946 llvm::FoldingSetNodeID ID;
2947 MemberPointerType::Profile(ID, T, Cls);
2948
2949 void *InsertPos = nullptr;
2950 if (MemberPointerType *PT =
2951 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2952 return QualType(PT, 0);
2953
2954 // If the pointee or class type isn't canonical, this won't be a canonical
2955 // type either, so fill in the canonical type field.
2956 QualType Canonical;
2957 if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
2958 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
2959
2960 // Get the new insert position for the node we care about.
2961 MemberPointerType *NewIP =
2962 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2963 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2963, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
2964 }
2965 auto *New = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
2966 Types.push_back(New);
2967 MemberPointerTypes.InsertNode(New, InsertPos);
2968 return QualType(New, 0);
2969}
2970
2971/// getConstantArrayType - Return the unique reference to the type for an
2972/// array of the specified element type.
2973QualType ASTContext::getConstantArrayType(QualType EltTy,
2974 const llvm::APInt &ArySizeIn,
2975 ArrayType::ArraySizeModifier ASM,
2976 unsigned IndexTypeQuals) const {
2977 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2979, __extension__ __PRETTY_FUNCTION__))
2978 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2979, __extension__ __PRETTY_FUNCTION__))
2979 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 2979, __extension__ __PRETTY_FUNCTION__))
;
2980
2981 // Convert the array size into a canonical width matching the pointer size for
2982 // the target.
2983 llvm::APInt ArySize(ArySizeIn);
2984 ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());
2985
2986 llvm::FoldingSetNodeID ID;
2987 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals);
2988
2989 void *InsertPos = nullptr;
2990 if (ConstantArrayType *ATP =
2991 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
2992 return QualType(ATP, 0);
2993
2994 // If the element type isn't canonical or has qualifiers, this won't
2995 // be a canonical type either, so fill in the canonical type field.
2996 QualType Canon;
2997 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
2998 SplitQualType canonSplit = getCanonicalType(EltTy).split();
2999 Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize,
3000 ASM, IndexTypeQuals);
3001 Canon = getQualifiedType(Canon, canonSplit.Quals);
3002
3003 // Get the new insert position for the node we care about.
3004 ConstantArrayType *NewIP =
3005 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
3006 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3006, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
3007 }
3008
3009 auto *New = new (*this,TypeAlignment)
3010 ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals);
3011 ConstantArrayTypes.InsertNode(New, InsertPos);
3012 Types.push_back(New);
3013 return QualType(New, 0);
3014}
3015
3016/// getVariableArrayDecayedType - Turns the given type, which may be
3017/// variably-modified, into the corresponding type with all the known
3018/// sizes replaced with [*].
3019QualType ASTContext::getVariableArrayDecayedType(QualType type) const {
3020 // Vastly most common case.
3021 if (!type->isVariablyModifiedType()) return type;
3022
3023 QualType result;
3024
3025 SplitQualType split = type.getSplitDesugaredType();
3026 const Type *ty = split.Ty;
3027 switch (ty->getTypeClass()) {
3028#define TYPE(Class, Base)
3029#define ABSTRACT_TYPE(Class, Base)
3030#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3031#include "clang/AST/TypeNodes.def"
3032 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3032)
;
3033
3034 // These types should never be variably-modified.
3035 case Type::Builtin:
3036 case Type::Complex:
3037 case Type::Vector:
3038 case Type::DependentVector:
3039 case Type::ExtVector:
3040 case Type::DependentSizedExtVector:
3041 case Type::DependentAddressSpace:
3042 case Type::ObjCObject:
3043 case Type::ObjCInterface:
3044 case Type::ObjCObjectPointer:
3045 case Type::Record:
3046 case Type::Enum:
3047 case Type::UnresolvedUsing:
3048 case Type::TypeOfExpr:
3049 case Type::TypeOf:
3050 case Type::Decltype:
3051 case Type::UnaryTransform:
3052 case Type::DependentName:
3053 case Type::InjectedClassName:
3054 case Type::TemplateSpecialization:
3055 case Type::DependentTemplateSpecialization:
3056 case Type::TemplateTypeParm:
3057 case Type::SubstTemplateTypeParmPack:
3058 case Type::Auto:
3059 case Type::DeducedTemplateSpecialization:
3060 case Type::PackExpansion:
3061 llvm_unreachable("type should never be variably-modified")::llvm::llvm_unreachable_internal("type should never be variably-modified"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3061)
;
3062
3063 // These types can be variably-modified but should never need to
3064 // further decay.
3065 case Type::FunctionNoProto:
3066 case Type::FunctionProto:
3067 case Type::BlockPointer:
3068 case Type::MemberPointer:
3069 case Type::Pipe:
3070 return type;
3071
3072 // These types can be variably-modified. All these modifications
3073 // preserve structure except as noted by comments.
3074 // TODO: if we ever care about optimizing VLAs, there are no-op
3075 // optimizations available here.
3076 case Type::Pointer:
3077 result = getPointerType(getVariableArrayDecayedType(
3078 cast<PointerType>(ty)->getPointeeType()));
3079 break;
3080
3081 case Type::LValueReference: {
3082 const auto *lv = cast<LValueReferenceType>(ty);
3083 result = getLValueReferenceType(
3084 getVariableArrayDecayedType(lv->getPointeeType()),
3085 lv->isSpelledAsLValue());
3086 break;
3087 }
3088
3089 case Type::RValueReference: {
3090 const auto *lv = cast<RValueReferenceType>(ty);
3091 result = getRValueReferenceType(
3092 getVariableArrayDecayedType(lv->getPointeeType()));
3093 break;
3094 }
3095
3096 case Type::Atomic: {
3097 const auto *at = cast<AtomicType>(ty);
3098 result = getAtomicType(getVariableArrayDecayedType(at->getValueType()));
3099 break;
3100 }
3101
3102 case Type::ConstantArray: {
3103 const auto *cat = cast<ConstantArrayType>(ty);
3104 result = getConstantArrayType(
3105 getVariableArrayDecayedType(cat->getElementType()),
3106 cat->getSize(),
3107 cat->getSizeModifier(),
3108 cat->getIndexTypeCVRQualifiers());
3109 break;
3110 }
3111
3112 case Type::DependentSizedArray: {
3113 const auto *dat = cast<DependentSizedArrayType>(ty);
3114 result = getDependentSizedArrayType(
3115 getVariableArrayDecayedType(dat->getElementType()),
3116 dat->getSizeExpr(),
3117 dat->getSizeModifier(),
3118 dat->getIndexTypeCVRQualifiers(),
3119 dat->getBracketsRange());
3120 break;
3121 }
3122
3123 // Turn incomplete types into [*] types.
3124 case Type::IncompleteArray: {
3125 const auto *iat = cast<IncompleteArrayType>(ty);
3126 result = getVariableArrayType(
3127 getVariableArrayDecayedType(iat->getElementType()),
3128 /*size*/ nullptr,
3129 ArrayType::Normal,
3130 iat->getIndexTypeCVRQualifiers(),
3131 SourceRange());
3132 break;
3133 }
3134
3135 // Turn VLA types into [*] types.
3136 case Type::VariableArray: {
3137 const auto *vat = cast<VariableArrayType>(ty);
3138 result = getVariableArrayType(
3139 getVariableArrayDecayedType(vat->getElementType()),
3140 /*size*/ nullptr,
3141 ArrayType::Star,
3142 vat->getIndexTypeCVRQualifiers(),
3143 vat->getBracketsRange());
3144 break;
3145 }
3146 }
3147
3148 // Apply the top-level qualifiers from the original.
3149 return getQualifiedType(result, split.Quals);
3150}
3151
3152/// getVariableArrayType - Returns a non-unique reference to the type for a
3153/// variable array of the specified element type.
3154QualType ASTContext::getVariableArrayType(QualType EltTy,
3155 Expr *NumElts,
3156 ArrayType::ArraySizeModifier ASM,
3157 unsigned IndexTypeQuals,
3158 SourceRange Brackets) const {
3159 // Since we don't unique expressions, it isn't possible to unique VLA's
3160 // that have an expression provided for their size.
3161 QualType Canon;
3162
3163 // Be sure to pull qualifiers off the element type.
3164 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
3165 SplitQualType canonSplit = getCanonicalType(EltTy).split();
3166 Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM,
3167 IndexTypeQuals, Brackets);
3168 Canon = getQualifiedType(Canon, canonSplit.Quals);
3169 }
3170
3171 auto *New = new (*this, TypeAlignment)
3172 VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);
3173
3174 VariableArrayTypes.push_back(New);
3175 Types.push_back(New);
3176 return QualType(New, 0);
3177}
3178
3179/// getDependentSizedArrayType - Returns a non-unique reference to
3180/// the type for a dependently-sized array of the specified element
3181/// type.
3182QualType ASTContext::getDependentSizedArrayType(QualType elementType,
3183 Expr *numElements,
3184 ArrayType::ArraySizeModifier ASM,
3185 unsigned elementTypeQuals,
3186 SourceRange brackets) const {
3187 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3189, __extension__ __PRETTY_FUNCTION__))
3188 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3189, __extension__ __PRETTY_FUNCTION__))
3189 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3189, __extension__ __PRETTY_FUNCTION__))
;
3190
3191 // Dependently-sized array types that do not have a specified number
3192 // of elements will have their sizes deduced from a dependent
3193 // initializer. We do no canonicalization here at all, which is okay
3194 // because they can't be used in most locations.
3195 if (!numElements) {
3196 auto *newType
3197 = new (*this, TypeAlignment)
3198 DependentSizedArrayType(*this, elementType, QualType(),
3199 numElements, ASM, elementTypeQuals,
3200 brackets);
3201 Types.push_back(newType);
3202 return QualType(newType, 0);
3203 }
3204
3205 // Otherwise, we actually build a new type every time, but we
3206 // also build a canonical type.
3207
3208 SplitQualType canonElementType = getCanonicalType(elementType).split();
3209
3210 void *insertPos = nullptr;
3211 llvm::FoldingSetNodeID ID;
3212 DependentSizedArrayType::Profile(ID, *this,
3213 QualType(canonElementType.Ty, 0),
3214 ASM, elementTypeQuals, numElements);
3215
3216 // Look for an existing type with these properties.
3217 DependentSizedArrayType *canonTy =
3218 DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3219
3220 // If we don't have one, build one.
3221 if (!canonTy) {
3222 canonTy = new (*this, TypeAlignment)
3223 DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0),
3224 QualType(), numElements, ASM, elementTypeQuals,
3225 brackets);
3226 DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
3227 Types.push_back(canonTy);
3228 }
3229
3230 // Apply qualifiers from the element type to the array.
3231 QualType canon = getQualifiedType(QualType(canonTy,0),
3232 canonElementType.Quals);
3233
3234 // If we didn't need extra canonicalization for the element type or the size
3235 // expression, then just use that as our result.
3236 if (QualType(canonElementType.Ty, 0) == elementType &&
3237 canonTy->getSizeExpr() == numElements)
3238 return canon;
3239
3240 // Otherwise, we need to build a type which follows the spelling
3241 // of the element type.
3242 auto *sugaredType
3243 = new (*this, TypeAlignment)
3244 DependentSizedArrayType(*this, elementType, canon, numElements,
3245 ASM, elementTypeQuals, brackets);
3246 Types.push_back(sugaredType);
3247 return QualType(sugaredType, 0);
3248}
3249
3250QualType ASTContext::getIncompleteArrayType(QualType elementType,
3251 ArrayType::ArraySizeModifier ASM,
3252 unsigned elementTypeQuals) const {
3253 llvm::FoldingSetNodeID ID;
3254 IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals);
3255
3256 void *insertPos = nullptr;
3257 if (IncompleteArrayType *iat =
3258 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
3259 return QualType(iat, 0);
3260
3261 // If the element type isn't canonical, this won't be a canonical type
3262 // either, so fill in the canonical type field. We also have to pull
3263 // qualifiers off the element type.
3264 QualType canon;
3265
3266 if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) {
3267 SplitQualType canonSplit = getCanonicalType(elementType).split();
3268 canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0),
3269 ASM, elementTypeQuals);
3270 canon = getQualifiedType(canon, canonSplit.Quals);
3271
3272 // Get the new insert position for the node we care about.
3273 IncompleteArrayType *existing =
3274 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3275 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3275, __extension__ __PRETTY_FUNCTION__))
; (void) existing;
3276 }
3277
3278 auto *newType = new (*this, TypeAlignment)
3279 IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);
3280
3281 IncompleteArrayTypes.InsertNode(newType, insertPos);
3282 Types.push_back(newType);
3283 return QualType(newType, 0);
3284}
3285
3286/// getVectorType - Return the unique reference to a vector type of
3287/// the specified element type and size. VectorType must be a built-in type.
3288QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts,
3289 VectorType::VectorKind VecKind) const {
3290 assert(vecType->isBuiltinType())(static_cast <bool> (vecType->isBuiltinType()) ? void
(0) : __assert_fail ("vecType->isBuiltinType()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3290, __extension__ __PRETTY_FUNCTION__))
;
3291
3292 // Check if we've already instantiated a vector of this type.
3293 llvm::FoldingSetNodeID ID;
3294 VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind);
3295
3296 void *InsertPos = nullptr;
3297 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3298 return QualType(VTP, 0);
3299
3300 // If the element type isn't canonical, this won't be a canonical type either,
3301 // so fill in the canonical type field.
3302 QualType Canonical;
3303 if (!vecType.isCanonical()) {
3304 Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind);
3305
3306 // Get the new insert position for the node we care about.
3307 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3308 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3308, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
3309 }
3310 auto *New = new (*this, TypeAlignment)
3311 VectorType(vecType, NumElts, Canonical, VecKind);
3312 VectorTypes.InsertNode(New, InsertPos);
3313 Types.push_back(New);
3314 return QualType(New, 0);
3315}
3316
3317QualType
3318ASTContext::getDependentVectorType(QualType VecType, Expr *SizeExpr,
3319 SourceLocation AttrLoc,
3320 VectorType::VectorKind VecKind) const {
3321 llvm::FoldingSetNodeID ID;
3322 DependentVectorType::Profile(ID, *this, getCanonicalType(VecType), SizeExpr,
3323 VecKind);
3324 void *InsertPos = nullptr;
3325 DependentVectorType *Canon =
3326 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3327 DependentVectorType *New;
3328
3329 if (Canon) {
3330 New = new (*this, TypeAlignment) DependentVectorType(
3331 *this, VecType, QualType(Canon, 0), SizeExpr, AttrLoc, VecKind);
3332 } else {
3333 QualType CanonVecTy = getCanonicalType(VecType);
3334 if (CanonVecTy == VecType) {
3335 New = new (*this, TypeAlignment) DependentVectorType(
3336 *this, VecType, QualType(), SizeExpr, AttrLoc, VecKind);
3337
3338 DependentVectorType *CanonCheck =
3339 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3340 assert(!CanonCheck &&(static_cast <bool> (!CanonCheck && "Dependent-sized vector_size canonical type broken"
) ? void (0) : __assert_fail ("!CanonCheck && \"Dependent-sized vector_size canonical type broken\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3341, __extension__ __PRETTY_FUNCTION__))
3341 "Dependent-sized vector_size canonical type broken")(static_cast <bool> (!CanonCheck && "Dependent-sized vector_size canonical type broken"
) ? void (0) : __assert_fail ("!CanonCheck && \"Dependent-sized vector_size canonical type broken\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3341, __extension__ __PRETTY_FUNCTION__))
;
3342 (void)CanonCheck;
3343 DependentVectorTypes.InsertNode(New, InsertPos);
3344 } else {
3345 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
3346 SourceLocation());
3347 New = new (*this, TypeAlignment) DependentVectorType(
3348 *this, VecType, Canon, SizeExpr, AttrLoc, VecKind);
3349 }
3350 }
3351
3352 Types.push_back(New);
3353 return QualType(New, 0);
3354}
3355
3356/// getExtVectorType - Return the unique reference to an extended vector type of
3357/// the specified element type and size. VectorType must be a built-in type.
3358QualType
3359ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const {
3360 assert(vecType->isBuiltinType() || vecType->isDependentType())(static_cast <bool> (vecType->isBuiltinType() || vecType
->isDependentType()) ? void (0) : __assert_fail ("vecType->isBuiltinType() || vecType->isDependentType()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3360, __extension__ __PRETTY_FUNCTION__))
;
3361
3362 // Check if we've already instantiated a vector of this type.
3363 llvm::FoldingSetNodeID ID;
3364 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
3365 VectorType::GenericVector);
3366 void *InsertPos = nullptr;
3367 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3368 return QualType(VTP, 0);
3369
3370 // If the element type isn't canonical, this won't be a canonical type either,
3371 // so fill in the canonical type field.
3372 QualType Canonical;
3373 if (!vecType.isCanonical()) {
3374 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
3375
3376 // Get the new insert position for the node we care about.
3377 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3378 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3378, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
3379 }
3380 auto *New = new (*this, TypeAlignment)
3381 ExtVectorType(vecType, NumElts, Canonical);
3382 VectorTypes.InsertNode(New, InsertPos);
3383 Types.push_back(New);
3384 return QualType(New, 0);
3385}
3386
3387QualType
3388ASTContext::getDependentSizedExtVectorType(QualType vecType,
3389 Expr *SizeExpr,
3390 SourceLocation AttrLoc) const {
3391 llvm::FoldingSetNodeID ID;
3392 DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType),
3393 SizeExpr);
3394
3395 void *InsertPos = nullptr;
3396 DependentSizedExtVectorType *Canon
3397 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3398 DependentSizedExtVectorType *New;
3399 if (Canon) {
3400 // We already have a canonical version of this array type; use it as
3401 // the canonical type for a newly-built type.
3402 New = new (*this, TypeAlignment)
3403 DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
3404 SizeExpr, AttrLoc);
3405 } else {
3406 QualType CanonVecTy = getCanonicalType(vecType);
3407 if (CanonVecTy == vecType) {
3408 New = new (*this, TypeAlignment)
3409 DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
3410 AttrLoc);
3411
3412 DependentSizedExtVectorType *CanonCheck
3413 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3414 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3414, __extension__ __PRETTY_FUNCTION__))
;
3415 (void)CanonCheck;
3416 DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
3417 } else {
3418 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
3419 SourceLocation());
3420 New = new (*this, TypeAlignment)
3421 DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc);
3422 }
3423 }
3424
3425 Types.push_back(New);
3426 return QualType(New, 0);
3427}
3428
3429QualType ASTContext::getDependentAddressSpaceType(QualType PointeeType,
3430 Expr *AddrSpaceExpr,
3431 SourceLocation AttrLoc) const {
3432 assert(AddrSpaceExpr->isInstantiationDependent())(static_cast <bool> (AddrSpaceExpr->isInstantiationDependent
()) ? void (0) : __assert_fail ("AddrSpaceExpr->isInstantiationDependent()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3432, __extension__ __PRETTY_FUNCTION__))
;
3433
3434 QualType canonPointeeType = getCanonicalType(PointeeType);
3435
3436 void *insertPos = nullptr;
3437 llvm::FoldingSetNodeID ID;
3438 DependentAddressSpaceType::Profile(ID, *this, canonPointeeType,
3439 AddrSpaceExpr);
3440
3441 DependentAddressSpaceType *canonTy =
3442 DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
3443
3444 if (!canonTy) {
3445 canonTy = new (*this, TypeAlignment)
3446 DependentAddressSpaceType(*this, canonPointeeType,
3447 QualType(), AddrSpaceExpr, AttrLoc);
3448 DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
3449 Types.push_back(canonTy);
3450 }
3451
3452 if (canonPointeeType == PointeeType &&
3453 canonTy->getAddrSpaceExpr() == AddrSpaceExpr)
3454 return QualType(canonTy, 0);
3455
3456 auto *sugaredType
3457 = new (*this, TypeAlignment)
3458 DependentAddressSpaceType(*this, PointeeType, QualType(canonTy, 0),
3459 AddrSpaceExpr, AttrLoc);
3460 Types.push_back(sugaredType);
3461 return QualType(sugaredType, 0);
3462}
3463
3464/// Determine whether \p T is canonical as the result type of a function.
3465static bool isCanonicalResultType(QualType T) {
3466 return T.isCanonical() &&
3467 (T.getObjCLifetime() == Qualifiers::OCL_None ||
3468 T.getObjCLifetime() == Qualifiers::OCL_ExplicitNone);
3469}
3470
3471/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
3472QualType
3473ASTContext::getFunctionNoProtoType(QualType ResultTy,
3474 const FunctionType::ExtInfo &Info) const {
3475 // Unique functions, to guarantee there is only one function of a particular
3476 // structure.
3477 llvm::FoldingSetNodeID ID;
3478 FunctionNoProtoType::Profile(ID, ResultTy, Info);
3479
3480 void *InsertPos = nullptr;
3481 if (FunctionNoProtoType *FT =
3482 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
3483 return QualType(FT, 0);
3484
3485 QualType Canonical;
3486 if (!isCanonicalResultType(ResultTy)) {
3487 Canonical =
3488 getFunctionNoProtoType(getCanonicalFunctionResultType(ResultTy), Info);
3489
3490 // Get the new insert position for the node we care about.
3491 FunctionNoProtoType *NewIP =
3492 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3493 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3493, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
3494 }
3495
3496 auto *New = new (*this, TypeAlignment)
3497 FunctionNoProtoType(ResultTy, Canonical, Info);
3498 Types.push_back(New);
3499 FunctionNoProtoTypes.InsertNode(New, InsertPos);
3500 return QualType(New, 0);
3501}
3502
3503CanQualType
3504ASTContext::getCanonicalFunctionResultType(QualType ResultType) const {
3505 CanQualType CanResultType = getCanonicalType(ResultType);
3506
3507 // Canonical result types do not have ARC lifetime qualifiers.
3508 if (CanResultType.getQualifiers().hasObjCLifetime()) {
3509 Qualifiers Qs = CanResultType.getQualifiers();
3510 Qs.removeObjCLifetime();
3511 return CanQualType::CreateUnsafe(
3512 getQualifiedType(CanResultType.getUnqualifiedType(), Qs));
3513 }
3514
3515 return CanResultType;
3516}
3517
3518static bool isCanonicalExceptionSpecification(
3519 const FunctionProtoType::ExceptionSpecInfo &ESI, bool NoexceptInType) {
3520 if (ESI.Type == EST_None)
3521 return true;
3522 if (!NoexceptInType)
3523 return false;
3524
3525 // C++17 onwards: exception specification is part of the type, as a simple
3526 // boolean "can this function type throw".
3527 if (ESI.Type == EST_BasicNoexcept)
3528 return true;
3529
3530 // A noexcept(expr) specification is (possibly) canonical if expr is
3531 // value-dependent.
3532 if (ESI.Type == EST_DependentNoexcept)
3533 return true;
3534
3535 // A dynamic exception specification is canonical if it only contains pack
3536 // expansions (so we can't tell whether it's non-throwing) and all its
3537 // contained types are canonical.
3538 if (ESI.Type == EST_Dynamic) {
3539 bool AnyPackExpansions = false;
3540 for (QualType ET : ESI.Exceptions) {
3541 if (!ET.isCanonical())
3542 return false;
3543 if (ET->getAs<PackExpansionType>())
3544 AnyPackExpansions = true;
3545 }
3546 return AnyPackExpansions;
3547 }
3548
3549 return false;
3550}
3551
3552QualType ASTContext::getFunctionTypeInternal(
3553 QualType ResultTy, ArrayRef<QualType> ArgArray,
3554 const FunctionProtoType::ExtProtoInfo &EPI, bool OnlyWantCanonical) const {
3555 size_t NumArgs = ArgArray.size();
3556
3557 // Unique functions, to guarantee there is only one function of a particular
3558 // structure.
3559 llvm::FoldingSetNodeID ID;
3560 FunctionProtoType::Profile(ID, ResultTy, ArgArray.begin(), NumArgs, EPI,
3561 *this, true);
3562
3563 QualType Canonical;
3564 bool Unique = false;
3565
3566 void *InsertPos = nullptr;
3567 if (FunctionProtoType *FPT =
3568 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
3569 QualType Existing = QualType(FPT, 0);
3570
3571 // If we find a pre-existing equivalent FunctionProtoType, we can just reuse
3572 // it so long as our exception specification doesn't contain a dependent
3573 // noexcept expression, or we're just looking for a canonical type.
3574 // Otherwise, we're going to need to create a type
3575 // sugar node to hold the concrete expression.
3576 if (OnlyWantCanonical || !isComputedNoexcept(EPI.ExceptionSpec.Type) ||
3577 EPI.ExceptionSpec.NoexceptExpr == FPT->getNoexceptExpr())
3578 return Existing;
3579
3580 // We need a new type sugar node for this one, to hold the new noexcept
3581 // expression. We do no canonicalization here, but that's OK since we don't
3582 // expect to see the same noexcept expression much more than once.
3583 Canonical = getCanonicalType(Existing);
3584 Unique = true;
3585 }
3586
3587 bool NoexceptInType = getLangOpts().CPlusPlus17;
3588 bool IsCanonicalExceptionSpec =
3589 isCanonicalExceptionSpecification(EPI.ExceptionSpec, NoexceptInType);
3590
3591 // Determine whether the type being created is already canonical or not.
3592 bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
3593 isCanonicalResultType(ResultTy) && !EPI.HasTrailingReturn;
3594 for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
3595 if (!ArgArray[i].isCanonicalAsParam())
3596 isCanonical = false;
3597
3598 if (OnlyWantCanonical)
3599 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3600, __extension__ __PRETTY_FUNCTION__))
3600 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3600, __extension__ __PRETTY_FUNCTION__))
;
3601
3602 // If this type isn't canonical, get the canonical version of it if we don't
3603 // already have it. The exception spec is only partially part of the
3604 // canonical type, and only in C++17 onwards.
3605 if (!isCanonical && Canonical.isNull()) {
3606 SmallVector<QualType, 16> CanonicalArgs;
3607 CanonicalArgs.reserve(NumArgs);
3608 for (unsigned i = 0; i != NumArgs; ++i)
3609 CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));
3610
3611 llvm::SmallVector<QualType, 8> ExceptionTypeStorage;
3612 FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
3613 CanonicalEPI.HasTrailingReturn = false;
3614
3615 if (IsCanonicalExceptionSpec) {
3616 // Exception spec is already OK.
3617 } else if (NoexceptInType) {
3618 switch (EPI.ExceptionSpec.Type) {
3619 case EST_Unparsed: case EST_Unevaluated: case EST_Uninstantiated:
3620 // We don't know yet. It shouldn't matter what we pick here; no-one
3621 // should ever look at this.
3622 LLVM_FALLTHROUGH[[clang::fallthrough]];
3623 case EST_None: case EST_MSAny: case EST_NoexceptFalse:
3624 CanonicalEPI.ExceptionSpec.Type = EST_None;
3625 break;
3626
3627 // A dynamic exception specification is almost always "not noexcept",
3628 // with the exception that a pack expansion might expand to no types.
3629 case EST_Dynamic: {
3630 bool AnyPacks = false;
3631 for (QualType ET : EPI.ExceptionSpec.Exceptions) {
3632 if (ET->getAs<PackExpansionType>())
3633 AnyPacks = true;
3634 ExceptionTypeStorage.push_back(getCanonicalType(ET));
3635 }
3636 if (!AnyPacks)
3637 CanonicalEPI.ExceptionSpec.Type = EST_None;
3638 else {
3639 CanonicalEPI.ExceptionSpec.Type = EST_Dynamic;
3640 CanonicalEPI.ExceptionSpec.Exceptions = ExceptionTypeStorage;
3641 }
3642 break;
3643 }
3644
3645 case EST_DynamicNone: case EST_BasicNoexcept: case EST_NoexceptTrue:
3646 CanonicalEPI.ExceptionSpec.Type = EST_BasicNoexcept;
3647 break;
3648
3649 case EST_DependentNoexcept:
3650 llvm_unreachable("dependent noexcept is already canonical")::llvm::llvm_unreachable_internal("dependent noexcept is already canonical"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3650)
;
3651 }
3652 } else {
3653 CanonicalEPI.ExceptionSpec = FunctionProtoType::ExceptionSpecInfo();
3654 }
3655
3656 // Adjust the canonical function result type.
3657 CanQualType CanResultTy = getCanonicalFunctionResultType(ResultTy);
3658 Canonical =
3659 getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI, true);
3660
3661 // Get the new insert position for the node we care about.
3662 FunctionProtoType *NewIP =
3663 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3664 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3664, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
3665 }
3666
3667 // FunctionProtoType objects are allocated with extra bytes after
3668 // them for three variable size arrays at the end:
3669 // - parameter types
3670 // - exception types
3671 // - extended parameter information
3672 // Instead of the exception types, there could be a noexcept
3673 // expression, or information used to resolve the exception
3674 // specification.
3675 size_t Size =
3676 sizeof(FunctionProtoType) + NumArgs * sizeof(QualType) +
3677 FunctionProtoType::getExceptionSpecSize(
3678 EPI.ExceptionSpec.Type, EPI.ExceptionSpec.Exceptions.size());
3679
3680 // Put the ExtParameterInfos last. If all were equal, it would make
3681 // more sense to put these before the exception specification, because
3682 // it's much easier to skip past them compared to the elaborate switch
3683 // required to skip the exception specification. However, all is not
3684 // equal; ExtParameterInfos are used to model very uncommon features,
3685 // and it's better not to burden the more common paths.
3686 if (EPI.ExtParameterInfos) {
3687 Size += NumArgs * sizeof(FunctionProtoType::ExtParameterInfo);
3688 }
3689
3690 auto *FTP = (FunctionProtoType *) Allocate(Size, TypeAlignment);
3691 FunctionProtoType::ExtProtoInfo newEPI = EPI;
3692 new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
3693 Types.push_back(FTP);
3694 if (!Unique)
3695 FunctionProtoTypes.InsertNode(FTP, InsertPos);
3696 return QualType(FTP, 0);
3697}
3698
3699QualType ASTContext::getPipeType(QualType T, bool ReadOnly) const {
3700 llvm::FoldingSetNodeID ID;
3701 PipeType::Profile(ID, T, ReadOnly);
3702
3703 void *InsertPos = nullptr;
3704 if (PipeType *PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))
3705 return QualType(PT, 0);
3706
3707 // If the pipe element type isn't canonical, this won't be a canonical type
3708 // either, so fill in the canonical type field.
3709 QualType Canonical;
3710 if (!T.isCanonical()) {
3711 Canonical = getPipeType(getCanonicalType(T), ReadOnly);
3712
3713 // Get the new insert position for the node we care about.
3714 PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);
3715 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3715, __extension__ __PRETTY_FUNCTION__))
;
3716 (void)NewIP;
3717 }
3718 auto *New = new (*this, TypeAlignment) PipeType(T, Canonical, ReadOnly);
3719 Types.push_back(New);
3720 PipeTypes.InsertNode(New, InsertPos);
3721 return QualType(New, 0);
3722}
3723
3724QualType ASTContext::adjustStringLiteralBaseType(QualType Ty) const {
3725 // OpenCL v1.1 s6.5.3: a string literal is in the constant address space.
3726 return LangOpts.OpenCL ? getAddrSpaceQualType(Ty, LangAS::opencl_constant)
3727 : Ty;
3728}
3729
3730QualType ASTContext::getReadPipeType(QualType T) const {
3731 return getPipeType(T, true);
3732}
3733
3734QualType ASTContext::getWritePipeType(QualType T) const {
3735 return getPipeType(T, false);
3736}
3737
3738#ifndef NDEBUG
3739static bool NeedsInjectedClassNameType(const RecordDecl *D) {
3740 if (!isa<CXXRecordDecl>(D)) return false;
3741 const auto *RD = cast<CXXRecordDecl>(D);
3742 if (isa<ClassTemplatePartialSpecializationDecl>(RD))
3743 return true;
3744 if (RD->getDescribedClassTemplate() &&
3745 !isa<ClassTemplateSpecializationDecl>(RD))
3746 return true;
3747 return false;
3748}
3749#endif
3750
3751/// getInjectedClassNameType - Return the unique reference to the
3752/// injected class name type for the specified templated declaration.
3753QualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl,
3754 QualType TST) const {
3755 assert(NeedsInjectedClassNameType(Decl))(static_cast <bool> (NeedsInjectedClassNameType(Decl)) ?
void (0) : __assert_fail ("NeedsInjectedClassNameType(Decl)"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3755, __extension__ __PRETTY_FUNCTION__))
;
3756 if (Decl->TypeForDecl) {
3757 assert(isa<InjectedClassNameType>(Decl->TypeForDecl))(static_cast <bool> (isa<InjectedClassNameType>(Decl
->TypeForDecl)) ? void (0) : __assert_fail ("isa<InjectedClassNameType>(Decl->TypeForDecl)"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3757, __extension__ __PRETTY_FUNCTION__))
;
3758 } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) {
3759 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3759, __extension__ __PRETTY_FUNCTION__))
;
3760 Decl->TypeForDecl = PrevDecl->TypeForDecl;
3761 assert(isa<InjectedClassNameType>(Decl->TypeForDecl))(static_cast <bool> (isa<InjectedClassNameType>(Decl
->TypeForDecl)) ? void (0) : __assert_fail ("isa<InjectedClassNameType>(Decl->TypeForDecl)"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3761, __extension__ __PRETTY_FUNCTION__))
;
3762 } else {
3763 Type *newType =
3764 new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
3765 Decl->TypeForDecl = newType;
3766 Types.push_back(newType);
3767 }
3768 return QualType(Decl->TypeForDecl, 0);
3769}
3770
3771/// getTypeDeclType - Return the unique reference to the type for the
3772/// specified type declaration.
3773QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const {
3774 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3774, __extension__ __PRETTY_FUNCTION__))
;
3775 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3775, __extension__ __PRETTY_FUNCTION__))
;
3776
3777 if (const auto *Typedef = dyn_cast<TypedefNameDecl>(Decl))
3778 return getTypedefType(Typedef);
3779
3780 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3781, __extension__ __PRETTY_FUNCTION__))
3781 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3781, __extension__ __PRETTY_FUNCTION__))
;
3782
3783 if (const auto *Record = dyn_cast<RecordDecl>(Decl)) {
3784 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3784, __extension__ __PRETTY_FUNCTION__))
;
3785 assert(!NeedsInjectedClassNameType(Record))(static_cast <bool> (!NeedsInjectedClassNameType(Record
)) ? void (0) : __assert_fail ("!NeedsInjectedClassNameType(Record)"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3785, __extension__ __PRETTY_FUNCTION__))
;
3786 return getRecordType(Record);
3787 } else if (const auto *Enum = dyn_cast<EnumDecl>(Decl)) {
3788 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3788, __extension__ __PRETTY_FUNCTION__))
;
3789 return getEnumType(Enum);
3790 } else if (const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
3791 Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using);
3792 Decl->TypeForDecl = newType;
3793 Types.push_back(newType);
3794 } else
3795 llvm_unreachable("TypeDecl without a type?")::llvm::llvm_unreachable_internal("TypeDecl without a type?",
"/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3795)
;
3796
3797 return QualType(Decl->TypeForDecl, 0);
3798}
3799
3800/// getTypedefType - Return the unique reference to the type for the
3801/// specified typedef name decl.
3802QualType
3803ASTContext::getTypedefType(const TypedefNameDecl *Decl,
3804 QualType Canonical) const {
3805 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3806
3807 if (Canonical.isNull())
3808 Canonical = getCanonicalType(Decl->getUnderlyingType());
3809 auto *newType = new (*this, TypeAlignment)
3810 TypedefType(Type::Typedef, Decl, Canonical);
3811 Decl->TypeForDecl = newType;
3812 Types.push_back(newType);
3813 return QualType(newType, 0);
3814}
3815
3816QualType ASTContext::getRecordType(const RecordDecl *Decl) const {
3817 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3818
3819 if (const RecordDecl *PrevDecl = Decl->getPreviousDecl())
3820 if (PrevDecl->TypeForDecl)
3821 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3822
3823 auto *newType = new (*this, TypeAlignment) RecordType(Decl);
3824 Decl->TypeForDecl = newType;
3825 Types.push_back(newType);
3826 return QualType(newType, 0);
3827}
3828
3829QualType ASTContext::getEnumType(const EnumDecl *Decl) const {
3830 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3831
3832 if (const EnumDecl *PrevDecl = Decl->getPreviousDecl())
3833 if (PrevDecl->TypeForDecl)
3834 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3835
3836 auto *newType = new (*this, TypeAlignment) EnumType(Decl);
3837 Decl->TypeForDecl = newType;
3838 Types.push_back(newType);
3839 return QualType(newType, 0);
3840}
3841
3842QualType ASTContext::getAttributedType(AttributedType::Kind attrKind,
3843 QualType modifiedType,
3844 QualType equivalentType) {
3845 llvm::FoldingSetNodeID id;
3846 AttributedType::Profile(id, attrKind, modifiedType, equivalentType);
3847
3848 void *insertPos = nullptr;
3849 AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos);
3850 if (type) return QualType(type, 0);
3851
3852 QualType canon = getCanonicalType(equivalentType);
3853 type = new (*this, TypeAlignment)
3854 AttributedType(canon, attrKind, modifiedType, equivalentType);
3855
3856 Types.push_back(type);
3857 AttributedTypes.InsertNode(type, insertPos);
3858
3859 return QualType(type, 0);
3860}
3861
3862/// Retrieve a substitution-result type.
3863QualType
3864ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
3865 QualType Replacement) const {
3866 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3867, __extension__ __PRETTY_FUNCTION__))
3867 && "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3867, __extension__ __PRETTY_FUNCTION__))
;
3868
3869 llvm::FoldingSetNodeID ID;
3870 SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
3871 void *InsertPos = nullptr;
3872 SubstTemplateTypeParmType *SubstParm
3873 = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3874
3875 if (!SubstParm) {
3876 SubstParm = new (*this, TypeAlignment)
3877 SubstTemplateTypeParmType(Parm, Replacement);
3878 Types.push_back(SubstParm);
3879 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
3880 }
3881
3882 return QualType(SubstParm, 0);
3883}
3884
3885/// Retrieve a
3886QualType ASTContext::getSubstTemplateTypeParmPackType(
3887 const TemplateTypeParmType *Parm,
3888 const TemplateArgument &ArgPack) {
3889#ifndef NDEBUG
3890 for (const auto &P : ArgPack.pack_elements()) {
3891 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3891, __extension__ __PRETTY_FUNCTION__))
;
3892 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3892, __extension__ __PRETTY_FUNCTION__))
;
3893 }
3894#endif
3895
3896 llvm::FoldingSetNodeID ID;
3897 SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack);
3898 void *InsertPos = nullptr;
3899 if (SubstTemplateTypeParmPackType *SubstParm
3900 = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
3901 return QualType(SubstParm, 0);
3902
3903 QualType Canon;
3904 if (!Parm->isCanonicalUnqualified()) {
3905 Canon = getCanonicalType(QualType(Parm, 0));
3906 Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon),
3907 ArgPack);
3908 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
3909 }
3910
3911 auto *SubstParm
3912 = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon,
3913 ArgPack);
3914 Types.push_back(SubstParm);
3915 SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
3916 return QualType(SubstParm, 0);
3917}
3918
3919/// Retrieve the template type parameter type for a template
3920/// parameter or parameter pack with the given depth, index, and (optionally)
3921/// name.
3922QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
3923 bool ParameterPack,
3924 TemplateTypeParmDecl *TTPDecl) const {
3925 llvm::FoldingSetNodeID ID;
3926 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
3927 void *InsertPos = nullptr;
3928 TemplateTypeParmType *TypeParm
3929 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3930
3931 if (TypeParm)
3932 return QualType(TypeParm, 0);
3933
3934 if (TTPDecl) {
3935 QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
3936 TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon);
3937
3938 TemplateTypeParmType *TypeCheck
3939 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3940 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3940, __extension__ __PRETTY_FUNCTION__))
;
3941 (void)TypeCheck;
3942 } else
3943 TypeParm = new (*this, TypeAlignment)
3944 TemplateTypeParmType(Depth, Index, ParameterPack);
3945
3946 Types.push_back(TypeParm);
3947 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
3948
3949 return QualType(TypeParm, 0);
3950}
3951
3952TypeSourceInfo *
3953ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name,
3954 SourceLocation NameLoc,
3955 const TemplateArgumentListInfo &Args,
3956 QualType Underlying) const {
3957 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3958, __extension__ __PRETTY_FUNCTION__))
3958 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3958, __extension__ __PRETTY_FUNCTION__))
;
3959 QualType TST = getTemplateSpecializationType(Name, Args, Underlying);
3960
3961 TypeSourceInfo *DI = CreateTypeSourceInfo(TST);
3962 TemplateSpecializationTypeLoc TL =
3963 DI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>();
3964 TL.setTemplateKeywordLoc(SourceLocation());
3965 TL.setTemplateNameLoc(NameLoc);
3966 TL.setLAngleLoc(Args.getLAngleLoc());
3967 TL.setRAngleLoc(Args.getRAngleLoc());
3968 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3969 TL.setArgLocInfo(i, Args[i].getLocInfo());
3970 return DI;
3971}
3972
3973QualType
3974ASTContext::getTemplateSpecializationType(TemplateName Template,
3975 const TemplateArgumentListInfo &Args,
3976 QualType Underlying) const {
3977 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3978, __extension__ __PRETTY_FUNCTION__))
3978 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 3978, __extension__ __PRETTY_FUNCTION__))
;
3979
3980 SmallVector<TemplateArgument, 4> ArgVec;
3981 ArgVec.reserve(Args.size());
3982 for (const TemplateArgumentLoc &Arg : Args.arguments())
3983 ArgVec.push_back(Arg.getArgument());
3984
3985 return getTemplateSpecializationType(Template, ArgVec, Underlying);
3986}
3987
3988#ifndef NDEBUG
3989static bool hasAnyPackExpansions(ArrayRef<TemplateArgument> Args) {
3990 for (const TemplateArgument &Arg : Args)
3991 if (Arg.isPackExpansion())
3992 return true;
3993
3994 return true;
3995}
3996#endif
3997
3998QualType
3999ASTContext::getTemplateSpecializationType(TemplateName Template,
4000 ArrayRef<TemplateArgument> Args,
4001 QualType Underlying) const {
4002 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4003, __extension__ __PRETTY_FUNCTION__))
4003 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4003, __extension__ __PRETTY_FUNCTION__))
;
4004 // Look through qualified template names.
4005 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
4006 Template = TemplateName(QTN->getTemplateDecl());
4007
4008 bool IsTypeAlias =
4009 Template.getAsTemplateDecl() &&
4010 isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
4011 QualType CanonType;
4012 if (!Underlying.isNull())
4013 CanonType = getCanonicalType(Underlying);
4014 else {
4015 // We can get here with an alias template when the specialization contains
4016 // a pack expansion that does not match up with a parameter pack.
4017 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4018, __extension__ __PRETTY_FUNCTION__))
4018 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4018, __extension__ __PRETTY_FUNCTION__))
;
4019 IsTypeAlias = false;
4020 CanonType = getCanonicalTemplateSpecializationType(Template, Args);
4021 }
4022
4023 // Allocate the (non-canonical) template specialization type, but don't
4024 // try to unique it: these types typically have location information that
4025 // we don't unique and don't want to lose.
4026 void *Mem = Allocate(sizeof(TemplateSpecializationType) +
4027 sizeof(TemplateArgument) * Args.size() +
4028 (IsTypeAlias? sizeof(QualType) : 0),
4029 TypeAlignment);
4030 auto *Spec
4031 = new (Mem) TemplateSpecializationType(Template, Args, CanonType,
4032 IsTypeAlias ? Underlying : QualType());
4033
4034 Types.push_back(Spec);
4035 return QualType(Spec, 0);
4036}
4037
4038QualType ASTContext::getCanonicalTemplateSpecializationType(
4039 TemplateName Template, ArrayRef<TemplateArgument> Args) const {
4040 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4041, __extension__ __PRETTY_FUNCTION__))
4041 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4041, __extension__ __PRETTY_FUNCTION__))
;
4042
4043 // Look through qualified template names.
4044 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
4045 Template = TemplateName(QTN->getTemplateDecl());
4046
4047 // Build the canonical template specialization type.
4048 TemplateName CanonTemplate = getCanonicalTemplateName(Template);
4049 SmallVector<TemplateArgument, 4> CanonArgs;
4050 unsigned NumArgs = Args.size();
4051 CanonArgs.reserve(NumArgs);
4052 for (const TemplateArgument &Arg : Args)
4053 CanonArgs.push_back(getCanonicalTemplateArgument(Arg));
4054
4055 // Determine whether this canonical template specialization type already
4056 // exists.
4057 llvm::FoldingSetNodeID ID;
4058 TemplateSpecializationType::Profile(ID, CanonTemplate,
4059 CanonArgs, *this);
4060
4061 void *InsertPos = nullptr;
4062 TemplateSpecializationType *Spec
4063 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4064
4065 if (!Spec) {
4066 // Allocate a new canonical template specialization type.
4067 void *Mem = Allocate((sizeof(TemplateSpecializationType) +
4068 sizeof(TemplateArgument) * NumArgs),
4069 TypeAlignment);
4070 Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
4071 CanonArgs,
4072 QualType(), QualType());
4073 Types.push_back(Spec);
4074 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
4075 }
4076
4077 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4078, __extension__ __PRETTY_FUNCTION__))
4078 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4078, __extension__ __PRETTY_FUNCTION__))
;
4079 return QualType(Spec, 0);
4080}
4081
4082QualType ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
4083 NestedNameSpecifier *NNS,
4084 QualType NamedType,
4085 TagDecl *OwnedTagDecl) const {
4086 llvm::FoldingSetNodeID ID;
4087 ElaboratedType::Profile(ID, Keyword, NNS, NamedType, OwnedTagDecl);
4088
4089 void *InsertPos = nullptr;
4090 ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
4091 if (T)
4092 return QualType(T, 0);
4093
4094 QualType Canon = NamedType;
4095 if (!Canon.isCanonical()) {
4096 Canon = getCanonicalType(NamedType);
4097 ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
4098 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4098, __extension__ __PRETTY_FUNCTION__))
;
4099 (void)CheckT;
4100 }
4101
4102 T = new (*this, TypeAlignment)
4103 ElaboratedType(Keyword, NNS, NamedType, Canon, OwnedTagDecl);
4104 Types.push_back(T);
4105 ElaboratedTypes.InsertNode(T, InsertPos);
4106 return QualType(T, 0);
4107}
4108
4109QualType
4110ASTContext::getParenType(QualType InnerType) const {
4111 llvm::FoldingSetNodeID ID;
4112 ParenType::Profile(ID, InnerType);
4113
4114 void *InsertPos = nullptr;
4115 ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4116 if (T)
4117 return QualType(T, 0);
4118
4119 QualType Canon = InnerType;
4120 if (!Canon.isCanonical()) {
4121 Canon = getCanonicalType(InnerType);
4122 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4123 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4123, __extension__ __PRETTY_FUNCTION__))
;
4124 (void)CheckT;
4125 }
4126
4127 T = new (*this, TypeAlignment) ParenType(InnerType, Canon);
4128 Types.push_back(T);
4129 ParenTypes.InsertNode(T, InsertPos);
4130 return QualType(T, 0);
4131}
4132
4133QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
4134 NestedNameSpecifier *NNS,
4135 const IdentifierInfo *Name,
4136 QualType Canon) const {
4137 if (Canon.isNull()) {
4138 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
4139 if (CanonNNS != NNS)
4140 Canon = getDependentNameType(Keyword, CanonNNS, Name);
4141 }
4142
4143 llvm::FoldingSetNodeID ID;
4144 DependentNameType::Profile(ID, Keyword, NNS, Name);
4145
4146 void *InsertPos = nullptr;
4147 DependentNameType *T
4148 = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
4149 if (T)
4150 return QualType(T, 0);
4151
4152 T = new (*this, TypeAlignment) DependentNameType(Keyword, NNS, Name, Canon);
4153 Types.push_back(T);
4154 DependentNameTypes.InsertNode(T, InsertPos);
4155 return QualType(T, 0);
4156}
4157
4158QualType
4159ASTContext::getDependentTemplateSpecializationType(
4160 ElaboratedTypeKeyword Keyword,
4161 NestedNameSpecifier *NNS,
4162 const IdentifierInfo *Name,
4163 const TemplateArgumentListInfo &Args) const {
4164 // TODO: avoid this copy
4165 SmallVector<TemplateArgument, 16> ArgCopy;
4166 for (unsigned I = 0, E = Args.size(); I != E; ++I)
4167 ArgCopy.push_back(Args[I].getArgument());
4168 return getDependentTemplateSpecializationType(Keyword, NNS, Name, ArgCopy);
4169}
4170
4171QualType
4172ASTContext::getDependentTemplateSpecializationType(
4173 ElaboratedTypeKeyword Keyword,
4174 NestedNameSpecifier *NNS,
4175 const IdentifierInfo *Name,
4176 ArrayRef<TemplateArgument> Args) const {
4177 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4178, __extension__ __PRETTY_FUNCTION__))
4178 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4178, __extension__ __PRETTY_FUNCTION__))
;
4179
4180 llvm::FoldingSetNodeID ID;
4181 DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
4182 Name, Args);
4183
4184 void *InsertPos = nullptr;
4185 DependentTemplateSpecializationType *T
4186 = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4187 if (T)
4188 return QualType(T, 0);
4189
4190 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
4191
4192 ElaboratedTypeKeyword CanonKeyword = Keyword;
4193 if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
4194
4195 bool AnyNonCanonArgs = false;
4196 unsigned NumArgs = Args.size();
4197 SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
4198 for (unsigned I = 0; I != NumArgs; ++I) {
4199 CanonArgs[I] = getCanonicalTemplateArgument(Args[I]);
4200 if (!CanonArgs[I].structurallyEquals(Args[I]))
4201 AnyNonCanonArgs = true;
4202 }
4203
4204 QualType Canon;
4205 if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
4206 Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
4207 Name,
4208 CanonArgs);
4209
4210 // Find the insert position again.
4211 DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4212 }
4213
4214 void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
4215 sizeof(TemplateArgument) * NumArgs),
4216 TypeAlignment);
4217 T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
4218 Name, Args, Canon);
4219 Types.push_back(T);
4220 DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
4221 return QualType(T, 0);
4222}
4223
4224TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) {
4225 TemplateArgument Arg;
4226 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
4227 QualType ArgType = getTypeDeclType(TTP);
4228 if (TTP->isParameterPack())
4229 ArgType = getPackExpansionType(ArgType, None);
4230
4231 Arg = TemplateArgument(ArgType);
4232 } else if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4233 Expr *E = new (*this) DeclRefExpr(
4234 NTTP, /*enclosing*/false,
4235 NTTP->getType().getNonLValueExprType(*this),
4236 Expr::getValueKindForType(NTTP->getType()), NTTP->getLocation());
4237
4238 if (NTTP->isParameterPack())
4239 E = new (*this) PackExpansionExpr(DependentTy, E, NTTP->getLocation(),
4240 None);
4241 Arg = TemplateArgument(E);
4242 } else {
4243 auto *TTP = cast<TemplateTemplateParmDecl>(Param);
4244 if (TTP->isParameterPack())
4245 Arg = TemplateArgument(TemplateName(TTP), Optional<unsigned>());
4246 else
4247 Arg = TemplateArgument(TemplateName(TTP));
4248 }
4249
4250 if (Param->isTemplateParameterPack())
4251 Arg = TemplateArgument::CreatePackCopy(*this, Arg);
4252
4253 return Arg;
4254}
4255
4256void
4257ASTContext::getInjectedTemplateArgs(const TemplateParameterList *Params,
4258 SmallVectorImpl<TemplateArgument> &Args) {
4259 Args.reserve(Args.size() + Params->size());
4260
4261 for (NamedDecl *Param : *Params)
4262 Args.push_back(getInjectedTemplateArg(Param));
4263}
4264
4265QualType ASTContext::getPackExpansionType(QualType Pattern,
4266 Optional<unsigned> NumExpansions) {
4267 llvm::FoldingSetNodeID ID;
4268 PackExpansionType::Profile(ID, Pattern, NumExpansions);
4269
4270 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4271, __extension__ __PRETTY_FUNCTION__))
4271 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4271, __extension__ __PRETTY_FUNCTION__))
;
4272 void *InsertPos = nullptr;
4273 PackExpansionType *T
4274 = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4275 if (T)
4276 return QualType(T, 0);
4277
4278 QualType Canon;
4279 if (!Pattern.isCanonical()) {
4280 Canon = getCanonicalType(Pattern);
4281 // The canonical type might not contain an unexpanded parameter pack, if it
4282 // contains an alias template specialization which ignores one of its
4283 // parameters.
4284 if (Canon->containsUnexpandedParameterPack()) {
4285 Canon = getPackExpansionType(Canon, NumExpansions);
4286
4287 // Find the insert position again, in case we inserted an element into
4288 // PackExpansionTypes and invalidated our insert position.
4289 PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4290 }
4291 }
4292
4293 T = new (*this, TypeAlignment)
4294 PackExpansionType(Pattern, Canon, NumExpansions);
4295 Types.push_back(T);
4296 PackExpansionTypes.InsertNode(T, InsertPos);
4297 return QualType(T, 0);
4298}
4299
4300/// CmpProtocolNames - Comparison predicate for sorting protocols
4301/// alphabetically.
4302static int CmpProtocolNames(ObjCProtocolDecl *const *LHS,
4303 ObjCProtocolDecl *const *RHS) {
4304 return DeclarationName::compare((*LHS)->getDeclName(), (*RHS)->getDeclName());
4305}
4306
4307static bool areSortedAndUniqued(ArrayRef<ObjCProtocolDecl *> Protocols) {
4308 if (Protocols.empty()) return true;
4309
4310 if (Protocols[0]->getCanonicalDecl() != Protocols[0])
4311 return false;
4312
4313 for (unsigned i = 1; i != Protocols.size(); ++i)
4314 if (CmpProtocolNames(&Protocols[i - 1], &Protocols[i]) >= 0 ||
4315 Protocols[i]->getCanonicalDecl() != Protocols[i])
4316 return false;
4317 return true;
4318}
4319
4320static void
4321SortAndUniqueProtocols(SmallVectorImpl<ObjCProtocolDecl *> &Protocols) {
4322 // Sort protocols, keyed by name.
4323 llvm::array_pod_sort(Protocols.begin(), Protocols.end(), CmpProtocolNames);
4324
4325 // Canonicalize.
4326 for (ObjCProtocolDecl *&P : Protocols)
4327 P = P->getCanonicalDecl();
4328
4329 // Remove duplicates.
4330 auto ProtocolsEnd = std::unique(Protocols.begin(), Protocols.end());
4331 Protocols.erase(ProtocolsEnd, Protocols.end());
4332}
4333
4334QualType ASTContext::getObjCObjectType(QualType BaseType,
4335 ObjCProtocolDecl * const *Protocols,
4336 unsigned NumProtocols) const {
4337 return getObjCObjectType(BaseType, {},
4338 llvm::makeArrayRef(Protocols, NumProtocols),
4339 /*isKindOf=*/false);
4340}
4341
4342QualType ASTContext::getObjCObjectType(
4343 QualType baseType,
4344 ArrayRef<QualType> typeArgs,
4345 ArrayRef<ObjCProtocolDecl *> protocols,
4346 bool isKindOf) const {
4347 // If the base type is an interface and there aren't any protocols or
4348 // type arguments to add, then the interface type will do just fine.
4349 if (typeArgs.empty() && protocols.empty() && !isKindOf &&
4350 isa<ObjCInterfaceType>(baseType))
4351 return baseType;
4352
4353 // Look in the folding set for an existing type.
4354 llvm::FoldingSetNodeID ID;
4355 ObjCObjectTypeImpl::Profile(ID, baseType, typeArgs, protocols, isKindOf);
4356 void *InsertPos = nullptr;
4357 if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
4358 return QualType(QT, 0);
4359
4360 // Determine the type arguments to be used for canonicalization,
4361 // which may be explicitly specified here or written on the base
4362 // type.
4363 ArrayRef<QualType> effectiveTypeArgs = typeArgs;
4364 if (effectiveTypeArgs.empty()) {
4365 if (const auto *baseObject = baseType->getAs<ObjCObjectType>())
4366 effectiveTypeArgs = baseObject->getTypeArgs();
4367 }
4368
4369 // Build the canonical type, which has the canonical base type and a
4370 // sorted-and-uniqued list of protocols and the type arguments
4371 // canonicalized.
4372 QualType canonical;
4373 bool typeArgsAreCanonical = std::all_of(effectiveTypeArgs.begin(),
4374 effectiveTypeArgs.end(),
4375 [&](QualType type) {
4376 return type.isCanonical();
4377 });
4378 bool protocolsSorted = areSortedAndUniqued(protocols);
4379 if (!typeArgsAreCanonical || !protocolsSorted || !baseType.isCanonical()) {
4380 // Determine the canonical type arguments.
4381 ArrayRef<QualType> canonTypeArgs;
4382 SmallVector<QualType, 4> canonTypeArgsVec;
4383 if (!typeArgsAreCanonical) {
4384 canonTypeArgsVec.reserve(effectiveTypeArgs.size());
4385 for (auto typeArg : effectiveTypeArgs)
4386 canonTypeArgsVec.push_back(getCanonicalType(typeArg));
4387 canonTypeArgs = canonTypeArgsVec;
4388 } else {
4389 canonTypeArgs = effectiveTypeArgs;
4390 }
4391
4392 ArrayRef<ObjCProtocolDecl *> canonProtocols;
4393 SmallVector<ObjCProtocolDecl*, 8> canonProtocolsVec;
4394 if (!protocolsSorted) {
4395 canonProtocolsVec.append(protocols.begin(), protocols.end());
4396 SortAndUniqueProtocols(canonProtocolsVec);
4397 canonProtocols = canonProtocolsVec;
4398 } else {
4399 canonProtocols = protocols;
4400 }
4401
4402 canonical = getObjCObjectType(getCanonicalType(baseType), canonTypeArgs,
4403 canonProtocols, isKindOf);
4404
4405 // Regenerate InsertPos.
4406 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
4407 }
4408
4409 unsigned size = sizeof(ObjCObjectTypeImpl);
4410 size += typeArgs.size() * sizeof(QualType);
4411 size += protocols.size() * sizeof(ObjCProtocolDecl *);
4412 void *mem = Allocate(size, TypeAlignment);
4413 auto *T =
4414 new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
4415 isKindOf);
4416
4417 Types.push_back(T);
4418 ObjCObjectTypes.InsertNode(T, InsertPos);
4419 return QualType(T, 0);
4420}
4421
4422/// Apply Objective-C protocol qualifiers to the given type.
4423/// If this is for the canonical type of a type parameter, we can apply
4424/// protocol qualifiers on the ObjCObjectPointerType.
4425QualType
4426ASTContext::applyObjCProtocolQualifiers(QualType type,
4427 ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
4428 bool allowOnPointerType) const {
4429 hasError = false;
4430
4431 if (const auto *objT = dyn_cast<ObjCTypeParamType>(type.getTypePtr())) {
4432 return getObjCTypeParamType(objT->getDecl(), protocols);
4433 }
4434
4435 // Apply protocol qualifiers to ObjCObjectPointerType.
4436 if (allowOnPointerType) {
4437 if (const auto *objPtr =
4438 dyn_cast<ObjCObjectPointerType>(type.getTypePtr())) {
4439 const ObjCObjectType *objT = objPtr->getObjectType();
4440 // Merge protocol lists and construct ObjCObjectType.
4441 SmallVector<ObjCProtocolDecl*, 8> protocolsVec;
4442 protocolsVec.append(objT->qual_begin(),
4443 objT->qual_end());
4444 protocolsVec.append(protocols.begin(), protocols.end());
4445 ArrayRef<ObjCProtocolDecl *> protocols = protocolsVec;
4446 type = getObjCObjectType(
4447 objT->getBaseType(),
4448 objT->getTypeArgsAsWritten(),
4449 protocols,
4450 objT->isKindOfTypeAsWritten());
4451 return getObjCObjectPointerType(type);
4452 }
4453 }
4454
4455 // Apply protocol qualifiers to ObjCObjectType.
4456 if (const auto *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){
4457 // FIXME: Check for protocols to which the class type is already
4458 // known to conform.
4459
4460 return getObjCObjectType(objT->getBaseType(),
4461 objT->getTypeArgsAsWritten(),
4462 protocols,
4463 objT->isKindOfTypeAsWritten());
4464 }
4465
4466 // If the canonical type is ObjCObjectType, ...
4467 if (type->isObjCObjectType()) {
4468 // Silently overwrite any existing protocol qualifiers.
4469 // TODO: determine whether that's the right thing to do.
4470
4471 // FIXME: Check for protocols to which the class type is already
4472 // known to conform.
4473 return getObjCObjectType(type, {}, protocols, false);
4474 }
4475
4476 // id<protocol-list>
4477 if (type->isObjCIdType()) {
4478 const auto *objPtr = type->castAs<ObjCObjectPointerType>();
4479 type = getObjCObjectType(ObjCBuiltinIdTy, {}, protocols,
4480 objPtr->isKindOfType());
4481 return getObjCObjectPointerType(type);
4482 }
4483
4484 // Class<protocol-list>
4485 if (type->isObjCClassType()) {
4486 const auto *objPtr = type->castAs<ObjCObjectPointerType>();
4487 type = getObjCObjectType(ObjCBuiltinClassTy, {}, protocols,
4488 objPtr->isKindOfType());
4489 return getObjCObjectPointerType(type);
4490 }
4491
4492 hasError = true;
4493 return type;
4494}
4495
4496QualType
4497ASTContext::getObjCTypeParamType(const ObjCTypeParamDecl *Decl,
4498 ArrayRef<ObjCProtocolDecl *> protocols,
4499 QualType Canonical) const {
4500 // Look in the folding set for an existing type.
4501 llvm::FoldingSetNodeID ID;
4502 ObjCTypeParamType::Profile(ID, Decl, protocols);
4503 void *InsertPos = nullptr;
4504 if (ObjCTypeParamType *TypeParam =
4505 ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
4506 return QualType(TypeParam, 0);
4507
4508 if (Canonical.isNull()) {
4509 // We canonicalize to the underlying type.
4510 Canonical = getCanonicalType(Decl->getUnderlyingType());
4511 if (!protocols.empty()) {
4512 // Apply the protocol qualifers.
4513 bool hasError;
4514 Canonical = applyObjCProtocolQualifiers(Canonical, protocols, hasError,
4515 true/*allowOnPointerType*/);
4516 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4516, __extension__ __PRETTY_FUNCTION__))
;
4517 }
4518 }
4519
4520 unsigned size = sizeof(ObjCTypeParamType);
4521 size += protocols.size() * sizeof(ObjCProtocolDecl *);
4522 void *mem = Allocate(size, TypeAlignment);
4523 auto *newType = new (mem) ObjCTypeParamType(Decl, Canonical, protocols);
4524
4525 Types.push_back(newType);
4526 ObjCTypeParamTypes.InsertNode(newType, InsertPos);
4527 return QualType(newType, 0);
4528}
4529
4530/// ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC's
4531/// protocol list adopt all protocols in QT's qualified-id protocol
4532/// list.
4533bool ASTContext::ObjCObjectAdoptsQTypeProtocols(QualType QT,
4534 ObjCInterfaceDecl *IC) {
4535 if (!QT->isObjCQualifiedIdType())
4536 return false;
4537
4538 if (const auto *OPT = QT->getAs<ObjCObjectPointerType>()) {
4539 // If both the right and left sides have qualifiers.
4540 for (auto *Proto : OPT->quals()) {
4541 if (!IC->ClassImplementsProtocol(Proto, false))
4542 return false;
4543 }
4544 return true;
4545 }
4546 return false;
4547}
4548
4549/// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
4550/// QT's qualified-id protocol list adopt all protocols in IDecl's list
4551/// of protocols.
4552bool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
4553 ObjCInterfaceDecl *IDecl) {
4554 if (!QT->isObjCQualifiedIdType())
4555 return false;
4556 const auto *OPT = QT->getAs<ObjCObjectPointerType>();
4557 if (!OPT)
4558 return false;
4559 if (!IDecl->hasDefinition())
4560 return false;
4561 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols;
4562 CollectInheritedProtocols(IDecl, InheritedProtocols);
4563 if (InheritedProtocols.empty())
4564 return false;
4565 // Check that if every protocol in list of id<plist> conforms to a protocol
4566 // of IDecl's, then bridge casting is ok.
4567 bool Conforms = false;
4568 for (auto *Proto : OPT->quals()) {
4569 Conforms = false;
4570 for (auto *PI : InheritedProtocols) {
4571 if (ProtocolCompatibleWithProtocol(Proto, PI)) {
4572 Conforms = true;
4573 break;
4574 }
4575 }
4576 if (!Conforms)
4577 break;
4578 }
4579 if (Conforms)
4580 return true;
4581
4582 for (auto *PI : InheritedProtocols) {
4583 // If both the right and left sides have qualifiers.
4584 bool Adopts = false;
4585 for (auto *Proto : OPT->quals()) {
4586 // return 'true' if 'PI' is in the inheritance hierarchy of Proto
4587 if ((Adopts = ProtocolCompatibleWithProtocol(PI, Proto)))
4588 break;
4589 }
4590 if (!Adopts)
4591 return false;
4592 }
4593 return true;
4594}
4595
4596/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
4597/// the given object type.
4598QualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const {
4599 llvm::FoldingSetNodeID ID;
4600 ObjCObjectPointerType::Profile(ID, ObjectT);
4601
4602 void *InsertPos = nullptr;
4603 if (ObjCObjectPointerType *QT =
4604 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
4605 return QualType(QT, 0);
4606
4607 // Find the canonical object type.
4608 QualType Canonical;
4609 if (!ObjectT.isCanonical()) {
4610 Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));
4611
4612 // Regenerate InsertPos.
4613 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
4614 }
4615
4616 // No match.
4617 void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
4618 auto *QType =
4619 new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
4620
4621 Types.push_back(QType);
4622 ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
4623 return QualType(QType, 0);
4624}
4625
4626/// getObjCInterfaceType - Return the unique reference to the type for the
4627/// specified ObjC interface decl. The list of protocols is optional.
4628QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
4629 ObjCInterfaceDecl *PrevDecl) const {
4630 if (Decl->TypeForDecl)
4631 return QualType(Decl->TypeForDecl, 0);
4632
4633 if (PrevDecl) {
4634 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4634, __extension__ __PRETTY_FUNCTION__))
;
4635 Decl->TypeForDecl = PrevDecl->TypeForDecl;
4636 return QualType(PrevDecl->TypeForDecl, 0);
4637 }
4638
4639 // Prefer the definition, if there is one.
4640 if (const ObjCInterfaceDecl *Def = Decl->getDefinition())
4641 Decl = Def;
4642
4643 void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
4644 auto *T = new (Mem) ObjCInterfaceType(Decl);
4645 Decl->TypeForDecl = T;
4646 Types.push_back(T);
4647 return QualType(T, 0);
4648}
4649
4650/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
4651/// TypeOfExprType AST's (since expression's are never shared). For example,
4652/// multiple declarations that refer to "typeof(x)" all contain different
4653/// DeclRefExpr's. This doesn't effect the type checker, since it operates
4654/// on canonical type's (which are always unique).
4655QualType ASTContext::getTypeOfExprType(Expr *tofExpr) const {
4656 TypeOfExprType *toe;
4657 if (tofExpr->isTypeDependent()) {
4658 llvm::FoldingSetNodeID ID;
4659 DependentTypeOfExprType::Profile(ID, *this, tofExpr);
4660
4661 void *InsertPos = nullptr;
4662 DependentTypeOfExprType *Canon
4663 = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
4664 if (Canon) {
4665 // We already have a "canonical" version of an identical, dependent
4666 // typeof(expr) type. Use that as our canonical type.
4667 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
4668 QualType((TypeOfExprType*)Canon, 0));
4669 } else {
4670 // Build a new, canonical typeof(expr) type.
4671 Canon
4672 = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
4673 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
4674 toe = Canon;
4675 }
4676 } else {
4677 QualType Canonical = getCanonicalType(tofExpr->getType());
4678 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
4679 }
4680 Types.push_back(toe);
4681 return QualType(toe, 0);
4682}
4683
4684/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique
4685/// TypeOfType nodes. The only motivation to unique these nodes would be
4686/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
4687/// an issue. This doesn't affect the type checker, since it operates
4688/// on canonical types (which are always unique).
4689QualType ASTContext::getTypeOfType(QualType tofType) const {
4690 QualType Canonical = getCanonicalType(tofType);
4691 auto *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
4692 Types.push_back(tot);
4693 return QualType(tot, 0);
4694}
4695
4696/// Unlike many "get<Type>" functions, we don't unique DecltypeType
4697/// nodes. This would never be helpful, since each such type has its own
4698/// expression, and would not give a significant memory saving, since there
4699/// is an Expr tree under each such type.
4700QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const {
4701 DecltypeType *dt;
4702
4703 // C++11 [temp.type]p2:
4704 // If an expression e involves a template parameter, decltype(e) denotes a
4705 // unique dependent type. Two such decltype-specifiers refer to the same
4706 // type only if their expressions are equivalent (14.5.6.1).
4707 if (e->isInstantiationDependent()) {
4708 llvm::FoldingSetNodeID ID;
4709 DependentDecltypeType::Profile(ID, *this, e);
4710
4711 void *InsertPos = nullptr;
4712 DependentDecltypeType *Canon
4713 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
4714 if (!Canon) {
4715 // Build a new, canonical decltype(expr) type.
4716 Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
4717 DependentDecltypeTypes.InsertNode(Canon, InsertPos);
4718 }
4719 dt = new (*this, TypeAlignment)
4720 DecltypeType(e, UnderlyingType, QualType((DecltypeType *)Canon, 0));
4721 } else {
4722 dt = new (*this, TypeAlignment)
4723 DecltypeType(e, UnderlyingType, getCanonicalType(UnderlyingType));
4724 }
4725 Types.push_back(dt);
4726 return QualType(dt, 0);
4727}
4728
4729/// getUnaryTransformationType - We don't unique these, since the memory
4730/// savings are minimal and these are rare.
4731QualType ASTContext::getUnaryTransformType(QualType BaseType,
4732 QualType UnderlyingType,
4733 UnaryTransformType::UTTKind Kind)
4734 const {
4735 UnaryTransformType *ut = nullptr;
4736
4737 if (BaseType->isDependentType()) {
4738 // Look in the folding set for an existing type.
4739 llvm::FoldingSetNodeID ID;
4740 DependentUnaryTransformType::Profile(ID, getCanonicalType(BaseType), Kind);
4741
4742 void *InsertPos = nullptr;
4743 DependentUnaryTransformType *Canon
4744 = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
4745
4746 if (!Canon) {
4747 // Build a new, canonical __underlying_type(type) type.
4748 Canon = new (*this, TypeAlignment)
4749 DependentUnaryTransformType(*this, getCanonicalType(BaseType),
4750 Kind);
4751 DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);
4752 }
4753 ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4754 QualType(), Kind,
4755 QualType(Canon, 0));
4756 } else {
4757 QualType CanonType = getCanonicalType(UnderlyingType);
4758 ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4759 UnderlyingType, Kind,
4760 CanonType);
4761 }
4762 Types.push_back(ut);
4763 return QualType(ut, 0);
4764}
4765
4766/// getAutoType - Return the uniqued reference to the 'auto' type which has been
4767/// deduced to the given type, or to the canonical undeduced 'auto' type, or the
4768/// canonical deduced-but-dependent 'auto' type.
4769QualType ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
4770 bool IsDependent) const {
4771 if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto && !IsDependent)
4772 return getAutoDeductType();
4773
4774 // Look in the folding set for an existing type.
4775 void *InsertPos = nullptr;
4776 llvm::FoldingSetNodeID ID;
4777 AutoType::Profile(ID, DeducedType, Keyword, IsDependent);
4778 if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
4779 return QualType(AT, 0);
4780
4781 auto *AT = new (*this, TypeAlignment)
4782 AutoType(DeducedType, Keyword, IsDependent);
4783 Types.push_back(AT);
4784 if (InsertPos)
4785 AutoTypes.InsertNode(AT, InsertPos);
4786 return QualType(AT, 0);
4787}
4788
4789/// Return the uniqued reference to the deduced template specialization type
4790/// which has been deduced to the given type, or to the canonical undeduced
4791/// such type, or the canonical deduced-but-dependent such type.
4792QualType ASTContext::getDeducedTemplateSpecializationType(
4793 TemplateName Template, QualType DeducedType, bool IsDependent) const {
4794 // Look in the folding set for an existing type.
4795 void *InsertPos = nullptr;
4796 llvm::FoldingSetNodeID ID;
4797 DeducedTemplateSpecializationType::Profile(ID, Template, DeducedType,
4798 IsDependent);
4799 if (DeducedTemplateSpecializationType *DTST =
4800 DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
4801 return QualType(DTST, 0);
4802
4803 auto *DTST = new (*this, TypeAlignment)
4804 DeducedTemplateSpecializationType(Template, DeducedType, IsDependent);
4805 Types.push_back(DTST);
4806 if (InsertPos)
4807 DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
4808 return QualType(DTST, 0);
4809}
4810
4811/// getAtomicType - Return the uniqued reference to the atomic type for
4812/// the given value type.
4813QualType ASTContext::getAtomicType(QualType T) const {
4814 // Unique pointers, to guarantee there is only one pointer of a particular
4815 // structure.
4816 llvm::FoldingSetNodeID ID;
4817 AtomicType::Profile(ID, T);
4818
4819 void *InsertPos = nullptr;
4820 if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
4821 return QualType(AT, 0);
4822
4823 // If the atomic value type isn't canonical, this won't be a canonical type
4824 // either, so fill in the canonical type field.
4825 QualType Canonical;
4826 if (!T.isCanonical()) {
4827 Canonical = getAtomicType(getCanonicalType(T));
4828
4829 // Get the new insert position for the node we care about.
4830 AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
4831 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4831, __extension__ __PRETTY_FUNCTION__))
; (void)NewIP;
4832 }
4833 auto *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
4834 Types.push_back(New);
4835 AtomicTypes.InsertNode(New, InsertPos);
4836 return QualType(New, 0);
4837}
4838
4839/// getAutoDeductType - Get type pattern for deducing against 'auto'.
4840QualType ASTContext::getAutoDeductType() const {
4841 if (AutoDeductTy.isNull())
4842 AutoDeductTy = QualType(
4843 new (*this, TypeAlignment) AutoType(QualType(), AutoTypeKeyword::Auto,
4844 /*dependent*/false),
4845 0);
4846 return AutoDeductTy;
4847}
4848
4849/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'.
4850QualType ASTContext::getAutoRRefDeductType() const {
4851 if (AutoRRefDeductTy.isNull())
4852 AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType());
4853 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4853, __extension__ __PRETTY_FUNCTION__))
;
4854 return AutoRRefDeductTy;
4855}
4856
4857/// getTagDeclType - Return the unique reference to the type for the
4858/// specified TagDecl (struct/union/class/enum) decl.
4859QualType ASTContext::getTagDeclType(const TagDecl *Decl) const {
4860 assert(Decl)(static_cast <bool> (Decl) ? void (0) : __assert_fail (
"Decl", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4860, __extension__ __PRETTY_FUNCTION__))
;
4861 // FIXME: What is the design on getTagDeclType when it requires casting
4862 // away const? mutable?
4863 return getTypeDeclType(const_cast<TagDecl*>(Decl));
4864}
4865
4866/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
4867/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
4868/// needs to agree with the definition in <stddef.h>.
4869CanQualType ASTContext::getSizeType() const {
4870 return getFromTargetType(Target->getSizeType());
4871}
4872
4873/// Return the unique signed counterpart of the integer type
4874/// corresponding to size_t.
4875CanQualType ASTContext::getSignedSizeType() const {
4876 return getFromTargetType(Target->getSignedSizeType());
4877}
4878
4879/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5).
4880CanQualType ASTContext::getIntMaxType() const {
4881 return getFromTargetType(Target->getIntMaxType());
4882}
4883
4884/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5).
4885CanQualType ASTContext::getUIntMaxType() const {
4886 return getFromTargetType(Target->getUIntMaxType());
4887}
4888
4889/// getSignedWCharType - Return the type of "signed wchar_t".
4890/// Used when in C++, as a GCC extension.
4891QualType ASTContext::getSignedWCharType() const {
4892 // FIXME: derive from "Target" ?
4893 return WCharTy;
4894}
4895
4896/// getUnsignedWCharType - Return the type of "unsigned wchar_t".
4897/// Used when in C++, as a GCC extension.
4898QualType ASTContext::getUnsignedWCharType() const {
4899 // FIXME: derive from "Target" ?
4900 return UnsignedIntTy;
4901}
4902
4903QualType ASTContext::getIntPtrType() const {
4904 return getFromTargetType(Target->getIntPtrType());
4905}
4906
4907QualType ASTContext::getUIntPtrType() const {
4908 return getCorrespondingUnsignedType(getIntPtrType());
4909}
4910
4911/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17)
4912/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
4913QualType ASTContext::getPointerDiffType() const {
4914 return getFromTargetType(Target->getPtrDiffType(0));
4915}
4916
4917/// Return the unique unsigned counterpart of "ptrdiff_t"
4918/// integer type. The standard (C11 7.21.6.1p7) refers to this type
4919/// in the definition of %tu format specifier.
4920QualType ASTContext::getUnsignedPointerDiffType() const {
4921 return getFromTargetType(Target->getUnsignedPtrDiffType(0));
4922}
4923
4924/// Return the unique type for "pid_t" defined in
4925/// <sys/types.h>. We need this to compute the correct type for vfork().
4926QualType ASTContext::getProcessIDType() const {
4927 return getFromTargetType(Target->getProcessIDType());
4928}
4929
4930//===----------------------------------------------------------------------===//
4931// Type Operators
4932//===----------------------------------------------------------------------===//
4933
4934CanQualType ASTContext::getCanonicalParamType(QualType T) const {
4935 // Push qualifiers into arrays, and then discard any remaining
4936 // qualifiers.
4937 T = getCanonicalType(T);
4938 T = getVariableArrayDecayedType(T);
4939 const Type *Ty = T.getTypePtr();
4940 QualType Result;
4941 if (isa<ArrayType>(Ty)) {
4942 Result = getArrayDecayedType(QualType(Ty,0));
4943 } else if (isa<FunctionType>(Ty)) {
4944 Result = getPointerType(QualType(Ty, 0));
4945 } else {
4946 Result = QualType(Ty, 0);
4947 }
4948
4949 return CanQualType::CreateUnsafe(Result);
4950}
4951
4952QualType ASTContext::getUnqualifiedArrayType(QualType type,
4953 Qualifiers &quals) {
4954 SplitQualType splitType = type.getSplitUnqualifiedType();
4955
4956 // FIXME: getSplitUnqualifiedType() actually walks all the way to
4957 // the unqualified desugared type and then drops it on the floor.
4958 // We then have to strip that sugar back off with
4959 // getUnqualifiedDesugaredType(), which is silly.
4960 const auto *AT =
4961 dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType());
4962
4963 // If we don't have an array, just use the results in splitType.
4964 if (!AT) {
4965 quals = splitType.Quals;
4966 return QualType(splitType.Ty, 0);
4967 }
4968
4969 // Otherwise, recurse on the array's element type.
4970 QualType elementType = AT->getElementType();
4971 QualType unqualElementType = getUnqualifiedArrayType(elementType, quals);
4972
4973 // If that didn't change the element type, AT has no qualifiers, so we
4974 // can just use the results in splitType.
4975 if (elementType == unqualElementType) {
4976 assert(quals.empty())(static_cast <bool> (quals.empty()) ? void (0) : __assert_fail
("quals.empty()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 4976, __extension__ __PRETTY_FUNCTION__))
; // from the recursive call
4977 quals = splitType.Quals;
4978 return QualType(splitType.Ty, 0);
4979 }
4980
4981 // Otherwise, add in the qualifiers from the outermost type, then
4982 // build the type back up.
4983 quals.addConsistentQualifiers(splitType.Quals);
4984
4985 if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
4986 return getConstantArrayType(unqualElementType, CAT->getSize(),
4987 CAT->getSizeModifier(), 0);
4988 }
4989
4990 if (const auto *IAT = dyn_cast<IncompleteArrayType>(AT)) {
4991 return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0);
4992 }
4993
4994 if (const auto *VAT = dyn_cast<VariableArrayType>(AT)) {
4995 return getVariableArrayType(unqualElementType,
4996 VAT->getSizeExpr(),
4997 VAT->getSizeModifier(),
4998 VAT->getIndexTypeCVRQualifiers(),
4999 VAT->getBracketsRange());
5000 }
5001
5002 const auto *DSAT = cast<DependentSizedArrayType>(AT);
5003 return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(),
5004 DSAT->getSizeModifier(), 0,
5005 SourceRange());
5006}
5007
5008/// Attempt to unwrap two types that may both be array types with the same bound
5009/// (or both be array types of unknown bound) for the purpose of comparing the
5010/// cv-decomposition of two types per C++ [conv.qual].
5011bool ASTContext::UnwrapSimilarArrayTypes(QualType &T1, QualType &T2) {
5012 bool UnwrappedAny = false;
5013 while (true) {
5014 auto *AT1 = getAsArrayType(T1);
5015 if (!AT1) return UnwrappedAny;
5016
5017 auto *AT2 = getAsArrayType(T2);
5018 if (!AT2) return UnwrappedAny;
5019
5020 // If we don't have two array types with the same constant bound nor two
5021 // incomplete array types, we've unwrapped everything we can.
5022 if (auto *CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
5023 auto *CAT2 = dyn_cast<ConstantArrayType>(AT2);
5024 if (!CAT2 || CAT1->getSize() != CAT2->getSize())
5025 return UnwrappedAny;
5026 } else if (!isa<IncompleteArrayType>(AT1) ||
5027 !isa<IncompleteArrayType>(AT2)) {
5028 return UnwrappedAny;
5029 }
5030
5031 T1 = AT1->getElementType();
5032 T2 = AT2->getElementType();
5033 UnwrappedAny = true;
5034 }
5035}
5036
5037/// Attempt to unwrap two types that may be similar (C++ [conv.qual]).
5038///
5039/// If T1 and T2 are both pointer types of the same kind, or both array types
5040/// with the same bound, unwraps layers from T1 and T2 until a pointer type is
5041/// unwrapped. Top-level qualifiers on T1 and T2 are ignored.
5042///
5043/// This function will typically be called in a loop that successively
5044/// "unwraps" pointer and pointer-to-member types to compare them at each
5045/// level.
5046///
5047/// \return \c true if a pointer type was unwrapped, \c false if we reached a
5048/// pair of types that can't be unwrapped further.
5049bool ASTContext::UnwrapSimilarTypes(QualType &T1, QualType &T2) {
5050 UnwrapSimilarArrayTypes(T1, T2);
5051
5052 const auto *T1PtrType = T1->getAs<PointerType>();
5053 const auto *T2PtrType = T2->getAs<PointerType>();
5054 if (T1PtrType && T2PtrType) {
5055 T1 = T1PtrType->getPointeeType();
5056 T2 = T2PtrType->getPointeeType();
5057 return true;
5058 }
5059
5060 const auto *T1MPType = T1->getAs<MemberPointerType>();
5061 const auto *T2MPType = T2->getAs<MemberPointerType>();
5062 if (T1MPType && T2MPType &&
5063 hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
5064 QualType(T2MPType->getClass(), 0))) {
5065 T1 = T1MPType->getPointeeType();
5066 T2 = T2MPType->getPointeeType();
5067 return true;
5068 }
5069
5070 if (getLangOpts().ObjC1) {
5071 const auto *T1OPType = T1->getAs<ObjCObjectPointerType>();
5072 const auto *T2OPType = T2->getAs<ObjCObjectPointerType>();
5073 if (T1OPType && T2OPType) {
5074 T1 = T1OPType->getPointeeType();
5075 T2 = T2OPType->getPointeeType();
5076 return true;
5077 }
5078 }
5079
5080 // FIXME: Block pointers, too?
5081
5082 return false;
5083}
5084
5085bool ASTContext::hasSimilarType(QualType T1, QualType T2) {
5086 while (true) {
5087 Qualifiers Quals;
5088 T1 = getUnqualifiedArrayType(T1, Quals);
5089 T2 = getUnqualifiedArrayType(T2, Quals);
5090 if (hasSameType(T1, T2))
5091 return true;
5092 if (!UnwrapSimilarTypes(T1, T2))
5093 return false;
5094 }
5095}
5096
5097bool ASTContext::hasCvrSimilarType(QualType T1, QualType T2) {
5098 while (true) {
5099 Qualifiers Quals1, Quals2;
5100 T1 = getUnqualifiedArrayType(T1, Quals1);
5101 T2 = getUnqualifiedArrayType(T2, Quals2);
5102
5103 Quals1.removeCVRQualifiers();
5104 Quals2.removeCVRQualifiers();
5105 if (Quals1 != Quals2)
5106 return false;
5107
5108 if (hasSameType(T1, T2))
5109 return true;
5110
5111 if (!UnwrapSimilarTypes(T1, T2))
5112 return false;
5113 }
5114}
5115
5116DeclarationNameInfo
5117ASTContext::getNameForTemplate(TemplateName Name,
5118 SourceLocation NameLoc) const {
5119 switch (Name.getKind()) {
5120 case TemplateName::QualifiedTemplate:
5121 case TemplateName::Template:
5122 // DNInfo work in progress: CHECKME: what about DNLoc?
5123 return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(),
5124 NameLoc);
5125
5126 case TemplateName::OverloadedTemplate: {
5127 OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate();
5128 // DNInfo work in progress: CHECKME: what about DNLoc?
5129 return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc);
5130 }
5131
5132 case TemplateName::DependentTemplate: {
5133 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
5134 DeclarationName DName;
5135 if (DTN->isIdentifier()) {
5136 DName = DeclarationNames.getIdentifier(DTN->getIdentifier());
5137 return DeclarationNameInfo(DName, NameLoc);
5138 } else {
5139 DName = DeclarationNames.getCXXOperatorName(DTN->getOperator());
5140 // DNInfo work in progress: FIXME: source locations?
5141 DeclarationNameLoc DNLoc;
5142 DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
5143 DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
5144 return DeclarationNameInfo(DName, NameLoc, DNLoc);
5145 }
5146 }
5147
5148 case TemplateName::SubstTemplateTemplateParm: {
5149 SubstTemplateTemplateParmStorage *subst
5150 = Name.getAsSubstTemplateTemplateParm();
5151 return DeclarationNameInfo(subst->getParameter()->getDeclName(),
5152 NameLoc);
5153 }
5154
5155 case TemplateName::SubstTemplateTemplateParmPack: {
5156 SubstTemplateTemplateParmPackStorage *subst
5157 = Name.getAsSubstTemplateTemplateParmPack();
5158 return DeclarationNameInfo(subst->getParameterPack()->getDeclName(),
5159 NameLoc);
5160 }
5161 }
5162
5163 llvm_unreachable("bad template name kind!")::llvm::llvm_unreachable_internal("bad template name kind!", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5163)
;
5164}
5165
5166TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const {
5167 switch (Name.getKind()) {
5168 case TemplateName::QualifiedTemplate:
5169 case TemplateName::Template: {
5170 TemplateDecl *Template = Name.getAsTemplateDecl();
5171 if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template))
5172 Template = getCanonicalTemplateTemplateParmDecl(TTP);
5173
5174 // The canonical template name is the canonical template declaration.
5175 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
5176 }
5177
5178 case TemplateName::OverloadedTemplate:
5179 llvm_unreachable("cannot canonicalize overloaded template")::llvm::llvm_unreachable_internal("cannot canonicalize overloaded template"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5179)
;
5180
5181 case TemplateName::DependentTemplate: {
5182 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
5183 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5183, __extension__ __PRETTY_FUNCTION__))
;
5184 return DTN->CanonicalTemplateName;
5185 }
5186
5187 case TemplateName::SubstTemplateTemplateParm: {
5188 SubstTemplateTemplateParmStorage *subst
5189 = Name.getAsSubstTemplateTemplateParm();
5190 return getCanonicalTemplateName(subst->getReplacement());
5191 }
5192
5193 case TemplateName::SubstTemplateTemplateParmPack: {
5194 SubstTemplateTemplateParmPackStorage *subst
5195 = Name.getAsSubstTemplateTemplateParmPack();
5196 TemplateTemplateParmDecl *canonParameter
5197 = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
5198 TemplateArgument canonArgPack
5199 = getCanonicalTemplateArgument(subst->getArgumentPack());
5200 return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
5201 }
5202 }
5203
5204 llvm_unreachable("bad template name!")::llvm::llvm_unreachable_internal("bad template name!", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5204)
;
5205}
5206
5207bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) {
5208 X = getCanonicalTemplateName(X);
5209 Y = getCanonicalTemplateName(Y);
5210 return X.getAsVoidPointer() == Y.getAsVoidPointer();
5211}
5212
5213TemplateArgument
5214ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
5215 switch (Arg.getKind()) {
5216 case TemplateArgument::Null:
5217 return Arg;
5218
5219 case TemplateArgument::Expression:
5220 return Arg;
5221
5222 case TemplateArgument::Declaration: {
5223 auto *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
5224 return TemplateArgument(D, Arg.getParamTypeForDecl());
5225 }
5226
5227 case TemplateArgument::NullPtr:
5228 return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),
5229 /*isNullPtr*/true);
5230
5231 case TemplateArgument::Template:
5232 return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));
5233
5234 case TemplateArgument::TemplateExpansion:
5235 return TemplateArgument(getCanonicalTemplateName(
5236 Arg.getAsTemplateOrTemplatePattern()),
5237 Arg.getNumTemplateExpansions());
5238
5239 case TemplateArgument::Integral:
5240 return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType()));
5241
5242 case TemplateArgument::Type:
5243 return TemplateArgument(getCanonicalType(Arg.getAsType()));
5244
5245 case TemplateArgument::Pack: {
5246 if (Arg.pack_size() == 0)
5247 return Arg;
5248
5249 auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
5250 unsigned Idx = 0;
5251 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
5252 AEnd = Arg.pack_end();
5253 A != AEnd; (void)++A, ++Idx)
5254 CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
5255
5256 return TemplateArgument(llvm::makeArrayRef(CanonArgs, Arg.pack_size()));
5257 }
5258 }
5259
5260 // Silence GCC warning
5261 llvm_unreachable("Unhandled template argument kind")::llvm::llvm_unreachable_internal("Unhandled template argument kind"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5261)
;
5262}
5263
5264NestedNameSpecifier *
5265ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const {
5266 if (!NNS)
5267 return nullptr;
5268
5269 switch (NNS->getKind()) {
5270 case NestedNameSpecifier::Identifier:
5271 // Canonicalize the prefix but keep the identifier the same.
5272 return NestedNameSpecifier::Create(*this,
5273 getCanonicalNestedNameSpecifier(NNS->getPrefix()),
5274 NNS->getAsIdentifier());
5275
5276 case NestedNameSpecifier::Namespace:
5277 // A namespace is canonical; build a nested-name-specifier with
5278 // this namespace and no prefix.
5279 return NestedNameSpecifier::Create(*this, nullptr,
5280 NNS->getAsNamespace()->getOriginalNamespace());
5281
5282 case NestedNameSpecifier::NamespaceAlias:
5283 // A namespace is canonical; build a nested-name-specifier with
5284 // this namespace and no prefix.
5285 return NestedNameSpecifier::Create(*this, nullptr,
5286 NNS->getAsNamespaceAlias()->getNamespace()
5287 ->getOriginalNamespace());
5288
5289 case NestedNameSpecifier::TypeSpec:
5290 case NestedNameSpecifier::TypeSpecWithTemplate: {
5291 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
5292
5293 // If we have some kind of dependent-named type (e.g., "typename T::type"),
5294 // break it apart into its prefix and identifier, then reconsititute those
5295 // as the canonical nested-name-specifier. This is required to canonicalize
5296 // a dependent nested-name-specifier involving typedefs of dependent-name
5297 // types, e.g.,
5298 // typedef typename T::type T1;
5299 // typedef typename T1::type T2;
5300 if (const auto *DNT = T->getAs<DependentNameType>())
5301 return NestedNameSpecifier::Create(*this, DNT->getQualifier(),
5302 const_cast<IdentifierInfo *>(DNT->getIdentifier()));
5303
5304 // Otherwise, just canonicalize the type, and force it to be a TypeSpec.
5305 // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the
5306 // first place?
5307 return NestedNameSpecifier::Create(*this, nullptr, false,
5308 const_cast<Type *>(T.getTypePtr()));
5309 }
5310
5311 case NestedNameSpecifier::Global:
5312 case NestedNameSpecifier::Super:
5313 // The global specifier and __super specifer are canonical and unique.
5314 return NNS;
5315 }
5316
5317 llvm_unreachable("Invalid NestedNameSpecifier::Kind!")::llvm::llvm_unreachable_internal("Invalid NestedNameSpecifier::Kind!"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5317)
;
5318}
5319
5320const ArrayType *ASTContext::getAsArrayType(QualType T) const {
5321 // Handle the non-qualified case efficiently.
5322 if (!T.hasLocalQualifiers()) {
5323 // Handle the common positive case fast.
5324 if (const auto *AT = dyn_cast<ArrayType>(T))
5325 return AT;
5326 }
5327
5328 // Handle the common negative case fast.
5329 if (!isa<ArrayType>(T.getCanonicalType()))
5330 return nullptr;
5331
5332 // Apply any qualifiers from the array type to the element type. This
5333 // implements C99 6.7.3p8: "If the specification of an array type includes
5334 // any type qualifiers, the element type is so qualified, not the array type."
5335
5336 // If we get here, we either have type qualifiers on the type, or we have
5337 // sugar such as a typedef in the way. If we have type qualifiers on the type
5338 // we must propagate them down into the element type.
5339
5340 SplitQualType split = T.getSplitDesugaredType();
5341 Qualifiers qs = split.Quals;
5342
5343 // If we have a simple case, just return now.
5344 const auto *ATy = dyn_cast<ArrayType>(split.Ty);
5345 if (!ATy || qs.empty())
5346 return ATy;
5347
5348 // Otherwise, we have an array and we have qualifiers on it. Push the
5349 // qualifiers into the array element type and return a new array type.
5350 QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs);
5351
5352 if (const auto *CAT = dyn_cast<ConstantArrayType>(ATy))
5353 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
5354 CAT->getSizeModifier(),
5355 CAT->getIndexTypeCVRQualifiers()));
5356 if (const auto *IAT = dyn_cast<IncompleteArrayType>(ATy))
5357 return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
5358 IAT->getSizeModifier(),
5359 IAT->getIndexTypeCVRQualifiers()));
5360
5361 if (const auto *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
5362 return cast<ArrayType>(
5363 getDependentSizedArrayType(NewEltTy,
5364 DSAT->getSizeExpr(),
5365 DSAT->getSizeModifier(),
5366 DSAT->getIndexTypeCVRQualifiers(),
5367 DSAT->getBracketsRange()));
5368
5369 const auto *VAT = cast<VariableArrayType>(ATy);
5370 return cast<ArrayType>(getVariableArrayType(NewEltTy,
5371 VAT->getSizeExpr(),
5372 VAT->getSizeModifier(),
5373 VAT->getIndexTypeCVRQualifiers(),
5374 VAT->getBracketsRange()));
5375}
5376
5377QualType ASTContext::getAdjustedParameterType(QualType T) const {
5378 if (T->isArrayType() || T->isFunctionType())
5379 return getDecayedType(T);
5380 return T;
5381}
5382
5383QualType ASTContext::getSignatureParameterType(QualType T) const {
5384 T = getVariableArrayDecayedType(T);
5385 T = getAdjustedParameterType(T);
5386 return T.getUnqualifiedType();
5387}
5388
5389QualType ASTContext::getExceptionObjectType(QualType T) const {
5390 // C++ [except.throw]p3:
5391 // A throw-expression initializes a temporary object, called the exception
5392 // object, the type of which is determined by removing any top-level
5393 // cv-qualifiers from the static type of the operand of throw and adjusting
5394 // the type from "array of T" or "function returning T" to "pointer to T"
5395 // or "pointer to function returning T", [...]
5396 T = getVariableArrayDecayedType(T);
5397 if (T->isArrayType() || T->isFunctionType())
5398 T = getDecayedType(T);
5399 return T.getUnqualifiedType();
5400}
5401
5402/// getArrayDecayedType - Return the properly qualified result of decaying the
5403/// specified array type to a pointer. This operation is non-trivial when
5404/// handling typedefs etc. The canonical type of "T" must be an array type,
5405/// this returns a pointer to a properly qualified element of the array.
5406///
5407/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
5408QualType ASTContext::getArrayDecayedType(QualType Ty) const {
5409 // Get the element type with 'getAsArrayType' so that we don't lose any
5410 // typedefs in the element type of the array. This also handles propagation
5411 // of type qualifiers from the array type into the element type if present
5412 // (C99 6.7.3p8).
5413 const ArrayType *PrettyArrayType = getAsArrayType(Ty);
5414 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5414, __extension__ __PRETTY_FUNCTION__))
;
5415
5416 QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
5417
5418 // int x[restrict 4] -> int *restrict
5419 QualType Result = getQualifiedType(PtrTy,
5420 PrettyArrayType->getIndexTypeQualifiers());
5421
5422 // int x[_Nullable] -> int * _Nullable
5423 if (auto Nullability = Ty->getNullability(*this)) {
5424 Result = const_cast<ASTContext *>(this)->getAttributedType(
5425 AttributedType::getNullabilityAttrKind(*Nullability), Result, Result);
5426 }
5427 return Result;
5428}
5429
5430QualType ASTContext::getBaseElementType(const ArrayType *array) const {
5431 return getBaseElementType(array->getElementType());
5432}
5433
5434QualType ASTContext::getBaseElementType(QualType type) const {
5435 Qualifiers qs;
5436 while (true) {
5437 SplitQualType split = type.getSplitDesugaredType();
5438 const ArrayType *array = split.Ty->getAsArrayTypeUnsafe();
5439 if (!array) break;
5440
5441 type = array->getElementType();
5442 qs.addConsistentQualifiers(split.Quals);
5443 }
5444
5445 return getQualifiedType(type, qs);
5446}
5447
5448/// getConstantArrayElementCount - Returns number of constant array elements.
5449uint64_t
5450ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const {
5451 uint64_t ElementCount = 1;
5452 do {
5453 ElementCount *= CA->getSize().getZExtValue();
5454 CA = dyn_cast_or_null<ConstantArrayType>(
5455 CA->getElementType()->getAsArrayTypeUnsafe());
5456 } while (CA);
5457 return ElementCount;
5458}
5459
5460/// getFloatingRank - Return a relative rank for floating point types.
5461/// This routine will assert if passed a built-in type that isn't a float.
5462static FloatingRank getFloatingRank(QualType T) {
5463 if (const auto *CT = T->getAs<ComplexType>())
5464 return getFloatingRank(CT->getElementType());
5465
5466 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5466, __extension__ __PRETTY_FUNCTION__))
;
5467 switch (T->getAs<BuiltinType>()->getKind()) {
5468 default: llvm_unreachable("getFloatingRank(): not a floating type")::llvm::llvm_unreachable_internal("getFloatingRank(): not a floating type"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5468)
;
5469 case BuiltinType::Float16: return Float16Rank;
5470 case BuiltinType::Half: return HalfRank;
5471 case BuiltinType::Float: return FloatRank;
5472 case BuiltinType::Double: return DoubleRank;
5473 case BuiltinType::LongDouble: return LongDoubleRank;
5474 case BuiltinType::Float128: return Float128Rank;
5475 }
5476}
5477
5478/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
5479/// point or a complex type (based on typeDomain/typeSize).
5480/// 'typeDomain' is a real floating point or complex type.
5481/// 'typeSize' is a real floating point or complex type.
5482QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
5483 QualType Domain) const {
5484 FloatingRank EltRank = getFloatingRank(Size);
5485 if (Domain->isComplexType()) {
5486 switch (EltRank) {
5487 case Float16Rank:
5488 case HalfRank: llvm_unreachable("Complex half is not supported")::llvm::llvm_unreachable_internal("Complex half is not supported"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5488)
;
5489 case FloatRank: return FloatComplexTy;
5490 case DoubleRank: return DoubleComplexTy;
5491 case LongDoubleRank: return LongDoubleComplexTy;
5492 case Float128Rank: return Float128ComplexTy;
5493 }
5494 }
5495
5496 assert(Domain->isRealFloatingType() && "Unknown domain!")(static_cast <bool> (Domain->isRealFloatingType() &&
"Unknown domain!") ? void (0) : __assert_fail ("Domain->isRealFloatingType() && \"Unknown domain!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5496, __extension__ __PRETTY_FUNCTION__))
;
5497 switch (EltRank) {
5498 case Float16Rank: return HalfTy;
5499 case HalfRank: return HalfTy;
5500 case FloatRank: return FloatTy;
5501 case DoubleRank: return DoubleTy;
5502 case LongDoubleRank: return LongDoubleTy;
5503 case Float128Rank: return Float128Ty;
5504 }
5505 llvm_unreachable("getFloatingRank(): illegal value for rank")::llvm::llvm_unreachable_internal("getFloatingRank(): illegal value for rank"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5505)
;
5506}
5507
5508/// getFloatingTypeOrder - Compare the rank of the two specified floating
5509/// point types, ignoring the domain of the type (i.e. 'double' ==
5510/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
5511/// LHS < RHS, return -1.
5512int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
5513 FloatingRank LHSR = getFloatingRank(LHS);
5514 FloatingRank RHSR = getFloatingRank(RHS);
5515
5516 if (LHSR == RHSR)
5517 return 0;
5518 if (LHSR > RHSR)
5519 return 1;
5520 return -1;
5521}
5522
5523/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
5524/// routine will assert if passed a built-in type that isn't an integer or enum,
5525/// or if it is not canonicalized.
5526unsigned ASTContext::getIntegerRank(const Type *T) const {
5527 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5527, __extension__ __PRETTY_FUNCTION__))
;
5528
5529 switch (cast<BuiltinType>(T)->getKind()) {
5530 default: llvm_unreachable("getIntegerRank(): not a built-in integer")::llvm::llvm_unreachable_internal("getIntegerRank(): not a built-in integer"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5530)
;
5531 case BuiltinType::Bool:
5532 return 1 + (getIntWidth(BoolTy) << 3);
5533 case BuiltinType::Char_S:
5534 case BuiltinType::Char_U:
5535 case BuiltinType::SChar:
5536 case BuiltinType::UChar:
5537 return 2 + (getIntWidth(CharTy) << 3);
5538 case BuiltinType::Short:
5539 case BuiltinType::UShort:
5540 return 3 + (getIntWidth(ShortTy) << 3);
5541 case BuiltinType::Int:
5542 case BuiltinType::UInt:
5543 return 4 + (getIntWidth(IntTy) << 3);
5544 case BuiltinType::Long:
5545 case BuiltinType::ULong:
5546 return 5 + (getIntWidth(LongTy) << 3);
5547 case BuiltinType::LongLong:
5548 case BuiltinType::ULongLong:
5549 return 6 + (getIntWidth(LongLongTy) << 3);
5550 case BuiltinType::Int128:
5551 case BuiltinType::UInt128:
5552 return 7 + (getIntWidth(Int128Ty) << 3);
5553 }
5554}
5555
5556/// Whether this is a promotable bitfield reference according
5557/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
5558///
5559/// \returns the type this bit-field will promote to, or NULL if no
5560/// promotion occurs.
5561QualType ASTContext::isPromotableBitField(Expr *E) const {
5562 if (E->isTypeDependent() || E->isValueDependent())
5563 return {};
5564
5565 // C++ [conv.prom]p5:
5566 // If the bit-field has an enumerated type, it is treated as any other
5567 // value of that type for promotion purposes.
5568 if (getLangOpts().CPlusPlus && E->getType()->isEnumeralType())
5569 return {};
5570
5571 // FIXME: We should not do this unless E->refersToBitField() is true. This
5572 // matters in C where getSourceBitField() will find bit-fields for various
5573 // cases where the source expression is not a bit-field designator.
5574
5575 FieldDecl *Field = E->getSourceBitField(); // FIXME: conditional bit-fields?
5576 if (!Field)
5577 return {};
5578
5579 QualType FT = Field->getType();
5580
5581 uint64_t BitWidth = Field->getBitWidthValue(*this);
5582 uint64_t IntSize = getTypeSize(IntTy);
5583 // C++ [conv.prom]p5:
5584 // A prvalue for an integral bit-field can be converted to a prvalue of type
5585 // int if int can represent all the values of the bit-field; otherwise, it
5586 // can be converted to unsigned int if unsigned int can represent all the
5587 // values of the bit-field. If the bit-field is larger yet, no integral
5588 // promotion applies to it.
5589 // C11 6.3.1.1/2:
5590 // [For a bit-field of type _Bool, int, signed int, or unsigned int:]
5591 // If an int can represent all values of the original type (as restricted by
5592 // the width, for a bit-field), the value is converted to an int; otherwise,
5593 // it is converted to an unsigned int.
5594 //
5595 // FIXME: C does not permit promotion of a 'long : 3' bitfield to int.
5596 // We perform that promotion here to match GCC and C++.
5597 // FIXME: C does not permit promotion of an enum bit-field whose rank is
5598 // greater than that of 'int'. We perform that promotion to match GCC.
5599 if (BitWidth < IntSize)
5600 return IntTy;
5601
5602 if (BitWidth == IntSize)
5603 return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy;
5604
5605 // Bit-fields wider than int are not subject to promotions, and therefore act
5606 // like the base type. GCC has some weird bugs in this area that we
5607 // deliberately do not follow (GCC follows a pre-standard resolution to
5608 // C's DR315 which treats bit-width as being part of the type, and this leaks
5609 // into their semantics in some cases).
5610 return {};
5611}
5612
5613/// getPromotedIntegerType - Returns the type that Promotable will
5614/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
5615/// integer type.
5616QualType ASTContext::getPromotedIntegerType(QualType Promotable) const {
5617 assert(!Promotable.isNull())(static_cast <bool> (!Promotable.isNull()) ? void (0) :
__assert_fail ("!Promotable.isNull()", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5617, __extension__ __PRETTY_FUNCTION__))
;
5618 assert(Promotable->isPromotableIntegerType())(static_cast <bool> (Promotable->isPromotableIntegerType
()) ? void (0) : __assert_fail ("Promotable->isPromotableIntegerType()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5618, __extension__ __PRETTY_FUNCTION__))
;
5619 if (const auto *ET = Promotable->getAs<EnumType>())
5620 return ET->getDecl()->getPromotionType();
5621
5622 if (const auto *BT = Promotable->getAs<BuiltinType>()) {
5623 // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t
5624 // (3.9.1) can be converted to a prvalue of the first of the following
5625 // types that can represent all the values of its underlying type:
5626 // int, unsigned int, long int, unsigned long int, long long int, or
5627 // unsigned long long int [...]
5628 // FIXME: Is there some better way to compute this?
5629 if (BT->getKind() == BuiltinType::WChar_S ||
5630 BT->getKind() == BuiltinType::WChar_U ||
5631 BT->getKind() == BuiltinType::Char8 ||
5632 BT->getKind() == BuiltinType::Char16 ||
5633 BT->getKind() == BuiltinType::Char32) {
5634 bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
5635 uint64_t FromSize = getTypeSize(BT);
5636 QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy,
5637 LongLongTy, UnsignedLongLongTy };
5638 for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) {
5639 uint64_t ToSize = getTypeSize(PromoteTypes[Idx]);
5640 if (FromSize < ToSize ||
5641 (FromSize == ToSize &&
5642 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType()))
5643 return PromoteTypes[Idx];
5644 }
5645 llvm_unreachable("char type should fit into long long")::llvm::llvm_unreachable_internal("char type should fit into long long"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5645)
;
5646 }
5647 }
5648
5649 // At this point, we should have a signed or unsigned integer type.
5650 if (Promotable->isSignedIntegerType())
5651 return IntTy;
5652 uint64_t PromotableSize = getIntWidth(Promotable);
5653 uint64_t IntSize = getIntWidth(IntTy);
5654 assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize)(static_cast <bool> (Promotable->isUnsignedIntegerType
() && PromotableSize <= IntSize) ? void (0) : __assert_fail
("Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5654, __extension__ __PRETTY_FUNCTION__))
;
5655 return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
5656}
5657
5658/// Recurses in pointer/array types until it finds an objc retainable
5659/// type and returns its ownership.
5660Qualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const {
5661 while (!T.isNull()) {
5662 if (T.getObjCLifetime() != Qualifiers::OCL_None)
5663 return T.getObjCLifetime();
5664 if (T->isArrayType())
5665 T = getBaseElementType(T);
5666 else if (const auto *PT = T->getAs<PointerType>())
5667 T = PT->getPointeeType();
5668 else if (const auto *RT = T->getAs<ReferenceType>())
5669 T = RT->getPointeeType();
5670 else
5671 break;
5672 }
5673
5674 return Qualifiers::OCL_None;
5675}
5676
5677static const Type *getIntegerTypeForEnum(const EnumType *ET) {
5678 // Incomplete enum types are not treated as integer types.
5679 // FIXME: In C++, enum types are never integer types.
5680 if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
5681 return ET->getDecl()->getIntegerType().getTypePtr();
5682 return nullptr;
5683}
5684
5685/// getIntegerTypeOrder - Returns the highest ranked integer type:
5686/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
5687/// LHS < RHS, return -1.
5688int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const {
5689 const Type *LHSC = getCanonicalType(LHS).getTypePtr();
5690 const Type *RHSC = getCanonicalType(RHS).getTypePtr();
5691
5692 // Unwrap enums to their underlying type.
5693 if (const auto *ET = dyn_cast<EnumType>(LHSC))
5694 LHSC = getIntegerTypeForEnum(ET);
5695 if (const auto *ET = dyn_cast<EnumType>(RHSC))
5696 RHSC = getIntegerTypeForEnum(ET);
5697
5698 if (LHSC == RHSC) return 0;
5699
5700 bool LHSUnsigned = LHSC->isUnsignedIntegerType();
5701 bool RHSUnsigned = RHSC->isUnsignedIntegerType();
5702
5703 unsigned LHSRank = getIntegerRank(LHSC);
5704 unsigned RHSRank = getIntegerRank(RHSC);
5705
5706 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
5707 if (LHSRank == RHSRank) return 0;
5708 return LHSRank > RHSRank ? 1 : -1;
5709 }
5710
5711 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
5712 if (LHSUnsigned) {
5713 // If the unsigned [LHS] type is larger, return it.
5714 if (LHSRank >= RHSRank)
5715 return 1;
5716
5717 // If the signed type can represent all values of the unsigned type, it
5718 // wins. Because we are dealing with 2's complement and types that are
5719 // powers of two larger than each other, this is always safe.
5720 return -1;
5721 }
5722
5723 // If the unsigned [RHS] type is larger, return it.
5724 if (RHSRank >= LHSRank)
5725 return -1;
5726
5727 // If the signed type can represent all values of the unsigned type, it
5728 // wins. Because we are dealing with 2's complement and types that are
5729 // powers of two larger than each other, this is always safe.
5730 return 1;
5731}
5732
5733TypedefDecl *ASTContext::getCFConstantStringDecl() const {
5734 if (!CFConstantStringTypeDecl) {
5735 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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5736, __extension__ __PRETTY_FUNCTION__))
5736 "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-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5736, __extension__ __PRETTY_FUNCTION__))
;
5737 CFConstantStringTagDecl = buildImplicitRecord("__NSConstantString_tag");
5738 CFConstantStringTagDecl->startDefinition();
5739
5740 QualType FieldTypes[4];
5741 const char *FieldNames[4];
5742
5743 // const int *isa;
5744 FieldTypes[0] = getPointerType(IntTy.withConst());
5745 FieldNames[0] = "isa";
5746 // int flags;
5747 FieldTypes[1] = IntTy;
5748 FieldNames[1] = "flags";
5749 // const char *str;
5750 FieldTypes[2] = getPointerType(CharTy.withConst());
5751 FieldNames[2] = "str";
5752 // long length;
5753 FieldTypes[3] = LongTy;
5754 FieldNames[3] = "length";
5755
5756 // Create fields
5757 for (unsigned i = 0; i < 4; ++i) {
5758 FieldDecl *Field = FieldDecl::Create(*this, CFConstantStringTagDecl,
5759 SourceLocation(),
5760 SourceLocation(),
5761 &Idents.get(FieldNames[i]),
5762 FieldTypes[i], /*TInfo=*/nullptr,
5763 /*BitWidth=*/nullptr,
5764 /*Mutable=*/false,
5765 ICIS_NoInit);
5766 Field->setAccess(AS_public);
5767 CFConstantStringTagDecl->addDecl(Field);
5768 }
5769
5770 CFConstantStringTagDecl->completeDefinition();
5771 // This type is designed to be compatible with NSConstantString, but cannot
5772 // use the same name, since NSConstantString is an interface.
5773 auto tagType = getTagDeclType(CFConstantStringTagDecl);
5774 CFConstantStringTypeDecl =
5775 buildImplicitTypedef(tagType, "__NSConstantString");
5776 }
5777
5778 return CFConstantStringTypeDecl;
5779}
5780
5781RecordDecl *ASTContext::getCFConstantStringTagDecl() const {
5782 if (!CFConstantStringTagDecl)
5783 getCFConstantStringDecl(); // Build the tag and the typedef.
5784 return CFConstantStringTagDecl;
5785}
5786
5787// getCFConstantStringType - Return the type used for constant CFStrings.
5788QualType ASTContext::getCFConstantStringType() const {
5789 return getTypedefType(getCFConstantStringDecl());
5790}
5791
5792QualType ASTContext::getObjCSuperType() const {
5793 if (ObjCSuperType.isNull()) {
5794 RecordDecl *ObjCSuperTypeDecl = buildImplicitRecord("objc_super");
5795 TUDecl->addDecl(ObjCSuperTypeDecl);
5796 ObjCSuperType = getTagDeclType(ObjCSuperTypeDecl);
5797 }
5798 return ObjCSuperType;
5799}
5800
5801void ASTContext::setCFConstantStringType(QualType T) {
5802 const auto *TD = T->getAs<TypedefType>();
5803 assert(TD && "Invalid CFConstantStringType")(static_cast <bool> (TD && "Invalid CFConstantStringType"
) ? void (0) : __assert_fail ("TD && \"Invalid CFConstantStringType\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5803, __extension__ __PRETTY_FUNCTION__))
;
5804 CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());
5805 const auto *TagType =
5806 CFConstantStringTypeDecl->getUnderlyingType()->getAs<RecordType>();
5807 assert(TagType && "Invalid CFConstantStringType")(static_cast <bool> (TagType && "Invalid CFConstantStringType"
) ? void (0) : __assert_fail ("TagType && \"Invalid CFConstantStringType\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/AST/ASTContext.cpp"
, 5807, __extension__ __PRETTY_FUNCTION__))
;
5808 CFConstantStringTagDecl = TagType->getDecl();
5809}
5810
5811QualType ASTContext::getBlockDescriptorType() const {
5812 if (BlockDescriptorType)
5813 return getTagDeclType(BlockDescriptorType);
5814
5815 RecordDecl *RD;
5816 // FIXME: Needs the FlagAppleBlock bit.
5817 RD = buildImplicitRecord("__block_descriptor");
5818 RD->startDefinition();
5819
5820 QualType FieldTypes[] = {
5821 UnsignedLong