Bug Summary

File:tools/clang/lib/AST/ASTContext.cpp
Warning:line 10196, 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-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-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/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-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/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-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/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/FixedPoint.h"
52#include "clang/Basic/IdentifierTable.h"
53#include "clang/Basic/LLVM.h"
54#include "clang/Basic/LangOptions.h"
55#include "clang/Basic/Linkage.h"
56#include "clang/Basic/ObjCRuntime.h"
57#include "clang/Basic/SanitizerBlacklist.h"
58#include "clang/Basic/SourceLocation.h"
59#include "clang/Basic/SourceManager.h"
60#include "clang/Basic/Specifiers.h"
61#include "clang/Basic/TargetCXXABI.h"
62#include "clang/Basic/TargetInfo.h"
63#include "clang/Basic/XRayLists.h"
64#include "llvm/ADT/APInt.h"
65#include "llvm/ADT/APSInt.h"
66#include "llvm/ADT/ArrayRef.h"
67#include "llvm/ADT/DenseMap.h"
68#include "llvm/ADT/DenseSet.h"
69#include "llvm/ADT/FoldingSet.h"
70#include "llvm/ADT/None.h"
71#include "llvm/ADT/Optional.h"
72#include "llvm/ADT/PointerUnion.h"
73#include "llvm/ADT/STLExtras.h"
74#include "llvm/ADT/SmallPtrSet.h"
75#include "llvm/ADT/SmallVector.h"
76#include "llvm/ADT/StringExtras.h"
77#include "llvm/ADT/StringRef.h"
78#include "llvm/ADT/Triple.h"
79#include "llvm/Support/Capacity.h"
80#include "llvm/Support/Casting.h"
81#include "llvm/Support/Compiler.h"
82#include "llvm/Support/ErrorHandling.h"
83#include "llvm/Support/MathExtras.h"
84#include "llvm/Support/raw_ostream.h"
85#include <algorithm>
86#include <cassert>
87#include <cstddef>
88#include <cstdint>
89#include <cstdlib>
90#include <map>
91#include <memory>
92#include <string>
93#include <tuple>
94#include <utility>
95
96using namespace clang;
97
98unsigned ASTContext::NumImplicitDefaultConstructors;
99unsigned ASTContext::NumImplicitDefaultConstructorsDeclared;
100unsigned ASTContext::NumImplicitCopyConstructors;
101unsigned ASTContext::NumImplicitCopyConstructorsDeclared;
102unsigned ASTContext::NumImplicitMoveConstructors;
103unsigned ASTContext::NumImplicitMoveConstructorsDeclared;
104unsigned ASTContext::NumImplicitCopyAssignmentOperators;
105unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
106unsigned ASTContext::NumImplicitMoveAssignmentOperators;
107unsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
108unsigned ASTContext::NumImplicitDestructors;
109unsigned ASTContext::NumImplicitDestructorsDeclared;
110
111enum FloatingRank {
112 Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank
113};
114
115RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
116 if (!CommentsLoaded && ExternalSource) {
117 ExternalSource->ReadComments();
118
119#ifndef NDEBUG
120 ArrayRef<RawComment *> RawComments = Comments.getComments();
121 assert(std::is_sorted(RawComments.begin(), RawComments.end(),((std::is_sorted(RawComments.begin(), RawComments.end(), BeforeThanCompare
<RawComment>(SourceMgr))) ? static_cast<void> (0)
: __assert_fail ("std::is_sorted(RawComments.begin(), RawComments.end(), BeforeThanCompare<RawComment>(SourceMgr))"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 122, __PRETTY_FUNCTION__))
122 BeforeThanCompare<RawComment>(SourceMgr)))((std::is_sorted(RawComments.begin(), RawComments.end(), BeforeThanCompare
<RawComment>(SourceMgr))) ? static_cast<void> (0)
: __assert_fail ("std::is_sorted(RawComments.begin(), RawComments.end(), BeforeThanCompare<RawComment>(SourceMgr))"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 122, __PRETTY_FUNCTION__))
;
123#endif
124
125 CommentsLoaded = true;
126 }
127
128 assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 128, __PRETTY_FUNCTION__))
;
129
130 // User can not attach documentation to implicit declarations.
131 if (D->isImplicit())
132 return nullptr;
133
134 // User can not attach documentation to implicit instantiations.
135 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
136 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
137 return nullptr;
138 }
139
140 if (const auto *VD = dyn_cast<VarDecl>(D)) {
141 if (VD->isStaticDataMember() &&
142 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
143 return nullptr;
144 }
145
146 if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
147 if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
148 return nullptr;
149 }
150
151 if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
152 TemplateSpecializationKind TSK = CTSD->getSpecializationKind();
153 if (TSK == TSK_ImplicitInstantiation ||
154 TSK == TSK_Undeclared)
155 return nullptr;
156 }
157
158 if (const auto *ED = dyn_cast<EnumDecl>(D)) {
159 if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
160 return nullptr;
161 }
162 if (const auto *TD = dyn_cast<TagDecl>(D)) {
163 // When tag declaration (but not definition!) is part of the
164 // decl-specifier-seq of some other declaration, it doesn't get comment
165 if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
166 return nullptr;
167 }
168 // TODO: handle comments for function parameters properly.
169 if (isa<ParmVarDecl>(D))
170 return nullptr;
171
172 // TODO: we could look up template parameter documentation in the template
173 // documentation.
174 if (isa<TemplateTypeParmDecl>(D) ||
175 isa<NonTypeTemplateParmDecl>(D) ||
176 isa<TemplateTemplateParmDecl>(D))
177 return nullptr;
178
179 ArrayRef<RawComment *> RawComments = Comments.getComments();
180
181 // If there are no comments anywhere, we won't find anything.
182 if (RawComments.empty())
183 return nullptr;
184
185 // Find declaration location.
186 // For Objective-C declarations we generally don't expect to have multiple
187 // declarators, thus use declaration starting location as the "declaration
188 // location".
189 // For all other declarations multiple declarators are used quite frequently,
190 // so we use the location of the identifier as the "declaration location".
191 SourceLocation DeclLoc;
192 if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) ||
193 isa<ObjCPropertyDecl>(D) ||
194 isa<RedeclarableTemplateDecl>(D) ||
195 isa<ClassTemplateSpecializationDecl>(D))
196 DeclLoc = D->getBeginLoc();
197 else {
198 DeclLoc = D->getLocation();
199 if (DeclLoc.isMacroID()) {
200 if (isa<TypedefDecl>(D)) {
201 // If location of the typedef name is in a macro, it is because being
202 // declared via a macro. Try using declaration's starting location as
203 // the "declaration location".
204 DeclLoc = D->getBeginLoc();
205 } else if (const auto *TD = dyn_cast<TagDecl>(D)) {
206 // If location of the tag decl is inside a macro, but the spelling of
207 // the tag name comes from a macro argument, it looks like a special
208 // macro like NS_ENUM is being used to define the tag decl. In that
209 // case, adjust the source location to the expansion loc so that we can
210 // attach the comment to the tag decl.
211 if (SourceMgr.isMacroArgExpansion(DeclLoc) &&
212 TD->isCompleteDefinition())
213 DeclLoc = SourceMgr.getExpansionLoc(DeclLoc);
214 }
215 }
216 }
217
218 // If the declaration doesn't map directly to a location in a file, we
219 // can't find the comment.
220 if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
221 return nullptr;
222
223 // Find the comment that occurs just after this declaration.
224 ArrayRef<RawComment *>::iterator Comment;
225 {
226 // When searching for comments during parsing, the comment we are looking
227 // for is usually among the last two comments we parsed -- check them
228 // first.
229 RawComment CommentAtDeclLoc(
230 SourceMgr, SourceRange(DeclLoc), LangOpts.CommentOpts, false);
231 BeforeThanCompare<RawComment> Compare(SourceMgr);
232 ArrayRef<RawComment *>::iterator MaybeBeforeDecl = RawComments.end() - 1;
233 bool Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
234 if (!Found && RawComments.size() >= 2) {
235 MaybeBeforeDecl--;
236 Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
237 }
238
239 if (Found) {
240 Comment = MaybeBeforeDecl + 1;
241 assert(Comment == std::lower_bound(RawComments.begin(), RawComments.end(),((Comment == std::lower_bound(RawComments.begin(), RawComments
.end(), &CommentAtDeclLoc, Compare)) ? static_cast<void
> (0) : __assert_fail ("Comment == std::lower_bound(RawComments.begin(), RawComments.end(), &CommentAtDeclLoc, Compare)"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 242, __PRETTY_FUNCTION__))
242 &CommentAtDeclLoc, Compare))((Comment == std::lower_bound(RawComments.begin(), RawComments
.end(), &CommentAtDeclLoc, Compare)) ? static_cast<void
> (0) : __assert_fail ("Comment == std::lower_bound(RawComments.begin(), RawComments.end(), &CommentAtDeclLoc, Compare)"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 242, __PRETTY_FUNCTION__))
;
243 } else {
244 // Slow path.
245 Comment = std::lower_bound(RawComments.begin(), RawComments.end(),
246 &CommentAtDeclLoc, Compare);
247 }
248 }
249
250 // Decompose the location for the declaration and find the beginning of the
251 // file buffer.
252 std::pair<FileID, unsigned> DeclLocDecomp = SourceMgr.getDecomposedLoc(DeclLoc);
253
254 // First check whether we have a trailing comment.
255 if (Comment != RawComments.end() &&
256 ((*Comment)->isDocumentation() || LangOpts.CommentOpts.ParseAllComments)
257 && (*Comment)->isTrailingComment() &&
258 (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D) ||
259 isa<ObjCMethodDecl>(D) || isa<ObjCPropertyDecl>(D))) {
260 std::pair<FileID, unsigned> CommentBeginDecomp
261 = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getBegin());
262 // Check that Doxygen trailing comment comes after the declaration, starts
263 // on the same line and in the same file as the declaration.
264 if (DeclLocDecomp.first == CommentBeginDecomp.first &&
265 SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second)
266 == SourceMgr.getLineNumber(CommentBeginDecomp.first,
267 CommentBeginDecomp.second)) {
268 return *Comment;
269 }
270 }
271
272 // The comment just after the declaration was not a trailing comment.
273 // Let's look at the previous comment.
274 if (Comment == RawComments.begin())
275 return nullptr;
276 --Comment;
277
278 // Check that we actually have a non-member Doxygen comment.
279 if (!((*Comment)->isDocumentation() ||
280 LangOpts.CommentOpts.ParseAllComments) ||
281 (*Comment)->isTrailingComment())
282 return nullptr;
283
284 // Decompose the end of the comment.
285 std::pair<FileID, unsigned> CommentEndDecomp
286 = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getEnd());
287
288 // If the comment and the declaration aren't in the same file, then they
289 // aren't related.
290 if (DeclLocDecomp.first != CommentEndDecomp.first)
291 return nullptr;
292
293 // Get the corresponding buffer.
294 bool Invalid = false;
295 const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,
296 &Invalid).data();
297 if (Invalid)
298 return nullptr;
299
300 // Extract text between the comment and declaration.
301 StringRef Text(Buffer + CommentEndDecomp.second,
302 DeclLocDecomp.second - CommentEndDecomp.second);
303
304 // There should be no other declarations or preprocessor directives between
305 // comment and declaration.
306 if (Text.find_first_of(";{}#@") != StringRef::npos)
307 return nullptr;
308
309 return *Comment;
310}
311
312/// If we have a 'templated' declaration for a template, adjust 'D' to
313/// refer to the actual template.
314/// If we have an implicit instantiation, adjust 'D' to refer to template.
315static const Decl *adjustDeclToTemplate(const Decl *D) {
316 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
317 // Is this function declaration part of a function template?
318 if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
319 return FTD;
320
321 // Nothing to do if function is not an implicit instantiation.
322 if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
323 return D;
324
325 // Function is an implicit instantiation of a function template?
326 if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())
327 return FTD;
328
329 // Function is instantiated from a member definition of a class template?
330 if (const FunctionDecl *MemberDecl =
331 FD->getInstantiatedFromMemberFunction())
332 return MemberDecl;
333
334 return D;
335 }
336 if (const auto *VD = dyn_cast<VarDecl>(D)) {
337 // Static data member is instantiated from a member definition of a class
338 // template?
339 if (VD->isStaticDataMember())
340 if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember())
341 return MemberDecl;
342
343 return D;
344 }
345 if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
346 // Is this class declaration part of a class template?
347 if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate())
348 return CTD;
349
350 // Class is an implicit instantiation of a class template or partial
351 // specialization?
352 if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
353 if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation)
354 return D;
355 llvm::PointerUnion<ClassTemplateDecl *,
356 ClassTemplatePartialSpecializationDecl *>
357 PU = CTSD->getSpecializedTemplateOrPartial();
358 return PU.is<ClassTemplateDecl*>() ?
359 static_cast<const Decl*>(PU.get<ClassTemplateDecl *>()) :
360 static_cast<const Decl*>(
361 PU.get<ClassTemplatePartialSpecializationDecl *>());
362 }
363
364 // Class is instantiated from a member definition of a class template?
365 if (const MemberSpecializationInfo *Info =
366 CRD->getMemberSpecializationInfo())
367 return Info->getInstantiatedFrom();
368
369 return D;
370 }
371 if (const auto *ED = dyn_cast<EnumDecl>(D)) {
372 // Enum is instantiated from a member definition of a class template?
373 if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum())
374 return MemberDecl;
375
376 return D;
377 }
378 // FIXME: Adjust alias templates?
379 return D;
380}
381
382const RawComment *ASTContext::getRawCommentForAnyRedecl(
383 const Decl *D,
384 const Decl **OriginalDecl) const {
385 D = adjustDeclToTemplate(D);
386
387 // Check whether we have cached a comment for this declaration already.
388 {
389 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
390 RedeclComments.find(D);
391 if (Pos != RedeclComments.end()) {
392 const RawCommentAndCacheFlags &Raw = Pos->second;
393 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) {
394 if (OriginalDecl)
395 *OriginalDecl = Raw.getOriginalDecl();
396 return Raw.getRaw();
397 }
398 }
399 }
400
401 // Search for comments attached to declarations in the redeclaration chain.
402 const RawComment *RC = nullptr;
403 const Decl *OriginalDeclForRC = nullptr;
404 for (auto I : D->redecls()) {
405 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
406 RedeclComments.find(I);
407 if (Pos != RedeclComments.end()) {
408 const RawCommentAndCacheFlags &Raw = Pos->second;
409 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) {
410 RC = Raw.getRaw();
411 OriginalDeclForRC = Raw.getOriginalDecl();
412 break;
413 }
414 } else {
415 RC = getRawCommentForDeclNoCache(I);
416 OriginalDeclForRC = I;
417 RawCommentAndCacheFlags Raw;
418 if (RC) {
419 // Call order swapped to work around ICE in VS2015 RTM (Release Win32)
420 // https://connect.microsoft.com/VisualStudio/feedback/details/1741530
421 Raw.setKind(RawCommentAndCacheFlags::FromDecl);
422 Raw.setRaw(RC);
423 } else
424 Raw.setKind(RawCommentAndCacheFlags::NoCommentInDecl);
425 Raw.setOriginalDecl(I);
426 RedeclComments[I] = Raw;
427 if (RC)
428 break;
429 }
430 }
431
432 // If we found a comment, it should be a documentation comment.
433 assert(!RC || RC->isDocumentation() || LangOpts.CommentOpts.ParseAllComments)((!RC || RC->isDocumentation() || LangOpts.CommentOpts.ParseAllComments
) ? static_cast<void> (0) : __assert_fail ("!RC || RC->isDocumentation() || LangOpts.CommentOpts.ParseAllComments"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 433, __PRETTY_FUNCTION__))
;
434
435 if (OriginalDecl)
436 *OriginalDecl = OriginalDeclForRC;
437
438 // Update cache for every declaration in the redeclaration chain.
439 RawCommentAndCacheFlags Raw;
440 Raw.setRaw(RC);
441 Raw.setKind(RawCommentAndCacheFlags::FromRedecl);
442 Raw.setOriginalDecl(OriginalDeclForRC);
443
444 for (auto I : D->redecls()) {
445 RawCommentAndCacheFlags &R = RedeclComments[I];
446 if (R.getKind() == RawCommentAndCacheFlags::NoCommentInDecl)
447 R = Raw;
448 }
449
450 return RC;
451}
452
453static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod,
454 SmallVectorImpl<const NamedDecl *> &Redeclared) {
455 const DeclContext *DC = ObjCMethod->getDeclContext();
456 if (const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {
457 const ObjCInterfaceDecl *ID = IMD->getClassInterface();
458 if (!ID)
459 return;
460 // Add redeclared method here.
461 for (const auto *Ext : ID->known_extensions()) {
462 if (ObjCMethodDecl *RedeclaredMethod =
463 Ext->getMethod(ObjCMethod->getSelector(),
464 ObjCMethod->isInstanceMethod()))
465 Redeclared.push_back(RedeclaredMethod);
466 }
467 }
468}
469
470comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC,
471 const Decl *D) const {
472 auto *ThisDeclInfo = new (*this) comments::DeclInfo;
473 ThisDeclInfo->CommentDecl = D;
474 ThisDeclInfo->IsFilled = false;
475 ThisDeclInfo->fill();
476 ThisDeclInfo->CommentDecl = FC->getDecl();
477 if (!ThisDeclInfo->TemplateParameters)
478 ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;
479 comments::FullComment *CFC =
480 new (*this) comments::FullComment(FC->getBlocks(),
481 ThisDeclInfo);
482 return CFC;
483}
484
485comments::FullComment *ASTContext::getLocalCommentForDeclUncached(const Decl *D) const {
486 const RawComment *RC = getRawCommentForDeclNoCache(D);
487 return RC ? RC->parse(*this, nullptr, D) : nullptr;
488}
489
490comments::FullComment *ASTContext::getCommentForDecl(
491 const Decl *D,
492 const Preprocessor *PP) const {
493 if (D->isInvalidDecl())
494 return nullptr;
495 D = adjustDeclToTemplate(D);
496
497 const Decl *Canonical = D->getCanonicalDecl();
498 llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
499 ParsedComments.find(Canonical);
500
501 if (Pos != ParsedComments.end()) {
502 if (Canonical != D) {
503 comments::FullComment *FC = Pos->second;
504 comments::FullComment *CFC = cloneFullComment(FC, D);
505 return CFC;
506 }
507 return Pos->second;
508 }
509
510 const Decl *OriginalDecl;
511
512 const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);
513 if (!RC) {
514 if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
515 SmallVector<const NamedDecl*, 8> Overridden;
516 const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
517 if (OMD && OMD->isPropertyAccessor())
518 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
519 if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))
520 return cloneFullComment(FC, D);
521 if (OMD)
522 addRedeclaredMethods(OMD, Overridden);
523 getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden);
524 for (unsigned i = 0, e = Overridden.size(); i < e; i++)
525 if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP))
526 return cloneFullComment(FC, D);
527 }
528 else if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
529 // Attach any tag type's documentation to its typedef if latter
530 // does not have one of its own.
531 QualType QT = TD->getUnderlyingType();
532 if (const auto *TT = QT->getAs<TagType>())
533 if (const Decl *TD = TT->getDecl())
534 if (comments::FullComment *FC = getCommentForDecl(TD, PP))
535 return cloneFullComment(FC, D);
536 }
537 else if (const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
538 while (IC->getSuperClass()) {
539 IC = IC->getSuperClass();
540 if (comments::FullComment *FC = getCommentForDecl(IC, PP))
541 return cloneFullComment(FC, D);
542 }
543 }
544 else if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {
545 if (const ObjCInterfaceDecl *IC = CD->getClassInterface())
546 if (comments::FullComment *FC = getCommentForDecl(IC, PP))
547 return cloneFullComment(FC, D);
548 }
549 else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
550 if (!(RD = RD->getDefinition()))
551 return nullptr;
552 // Check non-virtual bases.
553 for (const auto &I : RD->bases()) {
554 if (I.isVirtual() || (I.getAccessSpecifier() != AS_public))
555 continue;
556 QualType Ty = I.getType();
557 if (Ty.isNull())
558 continue;
559 if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) {
560 if (!(NonVirtualBase= NonVirtualBase->getDefinition()))
561 continue;
562
563 if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP))
564 return cloneFullComment(FC, D);
565 }
566 }
567 // Check virtual bases.
568 for (const auto &I : RD->vbases()) {
569 if (I.getAccessSpecifier() != AS_public)
570 continue;
571 QualType Ty = I.getType();
572 if (Ty.isNull())
573 continue;
574 if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) {
575 if (!(VirtualBase= VirtualBase->getDefinition()))
576 continue;
577 if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP))
578 return cloneFullComment(FC, D);
579 }
580 }
581 }
582 return nullptr;
583 }
584
585 // If the RawComment was attached to other redeclaration of this Decl, we
586 // should parse the comment in context of that other Decl. This is important
587 // because comments can contain references to parameter names which can be
588 // different across redeclarations.
589 if (D != OriginalDecl)
590 return getCommentForDecl(OriginalDecl, PP);
591
592 comments::FullComment *FC = RC->parse(*this, PP, D);
593 ParsedComments[Canonical] = FC;
594 return FC;
595}
596
597void
598ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
599 TemplateTemplateParmDecl *Parm) {
600 ID.AddInteger(Parm->getDepth());
601 ID.AddInteger(Parm->getPosition());
602 ID.AddBoolean(Parm->isParameterPack());
603
604 TemplateParameterList *Params = Parm->getTemplateParameters();
605 ID.AddInteger(Params->size());
606 for (TemplateParameterList::const_iterator P = Params->begin(),
607 PEnd = Params->end();
608 P != PEnd; ++P) {
609 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
610 ID.AddInteger(0);
611 ID.AddBoolean(TTP->isParameterPack());
612 continue;
613 }
614
615 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
616 ID.AddInteger(1);
617 ID.AddBoolean(NTTP->isParameterPack());
618 ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
619 if (NTTP->isExpandedParameterPack()) {
620 ID.AddBoolean(true);
621 ID.AddInteger(NTTP->getNumExpansionTypes());
622 for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
623 QualType T = NTTP->getExpansionType(I);
624 ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
625 }
626 } else
627 ID.AddBoolean(false);
628 continue;
629 }
630
631 auto *TTP = cast<TemplateTemplateParmDecl>(*P);
632 ID.AddInteger(2);
633 Profile(ID, TTP);
634 }
635}
636
637TemplateTemplateParmDecl *
638ASTContext::getCanonicalTemplateTemplateParmDecl(
639 TemplateTemplateParmDecl *TTP) const {
640 // Check if we already have a canonical template template parameter.
641 llvm::FoldingSetNodeID ID;
642 CanonicalTemplateTemplateParm::Profile(ID, TTP);
643 void *InsertPos = nullptr;
644 CanonicalTemplateTemplateParm *Canonical
645 = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
646 if (Canonical)
647 return Canonical->getParam();
648
649 // Build a canonical template parameter list.
650 TemplateParameterList *Params = TTP->getTemplateParameters();
651 SmallVector<NamedDecl *, 4> CanonParams;
652 CanonParams.reserve(Params->size());
653 for (TemplateParameterList::const_iterator P = Params->begin(),
654 PEnd = Params->end();
655 P != PEnd; ++P) {
656 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P))
657 CanonParams.push_back(
658 TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(),
659 SourceLocation(),
660 SourceLocation(),
661 TTP->getDepth(),
662 TTP->getIndex(), nullptr, false,
663 TTP->isParameterPack()));
664 else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
665 QualType T = getCanonicalType(NTTP->getType());
666 TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
667 NonTypeTemplateParmDecl *Param;
668 if (NTTP->isExpandedParameterPack()) {
669 SmallVector<QualType, 2> ExpandedTypes;
670 SmallVector<TypeSourceInfo *, 2> ExpandedTInfos;
671 for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
672 ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I)));
673 ExpandedTInfos.push_back(
674 getTrivialTypeSourceInfo(ExpandedTypes.back()));
675 }
676
677 Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
678 SourceLocation(),
679 SourceLocation(),
680 NTTP->getDepth(),
681 NTTP->getPosition(), nullptr,
682 T,
683 TInfo,
684 ExpandedTypes,
685 ExpandedTInfos);
686 } else {
687 Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
688 SourceLocation(),
689 SourceLocation(),
690 NTTP->getDepth(),
691 NTTP->getPosition(), nullptr,
692 T,
693 NTTP->isParameterPack(),
694 TInfo);
695 }
696 CanonParams.push_back(Param);
697
698 } else
699 CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
700 cast<TemplateTemplateParmDecl>(*P)));
701 }
702
703 assert(!TTP->getRequiresClause() &&((!TTP->getRequiresClause() && "Unexpected requires-clause on template template-parameter"
) ? static_cast<void> (0) : __assert_fail ("!TTP->getRequiresClause() && \"Unexpected requires-clause on template template-parameter\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 704, __PRETTY_FUNCTION__))
704 "Unexpected requires-clause on template template-parameter")((!TTP->getRequiresClause() && "Unexpected requires-clause on template template-parameter"
) ? static_cast<void> (0) : __assert_fail ("!TTP->getRequiresClause() && \"Unexpected requires-clause on template template-parameter\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 704, __PRETTY_FUNCTION__))
;
705 Expr *const CanonRequiresClause = nullptr;
706
707 TemplateTemplateParmDecl *CanonTTP
708 = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
709 SourceLocation(), TTP->getDepth(),
710 TTP->getPosition(),
711 TTP->isParameterPack(),
712 nullptr,
713 TemplateParameterList::Create(*this, SourceLocation(),
714 SourceLocation(),
715 CanonParams,
716 SourceLocation(),
717 CanonRequiresClause));
718
719 // Get the new insert position for the node we care about.
720 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
721 assert(!Canonical && "Shouldn't be in the map!")((!Canonical && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!Canonical && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 721, __PRETTY_FUNCTION__))
;
722 (void)Canonical;
723
724 // Create the canonical template template parameter entry.
725 Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);
726 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
727 return CanonTTP;
728}
729
730CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
731 if (!LangOpts.CPlusPlus) return nullptr;
732
733 switch (T.getCXXABI().getKind()) {
734 case TargetCXXABI::GenericARM: // Same as Itanium at this level
735 case TargetCXXABI::iOS:
736 case TargetCXXABI::iOS64:
737 case TargetCXXABI::WatchOS:
738 case TargetCXXABI::GenericAArch64:
739 case TargetCXXABI::GenericMIPS:
740 case TargetCXXABI::GenericItanium:
741 case TargetCXXABI::WebAssembly:
742 return CreateItaniumCXXABI(*this);
743 case TargetCXXABI::Microsoft:
744 return CreateMicrosoftCXXABI(*this);
745 }
746 llvm_unreachable("Invalid CXXABI type!")::llvm::llvm_unreachable_internal("Invalid CXXABI type!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 746)
;
747}
748
749static const LangASMap *getAddressSpaceMap(const TargetInfo &T,
750 const LangOptions &LOpts) {
751 if (LOpts.FakeAddressSpaceMap) {
752 // The fake address space map must have a distinct entry for each
753 // language-specific address space.
754 static const unsigned FakeAddrSpaceMap[] = {
755 0, // Default
756 1, // opencl_global
757 3, // opencl_local
758 2, // opencl_constant
759 0, // opencl_private
760 4, // opencl_generic
761 5, // cuda_device
762 6, // cuda_constant
763 7 // cuda_shared
764 };
765 return &FakeAddrSpaceMap;
766 } else {
767 return &T.getAddressSpaceMap();
768 }
769}
770
771static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI,
772 const LangOptions &LangOpts) {
773 switch (LangOpts.getAddressSpaceMapMangling()) {
774 case LangOptions::ASMM_Target:
775 return TI.useAddressSpaceMapMangling();
776 case LangOptions::ASMM_On:
777 return true;
778 case LangOptions::ASMM_Off:
779 return false;
780 }
781 llvm_unreachable("getAddressSpaceMapMangling() doesn't cover anything.")::llvm::llvm_unreachable_internal("getAddressSpaceMapMangling() doesn't cover anything."
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 781)
;
782}
783
784ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM,
785 IdentifierTable &idents, SelectorTable &sels,
786 Builtin::Context &builtins)
787 : FunctionProtoTypes(this_()), TemplateSpecializationTypes(this_()),
788 DependentTemplateSpecializationTypes(this_()),
789 SubstTemplateTemplateParmPacks(this_()), SourceMgr(SM), LangOpts(LOpts),
790 SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
791 XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
792 LangOpts.XRayNeverInstrumentFiles,
793 LangOpts.XRayAttrListFiles, SM)),
794 PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
795 BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
796 CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
797 CompCategories(this_()), LastSDM(nullptr, 0) {
798 TUDecl = TranslationUnitDecl::Create(*this);
799}
800
801ASTContext::~ASTContext() {
802 ReleaseParentMapEntries();
803
804 // Release the DenseMaps associated with DeclContext objects.
805 // FIXME: Is this the ideal solution?
806 ReleaseDeclContextMaps();
807
808 // Call all of the deallocation functions on all of their targets.
809 for (auto &Pair : Deallocations)
810 (Pair.first)(Pair.second);
811
812 // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed
813 // because they can contain DenseMaps.
814 for (llvm::DenseMap<const ObjCContainerDecl*,
815 const ASTRecordLayout*>::iterator
816 I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
817 // Increment in loop to prevent using deallocated memory.
818 if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
819 R->Destroy(*this);
820
821 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
822 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
823 // Increment in loop to prevent using deallocated memory.
824 if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
825 R->Destroy(*this);
826 }
827
828 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
829 AEnd = DeclAttrs.end();
830 A != AEnd; ++A)
831 A->second->~AttrVec();
832
833 for (std::pair<const MaterializeTemporaryExpr *, APValue *> &MTVPair :
834 MaterializedTemporaryValues)
835 MTVPair.second->~APValue();
836
837 for (const auto &Value : ModuleInitializers)
838 Value.second->~PerModuleInitializers();
839}
840
841void ASTContext::ReleaseParentMapEntries() {
842 if (!PointerParents) return;
843 for (const auto &Entry : *PointerParents) {
844 if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
845 delete Entry.second.get<ast_type_traits::DynTypedNode *>();
846 } else if (Entry.second.is<ParentVector *>()) {
847 delete Entry.second.get<ParentVector *>();
848 }
849 }
850 for (const auto &Entry : *OtherParents) {
851 if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
852 delete Entry.second.get<ast_type_traits::DynTypedNode *>();
853 } else if (Entry.second.is<ParentVector *>()) {
854 delete Entry.second.get<ParentVector *>();
855 }
856 }
857}
858
859void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) {
860 Deallocations.push_back({Callback, Data});
861}
862
863void
864ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) {
865 ExternalSource = std::move(Source);
866}
867
868void ASTContext::PrintStats() const {
869 llvm::errs() << "\n*** AST Context Stats:\n";
870 llvm::errs() << " " << Types.size() << " types total.\n";
871
872 unsigned counts[] = {
873#define TYPE(Name, Parent) 0,
874#define ABSTRACT_TYPE(Name, Parent)
875#include "clang/AST/TypeNodes.def"
876 0 // Extra
877 };
878
879 for (unsigned i = 0, e = Types.size(); i != e; ++i) {
880 Type *T = Types[i];
881 counts[(unsigned)T->getTypeClass()]++;
882 }
883
884 unsigned Idx = 0;
885 unsigned TotalBytes = 0;
886#define TYPE(Name, Parent) \
887 if (counts[Idx]) \
888 llvm::errs() << " " << counts[Idx] << " " << #Name \
889 << " types, " << sizeof(Name##Type) << " each " \
890 << "(" << counts[Idx] * sizeof(Name##Type) \
891 << " bytes)\n"; \
892 TotalBytes += counts[Idx] * sizeof(Name##Type); \
893 ++Idx;
894#define ABSTRACT_TYPE(Name, Parent)
895#include "clang/AST/TypeNodes.def"
896
897 llvm::errs() << "Total bytes = " << TotalBytes << "\n";
898
899 // Implicit special member functions.
900 llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/"
901 << NumImplicitDefaultConstructors
902 << " implicit default constructors created\n";
903 llvm::errs() << NumImplicitCopyConstructorsDeclared << "/"
904 << NumImplicitCopyConstructors
905 << " implicit copy constructors created\n";
906 if (getLangOpts().CPlusPlus)
907 llvm::errs() << NumImplicitMoveConstructorsDeclared << "/"
908 << NumImplicitMoveConstructors
909 << " implicit move constructors created\n";
910 llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/"
911 << NumImplicitCopyAssignmentOperators
912 << " implicit copy assignment operators created\n";
913 if (getLangOpts().CPlusPlus)
914 llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/"
915 << NumImplicitMoveAssignmentOperators
916 << " implicit move assignment operators created\n";
917 llvm::errs() << NumImplicitDestructorsDeclared << "/"
918 << NumImplicitDestructors
919 << " implicit destructors created\n";
920
921 if (ExternalSource) {
922 llvm::errs() << "\n";
923 ExternalSource->PrintStats();
924 }
925
926 BumpAlloc.PrintStats();
927}
928
929void ASTContext::mergeDefinitionIntoModule(NamedDecl *ND, Module *M,
930 bool NotifyListeners) {
931 if (NotifyListeners)
932 if (auto *Listener = getASTMutationListener())
933 Listener->RedefinedHiddenDefinition(ND, M);
934
935 MergedDefModules[cast<NamedDecl>(ND->getCanonicalDecl())].push_back(M);
936}
937
938void ASTContext::deduplicateMergedDefinitonsFor(NamedDecl *ND) {
939 auto It = MergedDefModules.find(cast<NamedDecl>(ND->getCanonicalDecl()));
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")((Source && "lazy initializers but no external source"
) ? static_cast<void> (0) : __assert_fail ("Source && \"lazy initializers but no external source\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 956, __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() &&((LazyInitializers.empty() && "GetExternalDecl for lazy module initializer added more inits"
) ? static_cast<void> (0) : __assert_fail ("LazyInitializers.empty() && \"GetExternalDecl for lazy module initializer added more inits\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 965, __PRETTY_FUNCTION__))
965 "GetExternalDecl for lazy module initializer added more inits")((LazyInitializers.empty() && "GetExternalDecl for lazy module initializer added more inits"
) ? static_cast<void> (0) : __assert_fail ("LazyInitializers.empty() && \"GetExternalDecl for lazy module initializer added more inits\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 965, __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) &&(((!this->Target || this->Target == &Target) &&
"Incorrect target reinitialization") ? static_cast<void>
(0) : __assert_fail ("(!this->Target || this->Target == &Target) && \"Incorrect target reinitialization\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1092, __PRETTY_FUNCTION__))
1092 "Incorrect target reinitialization")(((!this->Target || this->Target == &Target) &&
"Incorrect target reinitialization") ? static_cast<void>
(0) : __assert_fail ("(!this->Target || this->Target == &Target) && \"Incorrect target reinitialization\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1092, __PRETTY_FUNCTION__))
;
1093 assert(VoidTy.isNull() && "Context reinitialized?")((VoidTy.isNull() && "Context reinitialized?") ? static_cast
<void> (0) : __assert_fail ("VoidTy.isNull() && \"Context reinitialized?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1093, __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")((Var->isStaticDataMember() && "Not a static data member"
) ? static_cast<void> (0) : __assert_fail ("Var->isStaticDataMember() && \"Not a static data member\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1300, __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")((Inst->isStaticDataMember() && "Not a static data member"
) ? static_cast<void> (0) : __assert_fail ("Inst->isStaticDataMember() && \"Not a static data member\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1319, __PRETTY_FUNCTION__))
;
1320 assert(Tmpl->isStaticDataMember() && "Not a static data member")((Tmpl->isStaticDataMember() && "Not a static data member"
) ? static_cast<void> (0) : __assert_fail ("Tmpl->isStaticDataMember() && \"Not a static data member\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1320, __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] &&((!TemplateOrInstantiation[Inst] && "Already noted what the variable was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!TemplateOrInstantiation[Inst] && \"Already noted what the variable was instantiated from\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1329, __PRETTY_FUNCTION__))
1329 "Already noted what the variable was instantiated from")((!TemplateOrInstantiation[Inst] && "Already noted what the variable was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!TemplateOrInstantiation[Inst] && \"Already noted what the variable was instantiated from\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1329, __PRETTY_FUNCTION__))
;
1330 TemplateOrInstantiation[Inst] = TSI;
1331}
1332
1333FunctionDecl *ASTContext::getClassScopeSpecializationPattern(
1334 const FunctionDecl *FD){
1335 assert(FD && "Specialization is 0")((FD && "Specialization is 0") ? static_cast<void>
(0) : __assert_fail ("FD && \"Specialization is 0\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1335, __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")((FD && "Specialization is 0") ? static_cast<void>
(0) : __assert_fail ("FD && \"Specialization is 0\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1346, __PRETTY_FUNCTION__))
;
1347 assert(Pattern && "Class scope specialization pattern is 0")((Pattern && "Class scope specialization pattern is 0"
) ? static_cast<void> (0) : __assert_fail ("Pattern && \"Class scope specialization pattern is 0\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1347, __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) ||(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __PRETTY_FUNCTION__))
1363 isa<UnresolvedUsingValueDecl>(Pattern) ||(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __PRETTY_FUNCTION__))
1364 isa<UnresolvedUsingTypenameDecl>(Pattern)) &&(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __PRETTY_FUNCTION__))
1365 "pattern decl is not a using decl")(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __PRETTY_FUNCTION__))
;
1366 assert((isa<UsingDecl>(Inst) ||(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
"instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __PRETTY_FUNCTION__))
1367 isa<UnresolvedUsingValueDecl>(Inst) ||(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
"instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __PRETTY_FUNCTION__))
1368 isa<UnresolvedUsingTypenameDecl>(Inst)) &&(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
"instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __PRETTY_FUNCTION__))
1369 "instantiation did not produce a using decl")(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
"instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __PRETTY_FUNCTION__))
;
1370 assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists")((!InstantiatedFromUsingDecl[Inst] && "pattern already exists"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUsingDecl[Inst] && \"pattern already exists\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1370, __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")((!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUsingShadowDecl[Inst] && \"pattern already exists\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1387, __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")((!Inst->getDeclName() && "Instantiated field decl is not unnamed"
) ? static_cast<void> (0) : __assert_fail ("!Inst->getDeclName() && \"Instantiated field decl is not unnamed\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1402, __PRETTY_FUNCTION__))
;
1403 assert(!Tmpl->getDeclName() && "Template field decl is not unnamed")((!Tmpl->getDeclName() && "Template field decl is not unnamed"
) ? static_cast<void> (0) : __assert_fail ("!Tmpl->getDeclName() && \"Template field decl is not unnamed\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1403, __PRETTY_FUNCTION__))
;
1404 assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&((!InstantiatedFromUnnamedFieldDecl[Inst] && "Already noted what unnamed field was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUnnamedFieldDecl[Inst] && \"Already noted what unnamed field was instantiated from\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1405, __PRETTY_FUNCTION__))
1405 "Already noted what unnamed field was instantiated from")((!InstantiatedFromUnnamedFieldDecl[Inst] && "Already noted what unnamed field was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUnnamedFieldDecl[Inst] && \"Already noted what unnamed field was instantiated from\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1405, __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())((Method->isCanonicalDecl() && Overridden->isCanonicalDecl
()) ? static_cast<void> (0) : __assert_fail ("Method->isCanonicalDecl() && Overridden->isCanonicalDecl()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1437, __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)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1444, __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")((!Import->NextLocalImport && "Import declaration already in the chain"
) ? static_cast<void> (0) : __assert_fail ("!Import->NextLocalImport && \"Import declaration already in the chain\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1462, __PRETTY_FUNCTION__))
;
1463 assert(!Import->isFromASTFile() && "Non-local import declaration")((!Import->isFromASTFile() && "Non-local import declaration"
) ? static_cast<void> (0) : __assert_fail ("!Import->isFromASTFile() && \"Non-local import declaration\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1463, __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!")((BT && "Not a floating point type!") ? static_cast<
void> (0) : __assert_fail ("BT && \"Not a floating point type!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1482, __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-8~svn345461/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()) <=(((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity
()) <= (uint64_t)(-1)/Size) && "Overflow in array type char size evaluation"
) ? static_cast<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-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1620, __PRETTY_FUNCTION__))
1619 (uint64_t)(-1)/Size) &&(((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity
()) <= (uint64_t)(-1)/Size) && "Overflow in array type char size evaluation"
) ? static_cast<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-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1620, __PRETTY_FUNCTION__))
1620 "Overflow in array type char size evaluation")(((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity
()) <= (uint64_t)(-1)/Size) && "Overflow in array type char size evaluation"
) ? static_cast<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-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1620, __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")((!T->isDependentType() && "should not see dependent types here"
) ? static_cast<void> (0) : __assert_fail ("!T->isDependentType() && \"should not see dependent types here\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1705, __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-8~svn345461/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) &&(((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&
"Overflow in array type bit size evaluation") ? static_cast<
void> (0) : __assert_fail ("(Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) && \"Overflow in array type bit size evaluation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1729, __PRETTY_FUNCTION__))
1729 "Overflow in array type bit size evaluation")(((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&
"Overflow in array type bit size evaluation") ? static_cast<
void> (0) : __assert_fail ("(Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) && \"Overflow in array type bit size evaluation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1729, __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-8~svn345461/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() &&((!A->getDeducedType().isNull() && "cannot request the size of an undeduced or dependent auto type"
) ? static_cast<void> (0) : __assert_fail ("!A->getDeducedType().isNull() && \"cannot request the size of an undeduced or dependent auto type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1989, __PRETTY_FUNCTION__))
1989 "cannot request the size of an undeduced or dependent auto type")((!A->getDeducedType().isNull() && "cannot request the size of an undeduced or dependent auto type"
) ? static_cast<void> (0) : __assert_fail ("!A->getDeducedType().isNull() && \"cannot request the size of an undeduced or dependent auto type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1989, __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)((Align) ? static_cast<void> (0) : __assert_fail ("Align"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2033, __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")((llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"
) ? static_cast<void> (0) : __assert_fail ("llvm::isPowerOf2_32(Align) && \"Alignment must be power of 2\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2055, __PRETTY_FUNCTION__))
;
2056 return TypeInfo(Width, Align, AlignIsRequired);
2057}
2058
2059unsigned ASTContext::getTypeUnadjustedAlign(const Type *T) const {
2060 UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(T);
2061 if (I != MemoizedUnadjustedAlign.end())
2062 return I->second;
2063
2064 unsigned UnadjustedAlign;
2065 if (const auto *RT = T->getAs<RecordType>()) {
2066 const RecordDecl *RD = RT->getDecl();
2067 const ASTRecordLayout &Layout = getASTRecordLayout(RD);
2068 UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
2069 } else if (const auto *ObjCI = T->getAs<ObjCInterfaceType>()) {
2070 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
2071 UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
2072 } else {
2073 UnadjustedAlign = getTypeAlign(T);
2074 }
2075
2076 MemoizedUnadjustedAlign[T] = UnadjustedAlign;
2077 return UnadjustedAlign;
2078}
2079
2080unsigned ASTContext::getOpenMPDefaultSimdAlign(QualType T) const {
2081 unsigned SimdAlign = getTargetInfo().getSimdDefaultAlign();
2082 // Target ppc64 with QPX: simd default alignment for pointer to double is 32.
2083 if ((getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64 ||
2084 getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64le) &&
2085 getTargetInfo().getABI() == "elfv1-qpx" &&
2086 T->isSpecificBuiltinType(BuiltinType::Double))
2087 SimdAlign = 256;
2088 return SimdAlign;
2089}
2090
2091/// toCharUnitsFromBits - Convert a size in bits to a size in characters.
2092CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const {
2093 return CharUnits::fromQuantity(BitSize / getCharWidth());
2094}
2095
2096/// toBits - Convert a size in characters to a size in characters.
2097int64_t ASTContext::toBits(CharUnits CharSize) const {
2098 return CharSize.getQuantity() * getCharWidth();
2099}
2100
2101/// getTypeSizeInChars - Return the size of the specified type, in characters.
2102/// This method does not work on incomplete types.
2103CharUnits ASTContext::getTypeSizeInChars(QualType T) const {
2104 return getTypeInfoInChars(T).first;
2105}
2106CharUnits ASTContext::getTypeSizeInChars(const Type *T) const {
2107 return getTypeInfoInChars(T).first;
2108}
2109
2110/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in
2111/// characters. This method does not work on incomplete types.
2112CharUnits ASTContext::getTypeAlignInChars(QualType T) const {
2113 return toCharUnitsFromBits(getTypeAlign(T));
2114}
2115CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
2116 return toCharUnitsFromBits(getTypeAlign(T));
2117}
2118
2119/// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a
2120/// type, in characters, before alignment adustments. This method does
2121/// not work on incomplete types.
2122CharUnits ASTContext::getTypeUnadjustedAlignInChars(QualType T) const {
2123 return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
2124}
2125CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const {
2126 return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
2127}
2128
2129/// getPreferredTypeAlign - Return the "preferred" alignment of the specified
2130/// type for the current target in bits. This can be different than the ABI
2131/// alignment in cases where it is beneficial for performance to overalign
2132/// a data type.
2133unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
2134 TypeInfo TI = getTypeInfo(T);
2135 unsigned ABIAlign = TI.Align;
2136
2137 T = T->getBaseElementTypeUnsafe();
2138
2139 // The preferred alignment of member pointers is that of a pointer.
2140 if (T->isMemberPointerType())
2141 return getPreferredTypeAlign(getPointerDiffType().getTypePtr());
2142
2143 if (!Target->allowsLargerPreferedTypeAlignment())
2144 return ABIAlign;
2145
2146 // Double and long long should be naturally aligned if possible.
2147 if (const auto *CT = T->getAs<ComplexType>())
2148 T = CT->getElementType().getTypePtr();
2149 if (const auto *ET = T->getAs<EnumType>())
2150 T = ET->getDecl()->getIntegerType().getTypePtr();
2151 if (T->isSpecificBuiltinType(BuiltinType::Double) ||
2152 T->isSpecificBuiltinType(BuiltinType::LongLong) ||
2153 T->isSpecificBuiltinType(BuiltinType::ULongLong))
2154 // Don't increase the alignment if an alignment attribute was specified on a
2155 // typedef declaration.
2156 if (!TI.AlignIsRequired)
2157 return std::max(ABIAlign, (unsigned)getTypeSize(T));
2158
2159 return ABIAlign;
2160}
2161
2162/// getTargetDefaultAlignForAttributeAligned - Return the default alignment
2163/// for __attribute__((aligned)) on this target, to be used if no alignment
2164/// value is specified.
2165unsigned ASTContext::getTargetDefaultAlignForAttributeAligned() const {
2166 return getTargetInfo().getDefaultAlignForAttributeAligned();
2167}
2168
2169/// getAlignOfGlobalVar - Return the alignment in bits that should be given
2170/// to a global variable of the specified type.
2171unsigned ASTContext::getAlignOfGlobalVar(QualType T) const {
2172 return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign());
2173}
2174
2175/// getAlignOfGlobalVarInChars - Return the alignment in characters that
2176/// should be given to a global variable of the specified type.
2177CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T) const {
2178 return toCharUnitsFromBits(getAlignOfGlobalVar(T));
2179}
2180
2181CharUnits ASTContext::getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const {
2182 CharUnits Offset = CharUnits::Zero();
2183 const ASTRecordLayout *Layout = &getASTRecordLayout(RD);
2184 while (const CXXRecordDecl *Base = Layout->getBaseSharingVBPtr()) {
2185 Offset += Layout->getBaseClassOffset(Base);
2186 Layout = &getASTRecordLayout(Base);
2187 }
2188 return Offset;
2189}
2190
2191/// DeepCollectObjCIvars -
2192/// This routine first collects all declared, but not synthesized, ivars in
2193/// super class and then collects all ivars, including those synthesized for
2194/// current class. This routine is used for implementation of current class
2195/// when all ivars, declared and synthesized are known.
2196void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI,
2197 bool leafClass,
2198 SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const {
2199 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
2200 DeepCollectObjCIvars(SuperClass, false, Ivars);
2201 if (!leafClass) {
2202 for (const auto *I : OI->ivars())
2203 Ivars.push_back(I);
2204 } else {
2205 auto *IDecl = const_cast<ObjCInterfaceDecl *>(OI);
2206 for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
2207 Iv= Iv->getNextIvar())
2208 Ivars.push_back(Iv);
2209 }
2210}
2211
2212/// CollectInheritedProtocols - Collect all protocols in current class and
2213/// those inherited by it.
2214void ASTContext::CollectInheritedProtocols(const Decl *CDecl,
2215 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
2216 if (const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2217 // We can use protocol_iterator here instead of
2218 // all_referenced_protocol_iterator since we are walking all categories.
2219 for (auto *Proto : OI->all_referenced_protocols()) {
2220 CollectInheritedProtocols(Proto, Protocols);
2221 }
2222
2223 // Categories of this Interface.
2224 for (const auto *Cat : OI->visible_categories())
2225 CollectInheritedProtocols(Cat, Protocols);
2226
2227 if (ObjCInterfaceDecl *SD = OI->getSuperClass())
2228 while (SD) {
2229 CollectInheritedProtocols(SD, Protocols);
2230 SD = SD->getSuperClass();
2231 }
2232 } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2233 for (auto *Proto : OC->protocols()) {
2234 CollectInheritedProtocols(Proto, Protocols);
2235 }
2236 } else if (const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
2237 // Insert the protocol.
2238 if (!Protocols.insert(
2239 const_cast<ObjCProtocolDecl *>(OP->getCanonicalDecl())).second)
2240 return;
2241
2242 for (auto *Proto : OP->protocols())
2243 CollectInheritedProtocols(Proto, Protocols);
2244 }
2245}
2246
2247static bool unionHasUniqueObjectRepresentations(const ASTContext &Context,
2248 const RecordDecl *RD) {
2249 assert(RD->isUnion() && "Must be union type")((RD->isUnion() && "Must be union type") ? static_cast
<void> (0) : __assert_fail ("RD->isUnion() && \"Must be union type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2249, __PRETTY_FUNCTION__))
;
2250 CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());
2251
2252 for (const auto *Field : RD->fields()) {
2253 if (!Context.hasUniqueObjectRepresentations(Field->getType()))
2254 return false;
2255 CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
2256 if (FieldSize != UnionSize)
2257 return false;
2258 }
2259 return !RD->field_empty();
2260}
2261
2262static bool isStructEmpty(QualType Ty) {
2263 const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();
2264
2265 if (!RD->field_empty())
2266 return false;
2267
2268 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD))
2269 return ClassDecl->isEmpty();
2270
2271 return true;
2272}
2273
2274static llvm::Optional<int64_t>
2275structHasUniqueObjectRepresentations(const ASTContext &Context,
2276 const RecordDecl *RD) {
2277 assert(!RD->isUnion() && "Must be struct/class type")((!RD->isUnion() && "Must be struct/class type") ?
static_cast<void> (0) : __assert_fail ("!RD->isUnion() && \"Must be struct/class type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2277, __PRETTY_FUNCTION__))
;
2278 const auto &Layout = Context.getASTRecordLayout(RD);
2279
2280 int64_t CurOffsetInBits = 0;
2281 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2282 if (ClassDecl->isDynamicClass())
2283 return llvm::None;
2284
2285 SmallVector<std::pair<QualType, int64_t>, 4> Bases;
2286 for (const auto Base : ClassDecl->bases()) {
2287 // Empty types can be inherited from, and non-empty types can potentially
2288 // have tail padding, so just make sure there isn't an error.
2289 if (!isStructEmpty(Base.getType())) {
2290 llvm::Optional<int64_t> Size = structHasUniqueObjectRepresentations(
2291 Context, Base.getType()->getAs<RecordType>()->getDecl());
2292 if (!Size)
2293 return llvm::None;
2294 Bases.emplace_back(Base.getType(), Size.getValue());
2295 }
2296 }
2297
2298 llvm::sort(Bases, [&](const std::pair<QualType, int64_t> &L,
2299 const std::pair<QualType, int64_t> &R) {
2300 return Layout.getBaseClassOffset(L.first->getAsCXXRecordDecl()) <
2301 Layout.getBaseClassOffset(R.first->getAsCXXRecordDecl());
2302 });
2303
2304 for (const auto Base : Bases) {
2305 int64_t BaseOffset = Context.toBits(
2306 Layout.getBaseClassOffset(Base.first->getAsCXXRecordDecl()));
2307 int64_t BaseSize = Base.second;
2308 if (BaseOffset != CurOffsetInBits)
2309 return llvm::None;
2310 CurOffsetInBits = BaseOffset + BaseSize;
2311 }
2312 }
2313
2314 for (const auto *Field : RD->fields()) {
2315 if (!Field->getType()->isReferenceType() &&
2316 !Context.hasUniqueObjectRepresentations(Field->getType()))
2317 return llvm::None;
2318
2319 int64_t FieldSizeInBits =
2320 Context.toBits(Context.getTypeSizeInChars(Field->getType()));
2321 if (Field->isBitField()) {
2322 int64_t BitfieldSize = Field->getBitWidthValue(Context);
2323
2324 if (BitfieldSize > FieldSizeInBits)
2325 return llvm::None;
2326 FieldSizeInBits = BitfieldSize;
2327 }
2328
2329 int64_t FieldOffsetInBits = Context.getFieldOffset(Field);
2330
2331 if (FieldOffsetInBits != CurOffsetInBits)
2332 return llvm::None;
2333
2334 CurOffsetInBits = FieldSizeInBits + FieldOffsetInBits;
2335 }
2336
2337 return CurOffsetInBits;
2338}
2339
2340bool ASTContext::hasUniqueObjectRepresentations(QualType Ty) const {
2341 // C++17 [meta.unary.prop]:
2342 // The predicate condition for a template specialization
2343 // has_unique_object_representations<T> shall be
2344 // satisfied if and only if:
2345 // (9.1) - T is trivially copyable, and
2346 // (9.2) - any two objects of type T with the same value have the same
2347 // object representation, where two objects
2348 // of array or non-union class type are considered to have the same value
2349 // if their respective sequences of
2350 // direct subobjects have the same values, and two objects of union type
2351 // are considered to have the same
2352 // value if they have the same active member and the corresponding members
2353 // have the same value.
2354 // The set of scalar types for which this condition holds is
2355 // implementation-defined. [ Note: If a type has padding
2356 // bits, the condition does not hold; otherwise, the condition holds true
2357 // for unsigned integral types. -- end note ]
2358 assert(!Ty.isNull() && "Null QualType sent to unique object rep check")((!Ty.isNull() && "Null QualType sent to unique object rep check"
) ? static_cast<void> (0) : __assert_fail ("!Ty.isNull() && \"Null QualType sent to unique object rep check\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2358, __PRETTY_FUNCTION__))
;
2359
2360 // Arrays are unique only if their element type is unique.
2361 if (Ty->isArrayType())
2362 return hasUniqueObjectRepresentations(getBaseElementType(Ty));
2363
2364 // (9.1) - T is trivially copyable...
2365 if (!Ty.isTriviallyCopyableType(*this))
2366 return false;
2367
2368 // All integrals and enums are unique.
2369 if (Ty->isIntegralOrEnumerationType())
2370 return true;
2371
2372 // All other pointers are unique.
2373 if (Ty->isPointerType())
2374 return true;
2375
2376 if (Ty->isMemberPointerType()) {
2377 const auto *MPT = Ty->getAs<MemberPointerType>();
2378 return !ABI->getMemberPointerInfo(MPT).HasPadding;
2379 }
2380
2381 if (Ty->isRecordType()) {
2382 const RecordDecl *Record = Ty->getAs<RecordType>()->getDecl();
2383
2384 if (Record->isInvalidDecl())
2385 return false;
2386
2387 if (Record->isUnion())
2388 return unionHasUniqueObjectRepresentations(*this, Record);
2389
2390 Optional<int64_t> StructSize =
2391 structHasUniqueObjectRepresentations(*this, Record);
2392
2393 return StructSize &&
2394 StructSize.getValue() == static_cast<int64_t>(getTypeSize(Ty));
2395 }
2396
2397 // FIXME: More cases to handle here (list by rsmith):
2398 // vectors (careful about, eg, vector of 3 foo)
2399 // _Complex int and friends
2400 // _Atomic T
2401 // Obj-C block pointers
2402 // Obj-C object pointers
2403 // and perhaps OpenCL's various builtin types (pipe, sampler_t, event_t,
2404 // clk_event_t, queue_t, reserve_id_t)
2405 // There're also Obj-C class types and the Obj-C selector type, but I think it
2406 // makes sense for those to return false here.
2407
2408 return false;
2409}
2410
2411unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const {
2412 unsigned count = 0;
2413 // Count ivars declared in class extension.
2414 for (const auto *Ext : OI->known_extensions())
2415 count += Ext->ivar_size();
2416
2417 // Count ivar defined in this class's implementation. This
2418 // includes synthesized ivars.
2419 if (ObjCImplementationDecl *ImplDecl = OI->getImplementation())
2420 count += ImplDecl->ivar_size();
2421
2422 return count;
2423}
2424
2425bool ASTContext::isSentinelNullExpr(const Expr *E) {
2426 if (!E)
2427 return false;
2428
2429 // nullptr_t is always treated as null.
2430 if (E->getType()->isNullPtrType()) return true;
2431
2432 if (E->getType()->isAnyPointerType() &&
2433 E->IgnoreParenCasts()->isNullPointerConstant(*this,
2434 Expr::NPC_ValueDependentIsNull))
2435 return true;
2436
2437 // Unfortunately, __null has type 'int'.
2438 if (isa<GNUNullExpr>(E)) return true;
2439
2440 return false;
2441}
2442
2443/// Get the implementation of ObjCInterfaceDecl, or nullptr if none
2444/// exists.
2445ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
2446 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2447 I = ObjCImpls.find(D);
2448 if (I != ObjCImpls.end())
2449 return cast<ObjCImplementationDecl>(I->second);
2450 return nullptr;
2451}
2452
2453/// Get the implementation of ObjCCategoryDecl, or nullptr if none
2454/// exists.
2455ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) {
2456 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2457 I = ObjCImpls.find(D);
2458 if (I != ObjCImpls.end())
2459 return cast<ObjCCategoryImplDecl>(I->second);
2460 return nullptr;
2461}
2462
2463/// Set the implementation of ObjCInterfaceDecl.
2464void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD,
2465 ObjCImplementationDecl *ImplD) {
2466 assert(IFaceD && ImplD && "Passed null params")((IFaceD && ImplD && "Passed null params") ? static_cast
<void> (0) : __assert_fail ("IFaceD && ImplD && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2466, __PRETTY_FUNCTION__))
;
2467 ObjCImpls[IFaceD] = ImplD;
2468}
2469
2470/// Set the implementation of ObjCCategoryDecl.
2471void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD,
2472 ObjCCategoryImplDecl *ImplD) {
2473 assert(CatD && ImplD && "Passed null params")((CatD && ImplD && "Passed null params") ? static_cast
<void> (0) : __assert_fail ("CatD && ImplD && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2473, __PRETTY_FUNCTION__))
;
2474 ObjCImpls[CatD] = ImplD;
2475}
2476
2477const ObjCMethodDecl *
2478ASTContext::getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const {
2479 return ObjCMethodRedecls.lookup(MD);
2480}
2481
2482void ASTContext::setObjCMethodRedeclaration(const ObjCMethodDecl *MD,
2483 const ObjCMethodDecl *Redecl) {
2484 assert(!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration")((!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration"
) ? static_cast<void> (0) : __assert_fail ("!getObjCMethodRedeclaration(MD) && \"MD already has a redeclaration\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2484, __PRETTY_FUNCTION__))
;
2485 ObjCMethodRedecls[MD] = Redecl;
2486}
2487
2488const ObjCInterfaceDecl *ASTContext::getObjContainingInterface(
2489 const NamedDecl *ND) const {
2490 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext()))
2491 return ID;
2492 if (const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext()))
2493 return CD->getClassInterface();
2494 if (const auto *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext()))
2495 return IMD->getClassInterface();
2496
2497 return nullptr;
2498}
2499
2500/// Get the copy initialization expression of VarDecl, or nullptr if
2501/// none exists.
2502ASTContext::BlockVarCopyInit
2503ASTContext::getBlockVarCopyInit(const VarDecl*VD) const {
2504 assert(VD && "Passed null params")((VD && "Passed null params") ? static_cast<void>
(0) : __assert_fail ("VD && \"Passed null params\"",
"/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2504, __PRETTY_FUNCTION__))
;
2505 assert(VD->hasAttr<BlocksAttr>() &&((VD->hasAttr<BlocksAttr>() && "getBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"getBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2506, __PRETTY_FUNCTION__))
2506 "getBlockVarCopyInits - not __block var")((VD->hasAttr<BlocksAttr>() && "getBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"getBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2506, __PRETTY_FUNCTION__))
;
2507 auto I = BlockVarCopyInits.find(VD);
2508 if (I != BlockVarCopyInits.end())
2509 return I->second;
2510 return {nullptr, false};
2511}
2512
2513/// Set the copy inialization expression of a block var decl.
2514void ASTContext::setBlockVarCopyInit(const VarDecl*VD, Expr *CopyExpr,
2515 bool CanThrow) {
2516 assert(VD && CopyExpr && "Passed null params")((VD && CopyExpr && "Passed null params") ? static_cast
<void> (0) : __assert_fail ("VD && CopyExpr && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2516, __PRETTY_FUNCTION__))
;
2517 assert(VD->hasAttr<BlocksAttr>() &&((VD->hasAttr<BlocksAttr>() && "setBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"setBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2518, __PRETTY_FUNCTION__))
2518 "setBlockVarCopyInits - not __block var")((VD->hasAttr<BlocksAttr>() && "setBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"setBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2518, __PRETTY_FUNCTION__))
;
2519 BlockVarCopyInits[VD].setExprAndFlag(CopyExpr, CanThrow);
2520}
2521
2522TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T,
2523 unsigned DataSize) const {
2524 if (!DataSize)
2525 DataSize = TypeLoc::getFullDataSizeForType(T);
2526 else
2527 assert(DataSize == TypeLoc::getFullDataSizeForType(T) &&((DataSize == TypeLoc::getFullDataSizeForType(T) && "incorrect data size provided to CreateTypeSourceInfo!"
) ? static_cast<void> (0) : __assert_fail ("DataSize == TypeLoc::getFullDataSizeForType(T) && \"incorrect data size provided to CreateTypeSourceInfo!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2528, __PRETTY_FUNCTION__))
2528 "incorrect data size provided to CreateTypeSourceInfo!")((DataSize == TypeLoc::getFullDataSizeForType(T) && "incorrect data size provided to CreateTypeSourceInfo!"
) ? static_cast<void> (0) : __assert_fail ("DataSize == TypeLoc::getFullDataSizeForType(T) && \"incorrect data size provided to CreateTypeSourceInfo!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2528, __PRETTY_FUNCTION__))
;
2529
2530 auto *TInfo =
2531 (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
2532 new (TInfo) TypeSourceInfo(T);
2533 return TInfo;
2534}
2535
2536TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T,
2537 SourceLocation L) const {
2538 TypeSourceInfo *DI = CreateTypeSourceInfo(T);
2539 DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L);
2540 return DI;
2541}
2542
2543const ASTRecordLayout &
2544ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const {
2545 return getObjCLayout(D, nullptr);
2546}
2547
2548const ASTRecordLayout &
2549ASTContext::getASTObjCImplementationLayout(
2550 const ObjCImplementationDecl *D) const {
2551 return getObjCLayout(D->getClassInterface(), D);
2552}
2553
2554//===----------------------------------------------------------------------===//
2555// Type creation/memoization methods
2556//===----------------------------------------------------------------------===//
2557
2558QualType
2559ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
2560 unsigned fastQuals = quals.getFastQualifiers();
2561 quals.removeFastQualifiers();
2562
2563 // Check if we've already instantiated this type.
2564 llvm::FoldingSetNodeID ID;
2565 ExtQuals::Profile(ID, baseType, quals);
2566 void *insertPos = nullptr;
2567 if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
2568 assert(eq->getQualifiers() == quals)((eq->getQualifiers() == quals) ? static_cast<void> (
0) : __assert_fail ("eq->getQualifiers() == quals", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2568, __PRETTY_FUNCTION__))
;
2569 return QualType(eq, fastQuals);
2570 }
2571
2572 // If the base type is not canonical, make the appropriate canonical type.
2573 QualType canon;
2574 if (!baseType->isCanonicalUnqualified()) {
2575 SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split();
2576 canonSplit.Quals.addConsistentQualifiers(quals);
2577 canon = getExtQualType(canonSplit.Ty, canonSplit.Quals);
2578
2579 // Re-find the insert position.
2580 (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
2581 }
2582
2583 auto *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
2584 ExtQualNodes.InsertNode(eq, insertPos);
2585 return QualType(eq, fastQuals);
2586}
2587
2588QualType ASTContext::getAddrSpaceQualType(QualType T,
2589 LangAS AddressSpace) const {
2590 QualType CanT = getCanonicalType(T);
2591 if (CanT.getAddressSpace() == AddressSpace)
2592 return T;
2593
2594 // If we are composing extended qualifiers together, merge together
2595 // into one ExtQuals node.
2596 QualifierCollector Quals;
2597 const Type *TypeNode = Quals.strip(T);
2598
2599 // If this type already has an address space specified, it cannot get
2600 // another one.
2601 assert(!Quals.hasAddressSpace() &&((!Quals.hasAddressSpace() && "Type cannot be in multiple addr spaces!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasAddressSpace() && \"Type cannot be in multiple addr spaces!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2602, __PRETTY_FUNCTION__))
2602 "Type cannot be in multiple addr spaces!")((!Quals.hasAddressSpace() && "Type cannot be in multiple addr spaces!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasAddressSpace() && \"Type cannot be in multiple addr spaces!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2602, __PRETTY_FUNCTION__))
;
2603 Quals.addAddressSpace(AddressSpace);
2604
2605 return getExtQualType(TypeNode, Quals);
2606}
2607
2608QualType ASTContext::removeAddrSpaceQualType(QualType T) const {
2609 // If we are composing extended qualifiers together, merge together
2610 // into one ExtQuals node.
2611 QualifierCollector Quals;
2612 const Type *TypeNode = Quals.strip(T);
2613
2614 // If the qualifier doesn't have an address space just return it.
2615 if (!Quals.hasAddressSpace())
2616 return T;
2617
2618 Quals.removeAddressSpace();
2619
2620 // Removal of the address space can mean there are no longer any
2621 // non-fast qualifiers, so creating an ExtQualType isn't possible (asserts)
2622 // or required.
2623 if (Quals.hasNonFastQualifiers())
2624 return getExtQualType(TypeNode, Quals);
2625 else
2626 return QualType(TypeNode, Quals.getFastQualifiers());
2627}
2628
2629QualType ASTContext::getObjCGCQualType(QualType T,
2630 Qualifiers::GC GCAttr) const {
2631 QualType CanT = getCanonicalType(T);
2632 if (CanT.getObjCGCAttr() == GCAttr)
2633 return T;
2634
2635 if (const auto *ptr = T->getAs<PointerType>()) {
2636 QualType Pointee = ptr->getPointeeType();
2637 if (Pointee->isAnyPointerType()) {
2638 QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
2639 return getPointerType(ResultType);
2640 }
2641 }
2642
2643 // If we are composing extended qualifiers together, merge together
2644 // into one ExtQuals node.
2645 QualifierCollector Quals;
2646 const Type *TypeNode = Quals.strip(T);
2647
2648 // If this type already has an ObjCGC specified, it cannot get
2649 // another one.
2650 assert(!Quals.hasObjCGCAttr() &&((!Quals.hasObjCGCAttr() && "Type cannot have multiple ObjCGCs!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasObjCGCAttr() && \"Type cannot have multiple ObjCGCs!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2651, __PRETTY_FUNCTION__))
2651 "Type cannot have multiple ObjCGCs!")((!Quals.hasObjCGCAttr() && "Type cannot have multiple ObjCGCs!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasObjCGCAttr() && \"Type cannot have multiple ObjCGCs!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2651, __PRETTY_FUNCTION__))
;
2652 Quals.addObjCGCAttr(GCAttr);
2653
2654 return getExtQualType(TypeNode, Quals);
2655}
2656
2657const FunctionType *ASTContext::adjustFunctionType(const FunctionType *T,
2658 FunctionType::ExtInfo Info) {
2659 if (T->getExtInfo() == Info)
2660 return T;
2661
2662 QualType Result;
2663 if (const auto *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
2664 Result = getFunctionNoProtoType(FNPT->getReturnType(), Info);
2665 } else {
2666 const auto *FPT = cast<FunctionProtoType>(T);
2667 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
2668 EPI.ExtInfo = Info;
2669 Result = getFunctionType(FPT->getReturnType(), FPT->getParamTypes(), EPI);
2670 }
2671
2672 return cast<FunctionType>(Result.getTypePtr());
2673}
2674
2675void ASTContext::adjustDeducedFunctionResultType(FunctionDecl *FD,
2676 QualType ResultType) {
2677 FD = FD->getMostRecentDecl();
2678 while (true) {
2679 const auto *FPT = FD->getType()->castAs<FunctionProtoType>();
2680 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
2681 FD->setType(getFunctionType(ResultType, FPT->getParamTypes(), EPI));
2682 if (FunctionDecl *Next = FD->getPreviousDecl())
2683 FD = Next;
2684 else
2685 break;
2686 }
2687 if (ASTMutationListener *L = getASTMutationListener())
2688 L->DeducedReturnType(FD, ResultType);
2689}
2690
2691/// Get a function type and produce the equivalent function type with the
2692/// specified exception specification. Type sugar that can be present on a
2693/// declaration of a function with an exception specification is permitted
2694/// and preserved. Other type sugar (for instance, typedefs) is not.
2695QualType ASTContext::getFunctionTypeWithExceptionSpec(
2696 QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) {
2697 // Might have some parens.
2698 if (const auto *PT = dyn_cast<ParenType>(Orig))
2699 return getParenType(
2700 getFunctionTypeWithExceptionSpec(PT->getInnerType(), ESI));
2701
2702 // Might have a calling-convention attribute.
2703 if (const auto *AT = dyn_cast<AttributedType>(Orig))
2704 return getAttributedType(
2705 AT->getAttrKind(),
2706 getFunctionTypeWithExceptionSpec(AT->getModifiedType(), ESI),
2707 getFunctionTypeWithExceptionSpec(AT->getEquivalentType(), ESI));
2708
2709 // Anything else must be a function type. Rebuild it with the new exception
2710 // specification.
2711 const auto *Proto = cast<FunctionProtoType>(Orig);
2712 return getFunctionType(
2713 Proto->getReturnType(), Proto->getParamTypes(),
2714 Proto->getExtProtoInfo().withExceptionSpec(ESI));
2715}
2716
2717bool ASTContext::hasSameFunctionTypeIgnoringExceptionSpec(QualType T,
2718 QualType U) {
2719 return hasSameType(T, U) ||
2720 (getLangOpts().CPlusPlus17 &&
2721 hasSameType(getFunctionTypeWithExceptionSpec(T, EST_None),
2722 getFunctionTypeWithExceptionSpec(U, EST_None)));
2723}
2724
2725void ASTContext::adjustExceptionSpec(
2726 FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI,
2727 bool AsWritten) {
2728 // Update the type.
2729 QualType Updated =
2730 getFunctionTypeWithExceptionSpec(FD->getType(), ESI);
2731 FD->setType(Updated);
2732
2733 if (!AsWritten)
2734 return;
2735
2736 // Update the type in the type source information too.
2737 if (TypeSourceInfo *TSInfo = FD->getTypeSourceInfo()) {
2738 // If the type and the type-as-written differ, we may need to update
2739 // the type-as-written too.
2740 if (TSInfo->getType() != FD->getType())
2741 Updated = getFunctionTypeWithExceptionSpec(TSInfo->getType(), ESI);
2742
2743 // FIXME: When we get proper type location information for exceptions,
2744 // we'll also have to rebuild the TypeSourceInfo. For now, we just patch
2745 // up the TypeSourceInfo;
2746 assert(TypeLoc::getFullDataSizeForType(Updated) ==((TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType
(TSInfo->getType()) && "TypeLoc size mismatch from updating exception specification"
) ? static_cast<void> (0) : __assert_fail ("TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType(TSInfo->getType()) && \"TypeLoc size mismatch from updating exception specification\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2748, __PRETTY_FUNCTION__))
2747 TypeLoc::getFullDataSizeForType(TSInfo->getType()) &&((TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType
(TSInfo->getType()) && "TypeLoc size mismatch from updating exception specification"
) ? static_cast<void> (0) : __assert_fail ("TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType(TSInfo->getType()) && \"TypeLoc size mismatch from updating exception specification\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2748, __PRETTY_FUNCTION__))
2748 "TypeLoc size mismatch from updating exception specification")((TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType
(TSInfo->getType()) && "TypeLoc size mismatch from updating exception specification"
) ? static_cast<void> (0) : __assert_fail ("TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType(TSInfo->getType()) && \"TypeLoc size mismatch from updating exception specification\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2748, __PRETTY_FUNCTION__))
;
2749 TSInfo->overrideType(Updated);
2750 }
2751}
2752
2753/// getComplexType - Return the uniqued reference to the type for a complex
2754/// number with the specified element type.
2755QualType ASTContext::getComplexType(QualType T) const {
2756 // Unique pointers, to guarantee there is only one pointer of a particular
2757 // structure.
2758 llvm::FoldingSetNodeID ID;
2759 ComplexType::Profile(ID, T);
2760
2761 void *InsertPos = nullptr;
2762 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
2763 return QualType(CT, 0);
2764
2765 // If the pointee type isn't canonical, this won't be a canonical type either,
2766 // so fill in the canonical type field.
2767 QualType Canonical;
2768 if (!T.isCanonical()) {
2769 Canonical = getComplexType(getCanonicalType(T));
2770
2771 // Get the new insert position for the node we care about.
2772 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
2773 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2773, __PRETTY_FUNCTION__))
; (void)NewIP;
2774 }
2775 auto *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
2776 Types.push_back(New);
2777 ComplexTypes.InsertNode(New, InsertPos);
2778 return QualType(New, 0);
2779}
2780
2781/// getPointerType - Return the uniqued reference to the type for a pointer to
2782/// the specified type.
2783QualType ASTContext::getPointerType(QualType T) const {
2784 // Unique pointers, to guarantee there is only one pointer of a particular
2785 // structure.
2786 llvm::FoldingSetNodeID ID;
2787 PointerType::Profile(ID, T);
2788
2789 void *InsertPos = nullptr;
2790 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2791 return QualType(PT, 0);
2792
2793 // If the pointee type isn't canonical, this won't be a canonical type either,
2794 // so fill in the canonical type field.
2795 QualType Canonical;
2796 if (!T.isCanonical()) {
2797 Canonical = getPointerType(getCanonicalType(T));
2798
2799 // Get the new insert position for the node we care about.
2800 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2801 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2801, __PRETTY_FUNCTION__))
; (void)NewIP;
2802 }
2803 auto *New = new (*this, TypeAlignment) PointerType(T, Canonical);
2804 Types.push_back(New);
2805 PointerTypes.InsertNode(New, InsertPos);
2806 return QualType(New, 0);
2807}
2808
2809QualType ASTContext::getAdjustedType(QualType Orig, QualType New) const {
2810 llvm::FoldingSetNodeID ID;
2811 AdjustedType::Profile(ID, Orig, New);
2812 void *InsertPos = nullptr;
2813 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2814 if (AT)
2815 return QualType(AT, 0);
2816
2817 QualType Canonical = getCanonicalType(New);
2818
2819 // Get the new insert position for the node we care about.
2820 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2821 assert(!AT && "Shouldn't be in the map!")((!AT && "Shouldn't be in the map!") ? static_cast<
void> (0) : __assert_fail ("!AT && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2821, __PRETTY_FUNCTION__))
;
2822
2823 AT = new (*this, TypeAlignment)
2824 AdjustedType(Type::Adjusted, Orig, New, Canonical);
2825 Types.push_back(AT);
2826 AdjustedTypes.InsertNode(AT, InsertPos);
2827 return QualType(AT, 0);
2828}
2829
2830QualType ASTContext::getDecayedType(QualType T) const {
2831 assert((T->isArrayType() || T->isFunctionType()) && "T does not decay")(((T->isArrayType() || T->isFunctionType()) && "T does not decay"
) ? static_cast<void> (0) : __assert_fail ("(T->isArrayType() || T->isFunctionType()) && \"T does not decay\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2831, __PRETTY_FUNCTION__))
;
2832
2833 QualType Decayed;
2834
2835 // C99 6.7.5.3p7:
2836 // A declaration of a parameter as "array of type" shall be
2837 // adjusted to "qualified pointer to type", where the type
2838 // qualifiers (if any) are those specified within the [ and ] of
2839 // the array type derivation.
2840 if (T->isArrayType())
2841 Decayed = getArrayDecayedType(T);
2842
2843 // C99 6.7.5.3p8:
2844 // A declaration of a parameter as "function returning type"
2845 // shall be adjusted to "pointer to function returning type", as
2846 // in 6.3.2.1.
2847 if (T->isFunctionType())
2848 Decayed = getPointerType(T);
2849
2850 llvm::FoldingSetNodeID ID;
2851 AdjustedType::Profile(ID, T, Decayed);
2852 void *InsertPos = nullptr;
2853 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2854 if (AT)
2855 return QualType(AT, 0);
2856
2857 QualType Canonical = getCanonicalType(Decayed);
2858
2859 // Get the new insert position for the node we care about.
2860 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2861 assert(!AT && "Shouldn't be in the map!")((!AT && "Shouldn't be in the map!") ? static_cast<
void> (0) : __assert_fail ("!AT && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2861, __PRETTY_FUNCTION__))
;
2862
2863 AT = new (*this, TypeAlignment) DecayedType(T, Decayed, Canonical);
2864 Types.push_back(AT);
2865 AdjustedTypes.InsertNode(AT, InsertPos);
2866 return QualType(AT, 0);
2867}
2868
2869/// getBlockPointerType - Return the uniqued reference to the type for
2870/// a pointer to the specified block.
2871QualType ASTContext::getBlockPointerType(QualType T) const {
2872 assert(T->isFunctionType() && "block of function types only")((T->isFunctionType() && "block of function types only"
) ? static_cast<void> (0) : __assert_fail ("T->isFunctionType() && \"block of function types only\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2872, __PRETTY_FUNCTION__))
;
2873 // Unique pointers, to guarantee there is only one block of a particular
2874 // structure.
2875 llvm::FoldingSetNodeID ID;
2876 BlockPointerType::Profile(ID, T);
2877
2878 void *InsertPos = nullptr;
2879 if (BlockPointerType *PT =
2880 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2881 return QualType(PT, 0);
2882
2883 // If the block pointee type isn't canonical, this won't be a canonical
2884 // type either so fill in the canonical type field.
2885 QualType Canonical;
2886 if (!T.isCanonical()) {
2887 Canonical = getBlockPointerType(getCanonicalType(T));
2888
2889 // Get the new insert position for the node we care about.
2890 BlockPointerType *NewIP =
2891 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2892 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2892, __PRETTY_FUNCTION__))
; (void)NewIP;
2893 }
2894 auto *New = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
2895 Types.push_back(New);
2896 BlockPointerTypes.InsertNode(New, InsertPos);
2897 return QualType(New, 0);
2898}
2899
2900/// getLValueReferenceType - Return the uniqued reference to the type for an
2901/// lvalue reference to the specified type.
2902QualType
2903ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const {
2904 assert(getCanonicalType(T) != OverloadTy &&((getCanonicalType(T) != OverloadTy && "Unresolved overloaded function type"
) ? static_cast<void> (0) : __assert_fail ("getCanonicalType(T) != OverloadTy && \"Unresolved overloaded function type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2905, __PRETTY_FUNCTION__))
2905 "Unresolved overloaded function type")((getCanonicalType(T) != OverloadTy && "Unresolved overloaded function type"
) ? static_cast<void> (0) : __assert_fail ("getCanonicalType(T) != OverloadTy && \"Unresolved overloaded function type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2905, __PRETTY_FUNCTION__))
;
2906
2907 // Unique pointers, to guarantee there is only one pointer of a particular
2908 // structure.
2909 llvm::FoldingSetNodeID ID;
2910 ReferenceType::Profile(ID, T, SpelledAsLValue);
2911
2912 void *InsertPos = nullptr;
2913 if (LValueReferenceType *RT =
2914 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2915 return QualType(RT, 0);
2916
2917 const auto *InnerRef = T->getAs<ReferenceType>();
2918
2919 // If the referencee type isn't canonical, this won't be a canonical type
2920 // either, so fill in the canonical type field.
2921 QualType Canonical;
2922 if (!SpelledAsLValue || InnerRef || !T.isCanonical()) {
2923 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2924 Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
2925
2926 // Get the new insert position for the node we care about.
2927 LValueReferenceType *NewIP =
2928 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
2929 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2929, __PRETTY_FUNCTION__))
; (void)NewIP;
2930 }
2931
2932 auto *New = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
2933 SpelledAsLValue);
2934 Types.push_back(New);
2935 LValueReferenceTypes.InsertNode(New, InsertPos);
2936
2937 return QualType(New, 0);
2938}
2939
2940/// getRValueReferenceType - Return the uniqued reference to the type for an
2941/// rvalue reference to the specified type.
2942QualType ASTContext::getRValueReferenceType(QualType T) const {
2943 // Unique pointers, to guarantee there is only one pointer of a particular
2944 // structure.
2945 llvm::FoldingSetNodeID ID;
2946 ReferenceType::Profile(ID, T, false);
2947
2948 void *InsertPos = nullptr;
2949 if (RValueReferenceType *RT =
2950 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2951 return QualType(RT, 0);
2952
2953 const auto *InnerRef = T->getAs<ReferenceType>();
2954
2955 // If the referencee type isn't canonical, this won't be a canonical type
2956 // either, so fill in the canonical type field.
2957 QualType Canonical;
2958 if (InnerRef || !T.isCanonical()) {
2959 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2960 Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
2961
2962 // Get the new insert position for the node we care about.
2963 RValueReferenceType *NewIP =
2964 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
2965 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2965, __PRETTY_FUNCTION__))
; (void)NewIP;
2966 }
2967
2968 auto *New = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
2969 Types.push_back(New);
2970 RValueReferenceTypes.InsertNode(New, InsertPos);
2971 return QualType(New, 0);
2972}
2973
2974/// getMemberPointerType - Return the uniqued reference to the type for a
2975/// member pointer to the specified type, in the specified class.
2976QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const {
2977 // Unique pointers, to guarantee there is only one pointer of a particular
2978 // structure.
2979 llvm::FoldingSetNodeID ID;
2980 MemberPointerType::Profile(ID, T, Cls);
2981
2982 void *InsertPos = nullptr;
2983 if (MemberPointerType *PT =
2984 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2985 return QualType(PT, 0);
2986
2987 // If the pointee or class type isn't canonical, this won't be a canonical
2988 // type either, so fill in the canonical type field.
2989 QualType Canonical;
2990 if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
2991 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
2992
2993 // Get the new insert position for the node we care about.
2994 MemberPointerType *NewIP =
2995 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2996 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2996, __PRETTY_FUNCTION__))
; (void)NewIP;
2997 }
2998 auto *New = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
2999 Types.push_back(New);
3000 MemberPointerTypes.InsertNode(New, InsertPos);
3001 return QualType(New, 0);
3002}
3003
3004/// getConstantArrayType - Return the unique reference to the type for an
3005/// array of the specified element type.
3006QualType ASTContext::getConstantArrayType(QualType EltTy,
3007 const llvm::APInt &ArySizeIn,
3008 ArrayType::ArraySizeModifier ASM,
3009 unsigned IndexTypeQuals) const {
3010 assert((EltTy->isDependentType() ||(((EltTy->isDependentType() || EltTy->isIncompleteType(
) || EltTy->isConstantSizeType()) && "Constant array of VLAs is illegal!"
) ? static_cast<void> (0) : __assert_fail ("(EltTy->isDependentType() || EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && \"Constant array of VLAs is illegal!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3012, __PRETTY_FUNCTION__))
3011 EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&(((EltTy->isDependentType() || EltTy->isIncompleteType(
) || EltTy->isConstantSizeType()) && "Constant array of VLAs is illegal!"
) ? static_cast<void> (0) : __assert_fail ("(EltTy->isDependentType() || EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && \"Constant array of VLAs is illegal!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3012, __PRETTY_FUNCTION__))
3012 "Constant array of VLAs is illegal!")(((EltTy->isDependentType() || EltTy->isIncompleteType(
) || EltTy->isConstantSizeType()) && "Constant array of VLAs is illegal!"
) ? static_cast<void> (0) : __assert_fail ("(EltTy->isDependentType() || EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && \"Constant array of VLAs is illegal!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3012, __PRETTY_FUNCTION__))
;
3013
3014 // Convert the array size into a canonical width matching the pointer size for
3015 // the target.
3016 llvm::APInt ArySize(ArySizeIn);
3017 ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());
3018
3019 llvm::FoldingSetNodeID ID;
3020 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals);
3021
3022 void *InsertPos = nullptr;
3023 if (ConstantArrayType *ATP =
3024 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
3025 return QualType(ATP, 0);
3026
3027 // If the element type isn't canonical or has qualifiers, this won't
3028 // be a canonical type either, so fill in the canonical type field.
3029 QualType Canon;
3030 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
3031 SplitQualType canonSplit = getCanonicalType(EltTy).split();
3032 Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize,
3033 ASM, IndexTypeQuals);
3034 Canon = getQualifiedType(Canon, canonSplit.Quals);
3035
3036 // Get the new insert position for the node we care about.
3037 ConstantArrayType *NewIP =
3038 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
3039 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3039, __PRETTY_FUNCTION__))
; (void)NewIP;
3040 }
3041
3042 auto *New = new (*this,TypeAlignment)
3043 ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals);
3044 ConstantArrayTypes.InsertNode(New, InsertPos);
3045 Types.push_back(New);
3046 return QualType(New, 0);
3047}
3048
3049/// getVariableArrayDecayedType - Turns the given type, which may be
3050/// variably-modified, into the corresponding type with all the known
3051/// sizes replaced with [*].
3052QualType ASTContext::getVariableArrayDecayedType(QualType type) const {
3053 // Vastly most common case.
3054 if (!type->isVariablyModifiedType()) return type;
3055
3056 QualType result;
3057
3058 SplitQualType split = type.getSplitDesugaredType();
3059 const Type *ty = split.Ty;
3060 switch (ty->getTypeClass()) {
3061#define TYPE(Class, Base)
3062#define ABSTRACT_TYPE(Class, Base)
3063#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3064#include "clang/AST/TypeNodes.def"
3065 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-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3065)
;
3066
3067 // These types should never be variably-modified.
3068 case Type::Builtin:
3069 case Type::Complex:
3070 case Type::Vector:
3071 case Type::DependentVector:
3072 case Type::ExtVector:
3073 case Type::DependentSizedExtVector:
3074 case Type::DependentAddressSpace:
3075 case Type::ObjCObject:
3076 case Type::ObjCInterface:
3077 case Type::ObjCObjectPointer:
3078 case Type::Record:
3079 case Type::Enum:
3080 case Type::UnresolvedUsing:
3081 case Type::TypeOfExpr:
3082 case Type::TypeOf:
3083 case Type::Decltype:
3084 case Type::UnaryTransform:
3085 case Type::DependentName:
3086 case Type::InjectedClassName:
3087 case Type::TemplateSpecialization:
3088 case Type::DependentTemplateSpecialization:
3089 case Type::TemplateTypeParm:
3090 case Type::SubstTemplateTypeParmPack:
3091 case Type::Auto:
3092 case Type::DeducedTemplateSpecialization:
3093 case Type::PackExpansion:
3094 llvm_unreachable("type should never be variably-modified")::llvm::llvm_unreachable_internal("type should never be variably-modified"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3094)
;
3095
3096 // These types can be variably-modified but should never need to
3097 // further decay.
3098 case Type::FunctionNoProto:
3099 case Type::FunctionProto:
3100 case Type::BlockPointer:
3101 case Type::MemberPointer:
3102 case Type::Pipe:
3103 return type;
3104
3105 // These types can be variably-modified. All these modifications
3106 // preserve structure except as noted by comments.
3107 // TODO: if we ever care about optimizing VLAs, there are no-op
3108 // optimizations available here.
3109 case Type::Pointer:
3110 result = getPointerType(getVariableArrayDecayedType(
3111 cast<PointerType>(ty)->getPointeeType()));
3112 break;
3113
3114 case Type::LValueReference: {
3115 const auto *lv = cast<LValueReferenceType>(ty);
3116 result = getLValueReferenceType(
3117 getVariableArrayDecayedType(lv->getPointeeType()),
3118 lv->isSpelledAsLValue());
3119 break;
3120 }
3121
3122 case Type::RValueReference: {
3123 const auto *lv = cast<RValueReferenceType>(ty);
3124 result = getRValueReferenceType(
3125 getVariableArrayDecayedType(lv->getPointeeType()));
3126 break;
3127 }
3128
3129 case Type::Atomic: {
3130 const auto *at = cast<AtomicType>(ty);
3131 result = getAtomicType(getVariableArrayDecayedType(at->getValueType()));
3132 break;
3133 }
3134
3135 case Type::ConstantArray: {
3136 const auto *cat = cast<ConstantArrayType>(ty);
3137 result = getConstantArrayType(
3138 getVariableArrayDecayedType(cat->getElementType()),
3139 cat->getSize(),
3140 cat->getSizeModifier(),
3141 cat->getIndexTypeCVRQualifiers());
3142 break;
3143 }
3144
3145 case Type::DependentSizedArray: {
3146 const auto *dat = cast<DependentSizedArrayType>(ty);
3147 result = getDependentSizedArrayType(
3148 getVariableArrayDecayedType(dat->getElementType()),
3149 dat->getSizeExpr(),
3150 dat->getSizeModifier(),
3151 dat->getIndexTypeCVRQualifiers(),
3152 dat->getBracketsRange());
3153 break;
3154 }
3155
3156 // Turn incomplete types into [*] types.
3157 case Type::IncompleteArray: {
3158 const auto *iat = cast<IncompleteArrayType>(ty);
3159 result = getVariableArrayType(
3160 getVariableArrayDecayedType(iat->getElementType()),
3161 /*size*/ nullptr,
3162 ArrayType::Normal,
3163 iat->getIndexTypeCVRQualifiers(),
3164 SourceRange());
3165 break;
3166 }
3167
3168 // Turn VLA types into [*] types.
3169 case Type::VariableArray: {
3170 const auto *vat = cast<VariableArrayType>(ty);
3171 result = getVariableArrayType(
3172 getVariableArrayDecayedType(vat->getElementType()),
3173 /*size*/ nullptr,
3174 ArrayType::Star,
3175 vat->getIndexTypeCVRQualifiers(),
3176 vat->getBracketsRange());
3177 break;
3178 }
3179 }
3180
3181 // Apply the top-level qualifiers from the original.
3182 return getQualifiedType(result, split.Quals);
3183}
3184
3185/// getVariableArrayType - Returns a non-unique reference to the type for a
3186/// variable array of the specified element type.
3187QualType ASTContext::getVariableArrayType(QualType EltTy,
3188 Expr *NumElts,
3189 ArrayType::ArraySizeModifier ASM,
3190 unsigned IndexTypeQuals,
3191 SourceRange Brackets) const {
3192 // Since we don't unique expressions, it isn't possible to unique VLA's
3193 // that have an expression provided for their size.
3194 QualType Canon;
3195
3196 // Be sure to pull qualifiers off the element type.
3197 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
3198 SplitQualType canonSplit = getCanonicalType(EltTy).split();
3199 Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM,
3200 IndexTypeQuals, Brackets);
3201 Canon = getQualifiedType(Canon, canonSplit.Quals);
3202 }
3203
3204 auto *New = new (*this, TypeAlignment)
3205 VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);
3206
3207 VariableArrayTypes.push_back(New);
3208 Types.push_back(New);
3209 return QualType(New, 0);
3210}
3211
3212/// getDependentSizedArrayType - Returns a non-unique reference to
3213/// the type for a dependently-sized array of the specified element
3214/// type.
3215QualType ASTContext::getDependentSizedArrayType(QualType elementType,
3216 Expr *numElements,
3217 ArrayType::ArraySizeModifier ASM,
3218 unsigned elementTypeQuals,
3219 SourceRange brackets) const {
3220 assert((!numElements || numElements->isTypeDependent() ||(((!numElements || numElements->isTypeDependent() || numElements
->isValueDependent()) && "Size must be type- or value-dependent!"
) ? static_cast<void> (0) : __assert_fail ("(!numElements || numElements->isTypeDependent() || numElements->isValueDependent()) && \"Size must be type- or value-dependent!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3222, __PRETTY_FUNCTION__))
3221 numElements->isValueDependent()) &&(((!numElements || numElements->isTypeDependent() || numElements
->isValueDependent()) && "Size must be type- or value-dependent!"
) ? static_cast<void> (0) : __assert_fail ("(!numElements || numElements->isTypeDependent() || numElements->isValueDependent()) && \"Size must be type- or value-dependent!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3222, __PRETTY_FUNCTION__))
3222 "Size must be type- or value-dependent!")(((!numElements || numElements->isTypeDependent() || numElements
->isValueDependent()) && "Size must be type- or value-dependent!"
) ? static_cast<void> (0) : __assert_fail ("(!numElements || numElements->isTypeDependent() || numElements->isValueDependent()) && \"Size must be type- or value-dependent!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3222, __PRETTY_FUNCTION__))
;
3223
3224 // Dependently-sized array types that do not have a specified number
3225 // of elements will have their sizes deduced from a dependent
3226 // initializer. We do no canonicalization here at all, which is okay
3227 // because they can't be used in most locations.
3228 if (!numElements) {
3229 auto *newType
3230 = new (*this, TypeAlignment)
3231 DependentSizedArrayType(*this, elementType, QualType(),
3232 numElements, ASM, elementTypeQuals,
3233 brackets);
3234 Types.push_back(newType);
3235 return QualType(newType, 0);
3236 }
3237
3238 // Otherwise, we actually build a new type every time, but we
3239 // also build a canonical type.
3240
3241 SplitQualType canonElementType = getCanonicalType(elementType).split();
3242
3243 void *insertPos = nullptr;
3244 llvm::FoldingSetNodeID ID;
3245 DependentSizedArrayType::Profile(ID, *this,
3246 QualType(canonElementType.Ty, 0),
3247 ASM, elementTypeQuals, numElements);
3248
3249 // Look for an existing type with these properties.
3250 DependentSizedArrayType *canonTy =
3251 DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3252
3253 // If we don't have one, build one.
3254 if (!canonTy) {
3255 canonTy = new (*this, TypeAlignment)
3256 DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0),
3257 QualType(), numElements, ASM, elementTypeQuals,
3258 brackets);
3259 DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
3260 Types.push_back(canonTy);
3261 }
3262
3263 // Apply qualifiers from the element type to the array.
3264 QualType canon = getQualifiedType(QualType(canonTy,0),
3265 canonElementType.Quals);
3266
3267 // If we didn't need extra canonicalization for the element type or the size
3268 // expression, then just use that as our result.
3269 if (QualType(canonElementType.Ty, 0) == elementType &&
3270 canonTy->getSizeExpr() == numElements)
3271 return canon;
3272
3273 // Otherwise, we need to build a type which follows the spelling
3274 // of the element type.
3275 auto *sugaredType
3276 = new (*this, TypeAlignment)
3277 DependentSizedArrayType(*this, elementType, canon, numElements,
3278 ASM, elementTypeQuals, brackets);
3279 Types.push_back(sugaredType);
3280 return QualType(sugaredType, 0);
3281}
3282
3283QualType ASTContext::getIncompleteArrayType(QualType elementType,
3284 ArrayType::ArraySizeModifier ASM,
3285 unsigned elementTypeQuals) const {
3286 llvm::FoldingSetNodeID ID;
3287 IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals);
3288
3289 void *insertPos = nullptr;
3290 if (IncompleteArrayType *iat =
3291 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
3292 return QualType(iat, 0);
3293
3294 // If the element type isn't canonical, this won't be a canonical type
3295 // either, so fill in the canonical type field. We also have to pull
3296 // qualifiers off the element type.
3297 QualType canon;
3298
3299 if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) {
3300 SplitQualType canonSplit = getCanonicalType(elementType).split();
3301 canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0),
3302 ASM, elementTypeQuals);
3303 canon = getQualifiedType(canon, canonSplit.Quals);
3304
3305 // Get the new insert position for the node we care about.
3306 IncompleteArrayType *existing =
3307 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3308 assert(!existing && "Shouldn't be in the map!")((!existing && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!existing && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3308, __PRETTY_FUNCTION__))
; (void) existing;
3309 }
3310
3311 auto *newType = new (*this, TypeAlignment)
3312 IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);
3313
3314 IncompleteArrayTypes.InsertNode(newType, insertPos);
3315 Types.push_back(newType);
3316 return QualType(newType, 0);
3317}
3318
3319/// getVectorType - Return the unique reference to a vector type of
3320/// the specified element type and size. VectorType must be a built-in type.
3321QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts,
3322 VectorType::VectorKind VecKind) const {
3323 assert(vecType->isBuiltinType())((vecType->isBuiltinType()) ? static_cast<void> (0) :
__assert_fail ("vecType->isBuiltinType()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3323, __PRETTY_FUNCTION__))
;
3324
3325 // Check if we've already instantiated a vector of this type.
3326 llvm::FoldingSetNodeID ID;
3327 VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind);
3328
3329 void *InsertPos = nullptr;
3330 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3331 return QualType(VTP, 0);
3332
3333 // If the element type isn't canonical, this won't be a canonical type either,
3334 // so fill in the canonical type field.
3335 QualType Canonical;
3336 if (!vecType.isCanonical()) {
3337 Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind);
3338
3339 // Get the new insert position for the node we care about.
3340 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3341 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3341, __PRETTY_FUNCTION__))
; (void)NewIP;
3342 }
3343 auto *New = new (*this, TypeAlignment)
3344 VectorType(vecType, NumElts, Canonical, VecKind);
3345 VectorTypes.InsertNode(New, InsertPos);
3346 Types.push_back(New);
3347 return QualType(New, 0);
3348}
3349
3350QualType
3351ASTContext::getDependentVectorType(QualType VecType, Expr *SizeExpr,
3352 SourceLocation AttrLoc,
3353 VectorType::VectorKind VecKind) const {
3354 llvm::FoldingSetNodeID ID;
3355 DependentVectorType::Profile(ID, *this, getCanonicalType(VecType), SizeExpr,
3356 VecKind);
3357 void *InsertPos = nullptr;
3358 DependentVectorType *Canon =
3359 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3360 DependentVectorType *New;
3361
3362 if (Canon) {
3363 New = new (*this, TypeAlignment) DependentVectorType(
3364 *this, VecType, QualType(Canon, 0), SizeExpr, AttrLoc, VecKind);
3365 } else {
3366 QualType CanonVecTy = getCanonicalType(VecType);
3367 if (CanonVecTy == VecType) {
3368 New = new (*this, TypeAlignment) DependentVectorType(
3369 *this, VecType, QualType(), SizeExpr, AttrLoc, VecKind);
3370
3371 DependentVectorType *CanonCheck =
3372 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3373 assert(!CanonCheck &&((!CanonCheck && "Dependent-sized vector_size canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!CanonCheck && \"Dependent-sized vector_size canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3374, __PRETTY_FUNCTION__))
3374 "Dependent-sized vector_size canonical type broken")((!CanonCheck && "Dependent-sized vector_size canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!CanonCheck && \"Dependent-sized vector_size canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3374, __PRETTY_FUNCTION__))
;
3375 (void)CanonCheck;
3376 DependentVectorTypes.InsertNode(New, InsertPos);
3377 } else {
3378 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
3379 SourceLocation());
3380 New = new (*this, TypeAlignment) DependentVectorType(
3381 *this, VecType, Canon, SizeExpr, AttrLoc, VecKind);
3382 }
3383 }
3384
3385 Types.push_back(New);
3386 return QualType(New, 0);
3387}
3388
3389/// getExtVectorType - Return the unique reference to an extended vector type of
3390/// the specified element type and size. VectorType must be a built-in type.
3391QualType
3392ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const {
3393 assert(vecType->isBuiltinType() || vecType->isDependentType())((vecType->isBuiltinType() || vecType->isDependentType(
)) ? static_cast<void> (0) : __assert_fail ("vecType->isBuiltinType() || vecType->isDependentType()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3393, __PRETTY_FUNCTION__))
;
3394
3395 // Check if we've already instantiated a vector of this type.
3396 llvm::FoldingSetNodeID ID;
3397 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
3398 VectorType::GenericVector);
3399 void *InsertPos = nullptr;
3400 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3401 return QualType(VTP, 0);
3402
3403 // If the element type isn't canonical, this won't be a canonical type either,
3404 // so fill in the canonical type field.
3405 QualType Canonical;
3406 if (!vecType.isCanonical()) {
3407 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
3408
3409 // Get the new insert position for the node we care about.
3410 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3411 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3411, __PRETTY_FUNCTION__))
; (void)NewIP;
3412 }
3413 auto *New = new (*this, TypeAlignment)
3414 ExtVectorType(vecType, NumElts, Canonical);
3415 VectorTypes.InsertNode(New, InsertPos);
3416 Types.push_back(New);
3417 return QualType(New, 0);
3418}
3419
3420QualType
3421ASTContext::getDependentSizedExtVectorType(QualType vecType,
3422 Expr *SizeExpr,
3423 SourceLocation AttrLoc) const {
3424 llvm::FoldingSetNodeID ID;
3425 DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType),
3426 SizeExpr);
3427
3428 void *InsertPos = nullptr;
3429 DependentSizedExtVectorType *Canon
3430 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3431 DependentSizedExtVectorType *New;
3432 if (Canon) {
3433 // We already have a canonical version of this array type; use it as
3434 // the canonical type for a newly-built type.
3435 New = new (*this, TypeAlignment)
3436 DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
3437 SizeExpr, AttrLoc);
3438 } else {
3439 QualType CanonVecTy = getCanonicalType(vecType);
3440 if (CanonVecTy == vecType) {
3441 New = new (*this, TypeAlignment)
3442 DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
3443 AttrLoc);
3444
3445 DependentSizedExtVectorType *CanonCheck
3446 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3447 assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken")((!CanonCheck && "Dependent-sized ext_vector canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!CanonCheck && \"Dependent-sized ext_vector canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3447, __PRETTY_FUNCTION__))
;
3448 (void)CanonCheck;
3449 DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
3450 } else {
3451 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
3452 SourceLocation());
3453 New = new (*this, TypeAlignment)
3454 DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc);
3455 }
3456 }
3457
3458 Types.push_back(New);
3459 return QualType(New, 0);
3460}
3461
3462QualType ASTContext::getDependentAddressSpaceType(QualType PointeeType,
3463 Expr *AddrSpaceExpr,
3464 SourceLocation AttrLoc) const {
3465 assert(AddrSpaceExpr->isInstantiationDependent())((AddrSpaceExpr->isInstantiationDependent()) ? static_cast
<void> (0) : __assert_fail ("AddrSpaceExpr->isInstantiationDependent()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3465, __PRETTY_FUNCTION__))
;
3466
3467 QualType canonPointeeType = getCanonicalType(PointeeType);
3468
3469 void *insertPos = nullptr;
3470 llvm::FoldingSetNodeID ID;
3471 DependentAddressSpaceType::Profile(ID, *this, canonPointeeType,
3472 AddrSpaceExpr);
3473
3474 DependentAddressSpaceType *canonTy =
3475 DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
3476
3477 if (!canonTy) {
3478 canonTy = new (*this, TypeAlignment)
3479 DependentAddressSpaceType(*this, canonPointeeType,
3480 QualType(), AddrSpaceExpr, AttrLoc);
3481 DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
3482 Types.push_back(canonTy);
3483 }
3484
3485 if (canonPointeeType == PointeeType &&
3486 canonTy->getAddrSpaceExpr() == AddrSpaceExpr)
3487 return QualType(canonTy, 0);
3488
3489 auto *sugaredType
3490 = new (*this, TypeAlignment)
3491 DependentAddressSpaceType(*this, PointeeType, QualType(canonTy, 0),
3492 AddrSpaceExpr, AttrLoc);
3493 Types.push_back(sugaredType);
3494 return QualType(sugaredType, 0);
3495}
3496
3497/// Determine whether \p T is canonical as the result type of a function.
3498static bool isCanonicalResultType(QualType T) {
3499 return T.isCanonical() &&
3500 (T.getObjCLifetime() == Qualifiers::OCL_None ||
3501 T.getObjCLifetime() == Qualifiers::OCL_ExplicitNone);
3502}
3503
3504/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
3505QualType
3506ASTContext::getFunctionNoProtoType(QualType ResultTy,
3507 const FunctionType::ExtInfo &Info) const {
3508 // Unique functions, to guarantee there is only one function of a particular
3509 // structure.
3510 llvm::FoldingSetNodeID ID;
3511 FunctionNoProtoType::Profile(ID, ResultTy, Info);
3512
3513 void *InsertPos = nullptr;
3514 if (FunctionNoProtoType *FT =
3515 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
3516 return QualType(FT, 0);
3517
3518 QualType Canonical;
3519 if (!isCanonicalResultType(ResultTy)) {
3520 Canonical =
3521 getFunctionNoProtoType(getCanonicalFunctionResultType(ResultTy), Info);
3522
3523 // Get the new insert position for the node we care about.
3524 FunctionNoProtoType *NewIP =
3525 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3526 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3526, __PRETTY_FUNCTION__))
; (void)NewIP;
3527 }
3528
3529 auto *New = new (*this, TypeAlignment)
3530 FunctionNoProtoType(ResultTy, Canonical, Info);
3531 Types.push_back(New);
3532 FunctionNoProtoTypes.InsertNode(New, InsertPos);
3533 return QualType(New, 0);
3534}
3535
3536CanQualType
3537ASTContext::getCanonicalFunctionResultType(QualType ResultType) const {
3538 CanQualType CanResultType = getCanonicalType(ResultType);
3539
3540 // Canonical result types do not have ARC lifetime qualifiers.
3541 if (CanResultType.getQualifiers().hasObjCLifetime()) {
3542 Qualifiers Qs = CanResultType.getQualifiers();
3543 Qs.removeObjCLifetime();
3544 return CanQualType::CreateUnsafe(
3545 getQualifiedType(CanResultType.getUnqualifiedType(), Qs));
3546 }
3547
3548 return CanResultType;
3549}
3550
3551static bool isCanonicalExceptionSpecification(
3552 const FunctionProtoType::ExceptionSpecInfo &ESI, bool NoexceptInType) {
3553 if (ESI.Type == EST_None)
3554 return true;
3555 if (!NoexceptInType)
3556 return false;
3557
3558 // C++17 onwards: exception specification is part of the type, as a simple
3559 // boolean "can this function type throw".
3560 if (ESI.Type == EST_BasicNoexcept)
3561 return true;
3562
3563 // A noexcept(expr) specification is (possibly) canonical if expr is
3564 // value-dependent.
3565 if (ESI.Type == EST_DependentNoexcept)
3566 return true;
3567
3568 // A dynamic exception specification is canonical if it only contains pack
3569 // expansions (so we can't tell whether it's non-throwing) and all its
3570 // contained types are canonical.
3571 if (ESI.Type == EST_Dynamic) {
3572 bool AnyPackExpansions = false;
3573 for (QualType ET : ESI.Exceptions) {
3574 if (!ET.isCanonical())
3575 return false;
3576 if (ET->getAs<PackExpansionType>())
3577 AnyPackExpansions = true;
3578 }
3579 return AnyPackExpansions;
3580 }
3581
3582 return false;
3583}
3584
3585QualType ASTContext::getFunctionTypeInternal(
3586 QualType ResultTy, ArrayRef<QualType> ArgArray,
3587 const FunctionProtoType::ExtProtoInfo &EPI, bool OnlyWantCanonical) const {
3588 size_t NumArgs = ArgArray.size();
3589
3590 // Unique functions, to guarantee there is only one function of a particular
3591 // structure.
3592 llvm::FoldingSetNodeID ID;
3593 FunctionProtoType::Profile(ID, ResultTy, ArgArray.begin(), NumArgs, EPI,
3594 *this, true);
3595
3596 QualType Canonical;
3597 bool Unique = false;
3598
3599 void *InsertPos = nullptr;
3600 if (FunctionProtoType *FPT =
3601 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
3602 QualType Existing = QualType(FPT, 0);
3603
3604 // If we find a pre-existing equivalent FunctionProtoType, we can just reuse
3605 // it so long as our exception specification doesn't contain a dependent
3606 // noexcept expression, or we're just looking for a canonical type.
3607 // Otherwise, we're going to need to create a type
3608 // sugar node to hold the concrete expression.
3609 if (OnlyWantCanonical || !isComputedNoexcept(EPI.ExceptionSpec.Type) ||
3610 EPI.ExceptionSpec.NoexceptExpr == FPT->getNoexceptExpr())
3611 return Existing;
3612
3613 // We need a new type sugar node for this one, to hold the new noexcept
3614 // expression. We do no canonicalization here, but that's OK since we don't
3615 // expect to see the same noexcept expression much more than once.
3616 Canonical = getCanonicalType(Existing);
3617 Unique = true;
3618 }
3619
3620 bool NoexceptInType = getLangOpts().CPlusPlus17;
3621 bool IsCanonicalExceptionSpec =
3622 isCanonicalExceptionSpecification(EPI.ExceptionSpec, NoexceptInType);
3623
3624 // Determine whether the type being created is already canonical or not.
3625 bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
3626 isCanonicalResultType(ResultTy) && !EPI.HasTrailingReturn;
3627 for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
3628 if (!ArgArray[i].isCanonicalAsParam())
3629 isCanonical = false;
3630
3631 if (OnlyWantCanonical)
3632 assert(isCanonical &&((isCanonical && "given non-canonical parameters constructing canonical type"
) ? static_cast<void> (0) : __assert_fail ("isCanonical && \"given non-canonical parameters constructing canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3633, __PRETTY_FUNCTION__))
3633 "given non-canonical parameters constructing canonical type")((isCanonical && "given non-canonical parameters constructing canonical type"
) ? static_cast<void> (0) : __assert_fail ("isCanonical && \"given non-canonical parameters constructing canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3633, __PRETTY_FUNCTION__))
;
3634
3635 // If this type isn't canonical, get the canonical version of it if we don't
3636 // already have it. The exception spec is only partially part of the
3637 // canonical type, and only in C++17 onwards.
3638 if (!isCanonical && Canonical.isNull()) {
3639 SmallVector<QualType, 16> CanonicalArgs;
3640 CanonicalArgs.reserve(NumArgs);
3641 for (unsigned i = 0; i != NumArgs; ++i)
3642 CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));
3643
3644 llvm::SmallVector<QualType, 8> ExceptionTypeStorage;
3645 FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
3646 CanonicalEPI.HasTrailingReturn = false;
3647
3648 if (IsCanonicalExceptionSpec) {
3649 // Exception spec is already OK.
3650 } else if (NoexceptInType) {
3651 switch (EPI.ExceptionSpec.Type) {
3652 case EST_Unparsed: case EST_Unevaluated: case EST_Uninstantiated:
3653 // We don't know yet. It shouldn't matter what we pick here; no-one
3654 // should ever look at this.
3655 LLVM_FALLTHROUGH[[clang::fallthrough]];
3656 case EST_None: case EST_MSAny: case EST_NoexceptFalse:
3657 CanonicalEPI.ExceptionSpec.Type = EST_None;
3658 break;
3659
3660 // A dynamic exception specification is almost always "not noexcept",
3661 // with the exception that a pack expansion might expand to no types.
3662 case EST_Dynamic: {
3663 bool AnyPacks = false;
3664 for (QualType ET : EPI.ExceptionSpec.Exceptions) {
3665 if (ET->getAs<PackExpansionType>())
3666 AnyPacks = true;
3667 ExceptionTypeStorage.push_back(getCanonicalType(ET));
3668 }
3669 if (!AnyPacks)
3670 CanonicalEPI.ExceptionSpec.Type = EST_None;
3671 else {
3672 CanonicalEPI.ExceptionSpec.Type = EST_Dynamic;
3673 CanonicalEPI.ExceptionSpec.Exceptions = ExceptionTypeStorage;
3674 }
3675 break;
3676 }
3677
3678 case EST_DynamicNone: case EST_BasicNoexcept: case EST_NoexceptTrue:
3679 CanonicalEPI.ExceptionSpec.Type = EST_BasicNoexcept;
3680 break;
3681
3682 case EST_DependentNoexcept:
3683 llvm_unreachable("dependent noexcept is already canonical")::llvm::llvm_unreachable_internal("dependent noexcept is already canonical"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3683)
;
3684 }
3685 } else {
3686 CanonicalEPI.ExceptionSpec = FunctionProtoType::ExceptionSpecInfo();
3687 }
3688
3689 // Adjust the canonical function result type.
3690 CanQualType CanResultTy = getCanonicalFunctionResultType(ResultTy);
3691 Canonical =
3692 getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI, true);
3693
3694 // Get the new insert position for the node we care about.
3695 FunctionProtoType *NewIP =
3696 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3697 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3697, __PRETTY_FUNCTION__))
; (void)NewIP;
3698 }
3699
3700 // Compute the needed size to hold this FunctionProtoType and the
3701 // various trailing objects.
3702 auto ESH = FunctionProtoType::getExceptionSpecSize(
3703 EPI.ExceptionSpec.Type, EPI.ExceptionSpec.Exceptions.size());
3704 size_t Size = FunctionProtoType::totalSizeToAlloc<
3705 QualType, FunctionType::FunctionTypeExtraBitfields,
3706 FunctionType::ExceptionType, Expr *, FunctionDecl *,
3707 FunctionProtoType::ExtParameterInfo>(
3708 NumArgs, FunctionProtoType::hasExtraBitfields(EPI.ExceptionSpec.Type),
3709 ESH.NumExceptionType, ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
3710 EPI.ExtParameterInfos ? NumArgs : 0);
3711
3712 auto *FTP = (FunctionProtoType *)Allocate(Size, TypeAlignment);
3713 FunctionProtoType::ExtProtoInfo newEPI = EPI;
3714 new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
3715 Types.push_back(FTP);
3716 if (!Unique)
3717 FunctionProtoTypes.InsertNode(FTP, InsertPos);
3718 return QualType(FTP, 0);
3719}
3720
3721QualType ASTContext::getPipeType(QualType T, bool ReadOnly) const {
3722 llvm::FoldingSetNodeID ID;
3723 PipeType::Profile(ID, T, ReadOnly);
3724
3725 void *InsertPos = nullptr;
3726 if (PipeType *PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))
3727 return QualType(PT, 0);
3728
3729 // If the pipe element type isn't canonical, this won't be a canonical type
3730 // either, so fill in the canonical type field.
3731 QualType Canonical;
3732 if (!T.isCanonical()) {
3733 Canonical = getPipeType(getCanonicalType(T), ReadOnly);
3734
3735 // Get the new insert position for the node we care about.
3736 PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);
3737 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3737, __PRETTY_FUNCTION__))
;
3738 (void)NewIP;
3739 }
3740 auto *New = new (*this, TypeAlignment) PipeType(T, Canonical, ReadOnly);
3741 Types.push_back(New);
3742 PipeTypes.InsertNode(New, InsertPos);
3743 return QualType(New, 0);
3744}
3745
3746QualType ASTContext::adjustStringLiteralBaseType(QualType Ty) const {
3747 // OpenCL v1.1 s6.5.3: a string literal is in the constant address space.
3748 return LangOpts.OpenCL ? getAddrSpaceQualType(Ty, LangAS::opencl_constant)
3749 : Ty;
3750}
3751
3752QualType ASTContext::getReadPipeType(QualType T) const {
3753 return getPipeType(T, true);
3754}
3755
3756QualType ASTContext::getWritePipeType(QualType T) const {
3757 return getPipeType(T, false);
3758}
3759
3760#ifndef NDEBUG
3761static bool NeedsInjectedClassNameType(const RecordDecl *D) {
3762 if (!isa<CXXRecordDecl>(D)) return false;
3763 const auto *RD = cast<CXXRecordDecl>(D);
3764 if (isa<ClassTemplatePartialSpecializationDecl>(RD))
3765 return true;
3766 if (RD->getDescribedClassTemplate() &&
3767 !isa<ClassTemplateSpecializationDecl>(RD))
3768 return true;
3769 return false;
3770}
3771#endif
3772
3773/// getInjectedClassNameType - Return the unique reference to the
3774/// injected class name type for the specified templated declaration.
3775QualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl,
3776 QualType TST) const {
3777 assert(NeedsInjectedClassNameType(Decl))((NeedsInjectedClassNameType(Decl)) ? static_cast<void>
(0) : __assert_fail ("NeedsInjectedClassNameType(Decl)", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3777, __PRETTY_FUNCTION__))
;
3778 if (Decl->TypeForDecl) {
3779 assert(isa<InjectedClassNameType>(Decl->TypeForDecl))((isa<InjectedClassNameType>(Decl->TypeForDecl)) ? static_cast
<void> (0) : __assert_fail ("isa<InjectedClassNameType>(Decl->TypeForDecl)"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3779, __PRETTY_FUNCTION__))
;
3780 } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) {
3781 assert(PrevDecl->TypeForDecl && "previous declaration has no type")((PrevDecl->TypeForDecl && "previous declaration has no type"
) ? static_cast<void> (0) : __assert_fail ("PrevDecl->TypeForDecl && \"previous declaration has no type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3781, __PRETTY_FUNCTION__))
;
3782 Decl->TypeForDecl = PrevDecl->TypeForDecl;
3783 assert(isa<InjectedClassNameType>(Decl->TypeForDecl))((isa<InjectedClassNameType>(Decl->TypeForDecl)) ? static_cast
<void> (0) : __assert_fail ("isa<InjectedClassNameType>(Decl->TypeForDecl)"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3783, __PRETTY_FUNCTION__))
;
3784 } else {
3785 Type *newType =
3786 new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
3787 Decl->TypeForDecl = newType;
3788 Types.push_back(newType);
3789 }
3790 return QualType(Decl->TypeForDecl, 0);
3791}
3792
3793/// getTypeDeclType - Return the unique reference to the type for the
3794/// specified type declaration.
3795QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const {
3796 assert(Decl && "Passed null for Decl param")((Decl && "Passed null for Decl param") ? static_cast
<void> (0) : __assert_fail ("Decl && \"Passed null for Decl param\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3796, __PRETTY_FUNCTION__))
;
3797 assert(!Decl->TypeForDecl && "TypeForDecl present in slow case")((!Decl->TypeForDecl && "TypeForDecl present in slow case"
) ? static_cast<void> (0) : __assert_fail ("!Decl->TypeForDecl && \"TypeForDecl present in slow case\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3797, __PRETTY_FUNCTION__))
;
3798
3799 if (const auto *Typedef = dyn_cast<TypedefNameDecl>(Decl))
3800 return getTypedefType(Typedef);
3801
3802 assert(!isa<TemplateTypeParmDecl>(Decl) &&((!isa<TemplateTypeParmDecl>(Decl) && "Template type parameter types are always available."
) ? static_cast<void> (0) : __assert_fail ("!isa<TemplateTypeParmDecl>(Decl) && \"Template type parameter types are always available.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3803, __PRETTY_FUNCTION__))
3803 "Template type parameter types are always available.")((!isa<TemplateTypeParmDecl>(Decl) && "Template type parameter types are always available."
) ? static_cast<void> (0) : __assert_fail ("!isa<TemplateTypeParmDecl>(Decl) && \"Template type parameter types are always available.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3803, __PRETTY_FUNCTION__))
;
3804
3805 if (const auto *Record = dyn_cast<RecordDecl>(Decl)) {
3806 assert(Record->isFirstDecl() && "struct/union has previous declaration")((Record->isFirstDecl() && "struct/union has previous declaration"
) ? static_cast<void> (0) : __assert_fail ("Record->isFirstDecl() && \"struct/union has previous declaration\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3806, __PRETTY_FUNCTION__))
;
3807 assert(!NeedsInjectedClassNameType(Record))((!NeedsInjectedClassNameType(Record)) ? static_cast<void>
(0) : __assert_fail ("!NeedsInjectedClassNameType(Record)", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3807, __PRETTY_FUNCTION__))
;
3808 return getRecordType(Record);
3809 } else if (const auto *Enum = dyn_cast<EnumDecl>(Decl)) {
3810 assert(Enum->isFirstDecl() && "enum has previous declaration")((Enum->isFirstDecl() && "enum has previous declaration"
) ? static_cast<void> (0) : __assert_fail ("Enum->isFirstDecl() && \"enum has previous declaration\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3810, __PRETTY_FUNCTION__))
;
3811 return getEnumType(Enum);
3812 } else if (const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
3813 Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using);
3814 Decl->TypeForDecl = newType;
3815 Types.push_back(newType);
3816 } else
3817 llvm_unreachable("TypeDecl without a type?")::llvm::llvm_unreachable_internal("TypeDecl without a type?",
"/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3817)
;
3818
3819 return QualType(Decl->TypeForDecl, 0);
3820}
3821
3822/// getTypedefType - Return the unique reference to the type for the
3823/// specified typedef name decl.
3824QualType
3825ASTContext::getTypedefType(const TypedefNameDecl *Decl,
3826 QualType Canonical) const {
3827 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3828
3829 if (Canonical.isNull())
3830 Canonical = getCanonicalType(Decl->getUnderlyingType());
3831 auto *newType = new (*this, TypeAlignment)
3832 TypedefType(Type::Typedef, Decl, Canonical);
3833 Decl->TypeForDecl = newType;
3834 Types.push_back(newType);
3835 return QualType(newType, 0);
3836}
3837
3838QualType ASTContext::getRecordType(const RecordDecl *Decl) const {
3839 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3840
3841 if (const RecordDecl *PrevDecl = Decl->getPreviousDecl())
3842 if (PrevDecl->TypeForDecl)
3843 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3844
3845 auto *newType = new (*this, TypeAlignment) RecordType(Decl);
3846 Decl->TypeForDecl = newType;
3847 Types.push_back(newType);
3848 return QualType(newType, 0);
3849}
3850
3851QualType ASTContext::getEnumType(const EnumDecl *Decl) const {
3852 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3853
3854 if (const EnumDecl *PrevDecl = Decl->getPreviousDecl())
3855 if (PrevDecl->TypeForDecl)
3856 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3857
3858 auto *newType = new (*this, TypeAlignment) EnumType(Decl);
3859 Decl->TypeForDecl = newType;
3860 Types.push_back(newType);
3861 return QualType(newType, 0);
3862}
3863
3864QualType ASTContext::getAttributedType(attr::Kind attrKind,
3865 QualType modifiedType,
3866 QualType equivalentType) {
3867 llvm::FoldingSetNodeID id;
3868 AttributedType::Profile(id, attrKind, modifiedType, equivalentType);
3869
3870 void *insertPos = nullptr;
3871 AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos);
3872 if (type) return QualType(type, 0);
3873
3874 QualType canon = getCanonicalType(equivalentType);
3875 type = new (*this, TypeAlignment)
3876 AttributedType(canon, attrKind, modifiedType, equivalentType);
3877
3878 Types.push_back(type);
3879 AttributedTypes.InsertNode(type, insertPos);
3880
3881 return QualType(type, 0);
3882}
3883
3884/// Retrieve a substitution-result type.
3885QualType
3886ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
3887 QualType Replacement) const {
3888 assert(Replacement.isCanonical()((Replacement.isCanonical() && "replacement types must always be canonical"
) ? static_cast<void> (0) : __assert_fail ("Replacement.isCanonical() && \"replacement types must always be canonical\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3889, __PRETTY_FUNCTION__))
3889 && "replacement types must always be canonical")((Replacement.isCanonical() && "replacement types must always be canonical"
) ? static_cast<void> (0) : __assert_fail ("Replacement.isCanonical() && \"replacement types must always be canonical\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3889, __PRETTY_FUNCTION__))
;
3890
3891 llvm::FoldingSetNodeID ID;
3892 SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
3893 void *InsertPos = nullptr;
3894 SubstTemplateTypeParmType *SubstParm
3895 = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3896
3897 if (!SubstParm) {
3898 SubstParm = new (*this, TypeAlignment)
3899 SubstTemplateTypeParmType(Parm, Replacement);
3900 Types.push_back(SubstParm);
3901 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
3902 }
3903
3904 return QualType(SubstParm, 0);
3905}
3906
3907/// Retrieve a
3908QualType ASTContext::getSubstTemplateTypeParmPackType(
3909 const TemplateTypeParmType *Parm,
3910 const TemplateArgument &ArgPack) {
3911#ifndef NDEBUG
3912 for (const auto &P : ArgPack.pack_elements()) {
3913 assert(P.getKind() == TemplateArgument::Type &&"Pack contains a non-type")((P.getKind() == TemplateArgument::Type &&"Pack contains a non-type"
) ? static_cast<void> (0) : __assert_fail ("P.getKind() == TemplateArgument::Type &&\"Pack contains a non-type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3913, __PRETTY_FUNCTION__))
;
3914 assert(P.getAsType().isCanonical() && "Pack contains non-canonical type")((P.getAsType().isCanonical() && "Pack contains non-canonical type"
) ? static_cast<void> (0) : __assert_fail ("P.getAsType().isCanonical() && \"Pack contains non-canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3914, __PRETTY_FUNCTION__))
;
3915 }
3916#endif
3917
3918 llvm::FoldingSetNodeID ID;
3919 SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack);
3920 void *InsertPos = nullptr;
3921 if (SubstTemplateTypeParmPackType *SubstParm
3922 = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
3923 return QualType(SubstParm, 0);
3924
3925 QualType Canon;
3926 if (!Parm->isCanonicalUnqualified()) {
3927 Canon = getCanonicalType(QualType(Parm, 0));
3928 Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon),
3929 ArgPack);
3930 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
3931 }
3932
3933 auto *SubstParm
3934 = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon,
3935 ArgPack);
3936 Types.push_back(SubstParm);
3937 SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
3938 return QualType(SubstParm, 0);
3939}
3940
3941/// Retrieve the template type parameter type for a template
3942/// parameter or parameter pack with the given depth, index, and (optionally)
3943/// name.
3944QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
3945 bool ParameterPack,
3946 TemplateTypeParmDecl *TTPDecl) const {
3947 llvm::FoldingSetNodeID ID;
3948 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
3949 void *InsertPos = nullptr;
3950 TemplateTypeParmType *TypeParm
3951 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3952
3953 if (TypeParm)
3954 return QualType(TypeParm, 0);
3955
3956 if (TTPDecl) {
3957 QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
3958 TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon);
3959
3960 TemplateTypeParmType *TypeCheck
3961 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3962 assert(!TypeCheck && "Template type parameter canonical type broken")((!TypeCheck && "Template type parameter canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!TypeCheck && \"Template type parameter canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3962, __PRETTY_FUNCTION__))
;
3963 (void)TypeCheck;
3964 } else
3965 TypeParm = new (*this, TypeAlignment)
3966 TemplateTypeParmType(Depth, Index, ParameterPack);
3967
3968 Types.push_back(TypeParm);
3969 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
3970
3971 return QualType(TypeParm, 0);
3972}
3973
3974TypeSourceInfo *
3975ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name,
3976 SourceLocation NameLoc,
3977 const TemplateArgumentListInfo &Args,
3978 QualType Underlying) const {
3979 assert(!Name.getAsDependentTemplateName() &&((!Name.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Name.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3980, __PRETTY_FUNCTION__))
3980 "No dependent template names here!")((!Name.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Name.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3980, __PRETTY_FUNCTION__))
;
3981 QualType TST = getTemplateSpecializationType(Name, Args, Underlying);
3982
3983 TypeSourceInfo *DI = CreateTypeSourceInfo(TST);
3984 TemplateSpecializationTypeLoc TL =
3985 DI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>();
3986 TL.setTemplateKeywordLoc(SourceLocation());
3987 TL.setTemplateNameLoc(NameLoc);
3988 TL.setLAngleLoc(Args.getLAngleLoc());
3989 TL.setRAngleLoc(Args.getRAngleLoc());
3990 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3991 TL.setArgLocInfo(i, Args[i].getLocInfo());
3992 return DI;
3993}
3994
3995QualType
3996ASTContext::getTemplateSpecializationType(TemplateName Template,
3997 const TemplateArgumentListInfo &Args,
3998 QualType Underlying) const {
3999 assert(!Template.getAsDependentTemplateName() &&((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4000, __PRETTY_FUNCTION__))
4000 "No dependent template names here!")((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4000, __PRETTY_FUNCTION__))
;
4001
4002 SmallVector<TemplateArgument, 4> ArgVec;
4003 ArgVec.reserve(Args.size());
4004 for (const TemplateArgumentLoc &Arg : Args.arguments())
4005 ArgVec.push_back(Arg.getArgument());
4006
4007 return getTemplateSpecializationType(Template, ArgVec, Underlying);
4008}
4009
4010#ifndef NDEBUG
4011static bool hasAnyPackExpansions(ArrayRef<TemplateArgument> Args) {
4012 for (const TemplateArgument &Arg : Args)
4013 if (Arg.isPackExpansion())
4014 return true;
4015
4016 return true;
4017}
4018#endif
4019
4020QualType
4021ASTContext::getTemplateSpecializationType(TemplateName Template,
4022 ArrayRef<TemplateArgument> Args,
4023 QualType Underlying) const {
4024 assert(!Template.getAsDependentTemplateName() &&((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4025, __PRETTY_FUNCTION__))
4025 "No dependent template names here!")((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4025, __PRETTY_FUNCTION__))
;
4026 // Look through qualified template names.
4027 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
4028 Template = TemplateName(QTN->getTemplateDecl());
4029
4030 bool IsTypeAlias =
4031 Template.getAsTemplateDecl() &&
4032 isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
4033 QualType CanonType;
4034 if (!Underlying.isNull())
4035 CanonType = getCanonicalType(Underlying);
4036 else {
4037 // We can get here with an alias template when the specialization contains
4038 // a pack expansion that does not match up with a parameter pack.
4039 assert((!IsTypeAlias || hasAnyPackExpansions(Args)) &&(((!IsTypeAlias || hasAnyPackExpansions(Args)) && "Caller must compute aliased type"
) ? static_cast<void> (0) : __assert_fail ("(!IsTypeAlias || hasAnyPackExpansions(Args)) && \"Caller must compute aliased type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4040, __PRETTY_FUNCTION__))
4040 "Caller must compute aliased type")(((!IsTypeAlias || hasAnyPackExpansions(Args)) && "Caller must compute aliased type"
) ? static_cast<void> (0) : __assert_fail ("(!IsTypeAlias || hasAnyPackExpansions(Args)) && \"Caller must compute aliased type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4040, __PRETTY_FUNCTION__))
;
4041 IsTypeAlias = false;
4042 CanonType = getCanonicalTemplateSpecializationType(Template, Args);
4043 }
4044
4045 // Allocate the (non-canonical) template specialization type, but don't
4046 // try to unique it: these types typically have location information that
4047 // we don't unique and don't want to lose.
4048 void *Mem = Allocate(sizeof(TemplateSpecializationType) +
4049 sizeof(TemplateArgument) * Args.size() +
4050 (IsTypeAlias? sizeof(QualType) : 0),
4051 TypeAlignment);
4052 auto *Spec
4053 = new (Mem) TemplateSpecializationType(Template, Args, CanonType,
4054 IsTypeAlias ? Underlying : QualType());
4055
4056 Types.push_back(Spec);
4057 return QualType(Spec, 0);
4058}
4059
4060QualType ASTContext::getCanonicalTemplateSpecializationType(
4061 TemplateName Template, ArrayRef<TemplateArgument> Args) const {
4062 assert(!Template.getAsDependentTemplateName() &&((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4063, __PRETTY_FUNCTION__))
4063 "No dependent template names here!")((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4063, __PRETTY_FUNCTION__))
;
4064
4065 // Look through qualified template names.
4066 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
4067 Template = TemplateName(QTN->getTemplateDecl());
4068
4069 // Build the canonical template specialization type.
4070 TemplateName CanonTemplate = getCanonicalTemplateName(Template);
4071 SmallVector<TemplateArgument, 4> CanonArgs;
4072 unsigned NumArgs = Args.size();
4073 CanonArgs.reserve(NumArgs);
4074 for (const TemplateArgument &Arg : Args)
4075 CanonArgs.push_back(getCanonicalTemplateArgument(Arg));
4076
4077 // Determine whether this canonical template specialization type already
4078 // exists.
4079 llvm::FoldingSetNodeID ID;
4080 TemplateSpecializationType::Profile(ID, CanonTemplate,
4081 CanonArgs, *this);
4082
4083 void *InsertPos = nullptr;
4084 TemplateSpecializationType *Spec
4085 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4086
4087 if (!Spec) {
4088 // Allocate a new canonical template specialization type.
4089 void *Mem = Allocate((sizeof(TemplateSpecializationType) +
4090 sizeof(TemplateArgument) * NumArgs),
4091 TypeAlignment);
4092 Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
4093 CanonArgs,
4094 QualType(), QualType());
4095 Types.push_back(Spec);
4096 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
4097 }
4098
4099 assert(Spec->isDependentType() &&((Spec->isDependentType() && "Non-dependent template-id type must have a canonical type"
) ? static_cast<void> (0) : __assert_fail ("Spec->isDependentType() && \"Non-dependent template-id type must have a canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4100, __PRETTY_FUNCTION__))
4100 "Non-dependent template-id type must have a canonical type")((Spec->isDependentType() && "Non-dependent template-id type must have a canonical type"
) ? static_cast<void> (0) : __assert_fail ("Spec->isDependentType() && \"Non-dependent template-id type must have a canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4100, __PRETTY_FUNCTION__))
;
4101 return QualType(Spec, 0);
4102}
4103
4104QualType ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
4105 NestedNameSpecifier *NNS,
4106 QualType NamedType,
4107 TagDecl *OwnedTagDecl) const {
4108 llvm::FoldingSetNodeID ID;
4109 ElaboratedType::Profile(ID, Keyword, NNS, NamedType, OwnedTagDecl);
4110
4111 void *InsertPos = nullptr;
4112 ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
4113 if (T)
4114 return QualType(T, 0);
4115
4116 QualType Canon = NamedType;
4117 if (!Canon.isCanonical()) {
4118 Canon = getCanonicalType(NamedType);
4119 ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
4120 assert(!CheckT && "Elaborated canonical type broken")((!CheckT && "Elaborated canonical type broken") ? static_cast
<void> (0) : __assert_fail ("!CheckT && \"Elaborated canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4120, __PRETTY_FUNCTION__))
;
4121 (void)CheckT;
4122 }
4123
4124 void *Mem = Allocate(ElaboratedType::totalSizeToAlloc<TagDecl *>(!!OwnedTagDecl),
4125 TypeAlignment);
4126 T = new (Mem) ElaboratedType(Keyword, NNS, NamedType, Canon, OwnedTagDecl);
4127
4128 Types.push_back(T);
4129 ElaboratedTypes.InsertNode(T, InsertPos);
4130 return QualType(T, 0);
4131}
4132
4133QualType
4134ASTContext::getParenType(QualType InnerType) const {
4135 llvm::FoldingSetNodeID ID;
4136 ParenType::Profile(ID, InnerType);
4137
4138 void *InsertPos = nullptr;
4139 ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4140 if (T)
4141 return QualType(T, 0);
4142
4143 QualType Canon = InnerType;
4144 if (!Canon.isCanonical()) {
4145 Canon = getCanonicalType(InnerType);
4146 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4147 assert(!CheckT && "Paren canonical type broken")((!CheckT && "Paren canonical type broken") ? static_cast
<void> (0) : __assert_fail ("!CheckT && \"Paren canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4147, __PRETTY_FUNCTION__))
;
4148 (void)CheckT;
4149 }
4150
4151 T = new (*this, TypeAlignment) ParenType(InnerType, Canon);
4152 Types.push_back(T);
4153 ParenTypes.InsertNode(T, InsertPos);
4154 return QualType(T, 0);
4155}
4156
4157QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
4158 NestedNameSpecifier *NNS,
4159 const IdentifierInfo *Name,
4160 QualType Canon) const {
4161 if (Canon.isNull()) {
4162 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
4163 if (CanonNNS != NNS)
4164 Canon = getDependentNameType(Keyword, CanonNNS, Name);
4165 }
4166
4167 llvm::FoldingSetNodeID ID;
4168 DependentNameType::Profile(ID, Keyword, NNS, Name);
4169
4170 void *InsertPos = nullptr;
4171 DependentNameType *T
4172 = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
4173 if (T)
4174 return QualType(T, 0);
4175
4176 T = new (*this, TypeAlignment) DependentNameType(Keyword, NNS, Name, Canon);
4177 Types.push_back(T);
4178 DependentNameTypes.InsertNode(T, InsertPos);
4179 return QualType(T, 0);
4180}
4181
4182QualType
4183ASTContext::getDependentTemplateSpecializationType(
4184 ElaboratedTypeKeyword Keyword,
4185 NestedNameSpecifier *NNS,
4186 const IdentifierInfo *Name,
4187 const TemplateArgumentListInfo &Args) const {
4188 // TODO: avoid this copy
4189 SmallVector<TemplateArgument, 16> ArgCopy;
4190 for (unsigned I = 0, E = Args.size(); I != E; ++I)
4191 ArgCopy.push_back(Args[I].getArgument());
4192 return getDependentTemplateSpecializationType(Keyword, NNS, Name, ArgCopy);
4193}
4194
4195QualType
4196ASTContext::getDependentTemplateSpecializationType(
4197 ElaboratedTypeKeyword Keyword,
4198 NestedNameSpecifier *NNS,
4199 const IdentifierInfo *Name,
4200 ArrayRef<TemplateArgument> Args) const {
4201 assert((!NNS || NNS->isDependent()) &&(((!NNS || NNS->isDependent()) && "nested-name-specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"nested-name-specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4202, __PRETTY_FUNCTION__))
4202 "nested-name-specifier must be dependent")(((!NNS || NNS->isDependent()) && "nested-name-specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"nested-name-specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4202, __PRETTY_FUNCTION__))
;
4203
4204 llvm::FoldingSetNodeID ID;
4205 DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
4206 Name, Args);
4207
4208 void *InsertPos = nullptr;
4209 DependentTemplateSpecializationType *T
4210 = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4211 if (T)
4212 return QualType(T, 0);
4213
4214 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
4215
4216 ElaboratedTypeKeyword CanonKeyword = Keyword;
4217 if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
4218
4219 bool AnyNonCanonArgs = false;
4220 unsigned NumArgs = Args.size();
4221 SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
4222 for (unsigned I = 0; I != NumArgs; ++I) {
4223 CanonArgs[I] = getCanonicalTemplateArgument(Args[I]);
4224 if (!CanonArgs[I].structurallyEquals(Args[I]))
4225 AnyNonCanonArgs = true;
4226 }
4227
4228 QualType Canon;
4229 if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
4230 Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
4231 Name,
4232 CanonArgs);
4233
4234 // Find the insert position again.
4235 DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4236 }
4237
4238 void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
4239 sizeof(TemplateArgument) * NumArgs),
4240 TypeAlignment);
4241 T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
4242 Name, Args, Canon);
4243 Types.push_back(T);
4244 DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
4245 return QualType(T, 0);
4246}
4247
4248TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) {
4249 TemplateArgument Arg;
4250 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
4251 QualType ArgType = getTypeDeclType(TTP);
4252 if (TTP->isParameterPack())
4253 ArgType = getPackExpansionType(ArgType, None);
4254
4255 Arg = TemplateArgument(ArgType);
4256 } else if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4257 Expr *E = new (*this) DeclRefExpr(
4258 NTTP, /*enclosing*/false,
4259 NTTP->getType().getNonLValueExprType(*this),
4260 Expr::getValueKindForType(NTTP->getType()), NTTP->getLocation());
4261
4262 if (NTTP->isParameterPack())
4263 E = new (*this) PackExpansionExpr(DependentTy, E, NTTP->getLocation(),
4264 None);
4265 Arg = TemplateArgument(E);
4266 } else {
4267 auto *TTP = cast<TemplateTemplateParmDecl>(Param);
4268 if (TTP->isParameterPack())
4269 Arg = TemplateArgument(TemplateName(TTP), Optional<unsigned>());
4270 else
4271 Arg = TemplateArgument(TemplateName(TTP));
4272 }
4273
4274 if (Param->isTemplateParameterPack())
4275 Arg = TemplateArgument::CreatePackCopy(*this, Arg);
4276
4277 return Arg;
4278}
4279
4280void
4281ASTContext::getInjectedTemplateArgs(const TemplateParameterList *Params,
4282 SmallVectorImpl<TemplateArgument> &Args) {
4283 Args.reserve(Args.size() + Params->size());
4284
4285 for (NamedDecl *Param : *Params)
4286 Args.push_back(getInjectedTemplateArg(Param));
4287}
4288
4289QualType ASTContext::getPackExpansionType(QualType Pattern,
4290 Optional<unsigned> NumExpansions) {
4291 llvm::FoldingSetNodeID ID;
4292 PackExpansionType::Profile(ID, Pattern, NumExpansions);
4293
4294 assert(Pattern->containsUnexpandedParameterPack() &&((Pattern->containsUnexpandedParameterPack() && "Pack expansions must expand one or more parameter packs"
) ? static_cast<void> (0) : __assert_fail ("Pattern->containsUnexpandedParameterPack() && \"Pack expansions must expand one or more parameter packs\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4295, __PRETTY_FUNCTION__))
4295 "Pack expansions must expand one or more parameter packs")((Pattern->containsUnexpandedParameterPack() && "Pack expansions must expand one or more parameter packs"
) ? static_cast<void> (0) : __assert_fail ("Pattern->containsUnexpandedParameterPack() && \"Pack expansions must expand one or more parameter packs\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4295, __PRETTY_FUNCTION__))
;
4296 void *InsertPos = nullptr;
4297 PackExpansionType *T
4298 = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4299 if (T)
4300 return QualType(T, 0);
4301
4302 QualType Canon;
4303 if (!Pattern.isCanonical()) {
4304 Canon = getCanonicalType(Pattern);
4305 // The canonical type might not contain an unexpanded parameter pack, if it
4306 // contains an alias template specialization which ignores one of its
4307 // parameters.
4308 if (Canon->containsUnexpandedParameterPack()) {
4309 Canon = getPackExpansionType(Canon, NumExpansions);
4310
4311 // Find the insert position again, in case we inserted an element into
4312 // PackExpansionTypes and invalidated our insert position.
4313 PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4314 }
4315 }
4316
4317 T = new (*this, TypeAlignment)
4318 PackExpansionType(Pattern, Canon, NumExpansions);
4319 Types.push_back(T);
4320 PackExpansionTypes.InsertNode(T, InsertPos);
4321 return QualType(T, 0);
4322}
4323
4324/// CmpProtocolNames - Comparison predicate for sorting protocols
4325/// alphabetically.
4326static int CmpProtocolNames(ObjCProtocolDecl *const *LHS,
4327 ObjCProtocolDecl *const *RHS) {
4328 return DeclarationName::compare((*LHS)->getDeclName(), (*RHS)->getDeclName());
4329}
4330
4331static bool areSortedAndUniqued(ArrayRef<ObjCProtocolDecl *> Protocols) {
4332 if (Protocols.empty()) return true;
4333
4334 if (Protocols[0]->getCanonicalDecl() != Protocols[0])
4335 return false;
4336
4337 for (unsigned i = 1; i != Protocols.size(); ++i)
4338 if (CmpProtocolNames(&Protocols[i - 1], &Protocols[i]) >= 0 ||
4339 Protocols[i]->getCanonicalDecl() != Protocols[i])
4340 return false;
4341 return true;
4342}
4343
4344static void
4345SortAndUniqueProtocols(SmallVectorImpl<ObjCProtocolDecl *> &Protocols) {
4346 // Sort protocols, keyed by name.
4347 llvm::array_pod_sort(Protocols.begin(), Protocols.end(), CmpProtocolNames);
4348
4349 // Canonicalize.
4350 for (ObjCProtocolDecl *&P : Protocols)
4351 P = P->getCanonicalDecl();
4352
4353 // Remove duplicates.
4354 auto ProtocolsEnd = std::unique(Protocols.begin(), Protocols.end());
4355 Protocols.erase(ProtocolsEnd, Protocols.end());
4356}
4357
4358QualType ASTContext::getObjCObjectType(QualType BaseType,
4359 ObjCProtocolDecl * const *Protocols,
4360 unsigned NumProtocols) const {
4361 return getObjCObjectType(BaseType, {},
4362 llvm::makeArrayRef(Protocols, NumProtocols),
4363 /*isKindOf=*/false);
4364}
4365
4366QualType ASTContext::getObjCObjectType(
4367 QualType baseType,
4368 ArrayRef<QualType> typeArgs,
4369 ArrayRef<ObjCProtocolDecl *> protocols,
4370 bool isKindOf) const {
4371 // If the base type is an interface and there aren't any protocols or
4372 // type arguments to add, then the interface type will do just fine.
4373 if (typeArgs.empty() && protocols.empty() && !isKindOf &&
4374 isa<ObjCInterfaceType>(baseType))
4375 return baseType;
4376
4377 // Look in the folding set for an existing type.
4378 llvm::FoldingSetNodeID ID;
4379 ObjCObjectTypeImpl::Profile(ID, baseType, typeArgs, protocols, isKindOf);
4380 void *InsertPos = nullptr;
4381 if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
4382 return QualType(QT, 0);
4383
4384 // Determine the type arguments to be used for canonicalization,
4385 // which may be explicitly specified here or written on the base
4386 // type.
4387 ArrayRef<QualType> effectiveTypeArgs = typeArgs;
4388 if (effectiveTypeArgs.empty()) {
4389 if (const auto *baseObject = baseType->getAs<ObjCObjectType>())
4390 effectiveTypeArgs = baseObject->getTypeArgs();
4391 }
4392
4393 // Build the canonical type, which has the canonical base type and a
4394 // sorted-and-uniqued list of protocols and the type arguments
4395 // canonicalized.
4396 QualType canonical;
4397 bool typeArgsAreCanonical = std::all_of(effectiveTypeArgs.begin(),
4398 effectiveTypeArgs.end(),
4399 [&](QualType type) {
4400 return type.isCanonical();
4401 });
4402 bool protocolsSorted = areSortedAndUniqued(protocols);
4403 if (!typeArgsAreCanonical || !protocolsSorted || !baseType.isCanonical()) {
4404 // Determine the canonical type arguments.
4405 ArrayRef<QualType> canonTypeArgs;
4406 SmallVector<QualType, 4> canonTypeArgsVec;
4407 if (!typeArgsAreCanonical) {
4408 canonTypeArgsVec.reserve(effectiveTypeArgs.size());
4409 for (auto typeArg : effectiveTypeArgs)
4410 canonTypeArgsVec.push_back(getCanonicalType(typeArg));
4411 canonTypeArgs = canonTypeArgsVec;
4412 } else {
4413 canonTypeArgs = effectiveTypeArgs;
4414 }
4415
4416 ArrayRef<ObjCProtocolDecl *> canonProtocols;
4417 SmallVector<ObjCProtocolDecl*, 8> canonProtocolsVec;
4418 if (!protocolsSorted) {
4419 canonProtocolsVec.append(protocols.begin(), protocols.end());
4420 SortAndUniqueProtocols(canonProtocolsVec);
4421 canonProtocols = canonProtocolsVec;
4422 } else {
4423 canonProtocols = protocols;
4424 }
4425
4426 canonical = getObjCObjectType(getCanonicalType(baseType), canonTypeArgs,
4427 canonProtocols, isKindOf);
4428
4429 // Regenerate InsertPos.
4430 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
4431 }
4432
4433 unsigned size = sizeof(ObjCObjectTypeImpl);
4434 size += typeArgs.size() * sizeof(QualType);
4435 size += protocols.size() * sizeof(ObjCProtocolDecl *);
4436 void *mem = Allocate(size, TypeAlignment);
4437 auto *T =
4438 new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
4439 isKindOf);
4440
4441 Types.push_back(T);
4442 ObjCObjectTypes.InsertNode(T, InsertPos);
4443 return QualType(T, 0);
4444}
4445
4446/// Apply Objective-C protocol qualifiers to the given type.
4447/// If this is for the canonical type of a type parameter, we can apply
4448/// protocol qualifiers on the ObjCObjectPointerType.
4449QualType
4450ASTContext::applyObjCProtocolQualifiers(QualType type,
4451 ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
4452 bool allowOnPointerType) const {
4453 hasError = false;
4454
4455 if (const auto *objT = dyn_cast<ObjCTypeParamType>(type.getTypePtr())) {
4456 return getObjCTypeParamType(objT->getDecl(), protocols);
4457 }
4458
4459 // Apply protocol qualifiers to ObjCObjectPointerType.
4460 if (allowOnPointerType) {
4461 if (const auto *objPtr =
4462 dyn_cast<ObjCObjectPointerType>(type.getTypePtr())) {
4463 const ObjCObjectType *objT = objPtr->getObjectType();
4464 // Merge protocol lists and construct ObjCObjectType.
4465 SmallVector<ObjCProtocolDecl*, 8> protocolsVec;
4466 protocolsVec.append(objT->qual_begin(),
4467 objT->qual_end());
4468 protocolsVec.append(protocols.begin(), protocols.end());
4469 ArrayRef<ObjCProtocolDecl *> protocols = protocolsVec;
4470 type = getObjCObjectType(
4471 objT->getBaseType(),
4472 objT->getTypeArgsAsWritten(),
4473 protocols,
4474 objT->isKindOfTypeAsWritten());
4475 return getObjCObjectPointerType(type);
4476 }
4477 }
4478
4479 // Apply protocol qualifiers to ObjCObjectType.
4480 if (const auto *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){
4481 // FIXME: Check for protocols to which the class type is already
4482 // known to conform.
4483
4484 return getObjCObjectType(objT->getBaseType(),
4485 objT->getTypeArgsAsWritten(),
4486 protocols,
4487 objT->isKindOfTypeAsWritten());
4488 }
4489
4490 // If the canonical type is ObjCObjectType, ...
4491 if (type->isObjCObjectType()) {
4492 // Silently overwrite any existing protocol qualifiers.
4493 // TODO: determine whether that's the right thing to do.
4494
4495 // FIXME: Check for protocols to which the class type is already
4496 // known to conform.
4497 return getObjCObjectType(type, {}, protocols, false);
4498 }
4499
4500 // id<protocol-list>
4501 if (type->isObjCIdType()) {
4502 const auto *objPtr = type->castAs<ObjCObjectPointerType>();
4503 type = getObjCObjectType(ObjCBuiltinIdTy, {}, protocols,
4504 objPtr->isKindOfType());
4505 return getObjCObjectPointerType(type);
4506 }
4507
4508 // Class<protocol-list>
4509 if (type->isObjCClassType()) {
4510 const auto *objPtr = type->castAs<ObjCObjectPointerType>();
4511 type = getObjCObjectType(ObjCBuiltinClassTy, {}, protocols,
4512 objPtr->isKindOfType());
4513 return getObjCObjectPointerType(type);
4514 }
4515
4516 hasError = true;
4517 return type;
4518}
4519
4520QualType
4521ASTContext::getObjCTypeParamType(const ObjCTypeParamDecl *Decl,
4522 ArrayRef<ObjCProtocolDecl *> protocols,
4523 QualType Canonical) const {
4524 // Look in the folding set for an existing type.
4525 llvm::FoldingSetNodeID ID;
4526 ObjCTypeParamType::Profile(ID, Decl, protocols);
4527 void *InsertPos = nullptr;
4528 if (ObjCTypeParamType *TypeParam =
4529 ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
4530 return QualType(TypeParam, 0);
4531
4532 if (Canonical.isNull()) {
4533 // We canonicalize to the underlying type.
4534 Canonical = getCanonicalType(Decl->getUnderlyingType());
4535 if (!protocols.empty()) {
4536 // Apply the protocol qualifers.
4537 bool hasError;
4538 Canonical = getCanonicalType(applyObjCProtocolQualifiers(
4539 Canonical, protocols, hasError, true /*allowOnPointerType*/));
4540 assert(!hasError && "Error when apply protocol qualifier to bound type")((!hasError && "Error when apply protocol qualifier to bound type"
) ? static_cast<void> (0) : __assert_fail ("!hasError && \"Error when apply protocol qualifier to bound type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4540, __PRETTY_FUNCTION__))
;
4541 }
4542 }
4543
4544 unsigned size = sizeof(ObjCTypeParamType);
4545 size += protocols.size() * sizeof(ObjCProtocolDecl *);
4546 void *mem = Allocate(size, TypeAlignment);
4547 auto *newType = new (mem) ObjCTypeParamType(Decl, Canonical, protocols);
4548
4549 Types.push_back(newType);
4550 ObjCTypeParamTypes.InsertNode(newType, InsertPos);
4551 return QualType(newType, 0);
4552}
4553
4554/// ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC's
4555/// protocol list adopt all protocols in QT's qualified-id protocol
4556/// list.
4557bool ASTContext::ObjCObjectAdoptsQTypeProtocols(QualType QT,
4558 ObjCInterfaceDecl *IC) {
4559 if (!QT->isObjCQualifiedIdType())
4560 return false;
4561
4562 if (const auto *OPT = QT->getAs<ObjCObjectPointerType>()) {
4563 // If both the right and left sides have qualifiers.
4564 for (auto *Proto : OPT->quals()) {
4565 if (!IC->ClassImplementsProtocol(Proto, false))
4566 return false;
4567 }
4568 return true;
4569 }
4570 return false;
4571}
4572
4573/// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
4574/// QT's qualified-id protocol list adopt all protocols in IDecl's list
4575/// of protocols.
4576bool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
4577 ObjCInterfaceDecl *IDecl) {
4578 if (!QT->isObjCQualifiedIdType())
4579 return false;
4580 const auto *OPT = QT->getAs<ObjCObjectPointerType>();
4581 if (!OPT)
4582 return false;
4583 if (!IDecl->hasDefinition())
4584 return false;
4585 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols;
4586 CollectInheritedProtocols(IDecl, InheritedProtocols);
4587 if (InheritedProtocols.empty())
4588 return false;
4589 // Check that if every protocol in list of id<plist> conforms to a protocol
4590 // of IDecl's, then bridge casting is ok.
4591 bool Conforms = false;
4592 for (auto *Proto : OPT->quals()) {
4593 Conforms = false;
4594 for (auto *PI : InheritedProtocols) {
4595 if (ProtocolCompatibleWithProtocol(Proto, PI)) {
4596 Conforms = true;
4597 break;
4598 }
4599 }
4600 if (!Conforms)
4601 break;
4602 }
4603 if (Conforms)
4604 return true;
4605
4606 for (auto *PI : InheritedProtocols) {
4607 // If both the right and left sides have qualifiers.
4608 bool Adopts = false;
4609 for (auto *Proto : OPT->quals()) {
4610 // return 'true' if 'PI' is in the inheritance hierarchy of Proto
4611 if ((Adopts = ProtocolCompatibleWithProtocol(PI, Proto)))
4612 break;
4613 }
4614 if (!Adopts)
4615 return false;
4616 }
4617 return true;
4618}
4619
4620/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
4621/// the given object type.
4622QualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const {
4623 llvm::FoldingSetNodeID ID;
4624 ObjCObjectPointerType::Profile(ID, ObjectT);
4625
4626 void *InsertPos = nullptr;
4627 if (ObjCObjectPointerType *QT =
4628 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
4629 return QualType(QT, 0);
4630
4631 // Find the canonical object type.
4632 QualType Canonical;
4633 if (!ObjectT.isCanonical()) {
4634 Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));
4635
4636 // Regenerate InsertPos.
4637 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
4638 }
4639
4640 // No match.
4641 void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
4642 auto *QType =
4643 new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
4644
4645 Types.push_back(QType);
4646 ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
4647 return QualType(QType, 0);
4648}
4649
4650/// getObjCInterfaceType - Return the unique reference to the type for the
4651/// specified ObjC interface decl. The list of protocols is optional.
4652QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
4653 ObjCInterfaceDecl *PrevDecl) const {
4654 if (Decl->TypeForDecl)
4655 return QualType(Decl->TypeForDecl, 0);
4656
4657 if (PrevDecl) {
4658 assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl")((PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"
) ? static_cast<void> (0) : __assert_fail ("PrevDecl->TypeForDecl && \"previous decl has no TypeForDecl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4658, __PRETTY_FUNCTION__))
;
4659 Decl->TypeForDecl = PrevDecl->TypeForDecl;
4660 return QualType(PrevDecl->TypeForDecl, 0);
4661 }
4662
4663 // Prefer the definition, if there is one.
4664 if (const ObjCInterfaceDecl *Def = Decl->getDefinition())
4665 Decl = Def;
4666
4667 void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
4668 auto *T = new (Mem) ObjCInterfaceType(Decl);
4669 Decl->TypeForDecl = T;
4670 Types.push_back(T);
4671 return QualType(T, 0);
4672}
4673
4674/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
4675/// TypeOfExprType AST's (since expression's are never shared). For example,
4676/// multiple declarations that refer to "typeof(x)" all contain different
4677/// DeclRefExpr's. This doesn't effect the type checker, since it operates
4678/// on canonical type's (which are always unique).
4679QualType ASTContext::getTypeOfExprType(Expr *tofExpr) const {
4680 TypeOfExprType *toe;
4681 if (tofExpr->isTypeDependent()) {
4682 llvm::FoldingSetNodeID ID;
4683 DependentTypeOfExprType::Profile(ID, *this, tofExpr);
4684
4685 void *InsertPos = nullptr;
4686 DependentTypeOfExprType *Canon
4687 = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
4688 if (Canon) {
4689 // We already have a "canonical" version of an identical, dependent
4690 // typeof(expr) type. Use that as our canonical type.
4691 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
4692 QualType((TypeOfExprType*)Canon, 0));
4693 } else {
4694 // Build a new, canonical typeof(expr) type.
4695 Canon
4696 = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
4697 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
4698 toe = Canon;
4699 }
4700 } else {
4701 QualType Canonical = getCanonicalType(tofExpr->getType());
4702 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
4703 }
4704 Types.push_back(toe);
4705 return QualType(toe, 0);
4706}
4707
4708/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique
4709/// TypeOfType nodes. The only motivation to unique these nodes would be
4710/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
4711/// an issue. This doesn't affect the type checker, since it operates
4712/// on canonical types (which are always unique).
4713QualType ASTContext::getTypeOfType(QualType tofType) const {
4714 QualType Canonical = getCanonicalType(tofType);
4715 auto *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
4716 Types.push_back(tot);
4717 return QualType(tot, 0);
4718}
4719
4720/// Unlike many "get<Type>" functions, we don't unique DecltypeType
4721/// nodes. This would never be helpful, since each such type has its own
4722/// expression, and would not give a significant memory saving, since there
4723/// is an Expr tree under each such type.
4724QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const {
4725 DecltypeType *dt;
4726
4727 // C++11 [temp.type]p2:
4728 // If an expression e involves a template parameter, decltype(e) denotes a
4729 // unique dependent type. Two such decltype-specifiers refer to the same
4730 // type only if their expressions are equivalent (14.5.6.1).
4731 if (e->isInstantiationDependent()) {
4732 llvm::FoldingSetNodeID ID;
4733 DependentDecltypeType::Profile(ID, *this, e);
4734
4735 void *InsertPos = nullptr;
4736 DependentDecltypeType *Canon
4737 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
4738 if (!Canon) {
4739 // Build a new, canonical decltype(expr) type.
4740 Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
4741 DependentDecltypeTypes.InsertNode(Canon, InsertPos);
4742 }
4743 dt = new (*this, TypeAlignment)
4744 DecltypeType(e, UnderlyingType, QualType((DecltypeType *)Canon, 0));
4745 } else {
4746 dt = new (*this, TypeAlignment)
4747 DecltypeType(e, UnderlyingType, getCanonicalType(UnderlyingType));
4748 }
4749 Types.push_back(dt);
4750 return QualType(dt, 0);
4751}
4752
4753/// getUnaryTransformationType - We don't unique these, since the memory
4754/// savings are minimal and these are rare.
4755QualType ASTContext::getUnaryTransformType(QualType BaseType,
4756 QualType UnderlyingType,
4757 UnaryTransformType::UTTKind Kind)
4758 const {
4759 UnaryTransformType *ut = nullptr;
4760
4761 if (BaseType->isDependentType()) {
4762 // Look in the folding set for an existing type.
4763 llvm::FoldingSetNodeID ID;
4764 DependentUnaryTransformType::Profile(ID, getCanonicalType(BaseType), Kind);
4765
4766 void *InsertPos = nullptr;
4767 DependentUnaryTransformType *Canon
4768 = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
4769
4770 if (!Canon) {
4771 // Build a new, canonical __underlying_type(type) type.
4772 Canon = new (*this, TypeAlignment)
4773 DependentUnaryTransformType(*this, getCanonicalType(BaseType),
4774 Kind);
4775 DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);
4776 }
4777 ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4778 QualType(), Kind,
4779 QualType(Canon, 0));
4780 } else {
4781 QualType CanonType = getCanonicalType(UnderlyingType);
4782 ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4783 UnderlyingType, Kind,
4784 CanonType);
4785 }
4786 Types.push_back(ut);
4787 return QualType(ut, 0);
4788}
4789
4790/// getAutoType - Return the uniqued reference to the 'auto' type which has been
4791/// deduced to the given type, or to the canonical undeduced 'auto' type, or the
4792/// canonical deduced-but-dependent 'auto' type.
4793QualType ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
4794 bool IsDependent) const {
4795 if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto && !IsDependent)
4796 return getAutoDeductType();
4797
4798 // Look in the folding set for an existing type.
4799 void *InsertPos = nullptr;
4800 llvm::FoldingSetNodeID ID;
4801 AutoType::Profile(ID, DeducedType, Keyword, IsDependent);
4802 if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
4803 return QualType(AT, 0);
4804
4805 auto *AT = new (*this, TypeAlignment)
4806 AutoType(DeducedType, Keyword, IsDependent);
4807 Types.push_back(AT);
4808 if (InsertPos)
4809 AutoTypes.InsertNode(AT, InsertPos);
4810 return QualType(AT, 0);
4811}
4812
4813/// Return the uniqued reference to the deduced template specialization type
4814/// which has been deduced to the given type, or to the canonical undeduced
4815/// such type, or the canonical deduced-but-dependent such type.
4816QualType ASTContext::getDeducedTemplateSpecializationType(
4817 TemplateName Template, QualType DeducedType, bool IsDependent) const {
4818 // Look in the folding set for an existing type.
4819 void *InsertPos = nullptr;
4820 llvm::FoldingSetNodeID ID;
4821 DeducedTemplateSpecializationType::Profile(ID, Template, DeducedType,
4822 IsDependent);
4823 if (DeducedTemplateSpecializationType *DTST =
4824 DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
4825 return QualType(DTST, 0);
4826
4827 auto *DTST = new (*this, TypeAlignment)
4828 DeducedTemplateSpecializationType(Template, DeducedType, IsDependent);
4829 Types.push_back(DTST);
4830 if (InsertPos)
4831 DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
4832 return QualType(DTST, 0);
4833}
4834
4835/// getAtomicType - Return the uniqued reference to the atomic type for
4836/// the given value type.
4837QualType ASTContext::getAtomicType(QualType T) const {
4838 // Unique pointers, to guarantee there is only one pointer of a particular
4839 // structure.
4840 llvm::FoldingSetNodeID ID;
4841 AtomicType::Profile(ID, T);
4842
4843 void *InsertPos = nullptr;
4844 if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
4845 return QualType(AT, 0);
4846
4847 // If the atomic value type isn't canonical, this won't be a canonical type
4848 // either, so fill in the canonical type field.
4849 QualType Canonical;
4850 if (!T.isCanonical()) {
4851 Canonical = getAtomicType(getCanonicalType(T));
4852
4853 // Get the new insert position for the node we care about.
4854 AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
4855 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4855, __PRETTY_FUNCTION__))
; (void)NewIP;
4856 }
4857 auto *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
4858 Types.push_back(New);
4859 AtomicTypes.InsertNode(New, InsertPos);
4860 return QualType(New, 0);
4861}
4862
4863/// getAutoDeductType - Get type pattern for deducing against 'auto'.
4864QualType ASTContext::getAutoDeductType() const {
4865 if (AutoDeductTy.isNull())
4866 AutoDeductTy = QualType(
4867 new (*this, TypeAlignment) AutoType(QualType(), AutoTypeKeyword::Auto,
4868 /*dependent*/false),
4869 0);
4870 return AutoDeductTy;
4871}
4872
4873/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'.
4874QualType ASTContext::getAutoRRefDeductType() const {
4875 if (AutoRRefDeductTy.isNull())
4876 AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType());
4877 assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern")((!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"
) ? static_cast<void> (0) : __assert_fail ("!AutoRRefDeductTy.isNull() && \"can't build 'auto &&' pattern\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4877, __PRETTY_FUNCTION__))
;
4878 return AutoRRefDeductTy;
4879}
4880
4881/// getTagDeclType - Return the unique reference to the type for the
4882/// specified TagDecl (struct/union/class/enum) decl.
4883QualType ASTContext::getTagDeclType(const TagDecl *Decl) const {
4884 assert(Decl)((Decl) ? static_cast<void> (0) : __assert_fail ("Decl"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4884, __PRETTY_FUNCTION__))
;
4885 // FIXME: What is the design on getTagDeclType when it requires casting
4886 // away const? mutable?
4887 return getTypeDeclType(const_cast<TagDecl*>(Decl));
4888}
4889
4890/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
4891/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
4892/// needs to agree with the definition in <stddef.h>.
4893CanQualType ASTContext::getSizeType() const {
4894 return getFromTargetType(Target->getSizeType());
4895}
4896
4897/// Return the unique signed counterpart of the integer type
4898/// corresponding to size_t.
4899CanQualType ASTContext::getSignedSizeType() const {
4900 return getFromTargetType(Target->getSignedSizeType());
4901}
4902
4903/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5).
4904CanQualType ASTContext::getIntMaxType() const {
4905 return getFromTargetType(Target->getIntMaxType());
4906}
4907
4908/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5).
4909CanQualType ASTContext::getUIntMaxType() const {
4910 return getFromTargetType(Target->getUIntMaxType());
4911}
4912
4913/// getSignedWCharType - Return the type of "signed wchar_t".
4914/// Used when in C++, as a GCC extension.
4915QualType ASTContext::getSignedWCharType() const {
4916 // FIXME: derive from "Target" ?
4917 return WCharTy;
4918}
4919
4920/// getUnsignedWCharType - Return the type of "unsigned wchar_t".
4921/// Used when in C++, as a GCC extension.
4922QualType ASTContext::getUnsignedWCharType() const {
4923 // FIXME: derive from "Target" ?
4924 return UnsignedIntTy;
4925}
4926
4927QualType ASTContext::getIntPtrType() const {
4928 return getFromTargetType(Target->getIntPtrType());
4929}
4930
4931QualType ASTContext::getUIntPtrType() const {
4932 return getCorrespondingUnsignedType(getIntPtrType());
4933}
4934
4935/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17)
4936/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
4937QualType ASTContext::getPointerDiffType() const {
4938 return getFromTargetType(Target->getPtrDiffType(0));
4939}
4940
4941/// Return the unique unsigned counterpart of "ptrdiff_t"
4942/// integer type. The standard (C11 7.21.6.1p7) refers to this type
4943/// in the definition of %tu format specifier.
4944QualType ASTContext::getUnsignedPointerDiffType() const {
4945 return getFromTargetType(Target->getUnsignedPtrDiffType(0));
4946}
4947
4948/// Return the unique type for "pid_t" defined in
4949/// <sys/types.h>. We need this to compute the correct type for vfork().
4950QualType ASTContext::getProcessIDType() const {
4951 return getFromTargetType(Target->getProcessIDType());
4952}
4953
4954//===----------------------------------------------------------------------===//
4955// Type Operators
4956//===----------------------------------------------------------------------===//
4957
4958CanQualType ASTContext::getCanonicalParamType(QualType T) const {
4959 // Push qualifiers into arrays, and then discard any remaining
4960 // qualifiers.
4961 T = getCanonicalType(T);
4962 T = getVariableArrayDecayedType(T);
4963 const Type *Ty = T.getTypePtr();
4964 QualType Result;
4965 if (isa<ArrayType>(Ty)) {
4966 Result = getArrayDecayedType(QualType(Ty,0));
4967 } else if (isa<FunctionType>(Ty)) {
4968 Result = getPointerType(QualType(Ty, 0));
4969 } else {
4970 Result = QualType(Ty, 0);
4971 }
4972
4973 return CanQualType::CreateUnsafe(Result);
4974}
4975
4976QualType ASTContext::getUnqualifiedArrayType(QualType type,
4977 Qualifiers &quals) {
4978 SplitQualType splitType = type.getSplitUnqualifiedType();
4979
4980 // FIXME: getSplitUnqualifiedType() actually walks all the way to
4981 // the unqualified desugared type and then drops it on the floor.
4982 // We then have to strip that sugar back off with
4983 // getUnqualifiedDesugaredType(), which is silly.
4984 const auto *AT =
4985 dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType());
4986
4987 // If we don't have an array, just use the results in splitType.
4988 if (!AT) {
4989 quals = splitType.Quals;
4990 return QualType(splitType.Ty, 0);
4991 }
4992
4993 // Otherwise, recurse on the array's element type.
4994 QualType elementType = AT->getElementType();
4995 QualType unqualElementType = getUnqualifiedArrayType(elementType, quals);
4996
4997 // If that didn't change the element type, AT has no qualifiers, so we
4998 // can just use the results in splitType.
4999 if (elementType == unqualElementType) {
5000 assert(quals.empty())((quals.empty()) ? static_cast<void> (0) : __assert_fail
("quals.empty()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5000, __PRETTY_FUNCTION__))
; // from the recursive call
5001 quals = splitType.Quals;
5002 return QualType(splitType.Ty, 0);
5003 }
5004
5005 // Otherwise, add in the qualifiers from the outermost type, then
5006 // build the type back up.
5007 quals.addConsistentQualifiers(splitType.Quals);
5008
5009 if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
5010 return getConstantArrayType(unqualElementType, CAT->getSize(),
5011 CAT->getSizeModifier(), 0);
5012 }
5013
5014 if (const auto *IAT = dyn_cast<IncompleteArrayType>(AT)) {
5015 return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0);
5016 }
5017
5018 if (const auto *VAT = dyn_cast<VariableArrayType>(AT)) {
5019 return getVariableArrayType(unqualElementType,
5020 VAT->getSizeExpr(),
5021 VAT->getSizeModifier(),
5022 VAT->getIndexTypeCVRQualifiers(),
5023 VAT->getBracketsRange());
5024 }
5025
5026 const auto *DSAT = cast<DependentSizedArrayType>(AT);
5027 return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(),
5028 DSAT->getSizeModifier(), 0,
5029 SourceRange());
5030}
5031
5032/// Attempt to unwrap two types that may both be array types with the same bound
5033/// (or both be array types of unknown bound) for the purpose of comparing the
5034/// cv-decomposition of two types per C++ [conv.qual].
5035bool ASTContext::UnwrapSimilarArrayTypes(QualType &T1, QualType &T2) {
5036 bool UnwrappedAny = false;
5037 while (true) {
5038 auto *AT1 = getAsArrayType(T1);
5039 if (!AT1) return UnwrappedAny;
5040
5041 auto *AT2 = getAsArrayType(T2);
5042 if (!AT2) return UnwrappedAny;
5043
5044 // If we don't have two array types with the same constant bound nor two
5045 // incomplete array types, we've unwrapped everything we can.
5046 if (auto *CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
5047 auto *CAT2 = dyn_cast<ConstantArrayType>(AT2);
5048 if (!CAT2 || CAT1->getSize() != CAT2->getSize())
5049 return UnwrappedAny;
5050 } else if (!isa<IncompleteArrayType>(AT1) ||
5051 !isa<IncompleteArrayType>(AT2)) {
5052 return UnwrappedAny;
5053 }
5054
5055 T1 = AT1->getElementType();
5056 T2 = AT2->getElementType();
5057 UnwrappedAny = true;
5058 }
5059}
5060
5061/// Attempt to unwrap two types that may be similar (C++ [conv.qual]).
5062///
5063/// If T1 and T2 are both pointer types of the same kind, or both array types
5064/// with the same bound, unwraps layers from T1 and T2 until a pointer type is
5065/// unwrapped. Top-level qualifiers on T1 and T2 are ignored.
5066///
5067/// This function will typically be called in a loop that successively
5068/// "unwraps" pointer and pointer-to-member types to compare them at each
5069/// level.
5070///
5071/// \return \c true if a pointer type was unwrapped, \c false if we reached a
5072/// pair of types that can't be unwrapped further.
5073bool ASTContext::UnwrapSimilarTypes(QualType &T1, QualType &T2) {
5074 UnwrapSimilarArrayTypes(T1, T2);
5075
5076 const auto *T1PtrType = T1->getAs<PointerType>();
5077 const auto *T2PtrType = T2->getAs<PointerType>();
5078 if (T1PtrType && T2PtrType) {
5079 T1 = T1PtrType->getPointeeType();
5080 T2 = T2PtrType->getPointeeType();
5081 return true;
5082 }
5083
5084 const auto *T1MPType = T1->getAs<MemberPointerType>();
5085 const auto *T2MPType = T2->getAs<MemberPointerType>();
5086 if (T1MPType && T2MPType &&
5087 hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
5088 QualType(T2MPType->getClass(), 0))) {
5089 T1 = T1MPType->getPointeeType();
5090 T2 = T2MPType->getPointeeType();
5091 return true;
5092 }
5093
5094 if (getLangOpts().ObjC1) {
5095 const auto *T1OPType = T1->getAs<ObjCObjectPointerType>();
5096 const auto *T2OPType = T2->getAs<ObjCObjectPointerType>();
5097 if (T1OPType && T2OPType) {
5098 T1 = T1OPType->getPointeeType();
5099 T2 = T2OPType->getPointeeType();
5100 return true;
5101 }
5102 }
5103
5104 // FIXME: Block pointers, too?
5105
5106 return false;
5107}
5108
5109bool ASTContext::hasSimilarType(QualType T1, QualType T2) {
5110 while (true) {
5111 Qualifiers Quals;
5112 T1 = getUnqualifiedArrayType(T1, Quals);
5113 T2 = getUnqualifiedArrayType(T2, Quals);
5114 if (hasSameType(T1, T2))
5115 return true;
5116 if (!UnwrapSimilarTypes(T1, T2))
5117 return false;
5118 }
5119}
5120
5121bool ASTContext::hasCvrSimilarType(QualType T1, QualType T2) {
5122 while (true) {
5123 Qualifiers Quals1, Quals2;
5124 T1 = getUnqualifiedArrayType(T1, Quals1);
5125 T2 = getUnqualifiedArrayType(T2, Quals2);
5126
5127 Quals1.removeCVRQualifiers();
5128 Quals2.removeCVRQualifiers();
5129 if (Quals1 != Quals2)
5130 return false;
5131
5132 if (hasSameType(T1, T2))
5133 return true;
5134
5135 if (!UnwrapSimilarTypes(T1, T2))
5136 return false;
5137 }
5138}
5139
5140DeclarationNameInfo
5141ASTContext::getNameForTemplate(TemplateName Name,
5142 SourceLocation NameLoc) const {
5143 switch (Name.getKind()) {
5144 case TemplateName::QualifiedTemplate:
5145 case TemplateName::Template:
5146 // DNInfo work in progress: CHECKME: what about DNLoc?
5147 return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(),
5148 NameLoc);
5149
5150 case TemplateName::OverloadedTemplate: {
5151 OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate();
5152 // DNInfo work in progress: CHECKME: what about DNLoc?
5153 return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc);
5154 }
5155
5156 case TemplateName::DependentTemplate: {
5157 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
5158 DeclarationName DName;
5159 if (DTN->isIdentifier()) {
5160 DName = DeclarationNames.getIdentifier(DTN->getIdentifier());
5161 return DeclarationNameInfo(DName, NameLoc);
5162 } else {
5163 DName = DeclarationNames.getCXXOperatorName(DTN->getOperator());
5164 // DNInfo work in progress: FIXME: source locations?
5165 DeclarationNameLoc DNLoc;
5166 DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
5167 DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
5168 return DeclarationNameInfo(DName, NameLoc, DNLoc);
5169 }
5170 }
5171
5172 case TemplateName::SubstTemplateTemplateParm: {
5173 SubstTemplateTemplateParmStorage *subst
5174 = Name.getAsSubstTemplateTemplateParm();
5175 return DeclarationNameInfo(subst->getParameter()->getDeclName(),
5176 NameLoc);
5177 }
5178
5179 case TemplateName::SubstTemplateTemplateParmPack: {
5180 SubstTemplateTemplateParmPackStorage *subst
5181 = Name.getAsSubstTemplateTemplateParmPack();
5182 return DeclarationNameInfo(subst->getParameterPack()->getDeclName(),
5183 NameLoc);
5184 }
5185 }
5186
5187 llvm_unreachable("bad template name kind!")::llvm::llvm_unreachable_internal("bad template name kind!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5187)
;
5188}
5189
5190TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const {
5191 switch (Name.getKind()) {
5192 case TemplateName::QualifiedTemplate:
5193 case TemplateName::Template: {
5194 TemplateDecl *Template = Name.getAsTemplateDecl();
5195 if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template))
5196 Template = getCanonicalTemplateTemplateParmDecl(TTP);
5197
5198 // The canonical template name is the canonical template declaration.
5199 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
5200 }
5201
5202 case TemplateName::OverloadedTemplate:
5203 llvm_unreachable("cannot canonicalize overloaded template")::llvm::llvm_unreachable_internal("cannot canonicalize overloaded template"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5203)
;
5204
5205 case TemplateName::DependentTemplate: {
5206 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
5207 assert(DTN && "Non-dependent template names must refer to template decls.")((DTN && "Non-dependent template names must refer to template decls."
) ? static_cast<void> (0) : __assert_fail ("DTN && \"Non-dependent template names must refer to template decls.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5207, __PRETTY_FUNCTION__))
;
5208 return DTN->CanonicalTemplateName;
5209 }
5210
5211 case TemplateName::SubstTemplateTemplateParm: {
5212 SubstTemplateTemplateParmStorage *subst
5213 = Name.getAsSubstTemplateTemplateParm();
5214 return getCanonicalTemplateName(subst->getReplacement());
5215 }
5216
5217 case TemplateName::SubstTemplateTemplateParmPack: {
5218 SubstTemplateTemplateParmPackStorage *subst
5219 = Name.getAsSubstTemplateTemplateParmPack();
5220 TemplateTemplateParmDecl *canonParameter
5221 = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
5222 TemplateArgument canonArgPack
5223 = getCanonicalTemplateArgument(subst->getArgumentPack());
5224 return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
5225 }
5226 }
5227
5228 llvm_unreachable("bad template name!")::llvm::llvm_unreachable_internal("bad template name!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5228)
;
5229}
5230
5231bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) {
5232 X = getCanonicalTemplateName(X);
5233 Y = getCanonicalTemplateName(Y);
5234 return X.getAsVoidPointer() == Y.getAsVoidPointer();
5235}
5236
5237TemplateArgument
5238ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
5239 switch (Arg.getKind()) {
5240 case TemplateArgument::Null:
5241 return Arg;
5242
5243 case TemplateArgument::Expression:
5244 return Arg;
5245
5246 case TemplateArgument::Declaration: {
5247 auto *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
5248 return TemplateArgument(D, Arg.getParamTypeForDecl());
5249 }
5250
5251 case TemplateArgument::NullPtr:
5252 return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),
5253 /*isNullPtr*/true);
5254
5255 case TemplateArgument::Template:
5256 return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));
5257
5258 case TemplateArgument::TemplateExpansion:
5259 return TemplateArgument(getCanonicalTemplateName(
5260 Arg.getAsTemplateOrTemplatePattern()),
5261 Arg.getNumTemplateExpansions());
5262
5263 case TemplateArgument::Integral:
5264 return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType()));
5265
5266 case TemplateArgument::Type:
5267 return TemplateArgument(getCanonicalType(Arg.getAsType()));
5268
5269 case TemplateArgument::Pack: {
5270 if (Arg.pack_size() == 0)
5271 return Arg;
5272
5273 auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
5274 unsigned Idx = 0;
5275 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
5276 AEnd = Arg.pack_end();
5277 A != AEnd; (void)++A, ++Idx)
5278 CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
5279
5280 return TemplateArgument(llvm::makeArrayRef(CanonArgs, Arg.pack_size()));
5281 }
5282 }
5283
5284 // Silence GCC warning
5285 llvm_unreachable("Unhandled template argument kind")::llvm::llvm_unreachable_internal("Unhandled template argument kind"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5285)
;
5286}
5287
5288NestedNameSpecifier *
5289ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const {
5290 if (!NNS)
5291 return nullptr;
5292
5293 switch (NNS->getKind()) {
5294 case NestedNameSpecifier::Identifier:
5295 // Canonicalize the prefix but keep the identifier the same.
5296 return NestedNameSpecifier::Create(*this,
5297 getCanonicalNestedNameSpecifier(NNS->getPrefix()),
5298 NNS->getAsIdentifier());
5299
5300 case NestedNameSpecifier::Namespace:
5301 // A namespace is canonical; build a nested-name-specifier with
5302 // this namespace and no prefix.
5303 return NestedNameSpecifier::Create(*this, nullptr,
5304 NNS->getAsNamespace()->getOriginalNamespace());
5305
5306 case NestedNameSpecifier::NamespaceAlias:
5307 // A namespace is canonical; build a nested-name-specifier with
5308 // this namespace and no prefix.
5309 return NestedNameSpecifier::Create(*this, nullptr,
5310 NNS->getAsNamespaceAlias()->getNamespace()
5311 ->getOriginalNamespace());
5312
5313 case NestedNameSpecifier::TypeSpec:
5314 case NestedNameSpecifier::TypeSpecWithTemplate: {
5315 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
5316
5317 // If we have some kind of dependent-named type (e.g., "typename T::type"),
5318 // break it apart into its prefix and identifier, then reconsititute those
5319 // as the canonical nested-name-specifier. This is required to canonicalize
5320 // a dependent nested-name-specifier involving typedefs of dependent-name
5321 // types, e.g.,
5322 // typedef typename T::type T1;
5323 // typedef typename T1::type T2;
5324 if (const auto *DNT = T->getAs<DependentNameType>())
5325 return NestedNameSpecifier::Create(*this, DNT->getQualifier(),
5326 const_cast<IdentifierInfo *>(DNT->getIdentifier()));
5327
5328 // Otherwise, just canonicalize the type, and force it to be a TypeSpec.
5329 // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the
5330 // first place?
5331 return NestedNameSpecifier::Create(*this, nullptr, false,
5332 const_cast<Type *>(T.getTypePtr()));
5333 }
5334
5335 case NestedNameSpecifier::Global:
5336 case NestedNameSpecifier::Super:
5337 // The global specifier and __super specifer are canonical and unique.
5338 return NNS;
5339 }
5340
5341 llvm_unreachable("Invalid NestedNameSpecifier::Kind!")::llvm::llvm_unreachable_internal("Invalid NestedNameSpecifier::Kind!"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5341)
;
5342}
5343
5344const ArrayType *ASTContext::getAsArrayType(QualType T) const {
5345 // Handle the non-qualified case efficiently.
5346 if (!T.hasLocalQualifiers()) {
5347 // Handle the common positive case fast.
5348 if (const auto *AT = dyn_cast<ArrayType>(T))
5349 return AT;
5350 }
5351
5352 // Handle the common negative case fast.
5353 if (!isa<ArrayType>(T.getCanonicalType()))
5354 return nullptr;
5355
5356 // Apply any qualifiers from the array type to the element type. This
5357 // implements C99 6.7.3p8: "If the specification of an array type includes
5358 // any type qualifiers, the element type is so qualified, not the array type."
5359
5360 // If we get here, we either have type qualifiers on the type, or we have
5361 // sugar such as a typedef in the way. If we have type qualifiers on the type
5362 // we must propagate them down into the element type.
5363
5364 SplitQualType split = T.getSplitDesugaredType();
5365 Qualifiers qs = split.Quals;
5366
5367 // If we have a simple case, just return now.
5368 const auto *ATy = dyn_cast<ArrayType>(split.Ty);
5369 if (!ATy || qs.empty())
5370 return ATy;
5371
5372 // Otherwise, we have an array and we have qualifiers on it. Push the
5373 // qualifiers into the array element type and return a new array type.
5374 QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs);
5375
5376 if (const auto *CAT = dyn_cast<ConstantArrayType>(ATy))
5377 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
5378 CAT->getSizeModifier(),
5379 CAT->getIndexTypeCVRQualifiers()));
5380 if (const auto *IAT = dyn_cast<IncompleteArrayType>(ATy))
5381 return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
5382 IAT->getSizeModifier(),
5383 IAT->getIndexTypeCVRQualifiers()));
5384
5385 if (const auto *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
5386 return cast<ArrayType>(
5387 getDependentSizedArrayType(NewEltTy,
5388 DSAT->getSizeExpr(),
5389 DSAT->getSizeModifier(),
5390 DSAT->getIndexTypeCVRQualifiers(),
5391 DSAT->getBracketsRange()));
5392
5393 const auto *VAT = cast<VariableArrayType>(ATy);
5394 return cast<ArrayType>(getVariableArrayType(NewEltTy,
5395 VAT->getSizeExpr(),
5396 VAT->getSizeModifier(),
5397 VAT->getIndexTypeCVRQualifiers(),
5398 VAT->getBracketsRange()));
5399}
5400
5401QualType ASTContext::getAdjustedParameterType(QualType T) const {
5402 if (T->isArrayType() || T->isFunctionType())
5403 return getDecayedType(T);
5404 return T;
5405}
5406
5407QualType ASTContext::getSignatureParameterType(QualType T) const {
5408 T = getVariableArrayDecayedType(T);
5409 T = getAdjustedParameterType(T);
5410 return T.getUnqualifiedType();
5411}
5412
5413QualType ASTContext::getExceptionObjectType(QualType T) const {
5414 // C++ [except.throw]p3:
5415 // A throw-expression initializes a temporary object, called the exception
5416 // object, the type of which is determined by removing any top-level
5417 // cv-qualifiers from the static type of the operand of throw and adjusting
5418 // the type from "array of T" or "function returning T" to "pointer to T"
5419 // or "pointer to function returning T", [...]
5420 T = getVariableArrayDecayedType(T);
5421 if (T->isArrayType() || T->isFunctionType())
5422 T = getDecayedType(T);
5423 return T.getUnqualifiedType();
5424}
5425
5426/// getArrayDecayedType - Return the properly qualified result of decaying the
5427/// specified array type to a pointer. This operation is non-trivial when
5428/// handling typedefs etc. The canonical type of "T" must be an array type,
5429/// this returns a pointer to a properly qualified element of the array.
5430///
5431/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
5432QualType ASTContext::getArrayDecayedType(QualType Ty) const {
5433 // Get the element type with 'getAsArrayType' so that we don't lose any
5434 // typedefs in the element type of the array. This also handles propagation
5435 // of type qualifiers from the array type into the element type if present
5436 // (C99 6.7.3p8).
5437 const ArrayType *PrettyArrayType = getAsArrayType(Ty);
5438 assert(PrettyArrayType && "Not an array type!")((PrettyArrayType && "Not an array type!") ? static_cast
<void> (0) : __assert_fail ("PrettyArrayType && \"Not an array type!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5438, __PRETTY_FUNCTION__))
;
5439
5440 QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
5441
5442 // int x[restrict 4] -> int *restrict
5443 QualType Result = getQualifiedType(PtrTy,
5444 PrettyArrayType->getIndexTypeQualifiers());
5445
5446 // int x[_Nullable] -> int * _Nullable
5447 if (auto Nullability = Ty->getNullability(*this)) {
5448 Result = const_cast<ASTContext *>(this)->getAttributedType(
5449 AttributedType::getNullabilityAttrKind(*Nullability), Result, Result);
5450 }
5451 return Result;
5452}
5453
5454QualType ASTContext::getBaseElementType(const ArrayType *array) const {
5455 return getBaseElementType(array->getElementType());
5456}
5457
5458QualType ASTContext::getBaseElementType(QualType type) const {
5459 Qualifiers qs;
5460 while (true) {
5461 SplitQualType split = type.getSplitDesugaredType();
5462 const ArrayType *array = split.Ty->getAsArrayTypeUnsafe();
5463 if (!array) break;
5464
5465 type = array->getElementType();
5466 qs.addConsistentQualifiers(split.Quals);
5467 }
5468
5469 return getQualifiedType(type, qs);
5470}
5471
5472/// getConstantArrayElementCount - Returns number of constant array elements.
5473uint64_t
5474ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const {
5475 uint64_t ElementCount = 1;
5476 do {
5477 ElementCount *= CA->getSize().getZExtValue();
5478 CA = dyn_cast_or_null<ConstantArrayType>(
5479 CA->getElementType()->getAsArrayTypeUnsafe());
5480 } while (CA);
5481 return ElementCount;
5482}
5483
5484/// getFloatingRank - Return a relative rank for floating point types.
5485/// This routine will assert if passed a built-in type that isn't a float.
5486static FloatingRank getFloatingRank(QualType T) {
5487 if (const auto *CT = T->getAs<ComplexType>())
5488 return getFloatingRank(CT->getElementType());
5489
5490 assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type")((T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"
) ? static_cast<void> (0) : __assert_fail ("T->getAs<BuiltinType>() && \"getFloatingRank(): not a floating type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5490, __PRETTY_FUNCTION__))
;
5491 switch (T->getAs<BuiltinType>()->getKind()) {
5492 default: llvm_unreachable("getFloatingRank(): not a floating type")::llvm::llvm_unreachable_internal("getFloatingRank(): not a floating type"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5492)
;
5493 case BuiltinType::Float16: return Float16Rank;
5494 case BuiltinType::Half: return HalfRank;
5495 case BuiltinType::Float: return FloatRank;
5496 case BuiltinType::Double: return DoubleRank;
5497 case BuiltinType::LongDouble: return LongDoubleRank;
5498 case BuiltinType::Float128: return Float128Rank;
5499 }
5500}
5501
5502/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
5503/// point or a complex type (based on typeDomain/typeSize).
5504/// 'typeDomain' is a real floating point or complex type.
5505/// 'typeSize' is a real floating point or complex type.
5506QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
5507 QualType Domain) const {
5508 FloatingRank EltRank = getFloatingRank(Size);
5509 if (Domain->isComplexType()) {
5510 switch (EltRank) {
5511 case Float16Rank:
5512 case HalfRank: llvm_unreachable("Complex half is not supported")::llvm::llvm_unreachable_internal("Complex half is not supported"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5512)
;
5513 case FloatRank: return FloatComplexTy;
5514 case DoubleRank: return DoubleComplexTy;
5515 case LongDoubleRank: return LongDoubleComplexTy;
5516 case Float128Rank: return Float128ComplexTy;
5517 }
5518 }
5519
5520 assert(Domain->isRealFloatingType() && "Unknown domain!")((Domain->isRealFloatingType() && "Unknown domain!"
) ? static_cast<void> (0) : __assert_fail ("Domain->isRealFloatingType() && \"Unknown domain!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5520, __PRETTY_FUNCTION__))
;
5521 switch (EltRank) {
5522 case Float16Rank: return HalfTy;
5523 case HalfRank: return HalfTy;
5524 case FloatRank: return FloatTy;
5525 case DoubleRank: return DoubleTy;
5526 case LongDoubleRank: return LongDoubleTy;
5527 case Float128Rank: return Float128Ty;
5528 }
5529 llvm_unreachable("getFloatingRank(): illegal value for rank")::llvm::llvm_unreachable_internal("getFloatingRank(): illegal value for rank"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5529)
;
5530}
5531
5532/// getFloatingTypeOrder - Compare the rank of the two specified floating
5533/// point types, ignoring the domain of the type (i.e. 'double' ==
5534/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
5535/// LHS < RHS, return -1.
5536int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
5537 FloatingRank LHSR = getFloatingRank(LHS);
5538 FloatingRank RHSR = getFloatingRank(RHS);
5539
5540 if (LHSR == RHSR)
5541 return 0;
5542 if (LHSR > RHSR)
5543 return 1;
5544 return -1;
5545}
5546
5547/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
5548/// routine will assert if passed a built-in type that isn't an integer or enum,
5549/// or if it is not canonicalized.
5550unsigned ASTContext::getIntegerRank(const Type *T) const {
5551 assert(T->isCanonicalUnqualified() && "T should be canonicalized")((T->isCanonicalUnqualified() && "T should be canonicalized"
) ? static_cast<void> (0) : __assert_fail ("T->isCanonicalUnqualified() && \"T should be canonicalized\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5551, __PRETTY_FUNCTION__))
;
5552
5553 switch (cast<BuiltinType>(T)->getKind()) {
5554 default: llvm_unreachable("getIntegerRank(): not a built-in integer")::llvm::llvm_unreachable_internal("getIntegerRank(): not a built-in integer"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5554)
;
5555 case BuiltinType::Bool:
5556 return 1 + (getIntWidth(BoolTy) << 3);
5557 case BuiltinType::Char_S:
5558 case BuiltinType::Char_U:
5559 case BuiltinType::SChar:
5560 case BuiltinType::UChar:
5561 return 2 + (getIntWidth(CharTy) << 3);
5562 case BuiltinType::Short:
5563 case BuiltinType::UShort:
5564 return 3 + (getIntWidth(ShortTy) << 3);
5565 case BuiltinType::Int:
5566 case BuiltinType::UInt:
5567 return 4 + (getIntWidth(IntTy) << 3);
5568 case BuiltinType::Long:
5569 case BuiltinType::ULong:
5570 return 5 + (getIntWidth(LongTy) << 3);
5571 case BuiltinType::LongLong:
5572 case BuiltinType::ULongLong:
5573 return 6 + (getIntWidth(LongLongTy) << 3);
5574 case BuiltinType::Int128:
5575 case BuiltinType::UInt128:
5576 return 7 + (getIntWidth(Int128Ty) << 3);
5577 }
5578}
5579
5580/// Whether this is a promotable bitfield reference according
5581/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
5582///
5583/// \returns the type this bit-field will promote to, or NULL if no
5584/// promotion occurs.
5585QualType ASTContext::isPromotableBitField(Expr *E) const {
5586 if (E->isTypeDependent() || E->isValueDependent())
5587 return {};
5588
5589 // C++ [conv.prom]p5:
5590 // If the bit-field has an enumerated type, it is treated as any other
5591 // value of that type for promotion purposes.
5592 if (getLangOpts().CPlusPlus && E->getType()->isEnumeralType())
5593 return {};
5594
5595 // FIXME: We should not do this unless E->refersToBitField() is true. This
5596 // matters in C where getSourceBitField() will find bit-fields for various
5597 // cases where the source expression is not a bit-field designator.
5598
5599 FieldDecl *Field = E->getSourceBitField(); // FIXME: conditional bit-fields?
5600 if (!Field)
5601 return {};
5602
5603 QualType FT = Field->getType();
5604
5605 uint64_t BitWidth = Field->getBitWidthValue(*this);
5606 uint64_t IntSize = getTypeSize(IntTy);
5607 // C++ [conv.prom]p5:
5608 // A prvalue for an integral bit-field can be converted to a prvalue of type
5609 // int if int can represent all the values of the bit-field; otherwise, it
5610 // can be converted to unsigned int if unsigned int can represent all the
5611 // values of the bit-field. If the bit-field is larger yet, no integral
5612 // promotion applies to it.
5613 // C11 6.3.1.1/2:
5614 // [For a bit-field of type _Bool, int, signed int, or unsigned int:]
5615 // If an int can represent all values of the original type (as restricted by
5616 // the width, for a bit-field), the value is converted to an int; otherwise,
5617 // it is converted to an unsigned int.
5618 //
5619 // FIXME: C does not permit promotion of a 'long : 3' bitfield to int.
5620 // We perform that promotion here to match GCC and C++.
5621 // FIXME: C does not permit promotion of an enum bit-field whose rank is
5622 // greater than that of 'int'. We perform that promotion to match GCC.
5623 if (BitWidth < IntSize)
5624 return IntTy;
5625
5626 if (BitWidth == IntSize)
5627 return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy;
5628
5629 // Bit-fields wider than int are not subject to promotions, and therefore act
5630 // like the base type. GCC has some weird bugs in this area that we
5631 // deliberately do not follow (GCC follows a pre-standard resolution to
5632 // C's DR315 which treats bit-width as being part of the type, and this leaks
5633 // into their semantics in some cases).
5634 return {};
5635}
5636
5637/// getPromotedIntegerType - Returns the type that Promotable will
5638/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
5639/// integer type.
5640QualType ASTContext::getPromotedIntegerType(QualType Promotable) const {
5641 assert(!Promotable.isNull())((!Promotable.isNull()) ? static_cast<void> (0) : __assert_fail
("!Promotable.isNull()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5641, __PRETTY_FUNCTION__))
;
5642 assert(Promotable->isPromotableIntegerType())((Promotable->isPromotableIntegerType()) ? static_cast<
void> (0) : __assert_fail ("Promotable->isPromotableIntegerType()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5642, __PRETTY_FUNCTION__))
;
5643 if (const auto *ET = Promotable->getAs<EnumType>())
5644 return ET->getDecl()->getPromotionType();
5645
5646 if (const auto *BT = Promotable->getAs<BuiltinType>()) {
5647 // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t
5648 // (3.9.1) can be converted to a prvalue of the first of the following
5649 // types that can represent all the values of its underlying type:
5650 // int, unsigned int, long int, unsigned long int, long long int, or
5651 // unsigned long long int [...]
5652 // FIXME: Is there some better way to compute this?
5653 if (BT->getKind() == BuiltinType::WChar_S ||
5654 BT->getKind() == BuiltinType::WChar_U ||
5655 BT->getKind() == BuiltinType::Char8 ||
5656 BT->getKind() == BuiltinType::Char16 ||
5657 BT->getKind() == BuiltinType::Char32) {
5658 bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
5659 uint64_t FromSize = getTypeSize(BT);
5660 QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy,
5661 LongLongTy, UnsignedLongLongTy };
5662 for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) {
5663 uint64_t ToSize = getTypeSize(PromoteTypes[Idx]);
5664 if (FromSize < ToSize ||
5665 (FromSize == ToSize &&
5666 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType()))
5667 return PromoteTypes[Idx];
5668 }
5669 llvm_unreachable("char type should fit into long long")::llvm::llvm_unreachable_internal("char type should fit into long long"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5669)
;
5670 }
5671 }
5672
5673 // At this point, we should have a signed or unsigned integer type.
5674 if (Promotable->isSignedIntegerType())
5675 return IntTy;
5676 uint64_t PromotableSize = getIntWidth(Promotable);
5677 uint64_t IntSize = getIntWidth(IntTy);
5678 assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize)((Promotable->isUnsignedIntegerType() && PromotableSize
<= IntSize) ? static_cast<void> (0) : __assert_fail
("Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5678, __PRETTY_FUNCTION__))
;
5679 return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
5680}
5681
5682/// Recurses in pointer/array types until it finds an objc retainable
5683/// type and returns its ownership.
5684Qualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const {
5685 while (!T.isNull()) {
5686 if (T.getObjCLifetime() != Qualifiers::OCL_None)
5687 return T.getObjCLifetime();
5688 if (T->isArrayType())
5689 T = getBaseElementType(T);
5690 else if (const auto *PT = T->getAs<PointerType>())
5691 T = PT->getPointeeType();
5692 else if (const auto *RT = T->getAs<ReferenceType>())
5693 T = RT->getPointeeType();
5694 else
5695 break;
5696 }
5697
5698 return Qualifiers::OCL_None;
5699}
5700
5701static const Type *getIntegerTypeForEnum(const EnumType *ET) {
5702 // Incomplete enum types are not treated as integer types.
5703 // FIXME: In C++, enum types are never integer types.
5704 if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
5705 return ET->getDecl()->getIntegerType().getTypePtr();
5706 return nullptr;
5707}
5708
5709/// getIntegerTypeOrder - Returns the highest ranked integer type:
5710/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
5711/// LHS < RHS, return -1.
5712int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const {
5713 const Type *LHSC = getCanonicalType(LHS).getTypePtr();
5714 const Type *RHSC = getCanonicalType(RHS).getTypePtr();
5715
5716 // Unwrap enums to their underlying type.
5717 if (const auto *ET = dyn_cast<EnumType>(LHSC))
5718 LHSC = getIntegerTypeForEnum(ET);
5719 if (const auto *ET = dyn_cast<EnumType>(RHSC))
5720 RHSC = getIntegerTypeForEnum(ET);
5721
5722 if (LHSC == RHSC) return 0;
5723
5724 bool LHSUnsigned = LHSC->isUnsignedIntegerType();
5725 bool RHSUnsigned = RHSC->isUnsignedIntegerType();
5726
5727 unsigned LHSRank = getIntegerRank(LHSC);
5728 unsigned RHSRank = getIntegerRank(RHSC);
5729
5730 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
5731 if (LHSRank == RHSRank) return 0;
5732 return LHSRank > RHSRank ? 1 : -1;
5733 }
5734
5735 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
5736 if (LHSUnsigned) {
5737 // If the unsigned [LHS] type is larger, return it.
5738 if (LHSRank >= RHSRank)
5739 return 1;
5740
5741 // If the signed type can represent all values of the unsigned type, it
5742 // wins. Because we are dealing with 2's complement and types that are
5743 // powers of two larger than each other, this is always safe.
5744 return -1;
5745 }
5746
5747 // If the unsigned [RHS] type is larger, return it.
5748 if (RHSRank >= LHSRank)
5749 return -1;
5750
5751 // If the signed type can represent all values of the unsigned type, it
5752 // wins. Because we are dealing with 2's complement and types that are
5753 // powers of two larger than each other, this is always safe.
5754 return 1;
5755}
5756
5757TypedefDecl *ASTContext::getCFConstantStringDecl() const {
5758 if (CFConstantStringTypeDecl)
5759 return CFConstantStringTypeDecl;
5760
5761 assert(!CFConstantStringTagDecl &&((!CFConstantStringTagDecl && "tag and typedef should be initialized together"
) ? static_cast<void> (0) : __assert_fail ("!CFConstantStringTagDecl && \"tag and typedef should be initialized together\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5762, __PRETTY_FUNCTION__))
5762 "tag and typedef should be initialized together")((!CFConstantStringTagDecl && "tag and typedef should be initialized together"
) ? static_cast<void> (0) : __assert_fail ("!CFConstantStringTagDecl && \"tag and typedef should be initialized together\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5762, __PRETTY_FUNCTION__))
;
5763 CFConstantStringTagDecl = buildImplicitRecord("__NSConstantString_tag");
5764 CFConstantStringTagDecl->startDefinition();
5765
5766 struct {
5767 QualType Type;
5768 const char *Name;
5769 } Fields[5];
5770 unsigned Count = 0;
5771
5772 /// Objective-C ABI
5773 ///
5774 /// typedef struct __NSConstantString_tag {
5775 /// const int *isa;
5776 /// int flags;
5777 /// const char *str;
5778 /// long length;
5779 /// } __NSConstantString;
5780 ///
5781 /// Swift ABI (4.1, 4.2)
5782 ///
5783 /// typedef struct __NSConstantString_tag {
5784 /// uintptr_t _cfisa;
5785 /// uintptr_t _swift_rc;
5786 /// _Atomic(uint64_t) _cfinfoa;
5787 /// const char *_ptr;
5788 /// uint32_t _length;
5789 /// } __NSConstantString;
5790 ///
5791 /// Swift ABI (5.0)
5792 ///
5793 /// typedef struct __NSConstantString_tag {
5794 /// uintptr_t _cfisa;
5795 /// uintptr_t _swift_rc;
5796 /// _Atomic(uint64_t) _cfinfoa;
5797 /// const char *_ptr;
5798 /// uintptr_t _length;
5799 /// } __NSConstantString;
5800
5801 const auto CFRuntime = getLangOpts().CFRuntime;
5802 if (static_cast<unsigned>(CFRuntime) <
5803 static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift)) {
5804 Fields[Count++] = { getPointerType(IntTy.withConst()), "isa" };
5805 Fields[Count++] = { IntTy, "flags" };
5806 Fields[Count++] = { getPointerType(CharTy.withConst()), "str" };
5807 Fields[Count++] = { LongTy, "length" };
5808 } else {
5809 Fields[Count++] = { getUIntPtrType(), "_cfisa" };
5810 Fields[Count++] = { getUIntPtrType(), "_swift_rc" };
5811 Fields[Count++] = { getFromTargetType(Target->getUInt64Type()), "_swift_rc" };
5812 Fields[Count++] = { getPointerType(CharTy.withConst()), "_ptr" };
5813 if (CFRuntime == LangOptions::CoreFoundationABI::Swift4_1 ||
5814 CFRuntime == LangOptions::CoreFoundationABI::Swift4_2)
5815 Fields[Count++] = { IntTy, "_ptr" };
5816 else
5817 Fields[Count++] = { getUIntPtrType(), "_ptr" };
5818 }
5819
5820 // Create fields
5821 for (unsigned i = 0; i < Count; ++i) {
5822 FieldDecl *Field =
5823 FieldDecl::Create(*this, CFConstantStringTagDecl, SourceLocation(),
5824 SourceLocation(), &Idents.get(Fields[i].Name),
5825 Fields[i].Type, /*TInfo=*/nullptr,
5826 /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
5827 Field->setAccess(AS_public);
5828 CFConstantStringTagDecl->addDecl(Field);
5829 }
5830
5831 CFConstantStringTagDecl->completeDefinition();
5832 // This type is designed to be compatible with NSConstantString, but cannot
5833 // use the same name, since NSConstantString is an interface.
5834 auto tagType = getTagDeclType(CFConstantStringTagDecl);
5835 CFConstantStringTypeDecl =
5836 buildImplicitTypedef(tagType, "__NSConstantString");
5837
5838 return CFConstantStringTypeDecl;
5839}
5840
5841RecordDecl *ASTContext::getCFConstantStringTagDecl() const {