Bug Summary

File:clang/lib/AST/ASTContext.cpp
Warning:line 2956, column 12
1st function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

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