Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ASTContext.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/clang/lib/AST -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp -faddrsig
1//===- ASTContext.cpp - Context to hold long-lived AST nodes --------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the ASTContext interface.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/ASTContext.h"
15#include "CXXABI.h"
16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTMutationListener.h"
18#include "clang/AST/ASTTypeTraits.h"
19#include "clang/AST/Attr.h"
20#include "clang/AST/AttrIterator.h"
21#include "clang/AST/CharUnits.h"
22#include "clang/AST/Comment.h"
23#include "clang/AST/Decl.h"
24#include "clang/AST/DeclBase.h"
25#include "clang/AST/DeclCXX.h"
26#include "clang/AST/DeclContextInternals.h"
27#include "clang/AST/DeclObjC.h"
28#include "clang/AST/DeclOpenMP.h"
29#include "clang/AST/DeclTemplate.h"
30#include "clang/AST/DeclarationName.h"
31#include "clang/AST/Expr.h"
32#include "clang/AST/ExprCXX.h"
33#include "clang/AST/ExternalASTSource.h"
34#include "clang/AST/Mangle.h"
35#include "clang/AST/MangleNumberingContext.h"
36#include "clang/AST/NestedNameSpecifier.h"
37#include "clang/AST/RawCommentList.h"
38#include "clang/AST/RecordLayout.h"
39#include "clang/AST/RecursiveASTVisitor.h"
40#include "clang/AST/Stmt.h"
41#include "clang/AST/TemplateBase.h"
42#include "clang/AST/TemplateName.h"
43#include "clang/AST/Type.h"
44#include "clang/AST/TypeLoc.h"
45#include "clang/AST/UnresolvedSet.h"
46#include "clang/AST/VTableBuilder.h"
47#include "clang/Basic/AddressSpaces.h"
48#include "clang/Basic/Builtins.h"
49#include "clang/Basic/CommentOptions.h"
50#include "clang/Basic/ExceptionSpecificationType.h"
51#include "clang/Basic/FixedPoint.h"
52#include "clang/Basic/IdentifierTable.h"
53#include "clang/Basic/LLVM.h"
54#include "clang/Basic/LangOptions.h"
55#include "clang/Basic/Linkage.h"
56#include "clang/Basic/ObjCRuntime.h"
57#include "clang/Basic/SanitizerBlacklist.h"
58#include "clang/Basic/SourceLocation.h"
59#include "clang/Basic/SourceManager.h"
60#include "clang/Basic/Specifiers.h"
61#include "clang/Basic/TargetCXXABI.h"
62#include "clang/Basic/TargetInfo.h"
63#include "clang/Basic/XRayLists.h"
64#include "llvm/ADT/APInt.h"
65#include "llvm/ADT/APSInt.h"
66#include "llvm/ADT/ArrayRef.h"
67#include "llvm/ADT/DenseMap.h"
68#include "llvm/ADT/DenseSet.h"
69#include "llvm/ADT/FoldingSet.h"
70#include "llvm/ADT/None.h"
71#include "llvm/ADT/Optional.h"
72#include "llvm/ADT/PointerUnion.h"
73#include "llvm/ADT/STLExtras.h"
74#include "llvm/ADT/SmallPtrSet.h"
75#include "llvm/ADT/SmallVector.h"
76#include "llvm/ADT/StringExtras.h"
77#include "llvm/ADT/StringRef.h"
78#include "llvm/ADT/Triple.h"
79#include "llvm/Support/Capacity.h"
80#include "llvm/Support/Casting.h"
81#include "llvm/Support/Compiler.h"
82#include "llvm/Support/ErrorHandling.h"
83#include "llvm/Support/MathExtras.h"
84#include "llvm/Support/raw_ostream.h"
85#include <algorithm>
86#include <cassert>
87#include <cstddef>
88#include <cstdint>
89#include <cstdlib>
90#include <map>
91#include <memory>
92#include <string>
93#include <tuple>
94#include <utility>
95
96using namespace clang;
97
98unsigned ASTContext::NumImplicitDefaultConstructors;
99unsigned ASTContext::NumImplicitDefaultConstructorsDeclared;
100unsigned ASTContext::NumImplicitCopyConstructors;
101unsigned ASTContext::NumImplicitCopyConstructorsDeclared;
102unsigned ASTContext::NumImplicitMoveConstructors;
103unsigned ASTContext::NumImplicitMoveConstructorsDeclared;
104unsigned ASTContext::NumImplicitCopyAssignmentOperators;
105unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
106unsigned ASTContext::NumImplicitMoveAssignmentOperators;
107unsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
108unsigned ASTContext::NumImplicitDestructors;
109unsigned ASTContext::NumImplicitDestructorsDeclared;
110
111enum FloatingRank {
112 Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank
113};
114
115RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
116 if (!CommentsLoaded && ExternalSource) {
117 ExternalSource->ReadComments();
118
119#ifndef NDEBUG
120 ArrayRef<RawComment *> RawComments = Comments.getComments();
121 assert(std::is_sorted(RawComments.begin(), RawComments.end(),((std::is_sorted(RawComments.begin(), RawComments.end(), BeforeThanCompare
<RawComment>(SourceMgr))) ? static_cast<void> (0)
: __assert_fail ("std::is_sorted(RawComments.begin(), RawComments.end(), BeforeThanCompare<RawComment>(SourceMgr))"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 122, __PRETTY_FUNCTION__))
122 BeforeThanCompare<RawComment>(SourceMgr)))((std::is_sorted(RawComments.begin(), RawComments.end(), BeforeThanCompare
<RawComment>(SourceMgr))) ? static_cast<void> (0)
: __assert_fail ("std::is_sorted(RawComments.begin(), RawComments.end(), BeforeThanCompare<RawComment>(SourceMgr))"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 122, __PRETTY_FUNCTION__))
;
123#endif
124
125 CommentsLoaded = true;
126 }
127
128 assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 128, __PRETTY_FUNCTION__))
;
129
130 // User can not attach documentation to implicit declarations.
131 if (D->isImplicit())
132 return nullptr;
133
134 // User can not attach documentation to implicit instantiations.
135 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
136 if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
137 return nullptr;
138 }
139
140 if (const auto *VD = dyn_cast<VarDecl>(D)) {
141 if (VD->isStaticDataMember() &&
142 VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
143 return nullptr;
144 }
145
146 if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
147 if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
148 return nullptr;
149 }
150
151 if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
152 TemplateSpecializationKind TSK = CTSD->getSpecializationKind();
153 if (TSK == TSK_ImplicitInstantiation ||
154 TSK == TSK_Undeclared)
155 return nullptr;
156 }
157
158 if (const auto *ED = dyn_cast<EnumDecl>(D)) {
159 if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
160 return nullptr;
161 }
162 if (const auto *TD = dyn_cast<TagDecl>(D)) {
163 // When tag declaration (but not definition!) is part of the
164 // decl-specifier-seq of some other declaration, it doesn't get comment
165 if (TD->isEmbeddedInDeclarator() && !TD->isCompleteDefinition())
166 return nullptr;
167 }
168 // TODO: handle comments for function parameters properly.
169 if (isa<ParmVarDecl>(D))
170 return nullptr;
171
172 // TODO: we could look up template parameter documentation in the template
173 // documentation.
174 if (isa<TemplateTypeParmDecl>(D) ||
175 isa<NonTypeTemplateParmDecl>(D) ||
176 isa<TemplateTemplateParmDecl>(D))
177 return nullptr;
178
179 ArrayRef<RawComment *> RawComments = Comments.getComments();
180
181 // If there are no comments anywhere, we won't find anything.
182 if (RawComments.empty())
183 return nullptr;
184
185 // Find declaration location.
186 // For Objective-C declarations we generally don't expect to have multiple
187 // declarators, thus use declaration starting location as the "declaration
188 // location".
189 // For all other declarations multiple declarators are used quite frequently,
190 // so we use the location of the identifier as the "declaration location".
191 SourceLocation DeclLoc;
192 if (isa<ObjCMethodDecl>(D) || isa<ObjCContainerDecl>(D) ||
193 isa<ObjCPropertyDecl>(D) ||
194 isa<RedeclarableTemplateDecl>(D) ||
195 isa<ClassTemplateSpecializationDecl>(D))
196 DeclLoc = D->getBeginLoc();
197 else {
198 DeclLoc = D->getLocation();
199 if (DeclLoc.isMacroID()) {
200 if (isa<TypedefDecl>(D)) {
201 // If location of the typedef name is in a macro, it is because being
202 // declared via a macro. Try using declaration's starting location as
203 // the "declaration location".
204 DeclLoc = D->getBeginLoc();
205 } else if (const auto *TD = dyn_cast<TagDecl>(D)) {
206 // If location of the tag decl is inside a macro, but the spelling of
207 // the tag name comes from a macro argument, it looks like a special
208 // macro like NS_ENUM is being used to define the tag decl. In that
209 // case, adjust the source location to the expansion loc so that we can
210 // attach the comment to the tag decl.
211 if (SourceMgr.isMacroArgExpansion(DeclLoc) &&
212 TD->isCompleteDefinition())
213 DeclLoc = SourceMgr.getExpansionLoc(DeclLoc);
214 }
215 }
216 }
217
218 // If the declaration doesn't map directly to a location in a file, we
219 // can't find the comment.
220 if (DeclLoc.isInvalid() || !DeclLoc.isFileID())
221 return nullptr;
222
223 // Find the comment that occurs just after this declaration.
224 ArrayRef<RawComment *>::iterator Comment;
225 {
226 // When searching for comments during parsing, the comment we are looking
227 // for is usually among the last two comments we parsed -- check them
228 // first.
229 RawComment CommentAtDeclLoc(
230 SourceMgr, SourceRange(DeclLoc), LangOpts.CommentOpts, false);
231 BeforeThanCompare<RawComment> Compare(SourceMgr);
232 ArrayRef<RawComment *>::iterator MaybeBeforeDecl = RawComments.end() - 1;
233 bool Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
234 if (!Found && RawComments.size() >= 2) {
235 MaybeBeforeDecl--;
236 Found = Compare(*MaybeBeforeDecl, &CommentAtDeclLoc);
237 }
238
239 if (Found) {
240 Comment = MaybeBeforeDecl + 1;
241 assert(Comment == std::lower_bound(RawComments.begin(), RawComments.end(),((Comment == std::lower_bound(RawComments.begin(), RawComments
.end(), &CommentAtDeclLoc, Compare)) ? static_cast<void
> (0) : __assert_fail ("Comment == std::lower_bound(RawComments.begin(), RawComments.end(), &CommentAtDeclLoc, Compare)"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 242, __PRETTY_FUNCTION__))
242 &CommentAtDeclLoc, Compare))((Comment == std::lower_bound(RawComments.begin(), RawComments
.end(), &CommentAtDeclLoc, Compare)) ? static_cast<void
> (0) : __assert_fail ("Comment == std::lower_bound(RawComments.begin(), RawComments.end(), &CommentAtDeclLoc, Compare)"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 242, __PRETTY_FUNCTION__))
;
243 } else {
244 // Slow path.
245 Comment = std::lower_bound(RawComments.begin(), RawComments.end(),
246 &CommentAtDeclLoc, Compare);
247 }
248 }
249
250 // Decompose the location for the declaration and find the beginning of the
251 // file buffer.
252 std::pair<FileID, unsigned> DeclLocDecomp = SourceMgr.getDecomposedLoc(DeclLoc);
253
254 // First check whether we have a trailing comment.
255 if (Comment != RawComments.end() &&
256 ((*Comment)->isDocumentation() || LangOpts.CommentOpts.ParseAllComments)
257 && (*Comment)->isTrailingComment() &&
258 (isa<FieldDecl>(D) || isa<EnumConstantDecl>(D) || isa<VarDecl>(D) ||
259 isa<ObjCMethodDecl>(D) || isa<ObjCPropertyDecl>(D))) {
260 std::pair<FileID, unsigned> CommentBeginDecomp
261 = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getBegin());
262 // Check that Doxygen trailing comment comes after the declaration, starts
263 // on the same line and in the same file as the declaration.
264 if (DeclLocDecomp.first == CommentBeginDecomp.first &&
265 SourceMgr.getLineNumber(DeclLocDecomp.first, DeclLocDecomp.second)
266 == SourceMgr.getLineNumber(CommentBeginDecomp.first,
267 CommentBeginDecomp.second)) {
268 return *Comment;
269 }
270 }
271
272 // The comment just after the declaration was not a trailing comment.
273 // Let's look at the previous comment.
274 if (Comment == RawComments.begin())
275 return nullptr;
276 --Comment;
277
278 // Check that we actually have a non-member Doxygen comment.
279 if (!((*Comment)->isDocumentation() ||
280 LangOpts.CommentOpts.ParseAllComments) ||
281 (*Comment)->isTrailingComment())
282 return nullptr;
283
284 // Decompose the end of the comment.
285 std::pair<FileID, unsigned> CommentEndDecomp
286 = SourceMgr.getDecomposedLoc((*Comment)->getSourceRange().getEnd());
287
288 // If the comment and the declaration aren't in the same file, then they
289 // aren't related.
290 if (DeclLocDecomp.first != CommentEndDecomp.first)
291 return nullptr;
292
293 // Get the corresponding buffer.
294 bool Invalid = false;
295 const char *Buffer = SourceMgr.getBufferData(DeclLocDecomp.first,
296 &Invalid).data();
297 if (Invalid)
298 return nullptr;
299
300 // Extract text between the comment and declaration.
301 StringRef Text(Buffer + CommentEndDecomp.second,
302 DeclLocDecomp.second - CommentEndDecomp.second);
303
304 // There should be no other declarations or preprocessor directives between
305 // comment and declaration.
306 if (Text.find_first_of(";{}#@") != StringRef::npos)
307 return nullptr;
308
309 return *Comment;
310}
311
312/// If we have a 'templated' declaration for a template, adjust 'D' to
313/// refer to the actual template.
314/// If we have an implicit instantiation, adjust 'D' to refer to template.
315static const Decl *adjustDeclToTemplate(const Decl *D) {
316 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
317 // Is this function declaration part of a function template?
318 if (const FunctionTemplateDecl *FTD = FD->getDescribedFunctionTemplate())
319 return FTD;
320
321 // Nothing to do if function is not an implicit instantiation.
322 if (FD->getTemplateSpecializationKind() != TSK_ImplicitInstantiation)
323 return D;
324
325 // Function is an implicit instantiation of a function template?
326 if (const FunctionTemplateDecl *FTD = FD->getPrimaryTemplate())
327 return FTD;
328
329 // Function is instantiated from a member definition of a class template?
330 if (const FunctionDecl *MemberDecl =
331 FD->getInstantiatedFromMemberFunction())
332 return MemberDecl;
333
334 return D;
335 }
336 if (const auto *VD = dyn_cast<VarDecl>(D)) {
337 // Static data member is instantiated from a member definition of a class
338 // template?
339 if (VD->isStaticDataMember())
340 if (const VarDecl *MemberDecl = VD->getInstantiatedFromStaticDataMember())
341 return MemberDecl;
342
343 return D;
344 }
345 if (const auto *CRD = dyn_cast<CXXRecordDecl>(D)) {
346 // Is this class declaration part of a class template?
347 if (const ClassTemplateDecl *CTD = CRD->getDescribedClassTemplate())
348 return CTD;
349
350 // Class is an implicit instantiation of a class template or partial
351 // specialization?
352 if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(CRD)) {
353 if (CTSD->getSpecializationKind() != TSK_ImplicitInstantiation)
354 return D;
355 llvm::PointerUnion<ClassTemplateDecl *,
356 ClassTemplatePartialSpecializationDecl *>
357 PU = CTSD->getSpecializedTemplateOrPartial();
358 return PU.is<ClassTemplateDecl*>() ?
359 static_cast<const Decl*>(PU.get<ClassTemplateDecl *>()) :
360 static_cast<const Decl*>(
361 PU.get<ClassTemplatePartialSpecializationDecl *>());
362 }
363
364 // Class is instantiated from a member definition of a class template?
365 if (const MemberSpecializationInfo *Info =
366 CRD->getMemberSpecializationInfo())
367 return Info->getInstantiatedFrom();
368
369 return D;
370 }
371 if (const auto *ED = dyn_cast<EnumDecl>(D)) {
372 // Enum is instantiated from a member definition of a class template?
373 if (const EnumDecl *MemberDecl = ED->getInstantiatedFromMemberEnum())
374 return MemberDecl;
375
376 return D;
377 }
378 // FIXME: Adjust alias templates?
379 return D;
380}
381
382const RawComment *ASTContext::getRawCommentForAnyRedecl(
383 const Decl *D,
384 const Decl **OriginalDecl) const {
385 D = adjustDeclToTemplate(D);
386
387 // Check whether we have cached a comment for this declaration already.
388 {
389 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
390 RedeclComments.find(D);
391 if (Pos != RedeclComments.end()) {
392 const RawCommentAndCacheFlags &Raw = Pos->second;
393 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) {
394 if (OriginalDecl)
395 *OriginalDecl = Raw.getOriginalDecl();
396 return Raw.getRaw();
397 }
398 }
399 }
400
401 // Search for comments attached to declarations in the redeclaration chain.
402 const RawComment *RC = nullptr;
403 const Decl *OriginalDeclForRC = nullptr;
404 for (auto I : D->redecls()) {
405 llvm::DenseMap<const Decl *, RawCommentAndCacheFlags>::iterator Pos =
406 RedeclComments.find(I);
407 if (Pos != RedeclComments.end()) {
408 const RawCommentAndCacheFlags &Raw = Pos->second;
409 if (Raw.getKind() != RawCommentAndCacheFlags::NoCommentInDecl) {
410 RC = Raw.getRaw();
411 OriginalDeclForRC = Raw.getOriginalDecl();
412 break;
413 }
414 } else {
415 RC = getRawCommentForDeclNoCache(I);
416 OriginalDeclForRC = I;
417 RawCommentAndCacheFlags Raw;
418 if (RC) {
419 // Call order swapped to work around ICE in VS2015 RTM (Release Win32)
420 // https://connect.microsoft.com/VisualStudio/feedback/details/1741530
421 Raw.setKind(RawCommentAndCacheFlags::FromDecl);
422 Raw.setRaw(RC);
423 } else
424 Raw.setKind(RawCommentAndCacheFlags::NoCommentInDecl);
425 Raw.setOriginalDecl(I);
426 RedeclComments[I] = Raw;
427 if (RC)
428 break;
429 }
430 }
431
432 // If we found a comment, it should be a documentation comment.
433 assert(!RC || RC->isDocumentation() || LangOpts.CommentOpts.ParseAllComments)((!RC || RC->isDocumentation() || LangOpts.CommentOpts.ParseAllComments
) ? static_cast<void> (0) : __assert_fail ("!RC || RC->isDocumentation() || LangOpts.CommentOpts.ParseAllComments"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 433, __PRETTY_FUNCTION__))
;
434
435 if (OriginalDecl)
436 *OriginalDecl = OriginalDeclForRC;
437
438 // Update cache for every declaration in the redeclaration chain.
439 RawCommentAndCacheFlags Raw;
440 Raw.setRaw(RC);
441 Raw.setKind(RawCommentAndCacheFlags::FromRedecl);
442 Raw.setOriginalDecl(OriginalDeclForRC);
443
444 for (auto I : D->redecls()) {
445 RawCommentAndCacheFlags &R = RedeclComments[I];
446 if (R.getKind() == RawCommentAndCacheFlags::NoCommentInDecl)
447 R = Raw;
448 }
449
450 return RC;
451}
452
453static void addRedeclaredMethods(const ObjCMethodDecl *ObjCMethod,
454 SmallVectorImpl<const NamedDecl *> &Redeclared) {
455 const DeclContext *DC = ObjCMethod->getDeclContext();
456 if (const auto *IMD = dyn_cast<ObjCImplDecl>(DC)) {
457 const ObjCInterfaceDecl *ID = IMD->getClassInterface();
458 if (!ID)
459 return;
460 // Add redeclared method here.
461 for (const auto *Ext : ID->known_extensions()) {
462 if (ObjCMethodDecl *RedeclaredMethod =
463 Ext->getMethod(ObjCMethod->getSelector(),
464 ObjCMethod->isInstanceMethod()))
465 Redeclared.push_back(RedeclaredMethod);
466 }
467 }
468}
469
470comments::FullComment *ASTContext::cloneFullComment(comments::FullComment *FC,
471 const Decl *D) const {
472 auto *ThisDeclInfo = new (*this) comments::DeclInfo;
473 ThisDeclInfo->CommentDecl = D;
474 ThisDeclInfo->IsFilled = false;
475 ThisDeclInfo->fill();
476 ThisDeclInfo->CommentDecl = FC->getDecl();
477 if (!ThisDeclInfo->TemplateParameters)
478 ThisDeclInfo->TemplateParameters = FC->getDeclInfo()->TemplateParameters;
479 comments::FullComment *CFC =
480 new (*this) comments::FullComment(FC->getBlocks(),
481 ThisDeclInfo);
482 return CFC;
483}
484
485comments::FullComment *ASTContext::getLocalCommentForDeclUncached(const Decl *D) const {
486 const RawComment *RC = getRawCommentForDeclNoCache(D);
487 return RC ? RC->parse(*this, nullptr, D) : nullptr;
488}
489
490comments::FullComment *ASTContext::getCommentForDecl(
491 const Decl *D,
492 const Preprocessor *PP) const {
493 if (D->isInvalidDecl())
494 return nullptr;
495 D = adjustDeclToTemplate(D);
496
497 const Decl *Canonical = D->getCanonicalDecl();
498 llvm::DenseMap<const Decl *, comments::FullComment *>::iterator Pos =
499 ParsedComments.find(Canonical);
500
501 if (Pos != ParsedComments.end()) {
502 if (Canonical != D) {
503 comments::FullComment *FC = Pos->second;
504 comments::FullComment *CFC = cloneFullComment(FC, D);
505 return CFC;
506 }
507 return Pos->second;
508 }
509
510 const Decl *OriginalDecl;
511
512 const RawComment *RC = getRawCommentForAnyRedecl(D, &OriginalDecl);
513 if (!RC) {
514 if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {
515 SmallVector<const NamedDecl*, 8> Overridden;
516 const auto *OMD = dyn_cast<ObjCMethodDecl>(D);
517 if (OMD && OMD->isPropertyAccessor())
518 if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
519 if (comments::FullComment *FC = getCommentForDecl(PDecl, PP))
520 return cloneFullComment(FC, D);
521 if (OMD)
522 addRedeclaredMethods(OMD, Overridden);
523 getOverriddenMethods(dyn_cast<NamedDecl>(D), Overridden);
524 for (unsigned i = 0, e = Overridden.size(); i < e; i++)
525 if (comments::FullComment *FC = getCommentForDecl(Overridden[i], PP))
526 return cloneFullComment(FC, D);
527 }
528 else if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
529 // Attach any tag type's documentation to its typedef if latter
530 // does not have one of its own.
531 QualType QT = TD->getUnderlyingType();
532 if (const auto *TT = QT->getAs<TagType>())
533 if (const Decl *TD = TT->getDecl())
534 if (comments::FullComment *FC = getCommentForDecl(TD, PP))
535 return cloneFullComment(FC, D);
536 }
537 else if (const auto *IC = dyn_cast<ObjCInterfaceDecl>(D)) {
538 while (IC->getSuperClass()) {
539 IC = IC->getSuperClass();
540 if (comments::FullComment *FC = getCommentForDecl(IC, PP))
541 return cloneFullComment(FC, D);
542 }
543 }
544 else if (const auto *CD = dyn_cast<ObjCCategoryDecl>(D)) {
545 if (const ObjCInterfaceDecl *IC = CD->getClassInterface())
546 if (comments::FullComment *FC = getCommentForDecl(IC, PP))
547 return cloneFullComment(FC, D);
548 }
549 else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
550 if (!(RD = RD->getDefinition()))
551 return nullptr;
552 // Check non-virtual bases.
553 for (const auto &I : RD->bases()) {
554 if (I.isVirtual() || (I.getAccessSpecifier() != AS_public))
555 continue;
556 QualType Ty = I.getType();
557 if (Ty.isNull())
558 continue;
559 if (const CXXRecordDecl *NonVirtualBase = Ty->getAsCXXRecordDecl()) {
560 if (!(NonVirtualBase= NonVirtualBase->getDefinition()))
561 continue;
562
563 if (comments::FullComment *FC = getCommentForDecl((NonVirtualBase), PP))
564 return cloneFullComment(FC, D);
565 }
566 }
567 // Check virtual bases.
568 for (const auto &I : RD->vbases()) {
569 if (I.getAccessSpecifier() != AS_public)
570 continue;
571 QualType Ty = I.getType();
572 if (Ty.isNull())
573 continue;
574 if (const CXXRecordDecl *VirtualBase = Ty->getAsCXXRecordDecl()) {
575 if (!(VirtualBase= VirtualBase->getDefinition()))
576 continue;
577 if (comments::FullComment *FC = getCommentForDecl((VirtualBase), PP))
578 return cloneFullComment(FC, D);
579 }
580 }
581 }
582 return nullptr;
583 }
584
585 // If the RawComment was attached to other redeclaration of this Decl, we
586 // should parse the comment in context of that other Decl. This is important
587 // because comments can contain references to parameter names which can be
588 // different across redeclarations.
589 if (D != OriginalDecl)
590 return getCommentForDecl(OriginalDecl, PP);
591
592 comments::FullComment *FC = RC->parse(*this, PP, D);
593 ParsedComments[Canonical] = FC;
594 return FC;
595}
596
597void
598ASTContext::CanonicalTemplateTemplateParm::Profile(llvm::FoldingSetNodeID &ID,
599 TemplateTemplateParmDecl *Parm) {
600 ID.AddInteger(Parm->getDepth());
601 ID.AddInteger(Parm->getPosition());
602 ID.AddBoolean(Parm->isParameterPack());
603
604 TemplateParameterList *Params = Parm->getTemplateParameters();
605 ID.AddInteger(Params->size());
606 for (TemplateParameterList::const_iterator P = Params->begin(),
607 PEnd = Params->end();
608 P != PEnd; ++P) {
609 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
610 ID.AddInteger(0);
611 ID.AddBoolean(TTP->isParameterPack());
612 continue;
613 }
614
615 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
616 ID.AddInteger(1);
617 ID.AddBoolean(NTTP->isParameterPack());
618 ID.AddPointer(NTTP->getType().getCanonicalType().getAsOpaquePtr());
619 if (NTTP->isExpandedParameterPack()) {
620 ID.AddBoolean(true);
621 ID.AddInteger(NTTP->getNumExpansionTypes());
622 for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
623 QualType T = NTTP->getExpansionType(I);
624 ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
625 }
626 } else
627 ID.AddBoolean(false);
628 continue;
629 }
630
631 auto *TTP = cast<TemplateTemplateParmDecl>(*P);
632 ID.AddInteger(2);
633 Profile(ID, TTP);
634 }
635}
636
637TemplateTemplateParmDecl *
638ASTContext::getCanonicalTemplateTemplateParmDecl(
639 TemplateTemplateParmDecl *TTP) const {
640 // Check if we already have a canonical template template parameter.
641 llvm::FoldingSetNodeID ID;
642 CanonicalTemplateTemplateParm::Profile(ID, TTP);
643 void *InsertPos = nullptr;
644 CanonicalTemplateTemplateParm *Canonical
645 = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
646 if (Canonical)
647 return Canonical->getParam();
648
649 // Build a canonical template parameter list.
650 TemplateParameterList *Params = TTP->getTemplateParameters();
651 SmallVector<NamedDecl *, 4> CanonParams;
652 CanonParams.reserve(Params->size());
653 for (TemplateParameterList::const_iterator P = Params->begin(),
654 PEnd = Params->end();
655 P != PEnd; ++P) {
656 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(*P))
657 CanonParams.push_back(
658 TemplateTypeParmDecl::Create(*this, getTranslationUnitDecl(),
659 SourceLocation(),
660 SourceLocation(),
661 TTP->getDepth(),
662 TTP->getIndex(), nullptr, false,
663 TTP->isParameterPack()));
664 else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
665 QualType T = getCanonicalType(NTTP->getType());
666 TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
667 NonTypeTemplateParmDecl *Param;
668 if (NTTP->isExpandedParameterPack()) {
669 SmallVector<QualType, 2> ExpandedTypes;
670 SmallVector<TypeSourceInfo *, 2> ExpandedTInfos;
671 for (unsigned I = 0, N = NTTP->getNumExpansionTypes(); I != N; ++I) {
672 ExpandedTypes.push_back(getCanonicalType(NTTP->getExpansionType(I)));
673 ExpandedTInfos.push_back(
674 getTrivialTypeSourceInfo(ExpandedTypes.back()));
675 }
676
677 Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
678 SourceLocation(),
679 SourceLocation(),
680 NTTP->getDepth(),
681 NTTP->getPosition(), nullptr,
682 T,
683 TInfo,
684 ExpandedTypes,
685 ExpandedTInfos);
686 } else {
687 Param = NonTypeTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
688 SourceLocation(),
689 SourceLocation(),
690 NTTP->getDepth(),
691 NTTP->getPosition(), nullptr,
692 T,
693 NTTP->isParameterPack(),
694 TInfo);
695 }
696 CanonParams.push_back(Param);
697
698 } else
699 CanonParams.push_back(getCanonicalTemplateTemplateParmDecl(
700 cast<TemplateTemplateParmDecl>(*P)));
701 }
702
703 assert(!TTP->getRequiresClause() &&((!TTP->getRequiresClause() && "Unexpected requires-clause on template template-parameter"
) ? static_cast<void> (0) : __assert_fail ("!TTP->getRequiresClause() && \"Unexpected requires-clause on template template-parameter\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 704, __PRETTY_FUNCTION__))
704 "Unexpected requires-clause on template template-parameter")((!TTP->getRequiresClause() && "Unexpected requires-clause on template template-parameter"
) ? static_cast<void> (0) : __assert_fail ("!TTP->getRequiresClause() && \"Unexpected requires-clause on template template-parameter\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 704, __PRETTY_FUNCTION__))
;
705 Expr *const CanonRequiresClause = nullptr;
706
707 TemplateTemplateParmDecl *CanonTTP
708 = TemplateTemplateParmDecl::Create(*this, getTranslationUnitDecl(),
709 SourceLocation(), TTP->getDepth(),
710 TTP->getPosition(),
711 TTP->isParameterPack(),
712 nullptr,
713 TemplateParameterList::Create(*this, SourceLocation(),
714 SourceLocation(),
715 CanonParams,
716 SourceLocation(),
717 CanonRequiresClause));
718
719 // Get the new insert position for the node we care about.
720 Canonical = CanonTemplateTemplateParms.FindNodeOrInsertPos(ID, InsertPos);
721 assert(!Canonical && "Shouldn't be in the map!")((!Canonical && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!Canonical && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 721, __PRETTY_FUNCTION__))
;
722 (void)Canonical;
723
724 // Create the canonical template template parameter entry.
725 Canonical = new (*this) CanonicalTemplateTemplateParm(CanonTTP);
726 CanonTemplateTemplateParms.InsertNode(Canonical, InsertPos);
727 return CanonTTP;
728}
729
730CXXABI *ASTContext::createCXXABI(const TargetInfo &T) {
731 if (!LangOpts.CPlusPlus) return nullptr;
732
733 switch (T.getCXXABI().getKind()) {
734 case TargetCXXABI::GenericARM: // Same as Itanium at this level
735 case TargetCXXABI::iOS:
736 case TargetCXXABI::iOS64:
737 case TargetCXXABI::WatchOS:
738 case TargetCXXABI::GenericAArch64:
739 case TargetCXXABI::GenericMIPS:
740 case TargetCXXABI::GenericItanium:
741 case TargetCXXABI::WebAssembly:
742 return CreateItaniumCXXABI(*this);
743 case TargetCXXABI::Microsoft:
744 return CreateMicrosoftCXXABI(*this);
745 }
746 llvm_unreachable("Invalid CXXABI type!")::llvm::llvm_unreachable_internal("Invalid CXXABI type!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 746)
;
747}
748
749static const LangASMap *getAddressSpaceMap(const TargetInfo &T,
750 const LangOptions &LOpts) {
751 if (LOpts.FakeAddressSpaceMap) {
752 // The fake address space map must have a distinct entry for each
753 // language-specific address space.
754 static const unsigned FakeAddrSpaceMap[] = {
755 0, // Default
756 1, // opencl_global
757 3, // opencl_local
758 2, // opencl_constant
759 0, // opencl_private
760 4, // opencl_generic
761 5, // cuda_device
762 6, // cuda_constant
763 7 // cuda_shared
764 };
765 return &FakeAddrSpaceMap;
766 } else {
767 return &T.getAddressSpaceMap();
768 }
769}
770
771static bool isAddrSpaceMapManglingEnabled(const TargetInfo &TI,
772 const LangOptions &LangOpts) {
773 switch (LangOpts.getAddressSpaceMapMangling()) {
774 case LangOptions::ASMM_Target:
775 return TI.useAddressSpaceMapMangling();
776 case LangOptions::ASMM_On:
777 return true;
778 case LangOptions::ASMM_Off:
779 return false;
780 }
781 llvm_unreachable("getAddressSpaceMapMangling() doesn't cover anything.")::llvm::llvm_unreachable_internal("getAddressSpaceMapMangling() doesn't cover anything."
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 781)
;
782}
783
784ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM,
785 IdentifierTable &idents, SelectorTable &sels,
786 Builtin::Context &builtins)
787 : FunctionProtoTypes(this_()), TemplateSpecializationTypes(this_()),
788 DependentTemplateSpecializationTypes(this_()),
789 SubstTemplateTemplateParmPacks(this_()), SourceMgr(SM), LangOpts(LOpts),
790 SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
791 XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
792 LangOpts.XRayNeverInstrumentFiles,
793 LangOpts.XRayAttrListFiles, SM)),
794 PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
795 BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
796 CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
797 CompCategories(this_()), LastSDM(nullptr, 0) {
798 TUDecl = TranslationUnitDecl::Create(*this);
799}
800
801ASTContext::~ASTContext() {
802 ReleaseParentMapEntries();
803
804 // Release the DenseMaps associated with DeclContext objects.
805 // FIXME: Is this the ideal solution?
806 ReleaseDeclContextMaps();
807
808 // Call all of the deallocation functions on all of their targets.
809 for (auto &Pair : Deallocations)
810 (Pair.first)(Pair.second);
811
812 // ASTRecordLayout objects in ASTRecordLayouts must always be destroyed
813 // because they can contain DenseMaps.
814 for (llvm::DenseMap<const ObjCContainerDecl*,
815 const ASTRecordLayout*>::iterator
816 I = ObjCLayouts.begin(), E = ObjCLayouts.end(); I != E; )
817 // Increment in loop to prevent using deallocated memory.
818 if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
819 R->Destroy(*this);
820
821 for (llvm::DenseMap<const RecordDecl*, const ASTRecordLayout*>::iterator
822 I = ASTRecordLayouts.begin(), E = ASTRecordLayouts.end(); I != E; ) {
823 // Increment in loop to prevent using deallocated memory.
824 if (auto *R = const_cast<ASTRecordLayout *>((I++)->second))
825 R->Destroy(*this);
826 }
827
828 for (llvm::DenseMap<const Decl*, AttrVec*>::iterator A = DeclAttrs.begin(),
829 AEnd = DeclAttrs.end();
830 A != AEnd; ++A)
831 A->second->~AttrVec();
832
833 for (std::pair<const MaterializeTemporaryExpr *, APValue *> &MTVPair :
834 MaterializedTemporaryValues)
835 MTVPair.second->~APValue();
836
837 for (const auto &Value : ModuleInitializers)
838 Value.second->~PerModuleInitializers();
839}
840
841void ASTContext::ReleaseParentMapEntries() {
842 if (!PointerParents) return;
843 for (const auto &Entry : *PointerParents) {
844 if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
845 delete Entry.second.get<ast_type_traits::DynTypedNode *>();
846 } else if (Entry.second.is<ParentVector *>()) {
847 delete Entry.second.get<ParentVector *>();
848 }
849 }
850 for (const auto &Entry : *OtherParents) {
851 if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
852 delete Entry.second.get<ast_type_traits::DynTypedNode *>();
853 } else if (Entry.second.is<ParentVector *>()) {
854 delete Entry.second.get<ParentVector *>();
855 }
856 }
857}
858
859void ASTContext::AddDeallocation(void (*Callback)(void*), void *Data) {
860 Deallocations.push_back({Callback, Data});
861}
862
863void
864ASTContext::setExternalSource(IntrusiveRefCntPtr<ExternalASTSource> Source) {
865 ExternalSource = std::move(Source);
866}
867
868void ASTContext::PrintStats() const {
869 llvm::errs() << "\n*** AST Context Stats:\n";
870 llvm::errs() << " " << Types.size() << " types total.\n";
871
872 unsigned counts[] = {
873#define TYPE(Name, Parent) 0,
874#define ABSTRACT_TYPE(Name, Parent)
875#include "clang/AST/TypeNodes.def"
876 0 // Extra
877 };
878
879 for (unsigned i = 0, e = Types.size(); i != e; ++i) {
880 Type *T = Types[i];
881 counts[(unsigned)T->getTypeClass()]++;
882 }
883
884 unsigned Idx = 0;
885 unsigned TotalBytes = 0;
886#define TYPE(Name, Parent) \
887 if (counts[Idx]) \
888 llvm::errs() << " " << counts[Idx] << " " << #Name \
889 << " types, " << sizeof(Name##Type) << " each " \
890 << "(" << counts[Idx] * sizeof(Name##Type) \
891 << " bytes)\n"; \
892 TotalBytes += counts[Idx] * sizeof(Name##Type); \
893 ++Idx;
894#define ABSTRACT_TYPE(Name, Parent)
895#include "clang/AST/TypeNodes.def"
896
897 llvm::errs() << "Total bytes = " << TotalBytes << "\n";
898
899 // Implicit special member functions.
900 llvm::errs() << NumImplicitDefaultConstructorsDeclared << "/"
901 << NumImplicitDefaultConstructors
902 << " implicit default constructors created\n";
903 llvm::errs() << NumImplicitCopyConstructorsDeclared << "/"
904 << NumImplicitCopyConstructors
905 << " implicit copy constructors created\n";
906 if (getLangOpts().CPlusPlus)
907 llvm::errs() << NumImplicitMoveConstructorsDeclared << "/"
908 << NumImplicitMoveConstructors
909 << " implicit move constructors created\n";
910 llvm::errs() << NumImplicitCopyAssignmentOperatorsDeclared << "/"
911 << NumImplicitCopyAssignmentOperators
912 << " implicit copy assignment operators created\n";
913 if (getLangOpts().CPlusPlus)
914 llvm::errs() << NumImplicitMoveAssignmentOperatorsDeclared << "/"
915 << NumImplicitMoveAssignmentOperators
916 << " implicit move assignment operators created\n";
917 llvm::errs() << NumImplicitDestructorsDeclared << "/"
918 << NumImplicitDestructors
919 << " implicit destructors created\n";
920
921 if (ExternalSource) {
922 llvm::errs() << "\n";
923 ExternalSource->PrintStats();
924 }
925
926 BumpAlloc.PrintStats();
927}
928
929void ASTContext::mergeDefinitionIntoModule(NamedDecl *ND, Module *M,
930 bool NotifyListeners) {
931 if (NotifyListeners)
932 if (auto *Listener = getASTMutationListener())
933 Listener->RedefinedHiddenDefinition(ND, M);
934
935 MergedDefModules[cast<NamedDecl>(ND->getCanonicalDecl())].push_back(M);
936}
937
938void ASTContext::deduplicateMergedDefinitonsFor(NamedDecl *ND) {
939 auto It = MergedDefModules.find(cast<NamedDecl>(ND->getCanonicalDecl()));
940 if (It == MergedDefModules.end())
941 return;
942
943 auto &Merged = It->second;
944 llvm::DenseSet<Module*> Found;
945 for (Module *&M : Merged)
946 if (!Found.insert(M).second)
947 M = nullptr;
948 Merged.erase(std::remove(Merged.begin(), Merged.end(), nullptr), Merged.end());
949}
950
951void ASTContext::PerModuleInitializers::resolve(ASTContext &Ctx) {
952 if (LazyInitializers.empty())
953 return;
954
955 auto *Source = Ctx.getExternalSource();
956 assert(Source && "lazy initializers but no external source")((Source && "lazy initializers but no external source"
) ? static_cast<void> (0) : __assert_fail ("Source && \"lazy initializers but no external source\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 956, __PRETTY_FUNCTION__))
;
957
958 auto LazyInits = std::move(LazyInitializers);
959 LazyInitializers.clear();
960
961 for (auto ID : LazyInits)
962 Initializers.push_back(Source->GetExternalDecl(ID));
963
964 assert(LazyInitializers.empty() &&((LazyInitializers.empty() && "GetExternalDecl for lazy module initializer added more inits"
) ? static_cast<void> (0) : __assert_fail ("LazyInitializers.empty() && \"GetExternalDecl for lazy module initializer added more inits\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 965, __PRETTY_FUNCTION__))
965 "GetExternalDecl for lazy module initializer added more inits")((LazyInitializers.empty() && "GetExternalDecl for lazy module initializer added more inits"
) ? static_cast<void> (0) : __assert_fail ("LazyInitializers.empty() && \"GetExternalDecl for lazy module initializer added more inits\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 965, __PRETTY_FUNCTION__))
;
966}
967
968void ASTContext::addModuleInitializer(Module *M, Decl *D) {
969 // One special case: if we add a module initializer that imports another
970 // module, and that module's only initializer is an ImportDecl, simplify.
971 if (const auto *ID = dyn_cast<ImportDecl>(D)) {
972 auto It = ModuleInitializers.find(ID->getImportedModule());
973
974 // Maybe the ImportDecl does nothing at all. (Common case.)
975 if (It == ModuleInitializers.end())
976 return;
977
978 // Maybe the ImportDecl only imports another ImportDecl.
979 auto &Imported = *It->second;
980 if (Imported.Initializers.size() + Imported.LazyInitializers.size() == 1) {
981 Imported.resolve(*this);
982 auto *OnlyDecl = Imported.Initializers.front();
983 if (isa<ImportDecl>(OnlyDecl))
984 D = OnlyDecl;
985 }
986 }
987
988 auto *&Inits = ModuleInitializers[M];
989 if (!Inits)
990 Inits = new (*this) PerModuleInitializers;
991 Inits->Initializers.push_back(D);
992}
993
994void ASTContext::addLazyModuleInitializers(Module *M, ArrayRef<uint32_t> IDs) {
995 auto *&Inits = ModuleInitializers[M];
996 if (!Inits)
997 Inits = new (*this) PerModuleInitializers;
998 Inits->LazyInitializers.insert(Inits->LazyInitializers.end(),
999 IDs.begin(), IDs.end());
1000}
1001
1002ArrayRef<Decl *> ASTContext::getModuleInitializers(Module *M) {
1003 auto It = ModuleInitializers.find(M);
1004 if (It == ModuleInitializers.end())
1005 return None;
1006
1007 auto *Inits = It->second;
1008 Inits->resolve(*this);
1009 return Inits->Initializers;
1010}
1011
1012ExternCContextDecl *ASTContext::getExternCContextDecl() const {
1013 if (!ExternCContext)
1014 ExternCContext = ExternCContextDecl::Create(*this, getTranslationUnitDecl());
1015
1016 return ExternCContext;
1017}
1018
1019BuiltinTemplateDecl *
1020ASTContext::buildBuiltinTemplateDecl(BuiltinTemplateKind BTK,
1021 const IdentifierInfo *II) const {
1022 auto *BuiltinTemplate = BuiltinTemplateDecl::Create(*this, TUDecl, II, BTK);
1023 BuiltinTemplate->setImplicit();
1024 TUDecl->addDecl(BuiltinTemplate);
1025
1026 return BuiltinTemplate;
1027}
1028
1029BuiltinTemplateDecl *
1030ASTContext::getMakeIntegerSeqDecl() const {
1031 if (!MakeIntegerSeqDecl)
1032 MakeIntegerSeqDecl = buildBuiltinTemplateDecl(BTK__make_integer_seq,
1033 getMakeIntegerSeqName());
1034 return MakeIntegerSeqDecl;
1035}
1036
1037BuiltinTemplateDecl *
1038ASTContext::getTypePackElementDecl() const {
1039 if (!TypePackElementDecl)
1040 TypePackElementDecl = buildBuiltinTemplateDecl(BTK__type_pack_element,
1041 getTypePackElementName());
1042 return TypePackElementDecl;
1043}
1044
1045RecordDecl *ASTContext::buildImplicitRecord(StringRef Name,
1046 RecordDecl::TagKind TK) const {
1047 SourceLocation Loc;
1048 RecordDecl *NewDecl;
1049 if (getLangOpts().CPlusPlus)
1050 NewDecl = CXXRecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc,
1051 Loc, &Idents.get(Name));
1052 else
1053 NewDecl = RecordDecl::Create(*this, TK, getTranslationUnitDecl(), Loc, Loc,
1054 &Idents.get(Name));
1055 NewDecl->setImplicit();
1056 NewDecl->addAttr(TypeVisibilityAttr::CreateImplicit(
1057 const_cast<ASTContext &>(*this), TypeVisibilityAttr::Default));
1058 return NewDecl;
1059}
1060
1061TypedefDecl *ASTContext::buildImplicitTypedef(QualType T,
1062 StringRef Name) const {
1063 TypeSourceInfo *TInfo = getTrivialTypeSourceInfo(T);
1064 TypedefDecl *NewDecl = TypedefDecl::Create(
1065 const_cast<ASTContext &>(*this), getTranslationUnitDecl(),
1066 SourceLocation(), SourceLocation(), &Idents.get(Name), TInfo);
1067 NewDecl->setImplicit();
1068 return NewDecl;
1069}
1070
1071TypedefDecl *ASTContext::getInt128Decl() const {
1072 if (!Int128Decl)
1073 Int128Decl = buildImplicitTypedef(Int128Ty, "__int128_t");
1074 return Int128Decl;
1075}
1076
1077TypedefDecl *ASTContext::getUInt128Decl() const {
1078 if (!UInt128Decl)
1079 UInt128Decl = buildImplicitTypedef(UnsignedInt128Ty, "__uint128_t");
1080 return UInt128Decl;
1081}
1082
1083void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
1084 auto *Ty = new (*this, TypeAlignment) BuiltinType(K);
1085 R = CanQualType::CreateUnsafe(QualType(Ty, 0));
1086 Types.push_back(Ty);
1087}
1088
1089void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
1090 const TargetInfo *AuxTarget) {
1091 assert((!this->Target || this->Target == &Target) &&(((!this->Target || this->Target == &Target) &&
"Incorrect target reinitialization") ? static_cast<void>
(0) : __assert_fail ("(!this->Target || this->Target == &Target) && \"Incorrect target reinitialization\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1092, __PRETTY_FUNCTION__))
1092 "Incorrect target reinitialization")(((!this->Target || this->Target == &Target) &&
"Incorrect target reinitialization") ? static_cast<void>
(0) : __assert_fail ("(!this->Target || this->Target == &Target) && \"Incorrect target reinitialization\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1092, __PRETTY_FUNCTION__))
;
1093 assert(VoidTy.isNull() && "Context reinitialized?")((VoidTy.isNull() && "Context reinitialized?") ? static_cast
<void> (0) : __assert_fail ("VoidTy.isNull() && \"Context reinitialized?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1093, __PRETTY_FUNCTION__))
;
1094
1095 this->Target = &Target;
1096 this->AuxTarget = AuxTarget;
1097
1098 ABI.reset(createCXXABI(Target));
1099 AddrSpaceMap = getAddressSpaceMap(Target, LangOpts);
1100 AddrSpaceMapMangling = isAddrSpaceMapManglingEnabled(Target, LangOpts);
1101
1102 // C99 6.2.5p19.
1103 InitBuiltinType(VoidTy, BuiltinType::Void);
1104
1105 // C99 6.2.5p2.
1106 InitBuiltinType(BoolTy, BuiltinType::Bool);
1107 // C99 6.2.5p3.
1108 if (LangOpts.CharIsSigned)
1109 InitBuiltinType(CharTy, BuiltinType::Char_S);
1110 else
1111 InitBuiltinType(CharTy, BuiltinType::Char_U);
1112 // C99 6.2.5p4.
1113 InitBuiltinType(SignedCharTy, BuiltinType::SChar);
1114 InitBuiltinType(ShortTy, BuiltinType::Short);
1115 InitBuiltinType(IntTy, BuiltinType::Int);
1116 InitBuiltinType(LongTy, BuiltinType::Long);
1117 InitBuiltinType(LongLongTy, BuiltinType::LongLong);
1118
1119 // C99 6.2.5p6.
1120 InitBuiltinType(UnsignedCharTy, BuiltinType::UChar);
1121 InitBuiltinType(UnsignedShortTy, BuiltinType::UShort);
1122 InitBuiltinType(UnsignedIntTy, BuiltinType::UInt);
1123 InitBuiltinType(UnsignedLongTy, BuiltinType::ULong);
1124 InitBuiltinType(UnsignedLongLongTy, BuiltinType::ULongLong);
1125
1126 // C99 6.2.5p10.
1127 InitBuiltinType(FloatTy, BuiltinType::Float);
1128 InitBuiltinType(DoubleTy, BuiltinType::Double);
1129 InitBuiltinType(LongDoubleTy, BuiltinType::LongDouble);
1130
1131 // GNU extension, __float128 for IEEE quadruple precision
1132 InitBuiltinType(Float128Ty, BuiltinType::Float128);
1133
1134 // C11 extension ISO/IEC TS 18661-3
1135 InitBuiltinType(Float16Ty, BuiltinType::Float16);
1136
1137 // ISO/IEC JTC1 SC22 WG14 N1169 Extension
1138 InitBuiltinType(ShortAccumTy, BuiltinType::ShortAccum);
1139 InitBuiltinType(AccumTy, BuiltinType::Accum);
1140 InitBuiltinType(LongAccumTy, BuiltinType::LongAccum);
1141 InitBuiltinType(UnsignedShortAccumTy, BuiltinType::UShortAccum);
1142 InitBuiltinType(UnsignedAccumTy, BuiltinType::UAccum);
1143 InitBuiltinType(UnsignedLongAccumTy, BuiltinType::ULongAccum);
1144 InitBuiltinType(ShortFractTy, BuiltinType::ShortFract);
1145 InitBuiltinType(FractTy, BuiltinType::Fract);
1146 InitBuiltinType(LongFractTy, BuiltinType::LongFract);
1147 InitBuiltinType(UnsignedShortFractTy, BuiltinType::UShortFract);
1148 InitBuiltinType(UnsignedFractTy, BuiltinType::UFract);
1149 InitBuiltinType(UnsignedLongFractTy, BuiltinType::ULongFract);
1150 InitBuiltinType(SatShortAccumTy, BuiltinType::SatShortAccum);
1151 InitBuiltinType(SatAccumTy, BuiltinType::SatAccum);
1152 InitBuiltinType(SatLongAccumTy, BuiltinType::SatLongAccum);
1153 InitBuiltinType(SatUnsignedShortAccumTy, BuiltinType::SatUShortAccum);
1154 InitBuiltinType(SatUnsignedAccumTy, BuiltinType::SatUAccum);
1155 InitBuiltinType(SatUnsignedLongAccumTy, BuiltinType::SatULongAccum);
1156 InitBuiltinType(SatShortFractTy, BuiltinType::SatShortFract);
1157 InitBuiltinType(SatFractTy, BuiltinType::SatFract);
1158 InitBuiltinType(SatLongFractTy, BuiltinType::SatLongFract);
1159 InitBuiltinType(SatUnsignedShortFractTy, BuiltinType::SatUShortFract);
1160 InitBuiltinType(SatUnsignedFractTy, BuiltinType::SatUFract);
1161 InitBuiltinType(SatUnsignedLongFractTy, BuiltinType::SatULongFract);
1162
1163 // GNU extension, 128-bit integers.
1164 InitBuiltinType(Int128Ty, BuiltinType::Int128);
1165 InitBuiltinType(UnsignedInt128Ty, BuiltinType::UInt128);
1166
1167 // C++ 3.9.1p5
1168 if (TargetInfo::isTypeSigned(Target.getWCharType()))
1169 InitBuiltinType(WCharTy, BuiltinType::WChar_S);
1170 else // -fshort-wchar makes wchar_t be unsigned.
1171 InitBuiltinType(WCharTy, BuiltinType::WChar_U);
1172 if (LangOpts.CPlusPlus && LangOpts.WChar)
1173 WideCharTy = WCharTy;
1174 else {
1175 // C99 (or C++ using -fno-wchar).
1176 WideCharTy = getFromTargetType(Target.getWCharType());
1177 }
1178
1179 WIntTy = getFromTargetType(Target.getWIntType());
1180
1181 // C++20 (proposed)
1182 InitBuiltinType(Char8Ty, BuiltinType::Char8);
1183
1184 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
1185 InitBuiltinType(Char16Ty, BuiltinType::Char16);
1186 else // C99
1187 Char16Ty = getFromTargetType(Target.getChar16Type());
1188
1189 if (LangOpts.CPlusPlus) // C++0x 3.9.1p5, extension for C++
1190 InitBuiltinType(Char32Ty, BuiltinType::Char32);
1191 else // C99
1192 Char32Ty = getFromTargetType(Target.getChar32Type());
1193
1194 // Placeholder type for type-dependent expressions whose type is
1195 // completely unknown. No code should ever check a type against
1196 // DependentTy and users should never see it; however, it is here to
1197 // help diagnose failures to properly check for type-dependent
1198 // expressions.
1199 InitBuiltinType(DependentTy, BuiltinType::Dependent);
1200
1201 // Placeholder type for functions.
1202 InitBuiltinType(OverloadTy, BuiltinType::Overload);
1203
1204 // Placeholder type for bound members.
1205 InitBuiltinType(BoundMemberTy, BuiltinType::BoundMember);
1206
1207 // Placeholder type for pseudo-objects.
1208 InitBuiltinType(PseudoObjectTy, BuiltinType::PseudoObject);
1209
1210 // "any" type; useful for debugger-like clients.
1211 InitBuiltinType(UnknownAnyTy, BuiltinType::UnknownAny);
1212
1213 // Placeholder type for unbridged ARC casts.
1214 InitBuiltinType(ARCUnbridgedCastTy, BuiltinType::ARCUnbridgedCast);
1215
1216 // Placeholder type for builtin functions.
1217 InitBuiltinType(BuiltinFnTy, BuiltinType::BuiltinFn);
1218
1219 // Placeholder type for OMP array sections.
1220 if (LangOpts.OpenMP)
1221 InitBuiltinType(OMPArraySectionTy, BuiltinType::OMPArraySection);
1222
1223 // C99 6.2.5p11.
1224 FloatComplexTy = getComplexType(FloatTy);
1225 DoubleComplexTy = getComplexType(DoubleTy);
1226 LongDoubleComplexTy = getComplexType(LongDoubleTy);
1227 Float128ComplexTy = getComplexType(Float128Ty);
1228
1229 // Builtin types for 'id', 'Class', and 'SEL'.
1230 InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
1231 InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
1232 InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);
1233
1234 if (LangOpts.OpenCL) {
1235#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1236 InitBuiltinType(SingletonId, BuiltinType::Id);
1237#include "clang/Basic/OpenCLImageTypes.def"
1238
1239 InitBuiltinType(OCLSamplerTy, BuiltinType::OCLSampler);
1240 InitBuiltinType(OCLEventTy, BuiltinType::OCLEvent);
1241 InitBuiltinType(OCLClkEventTy, BuiltinType::OCLClkEvent);
1242 InitBuiltinType(OCLQueueTy, BuiltinType::OCLQueue);
1243 InitBuiltinType(OCLReserveIDTy, BuiltinType::OCLReserveID);
1244 }
1245
1246 // Builtin type for __objc_yes and __objc_no
1247 ObjCBuiltinBoolTy = (Target.useSignedCharForObjCBool() ?
1248 SignedCharTy : BoolTy);
1249
1250 ObjCConstantStringType = QualType();
1251
1252 ObjCSuperType = QualType();
1253
1254 // void * type
1255 if (LangOpts.OpenCLVersion >= 200) {
1256 auto Q = VoidTy.getQualifiers();
1257 Q.setAddressSpace(LangAS::opencl_generic);
1258 VoidPtrTy = getPointerType(getCanonicalType(
1259 getQualifiedType(VoidTy.getUnqualifiedType(), Q)));
1260 } else {
1261 VoidPtrTy = getPointerType(VoidTy);
1262 }
1263
1264 // nullptr type (C++0x 2.14.7)
1265 InitBuiltinType(NullPtrTy, BuiltinType::NullPtr);
1266
1267 // half type (OpenCL 6.1.1.1) / ARM NEON __fp16
1268 InitBuiltinType(HalfTy, BuiltinType::Half);
1269
1270 // Builtin type used to help define __builtin_va_list.
1271 VaListTagDecl = nullptr;
1272}
1273
1274DiagnosticsEngine &ASTContext::getDiagnostics() const {
1275 return SourceMgr.getDiagnostics();
1276}
1277
1278AttrVec& ASTContext::getDeclAttrs(const Decl *D) {
1279 AttrVec *&Result = DeclAttrs[D];
1280 if (!Result) {
1281 void *Mem = Allocate(sizeof(AttrVec));
1282 Result = new (Mem) AttrVec;
1283 }
1284
1285 return *Result;
1286}
1287
1288/// Erase the attributes corresponding to the given declaration.
1289void ASTContext::eraseDeclAttrs(const Decl *D) {
1290 llvm::DenseMap<const Decl*, AttrVec*>::iterator Pos = DeclAttrs.find(D);
1291 if (Pos != DeclAttrs.end()) {
1292 Pos->second->~AttrVec();
1293 DeclAttrs.erase(Pos);
1294 }
1295}
1296
1297// FIXME: Remove ?
1298MemberSpecializationInfo *
1299ASTContext::getInstantiatedFromStaticDataMember(const VarDecl *Var) {
1300 assert(Var->isStaticDataMember() && "Not a static data member")((Var->isStaticDataMember() && "Not a static data member"
) ? static_cast<void> (0) : __assert_fail ("Var->isStaticDataMember() && \"Not a static data member\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1300, __PRETTY_FUNCTION__))
;
1301 return getTemplateOrSpecializationInfo(Var)
1302 .dyn_cast<MemberSpecializationInfo *>();
1303}
1304
1305ASTContext::TemplateOrSpecializationInfo
1306ASTContext::getTemplateOrSpecializationInfo(const VarDecl *Var) {
1307 llvm::DenseMap<const VarDecl *, TemplateOrSpecializationInfo>::iterator Pos =
1308 TemplateOrInstantiation.find(Var);
1309 if (Pos == TemplateOrInstantiation.end())
1310 return {};
1311
1312 return Pos->second;
1313}
1314
1315void
1316ASTContext::setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl,
1317 TemplateSpecializationKind TSK,
1318 SourceLocation PointOfInstantiation) {
1319 assert(Inst->isStaticDataMember() && "Not a static data member")((Inst->isStaticDataMember() && "Not a static data member"
) ? static_cast<void> (0) : __assert_fail ("Inst->isStaticDataMember() && \"Not a static data member\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1319, __PRETTY_FUNCTION__))
;
1320 assert(Tmpl->isStaticDataMember() && "Not a static data member")((Tmpl->isStaticDataMember() && "Not a static data member"
) ? static_cast<void> (0) : __assert_fail ("Tmpl->isStaticDataMember() && \"Not a static data member\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1320, __PRETTY_FUNCTION__))
;
1321 setTemplateOrSpecializationInfo(Inst, new (*this) MemberSpecializationInfo(
1322 Tmpl, TSK, PointOfInstantiation));
1323}
1324
1325void
1326ASTContext::setTemplateOrSpecializationInfo(VarDecl *Inst,
1327 TemplateOrSpecializationInfo TSI) {
1328 assert(!TemplateOrInstantiation[Inst] &&((!TemplateOrInstantiation[Inst] && "Already noted what the variable was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!TemplateOrInstantiation[Inst] && \"Already noted what the variable was instantiated from\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1329, __PRETTY_FUNCTION__))
1329 "Already noted what the variable was instantiated from")((!TemplateOrInstantiation[Inst] && "Already noted what the variable was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!TemplateOrInstantiation[Inst] && \"Already noted what the variable was instantiated from\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1329, __PRETTY_FUNCTION__))
;
1330 TemplateOrInstantiation[Inst] = TSI;
1331}
1332
1333FunctionDecl *ASTContext::getClassScopeSpecializationPattern(
1334 const FunctionDecl *FD){
1335 assert(FD && "Specialization is 0")((FD && "Specialization is 0") ? static_cast<void>
(0) : __assert_fail ("FD && \"Specialization is 0\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1335, __PRETTY_FUNCTION__))
;
1336 llvm::DenseMap<const FunctionDecl*, FunctionDecl *>::const_iterator Pos
1337 = ClassScopeSpecializationPattern.find(FD);
1338 if (Pos == ClassScopeSpecializationPattern.end())
1339 return nullptr;
1340
1341 return Pos->second;
1342}
1343
1344void ASTContext::setClassScopeSpecializationPattern(FunctionDecl *FD,
1345 FunctionDecl *Pattern) {
1346 assert(FD && "Specialization is 0")((FD && "Specialization is 0") ? static_cast<void>
(0) : __assert_fail ("FD && \"Specialization is 0\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1346, __PRETTY_FUNCTION__))
;
1347 assert(Pattern && "Class scope specialization pattern is 0")((Pattern && "Class scope specialization pattern is 0"
) ? static_cast<void> (0) : __assert_fail ("Pattern && \"Class scope specialization pattern is 0\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1347, __PRETTY_FUNCTION__))
;
1348 ClassScopeSpecializationPattern[FD] = Pattern;
1349}
1350
1351NamedDecl *
1352ASTContext::getInstantiatedFromUsingDecl(NamedDecl *UUD) {
1353 auto Pos = InstantiatedFromUsingDecl.find(UUD);
1354 if (Pos == InstantiatedFromUsingDecl.end())
1355 return nullptr;
1356
1357 return Pos->second;
1358}
1359
1360void
1361ASTContext::setInstantiatedFromUsingDecl(NamedDecl *Inst, NamedDecl *Pattern) {
1362 assert((isa<UsingDecl>(Pattern) ||(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __PRETTY_FUNCTION__))
1363 isa<UnresolvedUsingValueDecl>(Pattern) ||(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __PRETTY_FUNCTION__))
1364 isa<UnresolvedUsingTypenameDecl>(Pattern)) &&(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __PRETTY_FUNCTION__))
1365 "pattern decl is not a using decl")(((isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl
>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern
)) && "pattern decl is not a using decl") ? static_cast
<void> (0) : __assert_fail ("(isa<UsingDecl>(Pattern) || isa<UnresolvedUsingValueDecl>(Pattern) || isa<UnresolvedUsingTypenameDecl>(Pattern)) && \"pattern decl is not a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1365, __PRETTY_FUNCTION__))
;
1366 assert((isa<UsingDecl>(Inst) ||(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
"instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __PRETTY_FUNCTION__))
1367 isa<UnresolvedUsingValueDecl>(Inst) ||(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
"instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __PRETTY_FUNCTION__))
1368 isa<UnresolvedUsingTypenameDecl>(Inst)) &&(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
"instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __PRETTY_FUNCTION__))
1369 "instantiation did not produce a using decl")(((isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl
>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) &&
"instantiation did not produce a using decl") ? static_cast<
void> (0) : __assert_fail ("(isa<UsingDecl>(Inst) || isa<UnresolvedUsingValueDecl>(Inst) || isa<UnresolvedUsingTypenameDecl>(Inst)) && \"instantiation did not produce a using decl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1369, __PRETTY_FUNCTION__))
;
1370 assert(!InstantiatedFromUsingDecl[Inst] && "pattern already exists")((!InstantiatedFromUsingDecl[Inst] && "pattern already exists"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUsingDecl[Inst] && \"pattern already exists\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1370, __PRETTY_FUNCTION__))
;
1371 InstantiatedFromUsingDecl[Inst] = Pattern;
1372}
1373
1374UsingShadowDecl *
1375ASTContext::getInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst) {
1376 llvm::DenseMap<UsingShadowDecl*, UsingShadowDecl*>::const_iterator Pos
1377 = InstantiatedFromUsingShadowDecl.find(Inst);
1378 if (Pos == InstantiatedFromUsingShadowDecl.end())
1379 return nullptr;
1380
1381 return Pos->second;
1382}
1383
1384void
1385ASTContext::setInstantiatedFromUsingShadowDecl(UsingShadowDecl *Inst,
1386 UsingShadowDecl *Pattern) {
1387 assert(!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists")((!InstantiatedFromUsingShadowDecl[Inst] && "pattern already exists"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUsingShadowDecl[Inst] && \"pattern already exists\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1387, __PRETTY_FUNCTION__))
;
1388 InstantiatedFromUsingShadowDecl[Inst] = Pattern;
1389}
1390
1391FieldDecl *ASTContext::getInstantiatedFromUnnamedFieldDecl(FieldDecl *Field) {
1392 llvm::DenseMap<FieldDecl *, FieldDecl *>::iterator Pos
1393 = InstantiatedFromUnnamedFieldDecl.find(Field);
1394 if (Pos == InstantiatedFromUnnamedFieldDecl.end())
1395 return nullptr;
1396
1397 return Pos->second;
1398}
1399
1400void ASTContext::setInstantiatedFromUnnamedFieldDecl(FieldDecl *Inst,
1401 FieldDecl *Tmpl) {
1402 assert(!Inst->getDeclName() && "Instantiated field decl is not unnamed")((!Inst->getDeclName() && "Instantiated field decl is not unnamed"
) ? static_cast<void> (0) : __assert_fail ("!Inst->getDeclName() && \"Instantiated field decl is not unnamed\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1402, __PRETTY_FUNCTION__))
;
1403 assert(!Tmpl->getDeclName() && "Template field decl is not unnamed")((!Tmpl->getDeclName() && "Template field decl is not unnamed"
) ? static_cast<void> (0) : __assert_fail ("!Tmpl->getDeclName() && \"Template field decl is not unnamed\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1403, __PRETTY_FUNCTION__))
;
1404 assert(!InstantiatedFromUnnamedFieldDecl[Inst] &&((!InstantiatedFromUnnamedFieldDecl[Inst] && "Already noted what unnamed field was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUnnamedFieldDecl[Inst] && \"Already noted what unnamed field was instantiated from\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1405, __PRETTY_FUNCTION__))
1405 "Already noted what unnamed field was instantiated from")((!InstantiatedFromUnnamedFieldDecl[Inst] && "Already noted what unnamed field was instantiated from"
) ? static_cast<void> (0) : __assert_fail ("!InstantiatedFromUnnamedFieldDecl[Inst] && \"Already noted what unnamed field was instantiated from\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1405, __PRETTY_FUNCTION__))
;
1406
1407 InstantiatedFromUnnamedFieldDecl[Inst] = Tmpl;
1408}
1409
1410ASTContext::overridden_cxx_method_iterator
1411ASTContext::overridden_methods_begin(const CXXMethodDecl *Method) const {
1412 return overridden_methods(Method).begin();
1413}
1414
1415ASTContext::overridden_cxx_method_iterator
1416ASTContext::overridden_methods_end(const CXXMethodDecl *Method) const {
1417 return overridden_methods(Method).end();
1418}
1419
1420unsigned
1421ASTContext::overridden_methods_size(const CXXMethodDecl *Method) const {
1422 auto Range = overridden_methods(Method);
1423 return Range.end() - Range.begin();
1424}
1425
1426ASTContext::overridden_method_range
1427ASTContext::overridden_methods(const CXXMethodDecl *Method) const {
1428 llvm::DenseMap<const CXXMethodDecl *, CXXMethodVector>::const_iterator Pos =
1429 OverriddenMethods.find(Method->getCanonicalDecl());
1430 if (Pos == OverriddenMethods.end())
1431 return overridden_method_range(nullptr, nullptr);
1432 return overridden_method_range(Pos->second.begin(), Pos->second.end());
1433}
1434
1435void ASTContext::addOverriddenMethod(const CXXMethodDecl *Method,
1436 const CXXMethodDecl *Overridden) {
1437 assert(Method->isCanonicalDecl() && Overridden->isCanonicalDecl())((Method->isCanonicalDecl() && Overridden->isCanonicalDecl
()) ? static_cast<void> (0) : __assert_fail ("Method->isCanonicalDecl() && Overridden->isCanonicalDecl()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1437, __PRETTY_FUNCTION__))
;
1438 OverriddenMethods[Method].push_back(Overridden);
1439}
1440
1441void ASTContext::getOverriddenMethods(
1442 const NamedDecl *D,
1443 SmallVectorImpl<const NamedDecl *> &Overridden) const {
1444 assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1444, __PRETTY_FUNCTION__))
;
1445
1446 if (const auto *CXXMethod = dyn_cast<CXXMethodDecl>(D)) {
1447 Overridden.append(overridden_methods_begin(CXXMethod),
1448 overridden_methods_end(CXXMethod));
1449 return;
1450 }
1451
1452 const auto *Method = dyn_cast<ObjCMethodDecl>(D);
1453 if (!Method)
1454 return;
1455
1456 SmallVector<const ObjCMethodDecl *, 8> OverDecls;
1457 Method->getOverriddenMethods(OverDecls);
1458 Overridden.append(OverDecls.begin(), OverDecls.end());
1459}
1460
1461void ASTContext::addedLocalImportDecl(ImportDecl *Import) {
1462 assert(!Import->NextLocalImport && "Import declaration already in the chain")((!Import->NextLocalImport && "Import declaration already in the chain"
) ? static_cast<void> (0) : __assert_fail ("!Import->NextLocalImport && \"Import declaration already in the chain\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1462, __PRETTY_FUNCTION__))
;
1463 assert(!Import->isFromASTFile() && "Non-local import declaration")((!Import->isFromASTFile() && "Non-local import declaration"
) ? static_cast<void> (0) : __assert_fail ("!Import->isFromASTFile() && \"Non-local import declaration\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1463, __PRETTY_FUNCTION__))
;
1464 if (!FirstLocalImport) {
1465 FirstLocalImport = Import;
1466 LastLocalImport = Import;
1467 return;
1468 }
1469
1470 LastLocalImport->NextLocalImport = Import;
1471 LastLocalImport = Import;
1472}
1473
1474//===----------------------------------------------------------------------===//
1475// Type Sizing and Analysis
1476//===----------------------------------------------------------------------===//
1477
1478/// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
1479/// scalar floating point type.
1480const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
1481 const auto *BT = T->getAs<BuiltinType>();
1482 assert(BT && "Not a floating point type!")((BT && "Not a floating point type!") ? static_cast<
void> (0) : __assert_fail ("BT && \"Not a floating point type!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1482, __PRETTY_FUNCTION__))
;
1483 switch (BT->getKind()) {
1484 default: llvm_unreachable("Not a floating point type!")::llvm::llvm_unreachable_internal("Not a floating point type!"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1484)
;
1485 case BuiltinType::Float16:
1486 case BuiltinType::Half:
1487 return Target->getHalfFormat();
1488 case BuiltinType::Float: return Target->getFloatFormat();
1489 case BuiltinType::Double: return Target->getDoubleFormat();
1490 case BuiltinType::LongDouble: return Target->getLongDoubleFormat();
1491 case BuiltinType::Float128: return Target->getFloat128Format();
1492 }
1493}
1494
1495CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
1496 unsigned Align = Target->getCharWidth();
1497
1498 bool UseAlignAttrOnly = false;
1499 if (unsigned AlignFromAttr = D->getMaxAlignment()) {
1500 Align = AlignFromAttr;
1501
1502 // __attribute__((aligned)) can increase or decrease alignment
1503 // *except* on a struct or struct member, where it only increases
1504 // alignment unless 'packed' is also specified.
1505 //
1506 // It is an error for alignas to decrease alignment, so we can
1507 // ignore that possibility; Sema should diagnose it.
1508 if (isa<FieldDecl>(D)) {
1509 UseAlignAttrOnly = D->hasAttr<PackedAttr>() ||
1510 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1511 } else {
1512 UseAlignAttrOnly = true;
1513 }
1514 }
1515 else if (isa<FieldDecl>(D))
1516 UseAlignAttrOnly =
1517 D->hasAttr<PackedAttr>() ||
1518 cast<FieldDecl>(D)->getParent()->hasAttr<PackedAttr>();
1519
1520 // If we're using the align attribute only, just ignore everything
1521 // else about the declaration and its type.
1522 if (UseAlignAttrOnly) {
1523 // do nothing
1524 } else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
1525 QualType T = VD->getType();
1526 if (const auto *RT = T->getAs<ReferenceType>()) {
1527 if (ForAlignof)
1528 T = RT->getPointeeType();
1529 else
1530 T = getPointerType(RT->getPointeeType());
1531 }
1532 QualType BaseT = getBaseElementType(T);
1533 if (T->isFunctionType())
1534 Align = getTypeInfoImpl(T.getTypePtr()).Align;
1535 else if (!BaseT->isIncompleteType()) {
1536 // Adjust alignments of declarations with array type by the
1537 // large-array alignment on the target.
1538 if (const ArrayType *arrayType = getAsArrayType(T)) {
1539 unsigned MinWidth = Target->getLargeArrayMinWidth();
1540 if (!ForAlignof && MinWidth) {
1541 if (isa<VariableArrayType>(arrayType))
1542 Align = std::max(Align, Target->getLargeArrayAlign());
1543 else if (isa<ConstantArrayType>(arrayType) &&
1544 MinWidth <= getTypeSize(cast<ConstantArrayType>(arrayType)))
1545 Align = std::max(Align, Target->getLargeArrayAlign());
1546 }
1547 }
1548 Align = std::max(Align, getPreferredTypeAlign(T.getTypePtr()));
1549 if (BaseT.getQualifiers().hasUnaligned())
1550 Align = Target->getCharWidth();
1551 if (const auto *VD = dyn_cast<VarDecl>(D)) {
1552 if (VD->hasGlobalStorage() && !ForAlignof)
1553 Align = std::max(Align, getTargetInfo().getMinGlobalAlign());
1554 }
1555 }
1556
1557 // Fields can be subject to extra alignment constraints, like if
1558 // the field is packed, the struct is packed, or the struct has a
1559 // a max-field-alignment constraint (#pragma pack). So calculate
1560 // the actual alignment of the field within the struct, and then
1561 // (as we're expected to) constrain that by the alignment of the type.
1562 if (const auto *Field = dyn_cast<FieldDecl>(VD)) {
1563 const RecordDecl *Parent = Field->getParent();
1564 // We can only produce a sensible answer if the record is valid.
1565 if (!Parent->isInvalidDecl()) {
1566 const ASTRecordLayout &Layout = getASTRecordLayout(Parent);
1567
1568 // Start with the record's overall alignment.
1569 unsigned FieldAlign = toBits(Layout.getAlignment());
1570
1571 // Use the GCD of that and the offset within the record.
1572 uint64_t Offset = Layout.getFieldOffset(Field->getFieldIndex());
1573 if (Offset > 0) {
1574 // Alignment is always a power of 2, so the GCD will be a power of 2,
1575 // which means we get to do this crazy thing instead of Euclid's.
1576 uint64_t LowBitOfOffset = Offset & (~Offset + 1);
1577 if (LowBitOfOffset < FieldAlign)
1578 FieldAlign = static_cast<unsigned>(LowBitOfOffset);
1579 }
1580
1581 Align = std::min(Align, FieldAlign);
1582 }
1583 }
1584 }
1585
1586 return toCharUnitsFromBits(Align);
1587}
1588
1589// getTypeInfoDataSizeInChars - Return the size of a type, in
1590// chars. If the type is a record, its data size is returned. This is
1591// the size of the memcpy that's performed when assigning this type
1592// using a trivial copy/move assignment operator.
1593std::pair<CharUnits, CharUnits>
1594ASTContext::getTypeInfoDataSizeInChars(QualType T) const {
1595 std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T);
1596
1597 // In C++, objects can sometimes be allocated into the tail padding
1598 // of a base-class subobject. We decide whether that's possible
1599 // during class layout, so here we can just trust the layout results.
1600 if (getLangOpts().CPlusPlus) {
1601 if (const auto *RT = T->getAs<RecordType>()) {
1602 const ASTRecordLayout &layout = getASTRecordLayout(RT->getDecl());
1603 sizeAndAlign.first = layout.getDataSize();
1604 }
1605 }
1606
1607 return sizeAndAlign;
1608}
1609
1610/// getConstantArrayInfoInChars - Performing the computation in CharUnits
1611/// instead of in bits prevents overflowing the uint64_t for some large arrays.
1612std::pair<CharUnits, CharUnits>
1613static getConstantArrayInfoInChars(const ASTContext &Context,
1614 const ConstantArrayType *CAT) {
1615 std::pair<CharUnits, CharUnits> EltInfo =
1616 Context.getTypeInfoInChars(CAT->getElementType());
1617 uint64_t Size = CAT->getSize().getZExtValue();
1618 assert((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <=(((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity
()) <= (uint64_t)(-1)/Size) && "Overflow in array type char size evaluation"
) ? static_cast<void> (0) : __assert_fail ("(Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <= (uint64_t)(-1)/Size) && \"Overflow in array type char size evaluation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1620, __PRETTY_FUNCTION__))
1619 (uint64_t)(-1)/Size) &&(((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity
()) <= (uint64_t)(-1)/Size) && "Overflow in array type char size evaluation"
) ? static_cast<void> (0) : __assert_fail ("(Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <= (uint64_t)(-1)/Size) && \"Overflow in array type char size evaluation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1620, __PRETTY_FUNCTION__))
1620 "Overflow in array type char size evaluation")(((Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity
()) <= (uint64_t)(-1)/Size) && "Overflow in array type char size evaluation"
) ? static_cast<void> (0) : __assert_fail ("(Size == 0 || static_cast<uint64_t>(EltInfo.first.getQuantity()) <= (uint64_t)(-1)/Size) && \"Overflow in array type char size evaluation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1620, __PRETTY_FUNCTION__))
;
1621 uint64_t Width = EltInfo.first.getQuantity() * Size;
1622 unsigned Align = EltInfo.second.getQuantity();
1623 if (!Context.getTargetInfo().getCXXABI().isMicrosoft() ||
1624 Context.getTargetInfo().getPointerWidth(0) == 64)
1625 Width = llvm::alignTo(Width, Align);
1626 return std::make_pair(CharUnits::fromQuantity(Width),
1627 CharUnits::fromQuantity(Align));
1628}
1629
1630std::pair<CharUnits, CharUnits>
1631ASTContext::getTypeInfoInChars(const Type *T) const {
1632 if (const auto *CAT = dyn_cast<ConstantArrayType>(T))
1633 return getConstantArrayInfoInChars(*this, CAT);
1634 TypeInfo Info = getTypeInfo(T);
1635 return std::make_pair(toCharUnitsFromBits(Info.Width),
1636 toCharUnitsFromBits(Info.Align));
1637}
1638
1639std::pair<CharUnits, CharUnits>
1640ASTContext::getTypeInfoInChars(QualType T) const {
1641 return getTypeInfoInChars(T.getTypePtr());
1642}
1643
1644bool ASTContext::isAlignmentRequired(const Type *T) const {
1645 return getTypeInfo(T).AlignIsRequired;
1646}
1647
1648bool ASTContext::isAlignmentRequired(QualType T) const {
1649 return isAlignmentRequired(T.getTypePtr());
1650}
1651
1652unsigned ASTContext::getTypeAlignIfKnown(QualType T) const {
1653 // An alignment on a typedef overrides anything else.
1654 if (const auto *TT = T->getAs<TypedefType>())
1655 if (unsigned Align = TT->getDecl()->getMaxAlignment())
1656 return Align;
1657
1658 // If we have an (array of) complete type, we're done.
1659 T = getBaseElementType(T);
1660 if (!T->isIncompleteType())
1661 return getTypeAlign(T);
1662
1663 // If we had an array type, its element type might be a typedef
1664 // type with an alignment attribute.
1665 if (const auto *TT = T->getAs<TypedefType>())
1666 if (unsigned Align = TT->getDecl()->getMaxAlignment())
1667 return Align;
1668
1669 // Otherwise, see if the declaration of the type had an attribute.
1670 if (const auto *TT = T->getAs<TagType>())
1671 return TT->getDecl()->getMaxAlignment();
1672
1673 return 0;
1674}
1675
1676TypeInfo ASTContext::getTypeInfo(const Type *T) const {
1677 TypeInfoMap::iterator I = MemoizedTypeInfo.find(T);
1678 if (I != MemoizedTypeInfo.end())
1679 return I->second;
1680
1681 // This call can invalidate MemoizedTypeInfo[T], so we need a second lookup.
1682 TypeInfo TI = getTypeInfoImpl(T);
1683 MemoizedTypeInfo[T] = TI;
1684 return TI;
1685}
1686
1687/// getTypeInfoImpl - Return the size of the specified type, in bits. This
1688/// method does not work on incomplete types.
1689///
1690/// FIXME: Pointers into different addr spaces could have different sizes and
1691/// alignment requirements: getPointerInfo should take an AddrSpace, this
1692/// should take a QualType, &c.
1693TypeInfo ASTContext::getTypeInfoImpl(const Type *T) const {
1694 uint64_t Width = 0;
1695 unsigned Align = 8;
1696 bool AlignIsRequired = false;
1697 unsigned AS = 0;
1698 switch (T->getTypeClass()) {
1699#define TYPE(Class, Base)
1700#define ABSTRACT_TYPE(Class, Base)
1701#define NON_CANONICAL_TYPE(Class, Base)
1702#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1703#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) \
1704 case Type::Class: \
1705 assert(!T->isDependentType() && "should not see dependent types here")((!T->isDependentType() && "should not see dependent types here"
) ? static_cast<void> (0) : __assert_fail ("!T->isDependentType() && \"should not see dependent types here\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1705, __PRETTY_FUNCTION__))
; \
1706 return getTypeInfo(cast<Class##Type>(T)->desugar().getTypePtr());
1707#include "clang/AST/TypeNodes.def"
1708 llvm_unreachable("Should not see dependent types")::llvm::llvm_unreachable_internal("Should not see dependent types"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1708)
;
1709
1710 case Type::FunctionNoProto:
1711 case Type::FunctionProto:
1712 // GCC extension: alignof(function) = 32 bits
1713 Width = 0;
1714 Align = 32;
1715 break;
1716
1717 case Type::IncompleteArray:
1718 case Type::VariableArray:
1719 Width = 0;
1720 Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
1721 break;
1722
1723 case Type::ConstantArray: {
1724 const auto *CAT = cast<ConstantArrayType>(T);
1725
1726 TypeInfo EltInfo = getTypeInfo(CAT->getElementType());
1727 uint64_t Size = CAT->getSize().getZExtValue();
1728 assert((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&(((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&
"Overflow in array type bit size evaluation") ? static_cast<
void> (0) : __assert_fail ("(Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) && \"Overflow in array type bit size evaluation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1729, __PRETTY_FUNCTION__))
1729 "Overflow in array type bit size evaluation")(((Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) &&
"Overflow in array type bit size evaluation") ? static_cast<
void> (0) : __assert_fail ("(Size == 0 || EltInfo.Width <= (uint64_t)(-1) / Size) && \"Overflow in array type bit size evaluation\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1729, __PRETTY_FUNCTION__))
;
1730 Width = EltInfo.Width * Size;
1731 Align = EltInfo.Align;
1732 if (!getTargetInfo().getCXXABI().isMicrosoft() ||
1733 getTargetInfo().getPointerWidth(0) == 64)
1734 Width = llvm::alignTo(Width, Align);
1735 break;
1736 }
1737 case Type::ExtVector:
1738 case Type::Vector: {
1739 const auto *VT = cast<VectorType>(T);
1740 TypeInfo EltInfo = getTypeInfo(VT->getElementType());
1741 Width = EltInfo.Width * VT->getNumElements();
1742 Align = Width;
1743 // If the alignment is not a power of 2, round up to the next power of 2.
1744 // This happens for non-power-of-2 length vectors.
1745 if (Align & (Align-1)) {
1746 Align = llvm::NextPowerOf2(Align);
1747 Width = llvm::alignTo(Width, Align);
1748 }
1749 // Adjust the alignment based on the target max.
1750 uint64_t TargetVectorAlign = Target->getMaxVectorAlign();
1751 if (TargetVectorAlign && TargetVectorAlign < Align)
1752 Align = TargetVectorAlign;
1753 break;
1754 }
1755
1756 case Type::Builtin:
1757 switch (cast<BuiltinType>(T)->getKind()) {
1758 default: llvm_unreachable("Unknown builtin type!")::llvm::llvm_unreachable_internal("Unknown builtin type!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1758)
;
1759 case BuiltinType::Void:
1760 // GCC extension: alignof(void) = 8 bits.
1761 Width = 0;
1762 Align = 8;
1763 break;
1764 case BuiltinType::Bool:
1765 Width = Target->getBoolWidth();
1766 Align = Target->getBoolAlign();
1767 break;
1768 case BuiltinType::Char_S:
1769 case BuiltinType::Char_U:
1770 case BuiltinType::UChar:
1771 case BuiltinType::SChar:
1772 case BuiltinType::Char8:
1773 Width = Target->getCharWidth();
1774 Align = Target->getCharAlign();
1775 break;
1776 case BuiltinType::WChar_S:
1777 case BuiltinType::WChar_U:
1778 Width = Target->getWCharWidth();
1779 Align = Target->getWCharAlign();
1780 break;
1781 case BuiltinType::Char16:
1782 Width = Target->getChar16Width();
1783 Align = Target->getChar16Align();
1784 break;
1785 case BuiltinType::Char32:
1786 Width = Target->getChar32Width();
1787 Align = Target->getChar32Align();
1788 break;
1789 case BuiltinType::UShort:
1790 case BuiltinType::Short:
1791 Width = Target->getShortWidth();
1792 Align = Target->getShortAlign();
1793 break;
1794 case BuiltinType::UInt:
1795 case BuiltinType::Int:
1796 Width = Target->getIntWidth();
1797 Align = Target->getIntAlign();
1798 break;
1799 case BuiltinType::ULong:
1800 case BuiltinType::Long:
1801 Width = Target->getLongWidth();
1802 Align = Target->getLongAlign();
1803 break;
1804 case BuiltinType::ULongLong:
1805 case BuiltinType::LongLong:
1806 Width = Target->getLongLongWidth();
1807 Align = Target->getLongLongAlign();
1808 break;
1809 case BuiltinType::Int128:
1810 case BuiltinType::UInt128:
1811 Width = 128;
1812 Align = 128; // int128_t is 128-bit aligned on all targets.
1813 break;
1814 case BuiltinType::ShortAccum:
1815 case BuiltinType::UShortAccum:
1816 case BuiltinType::SatShortAccum:
1817 case BuiltinType::SatUShortAccum:
1818 Width = Target->getShortAccumWidth();
1819 Align = Target->getShortAccumAlign();
1820 break;
1821 case BuiltinType::Accum:
1822 case BuiltinType::UAccum:
1823 case BuiltinType::SatAccum:
1824 case BuiltinType::SatUAccum:
1825 Width = Target->getAccumWidth();
1826 Align = Target->getAccumAlign();
1827 break;
1828 case BuiltinType::LongAccum:
1829 case BuiltinType::ULongAccum:
1830 case BuiltinType::SatLongAccum:
1831 case BuiltinType::SatULongAccum:
1832 Width = Target->getLongAccumWidth();
1833 Align = Target->getLongAccumAlign();
1834 break;
1835 case BuiltinType::ShortFract:
1836 case BuiltinType::UShortFract:
1837 case BuiltinType::SatShortFract:
1838 case BuiltinType::SatUShortFract:
1839 Width = Target->getShortFractWidth();
1840 Align = Target->getShortFractAlign();
1841 break;
1842 case BuiltinType::Fract:
1843 case BuiltinType::UFract:
1844 case BuiltinType::SatFract:
1845 case BuiltinType::SatUFract:
1846 Width = Target->getFractWidth();
1847 Align = Target->getFractAlign();
1848 break;
1849 case BuiltinType::LongFract:
1850 case BuiltinType::ULongFract:
1851 case BuiltinType::SatLongFract:
1852 case BuiltinType::SatULongFract:
1853 Width = Target->getLongFractWidth();
1854 Align = Target->getLongFractAlign();
1855 break;
1856 case BuiltinType::Float16:
1857 case BuiltinType::Half:
1858 Width = Target->getHalfWidth();
1859 Align = Target->getHalfAlign();
1860 break;
1861 case BuiltinType::Float:
1862 Width = Target->getFloatWidth();
1863 Align = Target->getFloatAlign();
1864 break;
1865 case BuiltinType::Double:
1866 Width = Target->getDoubleWidth();
1867 Align = Target->getDoubleAlign();
1868 break;
1869 case BuiltinType::LongDouble:
1870 Width = Target->getLongDoubleWidth();
1871 Align = Target->getLongDoubleAlign();
1872 break;
1873 case BuiltinType::Float128:
1874 Width = Target->getFloat128Width();
1875 Align = Target->getFloat128Align();
1876 break;
1877 case BuiltinType::NullPtr:
1878 Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
1879 Align = Target->getPointerAlign(0); // == sizeof(void*)
1880 break;
1881 case BuiltinType::ObjCId:
1882 case BuiltinType::ObjCClass:
1883 case BuiltinType::ObjCSel:
1884 Width = Target->getPointerWidth(0);
1885 Align = Target->getPointerAlign(0);
1886 break;
1887 case BuiltinType::OCLSampler:
1888 case BuiltinType::OCLEvent:
1889 case BuiltinType::OCLClkEvent:
1890 case BuiltinType::OCLQueue:
1891 case BuiltinType::OCLReserveID:
1892#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
1893 case BuiltinType::Id:
1894#include "clang/Basic/OpenCLImageTypes.def"
1895 AS = getTargetAddressSpace(
1896 Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T)));
1897 Width = Target->getPointerWidth(AS);
1898 Align = Target->getPointerAlign(AS);
1899 break;
1900 }
1901 break;
1902 case Type::ObjCObjectPointer:
1903 Width = Target->getPointerWidth(0);
1904 Align = Target->getPointerAlign(0);
1905 break;
1906 case Type::BlockPointer:
1907 AS = getTargetAddressSpace(cast<BlockPointerType>(T)->getPointeeType());
1908 Width = Target->getPointerWidth(AS);
1909 Align = Target->getPointerAlign(AS);
1910 break;
1911 case Type::LValueReference:
1912 case Type::RValueReference:
1913 // alignof and sizeof should never enter this code path here, so we go
1914 // the pointer route.
1915 AS = getTargetAddressSpace(cast<ReferenceType>(T)->getPointeeType());
1916 Width = Target->getPointerWidth(AS);
1917 Align = Target->getPointerAlign(AS);
1918 break;
1919 case Type::Pointer:
1920 AS = getTargetAddressSpace(cast<PointerType>(T)->getPointeeType());
1921 Width = Target->getPointerWidth(AS);
1922 Align = Target->getPointerAlign(AS);
1923 break;
1924 case Type::MemberPointer: {
1925 const auto *MPT = cast<MemberPointerType>(T);
1926 CXXABI::MemberPointerInfo MPI = ABI->getMemberPointerInfo(MPT);
1927 Width = MPI.Width;
1928 Align = MPI.Align;
1929 break;
1930 }
1931 case Type::Complex: {
1932 // Complex types have the same alignment as their elements, but twice the
1933 // size.
1934 TypeInfo EltInfo = getTypeInfo(cast<ComplexType>(T)->getElementType());
1935 Width = EltInfo.Width * 2;
1936 Align = EltInfo.Align;
1937 break;
1938 }
1939 case Type::ObjCObject:
1940 return getTypeInfo(cast<ObjCObjectType>(T)->getBaseType().getTypePtr());
1941 case Type::Adjusted:
1942 case Type::Decayed:
1943 return getTypeInfo(cast<AdjustedType>(T)->getAdjustedType().getTypePtr());
1944 case Type::ObjCInterface: {
1945 const auto *ObjCI = cast<ObjCInterfaceType>(T);
1946 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
1947 Width = toBits(Layout.getSize());
1948 Align = toBits(Layout.getAlignment());
1949 break;
1950 }
1951 case Type::Record:
1952 case Type::Enum: {
1953 const auto *TT = cast<TagType>(T);
1954
1955 if (TT->getDecl()->isInvalidDecl()) {
1956 Width = 8;
1957 Align = 8;
1958 break;
1959 }
1960
1961 if (const auto *ET = dyn_cast<EnumType>(TT)) {
1962 const EnumDecl *ED = ET->getDecl();
1963 TypeInfo Info =
1964 getTypeInfo(ED->getIntegerType()->getUnqualifiedDesugaredType());
1965 if (unsigned AttrAlign = ED->getMaxAlignment()) {
1966 Info.Align = AttrAlign;
1967 Info.AlignIsRequired = true;
1968 }
1969 return Info;
1970 }
1971
1972 const auto *RT = cast<RecordType>(TT);
1973 const RecordDecl *RD = RT->getDecl();
1974 const ASTRecordLayout &Layout = getASTRecordLayout(RD);
1975 Width = toBits(Layout.getSize());
1976 Align = toBits(Layout.getAlignment());
1977 AlignIsRequired = RD->hasAttr<AlignedAttr>();
1978 break;
1979 }
1980
1981 case Type::SubstTemplateTypeParm:
1982 return getTypeInfo(cast<SubstTemplateTypeParmType>(T)->
1983 getReplacementType().getTypePtr());
1984
1985 case Type::Auto:
1986 case Type::DeducedTemplateSpecialization: {
1987 const auto *A = cast<DeducedType>(T);
1988 assert(!A->getDeducedType().isNull() &&((!A->getDeducedType().isNull() && "cannot request the size of an undeduced or dependent auto type"
) ? static_cast<void> (0) : __assert_fail ("!A->getDeducedType().isNull() && \"cannot request the size of an undeduced or dependent auto type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1989, __PRETTY_FUNCTION__))
1989 "cannot request the size of an undeduced or dependent auto type")((!A->getDeducedType().isNull() && "cannot request the size of an undeduced or dependent auto type"
) ? static_cast<void> (0) : __assert_fail ("!A->getDeducedType().isNull() && \"cannot request the size of an undeduced or dependent auto type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 1989, __PRETTY_FUNCTION__))
;
1990 return getTypeInfo(A->getDeducedType().getTypePtr());
1991 }
1992
1993 case Type::Paren:
1994 return getTypeInfo(cast<ParenType>(T)->getInnerType().getTypePtr());
1995
1996 case Type::ObjCTypeParam:
1997 return getTypeInfo(cast<ObjCTypeParamType>(T)->desugar().getTypePtr());
1998
1999 case Type::Typedef: {
2000 const TypedefNameDecl *Typedef = cast<TypedefType>(T)->getDecl();
2001 TypeInfo Info = getTypeInfo(Typedef->getUnderlyingType().getTypePtr());
2002 // If the typedef has an aligned attribute on it, it overrides any computed
2003 // alignment we have. This violates the GCC documentation (which says that
2004 // attribute(aligned) can only round up) but matches its implementation.
2005 if (unsigned AttrAlign = Typedef->getMaxAlignment()) {
2006 Align = AttrAlign;
2007 AlignIsRequired = true;
2008 } else {
2009 Align = Info.Align;
2010 AlignIsRequired = Info.AlignIsRequired;
2011 }
2012 Width = Info.Width;
2013 break;
2014 }
2015
2016 case Type::Elaborated:
2017 return getTypeInfo(cast<ElaboratedType>(T)->getNamedType().getTypePtr());
2018
2019 case Type::Attributed:
2020 return getTypeInfo(
2021 cast<AttributedType>(T)->getEquivalentType().getTypePtr());
2022
2023 case Type::Atomic: {
2024 // Start with the base type information.
2025 TypeInfo Info = getTypeInfo(cast<AtomicType>(T)->getValueType());
2026 Width = Info.Width;
2027 Align = Info.Align;
2028
2029 if (!Width) {
2030 // An otherwise zero-sized type should still generate an
2031 // atomic operation.
2032 Width = Target->getCharWidth();
2033 assert(Align)((Align) ? static_cast<void> (0) : __assert_fail ("Align"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2033, __PRETTY_FUNCTION__))
;
2034 } else if (Width <= Target->getMaxAtomicPromoteWidth()) {
2035 // If the size of the type doesn't exceed the platform's max
2036 // atomic promotion width, make the size and alignment more
2037 // favorable to atomic operations:
2038
2039 // Round the size up to a power of 2.
2040 if (!llvm::isPowerOf2_64(Width))
2041 Width = llvm::NextPowerOf2(Width);
2042
2043 // Set the alignment equal to the size.
2044 Align = static_cast<unsigned>(Width);
2045 }
2046 }
2047 break;
2048
2049 case Type::Pipe:
2050 Width = Target->getPointerWidth(getTargetAddressSpace(LangAS::opencl_global));
2051 Align = Target->getPointerAlign(getTargetAddressSpace(LangAS::opencl_global));
2052 break;
2053 }
2054
2055 assert(llvm::isPowerOf2_32(Align) && "Alignment must be power of 2")((llvm::isPowerOf2_32(Align) && "Alignment must be power of 2"
) ? static_cast<void> (0) : __assert_fail ("llvm::isPowerOf2_32(Align) && \"Alignment must be power of 2\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2055, __PRETTY_FUNCTION__))
;
2056 return TypeInfo(Width, Align, AlignIsRequired);
2057}
2058
2059unsigned ASTContext::getTypeUnadjustedAlign(const Type *T) const {
2060 UnadjustedAlignMap::iterator I = MemoizedUnadjustedAlign.find(T);
2061 if (I != MemoizedUnadjustedAlign.end())
2062 return I->second;
2063
2064 unsigned UnadjustedAlign;
2065 if (const auto *RT = T->getAs<RecordType>()) {
2066 const RecordDecl *RD = RT->getDecl();
2067 const ASTRecordLayout &Layout = getASTRecordLayout(RD);
2068 UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
2069 } else if (const auto *ObjCI = T->getAs<ObjCInterfaceType>()) {
2070 const ASTRecordLayout &Layout = getASTObjCInterfaceLayout(ObjCI->getDecl());
2071 UnadjustedAlign = toBits(Layout.getUnadjustedAlignment());
2072 } else {
2073 UnadjustedAlign = getTypeAlign(T);
2074 }
2075
2076 MemoizedUnadjustedAlign[T] = UnadjustedAlign;
2077 return UnadjustedAlign;
2078}
2079
2080unsigned ASTContext::getOpenMPDefaultSimdAlign(QualType T) const {
2081 unsigned SimdAlign = getTargetInfo().getSimdDefaultAlign();
2082 // Target ppc64 with QPX: simd default alignment for pointer to double is 32.
2083 if ((getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64 ||
2084 getTargetInfo().getTriple().getArch() == llvm::Triple::ppc64le) &&
2085 getTargetInfo().getABI() == "elfv1-qpx" &&
2086 T->isSpecificBuiltinType(BuiltinType::Double))
2087 SimdAlign = 256;
2088 return SimdAlign;
2089}
2090
2091/// toCharUnitsFromBits - Convert a size in bits to a size in characters.
2092CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const {
2093 return CharUnits::fromQuantity(BitSize / getCharWidth());
2094}
2095
2096/// toBits - Convert a size in characters to a size in characters.
2097int64_t ASTContext::toBits(CharUnits CharSize) const {
2098 return CharSize.getQuantity() * getCharWidth();
2099}
2100
2101/// getTypeSizeInChars - Return the size of the specified type, in characters.
2102/// This method does not work on incomplete types.
2103CharUnits ASTContext::getTypeSizeInChars(QualType T) const {
2104 return getTypeInfoInChars(T).first;
2105}
2106CharUnits ASTContext::getTypeSizeInChars(const Type *T) const {
2107 return getTypeInfoInChars(T).first;
2108}
2109
2110/// getTypeAlignInChars - Return the ABI-specified alignment of a type, in
2111/// characters. This method does not work on incomplete types.
2112CharUnits ASTContext::getTypeAlignInChars(QualType T) const {
2113 return toCharUnitsFromBits(getTypeAlign(T));
2114}
2115CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
2116 return toCharUnitsFromBits(getTypeAlign(T));
2117}
2118
2119/// getTypeUnadjustedAlignInChars - Return the ABI-specified alignment of a
2120/// type, in characters, before alignment adustments. This method does
2121/// not work on incomplete types.
2122CharUnits ASTContext::getTypeUnadjustedAlignInChars(QualType T) const {
2123 return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
2124}
2125CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const {
2126 return toCharUnitsFromBits(getTypeUnadjustedAlign(T));
2127}
2128
2129/// getPreferredTypeAlign - Return the "preferred" alignment of the specified
2130/// type for the current target in bits. This can be different than the ABI
2131/// alignment in cases where it is beneficial for performance to overalign
2132/// a data type.
2133unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
2134 TypeInfo TI = getTypeInfo(T);
2135 unsigned ABIAlign = TI.Align;
2136
2137 T = T->getBaseElementTypeUnsafe();
2138
2139 // The preferred alignment of member pointers is that of a pointer.
2140 if (T->isMemberPointerType())
2141 return getPreferredTypeAlign(getPointerDiffType().getTypePtr());
2142
2143 if (!Target->allowsLargerPreferedTypeAlignment())
2144 return ABIAlign;
2145
2146 // Double and long long should be naturally aligned if possible.
2147 if (const auto *CT = T->getAs<ComplexType>())
2148 T = CT->getElementType().getTypePtr();
2149 if (const auto *ET = T->getAs<EnumType>())
2150 T = ET->getDecl()->getIntegerType().getTypePtr();
2151 if (T->isSpecificBuiltinType(BuiltinType::Double) ||
2152 T->isSpecificBuiltinType(BuiltinType::LongLong) ||
2153 T->isSpecificBuiltinType(BuiltinType::ULongLong))
2154 // Don't increase the alignment if an alignment attribute was specified on a
2155 // typedef declaration.
2156 if (!TI.AlignIsRequired)
2157 return std::max(ABIAlign, (unsigned)getTypeSize(T));
2158
2159 return ABIAlign;
2160}
2161
2162/// getTargetDefaultAlignForAttributeAligned - Return the default alignment
2163/// for __attribute__((aligned)) on this target, to be used if no alignment
2164/// value is specified.
2165unsigned ASTContext::getTargetDefaultAlignForAttributeAligned() const {
2166 return getTargetInfo().getDefaultAlignForAttributeAligned();
2167}
2168
2169/// getAlignOfGlobalVar - Return the alignment in bits that should be given
2170/// to a global variable of the specified type.
2171unsigned ASTContext::getAlignOfGlobalVar(QualType T) const {
2172 return std::max(getTypeAlign(T), getTargetInfo().getMinGlobalAlign());
2173}
2174
2175/// getAlignOfGlobalVarInChars - Return the alignment in characters that
2176/// should be given to a global variable of the specified type.
2177CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T) const {
2178 return toCharUnitsFromBits(getAlignOfGlobalVar(T));
2179}
2180
2181CharUnits ASTContext::getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const {
2182 CharUnits Offset = CharUnits::Zero();
2183 const ASTRecordLayout *Layout = &getASTRecordLayout(RD);
2184 while (const CXXRecordDecl *Base = Layout->getBaseSharingVBPtr()) {
2185 Offset += Layout->getBaseClassOffset(Base);
2186 Layout = &getASTRecordLayout(Base);
2187 }
2188 return Offset;
2189}
2190
2191/// DeepCollectObjCIvars -
2192/// This routine first collects all declared, but not synthesized, ivars in
2193/// super class and then collects all ivars, including those synthesized for
2194/// current class. This routine is used for implementation of current class
2195/// when all ivars, declared and synthesized are known.
2196void ASTContext::DeepCollectObjCIvars(const ObjCInterfaceDecl *OI,
2197 bool leafClass,
2198 SmallVectorImpl<const ObjCIvarDecl*> &Ivars) const {
2199 if (const ObjCInterfaceDecl *SuperClass = OI->getSuperClass())
2200 DeepCollectObjCIvars(SuperClass, false, Ivars);
2201 if (!leafClass) {
2202 for (const auto *I : OI->ivars())
2203 Ivars.push_back(I);
2204 } else {
2205 auto *IDecl = const_cast<ObjCInterfaceDecl *>(OI);
2206 for (const ObjCIvarDecl *Iv = IDecl->all_declared_ivar_begin(); Iv;
2207 Iv= Iv->getNextIvar())
2208 Ivars.push_back(Iv);
2209 }
2210}
2211
2212/// CollectInheritedProtocols - Collect all protocols in current class and
2213/// those inherited by it.
2214void ASTContext::CollectInheritedProtocols(const Decl *CDecl,
2215 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> &Protocols) {
2216 if (const auto *OI = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
2217 // We can use protocol_iterator here instead of
2218 // all_referenced_protocol_iterator since we are walking all categories.
2219 for (auto *Proto : OI->all_referenced_protocols()) {
2220 CollectInheritedProtocols(Proto, Protocols);
2221 }
2222
2223 // Categories of this Interface.
2224 for (const auto *Cat : OI->visible_categories())
2225 CollectInheritedProtocols(Cat, Protocols);
2226
2227 if (ObjCInterfaceDecl *SD = OI->getSuperClass())
2228 while (SD) {
2229 CollectInheritedProtocols(SD, Protocols);
2230 SD = SD->getSuperClass();
2231 }
2232 } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(CDecl)) {
2233 for (auto *Proto : OC->protocols()) {
2234 CollectInheritedProtocols(Proto, Protocols);
2235 }
2236 } else if (const auto *OP = dyn_cast<ObjCProtocolDecl>(CDecl)) {
2237 // Insert the protocol.
2238 if (!Protocols.insert(
2239 const_cast<ObjCProtocolDecl *>(OP->getCanonicalDecl())).second)
2240 return;
2241
2242 for (auto *Proto : OP->protocols())
2243 CollectInheritedProtocols(Proto, Protocols);
2244 }
2245}
2246
2247static bool unionHasUniqueObjectRepresentations(const ASTContext &Context,
2248 const RecordDecl *RD) {
2249 assert(RD->isUnion() && "Must be union type")((RD->isUnion() && "Must be union type") ? static_cast
<void> (0) : __assert_fail ("RD->isUnion() && \"Must be union type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2249, __PRETTY_FUNCTION__))
;
2250 CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());
2251
2252 for (const auto *Field : RD->fields()) {
2253 if (!Context.hasUniqueObjectRepresentations(Field->getType()))
2254 return false;
2255 CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
2256 if (FieldSize != UnionSize)
2257 return false;
2258 }
2259 return !RD->field_empty();
2260}
2261
2262static bool isStructEmpty(QualType Ty) {
2263 const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();
2264
2265 if (!RD->field_empty())
2266 return false;
2267
2268 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD))
2269 return ClassDecl->isEmpty();
2270
2271 return true;
2272}
2273
2274static llvm::Optional<int64_t>
2275structHasUniqueObjectRepresentations(const ASTContext &Context,
2276 const RecordDecl *RD) {
2277 assert(!RD->isUnion() && "Must be struct/class type")((!RD->isUnion() && "Must be struct/class type") ?
static_cast<void> (0) : __assert_fail ("!RD->isUnion() && \"Must be struct/class type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2277, __PRETTY_FUNCTION__))
;
2278 const auto &Layout = Context.getASTRecordLayout(RD);
2279
2280 int64_t CurOffsetInBits = 0;
2281 if (const auto *ClassDecl = dyn_cast<CXXRecordDecl>(RD)) {
2282 if (ClassDecl->isDynamicClass())
2283 return llvm::None;
2284
2285 SmallVector<std::pair<QualType, int64_t>, 4> Bases;
2286 for (const auto Base : ClassDecl->bases()) {
2287 // Empty types can be inherited from, and non-empty types can potentially
2288 // have tail padding, so just make sure there isn't an error.
2289 if (!isStructEmpty(Base.getType())) {
2290 llvm::Optional<int64_t> Size = structHasUniqueObjectRepresentations(
2291 Context, Base.getType()->getAs<RecordType>()->getDecl());
2292 if (!Size)
2293 return llvm::None;
2294 Bases.emplace_back(Base.getType(), Size.getValue());
2295 }
2296 }
2297
2298 llvm::sort(Bases, [&](const std::pair<QualType, int64_t> &L,
2299 const std::pair<QualType, int64_t> &R) {
2300 return Layout.getBaseClassOffset(L.first->getAsCXXRecordDecl()) <
2301 Layout.getBaseClassOffset(R.first->getAsCXXRecordDecl());
2302 });
2303
2304 for (const auto Base : Bases) {
2305 int64_t BaseOffset = Context.toBits(
2306 Layout.getBaseClassOffset(Base.first->getAsCXXRecordDecl()));
2307 int64_t BaseSize = Base.second;
2308 if (BaseOffset != CurOffsetInBits)
2309 return llvm::None;
2310 CurOffsetInBits = BaseOffset + BaseSize;
2311 }
2312 }
2313
2314 for (const auto *Field : RD->fields()) {
2315 if (!Field->getType()->isReferenceType() &&
2316 !Context.hasUniqueObjectRepresentations(Field->getType()))
2317 return llvm::None;
2318
2319 int64_t FieldSizeInBits =
2320 Context.toBits(Context.getTypeSizeInChars(Field->getType()));
2321 if (Field->isBitField()) {
2322 int64_t BitfieldSize = Field->getBitWidthValue(Context);
2323
2324 if (BitfieldSize > FieldSizeInBits)
2325 return llvm::None;
2326 FieldSizeInBits = BitfieldSize;
2327 }
2328
2329 int64_t FieldOffsetInBits = Context.getFieldOffset(Field);
2330
2331 if (FieldOffsetInBits != CurOffsetInBits)
2332 return llvm::None;
2333
2334 CurOffsetInBits = FieldSizeInBits + FieldOffsetInBits;
2335 }
2336
2337 return CurOffsetInBits;
2338}
2339
2340bool ASTContext::hasUniqueObjectRepresentations(QualType Ty) const {
2341 // C++17 [meta.unary.prop]:
2342 // The predicate condition for a template specialization
2343 // has_unique_object_representations<T> shall be
2344 // satisfied if and only if:
2345 // (9.1) - T is trivially copyable, and
2346 // (9.2) - any two objects of type T with the same value have the same
2347 // object representation, where two objects
2348 // of array or non-union class type are considered to have the same value
2349 // if their respective sequences of
2350 // direct subobjects have the same values, and two objects of union type
2351 // are considered to have the same
2352 // value if they have the same active member and the corresponding members
2353 // have the same value.
2354 // The set of scalar types for which this condition holds is
2355 // implementation-defined. [ Note: If a type has padding
2356 // bits, the condition does not hold; otherwise, the condition holds true
2357 // for unsigned integral types. -- end note ]
2358 assert(!Ty.isNull() && "Null QualType sent to unique object rep check")((!Ty.isNull() && "Null QualType sent to unique object rep check"
) ? static_cast<void> (0) : __assert_fail ("!Ty.isNull() && \"Null QualType sent to unique object rep check\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2358, __PRETTY_FUNCTION__))
;
2359
2360 // Arrays are unique only if their element type is unique.
2361 if (Ty->isArrayType())
2362 return hasUniqueObjectRepresentations(getBaseElementType(Ty));
2363
2364 // (9.1) - T is trivially copyable...
2365 if (!Ty.isTriviallyCopyableType(*this))
2366 return false;
2367
2368 // All integrals and enums are unique.
2369 if (Ty->isIntegralOrEnumerationType())
2370 return true;
2371
2372 // All other pointers are unique.
2373 if (Ty->isPointerType())
2374 return true;
2375
2376 if (Ty->isMemberPointerType()) {
2377 const auto *MPT = Ty->getAs<MemberPointerType>();
2378 return !ABI->getMemberPointerInfo(MPT).HasPadding;
2379 }
2380
2381 if (Ty->isRecordType()) {
2382 const RecordDecl *Record = Ty->getAs<RecordType>()->getDecl();
2383
2384 if (Record->isInvalidDecl())
2385 return false;
2386
2387 if (Record->isUnion())
2388 return unionHasUniqueObjectRepresentations(*this, Record);
2389
2390 Optional<int64_t> StructSize =
2391 structHasUniqueObjectRepresentations(*this, Record);
2392
2393 return StructSize &&
2394 StructSize.getValue() == static_cast<int64_t>(getTypeSize(Ty));
2395 }
2396
2397 // FIXME: More cases to handle here (list by rsmith):
2398 // vectors (careful about, eg, vector of 3 foo)
2399 // _Complex int and friends
2400 // _Atomic T
2401 // Obj-C block pointers
2402 // Obj-C object pointers
2403 // and perhaps OpenCL's various builtin types (pipe, sampler_t, event_t,
2404 // clk_event_t, queue_t, reserve_id_t)
2405 // There're also Obj-C class types and the Obj-C selector type, but I think it
2406 // makes sense for those to return false here.
2407
2408 return false;
2409}
2410
2411unsigned ASTContext::CountNonClassIvars(const ObjCInterfaceDecl *OI) const {
2412 unsigned count = 0;
2413 // Count ivars declared in class extension.
2414 for (const auto *Ext : OI->known_extensions())
2415 count += Ext->ivar_size();
2416
2417 // Count ivar defined in this class's implementation. This
2418 // includes synthesized ivars.
2419 if (ObjCImplementationDecl *ImplDecl = OI->getImplementation())
2420 count += ImplDecl->ivar_size();
2421
2422 return count;
2423}
2424
2425bool ASTContext::isSentinelNullExpr(const Expr *E) {
2426 if (!E)
2427 return false;
2428
2429 // nullptr_t is always treated as null.
2430 if (E->getType()->isNullPtrType()) return true;
2431
2432 if (E->getType()->isAnyPointerType() &&
2433 E->IgnoreParenCasts()->isNullPointerConstant(*this,
2434 Expr::NPC_ValueDependentIsNull))
2435 return true;
2436
2437 // Unfortunately, __null has type 'int'.
2438 if (isa<GNUNullExpr>(E)) return true;
2439
2440 return false;
2441}
2442
2443/// Get the implementation of ObjCInterfaceDecl, or nullptr if none
2444/// exists.
2445ObjCImplementationDecl *ASTContext::getObjCImplementation(ObjCInterfaceDecl *D) {
2446 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2447 I = ObjCImpls.find(D);
2448 if (I != ObjCImpls.end())
2449 return cast<ObjCImplementationDecl>(I->second);
2450 return nullptr;
2451}
2452
2453/// Get the implementation of ObjCCategoryDecl, or nullptr if none
2454/// exists.
2455ObjCCategoryImplDecl *ASTContext::getObjCImplementation(ObjCCategoryDecl *D) {
2456 llvm::DenseMap<ObjCContainerDecl*, ObjCImplDecl*>::iterator
2457 I = ObjCImpls.find(D);
2458 if (I != ObjCImpls.end())
2459 return cast<ObjCCategoryImplDecl>(I->second);
2460 return nullptr;
2461}
2462
2463/// Set the implementation of ObjCInterfaceDecl.
2464void ASTContext::setObjCImplementation(ObjCInterfaceDecl *IFaceD,
2465 ObjCImplementationDecl *ImplD) {
2466 assert(IFaceD && ImplD && "Passed null params")((IFaceD && ImplD && "Passed null params") ? static_cast
<void> (0) : __assert_fail ("IFaceD && ImplD && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2466, __PRETTY_FUNCTION__))
;
2467 ObjCImpls[IFaceD] = ImplD;
2468}
2469
2470/// Set the implementation of ObjCCategoryDecl.
2471void ASTContext::setObjCImplementation(ObjCCategoryDecl *CatD,
2472 ObjCCategoryImplDecl *ImplD) {
2473 assert(CatD && ImplD && "Passed null params")((CatD && ImplD && "Passed null params") ? static_cast
<void> (0) : __assert_fail ("CatD && ImplD && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2473, __PRETTY_FUNCTION__))
;
2474 ObjCImpls[CatD] = ImplD;
2475}
2476
2477const ObjCMethodDecl *
2478ASTContext::getObjCMethodRedeclaration(const ObjCMethodDecl *MD) const {
2479 return ObjCMethodRedecls.lookup(MD);
2480}
2481
2482void ASTContext::setObjCMethodRedeclaration(const ObjCMethodDecl *MD,
2483 const ObjCMethodDecl *Redecl) {
2484 assert(!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration")((!getObjCMethodRedeclaration(MD) && "MD already has a redeclaration"
) ? static_cast<void> (0) : __assert_fail ("!getObjCMethodRedeclaration(MD) && \"MD already has a redeclaration\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2484, __PRETTY_FUNCTION__))
;
2485 ObjCMethodRedecls[MD] = Redecl;
2486}
2487
2488const ObjCInterfaceDecl *ASTContext::getObjContainingInterface(
2489 const NamedDecl *ND) const {
2490 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND->getDeclContext()))
2491 return ID;
2492 if (const auto *CD = dyn_cast<ObjCCategoryDecl>(ND->getDeclContext()))
2493 return CD->getClassInterface();
2494 if (const auto *IMD = dyn_cast<ObjCImplDecl>(ND->getDeclContext()))
2495 return IMD->getClassInterface();
2496
2497 return nullptr;
2498}
2499
2500/// Get the copy initialization expression of VarDecl, or nullptr if
2501/// none exists.
2502ASTContext::BlockVarCopyInit
2503ASTContext::getBlockVarCopyInit(const VarDecl*VD) const {
2504 assert(VD && "Passed null params")((VD && "Passed null params") ? static_cast<void>
(0) : __assert_fail ("VD && \"Passed null params\"",
"/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2504, __PRETTY_FUNCTION__))
;
2505 assert(VD->hasAttr<BlocksAttr>() &&((VD->hasAttr<BlocksAttr>() && "getBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"getBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2506, __PRETTY_FUNCTION__))
2506 "getBlockVarCopyInits - not __block var")((VD->hasAttr<BlocksAttr>() && "getBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"getBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2506, __PRETTY_FUNCTION__))
;
2507 auto I = BlockVarCopyInits.find(VD);
2508 if (I != BlockVarCopyInits.end())
2509 return I->second;
2510 return {nullptr, false};
2511}
2512
2513/// Set the copy inialization expression of a block var decl.
2514void ASTContext::setBlockVarCopyInit(const VarDecl*VD, Expr *CopyExpr,
2515 bool CanThrow) {
2516 assert(VD && CopyExpr && "Passed null params")((VD && CopyExpr && "Passed null params") ? static_cast
<void> (0) : __assert_fail ("VD && CopyExpr && \"Passed null params\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2516, __PRETTY_FUNCTION__))
;
2517 assert(VD->hasAttr<BlocksAttr>() &&((VD->hasAttr<BlocksAttr>() && "setBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"setBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2518, __PRETTY_FUNCTION__))
2518 "setBlockVarCopyInits - not __block var")((VD->hasAttr<BlocksAttr>() && "setBlockVarCopyInits - not __block var"
) ? static_cast<void> (0) : __assert_fail ("VD->hasAttr<BlocksAttr>() && \"setBlockVarCopyInits - not __block var\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2518, __PRETTY_FUNCTION__))
;
2519 BlockVarCopyInits[VD].setExprAndFlag(CopyExpr, CanThrow);
2520}
2521
2522TypeSourceInfo *ASTContext::CreateTypeSourceInfo(QualType T,
2523 unsigned DataSize) const {
2524 if (!DataSize)
2525 DataSize = TypeLoc::getFullDataSizeForType(T);
2526 else
2527 assert(DataSize == TypeLoc::getFullDataSizeForType(T) &&((DataSize == TypeLoc::getFullDataSizeForType(T) && "incorrect data size provided to CreateTypeSourceInfo!"
) ? static_cast<void> (0) : __assert_fail ("DataSize == TypeLoc::getFullDataSizeForType(T) && \"incorrect data size provided to CreateTypeSourceInfo!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2528, __PRETTY_FUNCTION__))
2528 "incorrect data size provided to CreateTypeSourceInfo!")((DataSize == TypeLoc::getFullDataSizeForType(T) && "incorrect data size provided to CreateTypeSourceInfo!"
) ? static_cast<void> (0) : __assert_fail ("DataSize == TypeLoc::getFullDataSizeForType(T) && \"incorrect data size provided to CreateTypeSourceInfo!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2528, __PRETTY_FUNCTION__))
;
2529
2530 auto *TInfo =
2531 (TypeSourceInfo*)BumpAlloc.Allocate(sizeof(TypeSourceInfo) + DataSize, 8);
2532 new (TInfo) TypeSourceInfo(T);
2533 return TInfo;
2534}
2535
2536TypeSourceInfo *ASTContext::getTrivialTypeSourceInfo(QualType T,
2537 SourceLocation L) const {
2538 TypeSourceInfo *DI = CreateTypeSourceInfo(T);
2539 DI->getTypeLoc().initialize(const_cast<ASTContext &>(*this), L);
2540 return DI;
2541}
2542
2543const ASTRecordLayout &
2544ASTContext::getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const {
2545 return getObjCLayout(D, nullptr);
2546}
2547
2548const ASTRecordLayout &
2549ASTContext::getASTObjCImplementationLayout(
2550 const ObjCImplementationDecl *D) const {
2551 return getObjCLayout(D->getClassInterface(), D);
2552}
2553
2554//===----------------------------------------------------------------------===//
2555// Type creation/memoization methods
2556//===----------------------------------------------------------------------===//
2557
2558QualType
2559ASTContext::getExtQualType(const Type *baseType, Qualifiers quals) const {
2560 unsigned fastQuals = quals.getFastQualifiers();
2561 quals.removeFastQualifiers();
2562
2563 // Check if we've already instantiated this type.
2564 llvm::FoldingSetNodeID ID;
2565 ExtQuals::Profile(ID, baseType, quals);
2566 void *insertPos = nullptr;
2567 if (ExtQuals *eq = ExtQualNodes.FindNodeOrInsertPos(ID, insertPos)) {
2568 assert(eq->getQualifiers() == quals)((eq->getQualifiers() == quals) ? static_cast<void> (
0) : __assert_fail ("eq->getQualifiers() == quals", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2568, __PRETTY_FUNCTION__))
;
2569 return QualType(eq, fastQuals);
2570 }
2571
2572 // If the base type is not canonical, make the appropriate canonical type.
2573 QualType canon;
2574 if (!baseType->isCanonicalUnqualified()) {
2575 SplitQualType canonSplit = baseType->getCanonicalTypeInternal().split();
2576 canonSplit.Quals.addConsistentQualifiers(quals);
2577 canon = getExtQualType(canonSplit.Ty, canonSplit.Quals);
2578
2579 // Re-find the insert position.
2580 (void) ExtQualNodes.FindNodeOrInsertPos(ID, insertPos);
2581 }
2582
2583 auto *eq = new (*this, TypeAlignment) ExtQuals(baseType, canon, quals);
2584 ExtQualNodes.InsertNode(eq, insertPos);
2585 return QualType(eq, fastQuals);
2586}
2587
2588QualType ASTContext::getAddrSpaceQualType(QualType T,
2589 LangAS AddressSpace) const {
2590 QualType CanT = getCanonicalType(T);
2591 if (CanT.getAddressSpace() == AddressSpace)
2592 return T;
2593
2594 // If we are composing extended qualifiers together, merge together
2595 // into one ExtQuals node.
2596 QualifierCollector Quals;
2597 const Type *TypeNode = Quals.strip(T);
2598
2599 // If this type already has an address space specified, it cannot get
2600 // another one.
2601 assert(!Quals.hasAddressSpace() &&((!Quals.hasAddressSpace() && "Type cannot be in multiple addr spaces!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasAddressSpace() && \"Type cannot be in multiple addr spaces!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2602, __PRETTY_FUNCTION__))
2602 "Type cannot be in multiple addr spaces!")((!Quals.hasAddressSpace() && "Type cannot be in multiple addr spaces!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasAddressSpace() && \"Type cannot be in multiple addr spaces!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2602, __PRETTY_FUNCTION__))
;
2603 Quals.addAddressSpace(AddressSpace);
2604
2605 return getExtQualType(TypeNode, Quals);
2606}
2607
2608QualType ASTContext::removeAddrSpaceQualType(QualType T) const {
2609 // If we are composing extended qualifiers together, merge together
2610 // into one ExtQuals node.
2611 QualifierCollector Quals;
2612 const Type *TypeNode = Quals.strip(T);
2613
2614 // If the qualifier doesn't have an address space just return it.
2615 if (!Quals.hasAddressSpace())
2616 return T;
2617
2618 Quals.removeAddressSpace();
2619
2620 // Removal of the address space can mean there are no longer any
2621 // non-fast qualifiers, so creating an ExtQualType isn't possible (asserts)
2622 // or required.
2623 if (Quals.hasNonFastQualifiers())
2624 return getExtQualType(TypeNode, Quals);
2625 else
2626 return QualType(TypeNode, Quals.getFastQualifiers());
2627}
2628
2629QualType ASTContext::getObjCGCQualType(QualType T,
2630 Qualifiers::GC GCAttr) const {
2631 QualType CanT = getCanonicalType(T);
2632 if (CanT.getObjCGCAttr() == GCAttr)
2633 return T;
2634
2635 if (const auto *ptr = T->getAs<PointerType>()) {
2636 QualType Pointee = ptr->getPointeeType();
2637 if (Pointee->isAnyPointerType()) {
2638 QualType ResultType = getObjCGCQualType(Pointee, GCAttr);
2639 return getPointerType(ResultType);
2640 }
2641 }
2642
2643 // If we are composing extended qualifiers together, merge together
2644 // into one ExtQuals node.
2645 QualifierCollector Quals;
2646 const Type *TypeNode = Quals.strip(T);
2647
2648 // If this type already has an ObjCGC specified, it cannot get
2649 // another one.
2650 assert(!Quals.hasObjCGCAttr() &&((!Quals.hasObjCGCAttr() && "Type cannot have multiple ObjCGCs!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasObjCGCAttr() && \"Type cannot have multiple ObjCGCs!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2651, __PRETTY_FUNCTION__))
2651 "Type cannot have multiple ObjCGCs!")((!Quals.hasObjCGCAttr() && "Type cannot have multiple ObjCGCs!"
) ? static_cast<void> (0) : __assert_fail ("!Quals.hasObjCGCAttr() && \"Type cannot have multiple ObjCGCs!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2651, __PRETTY_FUNCTION__))
;
2652 Quals.addObjCGCAttr(GCAttr);
2653
2654 return getExtQualType(TypeNode, Quals);
2655}
2656
2657const FunctionType *ASTContext::adjustFunctionType(const FunctionType *T,
2658 FunctionType::ExtInfo Info) {
2659 if (T->getExtInfo() == Info)
2660 return T;
2661
2662 QualType Result;
2663 if (const auto *FNPT = dyn_cast<FunctionNoProtoType>(T)) {
2664 Result = getFunctionNoProtoType(FNPT->getReturnType(), Info);
2665 } else {
2666 const auto *FPT = cast<FunctionProtoType>(T);
2667 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
2668 EPI.ExtInfo = Info;
2669 Result = getFunctionType(FPT->getReturnType(), FPT->getParamTypes(), EPI);
2670 }
2671
2672 return cast<FunctionType>(Result.getTypePtr());
2673}
2674
2675void ASTContext::adjustDeducedFunctionResultType(FunctionDecl *FD,
2676 QualType ResultType) {
2677 FD = FD->getMostRecentDecl();
2678 while (true) {
2679 const auto *FPT = FD->getType()->castAs<FunctionProtoType>();
2680 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
2681 FD->setType(getFunctionType(ResultType, FPT->getParamTypes(), EPI));
2682 if (FunctionDecl *Next = FD->getPreviousDecl())
2683 FD = Next;
2684 else
2685 break;
2686 }
2687 if (ASTMutationListener *L = getASTMutationListener())
2688 L->DeducedReturnType(FD, ResultType);
2689}
2690
2691/// Get a function type and produce the equivalent function type with the
2692/// specified exception specification. Type sugar that can be present on a
2693/// declaration of a function with an exception specification is permitted
2694/// and preserved. Other type sugar (for instance, typedefs) is not.
2695QualType ASTContext::getFunctionTypeWithExceptionSpec(
2696 QualType Orig, const FunctionProtoType::ExceptionSpecInfo &ESI) {
2697 // Might have some parens.
2698 if (const auto *PT = dyn_cast<ParenType>(Orig))
2699 return getParenType(
2700 getFunctionTypeWithExceptionSpec(PT->getInnerType(), ESI));
2701
2702 // Might have a calling-convention attribute.
2703 if (const auto *AT = dyn_cast<AttributedType>(Orig))
2704 return getAttributedType(
2705 AT->getAttrKind(),
2706 getFunctionTypeWithExceptionSpec(AT->getModifiedType(), ESI),
2707 getFunctionTypeWithExceptionSpec(AT->getEquivalentType(), ESI));
2708
2709 // Anything else must be a function type. Rebuild it with the new exception
2710 // specification.
2711 const auto *Proto = cast<FunctionProtoType>(Orig);
2712 return getFunctionType(
2713 Proto->getReturnType(), Proto->getParamTypes(),
2714 Proto->getExtProtoInfo().withExceptionSpec(ESI));
2715}
2716
2717bool ASTContext::hasSameFunctionTypeIgnoringExceptionSpec(QualType T,
2718 QualType U) {
2719 return hasSameType(T, U) ||
2720 (getLangOpts().CPlusPlus17 &&
2721 hasSameType(getFunctionTypeWithExceptionSpec(T, EST_None),
2722 getFunctionTypeWithExceptionSpec(U, EST_None)));
2723}
2724
2725void ASTContext::adjustExceptionSpec(
2726 FunctionDecl *FD, const FunctionProtoType::ExceptionSpecInfo &ESI,
2727 bool AsWritten) {
2728 // Update the type.
2729 QualType Updated =
2730 getFunctionTypeWithExceptionSpec(FD->getType(), ESI);
2731 FD->setType(Updated);
2732
2733 if (!AsWritten)
2734 return;
2735
2736 // Update the type in the type source information too.
2737 if (TypeSourceInfo *TSInfo = FD->getTypeSourceInfo()) {
2738 // If the type and the type-as-written differ, we may need to update
2739 // the type-as-written too.
2740 if (TSInfo->getType() != FD->getType())
2741 Updated = getFunctionTypeWithExceptionSpec(TSInfo->getType(), ESI);
2742
2743 // FIXME: When we get proper type location information for exceptions,
2744 // we'll also have to rebuild the TypeSourceInfo. For now, we just patch
2745 // up the TypeSourceInfo;
2746 assert(TypeLoc::getFullDataSizeForType(Updated) ==((TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType
(TSInfo->getType()) && "TypeLoc size mismatch from updating exception specification"
) ? static_cast<void> (0) : __assert_fail ("TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType(TSInfo->getType()) && \"TypeLoc size mismatch from updating exception specification\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2748, __PRETTY_FUNCTION__))
2747 TypeLoc::getFullDataSizeForType(TSInfo->getType()) &&((TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType
(TSInfo->getType()) && "TypeLoc size mismatch from updating exception specification"
) ? static_cast<void> (0) : __assert_fail ("TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType(TSInfo->getType()) && \"TypeLoc size mismatch from updating exception specification\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2748, __PRETTY_FUNCTION__))
2748 "TypeLoc size mismatch from updating exception specification")((TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType
(TSInfo->getType()) && "TypeLoc size mismatch from updating exception specification"
) ? static_cast<void> (0) : __assert_fail ("TypeLoc::getFullDataSizeForType(Updated) == TypeLoc::getFullDataSizeForType(TSInfo->getType()) && \"TypeLoc size mismatch from updating exception specification\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2748, __PRETTY_FUNCTION__))
;
2749 TSInfo->overrideType(Updated);
2750 }
2751}
2752
2753/// getComplexType - Return the uniqued reference to the type for a complex
2754/// number with the specified element type.
2755QualType ASTContext::getComplexType(QualType T) const {
2756 // Unique pointers, to guarantee there is only one pointer of a particular
2757 // structure.
2758 llvm::FoldingSetNodeID ID;
2759 ComplexType::Profile(ID, T);
2760
2761 void *InsertPos = nullptr;
2762 if (ComplexType *CT = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos))
2763 return QualType(CT, 0);
2764
2765 // If the pointee type isn't canonical, this won't be a canonical type either,
2766 // so fill in the canonical type field.
2767 QualType Canonical;
2768 if (!T.isCanonical()) {
2769 Canonical = getComplexType(getCanonicalType(T));
2770
2771 // Get the new insert position for the node we care about.
2772 ComplexType *NewIP = ComplexTypes.FindNodeOrInsertPos(ID, InsertPos);
2773 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2773, __PRETTY_FUNCTION__))
; (void)NewIP;
2774 }
2775 auto *New = new (*this, TypeAlignment) ComplexType(T, Canonical);
2776 Types.push_back(New);
2777 ComplexTypes.InsertNode(New, InsertPos);
2778 return QualType(New, 0);
2779}
2780
2781/// getPointerType - Return the uniqued reference to the type for a pointer to
2782/// the specified type.
2783QualType ASTContext::getPointerType(QualType T) const {
2784 // Unique pointers, to guarantee there is only one pointer of a particular
2785 // structure.
2786 llvm::FoldingSetNodeID ID;
2787 PointerType::Profile(ID, T);
2788
2789 void *InsertPos = nullptr;
2790 if (PointerType *PT = PointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2791 return QualType(PT, 0);
2792
2793 // If the pointee type isn't canonical, this won't be a canonical type either,
2794 // so fill in the canonical type field.
2795 QualType Canonical;
2796 if (!T.isCanonical()) {
2797 Canonical = getPointerType(getCanonicalType(T));
2798
2799 // Get the new insert position for the node we care about.
2800 PointerType *NewIP = PointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2801 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2801, __PRETTY_FUNCTION__))
; (void)NewIP;
2802 }
2803 auto *New = new (*this, TypeAlignment) PointerType(T, Canonical);
2804 Types.push_back(New);
2805 PointerTypes.InsertNode(New, InsertPos);
2806 return QualType(New, 0);
2807}
2808
2809QualType ASTContext::getAdjustedType(QualType Orig, QualType New) const {
2810 llvm::FoldingSetNodeID ID;
2811 AdjustedType::Profile(ID, Orig, New);
2812 void *InsertPos = nullptr;
2813 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2814 if (AT)
2815 return QualType(AT, 0);
2816
2817 QualType Canonical = getCanonicalType(New);
2818
2819 // Get the new insert position for the node we care about.
2820 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2821 assert(!AT && "Shouldn't be in the map!")((!AT && "Shouldn't be in the map!") ? static_cast<
void> (0) : __assert_fail ("!AT && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2821, __PRETTY_FUNCTION__))
;
2822
2823 AT = new (*this, TypeAlignment)
2824 AdjustedType(Type::Adjusted, Orig, New, Canonical);
2825 Types.push_back(AT);
2826 AdjustedTypes.InsertNode(AT, InsertPos);
2827 return QualType(AT, 0);
2828}
2829
2830QualType ASTContext::getDecayedType(QualType T) const {
2831 assert((T->isArrayType() || T->isFunctionType()) && "T does not decay")(((T->isArrayType() || T->isFunctionType()) && "T does not decay"
) ? static_cast<void> (0) : __assert_fail ("(T->isArrayType() || T->isFunctionType()) && \"T does not decay\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2831, __PRETTY_FUNCTION__))
;
2832
2833 QualType Decayed;
2834
2835 // C99 6.7.5.3p7:
2836 // A declaration of a parameter as "array of type" shall be
2837 // adjusted to "qualified pointer to type", where the type
2838 // qualifiers (if any) are those specified within the [ and ] of
2839 // the array type derivation.
2840 if (T->isArrayType())
2841 Decayed = getArrayDecayedType(T);
2842
2843 // C99 6.7.5.3p8:
2844 // A declaration of a parameter as "function returning type"
2845 // shall be adjusted to "pointer to function returning type", as
2846 // in 6.3.2.1.
2847 if (T->isFunctionType())
2848 Decayed = getPointerType(T);
2849
2850 llvm::FoldingSetNodeID ID;
2851 AdjustedType::Profile(ID, T, Decayed);
2852 void *InsertPos = nullptr;
2853 AdjustedType *AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2854 if (AT)
2855 return QualType(AT, 0);
2856
2857 QualType Canonical = getCanonicalType(Decayed);
2858
2859 // Get the new insert position for the node we care about.
2860 AT = AdjustedTypes.FindNodeOrInsertPos(ID, InsertPos);
2861 assert(!AT && "Shouldn't be in the map!")((!AT && "Shouldn't be in the map!") ? static_cast<
void> (0) : __assert_fail ("!AT && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2861, __PRETTY_FUNCTION__))
;
2862
2863 AT = new (*this, TypeAlignment) DecayedType(T, Decayed, Canonical);
2864 Types.push_back(AT);
2865 AdjustedTypes.InsertNode(AT, InsertPos);
2866 return QualType(AT, 0);
2867}
2868
2869/// getBlockPointerType - Return the uniqued reference to the type for
2870/// a pointer to the specified block.
2871QualType ASTContext::getBlockPointerType(QualType T) const {
2872 assert(T->isFunctionType() && "block of function types only")((T->isFunctionType() && "block of function types only"
) ? static_cast<void> (0) : __assert_fail ("T->isFunctionType() && \"block of function types only\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2872, __PRETTY_FUNCTION__))
;
2873 // Unique pointers, to guarantee there is only one block of a particular
2874 // structure.
2875 llvm::FoldingSetNodeID ID;
2876 BlockPointerType::Profile(ID, T);
2877
2878 void *InsertPos = nullptr;
2879 if (BlockPointerType *PT =
2880 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2881 return QualType(PT, 0);
2882
2883 // If the block pointee type isn't canonical, this won't be a canonical
2884 // type either so fill in the canonical type field.
2885 QualType Canonical;
2886 if (!T.isCanonical()) {
2887 Canonical = getBlockPointerType(getCanonicalType(T));
2888
2889 // Get the new insert position for the node we care about.
2890 BlockPointerType *NewIP =
2891 BlockPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2892 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2892, __PRETTY_FUNCTION__))
; (void)NewIP;
2893 }
2894 auto *New = new (*this, TypeAlignment) BlockPointerType(T, Canonical);
2895 Types.push_back(New);
2896 BlockPointerTypes.InsertNode(New, InsertPos);
2897 return QualType(New, 0);
2898}
2899
2900/// getLValueReferenceType - Return the uniqued reference to the type for an
2901/// lvalue reference to the specified type.
2902QualType
2903ASTContext::getLValueReferenceType(QualType T, bool SpelledAsLValue) const {
2904 assert(getCanonicalType(T) != OverloadTy &&((getCanonicalType(T) != OverloadTy && "Unresolved overloaded function type"
) ? static_cast<void> (0) : __assert_fail ("getCanonicalType(T) != OverloadTy && \"Unresolved overloaded function type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2905, __PRETTY_FUNCTION__))
2905 "Unresolved overloaded function type")((getCanonicalType(T) != OverloadTy && "Unresolved overloaded function type"
) ? static_cast<void> (0) : __assert_fail ("getCanonicalType(T) != OverloadTy && \"Unresolved overloaded function type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2905, __PRETTY_FUNCTION__))
;
2906
2907 // Unique pointers, to guarantee there is only one pointer of a particular
2908 // structure.
2909 llvm::FoldingSetNodeID ID;
2910 ReferenceType::Profile(ID, T, SpelledAsLValue);
2911
2912 void *InsertPos = nullptr;
2913 if (LValueReferenceType *RT =
2914 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2915 return QualType(RT, 0);
2916
2917 const auto *InnerRef = T->getAs<ReferenceType>();
2918
2919 // If the referencee type isn't canonical, this won't be a canonical type
2920 // either, so fill in the canonical type field.
2921 QualType Canonical;
2922 if (!SpelledAsLValue || InnerRef || !T.isCanonical()) {
2923 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2924 Canonical = getLValueReferenceType(getCanonicalType(PointeeType));
2925
2926 // Get the new insert position for the node we care about.
2927 LValueReferenceType *NewIP =
2928 LValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
2929 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2929, __PRETTY_FUNCTION__))
; (void)NewIP;
2930 }
2931
2932 auto *New = new (*this, TypeAlignment) LValueReferenceType(T, Canonical,
2933 SpelledAsLValue);
2934 Types.push_back(New);
2935 LValueReferenceTypes.InsertNode(New, InsertPos);
2936
2937 return QualType(New, 0);
2938}
2939
2940/// getRValueReferenceType - Return the uniqued reference to the type for an
2941/// rvalue reference to the specified type.
2942QualType ASTContext::getRValueReferenceType(QualType T) const {
2943 // Unique pointers, to guarantee there is only one pointer of a particular
2944 // structure.
2945 llvm::FoldingSetNodeID ID;
2946 ReferenceType::Profile(ID, T, false);
2947
2948 void *InsertPos = nullptr;
2949 if (RValueReferenceType *RT =
2950 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos))
2951 return QualType(RT, 0);
2952
2953 const auto *InnerRef = T->getAs<ReferenceType>();
2954
2955 // If the referencee type isn't canonical, this won't be a canonical type
2956 // either, so fill in the canonical type field.
2957 QualType Canonical;
2958 if (InnerRef || !T.isCanonical()) {
2959 QualType PointeeType = (InnerRef ? InnerRef->getPointeeType() : T);
2960 Canonical = getRValueReferenceType(getCanonicalType(PointeeType));
2961
2962 // Get the new insert position for the node we care about.
2963 RValueReferenceType *NewIP =
2964 RValueReferenceTypes.FindNodeOrInsertPos(ID, InsertPos);
2965 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2965, __PRETTY_FUNCTION__))
; (void)NewIP;
2966 }
2967
2968 auto *New = new (*this, TypeAlignment) RValueReferenceType(T, Canonical);
2969 Types.push_back(New);
2970 RValueReferenceTypes.InsertNode(New, InsertPos);
2971 return QualType(New, 0);
2972}
2973
2974/// getMemberPointerType - Return the uniqued reference to the type for a
2975/// member pointer to the specified type, in the specified class.
2976QualType ASTContext::getMemberPointerType(QualType T, const Type *Cls) const {
2977 // Unique pointers, to guarantee there is only one pointer of a particular
2978 // structure.
2979 llvm::FoldingSetNodeID ID;
2980 MemberPointerType::Profile(ID, T, Cls);
2981
2982 void *InsertPos = nullptr;
2983 if (MemberPointerType *PT =
2984 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
2985 return QualType(PT, 0);
2986
2987 // If the pointee or class type isn't canonical, this won't be a canonical
2988 // type either, so fill in the canonical type field.
2989 QualType Canonical;
2990 if (!T.isCanonical() || !Cls->isCanonicalUnqualified()) {
2991 Canonical = getMemberPointerType(getCanonicalType(T),getCanonicalType(Cls));
2992
2993 // Get the new insert position for the node we care about.
2994 MemberPointerType *NewIP =
2995 MemberPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
2996 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 2996, __PRETTY_FUNCTION__))
; (void)NewIP;
2997 }
2998 auto *New = new (*this, TypeAlignment) MemberPointerType(T, Cls, Canonical);
2999 Types.push_back(New);
3000 MemberPointerTypes.InsertNode(New, InsertPos);
3001 return QualType(New, 0);
3002}
3003
3004/// getConstantArrayType - Return the unique reference to the type for an
3005/// array of the specified element type.
3006QualType ASTContext::getConstantArrayType(QualType EltTy,
3007 const llvm::APInt &ArySizeIn,
3008 ArrayType::ArraySizeModifier ASM,
3009 unsigned IndexTypeQuals) const {
3010 assert((EltTy->isDependentType() ||(((EltTy->isDependentType() || EltTy->isIncompleteType(
) || EltTy->isConstantSizeType()) && "Constant array of VLAs is illegal!"
) ? static_cast<void> (0) : __assert_fail ("(EltTy->isDependentType() || EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && \"Constant array of VLAs is illegal!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3012, __PRETTY_FUNCTION__))
3011 EltTy->isIncompleteType() || EltTy->isConstantSizeType()) &&(((EltTy->isDependentType() || EltTy->isIncompleteType(
) || EltTy->isConstantSizeType()) && "Constant array of VLAs is illegal!"
) ? static_cast<void> (0) : __assert_fail ("(EltTy->isDependentType() || EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && \"Constant array of VLAs is illegal!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3012, __PRETTY_FUNCTION__))
3012 "Constant array of VLAs is illegal!")(((EltTy->isDependentType() || EltTy->isIncompleteType(
) || EltTy->isConstantSizeType()) && "Constant array of VLAs is illegal!"
) ? static_cast<void> (0) : __assert_fail ("(EltTy->isDependentType() || EltTy->isIncompleteType() || EltTy->isConstantSizeType()) && \"Constant array of VLAs is illegal!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3012, __PRETTY_FUNCTION__))
;
3013
3014 // Convert the array size into a canonical width matching the pointer size for
3015 // the target.
3016 llvm::APInt ArySize(ArySizeIn);
3017 ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());
3018
3019 llvm::FoldingSetNodeID ID;
3020 ConstantArrayType::Profile(ID, EltTy, ArySize, ASM, IndexTypeQuals);
3021
3022 void *InsertPos = nullptr;
3023 if (ConstantArrayType *ATP =
3024 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos))
3025 return QualType(ATP, 0);
3026
3027 // If the element type isn't canonical or has qualifiers, this won't
3028 // be a canonical type either, so fill in the canonical type field.
3029 QualType Canon;
3030 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
3031 SplitQualType canonSplit = getCanonicalType(EltTy).split();
3032 Canon = getConstantArrayType(QualType(canonSplit.Ty, 0), ArySize,
3033 ASM, IndexTypeQuals);
3034 Canon = getQualifiedType(Canon, canonSplit.Quals);
3035
3036 // Get the new insert position for the node we care about.
3037 ConstantArrayType *NewIP =
3038 ConstantArrayTypes.FindNodeOrInsertPos(ID, InsertPos);
3039 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3039, __PRETTY_FUNCTION__))
; (void)NewIP;
3040 }
3041
3042 auto *New = new (*this,TypeAlignment)
3043 ConstantArrayType(EltTy, Canon, ArySize, ASM, IndexTypeQuals);
3044 ConstantArrayTypes.InsertNode(New, InsertPos);
3045 Types.push_back(New);
3046 return QualType(New, 0);
3047}
3048
3049/// getVariableArrayDecayedType - Turns the given type, which may be
3050/// variably-modified, into the corresponding type with all the known
3051/// sizes replaced with [*].
3052QualType ASTContext::getVariableArrayDecayedType(QualType type) const {
3053 // Vastly most common case.
3054 if (!type->isVariablyModifiedType()) return type;
3055
3056 QualType result;
3057
3058 SplitQualType split = type.getSplitDesugaredType();
3059 const Type *ty = split.Ty;
3060 switch (ty->getTypeClass()) {
3061#define TYPE(Class, Base)
3062#define ABSTRACT_TYPE(Class, Base)
3063#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
3064#include "clang/AST/TypeNodes.def"
3065 llvm_unreachable("didn't desugar past all non-canonical types?")::llvm::llvm_unreachable_internal("didn't desugar past all non-canonical types?"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3065)
;
3066
3067 // These types should never be variably-modified.
3068 case Type::Builtin:
3069 case Type::Complex:
3070 case Type::Vector:
3071 case Type::DependentVector:
3072 case Type::ExtVector:
3073 case Type::DependentSizedExtVector:
3074 case Type::DependentAddressSpace:
3075 case Type::ObjCObject:
3076 case Type::ObjCInterface:
3077 case Type::ObjCObjectPointer:
3078 case Type::Record:
3079 case Type::Enum:
3080 case Type::UnresolvedUsing:
3081 case Type::TypeOfExpr:
3082 case Type::TypeOf:
3083 case Type::Decltype:
3084 case Type::UnaryTransform:
3085 case Type::DependentName:
3086 case Type::InjectedClassName:
3087 case Type::TemplateSpecialization:
3088 case Type::DependentTemplateSpecialization:
3089 case Type::TemplateTypeParm:
3090 case Type::SubstTemplateTypeParmPack:
3091 case Type::Auto:
3092 case Type::DeducedTemplateSpecialization:
3093 case Type::PackExpansion:
3094 llvm_unreachable("type should never be variably-modified")::llvm::llvm_unreachable_internal("type should never be variably-modified"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3094)
;
3095
3096 // These types can be variably-modified but should never need to
3097 // further decay.
3098 case Type::FunctionNoProto:
3099 case Type::FunctionProto:
3100 case Type::BlockPointer:
3101 case Type::MemberPointer:
3102 case Type::Pipe:
3103 return type;
3104
3105 // These types can be variably-modified. All these modifications
3106 // preserve structure except as noted by comments.
3107 // TODO: if we ever care about optimizing VLAs, there are no-op
3108 // optimizations available here.
3109 case Type::Pointer:
3110 result = getPointerType(getVariableArrayDecayedType(
3111 cast<PointerType>(ty)->getPointeeType()));
3112 break;
3113
3114 case Type::LValueReference: {
3115 const auto *lv = cast<LValueReferenceType>(ty);
3116 result = getLValueReferenceType(
3117 getVariableArrayDecayedType(lv->getPointeeType()),
3118 lv->isSpelledAsLValue());
3119 break;
3120 }
3121
3122 case Type::RValueReference: {
3123 const auto *lv = cast<RValueReferenceType>(ty);
3124 result = getRValueReferenceType(
3125 getVariableArrayDecayedType(lv->getPointeeType()));
3126 break;
3127 }
3128
3129 case Type::Atomic: {
3130 const auto *at = cast<AtomicType>(ty);
3131 result = getAtomicType(getVariableArrayDecayedType(at->getValueType()));
3132 break;
3133 }
3134
3135 case Type::ConstantArray: {
3136 const auto *cat = cast<ConstantArrayType>(ty);
3137 result = getConstantArrayType(
3138 getVariableArrayDecayedType(cat->getElementType()),
3139 cat->getSize(),
3140 cat->getSizeModifier(),
3141 cat->getIndexTypeCVRQualifiers());
3142 break;
3143 }
3144
3145 case Type::DependentSizedArray: {
3146 const auto *dat = cast<DependentSizedArrayType>(ty);
3147 result = getDependentSizedArrayType(
3148 getVariableArrayDecayedType(dat->getElementType()),
3149 dat->getSizeExpr(),
3150 dat->getSizeModifier(),
3151 dat->getIndexTypeCVRQualifiers(),
3152 dat->getBracketsRange());
3153 break;
3154 }
3155
3156 // Turn incomplete types into [*] types.
3157 case Type::IncompleteArray: {
3158 const auto *iat = cast<IncompleteArrayType>(ty);
3159 result = getVariableArrayType(
3160 getVariableArrayDecayedType(iat->getElementType()),
3161 /*size*/ nullptr,
3162 ArrayType::Normal,
3163 iat->getIndexTypeCVRQualifiers(),
3164 SourceRange());
3165 break;
3166 }
3167
3168 // Turn VLA types into [*] types.
3169 case Type::VariableArray: {
3170 const auto *vat = cast<VariableArrayType>(ty);
3171 result = getVariableArrayType(
3172 getVariableArrayDecayedType(vat->getElementType()),
3173 /*size*/ nullptr,
3174 ArrayType::Star,
3175 vat->getIndexTypeCVRQualifiers(),
3176 vat->getBracketsRange());
3177 break;
3178 }
3179 }
3180
3181 // Apply the top-level qualifiers from the original.
3182 return getQualifiedType(result, split.Quals);
3183}
3184
3185/// getVariableArrayType - Returns a non-unique reference to the type for a
3186/// variable array of the specified element type.
3187QualType ASTContext::getVariableArrayType(QualType EltTy,
3188 Expr *NumElts,
3189 ArrayType::ArraySizeModifier ASM,
3190 unsigned IndexTypeQuals,
3191 SourceRange Brackets) const {
3192 // Since we don't unique expressions, it isn't possible to unique VLA's
3193 // that have an expression provided for their size.
3194 QualType Canon;
3195
3196 // Be sure to pull qualifiers off the element type.
3197 if (!EltTy.isCanonical() || EltTy.hasLocalQualifiers()) {
3198 SplitQualType canonSplit = getCanonicalType(EltTy).split();
3199 Canon = getVariableArrayType(QualType(canonSplit.Ty, 0), NumElts, ASM,
3200 IndexTypeQuals, Brackets);
3201 Canon = getQualifiedType(Canon, canonSplit.Quals);
3202 }
3203
3204 auto *New = new (*this, TypeAlignment)
3205 VariableArrayType(EltTy, Canon, NumElts, ASM, IndexTypeQuals, Brackets);
3206
3207 VariableArrayTypes.push_back(New);
3208 Types.push_back(New);
3209 return QualType(New, 0);
3210}
3211
3212/// getDependentSizedArrayType - Returns a non-unique reference to
3213/// the type for a dependently-sized array of the specified element
3214/// type.
3215QualType ASTContext::getDependentSizedArrayType(QualType elementType,
3216 Expr *numElements,
3217 ArrayType::ArraySizeModifier ASM,
3218 unsigned elementTypeQuals,
3219 SourceRange brackets) const {
3220 assert((!numElements || numElements->isTypeDependent() ||(((!numElements || numElements->isTypeDependent() || numElements
->isValueDependent()) && "Size must be type- or value-dependent!"
) ? static_cast<void> (0) : __assert_fail ("(!numElements || numElements->isTypeDependent() || numElements->isValueDependent()) && \"Size must be type- or value-dependent!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3222, __PRETTY_FUNCTION__))
3221 numElements->isValueDependent()) &&(((!numElements || numElements->isTypeDependent() || numElements
->isValueDependent()) && "Size must be type- or value-dependent!"
) ? static_cast<void> (0) : __assert_fail ("(!numElements || numElements->isTypeDependent() || numElements->isValueDependent()) && \"Size must be type- or value-dependent!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3222, __PRETTY_FUNCTION__))
3222 "Size must be type- or value-dependent!")(((!numElements || numElements->isTypeDependent() || numElements
->isValueDependent()) && "Size must be type- or value-dependent!"
) ? static_cast<void> (0) : __assert_fail ("(!numElements || numElements->isTypeDependent() || numElements->isValueDependent()) && \"Size must be type- or value-dependent!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3222, __PRETTY_FUNCTION__))
;
3223
3224 // Dependently-sized array types that do not have a specified number
3225 // of elements will have their sizes deduced from a dependent
3226 // initializer. We do no canonicalization here at all, which is okay
3227 // because they can't be used in most locations.
3228 if (!numElements) {
3229 auto *newType
3230 = new (*this, TypeAlignment)
3231 DependentSizedArrayType(*this, elementType, QualType(),
3232 numElements, ASM, elementTypeQuals,
3233 brackets);
3234 Types.push_back(newType);
3235 return QualType(newType, 0);
3236 }
3237
3238 // Otherwise, we actually build a new type every time, but we
3239 // also build a canonical type.
3240
3241 SplitQualType canonElementType = getCanonicalType(elementType).split();
3242
3243 void *insertPos = nullptr;
3244 llvm::FoldingSetNodeID ID;
3245 DependentSizedArrayType::Profile(ID, *this,
3246 QualType(canonElementType.Ty, 0),
3247 ASM, elementTypeQuals, numElements);
3248
3249 // Look for an existing type with these properties.
3250 DependentSizedArrayType *canonTy =
3251 DependentSizedArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3252
3253 // If we don't have one, build one.
3254 if (!canonTy) {
3255 canonTy = new (*this, TypeAlignment)
3256 DependentSizedArrayType(*this, QualType(canonElementType.Ty, 0),
3257 QualType(), numElements, ASM, elementTypeQuals,
3258 brackets);
3259 DependentSizedArrayTypes.InsertNode(canonTy, insertPos);
3260 Types.push_back(canonTy);
3261 }
3262
3263 // Apply qualifiers from the element type to the array.
3264 QualType canon = getQualifiedType(QualType(canonTy,0),
3265 canonElementType.Quals);
3266
3267 // If we didn't need extra canonicalization for the element type or the size
3268 // expression, then just use that as our result.
3269 if (QualType(canonElementType.Ty, 0) == elementType &&
3270 canonTy->getSizeExpr() == numElements)
3271 return canon;
3272
3273 // Otherwise, we need to build a type which follows the spelling
3274 // of the element type.
3275 auto *sugaredType
3276 = new (*this, TypeAlignment)
3277 DependentSizedArrayType(*this, elementType, canon, numElements,
3278 ASM, elementTypeQuals, brackets);
3279 Types.push_back(sugaredType);
3280 return QualType(sugaredType, 0);
3281}
3282
3283QualType ASTContext::getIncompleteArrayType(QualType elementType,
3284 ArrayType::ArraySizeModifier ASM,
3285 unsigned elementTypeQuals) const {
3286 llvm::FoldingSetNodeID ID;
3287 IncompleteArrayType::Profile(ID, elementType, ASM, elementTypeQuals);
3288
3289 void *insertPos = nullptr;
3290 if (IncompleteArrayType *iat =
3291 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos))
3292 return QualType(iat, 0);
3293
3294 // If the element type isn't canonical, this won't be a canonical type
3295 // either, so fill in the canonical type field. We also have to pull
3296 // qualifiers off the element type.
3297 QualType canon;
3298
3299 if (!elementType.isCanonical() || elementType.hasLocalQualifiers()) {
3300 SplitQualType canonSplit = getCanonicalType(elementType).split();
3301 canon = getIncompleteArrayType(QualType(canonSplit.Ty, 0),
3302 ASM, elementTypeQuals);
3303 canon = getQualifiedType(canon, canonSplit.Quals);
3304
3305 // Get the new insert position for the node we care about.
3306 IncompleteArrayType *existing =
3307 IncompleteArrayTypes.FindNodeOrInsertPos(ID, insertPos);
3308 assert(!existing && "Shouldn't be in the map!")((!existing && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!existing && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3308, __PRETTY_FUNCTION__))
; (void) existing;
3309 }
3310
3311 auto *newType = new (*this, TypeAlignment)
3312 IncompleteArrayType(elementType, canon, ASM, elementTypeQuals);
3313
3314 IncompleteArrayTypes.InsertNode(newType, insertPos);
3315 Types.push_back(newType);
3316 return QualType(newType, 0);
3317}
3318
3319/// getVectorType - Return the unique reference to a vector type of
3320/// the specified element type and size. VectorType must be a built-in type.
3321QualType ASTContext::getVectorType(QualType vecType, unsigned NumElts,
3322 VectorType::VectorKind VecKind) const {
3323 assert(vecType->isBuiltinType())((vecType->isBuiltinType()) ? static_cast<void> (0) :
__assert_fail ("vecType->isBuiltinType()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3323, __PRETTY_FUNCTION__))
;
3324
3325 // Check if we've already instantiated a vector of this type.
3326 llvm::FoldingSetNodeID ID;
3327 VectorType::Profile(ID, vecType, NumElts, Type::Vector, VecKind);
3328
3329 void *InsertPos = nullptr;
3330 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3331 return QualType(VTP, 0);
3332
3333 // If the element type isn't canonical, this won't be a canonical type either,
3334 // so fill in the canonical type field.
3335 QualType Canonical;
3336 if (!vecType.isCanonical()) {
3337 Canonical = getVectorType(getCanonicalType(vecType), NumElts, VecKind);
3338
3339 // Get the new insert position for the node we care about.
3340 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3341 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3341, __PRETTY_FUNCTION__))
; (void)NewIP;
3342 }
3343 auto *New = new (*this, TypeAlignment)
3344 VectorType(vecType, NumElts, Canonical, VecKind);
3345 VectorTypes.InsertNode(New, InsertPos);
3346 Types.push_back(New);
3347 return QualType(New, 0);
3348}
3349
3350QualType
3351ASTContext::getDependentVectorType(QualType VecType, Expr *SizeExpr,
3352 SourceLocation AttrLoc,
3353 VectorType::VectorKind VecKind) const {
3354 llvm::FoldingSetNodeID ID;
3355 DependentVectorType::Profile(ID, *this, getCanonicalType(VecType), SizeExpr,
3356 VecKind);
3357 void *InsertPos = nullptr;
3358 DependentVectorType *Canon =
3359 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3360 DependentVectorType *New;
3361
3362 if (Canon) {
3363 New = new (*this, TypeAlignment) DependentVectorType(
3364 *this, VecType, QualType(Canon, 0), SizeExpr, AttrLoc, VecKind);
3365 } else {
3366 QualType CanonVecTy = getCanonicalType(VecType);
3367 if (CanonVecTy == VecType) {
3368 New = new (*this, TypeAlignment) DependentVectorType(
3369 *this, VecType, QualType(), SizeExpr, AttrLoc, VecKind);
3370
3371 DependentVectorType *CanonCheck =
3372 DependentVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3373 assert(!CanonCheck &&((!CanonCheck && "Dependent-sized vector_size canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!CanonCheck && \"Dependent-sized vector_size canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3374, __PRETTY_FUNCTION__))
3374 "Dependent-sized vector_size canonical type broken")((!CanonCheck && "Dependent-sized vector_size canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!CanonCheck && \"Dependent-sized vector_size canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3374, __PRETTY_FUNCTION__))
;
3375 (void)CanonCheck;
3376 DependentVectorTypes.InsertNode(New, InsertPos);
3377 } else {
3378 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
3379 SourceLocation());
3380 New = new (*this, TypeAlignment) DependentVectorType(
3381 *this, VecType, Canon, SizeExpr, AttrLoc, VecKind);
3382 }
3383 }
3384
3385 Types.push_back(New);
3386 return QualType(New, 0);
3387}
3388
3389/// getExtVectorType - Return the unique reference to an extended vector type of
3390/// the specified element type and size. VectorType must be a built-in type.
3391QualType
3392ASTContext::getExtVectorType(QualType vecType, unsigned NumElts) const {
3393 assert(vecType->isBuiltinType() || vecType->isDependentType())((vecType->isBuiltinType() || vecType->isDependentType(
)) ? static_cast<void> (0) : __assert_fail ("vecType->isBuiltinType() || vecType->isDependentType()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3393, __PRETTY_FUNCTION__))
;
3394
3395 // Check if we've already instantiated a vector of this type.
3396 llvm::FoldingSetNodeID ID;
3397 VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
3398 VectorType::GenericVector);
3399 void *InsertPos = nullptr;
3400 if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
3401 return QualType(VTP, 0);
3402
3403 // If the element type isn't canonical, this won't be a canonical type either,
3404 // so fill in the canonical type field.
3405 QualType Canonical;
3406 if (!vecType.isCanonical()) {
3407 Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
3408
3409 // Get the new insert position for the node we care about.
3410 VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3411 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3411, __PRETTY_FUNCTION__))
; (void)NewIP;
3412 }
3413 auto *New = new (*this, TypeAlignment)
3414 ExtVectorType(vecType, NumElts, Canonical);
3415 VectorTypes.InsertNode(New, InsertPos);
3416 Types.push_back(New);
3417 return QualType(New, 0);
3418}
3419
3420QualType
3421ASTContext::getDependentSizedExtVectorType(QualType vecType,
3422 Expr *SizeExpr,
3423 SourceLocation AttrLoc) const {
3424 llvm::FoldingSetNodeID ID;
3425 DependentSizedExtVectorType::Profile(ID, *this, getCanonicalType(vecType),
3426 SizeExpr);
3427
3428 void *InsertPos = nullptr;
3429 DependentSizedExtVectorType *Canon
3430 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3431 DependentSizedExtVectorType *New;
3432 if (Canon) {
3433 // We already have a canonical version of this array type; use it as
3434 // the canonical type for a newly-built type.
3435 New = new (*this, TypeAlignment)
3436 DependentSizedExtVectorType(*this, vecType, QualType(Canon, 0),
3437 SizeExpr, AttrLoc);
3438 } else {
3439 QualType CanonVecTy = getCanonicalType(vecType);
3440 if (CanonVecTy == vecType) {
3441 New = new (*this, TypeAlignment)
3442 DependentSizedExtVectorType(*this, vecType, QualType(), SizeExpr,
3443 AttrLoc);
3444
3445 DependentSizedExtVectorType *CanonCheck
3446 = DependentSizedExtVectorTypes.FindNodeOrInsertPos(ID, InsertPos);
3447 assert(!CanonCheck && "Dependent-sized ext_vector canonical type broken")((!CanonCheck && "Dependent-sized ext_vector canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!CanonCheck && \"Dependent-sized ext_vector canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3447, __PRETTY_FUNCTION__))
;
3448 (void)CanonCheck;
3449 DependentSizedExtVectorTypes.InsertNode(New, InsertPos);
3450 } else {
3451 QualType Canon = getDependentSizedExtVectorType(CanonVecTy, SizeExpr,
3452 SourceLocation());
3453 New = new (*this, TypeAlignment)
3454 DependentSizedExtVectorType(*this, vecType, Canon, SizeExpr, AttrLoc);
3455 }
3456 }
3457
3458 Types.push_back(New);
3459 return QualType(New, 0);
3460}
3461
3462QualType ASTContext::getDependentAddressSpaceType(QualType PointeeType,
3463 Expr *AddrSpaceExpr,
3464 SourceLocation AttrLoc) const {
3465 assert(AddrSpaceExpr->isInstantiationDependent())((AddrSpaceExpr->isInstantiationDependent()) ? static_cast
<void> (0) : __assert_fail ("AddrSpaceExpr->isInstantiationDependent()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3465, __PRETTY_FUNCTION__))
;
3466
3467 QualType canonPointeeType = getCanonicalType(PointeeType);
3468
3469 void *insertPos = nullptr;
3470 llvm::FoldingSetNodeID ID;
3471 DependentAddressSpaceType::Profile(ID, *this, canonPointeeType,
3472 AddrSpaceExpr);
3473
3474 DependentAddressSpaceType *canonTy =
3475 DependentAddressSpaceTypes.FindNodeOrInsertPos(ID, insertPos);
3476
3477 if (!canonTy) {
3478 canonTy = new (*this, TypeAlignment)
3479 DependentAddressSpaceType(*this, canonPointeeType,
3480 QualType(), AddrSpaceExpr, AttrLoc);
3481 DependentAddressSpaceTypes.InsertNode(canonTy, insertPos);
3482 Types.push_back(canonTy);
3483 }
3484
3485 if (canonPointeeType == PointeeType &&
3486 canonTy->getAddrSpaceExpr() == AddrSpaceExpr)
3487 return QualType(canonTy, 0);
3488
3489 auto *sugaredType
3490 = new (*this, TypeAlignment)
3491 DependentAddressSpaceType(*this, PointeeType, QualType(canonTy, 0),
3492 AddrSpaceExpr, AttrLoc);
3493 Types.push_back(sugaredType);
3494 return QualType(sugaredType, 0);
3495}
3496
3497/// Determine whether \p T is canonical as the result type of a function.
3498static bool isCanonicalResultType(QualType T) {
3499 return T.isCanonical() &&
3500 (T.getObjCLifetime() == Qualifiers::OCL_None ||
3501 T.getObjCLifetime() == Qualifiers::OCL_ExplicitNone);
3502}
3503
3504/// getFunctionNoProtoType - Return a K&R style C function type like 'int()'.
3505QualType
3506ASTContext::getFunctionNoProtoType(QualType ResultTy,
3507 const FunctionType::ExtInfo &Info) const {
3508 // Unique functions, to guarantee there is only one function of a particular
3509 // structure.
3510 llvm::FoldingSetNodeID ID;
3511 FunctionNoProtoType::Profile(ID, ResultTy, Info);
3512
3513 void *InsertPos = nullptr;
3514 if (FunctionNoProtoType *FT =
3515 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos))
3516 return QualType(FT, 0);
3517
3518 QualType Canonical;
3519 if (!isCanonicalResultType(ResultTy)) {
3520 Canonical =
3521 getFunctionNoProtoType(getCanonicalFunctionResultType(ResultTy), Info);
3522
3523 // Get the new insert position for the node we care about.
3524 FunctionNoProtoType *NewIP =
3525 FunctionNoProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3526 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3526, __PRETTY_FUNCTION__))
; (void)NewIP;
3527 }
3528
3529 auto *New = new (*this, TypeAlignment)
3530 FunctionNoProtoType(ResultTy, Canonical, Info);
3531 Types.push_back(New);
3532 FunctionNoProtoTypes.InsertNode(New, InsertPos);
3533 return QualType(New, 0);
3534}
3535
3536CanQualType
3537ASTContext::getCanonicalFunctionResultType(QualType ResultType) const {
3538 CanQualType CanResultType = getCanonicalType(ResultType);
3539
3540 // Canonical result types do not have ARC lifetime qualifiers.
3541 if (CanResultType.getQualifiers().hasObjCLifetime()) {
3542 Qualifiers Qs = CanResultType.getQualifiers();
3543 Qs.removeObjCLifetime();
3544 return CanQualType::CreateUnsafe(
3545 getQualifiedType(CanResultType.getUnqualifiedType(), Qs));
3546 }
3547
3548 return CanResultType;
3549}
3550
3551static bool isCanonicalExceptionSpecification(
3552 const FunctionProtoType::ExceptionSpecInfo &ESI, bool NoexceptInType) {
3553 if (ESI.Type == EST_None)
3554 return true;
3555 if (!NoexceptInType)
3556 return false;
3557
3558 // C++17 onwards: exception specification is part of the type, as a simple
3559 // boolean "can this function type throw".
3560 if (ESI.Type == EST_BasicNoexcept)
3561 return true;
3562
3563 // A noexcept(expr) specification is (possibly) canonical if expr is
3564 // value-dependent.
3565 if (ESI.Type == EST_DependentNoexcept)
3566 return true;
3567
3568 // A dynamic exception specification is canonical if it only contains pack
3569 // expansions (so we can't tell whether it's non-throwing) and all its
3570 // contained types are canonical.
3571 if (ESI.Type == EST_Dynamic) {
3572 bool AnyPackExpansions = false;
3573 for (QualType ET : ESI.Exceptions) {
3574 if (!ET.isCanonical())
3575 return false;
3576 if (ET->getAs<PackExpansionType>())
3577 AnyPackExpansions = true;
3578 }
3579 return AnyPackExpansions;
3580 }
3581
3582 return false;
3583}
3584
3585QualType ASTContext::getFunctionTypeInternal(
3586 QualType ResultTy, ArrayRef<QualType> ArgArray,
3587 const FunctionProtoType::ExtProtoInfo &EPI, bool OnlyWantCanonical) const {
3588 size_t NumArgs = ArgArray.size();
3589
3590 // Unique functions, to guarantee there is only one function of a particular
3591 // structure.
3592 llvm::FoldingSetNodeID ID;
3593 FunctionProtoType::Profile(ID, ResultTy, ArgArray.begin(), NumArgs, EPI,
3594 *this, true);
3595
3596 QualType Canonical;
3597 bool Unique = false;
3598
3599 void *InsertPos = nullptr;
3600 if (FunctionProtoType *FPT =
3601 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos)) {
3602 QualType Existing = QualType(FPT, 0);
3603
3604 // If we find a pre-existing equivalent FunctionProtoType, we can just reuse
3605 // it so long as our exception specification doesn't contain a dependent
3606 // noexcept expression, or we're just looking for a canonical type.
3607 // Otherwise, we're going to need to create a type
3608 // sugar node to hold the concrete expression.
3609 if (OnlyWantCanonical || !isComputedNoexcept(EPI.ExceptionSpec.Type) ||
3610 EPI.ExceptionSpec.NoexceptExpr == FPT->getNoexceptExpr())
3611 return Existing;
3612
3613 // We need a new type sugar node for this one, to hold the new noexcept
3614 // expression. We do no canonicalization here, but that's OK since we don't
3615 // expect to see the same noexcept expression much more than once.
3616 Canonical = getCanonicalType(Existing);
3617 Unique = true;
3618 }
3619
3620 bool NoexceptInType = getLangOpts().CPlusPlus17;
3621 bool IsCanonicalExceptionSpec =
3622 isCanonicalExceptionSpecification(EPI.ExceptionSpec, NoexceptInType);
3623
3624 // Determine whether the type being created is already canonical or not.
3625 bool isCanonical = !Unique && IsCanonicalExceptionSpec &&
3626 isCanonicalResultType(ResultTy) && !EPI.HasTrailingReturn;
3627 for (unsigned i = 0; i != NumArgs && isCanonical; ++i)
3628 if (!ArgArray[i].isCanonicalAsParam())
3629 isCanonical = false;
3630
3631 if (OnlyWantCanonical)
3632 assert(isCanonical &&((isCanonical && "given non-canonical parameters constructing canonical type"
) ? static_cast<void> (0) : __assert_fail ("isCanonical && \"given non-canonical parameters constructing canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3633, __PRETTY_FUNCTION__))
3633 "given non-canonical parameters constructing canonical type")((isCanonical && "given non-canonical parameters constructing canonical type"
) ? static_cast<void> (0) : __assert_fail ("isCanonical && \"given non-canonical parameters constructing canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3633, __PRETTY_FUNCTION__))
;
3634
3635 // If this type isn't canonical, get the canonical version of it if we don't
3636 // already have it. The exception spec is only partially part of the
3637 // canonical type, and only in C++17 onwards.
3638 if (!isCanonical && Canonical.isNull()) {
3639 SmallVector<QualType, 16> CanonicalArgs;
3640 CanonicalArgs.reserve(NumArgs);
3641 for (unsigned i = 0; i != NumArgs; ++i)
3642 CanonicalArgs.push_back(getCanonicalParamType(ArgArray[i]));
3643
3644 llvm::SmallVector<QualType, 8> ExceptionTypeStorage;
3645 FunctionProtoType::ExtProtoInfo CanonicalEPI = EPI;
3646 CanonicalEPI.HasTrailingReturn = false;
3647
3648 if (IsCanonicalExceptionSpec) {
3649 // Exception spec is already OK.
3650 } else if (NoexceptInType) {
3651 switch (EPI.ExceptionSpec.Type) {
3652 case EST_Unparsed: case EST_Unevaluated: case EST_Uninstantiated:
3653 // We don't know yet. It shouldn't matter what we pick here; no-one
3654 // should ever look at this.
3655 LLVM_FALLTHROUGH[[clang::fallthrough]];
3656 case EST_None: case EST_MSAny: case EST_NoexceptFalse:
3657 CanonicalEPI.ExceptionSpec.Type = EST_None;
3658 break;
3659
3660 // A dynamic exception specification is almost always "not noexcept",
3661 // with the exception that a pack expansion might expand to no types.
3662 case EST_Dynamic: {
3663 bool AnyPacks = false;
3664 for (QualType ET : EPI.ExceptionSpec.Exceptions) {
3665 if (ET->getAs<PackExpansionType>())
3666 AnyPacks = true;
3667 ExceptionTypeStorage.push_back(getCanonicalType(ET));
3668 }
3669 if (!AnyPacks)
3670 CanonicalEPI.ExceptionSpec.Type = EST_None;
3671 else {
3672 CanonicalEPI.ExceptionSpec.Type = EST_Dynamic;
3673 CanonicalEPI.ExceptionSpec.Exceptions = ExceptionTypeStorage;
3674 }
3675 break;
3676 }
3677
3678 case EST_DynamicNone: case EST_BasicNoexcept: case EST_NoexceptTrue:
3679 CanonicalEPI.ExceptionSpec.Type = EST_BasicNoexcept;
3680 break;
3681
3682 case EST_DependentNoexcept:
3683 llvm_unreachable("dependent noexcept is already canonical")::llvm::llvm_unreachable_internal("dependent noexcept is already canonical"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3683)
;
3684 }
3685 } else {
3686 CanonicalEPI.ExceptionSpec = FunctionProtoType::ExceptionSpecInfo();
3687 }
3688
3689 // Adjust the canonical function result type.
3690 CanQualType CanResultTy = getCanonicalFunctionResultType(ResultTy);
3691 Canonical =
3692 getFunctionTypeInternal(CanResultTy, CanonicalArgs, CanonicalEPI, true);
3693
3694 // Get the new insert position for the node we care about.
3695 FunctionProtoType *NewIP =
3696 FunctionProtoTypes.FindNodeOrInsertPos(ID, InsertPos);
3697 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3697, __PRETTY_FUNCTION__))
; (void)NewIP;
3698 }
3699
3700 // Compute the needed size to hold this FunctionProtoType and the
3701 // various trailing objects.
3702 auto ESH = FunctionProtoType::getExceptionSpecSize(
3703 EPI.ExceptionSpec.Type, EPI.ExceptionSpec.Exceptions.size());
3704 size_t Size = FunctionProtoType::totalSizeToAlloc<
3705 QualType, FunctionType::FunctionTypeExtraBitfields,
3706 FunctionType::ExceptionType, Expr *, FunctionDecl *,
3707 FunctionProtoType::ExtParameterInfo>(
3708 NumArgs, FunctionProtoType::hasExtraBitfields(EPI.ExceptionSpec.Type),
3709 ESH.NumExceptionType, ESH.NumExprPtr, ESH.NumFunctionDeclPtr,
3710 EPI.ExtParameterInfos ? NumArgs : 0);
3711
3712 auto *FTP = (FunctionProtoType *)Allocate(Size, TypeAlignment);
3713 FunctionProtoType::ExtProtoInfo newEPI = EPI;
3714 new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
3715 Types.push_back(FTP);
3716 if (!Unique)
3717 FunctionProtoTypes.InsertNode(FTP, InsertPos);
3718 return QualType(FTP, 0);
3719}
3720
3721QualType ASTContext::getPipeType(QualType T, bool ReadOnly) const {
3722 llvm::FoldingSetNodeID ID;
3723 PipeType::Profile(ID, T, ReadOnly);
3724
3725 void *InsertPos = nullptr;
3726 if (PipeType *PT = PipeTypes.FindNodeOrInsertPos(ID, InsertPos))
3727 return QualType(PT, 0);
3728
3729 // If the pipe element type isn't canonical, this won't be a canonical type
3730 // either, so fill in the canonical type field.
3731 QualType Canonical;
3732 if (!T.isCanonical()) {
3733 Canonical = getPipeType(getCanonicalType(T), ReadOnly);
3734
3735 // Get the new insert position for the node we care about.
3736 PipeType *NewIP = PipeTypes.FindNodeOrInsertPos(ID, InsertPos);
3737 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3737, __PRETTY_FUNCTION__))
;
3738 (void)NewIP;
3739 }
3740 auto *New = new (*this, TypeAlignment) PipeType(T, Canonical, ReadOnly);
3741 Types.push_back(New);
3742 PipeTypes.InsertNode(New, InsertPos);
3743 return QualType(New, 0);
3744}
3745
3746QualType ASTContext::adjustStringLiteralBaseType(QualType Ty) const {
3747 // OpenCL v1.1 s6.5.3: a string literal is in the constant address space.
3748 return LangOpts.OpenCL ? getAddrSpaceQualType(Ty, LangAS::opencl_constant)
3749 : Ty;
3750}
3751
3752QualType ASTContext::getReadPipeType(QualType T) const {
3753 return getPipeType(T, true);
3754}
3755
3756QualType ASTContext::getWritePipeType(QualType T) const {
3757 return getPipeType(T, false);
3758}
3759
3760#ifndef NDEBUG
3761static bool NeedsInjectedClassNameType(const RecordDecl *D) {
3762 if (!isa<CXXRecordDecl>(D)) return false;
3763 const auto *RD = cast<CXXRecordDecl>(D);
3764 if (isa<ClassTemplatePartialSpecializationDecl>(RD))
3765 return true;
3766 if (RD->getDescribedClassTemplate() &&
3767 !isa<ClassTemplateSpecializationDecl>(RD))
3768 return true;
3769 return false;
3770}
3771#endif
3772
3773/// getInjectedClassNameType - Return the unique reference to the
3774/// injected class name type for the specified templated declaration.
3775QualType ASTContext::getInjectedClassNameType(CXXRecordDecl *Decl,
3776 QualType TST) const {
3777 assert(NeedsInjectedClassNameType(Decl))((NeedsInjectedClassNameType(Decl)) ? static_cast<void>
(0) : __assert_fail ("NeedsInjectedClassNameType(Decl)", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3777, __PRETTY_FUNCTION__))
;
3778 if (Decl->TypeForDecl) {
3779 assert(isa<InjectedClassNameType>(Decl->TypeForDecl))((isa<InjectedClassNameType>(Decl->TypeForDecl)) ? static_cast
<void> (0) : __assert_fail ("isa<InjectedClassNameType>(Decl->TypeForDecl)"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3779, __PRETTY_FUNCTION__))
;
3780 } else if (CXXRecordDecl *PrevDecl = Decl->getPreviousDecl()) {
3781 assert(PrevDecl->TypeForDecl && "previous declaration has no type")((PrevDecl->TypeForDecl && "previous declaration has no type"
) ? static_cast<void> (0) : __assert_fail ("PrevDecl->TypeForDecl && \"previous declaration has no type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3781, __PRETTY_FUNCTION__))
;
3782 Decl->TypeForDecl = PrevDecl->TypeForDecl;
3783 assert(isa<InjectedClassNameType>(Decl->TypeForDecl))((isa<InjectedClassNameType>(Decl->TypeForDecl)) ? static_cast
<void> (0) : __assert_fail ("isa<InjectedClassNameType>(Decl->TypeForDecl)"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3783, __PRETTY_FUNCTION__))
;
3784 } else {
3785 Type *newType =
3786 new (*this, TypeAlignment) InjectedClassNameType(Decl, TST);
3787 Decl->TypeForDecl = newType;
3788 Types.push_back(newType);
3789 }
3790 return QualType(Decl->TypeForDecl, 0);
3791}
3792
3793/// getTypeDeclType - Return the unique reference to the type for the
3794/// specified type declaration.
3795QualType ASTContext::getTypeDeclTypeSlow(const TypeDecl *Decl) const {
3796 assert(Decl && "Passed null for Decl param")((Decl && "Passed null for Decl param") ? static_cast
<void> (0) : __assert_fail ("Decl && \"Passed null for Decl param\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3796, __PRETTY_FUNCTION__))
;
3797 assert(!Decl->TypeForDecl && "TypeForDecl present in slow case")((!Decl->TypeForDecl && "TypeForDecl present in slow case"
) ? static_cast<void> (0) : __assert_fail ("!Decl->TypeForDecl && \"TypeForDecl present in slow case\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3797, __PRETTY_FUNCTION__))
;
3798
3799 if (const auto *Typedef = dyn_cast<TypedefNameDecl>(Decl))
3800 return getTypedefType(Typedef);
3801
3802 assert(!isa<TemplateTypeParmDecl>(Decl) &&((!isa<TemplateTypeParmDecl>(Decl) && "Template type parameter types are always available."
) ? static_cast<void> (0) : __assert_fail ("!isa<TemplateTypeParmDecl>(Decl) && \"Template type parameter types are always available.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3803, __PRETTY_FUNCTION__))
3803 "Template type parameter types are always available.")((!isa<TemplateTypeParmDecl>(Decl) && "Template type parameter types are always available."
) ? static_cast<void> (0) : __assert_fail ("!isa<TemplateTypeParmDecl>(Decl) && \"Template type parameter types are always available.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3803, __PRETTY_FUNCTION__))
;
3804
3805 if (const auto *Record = dyn_cast<RecordDecl>(Decl)) {
3806 assert(Record->isFirstDecl() && "struct/union has previous declaration")((Record->isFirstDecl() && "struct/union has previous declaration"
) ? static_cast<void> (0) : __assert_fail ("Record->isFirstDecl() && \"struct/union has previous declaration\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3806, __PRETTY_FUNCTION__))
;
3807 assert(!NeedsInjectedClassNameType(Record))((!NeedsInjectedClassNameType(Record)) ? static_cast<void>
(0) : __assert_fail ("!NeedsInjectedClassNameType(Record)", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3807, __PRETTY_FUNCTION__))
;
3808 return getRecordType(Record);
3809 } else if (const auto *Enum = dyn_cast<EnumDecl>(Decl)) {
3810 assert(Enum->isFirstDecl() && "enum has previous declaration")((Enum->isFirstDecl() && "enum has previous declaration"
) ? static_cast<void> (0) : __assert_fail ("Enum->isFirstDecl() && \"enum has previous declaration\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3810, __PRETTY_FUNCTION__))
;
3811 return getEnumType(Enum);
3812 } else if (const auto *Using = dyn_cast<UnresolvedUsingTypenameDecl>(Decl)) {
3813 Type *newType = new (*this, TypeAlignment) UnresolvedUsingType(Using);
3814 Decl->TypeForDecl = newType;
3815 Types.push_back(newType);
3816 } else
3817 llvm_unreachable("TypeDecl without a type?")::llvm::llvm_unreachable_internal("TypeDecl without a type?",
"/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3817)
;
3818
3819 return QualType(Decl->TypeForDecl, 0);
3820}
3821
3822/// getTypedefType - Return the unique reference to the type for the
3823/// specified typedef name decl.
3824QualType
3825ASTContext::getTypedefType(const TypedefNameDecl *Decl,
3826 QualType Canonical) const {
3827 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3828
3829 if (Canonical.isNull())
3830 Canonical = getCanonicalType(Decl->getUnderlyingType());
3831 auto *newType = new (*this, TypeAlignment)
3832 TypedefType(Type::Typedef, Decl, Canonical);
3833 Decl->TypeForDecl = newType;
3834 Types.push_back(newType);
3835 return QualType(newType, 0);
3836}
3837
3838QualType ASTContext::getRecordType(const RecordDecl *Decl) const {
3839 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3840
3841 if (const RecordDecl *PrevDecl = Decl->getPreviousDecl())
3842 if (PrevDecl->TypeForDecl)
3843 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3844
3845 auto *newType = new (*this, TypeAlignment) RecordType(Decl);
3846 Decl->TypeForDecl = newType;
3847 Types.push_back(newType);
3848 return QualType(newType, 0);
3849}
3850
3851QualType ASTContext::getEnumType(const EnumDecl *Decl) const {
3852 if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
3853
3854 if (const EnumDecl *PrevDecl = Decl->getPreviousDecl())
3855 if (PrevDecl->TypeForDecl)
3856 return QualType(Decl->TypeForDecl = PrevDecl->TypeForDecl, 0);
3857
3858 auto *newType = new (*this, TypeAlignment) EnumType(Decl);
3859 Decl->TypeForDecl = newType;
3860 Types.push_back(newType);
3861 return QualType(newType, 0);
3862}
3863
3864QualType ASTContext::getAttributedType(attr::Kind attrKind,
3865 QualType modifiedType,
3866 QualType equivalentType) {
3867 llvm::FoldingSetNodeID id;
3868 AttributedType::Profile(id, attrKind, modifiedType, equivalentType);
3869
3870 void *insertPos = nullptr;
3871 AttributedType *type = AttributedTypes.FindNodeOrInsertPos(id, insertPos);
3872 if (type) return QualType(type, 0);
3873
3874 QualType canon = getCanonicalType(equivalentType);
3875 type = new (*this, TypeAlignment)
3876 AttributedType(canon, attrKind, modifiedType, equivalentType);
3877
3878 Types.push_back(type);
3879 AttributedTypes.InsertNode(type, insertPos);
3880
3881 return QualType(type, 0);
3882}
3883
3884/// Retrieve a substitution-result type.
3885QualType
3886ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
3887 QualType Replacement) const {
3888 assert(Replacement.isCanonical()((Replacement.isCanonical() && "replacement types must always be canonical"
) ? static_cast<void> (0) : __assert_fail ("Replacement.isCanonical() && \"replacement types must always be canonical\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3889, __PRETTY_FUNCTION__))
3889 && "replacement types must always be canonical")((Replacement.isCanonical() && "replacement types must always be canonical"
) ? static_cast<void> (0) : __assert_fail ("Replacement.isCanonical() && \"replacement types must always be canonical\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3889, __PRETTY_FUNCTION__))
;
3890
3891 llvm::FoldingSetNodeID ID;
3892 SubstTemplateTypeParmType::Profile(ID, Parm, Replacement);
3893 void *InsertPos = nullptr;
3894 SubstTemplateTypeParmType *SubstParm
3895 = SubstTemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3896
3897 if (!SubstParm) {
3898 SubstParm = new (*this, TypeAlignment)
3899 SubstTemplateTypeParmType(Parm, Replacement);
3900 Types.push_back(SubstParm);
3901 SubstTemplateTypeParmTypes.InsertNode(SubstParm, InsertPos);
3902 }
3903
3904 return QualType(SubstParm, 0);
3905}
3906
3907/// Retrieve a
3908QualType ASTContext::getSubstTemplateTypeParmPackType(
3909 const TemplateTypeParmType *Parm,
3910 const TemplateArgument &ArgPack) {
3911#ifndef NDEBUG
3912 for (const auto &P : ArgPack.pack_elements()) {
3913 assert(P.getKind() == TemplateArgument::Type &&"Pack contains a non-type")((P.getKind() == TemplateArgument::Type &&"Pack contains a non-type"
) ? static_cast<void> (0) : __assert_fail ("P.getKind() == TemplateArgument::Type &&\"Pack contains a non-type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3913, __PRETTY_FUNCTION__))
;
3914 assert(P.getAsType().isCanonical() && "Pack contains non-canonical type")((P.getAsType().isCanonical() && "Pack contains non-canonical type"
) ? static_cast<void> (0) : __assert_fail ("P.getAsType().isCanonical() && \"Pack contains non-canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3914, __PRETTY_FUNCTION__))
;
3915 }
3916#endif
3917
3918 llvm::FoldingSetNodeID ID;
3919 SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack);
3920 void *InsertPos = nullptr;
3921 if (SubstTemplateTypeParmPackType *SubstParm
3922 = SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos))
3923 return QualType(SubstParm, 0);
3924
3925 QualType Canon;
3926 if (!Parm->isCanonicalUnqualified()) {
3927 Canon = getCanonicalType(QualType(Parm, 0));
3928 Canon = getSubstTemplateTypeParmPackType(cast<TemplateTypeParmType>(Canon),
3929 ArgPack);
3930 SubstTemplateTypeParmPackTypes.FindNodeOrInsertPos(ID, InsertPos);
3931 }
3932
3933 auto *SubstParm
3934 = new (*this, TypeAlignment) SubstTemplateTypeParmPackType(Parm, Canon,
3935 ArgPack);
3936 Types.push_back(SubstParm);
3937 SubstTemplateTypeParmPackTypes.InsertNode(SubstParm, InsertPos);
3938 return QualType(SubstParm, 0);
3939}
3940
3941/// Retrieve the template type parameter type for a template
3942/// parameter or parameter pack with the given depth, index, and (optionally)
3943/// name.
3944QualType ASTContext::getTemplateTypeParmType(unsigned Depth, unsigned Index,
3945 bool ParameterPack,
3946 TemplateTypeParmDecl *TTPDecl) const {
3947 llvm::FoldingSetNodeID ID;
3948 TemplateTypeParmType::Profile(ID, Depth, Index, ParameterPack, TTPDecl);
3949 void *InsertPos = nullptr;
3950 TemplateTypeParmType *TypeParm
3951 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3952
3953 if (TypeParm)
3954 return QualType(TypeParm, 0);
3955
3956 if (TTPDecl) {
3957 QualType Canon = getTemplateTypeParmType(Depth, Index, ParameterPack);
3958 TypeParm = new (*this, TypeAlignment) TemplateTypeParmType(TTPDecl, Canon);
3959
3960 TemplateTypeParmType *TypeCheck
3961 = TemplateTypeParmTypes.FindNodeOrInsertPos(ID, InsertPos);
3962 assert(!TypeCheck && "Template type parameter canonical type broken")((!TypeCheck && "Template type parameter canonical type broken"
) ? static_cast<void> (0) : __assert_fail ("!TypeCheck && \"Template type parameter canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3962, __PRETTY_FUNCTION__))
;
3963 (void)TypeCheck;
3964 } else
3965 TypeParm = new (*this, TypeAlignment)
3966 TemplateTypeParmType(Depth, Index, ParameterPack);
3967
3968 Types.push_back(TypeParm);
3969 TemplateTypeParmTypes.InsertNode(TypeParm, InsertPos);
3970
3971 return QualType(TypeParm, 0);
3972}
3973
3974TypeSourceInfo *
3975ASTContext::getTemplateSpecializationTypeInfo(TemplateName Name,
3976 SourceLocation NameLoc,
3977 const TemplateArgumentListInfo &Args,
3978 QualType Underlying) const {
3979 assert(!Name.getAsDependentTemplateName() &&((!Name.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Name.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3980, __PRETTY_FUNCTION__))
3980 "No dependent template names here!")((!Name.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Name.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 3980, __PRETTY_FUNCTION__))
;
3981 QualType TST = getTemplateSpecializationType(Name, Args, Underlying);
3982
3983 TypeSourceInfo *DI = CreateTypeSourceInfo(TST);
3984 TemplateSpecializationTypeLoc TL =
3985 DI->getTypeLoc().castAs<TemplateSpecializationTypeLoc>();
3986 TL.setTemplateKeywordLoc(SourceLocation());
3987 TL.setTemplateNameLoc(NameLoc);
3988 TL.setLAngleLoc(Args.getLAngleLoc());
3989 TL.setRAngleLoc(Args.getRAngleLoc());
3990 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
3991 TL.setArgLocInfo(i, Args[i].getLocInfo());
3992 return DI;
3993}
3994
3995QualType
3996ASTContext::getTemplateSpecializationType(TemplateName Template,
3997 const TemplateArgumentListInfo &Args,
3998 QualType Underlying) const {
3999 assert(!Template.getAsDependentTemplateName() &&((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4000, __PRETTY_FUNCTION__))
4000 "No dependent template names here!")((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4000, __PRETTY_FUNCTION__))
;
4001
4002 SmallVector<TemplateArgument, 4> ArgVec;
4003 ArgVec.reserve(Args.size());
4004 for (const TemplateArgumentLoc &Arg : Args.arguments())
4005 ArgVec.push_back(Arg.getArgument());
4006
4007 return getTemplateSpecializationType(Template, ArgVec, Underlying);
4008}
4009
4010#ifndef NDEBUG
4011static bool hasAnyPackExpansions(ArrayRef<TemplateArgument> Args) {
4012 for (const TemplateArgument &Arg : Args)
4013 if (Arg.isPackExpansion())
4014 return true;
4015
4016 return true;
4017}
4018#endif
4019
4020QualType
4021ASTContext::getTemplateSpecializationType(TemplateName Template,
4022 ArrayRef<TemplateArgument> Args,
4023 QualType Underlying) const {
4024 assert(!Template.getAsDependentTemplateName() &&((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4025, __PRETTY_FUNCTION__))
4025 "No dependent template names here!")((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4025, __PRETTY_FUNCTION__))
;
4026 // Look through qualified template names.
4027 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
4028 Template = TemplateName(QTN->getTemplateDecl());
4029
4030 bool IsTypeAlias =
4031 Template.getAsTemplateDecl() &&
4032 isa<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
4033 QualType CanonType;
4034 if (!Underlying.isNull())
4035 CanonType = getCanonicalType(Underlying);
4036 else {
4037 // We can get here with an alias template when the specialization contains
4038 // a pack expansion that does not match up with a parameter pack.
4039 assert((!IsTypeAlias || hasAnyPackExpansions(Args)) &&(((!IsTypeAlias || hasAnyPackExpansions(Args)) && "Caller must compute aliased type"
) ? static_cast<void> (0) : __assert_fail ("(!IsTypeAlias || hasAnyPackExpansions(Args)) && \"Caller must compute aliased type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4040, __PRETTY_FUNCTION__))
4040 "Caller must compute aliased type")(((!IsTypeAlias || hasAnyPackExpansions(Args)) && "Caller must compute aliased type"
) ? static_cast<void> (0) : __assert_fail ("(!IsTypeAlias || hasAnyPackExpansions(Args)) && \"Caller must compute aliased type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4040, __PRETTY_FUNCTION__))
;
4041 IsTypeAlias = false;
4042 CanonType = getCanonicalTemplateSpecializationType(Template, Args);
4043 }
4044
4045 // Allocate the (non-canonical) template specialization type, but don't
4046 // try to unique it: these types typically have location information that
4047 // we don't unique and don't want to lose.
4048 void *Mem = Allocate(sizeof(TemplateSpecializationType) +
4049 sizeof(TemplateArgument) * Args.size() +
4050 (IsTypeAlias? sizeof(QualType) : 0),
4051 TypeAlignment);
4052 auto *Spec
4053 = new (Mem) TemplateSpecializationType(Template, Args, CanonType,
4054 IsTypeAlias ? Underlying : QualType());
4055
4056 Types.push_back(Spec);
4057 return QualType(Spec, 0);
4058}
4059
4060QualType ASTContext::getCanonicalTemplateSpecializationType(
4061 TemplateName Template, ArrayRef<TemplateArgument> Args) const {
4062 assert(!Template.getAsDependentTemplateName() &&((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4063, __PRETTY_FUNCTION__))
4063 "No dependent template names here!")((!Template.getAsDependentTemplateName() && "No dependent template names here!"
) ? static_cast<void> (0) : __assert_fail ("!Template.getAsDependentTemplateName() && \"No dependent template names here!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4063, __PRETTY_FUNCTION__))
;
4064
4065 // Look through qualified template names.
4066 if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
4067 Template = TemplateName(QTN->getTemplateDecl());
4068
4069 // Build the canonical template specialization type.
4070 TemplateName CanonTemplate = getCanonicalTemplateName(Template);
4071 SmallVector<TemplateArgument, 4> CanonArgs;
4072 unsigned NumArgs = Args.size();
4073 CanonArgs.reserve(NumArgs);
4074 for (const TemplateArgument &Arg : Args)
4075 CanonArgs.push_back(getCanonicalTemplateArgument(Arg));
4076
4077 // Determine whether this canonical template specialization type already
4078 // exists.
4079 llvm::FoldingSetNodeID ID;
4080 TemplateSpecializationType::Profile(ID, CanonTemplate,
4081 CanonArgs, *this);
4082
4083 void *InsertPos = nullptr;
4084 TemplateSpecializationType *Spec
4085 = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4086
4087 if (!Spec) {
4088 // Allocate a new canonical template specialization type.
4089 void *Mem = Allocate((sizeof(TemplateSpecializationType) +
4090 sizeof(TemplateArgument) * NumArgs),
4091 TypeAlignment);
4092 Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
4093 CanonArgs,
4094 QualType(), QualType());
4095 Types.push_back(Spec);
4096 TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
4097 }
4098
4099 assert(Spec->isDependentType() &&((Spec->isDependentType() && "Non-dependent template-id type must have a canonical type"
) ? static_cast<void> (0) : __assert_fail ("Spec->isDependentType() && \"Non-dependent template-id type must have a canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4100, __PRETTY_FUNCTION__))
4100 "Non-dependent template-id type must have a canonical type")((Spec->isDependentType() && "Non-dependent template-id type must have a canonical type"
) ? static_cast<void> (0) : __assert_fail ("Spec->isDependentType() && \"Non-dependent template-id type must have a canonical type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4100, __PRETTY_FUNCTION__))
;
4101 return QualType(Spec, 0);
4102}
4103
4104QualType ASTContext::getElaboratedType(ElaboratedTypeKeyword Keyword,
4105 NestedNameSpecifier *NNS,
4106 QualType NamedType,
4107 TagDecl *OwnedTagDecl) const {
4108 llvm::FoldingSetNodeID ID;
4109 ElaboratedType::Profile(ID, Keyword, NNS, NamedType, OwnedTagDecl);
4110
4111 void *InsertPos = nullptr;
4112 ElaboratedType *T = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
4113 if (T)
4114 return QualType(T, 0);
4115
4116 QualType Canon = NamedType;
4117 if (!Canon.isCanonical()) {
4118 Canon = getCanonicalType(NamedType);
4119 ElaboratedType *CheckT = ElaboratedTypes.FindNodeOrInsertPos(ID, InsertPos);
4120 assert(!CheckT && "Elaborated canonical type broken")((!CheckT && "Elaborated canonical type broken") ? static_cast
<void> (0) : __assert_fail ("!CheckT && \"Elaborated canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4120, __PRETTY_FUNCTION__))
;
4121 (void)CheckT;
4122 }
4123
4124 void *Mem = Allocate(ElaboratedType::totalSizeToAlloc<TagDecl *>(!!OwnedTagDecl),
4125 TypeAlignment);
4126 T = new (Mem) ElaboratedType(Keyword, NNS, NamedType, Canon, OwnedTagDecl);
4127
4128 Types.push_back(T);
4129 ElaboratedTypes.InsertNode(T, InsertPos);
4130 return QualType(T, 0);
4131}
4132
4133QualType
4134ASTContext::getParenType(QualType InnerType) const {
4135 llvm::FoldingSetNodeID ID;
4136 ParenType::Profile(ID, InnerType);
4137
4138 void *InsertPos = nullptr;
4139 ParenType *T = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4140 if (T)
4141 return QualType(T, 0);
4142
4143 QualType Canon = InnerType;
4144 if (!Canon.isCanonical()) {
4145 Canon = getCanonicalType(InnerType);
4146 ParenType *CheckT = ParenTypes.FindNodeOrInsertPos(ID, InsertPos);
4147 assert(!CheckT && "Paren canonical type broken")((!CheckT && "Paren canonical type broken") ? static_cast
<void> (0) : __assert_fail ("!CheckT && \"Paren canonical type broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4147, __PRETTY_FUNCTION__))
;
4148 (void)CheckT;
4149 }
4150
4151 T = new (*this, TypeAlignment) ParenType(InnerType, Canon);
4152 Types.push_back(T);
4153 ParenTypes.InsertNode(T, InsertPos);
4154 return QualType(T, 0);
4155}
4156
4157QualType ASTContext::getDependentNameType(ElaboratedTypeKeyword Keyword,
4158 NestedNameSpecifier *NNS,
4159 const IdentifierInfo *Name,
4160 QualType Canon) const {
4161 if (Canon.isNull()) {
4162 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
4163 if (CanonNNS != NNS)
4164 Canon = getDependentNameType(Keyword, CanonNNS, Name);
4165 }
4166
4167 llvm::FoldingSetNodeID ID;
4168 DependentNameType::Profile(ID, Keyword, NNS, Name);
4169
4170 void *InsertPos = nullptr;
4171 DependentNameType *T
4172 = DependentNameTypes.FindNodeOrInsertPos(ID, InsertPos);
4173 if (T)
4174 return QualType(T, 0);
4175
4176 T = new (*this, TypeAlignment) DependentNameType(Keyword, NNS, Name, Canon);
4177 Types.push_back(T);
4178 DependentNameTypes.InsertNode(T, InsertPos);
4179 return QualType(T, 0);
4180}
4181
4182QualType
4183ASTContext::getDependentTemplateSpecializationType(
4184 ElaboratedTypeKeyword Keyword,
4185 NestedNameSpecifier *NNS,
4186 const IdentifierInfo *Name,
4187 const TemplateArgumentListInfo &Args) const {
4188 // TODO: avoid this copy
4189 SmallVector<TemplateArgument, 16> ArgCopy;
4190 for (unsigned I = 0, E = Args.size(); I != E; ++I)
4191 ArgCopy.push_back(Args[I].getArgument());
4192 return getDependentTemplateSpecializationType(Keyword, NNS, Name, ArgCopy);
4193}
4194
4195QualType
4196ASTContext::getDependentTemplateSpecializationType(
4197 ElaboratedTypeKeyword Keyword,
4198 NestedNameSpecifier *NNS,
4199 const IdentifierInfo *Name,
4200 ArrayRef<TemplateArgument> Args) const {
4201 assert((!NNS || NNS->isDependent()) &&(((!NNS || NNS->isDependent()) && "nested-name-specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"nested-name-specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4202, __PRETTY_FUNCTION__))
4202 "nested-name-specifier must be dependent")(((!NNS || NNS->isDependent()) && "nested-name-specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"nested-name-specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4202, __PRETTY_FUNCTION__))
;
4203
4204 llvm::FoldingSetNodeID ID;
4205 DependentTemplateSpecializationType::Profile(ID, *this, Keyword, NNS,
4206 Name, Args);
4207
4208 void *InsertPos = nullptr;
4209 DependentTemplateSpecializationType *T
4210 = DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4211 if (T)
4212 return QualType(T, 0);
4213
4214 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
4215
4216 ElaboratedTypeKeyword CanonKeyword = Keyword;
4217 if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
4218
4219 bool AnyNonCanonArgs = false;
4220 unsigned NumArgs = Args.size();
4221 SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
4222 for (unsigned I = 0; I != NumArgs; ++I) {
4223 CanonArgs[I] = getCanonicalTemplateArgument(Args[I]);
4224 if (!CanonArgs[I].structurallyEquals(Args[I]))
4225 AnyNonCanonArgs = true;
4226 }
4227
4228 QualType Canon;
4229 if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
4230 Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
4231 Name,
4232 CanonArgs);
4233
4234 // Find the insert position again.
4235 DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
4236 }
4237
4238 void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
4239 sizeof(TemplateArgument) * NumArgs),
4240 TypeAlignment);
4241 T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
4242 Name, Args, Canon);
4243 Types.push_back(T);
4244 DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
4245 return QualType(T, 0);
4246}
4247
4248TemplateArgument ASTContext::getInjectedTemplateArg(NamedDecl *Param) {
4249 TemplateArgument Arg;
4250 if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
4251 QualType ArgType = getTypeDeclType(TTP);
4252 if (TTP->isParameterPack())
4253 ArgType = getPackExpansionType(ArgType, None);
4254
4255 Arg = TemplateArgument(ArgType);
4256 } else if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
4257 Expr *E = new (*this) DeclRefExpr(
4258 NTTP, /*enclosing*/false,
4259 NTTP->getType().getNonLValueExprType(*this),
4260 Expr::getValueKindForType(NTTP->getType()), NTTP->getLocation());
4261
4262 if (NTTP->isParameterPack())
4263 E = new (*this) PackExpansionExpr(DependentTy, E, NTTP->getLocation(),
4264 None);
4265 Arg = TemplateArgument(E);
4266 } else {
4267 auto *TTP = cast<TemplateTemplateParmDecl>(Param);
4268 if (TTP->isParameterPack())
4269 Arg = TemplateArgument(TemplateName(TTP), Optional<unsigned>());
4270 else
4271 Arg = TemplateArgument(TemplateName(TTP));
4272 }
4273
4274 if (Param->isTemplateParameterPack())
4275 Arg = TemplateArgument::CreatePackCopy(*this, Arg);
4276
4277 return Arg;
4278}
4279
4280void
4281ASTContext::getInjectedTemplateArgs(const TemplateParameterList *Params,
4282 SmallVectorImpl<TemplateArgument> &Args) {
4283 Args.reserve(Args.size() + Params->size());
4284
4285 for (NamedDecl *Param : *Params)
4286 Args.push_back(getInjectedTemplateArg(Param));
4287}
4288
4289QualType ASTContext::getPackExpansionType(QualType Pattern,
4290 Optional<unsigned> NumExpansions) {
4291 llvm::FoldingSetNodeID ID;
4292 PackExpansionType::Profile(ID, Pattern, NumExpansions);
4293
4294 assert(Pattern->containsUnexpandedParameterPack() &&((Pattern->containsUnexpandedParameterPack() && "Pack expansions must expand one or more parameter packs"
) ? static_cast<void> (0) : __assert_fail ("Pattern->containsUnexpandedParameterPack() && \"Pack expansions must expand one or more parameter packs\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4295, __PRETTY_FUNCTION__))
4295 "Pack expansions must expand one or more parameter packs")((Pattern->containsUnexpandedParameterPack() && "Pack expansions must expand one or more parameter packs"
) ? static_cast<void> (0) : __assert_fail ("Pattern->containsUnexpandedParameterPack() && \"Pack expansions must expand one or more parameter packs\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4295, __PRETTY_FUNCTION__))
;
4296 void *InsertPos = nullptr;
4297 PackExpansionType *T
4298 = PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4299 if (T)
4300 return QualType(T, 0);
4301
4302 QualType Canon;
4303 if (!Pattern.isCanonical()) {
4304 Canon = getCanonicalType(Pattern);
4305 // The canonical type might not contain an unexpanded parameter pack, if it
4306 // contains an alias template specialization which ignores one of its
4307 // parameters.
4308 if (Canon->containsUnexpandedParameterPack()) {
4309 Canon = getPackExpansionType(Canon, NumExpansions);
4310
4311 // Find the insert position again, in case we inserted an element into
4312 // PackExpansionTypes and invalidated our insert position.
4313 PackExpansionTypes.FindNodeOrInsertPos(ID, InsertPos);
4314 }
4315 }
4316
4317 T = new (*this, TypeAlignment)
4318 PackExpansionType(Pattern, Canon, NumExpansions);
4319 Types.push_back(T);
4320 PackExpansionTypes.InsertNode(T, InsertPos);
4321 return QualType(T, 0);
4322}
4323
4324/// CmpProtocolNames - Comparison predicate for sorting protocols
4325/// alphabetically.
4326static int CmpProtocolNames(ObjCProtocolDecl *const *LHS,
4327 ObjCProtocolDecl *const *RHS) {
4328 return DeclarationName::compare((*LHS)->getDeclName(), (*RHS)->getDeclName());
4329}
4330
4331static bool areSortedAndUniqued(ArrayRef<ObjCProtocolDecl *> Protocols) {
4332 if (Protocols.empty()) return true;
4333
4334 if (Protocols[0]->getCanonicalDecl() != Protocols[0])
4335 return false;
4336
4337 for (unsigned i = 1; i != Protocols.size(); ++i)
4338 if (CmpProtocolNames(&Protocols[i - 1], &Protocols[i]) >= 0 ||
4339 Protocols[i]->getCanonicalDecl() != Protocols[i])
4340 return false;
4341 return true;
4342}
4343
4344static void
4345SortAndUniqueProtocols(SmallVectorImpl<ObjCProtocolDecl *> &Protocols) {
4346 // Sort protocols, keyed by name.
4347 llvm::array_pod_sort(Protocols.begin(), Protocols.end(), CmpProtocolNames);
4348
4349 // Canonicalize.
4350 for (ObjCProtocolDecl *&P : Protocols)
4351 P = P->getCanonicalDecl();
4352
4353 // Remove duplicates.
4354 auto ProtocolsEnd = std::unique(Protocols.begin(), Protocols.end());
4355 Protocols.erase(ProtocolsEnd, Protocols.end());
4356}
4357
4358QualType ASTContext::getObjCObjectType(QualType BaseType,
4359 ObjCProtocolDecl * const *Protocols,
4360 unsigned NumProtocols) const {
4361 return getObjCObjectType(BaseType, {},
4362 llvm::makeArrayRef(Protocols, NumProtocols),
4363 /*isKindOf=*/false);
4364}
4365
4366QualType ASTContext::getObjCObjectType(
4367 QualType baseType,
4368 ArrayRef<QualType> typeArgs,
4369 ArrayRef<ObjCProtocolDecl *> protocols,
4370 bool isKindOf) const {
4371 // If the base type is an interface and there aren't any protocols or
4372 // type arguments to add, then the interface type will do just fine.
4373 if (typeArgs.empty() && protocols.empty() && !isKindOf &&
4374 isa<ObjCInterfaceType>(baseType))
4375 return baseType;
4376
4377 // Look in the folding set for an existing type.
4378 llvm::FoldingSetNodeID ID;
4379 ObjCObjectTypeImpl::Profile(ID, baseType, typeArgs, protocols, isKindOf);
4380 void *InsertPos = nullptr;
4381 if (ObjCObjectType *QT = ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos))
4382 return QualType(QT, 0);
4383
4384 // Determine the type arguments to be used for canonicalization,
4385 // which may be explicitly specified here or written on the base
4386 // type.
4387 ArrayRef<QualType> effectiveTypeArgs = typeArgs;
4388 if (effectiveTypeArgs.empty()) {
4389 if (const auto *baseObject = baseType->getAs<ObjCObjectType>())
4390 effectiveTypeArgs = baseObject->getTypeArgs();
4391 }
4392
4393 // Build the canonical type, which has the canonical base type and a
4394 // sorted-and-uniqued list of protocols and the type arguments
4395 // canonicalized.
4396 QualType canonical;
4397 bool typeArgsAreCanonical = std::all_of(effectiveTypeArgs.begin(),
4398 effectiveTypeArgs.end(),
4399 [&](QualType type) {
4400 return type.isCanonical();
4401 });
4402 bool protocolsSorted = areSortedAndUniqued(protocols);
4403 if (!typeArgsAreCanonical || !protocolsSorted || !baseType.isCanonical()) {
4404 // Determine the canonical type arguments.
4405 ArrayRef<QualType> canonTypeArgs;
4406 SmallVector<QualType, 4> canonTypeArgsVec;
4407 if (!typeArgsAreCanonical) {
4408 canonTypeArgsVec.reserve(effectiveTypeArgs.size());
4409 for (auto typeArg : effectiveTypeArgs)
4410 canonTypeArgsVec.push_back(getCanonicalType(typeArg));
4411 canonTypeArgs = canonTypeArgsVec;
4412 } else {
4413 canonTypeArgs = effectiveTypeArgs;
4414 }
4415
4416 ArrayRef<ObjCProtocolDecl *> canonProtocols;
4417 SmallVector<ObjCProtocolDecl*, 8> canonProtocolsVec;
4418 if (!protocolsSorted) {
4419 canonProtocolsVec.append(protocols.begin(), protocols.end());
4420 SortAndUniqueProtocols(canonProtocolsVec);
4421 canonProtocols = canonProtocolsVec;
4422 } else {
4423 canonProtocols = protocols;
4424 }
4425
4426 canonical = getObjCObjectType(getCanonicalType(baseType), canonTypeArgs,
4427 canonProtocols, isKindOf);
4428
4429 // Regenerate InsertPos.
4430 ObjCObjectTypes.FindNodeOrInsertPos(ID, InsertPos);
4431 }
4432
4433 unsigned size = sizeof(ObjCObjectTypeImpl);
4434 size += typeArgs.size() * sizeof(QualType);
4435 size += protocols.size() * sizeof(ObjCProtocolDecl *);
4436 void *mem = Allocate(size, TypeAlignment);
4437 auto *T =
4438 new (mem) ObjCObjectTypeImpl(canonical, baseType, typeArgs, protocols,
4439 isKindOf);
4440
4441 Types.push_back(T);
4442 ObjCObjectTypes.InsertNode(T, InsertPos);
4443 return QualType(T, 0);
4444}
4445
4446/// Apply Objective-C protocol qualifiers to the given type.
4447/// If this is for the canonical type of a type parameter, we can apply
4448/// protocol qualifiers on the ObjCObjectPointerType.
4449QualType
4450ASTContext::applyObjCProtocolQualifiers(QualType type,
4451 ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
4452 bool allowOnPointerType) const {
4453 hasError = false;
4454
4455 if (const auto *objT = dyn_cast<ObjCTypeParamType>(type.getTypePtr())) {
4456 return getObjCTypeParamType(objT->getDecl(), protocols);
4457 }
4458
4459 // Apply protocol qualifiers to ObjCObjectPointerType.
4460 if (allowOnPointerType) {
4461 if (const auto *objPtr =
4462 dyn_cast<ObjCObjectPointerType>(type.getTypePtr())) {
4463 const ObjCObjectType *objT = objPtr->getObjectType();
4464 // Merge protocol lists and construct ObjCObjectType.
4465 SmallVector<ObjCProtocolDecl*, 8> protocolsVec;
4466 protocolsVec.append(objT->qual_begin(),
4467 objT->qual_end());
4468 protocolsVec.append(protocols.begin(), protocols.end());
4469 ArrayRef<ObjCProtocolDecl *> protocols = protocolsVec;
4470 type = getObjCObjectType(
4471 objT->getBaseType(),
4472 objT->getTypeArgsAsWritten(),
4473 protocols,
4474 objT->isKindOfTypeAsWritten());
4475 return getObjCObjectPointerType(type);
4476 }
4477 }
4478
4479 // Apply protocol qualifiers to ObjCObjectType.
4480 if (const auto *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){
4481 // FIXME: Check for protocols to which the class type is already
4482 // known to conform.
4483
4484 return getObjCObjectType(objT->getBaseType(),
4485 objT->getTypeArgsAsWritten(),
4486 protocols,
4487 objT->isKindOfTypeAsWritten());
4488 }
4489
4490 // If the canonical type is ObjCObjectType, ...
4491 if (type->isObjCObjectType()) {
4492 // Silently overwrite any existing protocol qualifiers.
4493 // TODO: determine whether that's the right thing to do.
4494
4495 // FIXME: Check for protocols to which the class type is already
4496 // known to conform.
4497 return getObjCObjectType(type, {}, protocols, false);
4498 }
4499
4500 // id<protocol-list>
4501 if (type->isObjCIdType()) {
4502 const auto *objPtr = type->castAs<ObjCObjectPointerType>();
4503 type = getObjCObjectType(ObjCBuiltinIdTy, {}, protocols,
4504 objPtr->isKindOfType());
4505 return getObjCObjectPointerType(type);
4506 }
4507
4508 // Class<protocol-list>
4509 if (type->isObjCClassType()) {
4510 const auto *objPtr = type->castAs<ObjCObjectPointerType>();
4511 type = getObjCObjectType(ObjCBuiltinClassTy, {}, protocols,
4512 objPtr->isKindOfType());
4513 return getObjCObjectPointerType(type);
4514 }
4515
4516 hasError = true;
4517 return type;
4518}
4519
4520QualType
4521ASTContext::getObjCTypeParamType(const ObjCTypeParamDecl *Decl,
4522 ArrayRef<ObjCProtocolDecl *> protocols,
4523 QualType Canonical) const {
4524 // Look in the folding set for an existing type.
4525 llvm::FoldingSetNodeID ID;
4526 ObjCTypeParamType::Profile(ID, Decl, protocols);
4527 void *InsertPos = nullptr;
4528 if (ObjCTypeParamType *TypeParam =
4529 ObjCTypeParamTypes.FindNodeOrInsertPos(ID, InsertPos))
4530 return QualType(TypeParam, 0);
4531
4532 if (Canonical.isNull()) {
4533 // We canonicalize to the underlying type.
4534 Canonical = getCanonicalType(Decl->getUnderlyingType());
4535 if (!protocols.empty()) {
4536 // Apply the protocol qualifers.
4537 bool hasError;
4538 Canonical = getCanonicalType(applyObjCProtocolQualifiers(
4539 Canonical, protocols, hasError, true /*allowOnPointerType*/));
4540 assert(!hasError && "Error when apply protocol qualifier to bound type")((!hasError && "Error when apply protocol qualifier to bound type"
) ? static_cast<void> (0) : __assert_fail ("!hasError && \"Error when apply protocol qualifier to bound type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4540, __PRETTY_FUNCTION__))
;
4541 }
4542 }
4543
4544 unsigned size = sizeof(ObjCTypeParamType);
4545 size += protocols.size() * sizeof(ObjCProtocolDecl *);
4546 void *mem = Allocate(size, TypeAlignment);
4547 auto *newType = new (mem) ObjCTypeParamType(Decl, Canonical, protocols);
4548
4549 Types.push_back(newType);
4550 ObjCTypeParamTypes.InsertNode(newType, InsertPos);
4551 return QualType(newType, 0);
4552}
4553
4554/// ObjCObjectAdoptsQTypeProtocols - Checks that protocols in IC's
4555/// protocol list adopt all protocols in QT's qualified-id protocol
4556/// list.
4557bool ASTContext::ObjCObjectAdoptsQTypeProtocols(QualType QT,
4558 ObjCInterfaceDecl *IC) {
4559 if (!QT->isObjCQualifiedIdType())
4560 return false;
4561
4562 if (const auto *OPT = QT->getAs<ObjCObjectPointerType>()) {
4563 // If both the right and left sides have qualifiers.
4564 for (auto *Proto : OPT->quals()) {
4565 if (!IC->ClassImplementsProtocol(Proto, false))
4566 return false;
4567 }
4568 return true;
4569 }
4570 return false;
4571}
4572
4573/// QIdProtocolsAdoptObjCObjectProtocols - Checks that protocols in
4574/// QT's qualified-id protocol list adopt all protocols in IDecl's list
4575/// of protocols.
4576bool ASTContext::QIdProtocolsAdoptObjCObjectProtocols(QualType QT,
4577 ObjCInterfaceDecl *IDecl) {
4578 if (!QT->isObjCQualifiedIdType())
4579 return false;
4580 const auto *OPT = QT->getAs<ObjCObjectPointerType>();
4581 if (!OPT)
4582 return false;
4583 if (!IDecl->hasDefinition())
4584 return false;
4585 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> InheritedProtocols;
4586 CollectInheritedProtocols(IDecl, InheritedProtocols);
4587 if (InheritedProtocols.empty())
4588 return false;
4589 // Check that if every protocol in list of id<plist> conforms to a protocol
4590 // of IDecl's, then bridge casting is ok.
4591 bool Conforms = false;
4592 for (auto *Proto : OPT->quals()) {
4593 Conforms = false;
4594 for (auto *PI : InheritedProtocols) {
4595 if (ProtocolCompatibleWithProtocol(Proto, PI)) {
4596 Conforms = true;
4597 break;
4598 }
4599 }
4600 if (!Conforms)
4601 break;
4602 }
4603 if (Conforms)
4604 return true;
4605
4606 for (auto *PI : InheritedProtocols) {
4607 // If both the right and left sides have qualifiers.
4608 bool Adopts = false;
4609 for (auto *Proto : OPT->quals()) {
4610 // return 'true' if 'PI' is in the inheritance hierarchy of Proto
4611 if ((Adopts = ProtocolCompatibleWithProtocol(PI, Proto)))
4612 break;
4613 }
4614 if (!Adopts)
4615 return false;
4616 }
4617 return true;
4618}
4619
4620/// getObjCObjectPointerType - Return a ObjCObjectPointerType type for
4621/// the given object type.
4622QualType ASTContext::getObjCObjectPointerType(QualType ObjectT) const {
4623 llvm::FoldingSetNodeID ID;
4624 ObjCObjectPointerType::Profile(ID, ObjectT);
4625
4626 void *InsertPos = nullptr;
4627 if (ObjCObjectPointerType *QT =
4628 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos))
4629 return QualType(QT, 0);
4630
4631 // Find the canonical object type.
4632 QualType Canonical;
4633 if (!ObjectT.isCanonical()) {
4634 Canonical = getObjCObjectPointerType(getCanonicalType(ObjectT));
4635
4636 // Regenerate InsertPos.
4637 ObjCObjectPointerTypes.FindNodeOrInsertPos(ID, InsertPos);
4638 }
4639
4640 // No match.
4641 void *Mem = Allocate(sizeof(ObjCObjectPointerType), TypeAlignment);
4642 auto *QType =
4643 new (Mem) ObjCObjectPointerType(Canonical, ObjectT);
4644
4645 Types.push_back(QType);
4646 ObjCObjectPointerTypes.InsertNode(QType, InsertPos);
4647 return QualType(QType, 0);
4648}
4649
4650/// getObjCInterfaceType - Return the unique reference to the type for the
4651/// specified ObjC interface decl. The list of protocols is optional.
4652QualType ASTContext::getObjCInterfaceType(const ObjCInterfaceDecl *Decl,
4653 ObjCInterfaceDecl *PrevDecl) const {
4654 if (Decl->TypeForDecl)
4655 return QualType(Decl->TypeForDecl, 0);
4656
4657 if (PrevDecl) {
4658 assert(PrevDecl->TypeForDecl && "previous decl has no TypeForDecl")((PrevDecl->TypeForDecl && "previous decl has no TypeForDecl"
) ? static_cast<void> (0) : __assert_fail ("PrevDecl->TypeForDecl && \"previous decl has no TypeForDecl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4658, __PRETTY_FUNCTION__))
;
4659 Decl->TypeForDecl = PrevDecl->TypeForDecl;
4660 return QualType(PrevDecl->TypeForDecl, 0);
4661 }
4662
4663 // Prefer the definition, if there is one.
4664 if (const ObjCInterfaceDecl *Def = Decl->getDefinition())
4665 Decl = Def;
4666
4667 void *Mem = Allocate(sizeof(ObjCInterfaceType), TypeAlignment);
4668 auto *T = new (Mem) ObjCInterfaceType(Decl);
4669 Decl->TypeForDecl = T;
4670 Types.push_back(T);
4671 return QualType(T, 0);
4672}
4673
4674/// getTypeOfExprType - Unlike many "get<Type>" functions, we can't unique
4675/// TypeOfExprType AST's (since expression's are never shared). For example,
4676/// multiple declarations that refer to "typeof(x)" all contain different
4677/// DeclRefExpr's. This doesn't effect the type checker, since it operates
4678/// on canonical type's (which are always unique).
4679QualType ASTContext::getTypeOfExprType(Expr *tofExpr) const {
4680 TypeOfExprType *toe;
4681 if (tofExpr->isTypeDependent()) {
4682 llvm::FoldingSetNodeID ID;
4683 DependentTypeOfExprType::Profile(ID, *this, tofExpr);
4684
4685 void *InsertPos = nullptr;
4686 DependentTypeOfExprType *Canon
4687 = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
4688 if (Canon) {
4689 // We already have a "canonical" version of an identical, dependent
4690 // typeof(expr) type. Use that as our canonical type.
4691 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
4692 QualType((TypeOfExprType*)Canon, 0));
4693 } else {
4694 // Build a new, canonical typeof(expr) type.
4695 Canon
4696 = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
4697 DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
4698 toe = Canon;
4699 }
4700 } else {
4701 QualType Canonical = getCanonicalType(tofExpr->getType());
4702 toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);
4703 }
4704 Types.push_back(toe);
4705 return QualType(toe, 0);
4706}
4707
4708/// getTypeOfType - Unlike many "get<Type>" functions, we don't unique
4709/// TypeOfType nodes. The only motivation to unique these nodes would be
4710/// memory savings. Since typeof(t) is fairly uncommon, space shouldn't be
4711/// an issue. This doesn't affect the type checker, since it operates
4712/// on canonical types (which are always unique).
4713QualType ASTContext::getTypeOfType(QualType tofType) const {
4714 QualType Canonical = getCanonicalType(tofType);
4715 auto *tot = new (*this, TypeAlignment) TypeOfType(tofType, Canonical);
4716 Types.push_back(tot);
4717 return QualType(tot, 0);
4718}
4719
4720/// Unlike many "get<Type>" functions, we don't unique DecltypeType
4721/// nodes. This would never be helpful, since each such type has its own
4722/// expression, and would not give a significant memory saving, since there
4723/// is an Expr tree under each such type.
4724QualType ASTContext::getDecltypeType(Expr *e, QualType UnderlyingType) const {
4725 DecltypeType *dt;
4726
4727 // C++11 [temp.type]p2:
4728 // If an expression e involves a template parameter, decltype(e) denotes a
4729 // unique dependent type. Two such decltype-specifiers refer to the same
4730 // type only if their expressions are equivalent (14.5.6.1).
4731 if (e->isInstantiationDependent()) {
4732 llvm::FoldingSetNodeID ID;
4733 DependentDecltypeType::Profile(ID, *this, e);
4734
4735 void *InsertPos = nullptr;
4736 DependentDecltypeType *Canon
4737 = DependentDecltypeTypes.FindNodeOrInsertPos(ID, InsertPos);
4738 if (!Canon) {
4739 // Build a new, canonical decltype(expr) type.
4740 Canon = new (*this, TypeAlignment) DependentDecltypeType(*this, e);
4741 DependentDecltypeTypes.InsertNode(Canon, InsertPos);
4742 }
4743 dt = new (*this, TypeAlignment)
4744 DecltypeType(e, UnderlyingType, QualType((DecltypeType *)Canon, 0));
4745 } else {
4746 dt = new (*this, TypeAlignment)
4747 DecltypeType(e, UnderlyingType, getCanonicalType(UnderlyingType));
4748 }
4749 Types.push_back(dt);
4750 return QualType(dt, 0);
4751}
4752
4753/// getUnaryTransformationType - We don't unique these, since the memory
4754/// savings are minimal and these are rare.
4755QualType ASTContext::getUnaryTransformType(QualType BaseType,
4756 QualType UnderlyingType,
4757 UnaryTransformType::UTTKind Kind)
4758 const {
4759 UnaryTransformType *ut = nullptr;
4760
4761 if (BaseType->isDependentType()) {
4762 // Look in the folding set for an existing type.
4763 llvm::FoldingSetNodeID ID;
4764 DependentUnaryTransformType::Profile(ID, getCanonicalType(BaseType), Kind);
4765
4766 void *InsertPos = nullptr;
4767 DependentUnaryTransformType *Canon
4768 = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
4769
4770 if (!Canon) {
4771 // Build a new, canonical __underlying_type(type) type.
4772 Canon = new (*this, TypeAlignment)
4773 DependentUnaryTransformType(*this, getCanonicalType(BaseType),
4774 Kind);
4775 DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);
4776 }
4777 ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4778 QualType(), Kind,
4779 QualType(Canon, 0));
4780 } else {
4781 QualType CanonType = getCanonicalType(UnderlyingType);
4782 ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
4783 UnderlyingType, Kind,
4784 CanonType);
4785 }
4786 Types.push_back(ut);
4787 return QualType(ut, 0);
4788}
4789
4790/// getAutoType - Return the uniqued reference to the 'auto' type which has been
4791/// deduced to the given type, or to the canonical undeduced 'auto' type, or the
4792/// canonical deduced-but-dependent 'auto' type.
4793QualType ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
4794 bool IsDependent) const {
4795 if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto && !IsDependent)
4796 return getAutoDeductType();
4797
4798 // Look in the folding set for an existing type.
4799 void *InsertPos = nullptr;
4800 llvm::FoldingSetNodeID ID;
4801 AutoType::Profile(ID, DeducedType, Keyword, IsDependent);
4802 if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
4803 return QualType(AT, 0);
4804
4805 auto *AT = new (*this, TypeAlignment)
4806 AutoType(DeducedType, Keyword, IsDependent);
4807 Types.push_back(AT);
4808 if (InsertPos)
4809 AutoTypes.InsertNode(AT, InsertPos);
4810 return QualType(AT, 0);
4811}
4812
4813/// Return the uniqued reference to the deduced template specialization type
4814/// which has been deduced to the given type, or to the canonical undeduced
4815/// such type, or the canonical deduced-but-dependent such type.
4816QualType ASTContext::getDeducedTemplateSpecializationType(
4817 TemplateName Template, QualType DeducedType, bool IsDependent) const {
4818 // Look in the folding set for an existing type.
4819 void *InsertPos = nullptr;
4820 llvm::FoldingSetNodeID ID;
4821 DeducedTemplateSpecializationType::Profile(ID, Template, DeducedType,
4822 IsDependent);
4823 if (DeducedTemplateSpecializationType *DTST =
4824 DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
4825 return QualType(DTST, 0);
4826
4827 auto *DTST = new (*this, TypeAlignment)
4828 DeducedTemplateSpecializationType(Template, DeducedType, IsDependent);
4829 Types.push_back(DTST);
4830 if (InsertPos)
4831 DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
4832 return QualType(DTST, 0);
4833}
4834
4835/// getAtomicType - Return the uniqued reference to the atomic type for
4836/// the given value type.
4837QualType ASTContext::getAtomicType(QualType T) const {
4838 // Unique pointers, to guarantee there is only one pointer of a particular
4839 // structure.
4840 llvm::FoldingSetNodeID ID;
4841 AtomicType::Profile(ID, T);
4842
4843 void *InsertPos = nullptr;
4844 if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
4845 return QualType(AT, 0);
4846
4847 // If the atomic value type isn't canonical, this won't be a canonical type
4848 // either, so fill in the canonical type field.
4849 QualType Canonical;
4850 if (!T.isCanonical()) {
4851 Canonical = getAtomicType(getCanonicalType(T));
4852
4853 // Get the new insert position for the node we care about.
4854 AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
4855 assert(!NewIP && "Shouldn't be in the map!")((!NewIP && "Shouldn't be in the map!") ? static_cast
<void> (0) : __assert_fail ("!NewIP && \"Shouldn't be in the map!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4855, __PRETTY_FUNCTION__))
; (void)NewIP;
4856 }
4857 auto *New = new (*this, TypeAlignment) AtomicType(T, Canonical);
4858 Types.push_back(New);
4859 AtomicTypes.InsertNode(New, InsertPos);
4860 return QualType(New, 0);
4861}
4862
4863/// getAutoDeductType - Get type pattern for deducing against 'auto'.
4864QualType ASTContext::getAutoDeductType() const {
4865 if (AutoDeductTy.isNull())
4866 AutoDeductTy = QualType(
4867 new (*this, TypeAlignment) AutoType(QualType(), AutoTypeKeyword::Auto,
4868 /*dependent*/false),
4869 0);
4870 return AutoDeductTy;
4871}
4872
4873/// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'.
4874QualType ASTContext::getAutoRRefDeductType() const {
4875 if (AutoRRefDeductTy.isNull())
4876 AutoRRefDeductTy = getRValueReferenceType(getAutoDeductType());
4877 assert(!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern")((!AutoRRefDeductTy.isNull() && "can't build 'auto &&' pattern"
) ? static_cast<void> (0) : __assert_fail ("!AutoRRefDeductTy.isNull() && \"can't build 'auto &&' pattern\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4877, __PRETTY_FUNCTION__))
;
4878 return AutoRRefDeductTy;
4879}
4880
4881/// getTagDeclType - Return the unique reference to the type for the
4882/// specified TagDecl (struct/union/class/enum) decl.
4883QualType ASTContext::getTagDeclType(const TagDecl *Decl) const {
4884 assert(Decl)((Decl) ? static_cast<void> (0) : __assert_fail ("Decl"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 4884, __PRETTY_FUNCTION__))
;
4885 // FIXME: What is the design on getTagDeclType when it requires casting
4886 // away const? mutable?
4887 return getTypeDeclType(const_cast<TagDecl*>(Decl));
4888}
4889
4890/// getSizeType - Return the unique type for "size_t" (C99 7.17), the result
4891/// of the sizeof operator (C99 6.5.3.4p4). The value is target dependent and
4892/// needs to agree with the definition in <stddef.h>.
4893CanQualType ASTContext::getSizeType() const {
4894 return getFromTargetType(Target->getSizeType());
4895}
4896
4897/// Return the unique signed counterpart of the integer type
4898/// corresponding to size_t.
4899CanQualType ASTContext::getSignedSizeType() const {
4900 return getFromTargetType(Target->getSignedSizeType());
4901}
4902
4903/// getIntMaxType - Return the unique type for "intmax_t" (C99 7.18.1.5).
4904CanQualType ASTContext::getIntMaxType() const {
4905 return getFromTargetType(Target->getIntMaxType());
4906}
4907
4908/// getUIntMaxType - Return the unique type for "uintmax_t" (C99 7.18.1.5).
4909CanQualType ASTContext::getUIntMaxType() const {
4910 return getFromTargetType(Target->getUIntMaxType());
4911}
4912
4913/// getSignedWCharType - Return the type of "signed wchar_t".
4914/// Used when in C++, as a GCC extension.
4915QualType ASTContext::getSignedWCharType() const {
4916 // FIXME: derive from "Target" ?
4917 return WCharTy;
4918}
4919
4920/// getUnsignedWCharType - Return the type of "unsigned wchar_t".
4921/// Used when in C++, as a GCC extension.
4922QualType ASTContext::getUnsignedWCharType() const {
4923 // FIXME: derive from "Target" ?
4924 return UnsignedIntTy;
4925}
4926
4927QualType ASTContext::getIntPtrType() const {
4928 return getFromTargetType(Target->getIntPtrType());
4929}
4930
4931QualType ASTContext::getUIntPtrType() const {
4932 return getCorrespondingUnsignedType(getIntPtrType());
4933}
4934
4935/// getPointerDiffType - Return the unique type for "ptrdiff_t" (C99 7.17)
4936/// defined in <stddef.h>. Pointer - pointer requires this (C99 6.5.6p9).
4937QualType ASTContext::getPointerDiffType() const {
4938 return getFromTargetType(Target->getPtrDiffType(0));
4939}
4940
4941/// Return the unique unsigned counterpart of "ptrdiff_t"
4942/// integer type. The standard (C11 7.21.6.1p7) refers to this type
4943/// in the definition of %tu format specifier.
4944QualType ASTContext::getUnsignedPointerDiffType() const {
4945 return getFromTargetType(Target->getUnsignedPtrDiffType(0));
4946}
4947
4948/// Return the unique type for "pid_t" defined in
4949/// <sys/types.h>. We need this to compute the correct type for vfork().
4950QualType ASTContext::getProcessIDType() const {
4951 return getFromTargetType(Target->getProcessIDType());
4952}
4953
4954//===----------------------------------------------------------------------===//
4955// Type Operators
4956//===----------------------------------------------------------------------===//
4957
4958CanQualType ASTContext::getCanonicalParamType(QualType T) const {
4959 // Push qualifiers into arrays, and then discard any remaining
4960 // qualifiers.
4961 T = getCanonicalType(T);
4962 T = getVariableArrayDecayedType(T);
4963 const Type *Ty = T.getTypePtr();
4964 QualType Result;
4965 if (isa<ArrayType>(Ty)) {
4966 Result = getArrayDecayedType(QualType(Ty,0));
4967 } else if (isa<FunctionType>(Ty)) {
4968 Result = getPointerType(QualType(Ty, 0));
4969 } else {
4970 Result = QualType(Ty, 0);
4971 }
4972
4973 return CanQualType::CreateUnsafe(Result);
4974}
4975
4976QualType ASTContext::getUnqualifiedArrayType(QualType type,
4977 Qualifiers &quals) {
4978 SplitQualType splitType = type.getSplitUnqualifiedType();
4979
4980 // FIXME: getSplitUnqualifiedType() actually walks all the way to
4981 // the unqualified desugared type and then drops it on the floor.
4982 // We then have to strip that sugar back off with
4983 // getUnqualifiedDesugaredType(), which is silly.
4984 const auto *AT =
4985 dyn_cast<ArrayType>(splitType.Ty->getUnqualifiedDesugaredType());
4986
4987 // If we don't have an array, just use the results in splitType.
4988 if (!AT) {
4989 quals = splitType.Quals;
4990 return QualType(splitType.Ty, 0);
4991 }
4992
4993 // Otherwise, recurse on the array's element type.
4994 QualType elementType = AT->getElementType();
4995 QualType unqualElementType = getUnqualifiedArrayType(elementType, quals);
4996
4997 // If that didn't change the element type, AT has no qualifiers, so we
4998 // can just use the results in splitType.
4999 if (elementType == unqualElementType) {
5000 assert(quals.empty())((quals.empty()) ? static_cast<void> (0) : __assert_fail
("quals.empty()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5000, __PRETTY_FUNCTION__))
; // from the recursive call
5001 quals = splitType.Quals;
5002 return QualType(splitType.Ty, 0);
5003 }
5004
5005 // Otherwise, add in the qualifiers from the outermost type, then
5006 // build the type back up.
5007 quals.addConsistentQualifiers(splitType.Quals);
5008
5009 if (const auto *CAT = dyn_cast<ConstantArrayType>(AT)) {
5010 return getConstantArrayType(unqualElementType, CAT->getSize(),
5011 CAT->getSizeModifier(), 0);
5012 }
5013
5014 if (const auto *IAT = dyn_cast<IncompleteArrayType>(AT)) {
5015 return getIncompleteArrayType(unqualElementType, IAT->getSizeModifier(), 0);
5016 }
5017
5018 if (const auto *VAT = dyn_cast<VariableArrayType>(AT)) {
5019 return getVariableArrayType(unqualElementType,
5020 VAT->getSizeExpr(),
5021 VAT->getSizeModifier(),
5022 VAT->getIndexTypeCVRQualifiers(),
5023 VAT->getBracketsRange());
5024 }
5025
5026 const auto *DSAT = cast<DependentSizedArrayType>(AT);
5027 return getDependentSizedArrayType(unqualElementType, DSAT->getSizeExpr(),
5028 DSAT->getSizeModifier(), 0,
5029 SourceRange());
5030}
5031
5032/// Attempt to unwrap two types that may both be array types with the same bound
5033/// (or both be array types of unknown bound) for the purpose of comparing the
5034/// cv-decomposition of two types per C++ [conv.qual].
5035bool ASTContext::UnwrapSimilarArrayTypes(QualType &T1, QualType &T2) {
5036 bool UnwrappedAny = false;
5037 while (true) {
5038 auto *AT1 = getAsArrayType(T1);
5039 if (!AT1) return UnwrappedAny;
5040
5041 auto *AT2 = getAsArrayType(T2);
5042 if (!AT2) return UnwrappedAny;
5043
5044 // If we don't have two array types with the same constant bound nor two
5045 // incomplete array types, we've unwrapped everything we can.
5046 if (auto *CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
5047 auto *CAT2 = dyn_cast<ConstantArrayType>(AT2);
5048 if (!CAT2 || CAT1->getSize() != CAT2->getSize())
5049 return UnwrappedAny;
5050 } else if (!isa<IncompleteArrayType>(AT1) ||
5051 !isa<IncompleteArrayType>(AT2)) {
5052 return UnwrappedAny;
5053 }
5054
5055 T1 = AT1->getElementType();
5056 T2 = AT2->getElementType();
5057 UnwrappedAny = true;
5058 }
5059}
5060
5061/// Attempt to unwrap two types that may be similar (C++ [conv.qual]).
5062///
5063/// If T1 and T2 are both pointer types of the same kind, or both array types
5064/// with the same bound, unwraps layers from T1 and T2 until a pointer type is
5065/// unwrapped. Top-level qualifiers on T1 and T2 are ignored.
5066///
5067/// This function will typically be called in a loop that successively
5068/// "unwraps" pointer and pointer-to-member types to compare them at each
5069/// level.
5070///
5071/// \return \c true if a pointer type was unwrapped, \c false if we reached a
5072/// pair of types that can't be unwrapped further.
5073bool ASTContext::UnwrapSimilarTypes(QualType &T1, QualType &T2) {
5074 UnwrapSimilarArrayTypes(T1, T2);
5075
5076 const auto *T1PtrType = T1->getAs<PointerType>();
5077 const auto *T2PtrType = T2->getAs<PointerType>();
5078 if (T1PtrType && T2PtrType) {
5079 T1 = T1PtrType->getPointeeType();
5080 T2 = T2PtrType->getPointeeType();
5081 return true;
5082 }
5083
5084 const auto *T1MPType = T1->getAs<MemberPointerType>();
5085 const auto *T2MPType = T2->getAs<MemberPointerType>();
5086 if (T1MPType && T2MPType &&
5087 hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
5088 QualType(T2MPType->getClass(), 0))) {
5089 T1 = T1MPType->getPointeeType();
5090 T2 = T2MPType->getPointeeType();
5091 return true;
5092 }
5093
5094 if (getLangOpts().ObjC1) {
5095 const auto *T1OPType = T1->getAs<ObjCObjectPointerType>();
5096 const auto *T2OPType = T2->getAs<ObjCObjectPointerType>();
5097 if (T1OPType && T2OPType) {
5098 T1 = T1OPType->getPointeeType();
5099 T2 = T2OPType->getPointeeType();
5100 return true;
5101 }
5102 }
5103
5104 // FIXME: Block pointers, too?
5105
5106 return false;
5107}
5108
5109bool ASTContext::hasSimilarType(QualType T1, QualType T2) {
5110 while (true) {
5111 Qualifiers Quals;
5112 T1 = getUnqualifiedArrayType(T1, Quals);
5113 T2 = getUnqualifiedArrayType(T2, Quals);
5114 if (hasSameType(T1, T2))
5115 return true;
5116 if (!UnwrapSimilarTypes(T1, T2))
5117 return false;
5118 }
5119}
5120
5121bool ASTContext::hasCvrSimilarType(QualType T1, QualType T2) {
5122 while (true) {
5123 Qualifiers Quals1, Quals2;
5124 T1 = getUnqualifiedArrayType(T1, Quals1);
5125 T2 = getUnqualifiedArrayType(T2, Quals2);
5126
5127 Quals1.removeCVRQualifiers();
5128 Quals2.removeCVRQualifiers();
5129 if (Quals1 != Quals2)
5130 return false;
5131
5132 if (hasSameType(T1, T2))
5133 return true;
5134
5135 if (!UnwrapSimilarTypes(T1, T2))
5136 return false;
5137 }
5138}
5139
5140DeclarationNameInfo
5141ASTContext::getNameForTemplate(TemplateName Name,
5142 SourceLocation NameLoc) const {
5143 switch (Name.getKind()) {
5144 case TemplateName::QualifiedTemplate:
5145 case TemplateName::Template:
5146 // DNInfo work in progress: CHECKME: what about DNLoc?
5147 return DeclarationNameInfo(Name.getAsTemplateDecl()->getDeclName(),
5148 NameLoc);
5149
5150 case TemplateName::OverloadedTemplate: {
5151 OverloadedTemplateStorage *Storage = Name.getAsOverloadedTemplate();
5152 // DNInfo work in progress: CHECKME: what about DNLoc?
5153 return DeclarationNameInfo((*Storage->begin())->getDeclName(), NameLoc);
5154 }
5155
5156 case TemplateName::DependentTemplate: {
5157 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
5158 DeclarationName DName;
5159 if (DTN->isIdentifier()) {
5160 DName = DeclarationNames.getIdentifier(DTN->getIdentifier());
5161 return DeclarationNameInfo(DName, NameLoc);
5162 } else {
5163 DName = DeclarationNames.getCXXOperatorName(DTN->getOperator());
5164 // DNInfo work in progress: FIXME: source locations?
5165 DeclarationNameLoc DNLoc;
5166 DNLoc.CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
5167 DNLoc.CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
5168 return DeclarationNameInfo(DName, NameLoc, DNLoc);
5169 }
5170 }
5171
5172 case TemplateName::SubstTemplateTemplateParm: {
5173 SubstTemplateTemplateParmStorage *subst
5174 = Name.getAsSubstTemplateTemplateParm();
5175 return DeclarationNameInfo(subst->getParameter()->getDeclName(),
5176 NameLoc);
5177 }
5178
5179 case TemplateName::SubstTemplateTemplateParmPack: {
5180 SubstTemplateTemplateParmPackStorage *subst
5181 = Name.getAsSubstTemplateTemplateParmPack();
5182 return DeclarationNameInfo(subst->getParameterPack()->getDeclName(),
5183 NameLoc);
5184 }
5185 }
5186
5187 llvm_unreachable("bad template name kind!")::llvm::llvm_unreachable_internal("bad template name kind!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5187)
;
5188}
5189
5190TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name) const {
5191 switch (Name.getKind()) {
5192 case TemplateName::QualifiedTemplate:
5193 case TemplateName::Template: {
5194 TemplateDecl *Template = Name.getAsTemplateDecl();
5195 if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template))
5196 Template = getCanonicalTemplateTemplateParmDecl(TTP);
5197
5198 // The canonical template name is the canonical template declaration.
5199 return TemplateName(cast<TemplateDecl>(Template->getCanonicalDecl()));
5200 }
5201
5202 case TemplateName::OverloadedTemplate:
5203 llvm_unreachable("cannot canonicalize overloaded template")::llvm::llvm_unreachable_internal("cannot canonicalize overloaded template"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5203)
;
5204
5205 case TemplateName::DependentTemplate: {
5206 DependentTemplateName *DTN = Name.getAsDependentTemplateName();
5207 assert(DTN && "Non-dependent template names must refer to template decls.")((DTN && "Non-dependent template names must refer to template decls."
) ? static_cast<void> (0) : __assert_fail ("DTN && \"Non-dependent template names must refer to template decls.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5207, __PRETTY_FUNCTION__))
;
5208 return DTN->CanonicalTemplateName;
5209 }
5210
5211 case TemplateName::SubstTemplateTemplateParm: {
5212 SubstTemplateTemplateParmStorage *subst
5213 = Name.getAsSubstTemplateTemplateParm();
5214 return getCanonicalTemplateName(subst->getReplacement());
5215 }
5216
5217 case TemplateName::SubstTemplateTemplateParmPack: {
5218 SubstTemplateTemplateParmPackStorage *subst
5219 = Name.getAsSubstTemplateTemplateParmPack();
5220 TemplateTemplateParmDecl *canonParameter
5221 = getCanonicalTemplateTemplateParmDecl(subst->getParameterPack());
5222 TemplateArgument canonArgPack
5223 = getCanonicalTemplateArgument(subst->getArgumentPack());
5224 return getSubstTemplateTemplateParmPack(canonParameter, canonArgPack);
5225 }
5226 }
5227
5228 llvm_unreachable("bad template name!")::llvm::llvm_unreachable_internal("bad template name!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5228)
;
5229}
5230
5231bool ASTContext::hasSameTemplateName(TemplateName X, TemplateName Y) {
5232 X = getCanonicalTemplateName(X);
5233 Y = getCanonicalTemplateName(Y);
5234 return X.getAsVoidPointer() == Y.getAsVoidPointer();
5235}
5236
5237TemplateArgument
5238ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
5239 switch (Arg.getKind()) {
5240 case TemplateArgument::Null:
5241 return Arg;
5242
5243 case TemplateArgument::Expression:
5244 return Arg;
5245
5246 case TemplateArgument::Declaration: {
5247 auto *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
5248 return TemplateArgument(D, Arg.getParamTypeForDecl());
5249 }
5250
5251 case TemplateArgument::NullPtr:
5252 return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),
5253 /*isNullPtr*/true);
5254
5255 case TemplateArgument::Template:
5256 return TemplateArgument(getCanonicalTemplateName(Arg.getAsTemplate()));
5257
5258 case TemplateArgument::TemplateExpansion:
5259 return TemplateArgument(getCanonicalTemplateName(
5260 Arg.getAsTemplateOrTemplatePattern()),
5261 Arg.getNumTemplateExpansions());
5262
5263 case TemplateArgument::Integral:
5264 return TemplateArgument(Arg, getCanonicalType(Arg.getIntegralType()));
5265
5266 case TemplateArgument::Type:
5267 return TemplateArgument(getCanonicalType(Arg.getAsType()));
5268
5269 case TemplateArgument::Pack: {
5270 if (Arg.pack_size() == 0)
5271 return Arg;
5272
5273 auto *CanonArgs = new (*this) TemplateArgument[Arg.pack_size()];
5274 unsigned Idx = 0;
5275 for (TemplateArgument::pack_iterator A = Arg.pack_begin(),
5276 AEnd = Arg.pack_end();
5277 A != AEnd; (void)++A, ++Idx)
5278 CanonArgs[Idx] = getCanonicalTemplateArgument(*A);
5279
5280 return TemplateArgument(llvm::makeArrayRef(CanonArgs, Arg.pack_size()));
5281 }
5282 }
5283
5284 // Silence GCC warning
5285 llvm_unreachable("Unhandled template argument kind")::llvm::llvm_unreachable_internal("Unhandled template argument kind"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5285)
;
5286}
5287
5288NestedNameSpecifier *
5289ASTContext::getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const {
5290 if (!NNS)
5291 return nullptr;
5292
5293 switch (NNS->getKind()) {
5294 case NestedNameSpecifier::Identifier:
5295 // Canonicalize the prefix but keep the identifier the same.
5296 return NestedNameSpecifier::Create(*this,
5297 getCanonicalNestedNameSpecifier(NNS->getPrefix()),
5298 NNS->getAsIdentifier());
5299
5300 case NestedNameSpecifier::Namespace:
5301 // A namespace is canonical; build a nested-name-specifier with
5302 // this namespace and no prefix.
5303 return NestedNameSpecifier::Create(*this, nullptr,
5304 NNS->getAsNamespace()->getOriginalNamespace());
5305
5306 case NestedNameSpecifier::NamespaceAlias:
5307 // A namespace is canonical; build a nested-name-specifier with
5308 // this namespace and no prefix.
5309 return NestedNameSpecifier::Create(*this, nullptr,
5310 NNS->getAsNamespaceAlias()->getNamespace()
5311 ->getOriginalNamespace());
5312
5313 case NestedNameSpecifier::TypeSpec:
5314 case NestedNameSpecifier::TypeSpecWithTemplate: {
5315 QualType T = getCanonicalType(QualType(NNS->getAsType(), 0));
5316
5317 // If we have some kind of dependent-named type (e.g., "typename T::type"),
5318 // break it apart into its prefix and identifier, then reconsititute those
5319 // as the canonical nested-name-specifier. This is required to canonicalize
5320 // a dependent nested-name-specifier involving typedefs of dependent-name
5321 // types, e.g.,
5322 // typedef typename T::type T1;
5323 // typedef typename T1::type T2;
5324 if (const auto *DNT = T->getAs<DependentNameType>())
5325 return NestedNameSpecifier::Create(*this, DNT->getQualifier(),
5326 const_cast<IdentifierInfo *>(DNT->getIdentifier()));
5327
5328 // Otherwise, just canonicalize the type, and force it to be a TypeSpec.
5329 // FIXME: Why are TypeSpec and TypeSpecWithTemplate distinct in the
5330 // first place?
5331 return NestedNameSpecifier::Create(*this, nullptr, false,
5332 const_cast<Type *>(T.getTypePtr()));
5333 }
5334
5335 case NestedNameSpecifier::Global:
5336 case NestedNameSpecifier::Super:
5337 // The global specifier and __super specifer are canonical and unique.
5338 return NNS;
5339 }
5340
5341 llvm_unreachable("Invalid NestedNameSpecifier::Kind!")::llvm::llvm_unreachable_internal("Invalid NestedNameSpecifier::Kind!"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5341)
;
5342}
5343
5344const ArrayType *ASTContext::getAsArrayType(QualType T) const {
5345 // Handle the non-qualified case efficiently.
5346 if (!T.hasLocalQualifiers()) {
5347 // Handle the common positive case fast.
5348 if (const auto *AT = dyn_cast<ArrayType>(T))
5349 return AT;
5350 }
5351
5352 // Handle the common negative case fast.
5353 if (!isa<ArrayType>(T.getCanonicalType()))
5354 return nullptr;
5355
5356 // Apply any qualifiers from the array type to the element type. This
5357 // implements C99 6.7.3p8: "If the specification of an array type includes
5358 // any type qualifiers, the element type is so qualified, not the array type."
5359
5360 // If we get here, we either have type qualifiers on the type, or we have
5361 // sugar such as a typedef in the way. If we have type qualifiers on the type
5362 // we must propagate them down into the element type.
5363
5364 SplitQualType split = T.getSplitDesugaredType();
5365 Qualifiers qs = split.Quals;
5366
5367 // If we have a simple case, just return now.
5368 const auto *ATy = dyn_cast<ArrayType>(split.Ty);
5369 if (!ATy || qs.empty())
5370 return ATy;
5371
5372 // Otherwise, we have an array and we have qualifiers on it. Push the
5373 // qualifiers into the array element type and return a new array type.
5374 QualType NewEltTy = getQualifiedType(ATy->getElementType(), qs);
5375
5376 if (const auto *CAT = dyn_cast<ConstantArrayType>(ATy))
5377 return cast<ArrayType>(getConstantArrayType(NewEltTy, CAT->getSize(),
5378 CAT->getSizeModifier(),
5379 CAT->getIndexTypeCVRQualifiers()));
5380 if (const auto *IAT = dyn_cast<IncompleteArrayType>(ATy))
5381 return cast<ArrayType>(getIncompleteArrayType(NewEltTy,
5382 IAT->getSizeModifier(),
5383 IAT->getIndexTypeCVRQualifiers()));
5384
5385 if (const auto *DSAT = dyn_cast<DependentSizedArrayType>(ATy))
5386 return cast<ArrayType>(
5387 getDependentSizedArrayType(NewEltTy,
5388 DSAT->getSizeExpr(),
5389 DSAT->getSizeModifier(),
5390 DSAT->getIndexTypeCVRQualifiers(),
5391 DSAT->getBracketsRange()));
5392
5393 const auto *VAT = cast<VariableArrayType>(ATy);
5394 return cast<ArrayType>(getVariableArrayType(NewEltTy,
5395 VAT->getSizeExpr(),
5396 VAT->getSizeModifier(),
5397 VAT->getIndexTypeCVRQualifiers(),
5398 VAT->getBracketsRange()));
5399}
5400
5401QualType ASTContext::getAdjustedParameterType(QualType T) const {
5402 if (T->isArrayType() || T->isFunctionType())
5403 return getDecayedType(T);
5404 return T;
5405}
5406
5407QualType ASTContext::getSignatureParameterType(QualType T) const {
5408 T = getVariableArrayDecayedType(T);
5409 T = getAdjustedParameterType(T);
5410 return T.getUnqualifiedType();
5411}
5412
5413QualType ASTContext::getExceptionObjectType(QualType T) const {
5414 // C++ [except.throw]p3:
5415 // A throw-expression initializes a temporary object, called the exception
5416 // object, the type of which is determined by removing any top-level
5417 // cv-qualifiers from the static type of the operand of throw and adjusting
5418 // the type from "array of T" or "function returning T" to "pointer to T"
5419 // or "pointer to function returning T", [...]
5420 T = getVariableArrayDecayedType(T);
5421 if (T->isArrayType() || T->isFunctionType())
5422 T = getDecayedType(T);
5423 return T.getUnqualifiedType();
5424}
5425
5426/// getArrayDecayedType - Return the properly qualified result of decaying the
5427/// specified array type to a pointer. This operation is non-trivial when
5428/// handling typedefs etc. The canonical type of "T" must be an array type,
5429/// this returns a pointer to a properly qualified element of the array.
5430///
5431/// See C99 6.7.5.3p7 and C99 6.3.2.1p3.
5432QualType ASTContext::getArrayDecayedType(QualType Ty) const {
5433 // Get the element type with 'getAsArrayType' so that we don't lose any
5434 // typedefs in the element type of the array. This also handles propagation
5435 // of type qualifiers from the array type into the element type if present
5436 // (C99 6.7.3p8).
5437 const ArrayType *PrettyArrayType = getAsArrayType(Ty);
5438 assert(PrettyArrayType && "Not an array type!")((PrettyArrayType && "Not an array type!") ? static_cast
<void> (0) : __assert_fail ("PrettyArrayType && \"Not an array type!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5438, __PRETTY_FUNCTION__))
;
5439
5440 QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
5441
5442 // int x[restrict 4] -> int *restrict
5443 QualType Result = getQualifiedType(PtrTy,
5444 PrettyArrayType->getIndexTypeQualifiers());
5445
5446 // int x[_Nullable] -> int * _Nullable
5447 if (auto Nullability = Ty->getNullability(*this)) {
5448 Result = const_cast<ASTContext *>(this)->getAttributedType(
5449 AttributedType::getNullabilityAttrKind(*Nullability), Result, Result);
5450 }
5451 return Result;
5452}
5453
5454QualType ASTContext::getBaseElementType(const ArrayType *array) const {
5455 return getBaseElementType(array->getElementType());
5456}
5457
5458QualType ASTContext::getBaseElementType(QualType type) const {
5459 Qualifiers qs;
5460 while (true) {
5461 SplitQualType split = type.getSplitDesugaredType();
5462 const ArrayType *array = split.Ty->getAsArrayTypeUnsafe();
5463 if (!array) break;
5464
5465 type = array->getElementType();
5466 qs.addConsistentQualifiers(split.Quals);
5467 }
5468
5469 return getQualifiedType(type, qs);
5470}
5471
5472/// getConstantArrayElementCount - Returns number of constant array elements.
5473uint64_t
5474ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA) const {
5475 uint64_t ElementCount = 1;
5476 do {
5477 ElementCount *= CA->getSize().getZExtValue();
5478 CA = dyn_cast_or_null<ConstantArrayType>(
5479 CA->getElementType()->getAsArrayTypeUnsafe());
5480 } while (CA);
5481 return ElementCount;
5482}
5483
5484/// getFloatingRank - Return a relative rank for floating point types.
5485/// This routine will assert if passed a built-in type that isn't a float.
5486static FloatingRank getFloatingRank(QualType T) {
5487 if (const auto *CT = T->getAs<ComplexType>())
5488 return getFloatingRank(CT->getElementType());
5489
5490 assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type")((T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type"
) ? static_cast<void> (0) : __assert_fail ("T->getAs<BuiltinType>() && \"getFloatingRank(): not a floating type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5490, __PRETTY_FUNCTION__))
;
5491 switch (T->getAs<BuiltinType>()->getKind()) {
5492 default: llvm_unreachable("getFloatingRank(): not a floating type")::llvm::llvm_unreachable_internal("getFloatingRank(): not a floating type"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5492)
;
5493 case BuiltinType::Float16: return Float16Rank;
5494 case BuiltinType::Half: return HalfRank;
5495 case BuiltinType::Float: return FloatRank;
5496 case BuiltinType::Double: return DoubleRank;
5497 case BuiltinType::LongDouble: return LongDoubleRank;
5498 case BuiltinType::Float128: return Float128Rank;
5499 }
5500}
5501
5502/// getFloatingTypeOfSizeWithinDomain - Returns a real floating
5503/// point or a complex type (based on typeDomain/typeSize).
5504/// 'typeDomain' is a real floating point or complex type.
5505/// 'typeSize' is a real floating point or complex type.
5506QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
5507 QualType Domain) const {
5508 FloatingRank EltRank = getFloatingRank(Size);
5509 if (Domain->isComplexType()) {
5510 switch (EltRank) {
5511 case Float16Rank:
5512 case HalfRank: llvm_unreachable("Complex half is not supported")::llvm::llvm_unreachable_internal("Complex half is not supported"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5512)
;
5513 case FloatRank: return FloatComplexTy;
5514 case DoubleRank: return DoubleComplexTy;
5515 case LongDoubleRank: return LongDoubleComplexTy;
5516 case Float128Rank: return Float128ComplexTy;
5517 }
5518 }
5519
5520 assert(Domain->isRealFloatingType() && "Unknown domain!")((Domain->isRealFloatingType() && "Unknown domain!"
) ? static_cast<void> (0) : __assert_fail ("Domain->isRealFloatingType() && \"Unknown domain!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5520, __PRETTY_FUNCTION__))
;
5521 switch (EltRank) {
5522 case Float16Rank: return HalfTy;
5523 case HalfRank: return HalfTy;
5524 case FloatRank: return FloatTy;
5525 case DoubleRank: return DoubleTy;
5526 case LongDoubleRank: return LongDoubleTy;
5527 case Float128Rank: return Float128Ty;
5528 }
5529 llvm_unreachable("getFloatingRank(): illegal value for rank")::llvm::llvm_unreachable_internal("getFloatingRank(): illegal value for rank"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5529)
;
5530}
5531
5532/// getFloatingTypeOrder - Compare the rank of the two specified floating
5533/// point types, ignoring the domain of the type (i.e. 'double' ==
5534/// '_Complex double'). If LHS > RHS, return 1. If LHS == RHS, return 0. If
5535/// LHS < RHS, return -1.
5536int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
5537 FloatingRank LHSR = getFloatingRank(LHS);
5538 FloatingRank RHSR = getFloatingRank(RHS);
5539
5540 if (LHSR == RHSR)
5541 return 0;
5542 if (LHSR > RHSR)
5543 return 1;
5544 return -1;
5545}
5546
5547/// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
5548/// routine will assert if passed a built-in type that isn't an integer or enum,
5549/// or if it is not canonicalized.
5550unsigned ASTContext::getIntegerRank(const Type *T) const {
5551 assert(T->isCanonicalUnqualified() && "T should be canonicalized")((T->isCanonicalUnqualified() && "T should be canonicalized"
) ? static_cast<void> (0) : __assert_fail ("T->isCanonicalUnqualified() && \"T should be canonicalized\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5551, __PRETTY_FUNCTION__))
;
5552
5553 switch (cast<BuiltinType>(T)->getKind()) {
5554 default: llvm_unreachable("getIntegerRank(): not a built-in integer")::llvm::llvm_unreachable_internal("getIntegerRank(): not a built-in integer"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5554)
;
5555 case BuiltinType::Bool:
5556 return 1 + (getIntWidth(BoolTy) << 3);
5557 case BuiltinType::Char_S:
5558 case BuiltinType::Char_U:
5559 case BuiltinType::SChar:
5560 case BuiltinType::UChar:
5561 return 2 + (getIntWidth(CharTy) << 3);
5562 case BuiltinType::Short:
5563 case BuiltinType::UShort:
5564 return 3 + (getIntWidth(ShortTy) << 3);
5565 case BuiltinType::Int:
5566 case BuiltinType::UInt:
5567 return 4 + (getIntWidth(IntTy) << 3);
5568 case BuiltinType::Long:
5569 case BuiltinType::ULong:
5570 return 5 + (getIntWidth(LongTy) << 3);
5571 case BuiltinType::LongLong:
5572 case BuiltinType::ULongLong:
5573 return 6 + (getIntWidth(LongLongTy) << 3);
5574 case BuiltinType::Int128:
5575 case BuiltinType::UInt128:
5576 return 7 + (getIntWidth(Int128Ty) << 3);
5577 }
5578}
5579
5580/// Whether this is a promotable bitfield reference according
5581/// to C99 6.3.1.1p2, bullet 2 (and GCC extensions).
5582///
5583/// \returns the type this bit-field will promote to, or NULL if no
5584/// promotion occurs.
5585QualType ASTContext::isPromotableBitField(Expr *E) const {
5586 if (E->isTypeDependent() || E->isValueDependent())
5587 return {};
5588
5589 // C++ [conv.prom]p5:
5590 // If the bit-field has an enumerated type, it is treated as any other
5591 // value of that type for promotion purposes.
5592 if (getLangOpts().CPlusPlus && E->getType()->isEnumeralType())
5593 return {};
5594
5595 // FIXME: We should not do this unless E->refersToBitField() is true. This
5596 // matters in C where getSourceBitField() will find bit-fields for various
5597 // cases where the source expression is not a bit-field designator.
5598
5599 FieldDecl *Field = E->getSourceBitField(); // FIXME: conditional bit-fields?
5600 if (!Field)
5601 return {};
5602
5603 QualType FT = Field->getType();
5604
5605 uint64_t BitWidth = Field->getBitWidthValue(*this);
5606 uint64_t IntSize = getTypeSize(IntTy);
5607 // C++ [conv.prom]p5:
5608 // A prvalue for an integral bit-field can be converted to a prvalue of type
5609 // int if int can represent all the values of the bit-field; otherwise, it
5610 // can be converted to unsigned int if unsigned int can represent all the
5611 // values of the bit-field. If the bit-field is larger yet, no integral
5612 // promotion applies to it.
5613 // C11 6.3.1.1/2:
5614 // [For a bit-field of type _Bool, int, signed int, or unsigned int:]
5615 // If an int can represent all values of the original type (as restricted by
5616 // the width, for a bit-field), the value is converted to an int; otherwise,
5617 // it is converted to an unsigned int.
5618 //
5619 // FIXME: C does not permit promotion of a 'long : 3' bitfield to int.
5620 // We perform that promotion here to match GCC and C++.
5621 // FIXME: C does not permit promotion of an enum bit-field whose rank is
5622 // greater than that of 'int'. We perform that promotion to match GCC.
5623 if (BitWidth < IntSize)
5624 return IntTy;
5625
5626 if (BitWidth == IntSize)
5627 return FT->isSignedIntegerType() ? IntTy : UnsignedIntTy;
5628
5629 // Bit-fields wider than int are not subject to promotions, and therefore act
5630 // like the base type. GCC has some weird bugs in this area that we
5631 // deliberately do not follow (GCC follows a pre-standard resolution to
5632 // C's DR315 which treats bit-width as being part of the type, and this leaks
5633 // into their semantics in some cases).
5634 return {};
5635}
5636
5637/// getPromotedIntegerType - Returns the type that Promotable will
5638/// promote to: C99 6.3.1.1p2, assuming that Promotable is a promotable
5639/// integer type.
5640QualType ASTContext::getPromotedIntegerType(QualType Promotable) const {
5641 assert(!Promotable.isNull())((!Promotable.isNull()) ? static_cast<void> (0) : __assert_fail
("!Promotable.isNull()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5641, __PRETTY_FUNCTION__))
;
5642 assert(Promotable->isPromotableIntegerType())((Promotable->isPromotableIntegerType()) ? static_cast<
void> (0) : __assert_fail ("Promotable->isPromotableIntegerType()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5642, __PRETTY_FUNCTION__))
;
5643 if (const auto *ET = Promotable->getAs<EnumType>())
5644 return ET->getDecl()->getPromotionType();
5645
5646 if (const auto *BT = Promotable->getAs<BuiltinType>()) {
5647 // C++ [conv.prom]: A prvalue of type char16_t, char32_t, or wchar_t
5648 // (3.9.1) can be converted to a prvalue of the first of the following
5649 // types that can represent all the values of its underlying type:
5650 // int, unsigned int, long int, unsigned long int, long long int, or
5651 // unsigned long long int [...]
5652 // FIXME: Is there some better way to compute this?
5653 if (BT->getKind() == BuiltinType::WChar_S ||
5654 BT->getKind() == BuiltinType::WChar_U ||
5655 BT->getKind() == BuiltinType::Char8 ||
5656 BT->getKind() == BuiltinType::Char16 ||
5657 BT->getKind() == BuiltinType::Char32) {
5658 bool FromIsSigned = BT->getKind() == BuiltinType::WChar_S;
5659 uint64_t FromSize = getTypeSize(BT);
5660 QualType PromoteTypes[] = { IntTy, UnsignedIntTy, LongTy, UnsignedLongTy,
5661 LongLongTy, UnsignedLongLongTy };
5662 for (size_t Idx = 0; Idx < llvm::array_lengthof(PromoteTypes); ++Idx) {
5663 uint64_t ToSize = getTypeSize(PromoteTypes[Idx]);
5664 if (FromSize < ToSize ||
5665 (FromSize == ToSize &&
5666 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType()))
5667 return PromoteTypes[Idx];
5668 }
5669 llvm_unreachable("char type should fit into long long")::llvm::llvm_unreachable_internal("char type should fit into long long"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5669)
;
5670 }
5671 }
5672
5673 // At this point, we should have a signed or unsigned integer type.
5674 if (Promotable->isSignedIntegerType())
5675 return IntTy;
5676 uint64_t PromotableSize = getIntWidth(Promotable);
5677 uint64_t IntSize = getIntWidth(IntTy);
5678 assert(Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize)((Promotable->isUnsignedIntegerType() && PromotableSize
<= IntSize) ? static_cast<void> (0) : __assert_fail
("Promotable->isUnsignedIntegerType() && PromotableSize <= IntSize"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5678, __PRETTY_FUNCTION__))
;
5679 return (PromotableSize != IntSize) ? IntTy : UnsignedIntTy;
5680}
5681
5682/// Recurses in pointer/array types until it finds an objc retainable
5683/// type and returns its ownership.
5684Qualifiers::ObjCLifetime ASTContext::getInnerObjCOwnership(QualType T) const {
5685 while (!T.isNull()) {
5686 if (T.getObjCLifetime() != Qualifiers::OCL_None)
5687 return T.getObjCLifetime();
5688 if (T->isArrayType())
5689 T = getBaseElementType(T);
5690 else if (const auto *PT = T->getAs<PointerType>())
5691 T = PT->getPointeeType();
5692 else if (const auto *RT = T->getAs<ReferenceType>())
5693 T = RT->getPointeeType();
5694 else
5695 break;
5696 }
5697
5698 return Qualifiers::OCL_None;
5699}
5700
5701static const Type *getIntegerTypeForEnum(const EnumType *ET) {
5702 // Incomplete enum types are not treated as integer types.
5703 // FIXME: In C++, enum types are never integer types.
5704 if (ET->getDecl()->isComplete() && !ET->getDecl()->isScoped())
5705 return ET->getDecl()->getIntegerType().getTypePtr();
5706 return nullptr;
5707}
5708
5709/// getIntegerTypeOrder - Returns the highest ranked integer type:
5710/// C99 6.3.1.8p1. If LHS > RHS, return 1. If LHS == RHS, return 0. If
5711/// LHS < RHS, return -1.
5712int ASTContext::getIntegerTypeOrder(QualType LHS, QualType RHS) const {
5713 const Type *LHSC = getCanonicalType(LHS).getTypePtr();
5714 const Type *RHSC = getCanonicalType(RHS).getTypePtr();
5715
5716 // Unwrap enums to their underlying type.
5717 if (const auto *ET = dyn_cast<EnumType>(LHSC))
5718 LHSC = getIntegerTypeForEnum(ET);
5719 if (const auto *ET = dyn_cast<EnumType>(RHSC))
5720 RHSC = getIntegerTypeForEnum(ET);
5721
5722 if (LHSC == RHSC) return 0;
5723
5724 bool LHSUnsigned = LHSC->isUnsignedIntegerType();
5725 bool RHSUnsigned = RHSC->isUnsignedIntegerType();
5726
5727 unsigned LHSRank = getIntegerRank(LHSC);
5728 unsigned RHSRank = getIntegerRank(RHSC);
5729
5730 if (LHSUnsigned == RHSUnsigned) { // Both signed or both unsigned.
5731 if (LHSRank == RHSRank) return 0;
5732 return LHSRank > RHSRank ? 1 : -1;
5733 }
5734
5735 // Otherwise, the LHS is signed and the RHS is unsigned or visa versa.
5736 if (LHSUnsigned) {
5737 // If the unsigned [LHS] type is larger, return it.
5738 if (LHSRank >= RHSRank)
5739 return 1;
5740
5741 // If the signed type can represent all values of the unsigned type, it
5742 // wins. Because we are dealing with 2's complement and types that are
5743 // powers of two larger than each other, this is always safe.
5744 return -1;
5745 }
5746
5747 // If the unsigned [RHS] type is larger, return it.
5748 if (RHSRank >= LHSRank)
5749 return -1;
5750
5751 // If the signed type can represent all values of the unsigned type, it
5752 // wins. Because we are dealing with 2's complement and types that are
5753 // powers of two larger than each other, this is always safe.
5754 return 1;
5755}
5756
5757TypedefDecl *ASTContext::getCFConstantStringDecl() const {
5758 if (CFConstantStringTypeDecl)
5759 return CFConstantStringTypeDecl;
5760
5761 assert(!CFConstantStringTagDecl &&((!CFConstantStringTagDecl && "tag and typedef should be initialized together"
) ? static_cast<void> (0) : __assert_fail ("!CFConstantStringTagDecl && \"tag and typedef should be initialized together\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5762, __PRETTY_FUNCTION__))
5762 "tag and typedef should be initialized together")((!CFConstantStringTagDecl && "tag and typedef should be initialized together"
) ? static_cast<void> (0) : __assert_fail ("!CFConstantStringTagDecl && \"tag and typedef should be initialized together\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5762, __PRETTY_FUNCTION__))
;
5763 CFConstantStringTagDecl = buildImplicitRecord("__NSConstantString_tag");
5764 CFConstantStringTagDecl->startDefinition();
5765
5766 struct {
5767 QualType Type;
5768 const char *Name;
5769 } Fields[5];
5770 unsigned Count = 0;
5771
5772 /// Objective-C ABI
5773 ///
5774 /// typedef struct __NSConstantString_tag {
5775 /// const int *isa;
5776 /// int flags;
5777 /// const char *str;
5778 /// long length;
5779 /// } __NSConstantString;
5780 ///
5781 /// Swift ABI (4.1, 4.2)
5782 ///
5783 /// typedef struct __NSConstantString_tag {
5784 /// uintptr_t _cfisa;
5785 /// uintptr_t _swift_rc;
5786 /// _Atomic(uint64_t) _cfinfoa;
5787 /// const char *_ptr;
5788 /// uint32_t _length;
5789 /// } __NSConstantString;
5790 ///
5791 /// Swift ABI (5.0)
5792 ///
5793 /// typedef struct __NSConstantString_tag {
5794 /// uintptr_t _cfisa;
5795 /// uintptr_t _swift_rc;
5796 /// _Atomic(uint64_t) _cfinfoa;
5797 /// const char *_ptr;
5798 /// uintptr_t _length;
5799 /// } __NSConstantString;
5800
5801 const auto CFRuntime = getLangOpts().CFRuntime;
5802 if (static_cast<unsigned>(CFRuntime) <
5803 static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift)) {
5804 Fields[Count++] = { getPointerType(IntTy.withConst()), "isa" };
5805 Fields[Count++] = { IntTy, "flags" };
5806 Fields[Count++] = { getPointerType(CharTy.withConst()), "str" };
5807 Fields[Count++] = { LongTy, "length" };
5808 } else {
5809 Fields[Count++] = { getUIntPtrType(), "_cfisa" };
5810 Fields[Count++] = { getUIntPtrType(), "_swift_rc" };
5811 Fields[Count++] = { getFromTargetType(Target->getUInt64Type()), "_swift_rc" };
5812 Fields[Count++] = { getPointerType(CharTy.withConst()), "_ptr" };
5813 if (CFRuntime == LangOptions::CoreFoundationABI::Swift4_1 ||
5814 CFRuntime == LangOptions::CoreFoundationABI::Swift4_2)
5815 Fields[Count++] = { IntTy, "_ptr" };
5816 else
5817 Fields[Count++] = { getUIntPtrType(), "_ptr" };
5818 }
5819
5820 // Create fields
5821 for (unsigned i = 0; i < Count; ++i) {
5822 FieldDecl *Field =
5823 FieldDecl::Create(*this, CFConstantStringTagDecl, SourceLocation(),
5824 SourceLocation(), &Idents.get(Fields[i].Name),
5825 Fields[i].Type, /*TInfo=*/nullptr,
5826 /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
5827 Field->setAccess(AS_public);
5828 CFConstantStringTagDecl->addDecl(Field);
5829 }
5830
5831 CFConstantStringTagDecl->completeDefinition();
5832 // This type is designed to be compatible with NSConstantString, but cannot
5833 // use the same name, since NSConstantString is an interface.
5834 auto tagType = getTagDeclType(CFConstantStringTagDecl);
5835 CFConstantStringTypeDecl =
5836 buildImplicitTypedef(tagType, "__NSConstantString");
5837
5838 return CFConstantStringTypeDecl;
5839}
5840
5841RecordDecl *ASTContext::getCFConstantStringTagDecl() const {
5842 if (!CFConstantStringTagDecl)
5843 getCFConstantStringDecl(); // Build the tag and the typedef.
5844 return CFConstantStringTagDecl;
5845}
5846
5847// getCFConstantStringType - Return the type used for constant CFStrings.
5848QualType ASTContext::getCFConstantStringType() const {
5849 return getTypedefType(getCFConstantStringDecl());
5850}
5851
5852QualType ASTContext::getObjCSuperType() const {
5853 if (ObjCSuperType.isNull()) {
5854 RecordDecl *ObjCSuperTypeDecl = buildImplicitRecord("objc_super");
5855 TUDecl->addDecl(ObjCSuperTypeDecl);
5856 ObjCSuperType = getTagDeclType(ObjCSuperTypeDecl);
5857 }
5858 return ObjCSuperType;
5859}
5860
5861void ASTContext::setCFConstantStringType(QualType T) {
5862 const auto *TD = T->getAs<TypedefType>();
5863 assert(TD && "Invalid CFConstantStringType")((TD && "Invalid CFConstantStringType") ? static_cast
<void> (0) : __assert_fail ("TD && \"Invalid CFConstantStringType\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5863, __PRETTY_FUNCTION__))
;
5864 CFConstantStringTypeDecl = cast<TypedefDecl>(TD->getDecl());
5865 const auto *TagType =
5866 CFConstantStringTypeDecl->getUnderlyingType()->getAs<RecordType>();
5867 assert(TagType && "Invalid CFConstantStringType")((TagType && "Invalid CFConstantStringType") ? static_cast
<void> (0) : __assert_fail ("TagType && \"Invalid CFConstantStringType\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 5867, __PRETTY_FUNCTION__))
;
5868 CFConstantStringTagDecl = TagType->getDecl();
5869}
5870
5871QualType ASTContext::getBlockDescriptorType() const {
5872 if (BlockDescriptorType)
5873 return getTagDeclType(BlockDescriptorType);
5874
5875 RecordDecl *RD;
5876 // FIXME: Needs the FlagAppleBlock bit.
5877 RD = buildImplicitRecord("__block_descriptor");
5878 RD->startDefinition();
5879
5880 QualType FieldTypes[] = {
5881 UnsignedLongTy,
5882 UnsignedLongTy,
5883 };
5884
5885 static const char *const FieldNames[] = {
5886 "reserved",
5887 "Size"
5888 };
5889
5890 for (size_t i = 0; i < 2; ++i) {
5891 FieldDecl *Field = FieldDecl::Create(
5892 *this, RD, SourceLocation(), SourceLocation(),
5893 &Idents.get(FieldNames[i]), FieldTypes[i], /*TInfo=*/nullptr,
5894 /*BitWidth=*/nullptr, /*Mutable=*/false, ICIS_NoInit);
5895 Field->setAccess(AS_public);
5896 RD->addDecl(Field);
5897 }
5898
5899 RD->completeDefinition();
5900
5901 BlockDescriptorType = RD;
5902
5903 return getTagDeclType(BlockDescriptorType);
5904}
5905
5906QualType ASTContext::getBlockDescriptorExtendedType() const {
5907 if (BlockDescriptorExtendedType)
5908 return getTagDeclType(BlockDescriptorExtendedType);
5909
5910 RecordDecl *RD;
5911 // FIXME: Needs the FlagAppleBlock bit.
5912 RD = buildImplicitRecord("__block_descriptor_withcopydispose");
5913 RD->startDefinition();
5914
5915 QualType FieldTypes[] = {
5916 UnsignedLongTy,
5917 UnsignedLongTy,
5918 getPointerType(VoidPtrTy),
5919 getPointerType(VoidPtrTy)
5920 };
5921
5922 static const char *const FieldNames[] = {
5923 "reserved",
5924 "Size",
5925 "CopyFuncPtr",
5926 "DestroyFuncPtr"
5927 };
5928
5929 for (size_t i = 0; i < 4; ++i) {
5930 FieldDecl *Field = FieldDecl::Create(
5931 *this, RD, SourceLocation(), SourceLocation(),
5932 &Idents.get(FieldNames[i]), FieldTypes[i], /*TInfo=*/nullptr,
5933 /*BitWidth=*/nullptr,
5934 /*Mutable=*/false, ICIS_NoInit);
5935 Field->setAccess(AS_public);
5936 RD->addDecl(Field);
5937 }
5938
5939 RD->completeDefinition();
5940
5941 BlockDescriptorExtendedType = RD;
5942 return getTagDeclType(BlockDescriptorExtendedType);
5943}
5944
5945TargetInfo::OpenCLTypeKind ASTContext::getOpenCLTypeKind(const Type *T) const {
5946 const auto *BT = dyn_cast<BuiltinType>(T);
5947
5948 if (!BT) {
5949 if (isa<PipeType>(T))
5950 return TargetInfo::OCLTK_Pipe;
5951
5952 return TargetInfo::OCLTK_Default;
5953 }
5954
5955 switch (BT->getKind()) {
5956#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
5957 case BuiltinType::Id: \
5958 return TargetInfo::OCLTK_Image;
5959#include "clang/Basic/OpenCLImageTypes.def"
5960
5961 case BuiltinType::OCLClkEvent:
5962 return TargetInfo::OCLTK_ClkEvent;
5963
5964 case BuiltinType::OCLEvent:
5965 return TargetInfo::OCLTK_Event;
5966
5967 case BuiltinType::OCLQueue:
5968 return TargetInfo::OCLTK_Queue;
5969
5970 case BuiltinType::OCLReserveID:
5971 return TargetInfo::OCLTK_ReserveID;
5972
5973 case BuiltinType::OCLSampler:
5974 return TargetInfo::OCLTK_Sampler;
5975
5976 default:
5977 return TargetInfo::OCLTK_Default;
5978 }
5979}
5980
5981LangAS ASTContext::getOpenCLTypeAddrSpace(const Type *T) const {
5982 return Target->getOpenCLTypeAddrSpace(getOpenCLTypeKind(T));
5983}
5984
5985/// BlockRequiresCopying - Returns true if byref variable "D" of type "Ty"
5986/// requires copy/dispose. Note that this must match the logic
5987/// in buildByrefHelpers.
5988bool ASTContext::BlockRequiresCopying(QualType Ty,
5989 const VarDecl *D) {
5990 if (const CXXRecordDecl *record = Ty->getAsCXXRecordDecl()) {
5991 const Expr *copyExpr = getBlockVarCopyInit(D).getCopyExpr();
5992 if (!copyExpr && record->hasTrivialDestructor()) return false;
5993
5994 return true;
5995 }
5996
5997 // The block needs copy/destroy helpers if Ty is non-trivial to destructively
5998 // move or destroy.
5999 if (Ty.isNonTrivialToPrimitiveDestructiveMove() || Ty.isDestructedType())
6000 return true;
6001
6002 if (!Ty->isObjCRetainableType()) return false;
6003
6004 Qualifiers qs = Ty.getQualifiers();
6005
6006 // If we have lifetime, that dominates.
6007 if (Qualifiers::ObjCLifetime lifetime = qs.getObjCLifetime()) {
6008 switch (lifetime) {
6009 case Qualifiers::OCL_None: llvm_unreachable("impossible")::llvm::llvm_unreachable_internal("impossible", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6009)
;
6010
6011 // These are just bits as far as the runtime is concerned.
6012 case Qualifiers::OCL_ExplicitNone:
6013 case Qualifiers::OCL_Autoreleasing:
6014 return false;
6015
6016 // These cases should have been taken care of when checking the type's
6017 // non-triviality.
6018 case Qualifiers::OCL_Weak:
6019 case Qualifiers::OCL_Strong:
6020 llvm_unreachable("impossible")::llvm::llvm_unreachable_internal("impossible", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6020)
;
6021 }
6022 llvm_unreachable("fell out of lifetime switch!")::llvm::llvm_unreachable_internal("fell out of lifetime switch!"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6022)
;
6023 }
6024 return (Ty->isBlockPointerType() || isObjCNSObjectType(Ty) ||
6025 Ty->isObjCObjectPointerType());
6026}
6027
6028bool ASTContext::getByrefLifetime(QualType Ty,
6029 Qualifiers::ObjCLifetime &LifeTime,
6030 bool &HasByrefExtendedLayout) const {
6031 if (!getLangOpts().ObjC1 ||
6032 getLangOpts().getGC() != LangOptions::NonGC)
6033 return false;
6034
6035 HasByrefExtendedLayout = false;
6036 if (Ty->isRecordType()) {
6037 HasByrefExtendedLayout = true;
6038 LifeTime = Qualifiers::OCL_None;
6039 } else if ((LifeTime = Ty.getObjCLifetime())) {
6040 // Honor the ARC qualifiers.
6041 } else if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType()) {
6042 // The MRR rule.
6043 LifeTime = Qualifiers::OCL_ExplicitNone;
6044 } else {
6045 LifeTime = Qualifiers::OCL_None;
6046 }
6047 return true;
6048}
6049
6050TypedefDecl *ASTContext::getObjCInstanceTypeDecl() {
6051 if (!ObjCInstanceTypeDecl)
6052 ObjCInstanceTypeDecl =
6053 buildImplicitTypedef(getObjCIdType(), "instancetype");
6054 return ObjCInstanceTypeDecl;
6055}
6056
6057// This returns true if a type has been typedefed to BOOL:
6058// typedef <type> BOOL;
6059static bool isTypeTypedefedAsBOOL(QualType T) {
6060 if (const auto *TT = dyn_cast<TypedefType>(T))
6061 if (IdentifierInfo *II = TT->getDecl()->getIdentifier())
6062 return II->isStr("BOOL");
6063
6064 return false;
6065}
6066
6067/// getObjCEncodingTypeSize returns size of type for objective-c encoding
6068/// purpose.
6069CharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const {
6070 if (!type->isIncompleteArrayType() && type->isIncompleteType())
6071 return CharUnits::Zero();
6072
6073 CharUnits sz = getTypeSizeInChars(type);
6074
6075 // Make all integer and enum types at least as large as an int
6076 if (sz.isPositive() && type->isIntegralOrEnumerationType())
6077 sz = std::max(sz, getTypeSizeInChars(IntTy));
6078 // Treat arrays as pointers, since that's how they're passed in.
6079 else if (type->isArrayType())
6080 sz = getTypeSizeInChars(VoidPtrTy);
6081 return sz;
6082}
6083
6084bool ASTContext::isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const {
6085 return getTargetInfo().getCXXABI().isMicrosoft() &&
6086 VD->isStaticDataMember() &&
6087 VD->getType()->isIntegralOrEnumerationType() &&
6088 !VD->getFirstDecl()->isOutOfLine() && VD->getFirstDecl()->hasInit();
6089}
6090
6091ASTContext::InlineVariableDefinitionKind
6092ASTContext::getInlineVariableDefinitionKind(const VarDecl *VD) const {
6093 if (!VD->isInline())
6094 return InlineVariableDefinitionKind::None;
6095
6096 // In almost all cases, it's a weak definition.
6097 auto *First = VD->getFirstDecl();
6098 if (First->isInlineSpecified() || !First->isStaticDataMember())
6099 return InlineVariableDefinitionKind::Weak;
6100
6101 // If there's a file-context declaration in this translation unit, it's a
6102 // non-discardable definition.
6103 for (auto *D : VD->redecls())
6104 if (D->getLexicalDeclContext()->isFileContext() &&
6105 !D->isInlineSpecified() && (D->isConstexpr() || First->isConstexpr()))
6106 return InlineVariableDefinitionKind::Strong;
6107
6108 // If we've not seen one yet, we don't know.
6109 return InlineVariableDefinitionKind::WeakUnknown;
6110}
6111
6112static std::string charUnitsToString(const CharUnits &CU) {
6113 return llvm::itostr(CU.getQuantity());
6114}
6115
6116/// getObjCEncodingForBlock - Return the encoded type for this block
6117/// declaration.
6118std::string ASTContext::getObjCEncodingForBlock(const BlockExpr *Expr) const {
6119 std::string S;
6120
6121 const BlockDecl *Decl = Expr->getBlockDecl();
6122 QualType BlockTy =
6123 Expr->getType()->getAs<BlockPointerType>()->getPointeeType();
6124 // Encode result type.
6125 if (getLangOpts().EncodeExtendedBlockSig)
6126 getObjCEncodingForMethodParameter(
6127 Decl::OBJC_TQ_None, BlockTy->getAs<FunctionType>()->getReturnType(), S,
6128 true /*Extended*/);
6129 else
6130 getObjCEncodingForType(BlockTy->getAs<FunctionType>()->getReturnType(), S);
6131 // Compute size of all parameters.
6132 // Start with computing size of a pointer in number of bytes.
6133 // FIXME: There might(should) be a better way of doing this computation!
6134 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
6135 CharUnits ParmOffset = PtrSize;
6136 for (auto PI : Decl->parameters()) {
6137 QualType PType = PI->getType();
6138 CharUnits sz = getObjCEncodingTypeSize(PType);
6139 if (sz.isZero())
6140 continue;
6141 assert(sz.isPositive() && "BlockExpr - Incomplete param type")((sz.isPositive() && "BlockExpr - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"BlockExpr - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6141, __PRETTY_FUNCTION__))
;
6142 ParmOffset += sz;
6143 }
6144 // Size of the argument frame
6145 S += charUnitsToString(ParmOffset);
6146 // Block pointer and offset.
6147 S += "@?0";
6148
6149 // Argument types.
6150 ParmOffset = PtrSize;
6151 for (auto PVDecl : Decl->parameters()) {
6152 QualType PType = PVDecl->getOriginalType();
6153 if (const auto *AT =
6154 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
6155 // Use array's original type only if it has known number of
6156 // elements.
6157 if (!isa<ConstantArrayType>(AT))
6158 PType = PVDecl->getType();
6159 } else if (PType->isFunctionType())
6160 PType = PVDecl->getType();
6161 if (getLangOpts().EncodeExtendedBlockSig)
6162 getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, PType,
6163 S, true /*Extended*/);
6164 else
6165 getObjCEncodingForType(PType, S);
6166 S += charUnitsToString(ParmOffset);
6167 ParmOffset += getObjCEncodingTypeSize(PType);
6168 }
6169
6170 return S;
6171}
6172
6173std::string
6174ASTContext::getObjCEncodingForFunctionDecl(const FunctionDecl *Decl) const {
6175 std::string S;
6176 // Encode result type.
6177 getObjCEncodingForType(Decl->getReturnType(), S);
6178 CharUnits ParmOffset;
6179 // Compute size of all parameters.
6180 for (auto PI : Decl->parameters()) {
6181 QualType PType = PI->getType();
6182 CharUnits sz = getObjCEncodingTypeSize(PType);
6183 if (sz.isZero())
6184 continue;
6185
6186 assert(sz.isPositive() &&((sz.isPositive() && "getObjCEncodingForFunctionDecl - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"getObjCEncodingForFunctionDecl - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6187, __PRETTY_FUNCTION__))
6187 "getObjCEncodingForFunctionDecl - Incomplete param type")((sz.isPositive() && "getObjCEncodingForFunctionDecl - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"getObjCEncodingForFunctionDecl - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6187, __PRETTY_FUNCTION__))
;
6188 ParmOffset += sz;
6189 }
6190 S += charUnitsToString(ParmOffset);
6191 ParmOffset = CharUnits::Zero();
6192
6193 // Argument types.
6194 for (auto PVDecl : Decl->parameters()) {
6195 QualType PType = PVDecl->getOriginalType();
6196 if (const auto *AT =
6197 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
6198 // Use array's original type only if it has known number of
6199 // elements.
6200 if (!isa<ConstantArrayType>(AT))
6201 PType = PVDecl->getType();
6202 } else if (PType->isFunctionType())
6203 PType = PVDecl->getType();
6204 getObjCEncodingForType(PType, S);
6205 S += charUnitsToString(ParmOffset);
6206 ParmOffset += getObjCEncodingTypeSize(PType);
6207 }
6208
6209 return S;
6210}
6211
6212/// getObjCEncodingForMethodParameter - Return the encoded type for a single
6213/// method parameter or return type. If Extended, include class names and
6214/// block object types.
6215void ASTContext::getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT,
6216 QualType T, std::string& S,
6217 bool Extended) const {
6218 // Encode type qualifer, 'in', 'inout', etc. for the parameter.
6219 getObjCEncodingForTypeQualifier(QT, S);
6220 // Encode parameter type.
6221 getObjCEncodingForTypeImpl(T, S, true, true, nullptr,
6222 true /*OutermostType*/,
6223 false /*EncodingProperty*/,
6224 false /*StructField*/,
6225 Extended /*EncodeBlockParameters*/,
6226 Extended /*EncodeClassNames*/);
6227}
6228
6229/// getObjCEncodingForMethodDecl - Return the encoded type for this method
6230/// declaration.
6231std::string ASTContext::getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl,
6232 bool Extended) const {
6233 // FIXME: This is not very efficient.
6234 // Encode return type.
6235 std::string S;
6236 getObjCEncodingForMethodParameter(Decl->getObjCDeclQualifier(),
6237 Decl->getReturnType(), S, Extended);
6238 // Compute size of all parameters.
6239 // Start with computing size of a pointer in number of bytes.
6240 // FIXME: There might(should) be a better way of doing this computation!
6241 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
6242 // The first two arguments (self and _cmd) are pointers; account for
6243 // their size.
6244 CharUnits ParmOffset = 2 * PtrSize;
6245 for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(),
6246 E = Decl->sel_param_end(); PI != E; ++PI) {
6247 QualType PType = (*PI)->getType();
6248 CharUnits sz = getObjCEncodingTypeSize(PType);
6249 if (sz.isZero())
6250 continue;
6251
6252 assert(sz.isPositive() &&((sz.isPositive() && "getObjCEncodingForMethodDecl - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"getObjCEncodingForMethodDecl - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6253, __PRETTY_FUNCTION__))
6253 "getObjCEncodingForMethodDecl - Incomplete param type")((sz.isPositive() && "getObjCEncodingForMethodDecl - Incomplete param type"
) ? static_cast<void> (0) : __assert_fail ("sz.isPositive() && \"getObjCEncodingForMethodDecl - Incomplete param type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6253, __PRETTY_FUNCTION__))
;
6254 ParmOffset += sz;
6255 }
6256 S += charUnitsToString(ParmOffset);
6257 S += "@0:";
6258 S += charUnitsToString(PtrSize);
6259
6260 // Argument types.
6261 ParmOffset = 2 * PtrSize;
6262 for (ObjCMethodDecl::param_const_iterator PI = Decl->param_begin(),
6263 E = Decl->sel_param_end(); PI != E; ++PI) {
6264 const ParmVarDecl *PVDecl = *PI;
6265 QualType PType = PVDecl->getOriginalType();
6266 if (const auto *AT =
6267 dyn_cast<ArrayType>(PType->getCanonicalTypeInternal())) {
6268 // Use array's original type only if it has known number of
6269 // elements.
6270 if (!isa<ConstantArrayType>(AT))
6271 PType = PVDecl->getType();
6272 } else if (PType->isFunctionType())
6273 PType = PVDecl->getType();
6274 getObjCEncodingForMethodParameter(PVDecl->getObjCDeclQualifier(),
6275 PType, S, Extended);
6276 S += charUnitsToString(ParmOffset);
6277 ParmOffset += getObjCEncodingTypeSize(PType);
6278 }
6279
6280 return S;
6281}
6282
6283ObjCPropertyImplDecl *
6284ASTContext::getObjCPropertyImplDeclForPropertyDecl(
6285 const ObjCPropertyDecl *PD,
6286 const Decl *Container) const {
6287 if (!Container)
6288 return nullptr;
6289 if (const auto *CID = dyn_cast<ObjCCategoryImplDecl>(Container)) {
6290 for (auto *PID : CID->property_impls())
6291 if (PID->getPropertyDecl() == PD)
6292 return PID;
6293 } else {
6294 const auto *OID = cast<ObjCImplementationDecl>(Container);
6295 for (auto *PID : OID->property_impls())
6296 if (PID->getPropertyDecl() == PD)
6297 return PID;
6298 }
6299 return nullptr;
6300}
6301
6302/// getObjCEncodingForPropertyDecl - Return the encoded type for this
6303/// property declaration. If non-NULL, Container must be either an
6304/// ObjCCategoryImplDecl or ObjCImplementationDecl; it should only be
6305/// NULL when getting encodings for protocol properties.
6306/// Property attributes are stored as a comma-delimited C string. The simple
6307/// attributes readonly and bycopy are encoded as single characters. The
6308/// parametrized attributes, getter=name, setter=name, and ivar=name, are
6309/// encoded as single characters, followed by an identifier. Property types
6310/// are also encoded as a parametrized attribute. The characters used to encode
6311/// these attributes are defined by the following enumeration:
6312/// @code
6313/// enum PropertyAttributes {
6314/// kPropertyReadOnly = 'R', // property is read-only.
6315/// kPropertyBycopy = 'C', // property is a copy of the value last assigned
6316/// kPropertyByref = '&', // property is a reference to the value last assigned
6317/// kPropertyDynamic = 'D', // property is dynamic
6318/// kPropertyGetter = 'G', // followed by getter selector name
6319/// kPropertySetter = 'S', // followed by setter selector name
6320/// kPropertyInstanceVariable = 'V' // followed by instance variable name
6321/// kPropertyType = 'T' // followed by old-style type encoding.
6322/// kPropertyWeak = 'W' // 'weak' property
6323/// kPropertyStrong = 'P' // property GC'able
6324/// kPropertyNonAtomic = 'N' // property non-atomic
6325/// };
6326/// @endcode
6327std::string
6328ASTContext::getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD,
6329 const Decl *Container) const {
6330 // Collect information from the property implementation decl(s).
6331 bool Dynamic = false;
6332 ObjCPropertyImplDecl *SynthesizePID = nullptr;
6333
6334 if (ObjCPropertyImplDecl *PropertyImpDecl =
6335 getObjCPropertyImplDeclForPropertyDecl(PD, Container)) {
6336 if (PropertyImpDecl->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
6337 Dynamic = true;
6338 else
6339 SynthesizePID = PropertyImpDecl;
6340 }
6341
6342 // FIXME: This is not very efficient.
6343 std::string S = "T";
6344
6345 // Encode result type.
6346 // GCC has some special rules regarding encoding of properties which
6347 // closely resembles encoding of ivars.
6348 getObjCEncodingForPropertyType(PD->getType(), S);
6349
6350 if (PD->isReadOnly()) {
6351 S += ",R";
6352 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_copy)
6353 S += ",C";
6354 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_retain)
6355 S += ",&";
6356 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_weak)
6357 S += ",W";
6358 } else {
6359 switch (PD->getSetterKind()) {
6360 case ObjCPropertyDecl::Assign: break;
6361 case ObjCPropertyDecl::Copy: S += ",C"; break;
6362 case ObjCPropertyDecl::Retain: S += ",&"; break;
6363 case ObjCPropertyDecl::Weak: S += ",W"; break;
6364 }
6365 }
6366
6367 // It really isn't clear at all what this means, since properties
6368 // are "dynamic by default".
6369 if (Dynamic)
6370 S += ",D";
6371
6372 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_nonatomic)
6373 S += ",N";
6374
6375 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_getter) {
6376 S += ",G";
6377 S += PD->getGetterName().getAsString();
6378 }
6379
6380 if (PD->getPropertyAttributes() & ObjCPropertyDecl::OBJC_PR_setter) {
6381 S += ",S";
6382 S += PD->getSetterName().getAsString();
6383 }
6384
6385 if (SynthesizePID) {
6386 const ObjCIvarDecl *OID = SynthesizePID->getPropertyIvarDecl();
6387 S += ",V";
6388 S += OID->getNameAsString();
6389 }
6390
6391 // FIXME: OBJCGC: weak & strong
6392 return S;
6393}
6394
6395/// getLegacyIntegralTypeEncoding -
6396/// Another legacy compatibility encoding: 32-bit longs are encoded as
6397/// 'l' or 'L' , but not always. For typedefs, we need to use
6398/// 'i' or 'I' instead if encoding a struct field, or a pointer!
6399void ASTContext::getLegacyIntegralTypeEncoding (QualType &PointeeTy) const {
6400 if (isa<TypedefType>(PointeeTy.getTypePtr())) {
6401 if (const auto *BT = PointeeTy->getAs<BuiltinType>()) {
6402 if (BT->getKind() == BuiltinType::ULong && getIntWidth(PointeeTy) == 32)
6403 PointeeTy = UnsignedIntTy;
6404 else
6405 if (BT->getKind() == BuiltinType::Long && getIntWidth(PointeeTy) == 32)
6406 PointeeTy = IntTy;
6407 }
6408 }
6409}
6410
6411void ASTContext::getObjCEncodingForType(QualType T, std::string& S,
6412 const FieldDecl *Field,
6413 QualType *NotEncodedT) const {
6414 // We follow the behavior of gcc, expanding structures which are
6415 // directly pointed to, and expanding embedded structures. Note that
6416 // these rules are sufficient to prevent recursive encoding of the
6417 // same type.
6418 getObjCEncodingForTypeImpl(T, S, true, true, Field,
6419 true /* outermost type */, false, false,
6420 false, false, false, NotEncodedT);
6421}
6422
6423void ASTContext::getObjCEncodingForPropertyType(QualType T,
6424 std::string& S) const {
6425 // Encode result type.
6426 // GCC has some special rules regarding encoding of properties which
6427 // closely resembles encoding of ivars.
6428 getObjCEncodingForTypeImpl(T, S, true, true, nullptr,
6429 true /* outermost type */,
6430 true /* encoding property */);
6431}
6432
6433static char getObjCEncodingForPrimitiveKind(const ASTContext *C,
6434 BuiltinType::Kind kind) {
6435 switch (kind) {
6436 case BuiltinType::Void: return 'v';
6437 case BuiltinType::Bool: return 'B';
6438 case BuiltinType::Char8:
6439 case BuiltinType::Char_U:
6440 case BuiltinType::UChar: return 'C';
6441 case BuiltinType::Char16:
6442 case BuiltinType::UShort: return 'S';
6443 case BuiltinType::Char32:
6444 case BuiltinType::UInt: return 'I';
6445 case BuiltinType::ULong:
6446 return C->getTargetInfo().getLongWidth() == 32 ? 'L' : 'Q';
6447 case BuiltinType::UInt128: return 'T';
6448 case BuiltinType::ULongLong: return 'Q';
6449 case BuiltinType::Char_S:
6450 case BuiltinType::SChar: return 'c';
6451 case BuiltinType::Short: return 's';
6452 case BuiltinType::WChar_S:
6453 case BuiltinType::WChar_U:
6454 case BuiltinType::Int: return 'i';
6455 case BuiltinType::Long:
6456 return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
6457 case BuiltinType::LongLong: return 'q';
6458 case BuiltinType::Int128: return 't';
6459 case BuiltinType::Float: return 'f';
6460 case BuiltinType::Double: return 'd';
6461 case BuiltinType::LongDouble: return 'D';
6462 case BuiltinType::NullPtr: return '*'; // like char*
6463
6464 case BuiltinType::Float16:
6465 case BuiltinType::Float128:
6466 case BuiltinType::Half:
6467 case BuiltinType::ShortAccum:
6468 case BuiltinType::Accum:
6469 case BuiltinType::LongAccum:
6470 case BuiltinType::UShortAccum:
6471 case BuiltinType::UAccum:
6472 case BuiltinType::ULongAccum:
6473 case BuiltinType::ShortFract:
6474 case BuiltinType::Fract:
6475 case BuiltinType::LongFract:
6476 case BuiltinType::UShortFract:
6477 case BuiltinType::UFract:
6478 case BuiltinType::ULongFract:
6479 case BuiltinType::SatShortAccum:
6480 case BuiltinType::SatAccum:
6481 case BuiltinType::SatLongAccum:
6482 case BuiltinType::SatUShortAccum:
6483 case BuiltinType::SatUAccum:
6484 case BuiltinType::SatULongAccum:
6485 case BuiltinType::SatShortFract:
6486 case BuiltinType::SatFract:
6487 case BuiltinType::SatLongFract:
6488 case BuiltinType::SatUShortFract:
6489 case BuiltinType::SatUFract:
6490 case BuiltinType::SatULongFract:
6491 // FIXME: potentially need @encodes for these!
6492 return ' ';
6493
6494 case BuiltinType::ObjCId:
6495 case BuiltinType::ObjCClass:
6496 case BuiltinType::ObjCSel:
6497 llvm_unreachable("@encoding ObjC primitive type")::llvm::llvm_unreachable_internal("@encoding ObjC primitive type"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6497)
;
6498
6499 // OpenCL and placeholder types don't need @encodings.
6500#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
6501 case BuiltinType::Id:
6502#include "clang/Basic/OpenCLImageTypes.def"
6503 case BuiltinType::OCLEvent:
6504 case BuiltinType::OCLClkEvent:
6505 case BuiltinType::OCLQueue:
6506 case BuiltinType::OCLReserveID:
6507 case BuiltinType::OCLSampler:
6508 case BuiltinType::Dependent:
6509#define BUILTIN_TYPE(KIND, ID)
6510#define PLACEHOLDER_TYPE(KIND, ID) \
6511 case BuiltinType::KIND:
6512#include "clang/AST/BuiltinTypes.def"
6513 llvm_unreachable("invalid builtin type for @encode")::llvm::llvm_unreachable_internal("invalid builtin type for @encode"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6513)
;
6514 }
6515 llvm_unreachable("invalid BuiltinType::Kind value")::llvm::llvm_unreachable_internal("invalid BuiltinType::Kind value"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6515)
;
6516}
6517
6518static char ObjCEncodingForEnumType(const ASTContext *C, const EnumType *ET) {
6519 EnumDecl *Enum = ET->getDecl();
6520
6521 // The encoding of an non-fixed enum type is always 'i', regardless of size.
6522 if (!Enum->isFixed())
6523 return 'i';
6524
6525 // The encoding of a fixed enum type matches its fixed underlying type.
6526 const auto *BT = Enum->getIntegerType()->castAs<BuiltinType>();
6527 return getObjCEncodingForPrimitiveKind(C, BT->getKind());
6528}
6529
6530static void EncodeBitField(const ASTContext *Ctx, std::string& S,
6531 QualType T, const FieldDecl *FD) {
6532 assert(FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl")((FD->isBitField() && "not a bitfield - getObjCEncodingForTypeImpl"
) ? static_cast<void> (0) : __assert_fail ("FD->isBitField() && \"not a bitfield - getObjCEncodingForTypeImpl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6532, __PRETTY_FUNCTION__))
;
6533 S += 'b';
6534 // The NeXT runtime encodes bit fields as b followed by the number of bits.
6535 // The GNU runtime requires more information; bitfields are encoded as b,
6536 // then the offset (in bits) of the first element, then the type of the
6537 // bitfield, then the size in bits. For example, in this structure:
6538 //
6539 // struct
6540 // {
6541 // int integer;
6542 // int flags:2;
6543 // };
6544 // On a 32-bit system, the encoding for flags would be b2 for the NeXT
6545 // runtime, but b32i2 for the GNU runtime. The reason for this extra
6546 // information is not especially sensible, but we're stuck with it for
6547 // compatibility with GCC, although providing it breaks anything that
6548 // actually uses runtime introspection and wants to work on both runtimes...
6549 if (Ctx->getLangOpts().ObjCRuntime.isGNUFamily()) {
6550 uint64_t Offset;
6551
6552 if (const auto *IVD = dyn_cast<ObjCIvarDecl>(FD)) {
6553 Offset = Ctx->lookupFieldBitOffset(IVD->getContainingInterface(), nullptr,
6554 IVD);
6555 } else {
6556 const RecordDecl *RD = FD->getParent();
6557 const ASTRecordLayout &RL = Ctx->getASTRecordLayout(RD);
6558 Offset = RL.getFieldOffset(FD->getFieldIndex());
6559 }
6560
6561 S += llvm::utostr(Offset);
6562
6563 if (const auto *ET = T->getAs<EnumType>())
6564 S += ObjCEncodingForEnumType(Ctx, ET);
6565 else {
6566 const auto *BT = T->castAs<BuiltinType>();
6567 S += getObjCEncodingForPrimitiveKind(Ctx, BT->getKind());
6568 }
6569 }
6570 S += llvm::utostr(FD->getBitWidthValue(*Ctx));
6571}
6572
6573// FIXME: Use SmallString for accumulating string.
6574void ASTContext::getObjCEncodingForTypeImpl(QualType T, std::string& S,
6575 bool ExpandPointedToStructures,
6576 bool ExpandStructures,
6577 const FieldDecl *FD,
6578 bool OutermostType,
6579 bool EncodingProperty,
6580 bool StructField,
6581 bool EncodeBlockParameters,
6582 bool EncodeClassNames,
6583 bool EncodePointerToObjCTypedef,
6584 QualType *NotEncodedT) const {
6585 CanQualType CT = getCanonicalType(T);
6586 switch (CT->getTypeClass()) {
6587 case Type::Builtin:
6588 case Type::Enum:
6589 if (FD && FD->isBitField())
6590 return EncodeBitField(this, S, T, FD);
6591 if (const auto *BT = dyn_cast<BuiltinType>(CT))
6592 S += getObjCEncodingForPrimitiveKind(this, BT->getKind());
6593 else
6594 S += ObjCEncodingForEnumType(this, cast<EnumType>(CT));
6595 return;
6596
6597 case Type::Complex: {
6598 const auto *CT = T->castAs<ComplexType>();
6599 S += 'j';
6600 getObjCEncodingForTypeImpl(CT->getElementType(), S, false, false, nullptr);
6601 return;
6602 }
6603
6604 case Type::Atomic: {
6605 const auto *AT = T->castAs<AtomicType>();
6606 S += 'A';
6607 getObjCEncodingForTypeImpl(AT->getValueType(), S, false, false, nullptr);
6608 return;
6609 }
6610
6611 // encoding for pointer or reference types.
6612 case Type::Pointer:
6613 case Type::LValueReference:
6614 case Type::RValueReference: {
6615 QualType PointeeTy;
6616 if (isa<PointerType>(CT)) {
6617 const auto *PT = T->castAs<PointerType>();
6618 if (PT->isObjCSelType()) {
6619 S += ':';
6620 return;
6621 }
6622 PointeeTy = PT->getPointeeType();
6623 } else {
6624 PointeeTy = T->castAs<ReferenceType>()->getPointeeType();
6625 }
6626
6627 bool isReadOnly = false;
6628 // For historical/compatibility reasons, the read-only qualifier of the
6629 // pointee gets emitted _before_ the '^'. The read-only qualifier of
6630 // the pointer itself gets ignored, _unless_ we are looking at a typedef!
6631 // Also, do not emit the 'r' for anything but the outermost type!
6632 if (isa<TypedefType>(T.getTypePtr())) {
6633 if (OutermostType && T.isConstQualified()) {
6634 isReadOnly = true;
6635 S += 'r';
6636 }
6637 } else if (OutermostType) {
6638 QualType P = PointeeTy;
6639 while (P->getAs<PointerType>())
6640 P = P->getAs<PointerType>()->getPointeeType();
6641 if (P.isConstQualified()) {
6642 isReadOnly = true;
6643 S += 'r';
6644 }
6645 }
6646 if (isReadOnly) {
6647 // Another legacy compatibility encoding. Some ObjC qualifier and type
6648 // combinations need to be rearranged.
6649 // Rewrite "in const" from "nr" to "rn"
6650 if (StringRef(S).endswith("nr"))
6651 S.replace(S.end()-2, S.end(), "rn");
6652 }
6653
6654 if (PointeeTy->isCharType()) {
6655 // char pointer types should be encoded as '*' unless it is a
6656 // type that has been typedef'd to 'BOOL'.
6657 if (!isTypeTypedefedAsBOOL(PointeeTy)) {
6658 S += '*';
6659 return;
6660 }
6661 } else if (const auto *RTy = PointeeTy->getAs<RecordType>()) {
6662 // GCC binary compat: Need to convert "struct objc_class *" to "#".
6663 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_class")) {
6664 S += '#';
6665 return;
6666 }
6667 // GCC binary compat: Need to convert "struct objc_object *" to "@".
6668 if (RTy->getDecl()->getIdentifier() == &Idents.get("objc_object")) {
6669 S += '@';
6670 return;
6671 }
6672 // fall through...
6673 }
6674 S += '^';
6675 getLegacyIntegralTypeEncoding(PointeeTy);
6676
6677 getObjCEncodingForTypeImpl(PointeeTy, S, false, ExpandPointedToStructures,
6678 nullptr, false, false, false, false, false, false,
6679 NotEncodedT);
6680 return;
6681 }
6682
6683 case Type::ConstantArray:
6684 case Type::IncompleteArray:
6685 case Type::VariableArray: {
6686 const auto *AT = cast<ArrayType>(CT);
6687
6688 if (isa<IncompleteArrayType>(AT) && !StructField) {
6689 // Incomplete arrays are encoded as a pointer to the array element.
6690 S += '^';
6691
6692 getObjCEncodingForTypeImpl(AT->getElementType(), S,
6693 false, ExpandStructures, FD);
6694 } else {
6695 S += '[';
6696
6697 if (const auto *CAT = dyn_cast<ConstantArrayType>(AT))
6698 S += llvm::utostr(CAT->getSize().getZExtValue());
6699 else {
6700 //Variable length arrays are encoded as a regular array with 0 elements.
6701 assert((isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) &&(((isa<VariableArrayType>(AT) || isa<IncompleteArrayType
>(AT)) && "Unknown array type!") ? static_cast<
void> (0) : __assert_fail ("(isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && \"Unknown array type!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6702, __PRETTY_FUNCTION__))
6702 "Unknown array type!")(((isa<VariableArrayType>(AT) || isa<IncompleteArrayType
>(AT)) && "Unknown array type!") ? static_cast<
void> (0) : __assert_fail ("(isa<VariableArrayType>(AT) || isa<IncompleteArrayType>(AT)) && \"Unknown array type!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6702, __PRETTY_FUNCTION__))
;
6703 S += '0';
6704 }
6705
6706 getObjCEncodingForTypeImpl(AT->getElementType(), S,
6707 false, ExpandStructures, FD,
6708 false, false, false, false, false, false,
6709 NotEncodedT);
6710 S += ']';
6711 }
6712 return;
6713 }
6714
6715 case Type::FunctionNoProto:
6716 case Type::FunctionProto:
6717 S += '?';
6718 return;
6719
6720 case Type::Record: {
6721 RecordDecl *RDecl = cast<RecordType>(CT)->getDecl();
6722 S += RDecl->isUnion() ? '(' : '{';
6723 // Anonymous structures print as '?'
6724 if (const IdentifierInfo *II = RDecl->getIdentifier()) {
6725 S += II->getName();
6726 if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(RDecl)) {
6727 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
6728 llvm::raw_string_ostream OS(S);
6729 printTemplateArgumentList(OS, TemplateArgs.asArray(),
6730 getPrintingPolicy());
6731 }
6732 } else {
6733 S += '?';
6734 }
6735 if (ExpandStructures) {
6736 S += '=';
6737 if (!RDecl->isUnion()) {
6738 getObjCEncodingForStructureImpl(RDecl, S, FD, true, NotEncodedT);
6739 } else {
6740 for (const auto *Field : RDecl->fields()) {
6741 if (FD) {
6742 S += '"';
6743 S += Field->getNameAsString();
6744 S += '"';
6745 }
6746
6747 // Special case bit-fields.
6748 if (Field->isBitField()) {
6749 getObjCEncodingForTypeImpl(Field->getType(), S, false, true,
6750 Field);
6751 } else {
6752 QualType qt = Field->getType();
6753 getLegacyIntegralTypeEncoding(qt);
6754 getObjCEncodingForTypeImpl(qt, S, false, true,
6755 FD, /*OutermostType*/false,
6756 /*EncodingProperty*/false,
6757 /*StructField*/true,
6758 false, false, false, NotEncodedT);
6759 }
6760 }
6761 }
6762 }
6763 S += RDecl->isUnion() ? ')' : '}';
6764 return;
6765 }
6766
6767 case Type::BlockPointer: {
6768 const auto *BT = T->castAs<BlockPointerType>();
6769 S += "@?"; // Unlike a pointer-to-function, which is "^?".
6770 if (EncodeBlockParameters) {
6771 const auto *FT = BT->getPointeeType()->castAs<FunctionType>();
6772
6773 S += '<';
6774 // Block return type
6775 getObjCEncodingForTypeImpl(
6776 FT->getReturnType(), S, ExpandPointedToStructures, ExpandStructures,
6777 FD, false /* OutermostType */, EncodingProperty,
6778 false /* StructField */, EncodeBlockParameters, EncodeClassNames, false,
6779 NotEncodedT);
6780 // Block self
6781 S += "@?";
6782 // Block parameters
6783 if (const auto *FPT = dyn_cast<FunctionProtoType>(FT)) {
6784 for (const auto &I : FPT->param_types())
6785 getObjCEncodingForTypeImpl(
6786 I, S, ExpandPointedToStructures, ExpandStructures, FD,
6787 false /* OutermostType */, EncodingProperty,
6788 false /* StructField */, EncodeBlockParameters, EncodeClassNames,
6789 false, NotEncodedT);
6790 }
6791 S += '>';
6792 }
6793 return;
6794 }
6795
6796 case Type::ObjCObject: {
6797 // hack to match legacy encoding of *id and *Class
6798 QualType Ty = getObjCObjectPointerType(CT);
6799 if (Ty->isObjCIdType()) {
6800 S += "{objc_object=}";
6801 return;
6802 }
6803 else if (Ty->isObjCClassType()) {
6804 S += "{objc_class=}";
6805 return;
6806 }
6807 // TODO: Double check to make sure this intentionally falls through.
6808 LLVM_FALLTHROUGH[[clang::fallthrough]];
6809 }
6810
6811 case Type::ObjCInterface: {
6812 // Ignore protocol qualifiers when mangling at this level.
6813 // @encode(class_name)
6814 ObjCInterfaceDecl *OI = T->castAs<ObjCObjectType>()->getInterface();
6815 S += '{';
6816 S += OI->getObjCRuntimeNameAsString();
6817 if (ExpandStructures) {
6818 S += '=';
6819 SmallVector<const ObjCIvarDecl*, 32> Ivars;
6820 DeepCollectObjCIvars(OI, true, Ivars);
6821 for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
6822 const FieldDecl *Field = Ivars[i];
6823 if (Field->isBitField())
6824 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, Field);
6825 else
6826 getObjCEncodingForTypeImpl(Field->getType(), S, false, true, FD,
6827 false, false, false, false, false,
6828 EncodePointerToObjCTypedef,
6829 NotEncodedT);
6830 }
6831 }
6832 S += '}';
6833 return;
6834 }
6835
6836 case Type::ObjCObjectPointer: {
6837 const auto *OPT = T->castAs<ObjCObjectPointerType>();
6838 if (OPT->isObjCIdType()) {
6839 S += '@';
6840 return;
6841 }
6842
6843 if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
6844 // FIXME: Consider if we need to output qualifiers for 'Class<p>'.
6845 // Since this is a binary compatibility issue, need to consult with runtime
6846 // folks. Fortunately, this is a *very* obscure construct.
6847 S += '#';
6848 return;
6849 }
6850
6851 if (OPT->isObjCQualifiedIdType()) {
6852 getObjCEncodingForTypeImpl(getObjCIdType(), S,
6853 ExpandPointedToStructures,
6854 ExpandStructures, FD);
6855 if (FD || EncodingProperty || EncodeClassNames) {
6856 // Note that we do extended encoding of protocol qualifer list
6857 // Only when doing ivar or property encoding.
6858 S += '"';
6859 for (const auto *I : OPT->quals()) {
6860 S += '<';
6861 S += I->getObjCRuntimeNameAsString();
6862 S += '>';
6863 }
6864 S += '"';
6865 }
6866 return;
6867 }
6868
6869 QualType PointeeTy = OPT->getPointeeType();
6870 if (!EncodingProperty &&
6871 isa<TypedefType>(PointeeTy.getTypePtr()) &&
6872 !EncodePointerToObjCTypedef) {
6873 // Another historical/compatibility reason.
6874 // We encode the underlying type which comes out as
6875 // {...};
6876 S += '^';
6877 if (FD && OPT->getInterfaceDecl()) {
6878 // Prevent recursive encoding of fields in some rare cases.
6879 ObjCInterfaceDecl *OI = OPT->getInterfaceDecl();
6880 SmallVector<const ObjCIvarDecl*, 32> Ivars;
6881 DeepCollectObjCIvars(OI, true, Ivars);
6882 for (unsigned i = 0, e = Ivars.size(); i != e; ++i) {
6883 if (Ivars[i] == FD) {
6884 S += '{';
6885 S += OI->getObjCRuntimeNameAsString();
6886 S += '}';
6887 return;
6888 }
6889 }
6890 }
6891 getObjCEncodingForTypeImpl(PointeeTy, S,
6892 false, ExpandPointedToStructures,
6893 nullptr,
6894 false, false, false, false, false,
6895 /*EncodePointerToObjCTypedef*/true);
6896 return;
6897 }
6898
6899 S += '@';
6900 if (OPT->getInterfaceDecl() &&
6901 (FD || EncodingProperty || EncodeClassNames)) {
6902 S += '"';
6903 S += OPT->getInterfaceDecl()->getObjCRuntimeNameAsString();
6904 for (const auto *I : OPT->quals()) {
6905 S += '<';
6906 S += I->getObjCRuntimeNameAsString();
6907 S += '>';
6908 }
6909 S += '"';
6910 }
6911 return;
6912 }
6913
6914 // gcc just blithely ignores member pointers.
6915 // FIXME: we shoul do better than that. 'M' is available.
6916 case Type::MemberPointer:
6917 // This matches gcc's encoding, even though technically it is insufficient.
6918 //FIXME. We should do a better job than gcc.
6919 case Type::Vector:
6920 case Type::ExtVector:
6921 // Until we have a coherent encoding of these three types, issue warning.
6922 if (NotEncodedT)
6923 *NotEncodedT = T;
6924 return;
6925
6926 // We could see an undeduced auto type here during error recovery.
6927 // Just ignore it.
6928 case Type::Auto:
6929 case Type::DeducedTemplateSpecialization:
6930 return;
6931
6932 case Type::Pipe:
6933#define ABSTRACT_TYPE(KIND, BASE)
6934#define TYPE(KIND, BASE)
6935#define DEPENDENT_TYPE(KIND, BASE) \
6936 case Type::KIND:
6937#define NON_CANONICAL_TYPE(KIND, BASE) \
6938 case Type::KIND:
6939#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(KIND, BASE) \
6940 case Type::KIND:
6941#include "clang/AST/TypeNodes.def"
6942 llvm_unreachable("@encode for dependent type!")::llvm::llvm_unreachable_internal("@encode for dependent type!"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6942)
;
6943 }
6944 llvm_unreachable("bad type kind!")::llvm::llvm_unreachable_internal("bad type kind!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6944)
;
6945}
6946
6947void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl,
6948 std::string &S,
6949 const FieldDecl *FD,
6950 bool includeVBases,
6951 QualType *NotEncodedT) const {
6952 assert(RDecl && "Expected non-null RecordDecl")((RDecl && "Expected non-null RecordDecl") ? static_cast
<void> (0) : __assert_fail ("RDecl && \"Expected non-null RecordDecl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6952, __PRETTY_FUNCTION__))
;
6953 assert(!RDecl->isUnion() && "Should not be called for unions")((!RDecl->isUnion() && "Should not be called for unions"
) ? static_cast<void> (0) : __assert_fail ("!RDecl->isUnion() && \"Should not be called for unions\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 6953, __PRETTY_FUNCTION__))
;
6954 if (!RDecl->getDefinition() || RDecl->getDefinition()->isInvalidDecl())
6955 return;
6956
6957 const auto *CXXRec = dyn_cast<CXXRecordDecl>(RDecl);
6958 std::multimap<uint64_t, NamedDecl *> FieldOrBaseOffsets;
6959 const ASTRecordLayout &layout = getASTRecordLayout(RDecl);
6960
6961 if (CXXRec) {
6962 for (const auto &BI : CXXRec->bases()) {
6963 if (!BI.isVirtual()) {
6964 CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
6965 if (base->isEmpty())
6966 continue;
6967 uint64_t offs = toBits(layout.getBaseClassOffset(base));
6968 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
6969 std::make_pair(offs, base));
6970 }
6971 }
6972 }
6973
6974 unsigned i = 0;
6975 for (auto *Field : RDecl->fields()) {
6976 uint64_t offs = layout.getFieldOffset(i);
6977 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
6978 std::make_pair(offs, Field));
6979 ++i;
6980 }
6981
6982 if (CXXRec && includeVBases) {
6983 for (const auto &BI : CXXRec->vbases()) {
6984 CXXRecordDecl *base = BI.getType()->getAsCXXRecordDecl();
6985 if (base->isEmpty())
6986 continue;
6987 uint64_t offs = toBits(layout.getVBaseClassOffset(base));
6988 if (offs >= uint64_t(toBits(layout.getNonVirtualSize())) &&
6989 FieldOrBaseOffsets.find(offs) == FieldOrBaseOffsets.end())
6990 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.end(),
6991 std::make_pair(offs, base));
6992 }
6993 }
6994
6995 CharUnits size;
6996 if (CXXRec) {
6997 size = includeVBases ? layout.getSize() : layout.getNonVirtualSize();
6998 } else {
6999 size = layout.getSize();
7000 }
7001
7002#ifndef NDEBUG
7003 uint64_t CurOffs = 0;
7004#endif
7005 std::multimap<uint64_t, NamedDecl *>::iterator
7006 CurLayObj = FieldOrBaseOffsets.begin();
7007
7008 if (CXXRec && CXXRec->isDynamicClass() &&
7009 (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
7010 if (FD) {
7011 S += "\"_vptr$";
7012 std::string recname = CXXRec->getNameAsString();
7013 if (recname.empty()) recname = "?";
7014 S += recname;
7015 S += '"';
7016 }
7017 S += "^^?";
7018#ifndef NDEBUG
7019 CurOffs += getTypeSize(VoidPtrTy);
7020#endif
7021 }
7022
7023 if (!RDecl->hasFlexibleArrayMember()) {
7024 // Mark the end of the structure.
7025 uint64_t offs = toBits(size);
7026 FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
7027 std::make_pair(offs, nullptr));
7028 }
7029
7030 for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {
7031#ifndef NDEBUG
7032 assert(CurOffs <= CurLayObj->first)((CurOffs <= CurLayObj->first) ? static_cast<void>
(0) : __assert_fail ("CurOffs <= CurLayObj->first", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7032, __PRETTY_FUNCTION__))
;
7033 if (CurOffs < CurLayObj->first) {
7034 uint64_t padding = CurLayObj->first - CurOffs;
7035 // FIXME: There doesn't seem to be a way to indicate in the encoding that
7036 // packing/alignment of members is different that normal, in which case
7037 // the encoding will be out-of-sync with the real layout.
7038 // If the runtime switches to just consider the size of types without
7039 // taking into account alignment, we could make padding explicit in the
7040 // encoding (e.g. using arrays of chars). The encoding strings would be
7041 // longer then though.
7042 CurOffs += padding;
7043 }
7044#endif
7045
7046 NamedDecl *dcl = CurLayObj->second;
7047 if (!dcl)
7048 break; // reached end of structure.
7049
7050 if (auto *base = dyn_cast<CXXRecordDecl>(dcl)) {
7051 // We expand the bases without their virtual bases since those are going
7052 // in the initial structure. Note that this differs from gcc which
7053 // expands virtual bases each time one is encountered in the hierarchy,
7054 // making the encoding type bigger than it really is.
7055 getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false,
7056 NotEncodedT);
7057 assert(!base->isEmpty())((!base->isEmpty()) ? static_cast<void> (0) : __assert_fail
("!base->isEmpty()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7057, __PRETTY_FUNCTION__))
;
7058#ifndef NDEBUG
7059 CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize());
7060#endif
7061 } else {
7062 const auto *field = cast<FieldDecl>(dcl);
7063 if (FD) {
7064 S += '"';
7065 S += field->getNameAsString();
7066 S += '"';
7067 }
7068
7069 if (field->isBitField()) {
7070 EncodeBitField(this, S, field->getType(), field);
7071#ifndef NDEBUG
7072 CurOffs += field->getBitWidthValue(*this);
7073#endif
7074 } else {
7075 QualType qt = field->getType();
7076 getLegacyIntegralTypeEncoding(qt);
7077 getObjCEncodingForTypeImpl(qt, S, false, true, FD,
7078 /*OutermostType*/false,
7079 /*EncodingProperty*/false,
7080 /*StructField*/true,
7081 false, false, false, NotEncodedT);
7082#ifndef NDEBUG
7083 CurOffs += getTypeSize(field->getType());
7084#endif
7085 }
7086 }
7087 }
7088}
7089
7090void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
7091 std::string& S) const {
7092 if (QT & Decl::OBJC_TQ_In)
7093 S += 'n';
7094 if (QT & Decl::OBJC_TQ_Inout)
7095 S += 'N';
7096 if (QT & Decl::OBJC_TQ_Out)
7097 S += 'o';
7098 if (QT & Decl::OBJC_TQ_Bycopy)
7099 S += 'O';
7100 if (QT & Decl::OBJC_TQ_Byref)
7101 S += 'R';
7102 if (QT & Decl::OBJC_TQ_Oneway)
7103 S += 'V';
7104}
7105
7106TypedefDecl *ASTContext::getObjCIdDecl() const {
7107 if (!ObjCIdDecl) {
7108 QualType T = getObjCObjectType(ObjCBuiltinIdTy, {}, {});
7109 T = getObjCObjectPointerType(T);
7110 ObjCIdDecl = buildImplicitTypedef(T, "id");
7111 }
7112 return ObjCIdDecl;
7113}
7114
7115TypedefDecl *ASTContext::getObjCSelDecl() const {
7116 if (!ObjCSelDecl) {
7117 QualType T = getPointerType(ObjCBuiltinSelTy);
7118 ObjCSelDecl = buildImplicitTypedef(T, "SEL");
7119 }
7120 return ObjCSelDecl;
7121}
7122
7123TypedefDecl *ASTContext::getObjCClassDecl() const {
7124 if (!ObjCClassDecl) {
7125 QualType T = getObjCObjectType(ObjCBuiltinClassTy, {}, {});
7126 T = getObjCObjectPointerType(T);
7127 ObjCClassDecl = buildImplicitTypedef(T, "Class");
7128 }
7129 return ObjCClassDecl;
7130}
7131
7132ObjCInterfaceDecl *ASTContext::getObjCProtocolDecl() const {
7133 if (!ObjCProtocolClassDecl) {
7134 ObjCProtocolClassDecl
7135 = ObjCInterfaceDecl::Create(*this, getTranslationUnitDecl(),
7136 SourceLocation(),
7137 &Idents.get("Protocol"),
7138 /*typeParamList=*/nullptr,
7139 /*PrevDecl=*/nullptr,
7140 SourceLocation(), true);
7141 }
7142
7143 return ObjCProtocolClassDecl;
7144}
7145
7146//===----------------------------------------------------------------------===//
7147// __builtin_va_list Construction Functions
7148//===----------------------------------------------------------------------===//
7149
7150static TypedefDecl *CreateCharPtrNamedVaListDecl(const ASTContext *Context,
7151 StringRef Name) {
7152 // typedef char* __builtin[_ms]_va_list;
7153 QualType T = Context->getPointerType(Context->CharTy);
7154 return Context->buildImplicitTypedef(T, Name);
7155}
7156
7157static TypedefDecl *CreateMSVaListDecl(const ASTContext *Context) {
7158 return CreateCharPtrNamedVaListDecl(Context, "__builtin_ms_va_list");
7159}
7160
7161static TypedefDecl *CreateCharPtrBuiltinVaListDecl(const ASTContext *Context) {
7162 return CreateCharPtrNamedVaListDecl(Context, "__builtin_va_list");
7163}
7164
7165static TypedefDecl *CreateVoidPtrBuiltinVaListDecl(const ASTContext *Context) {
7166 // typedef void* __builtin_va_list;
7167 QualType T = Context->getPointerType(Context->VoidTy);
7168 return Context->buildImplicitTypedef(T, "__builtin_va_list");
7169}
7170
7171static TypedefDecl *
7172CreateAArch64ABIBuiltinVaListDecl(const ASTContext *Context) {
7173 // struct __va_list
7174 RecordDecl *VaListTagDecl = Context->buildImplicitRecord("__va_list");
7175 if (Context->getLangOpts().CPlusPlus) {
7176 // namespace std { struct __va_list {
7177 NamespaceDecl *NS;
7178 NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
7179 Context->getTranslationUnitDecl(),
7180 /*Inline*/ false, SourceLocation(),
7181 SourceLocation(), &Context->Idents.get("std"),
7182 /*PrevDecl*/ nullptr);
7183 NS->setImplicit();
7184 VaListTagDecl->setDeclContext(NS);
7185 }
7186
7187 VaListTagDecl->startDefinition();
7188
7189 const size_t NumFields = 5;
7190 QualType FieldTypes[NumFields];
7191 const char *FieldNames[NumFields];
7192
7193 // void *__stack;
7194 FieldTypes[0] = Context->getPointerType(Context->VoidTy);
7195 FieldNames[0] = "__stack";
7196
7197 // void *__gr_top;
7198 FieldTypes[1] = Context->getPointerType(Context->VoidTy);
7199 FieldNames[1] = "__gr_top";
7200
7201 // void *__vr_top;
7202 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
7203 FieldNames[2] = "__vr_top";
7204
7205 // int __gr_offs;
7206 FieldTypes[3] = Context->IntTy;
7207 FieldNames[3] = "__gr_offs";
7208
7209 // int __vr_offs;
7210 FieldTypes[4] = Context->IntTy;
7211 FieldNames[4] = "__vr_offs";
7212
7213 // Create fields
7214 for (unsigned i = 0; i < NumFields; ++i) {
7215 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7216 VaListTagDecl,
7217 SourceLocation(),
7218 SourceLocation(),
7219 &Context->Idents.get(FieldNames[i]),
7220 FieldTypes[i], /*TInfo=*/nullptr,
7221 /*BitWidth=*/nullptr,
7222 /*Mutable=*/false,
7223 ICIS_NoInit);
7224 Field->setAccess(AS_public);
7225 VaListTagDecl->addDecl(Field);
7226 }
7227 VaListTagDecl->completeDefinition();
7228 Context->VaListTagDecl = VaListTagDecl;
7229 QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7230
7231 // } __builtin_va_list;
7232 return Context->buildImplicitTypedef(VaListTagType, "__builtin_va_list");
7233}
7234
7235static TypedefDecl *CreatePowerABIBuiltinVaListDecl(const ASTContext *Context) {
7236 // typedef struct __va_list_tag {
7237 RecordDecl *VaListTagDecl;
7238
7239 VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
7240 VaListTagDecl->startDefinition();
7241
7242 const size_t NumFields = 5;
7243 QualType FieldTypes[NumFields];
7244 const char *FieldNames[NumFields];
7245
7246 // unsigned char gpr;
7247 FieldTypes[0] = Context->UnsignedCharTy;
7248 FieldNames[0] = "gpr";
7249
7250 // unsigned char fpr;
7251 FieldTypes[1] = Context->UnsignedCharTy;
7252 FieldNames[1] = "fpr";
7253
7254 // unsigned short reserved;
7255 FieldTypes[2] = Context->UnsignedShortTy;
7256 FieldNames[2] = "reserved";
7257
7258 // void* overflow_arg_area;
7259 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
7260 FieldNames[3] = "overflow_arg_area";
7261
7262 // void* reg_save_area;
7263 FieldTypes[4] = Context->getPointerType(Context->VoidTy);
7264 FieldNames[4] = "reg_save_area";
7265
7266 // Create fields
7267 for (unsigned i = 0; i < NumFields; ++i) {
7268 FieldDecl *Field = FieldDecl::Create(*Context, VaListTagDecl,
7269 SourceLocation(),
7270 SourceLocation(),
7271 &Context->Idents.get(FieldNames[i]),
7272 FieldTypes[i], /*TInfo=*/nullptr,
7273 /*BitWidth=*/nullptr,
7274 /*Mutable=*/false,
7275 ICIS_NoInit);
7276 Field->setAccess(AS_public);
7277 VaListTagDecl->addDecl(Field);
7278 }
7279 VaListTagDecl->completeDefinition();
7280 Context->VaListTagDecl = VaListTagDecl;
7281 QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7282
7283 // } __va_list_tag;
7284 TypedefDecl *VaListTagTypedefDecl =
7285 Context->buildImplicitTypedef(VaListTagType, "__va_list_tag");
7286
7287 QualType VaListTagTypedefType =
7288 Context->getTypedefType(VaListTagTypedefDecl);
7289
7290 // typedef __va_list_tag __builtin_va_list[1];
7291 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
7292 QualType VaListTagArrayType
7293 = Context->getConstantArrayType(VaListTagTypedefType,
7294 Size, ArrayType::Normal, 0);
7295 return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7296}
7297
7298static TypedefDecl *
7299CreateX86_64ABIBuiltinVaListDecl(const ASTContext *Context) {
7300 // struct __va_list_tag {
7301 RecordDecl *VaListTagDecl;
7302 VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
7303 VaListTagDecl->startDefinition();
7304
7305 const size_t NumFields = 4;
7306 QualType FieldTypes[NumFields];
7307 const char *FieldNames[NumFields];
7308
7309 // unsigned gp_offset;
7310 FieldTypes[0] = Context->UnsignedIntTy;
7311 FieldNames[0] = "gp_offset";
7312
7313 // unsigned fp_offset;
7314 FieldTypes[1] = Context->UnsignedIntTy;
7315 FieldNames[1] = "fp_offset";
7316
7317 // void* overflow_arg_area;
7318 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
7319 FieldNames[2] = "overflow_arg_area";
7320
7321 // void* reg_save_area;
7322 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
7323 FieldNames[3] = "reg_save_area";
7324
7325 // Create fields
7326 for (unsigned i = 0; i < NumFields; ++i) {
7327 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7328 VaListTagDecl,
7329 SourceLocation(),
7330 SourceLocation(),
7331 &Context->Idents.get(FieldNames[i]),
7332 FieldTypes[i], /*TInfo=*/nullptr,
7333 /*BitWidth=*/nullptr,
7334 /*Mutable=*/false,
7335 ICIS_NoInit);
7336 Field->setAccess(AS_public);
7337 VaListTagDecl->addDecl(Field);
7338 }
7339 VaListTagDecl->completeDefinition();
7340 Context->VaListTagDecl = VaListTagDecl;
7341 QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7342
7343 // };
7344
7345 // typedef struct __va_list_tag __builtin_va_list[1];
7346 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
7347 QualType VaListTagArrayType =
7348 Context->getConstantArrayType(VaListTagType, Size, ArrayType::Normal, 0);
7349 return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7350}
7351
7352static TypedefDecl *CreatePNaClABIBuiltinVaListDecl(const ASTContext *Context) {
7353 // typedef int __builtin_va_list[4];
7354 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 4);
7355 QualType IntArrayType =
7356 Context->getConstantArrayType(Context->IntTy, Size, ArrayType::Normal, 0);
7357 return Context->buildImplicitTypedef(IntArrayType, "__builtin_va_list");
7358}
7359
7360static TypedefDecl *
7361CreateAAPCSABIBuiltinVaListDecl(const ASTContext *Context) {
7362 // struct __va_list
7363 RecordDecl *VaListDecl = Context->buildImplicitRecord("__va_list");
7364 if (Context->getLangOpts().CPlusPlus) {
7365 // namespace std { struct __va_list {
7366 NamespaceDecl *NS;
7367 NS = NamespaceDecl::Create(const_cast<ASTContext &>(*Context),
7368 Context->getTranslationUnitDecl(),
7369 /*Inline*/false, SourceLocation(),
7370 SourceLocation(), &Context->Idents.get("std"),
7371 /*PrevDecl*/ nullptr);
7372 NS->setImplicit();
7373 VaListDecl->setDeclContext(NS);
7374 }
7375
7376 VaListDecl->startDefinition();
7377
7378 // void * __ap;
7379 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7380 VaListDecl,
7381 SourceLocation(),
7382 SourceLocation(),
7383 &Context->Idents.get("__ap"),
7384 Context->getPointerType(Context->VoidTy),
7385 /*TInfo=*/nullptr,
7386 /*BitWidth=*/nullptr,
7387 /*Mutable=*/false,
7388 ICIS_NoInit);
7389 Field->setAccess(AS_public);
7390 VaListDecl->addDecl(Field);
7391
7392 // };
7393 VaListDecl->completeDefinition();
7394 Context->VaListTagDecl = VaListDecl;
7395
7396 // typedef struct __va_list __builtin_va_list;
7397 QualType T = Context->getRecordType(VaListDecl);
7398 return Context->buildImplicitTypedef(T, "__builtin_va_list");
7399}
7400
7401static TypedefDecl *
7402CreateSystemZBuiltinVaListDecl(const ASTContext *Context) {
7403 // struct __va_list_tag {
7404 RecordDecl *VaListTagDecl;
7405 VaListTagDecl = Context->buildImplicitRecord("__va_list_tag");
7406 VaListTagDecl->startDefinition();
7407
7408 const size_t NumFields = 4;
7409 QualType FieldTypes[NumFields];
7410 const char *FieldNames[NumFields];
7411
7412 // long __gpr;
7413 FieldTypes[0] = Context->LongTy;
7414 FieldNames[0] = "__gpr";
7415
7416 // long __fpr;
7417 FieldTypes[1] = Context->LongTy;
7418 FieldNames[1] = "__fpr";
7419
7420 // void *__overflow_arg_area;
7421 FieldTypes[2] = Context->getPointerType(Context->VoidTy);
7422 FieldNames[2] = "__overflow_arg_area";
7423
7424 // void *__reg_save_area;
7425 FieldTypes[3] = Context->getPointerType(Context->VoidTy);
7426 FieldNames[3] = "__reg_save_area";
7427
7428 // Create fields
7429 for (unsigned i = 0; i < NumFields; ++i) {
7430 FieldDecl *Field = FieldDecl::Create(const_cast<ASTContext &>(*Context),
7431 VaListTagDecl,
7432 SourceLocation(),
7433 SourceLocation(),
7434 &Context->Idents.get(FieldNames[i]),
7435 FieldTypes[i], /*TInfo=*/nullptr,
7436 /*BitWidth=*/nullptr,
7437 /*Mutable=*/false,
7438 ICIS_NoInit);
7439 Field->setAccess(AS_public);
7440 VaListTagDecl->addDecl(Field);
7441 }
7442 VaListTagDecl->completeDefinition();
7443 Context->VaListTagDecl = VaListTagDecl;
7444 QualType VaListTagType = Context->getRecordType(VaListTagDecl);
7445
7446 // };
7447
7448 // typedef __va_list_tag __builtin_va_list[1];
7449 llvm::APInt Size(Context->getTypeSize(Context->getSizeType()), 1);
7450 QualType VaListTagArrayType =
7451 Context->getConstantArrayType(VaListTagType, Size, ArrayType::Normal, 0);
7452
7453 return Context->buildImplicitTypedef(VaListTagArrayType, "__builtin_va_list");
7454}
7455
7456static TypedefDecl *CreateVaListDecl(const ASTContext *Context,
7457 TargetInfo::BuiltinVaListKind Kind) {
7458 switch (Kind) {
7459 case TargetInfo::CharPtrBuiltinVaList:
7460 return CreateCharPtrBuiltinVaListDecl(Context);
7461 case TargetInfo::VoidPtrBuiltinVaList:
7462 return CreateVoidPtrBuiltinVaListDecl(Context);
7463 case TargetInfo::AArch64ABIBuiltinVaList:
7464 return CreateAArch64ABIBuiltinVaListDecl(Context);
7465 case TargetInfo::PowerABIBuiltinVaList:
7466 return CreatePowerABIBuiltinVaListDecl(Context);
7467 case TargetInfo::X86_64ABIBuiltinVaList:
7468 return CreateX86_64ABIBuiltinVaListDecl(Context);
7469 case TargetInfo::PNaClABIBuiltinVaList:
7470 return CreatePNaClABIBuiltinVaListDecl(Context);
7471 case TargetInfo::AAPCSABIBuiltinVaList:
7472 return CreateAAPCSABIBuiltinVaListDecl(Context);
7473 case TargetInfo::SystemZBuiltinVaList:
7474 return CreateSystemZBuiltinVaListDecl(Context);
7475 }
7476
7477 llvm_unreachable("Unhandled __builtin_va_list type kind")::llvm::llvm_unreachable_internal("Unhandled __builtin_va_list type kind"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7477)
;
7478}
7479
7480TypedefDecl *ASTContext::getBuiltinVaListDecl() const {
7481 if (!BuiltinVaListDecl) {
7482 BuiltinVaListDecl = CreateVaListDecl(this, Target->getBuiltinVaListKind());
7483 assert(BuiltinVaListDecl->isImplicit())((BuiltinVaListDecl->isImplicit()) ? static_cast<void>
(0) : __assert_fail ("BuiltinVaListDecl->isImplicit()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7483, __PRETTY_FUNCTION__))
;
7484 }
7485
7486 return BuiltinVaListDecl;
7487}
7488
7489Decl *ASTContext::getVaListTagDecl() const {
7490 // Force the creation of VaListTagDecl by building the __builtin_va_list
7491 // declaration.
7492 if (!VaListTagDecl)
7493 (void)getBuiltinVaListDecl();
7494
7495 return VaListTagDecl;
7496}
7497
7498TypedefDecl *ASTContext::getBuiltinMSVaListDecl() const {
7499 if (!BuiltinMSVaListDecl)
7500 BuiltinMSVaListDecl = CreateMSVaListDecl(this);
7501
7502 return BuiltinMSVaListDecl;
7503}
7504
7505bool ASTContext::canBuiltinBeRedeclared(const FunctionDecl *FD) const {
7506 return BuiltinInfo.canBeRedeclared(FD->getBuiltinID());
7507}
7508
7509void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) {
7510 assert(ObjCConstantStringType.isNull() &&((ObjCConstantStringType.isNull() && "'NSConstantString' type already set!"
) ? static_cast<void> (0) : __assert_fail ("ObjCConstantStringType.isNull() && \"'NSConstantString' type already set!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7511, __PRETTY_FUNCTION__))
7511 "'NSConstantString' type already set!")((ObjCConstantStringType.isNull() && "'NSConstantString' type already set!"
) ? static_cast<void> (0) : __assert_fail ("ObjCConstantStringType.isNull() && \"'NSConstantString' type already set!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7511, __PRETTY_FUNCTION__))
;
7512
7513 ObjCConstantStringType = getObjCInterfaceType(Decl);
7514}
7515
7516/// Retrieve the template name that corresponds to a non-empty
7517/// lookup.
7518TemplateName
7519ASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin,
7520 UnresolvedSetIterator End) const {
7521 unsigned size = End - Begin;
7522 assert(size > 1 && "set is not overloaded!")((size > 1 && "set is not overloaded!") ? static_cast
<void> (0) : __assert_fail ("size > 1 && \"set is not overloaded!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7522, __PRETTY_FUNCTION__))
;
7523
7524 void *memory = Allocate(sizeof(OverloadedTemplateStorage) +
7525 size * sizeof(FunctionTemplateDecl*));
7526 auto *OT = new (memory) OverloadedTemplateStorage(size);
7527
7528 NamedDecl **Storage = OT->getStorage();
7529 for (UnresolvedSetIterator I = Begin; I != End; ++I) {
7530 NamedDecl *D = *I;
7531 assert(isa<FunctionTemplateDecl>(D) ||((isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl
>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl
>(D->getUnderlyingDecl()))) ? static_cast<void> (
0) : __assert_fail ("isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7534, __PRETTY_FUNCTION__))
7532 isa<UnresolvedUsingValueDecl>(D) ||((isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl
>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl
>(D->getUnderlyingDecl()))) ? static_cast<void> (
0) : __assert_fail ("isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7534, __PRETTY_FUNCTION__))
7533 (isa<UsingShadowDecl>(D) &&((isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl
>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl
>(D->getUnderlyingDecl()))) ? static_cast<void> (
0) : __assert_fail ("isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7534, __PRETTY_FUNCTION__))
7534 isa<FunctionTemplateDecl>(D->getUnderlyingDecl())))((isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl
>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl
>(D->getUnderlyingDecl()))) ? static_cast<void> (
0) : __assert_fail ("isa<FunctionTemplateDecl>(D) || isa<UnresolvedUsingValueDecl>(D) || (isa<UsingShadowDecl>(D) && isa<FunctionTemplateDecl>(D->getUnderlyingDecl()))"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7534, __PRETTY_FUNCTION__))
;
7535 *Storage++ = D;
7536 }
7537
7538 return TemplateName(OT);
7539}
7540
7541/// Retrieve the template name that represents a qualified
7542/// template name such as \c std::vector.
7543TemplateName
7544ASTContext::getQualifiedTemplateName(NestedNameSpecifier *NNS,
7545 bool TemplateKeyword,
7546 TemplateDecl *Template) const {
7547 assert(NNS && "Missing nested-name-specifier in qualified template name")((NNS && "Missing nested-name-specifier in qualified template name"
) ? static_cast<void> (0) : __assert_fail ("NNS && \"Missing nested-name-specifier in qualified template name\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7547, __PRETTY_FUNCTION__))
;
7548
7549 // FIXME: Canonicalization?
7550 llvm::FoldingSetNodeID ID;
7551 QualifiedTemplateName::Profile(ID, NNS, TemplateKeyword, Template);
7552
7553 void *InsertPos = nullptr;
7554 QualifiedTemplateName *QTN =
7555 QualifiedTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7556 if (!QTN) {
7557 QTN = new (*this, alignof(QualifiedTemplateName))
7558 QualifiedTemplateName(NNS, TemplateKeyword, Template);
7559 QualifiedTemplateNames.InsertNode(QTN, InsertPos);
7560 }
7561
7562 return TemplateName(QTN);
7563}
7564
7565/// Retrieve the template name that represents a dependent
7566/// template name such as \c MetaFun::template apply.
7567TemplateName
7568ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
7569 const IdentifierInfo *Name) const {
7570 assert((!NNS || NNS->isDependent()) &&(((!NNS || NNS->isDependent()) && "Nested name specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"Nested name specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7571, __PRETTY_FUNCTION__))
7571 "Nested name specifier must be dependent")(((!NNS || NNS->isDependent()) && "Nested name specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"Nested name specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7571, __PRETTY_FUNCTION__))
;
7572
7573 llvm::FoldingSetNodeID ID;
7574 DependentTemplateName::Profile(ID, NNS, Name);
7575
7576 void *InsertPos = nullptr;
7577 DependentTemplateName *QTN =
7578 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7579
7580 if (QTN)
7581 return TemplateName(QTN);
7582
7583 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
7584 if (CanonNNS == NNS) {
7585 QTN = new (*this, alignof(DependentTemplateName))
7586 DependentTemplateName(NNS, Name);
7587 } else {
7588 TemplateName Canon = getDependentTemplateName(CanonNNS, Name);
7589 QTN = new (*this, alignof(DependentTemplateName))
7590 DependentTemplateName(NNS, Name, Canon);
7591 DependentTemplateName *CheckQTN =
7592 DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7593 assert(!CheckQTN && "Dependent type name canonicalization broken")((!CheckQTN && "Dependent type name canonicalization broken"
) ? static_cast<void> (0) : __assert_fail ("!CheckQTN && \"Dependent type name canonicalization broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7593, __PRETTY_FUNCTION__))
;
7594 (void)CheckQTN;
7595 }
7596
7597 DependentTemplateNames.InsertNode(QTN, InsertPos);
7598 return TemplateName(QTN);
7599}
7600
7601/// Retrieve the template name that represents a dependent
7602/// template name such as \c MetaFun::template operator+.
7603TemplateName
7604ASTContext::getDependentTemplateName(NestedNameSpecifier *NNS,
7605 OverloadedOperatorKind Operator) const {
7606 assert((!NNS || NNS->isDependent()) &&(((!NNS || NNS->isDependent()) && "Nested name specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"Nested name specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7607, __PRETTY_FUNCTION__))
7607 "Nested name specifier must be dependent")(((!NNS || NNS->isDependent()) && "Nested name specifier must be dependent"
) ? static_cast<void> (0) : __assert_fail ("(!NNS || NNS->isDependent()) && \"Nested name specifier must be dependent\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7607, __PRETTY_FUNCTION__))
;
7608
7609 llvm::FoldingSetNodeID ID;
7610 DependentTemplateName::Profile(ID, NNS, Operator);
7611
7612 void *InsertPos = nullptr;
7613 DependentTemplateName *QTN
7614 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7615
7616 if (QTN)
7617 return TemplateName(QTN);
7618
7619 NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
7620 if (CanonNNS == NNS) {
7621 QTN = new (*this, alignof(DependentTemplateName))
7622 DependentTemplateName(NNS, Operator);
7623 } else {
7624 TemplateName Canon = getDependentTemplateName(CanonNNS, Operator);
7625 QTN = new (*this, alignof(DependentTemplateName))
7626 DependentTemplateName(NNS, Operator, Canon);
7627
7628 DependentTemplateName *CheckQTN
7629 = DependentTemplateNames.FindNodeOrInsertPos(ID, InsertPos);
7630 assert(!CheckQTN && "Dependent template name canonicalization broken")((!CheckQTN && "Dependent template name canonicalization broken"
) ? static_cast<void> (0) : __assert_fail ("!CheckQTN && \"Dependent template name canonicalization broken\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7630, __PRETTY_FUNCTION__))
;
7631 (void)CheckQTN;
7632 }
7633
7634 DependentTemplateNames.InsertNode(QTN, InsertPos);
7635 return TemplateName(QTN);
7636}
7637
7638TemplateName
7639ASTContext::getSubstTemplateTemplateParm(TemplateTemplateParmDecl *param,
7640 TemplateName replacement) const {
7641 llvm::FoldingSetNodeID ID;
7642 SubstTemplateTemplateParmStorage::Profile(ID, param, replacement);
7643
7644 void *insertPos = nullptr;
7645 SubstTemplateTemplateParmStorage *subst
7646 = SubstTemplateTemplateParms.FindNodeOrInsertPos(ID, insertPos);
7647
7648 if (!subst) {
7649 subst = new (*this) SubstTemplateTemplateParmStorage(param, replacement);
7650 SubstTemplateTemplateParms.InsertNode(subst, insertPos);
7651 }
7652
7653 return TemplateName(subst);
7654}
7655
7656TemplateName
7657ASTContext::getSubstTemplateTemplateParmPack(TemplateTemplateParmDecl *Param,
7658 const TemplateArgument &ArgPack) const {
7659 auto &Self = const_cast<ASTContext &>(*this);
7660 llvm::FoldingSetNodeID ID;
7661 SubstTemplateTemplateParmPackStorage::Profile(ID, Self, Param, ArgPack);
7662
7663 void *InsertPos = nullptr;
7664 SubstTemplateTemplateParmPackStorage *Subst
7665 = SubstTemplateTemplateParmPacks.FindNodeOrInsertPos(ID, InsertPos);
7666
7667 if (!Subst) {
7668 Subst = new (*this) SubstTemplateTemplateParmPackStorage(Param,
7669 ArgPack.pack_size(),
7670 ArgPack.pack_begin());
7671 SubstTemplateTemplateParmPacks.InsertNode(Subst, InsertPos);
7672 }
7673
7674 return TemplateName(Subst);
7675}
7676
7677/// getFromTargetType - Given one of the integer types provided by
7678/// TargetInfo, produce the corresponding type. The unsigned @p Type
7679/// is actually a value of type @c TargetInfo::IntType.
7680CanQualType ASTContext::getFromTargetType(unsigned Type) const {
7681 switch (Type) {
7682 case TargetInfo::NoInt: return {};
7683 case TargetInfo::SignedChar: return SignedCharTy;
7684 case TargetInfo::UnsignedChar: return UnsignedCharTy;
7685 case TargetInfo::SignedShort: return ShortTy;
7686 case TargetInfo::UnsignedShort: return UnsignedShortTy;
7687 case TargetInfo::SignedInt: return IntTy;
7688 case TargetInfo::UnsignedInt: return UnsignedIntTy;
7689 case TargetInfo::SignedLong: return LongTy;
7690 case TargetInfo::UnsignedLong: return UnsignedLongTy;
7691 case TargetInfo::SignedLongLong: return LongLongTy;
7692 case TargetInfo::UnsignedLongLong: return UnsignedLongLongTy;
7693 }
7694
7695 llvm_unreachable("Unhandled TargetInfo::IntType value")::llvm::llvm_unreachable_internal("Unhandled TargetInfo::IntType value"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7695)
;
7696}
7697
7698//===----------------------------------------------------------------------===//
7699// Type Predicates.
7700//===----------------------------------------------------------------------===//
7701
7702/// getObjCGCAttr - Returns one of GCNone, Weak or Strong objc's
7703/// garbage collection attribute.
7704///
7705Qualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const {
7706 if (getLangOpts().getGC() == LangOptions::NonGC)
7707 return Qualifiers::GCNone;
7708
7709 assert(getLangOpts().ObjC1)((getLangOpts().ObjC1) ? static_cast<void> (0) : __assert_fail
("getLangOpts().ObjC1", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7709, __PRETTY_FUNCTION__))
;
7710 Qualifiers::GC GCAttrs = Ty.getObjCGCAttr();
7711
7712 // Default behaviour under objective-C's gc is for ObjC pointers
7713 // (or pointers to them) be treated as though they were declared
7714 // as __strong.
7715 if (GCAttrs == Qualifiers::GCNone) {
7716 if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType())
7717 return Qualifiers::Strong;
7718 else if (Ty->isPointerType())
7719 return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType());
7720 } else {
7721 // It's not valid to set GC attributes on anything that isn't a
7722 // pointer.
7723#ifndef NDEBUG
7724 QualType CT = Ty->getCanonicalTypeInternal();
7725 while (const auto *AT = dyn_cast<ArrayType>(CT))
7726 CT = AT->getElementType();
7727 assert(CT->isAnyPointerType() || CT->isBlockPointerType())((CT->isAnyPointerType() || CT->isBlockPointerType()) ?
static_cast<void> (0) : __assert_fail ("CT->isAnyPointerType() || CT->isBlockPointerType()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7727, __PRETTY_FUNCTION__))
;
7728#endif
7729 }
7730 return GCAttrs;
7731}
7732
7733//===----------------------------------------------------------------------===//
7734// Type Compatibility Testing
7735//===----------------------------------------------------------------------===//
7736
7737/// areCompatVectorTypes - Return true if the two specified vector types are
7738/// compatible.
7739static bool areCompatVectorTypes(const VectorType *LHS,
7740 const VectorType *RHS) {
7741 assert(LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified())((LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified
()) ? static_cast<void> (0) : __assert_fail ("LHS->isCanonicalUnqualified() && RHS->isCanonicalUnqualified()"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7741, __PRETTY_FUNCTION__))
;
7742 return LHS->getElementType() == RHS->getElementType() &&
7743 LHS->getNumElements() == RHS->getNumElements();
7744}
7745
7746bool ASTContext::areCompatibleVectorTypes(QualType FirstVec,
7747 QualType SecondVec) {
7748 assert(FirstVec->isVectorType() && "FirstVec should be a vector type")((FirstVec->isVectorType() && "FirstVec should be a vector type"
) ? static_cast<void> (0) : __assert_fail ("FirstVec->isVectorType() && \"FirstVec should be a vector type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7748, __PRETTY_FUNCTION__))
;
7749 assert(SecondVec->isVectorType() && "SecondVec should be a vector type")((SecondVec->isVectorType() && "SecondVec should be a vector type"
) ? static_cast<void> (0) : __assert_fail ("SecondVec->isVectorType() && \"SecondVec should be a vector type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7749, __PRETTY_FUNCTION__))
;
7750
7751 if (hasSameUnqualifiedType(FirstVec, SecondVec))
7752 return true;
7753
7754 // Treat Neon vector types and most AltiVec vector types as if they are the
7755 // equivalent GCC vector types.
7756 const auto *First = FirstVec->getAs<VectorType>();
7757 const auto *Second = SecondVec->getAs<VectorType>();
7758 if (First->getNumElements() == Second->getNumElements() &&
7759 hasSameType(First->getElementType(), Second->getElementType()) &&
7760 First->getVectorKind() != VectorType::AltiVecPixel &&
7761 First->getVectorKind() != VectorType::AltiVecBool &&
7762 Second->getVectorKind() != VectorType::AltiVecPixel &&
7763 Second->getVectorKind() != VectorType::AltiVecBool)
7764 return true;
7765
7766 return false;
7767}
7768
7769//===----------------------------------------------------------------------===//
7770// ObjCQualifiedIdTypesAreCompatible - Compatibility testing for qualified id's.
7771//===----------------------------------------------------------------------===//
7772
7773/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
7774/// inheritance hierarchy of 'rProto'.
7775bool
7776ASTContext::ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
7777 ObjCProtocolDecl *rProto) const {
7778 if (declaresSameEntity(lProto, rProto))
7779 return true;
7780 for (auto *PI : rProto->protocols())
7781 if (ProtocolCompatibleWithProtocol(lProto, PI))
7782 return true;
7783 return false;
7784}
7785
7786/// ObjCQualifiedClassTypesAreCompatible - compare Class<pr,...> and
7787/// Class<pr1, ...>.
7788bool ASTContext::ObjCQualifiedClassTypesAreCompatible(QualType lhs,
7789 QualType rhs) {
7790 const auto *lhsQID = lhs->getAs<ObjCObjectPointerType>();
7791 const auto *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
7792 assert((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible")(((lhsQID && rhsOPT) && "ObjCQualifiedClassTypesAreCompatible"
) ? static_cast<void> (0) : __assert_fail ("(lhsQID && rhsOPT) && \"ObjCQualifiedClassTypesAreCompatible\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7792, __PRETTY_FUNCTION__))
;
7793
7794 for (auto *lhsProto : lhsQID->quals()) {
7795 bool match = false;
7796 for (auto *rhsProto : rhsOPT->quals()) {
7797 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto)) {
7798 match = true;
7799 break;
7800 }
7801 }
7802 if (!match)
7803 return false;
7804 }
7805 return true;
7806}
7807
7808/// ObjCQualifiedIdTypesAreCompatible - We know that one of lhs/rhs is an
7809/// ObjCQualifiedIDType.
7810bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs, QualType rhs,
7811 bool compare) {
7812 // Allow id<P..> and an 'id' or void* type in all cases.
7813 if (lhs->isVoidPointerType() ||
7814 lhs->isObjCIdType() || lhs->isObjCClassType())
7815 return true;
7816 else if (rhs->isVoidPointerType() ||
7817 rhs->isObjCIdType() || rhs->isObjCClassType())
7818 return true;
7819
7820 if (const ObjCObjectPointerType *lhsQID = lhs->getAsObjCQualifiedIdType()) {
7821 const auto *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
7822
7823 if (!rhsOPT) return false;
7824
7825 if (rhsOPT->qual_empty()) {
7826 // If the RHS is a unqualified interface pointer "NSString*",
7827 // make sure we check the class hierarchy.
7828 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
7829 for (auto *I : lhsQID->quals()) {
7830 // when comparing an id<P> on lhs with a static type on rhs,
7831 // see if static class implements all of id's protocols, directly or
7832 // through its super class and categories.
7833 if (!rhsID->ClassImplementsProtocol(I, true))
7834 return false;
7835 }
7836 }
7837 // If there are no qualifiers and no interface, we have an 'id'.
7838 return true;
7839 }
7840 // Both the right and left sides have qualifiers.
7841 for (auto *lhsProto : lhsQID->quals()) {
7842 bool match = false;
7843
7844 // when comparing an id<P> on lhs with a static type on rhs,
7845 // see if static class implements all of id's protocols, directly or
7846 // through its super class and categories.
7847 for (auto *rhsProto : rhsOPT->quals()) {
7848 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
7849 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
7850 match = true;
7851 break;
7852 }
7853 }
7854 // If the RHS is a qualified interface pointer "NSString<P>*",
7855 // make sure we check the class hierarchy.
7856 if (ObjCInterfaceDecl *rhsID = rhsOPT->getInterfaceDecl()) {
7857 for (auto *I : lhsQID->quals()) {
7858 // when comparing an id<P> on lhs with a static type on rhs,
7859 // see if static class implements all of id's protocols, directly or
7860 // through its super class and categories.
7861 if (rhsID->ClassImplementsProtocol(I, true)) {
7862 match = true;
7863 break;
7864 }
7865 }
7866 }
7867 if (!match)
7868 return false;
7869 }
7870
7871 return true;
7872 }
7873
7874 const ObjCObjectPointerType *rhsQID = rhs->getAsObjCQualifiedIdType();
7875 assert(rhsQID && "One of the LHS/RHS should be id<x>")((rhsQID && "One of the LHS/RHS should be id<x>"
) ? static_cast<void> (0) : __assert_fail ("rhsQID && \"One of the LHS/RHS should be id<x>\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 7875, __PRETTY_FUNCTION__))
;
7876
7877 if (const ObjCObjectPointerType *lhsOPT =
7878 lhs->getAsObjCInterfacePointerType()) {
7879 // If both the right and left sides have qualifiers.
7880 for (auto *lhsProto : lhsOPT->quals()) {
7881 bool match = false;
7882
7883 // when comparing an id<P> on rhs with a static type on lhs,
7884 // see if static class implements all of id's protocols, directly or
7885 // through its super class and categories.
7886 // First, lhs protocols in the qualifier list must be found, direct
7887 // or indirect in rhs's qualifier list or it is a mismatch.
7888 for (auto *rhsProto : rhsQID->quals()) {
7889 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
7890 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
7891 match = true;
7892 break;
7893 }
7894 }
7895 if (!match)
7896 return false;
7897 }
7898
7899 // Static class's protocols, or its super class or category protocols
7900 // must be found, direct or indirect in rhs's qualifier list or it is a mismatch.
7901 if (ObjCInterfaceDecl *lhsID = lhsOPT->getInterfaceDecl()) {
7902 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSInheritedProtocols;
7903 CollectInheritedProtocols(lhsID, LHSInheritedProtocols);
7904 // This is rather dubious but matches gcc's behavior. If lhs has
7905 // no type qualifier and its class has no static protocol(s)
7906 // assume that it is mismatch.
7907 if (LHSInheritedProtocols.empty() && lhsOPT->qual_empty())
7908 return false;
7909 for (auto *lhsProto : LHSInheritedProtocols) {
7910 bool match = false;
7911 for (auto *rhsProto : rhsQID->quals()) {
7912 if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
7913 (compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto))) {
7914 match = true;
7915 break;
7916 }
7917 }
7918 if (!match)
7919 return false;
7920 }
7921 }
7922 return true;
7923 }
7924 return false;
7925}
7926
7927/// canAssignObjCInterfaces - Return true if the two interface types are
7928/// compatible for assignment from RHS to LHS. This handles validation of any
7929/// protocol qualifiers on the LHS or RHS.
7930bool ASTContext::canAssignObjCInterfaces(const ObjCObjectPointerType *LHSOPT,
7931 const ObjCObjectPointerType *RHSOPT) {
7932 const ObjCObjectType* LHS = LHSOPT->getObjectType();
7933 const ObjCObjectType* RHS = RHSOPT->getObjectType();
7934
7935 // If either type represents the built-in 'id' or 'Class' types, return true.
7936 if (LHS->isObjCUnqualifiedIdOrClass() ||
7937 RHS->isObjCUnqualifiedIdOrClass())
7938 return true;
7939
7940 // Function object that propagates a successful result or handles
7941 // __kindof types.
7942 auto finish = [&](bool succeeded) -> bool {
7943 if (succeeded)
7944 return true;
7945
7946 if (!RHS->isKindOfType())
7947 return false;
7948
7949 // Strip off __kindof and protocol qualifiers, then check whether
7950 // we can assign the other way.
7951 return canAssignObjCInterfaces(RHSOPT->stripObjCKindOfTypeAndQuals(*this),
7952 LHSOPT->stripObjCKindOfTypeAndQuals(*this));
7953 };
7954
7955 if (LHS->isObjCQualifiedId() || RHS->isObjCQualifiedId()) {
7956 return finish(ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
7957 QualType(RHSOPT,0),
7958 false));
7959 }
7960
7961 if (LHS->isObjCQualifiedClass() && RHS->isObjCQualifiedClass()) {
7962 return finish(ObjCQualifiedClassTypesAreCompatible(QualType(LHSOPT,0),
7963 QualType(RHSOPT,0)));
7964 }
7965
7966 // If we have 2 user-defined types, fall into that path.
7967 if (LHS->getInterface() && RHS->getInterface()) {
7968 return finish(canAssignObjCInterfaces(LHS, RHS));
7969 }
7970
7971 return false;
7972}
7973
7974/// canAssignObjCInterfacesInBlockPointer - This routine is specifically written
7975/// for providing type-safety for objective-c pointers used to pass/return
7976/// arguments in block literals. When passed as arguments, passing 'A*' where
7977/// 'id' is expected is not OK. Passing 'Sub *" where 'Super *" is expected is
7978/// not OK. For the return type, the opposite is not OK.
7979bool ASTContext::canAssignObjCInterfacesInBlockPointer(
7980 const ObjCObjectPointerType *LHSOPT,
7981 const ObjCObjectPointerType *RHSOPT,
7982 bool BlockReturnType) {
7983
7984 // Function object that propagates a successful result or handles
7985 // __kindof types.
7986 auto finish = [&](bool succeeded) -> bool {
7987 if (succeeded)
7988 return true;
7989
7990 const ObjCObjectPointerType *Expected = BlockReturnType ? RHSOPT : LHSOPT;
7991 if (!Expected->isKindOfType())
7992 return false;
7993
7994 // Strip off __kindof and protocol qualifiers, then check whether
7995 // we can assign the other way.
7996 return canAssignObjCInterfacesInBlockPointer(
7997 RHSOPT->stripObjCKindOfTypeAndQuals(*this),
7998 LHSOPT->stripObjCKindOfTypeAndQuals(*this),
7999 BlockReturnType);
8000 };
8001
8002 if (RHSOPT->isObjCBuiltinType() || LHSOPT->isObjCIdType())
8003 return true;
8004
8005 if (LHSOPT->isObjCBuiltinType()) {
8006 return finish(RHSOPT->isObjCBuiltinType() ||
8007 RHSOPT->isObjCQualifiedIdType());
8008 }
8009
8010 if (LHSOPT->isObjCQualifiedIdType() || RHSOPT->isObjCQualifiedIdType())
8011 return finish(ObjCQualifiedIdTypesAreCompatible(QualType(LHSOPT,0),
8012 QualType(RHSOPT,0),
8013 false));
8014
8015 const ObjCInterfaceType* LHS = LHSOPT->getInterfaceType();
8016 const ObjCInterfaceType* RHS = RHSOPT->getInterfaceType();
8017 if (LHS && RHS) { // We have 2 user-defined types.
8018 if (LHS != RHS) {
8019 if (LHS->getDecl()->isSuperClassOf(RHS->getDecl()))
8020 return finish(BlockReturnType);
8021 if (RHS->getDecl()->isSuperClassOf(LHS->getDecl()))
8022 return finish(!BlockReturnType);
8023 }
8024 else
8025 return true;
8026 }
8027 return false;
8028}
8029
8030/// Comparison routine for Objective-C protocols to be used with
8031/// llvm::array_pod_sort.
8032static int compareObjCProtocolsByName(ObjCProtocolDecl * const *lhs,
8033 ObjCProtocolDecl * const *rhs) {
8034 return (*lhs)->getName().compare((*rhs)->getName());
8035}
8036
8037/// getIntersectionOfProtocols - This routine finds the intersection of set
8038/// of protocols inherited from two distinct objective-c pointer objects with
8039/// the given common base.
8040/// It is used to build composite qualifier list of the composite type of
8041/// the conditional expression involving two objective-c pointer objects.
8042static
8043void getIntersectionOfProtocols(ASTContext &Context,
8044 const ObjCInterfaceDecl *CommonBase,
8045 const ObjCObjectPointerType *LHSOPT,
8046 const ObjCObjectPointerType *RHSOPT,
8047 SmallVectorImpl<ObjCProtocolDecl *> &IntersectionSet) {
8048
8049 const ObjCObjectType* LHS = LHSOPT->getObjectType();
8050 const ObjCObjectType* RHS = RHSOPT->getObjectType();
8051 assert(LHS->getInterface() && "LHS must have an interface base")((LHS->getInterface() && "LHS must have an interface base"
) ? static_cast<void> (0) : __assert_fail ("LHS->getInterface() && \"LHS must have an interface base\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8051, __PRETTY_FUNCTION__))
;
8052 assert(RHS->getInterface() && "RHS must have an interface base")((RHS->getInterface() && "RHS must have an interface base"
) ? static_cast<void> (0) : __assert_fail ("RHS->getInterface() && \"RHS must have an interface base\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8052, __PRETTY_FUNCTION__))
;
8053
8054 // Add all of the protocols for the LHS.
8055 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> LHSProtocolSet;
8056
8057 // Start with the protocol qualifiers.
8058 for (auto proto : LHS->quals()) {
8059 Context.CollectInheritedProtocols(proto, LHSProtocolSet);
8060 }
8061
8062 // Also add the protocols associated with the LHS interface.
8063 Context.CollectInheritedProtocols(LHS->getInterface(), LHSProtocolSet);
8064
8065 // Add all of the protocls for the RHS.
8066 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> RHSProtocolSet;
8067
8068 // Start with the protocol qualifiers.
8069 for (auto proto : RHS->quals()) {
8070 Context.CollectInheritedProtocols(proto, RHSProtocolSet);
8071 }
8072
8073 // Also add the protocols associated with the RHS interface.
8074 Context.CollectInheritedProtocols(RHS->getInterface(), RHSProtocolSet);
8075
8076 // Compute the intersection of the collected protocol sets.
8077 for (auto proto : LHSProtocolSet) {
8078 if (RHSProtocolSet.count(proto))
8079 IntersectionSet.push_back(proto);
8080 }
8081
8082 // Compute the set of protocols that is implied by either the common type or
8083 // the protocols within the intersection.
8084 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> ImpliedProtocols;
8085 Context.CollectInheritedProtocols(CommonBase, ImpliedProtocols);
8086
8087 // Remove any implied protocols from the list of inherited protocols.
8088 if (!ImpliedProtocols.empty()) {
8089 IntersectionSet.erase(
8090 std::remove_if(IntersectionSet.begin(),
8091 IntersectionSet.end(),
8092 [&](ObjCProtocolDecl *proto) -> bool {
8093 return ImpliedProtocols.count(proto) > 0;
8094 }),
8095 IntersectionSet.end());
8096 }
8097
8098 // Sort the remaining protocols by name.
8099 llvm::array_pod_sort(IntersectionSet.begin(), IntersectionSet.end(),
8100 compareObjCProtocolsByName);
8101}
8102
8103/// Determine whether the first type is a subtype of the second.
8104static bool canAssignObjCObjectTypes(ASTContext &ctx, QualType lhs,
8105 QualType rhs) {
8106 // Common case: two object pointers.
8107 const auto *lhsOPT = lhs->getAs<ObjCObjectPointerType>();
8108 const auto *rhsOPT = rhs->getAs<ObjCObjectPointerType>();
8109 if (lhsOPT && rhsOPT)
8110 return ctx.canAssignObjCInterfaces(lhsOPT, rhsOPT);
8111
8112 // Two block pointers.
8113 const auto *lhsBlock = lhs->getAs<BlockPointerType>();
8114 const auto *rhsBlock = rhs->getAs<BlockPointerType>();
8115 if (lhsBlock && rhsBlock)
8116 return ctx.typesAreBlockPointerCompatible(lhs, rhs);
8117
8118 // If either is an unqualified 'id' and the other is a block, it's
8119 // acceptable.
8120 if ((lhsOPT && lhsOPT->isObjCIdType() && rhsBlock) ||
8121 (rhsOPT && rhsOPT->isObjCIdType() && lhsBlock))
8122 return true;
8123
8124 return false;
8125}
8126
8127// Check that the given Objective-C type argument lists are equivalent.
8128static bool sameObjCTypeArgs(ASTContext &ctx,
8129 const ObjCInterfaceDecl *iface,
8130 ArrayRef<QualType> lhsArgs,
8131 ArrayRef<QualType> rhsArgs,
8132 bool stripKindOf) {
8133 if (lhsArgs.size() != rhsArgs.size())
8134 return false;
8135
8136 ObjCTypeParamList *typeParams = iface->getTypeParamList();
8137 for (unsigned i = 0, n = lhsArgs.size(); i != n; ++i) {
8138 if (ctx.hasSameType(lhsArgs[i], rhsArgs[i]))
8139 continue;
8140
8141 switch (typeParams->begin()[i]->getVariance()) {
8142 case ObjCTypeParamVariance::Invariant:
8143 if (!stripKindOf ||
8144 !ctx.hasSameType(lhsArgs[i].stripObjCKindOfType(ctx),
8145 rhsArgs[i].stripObjCKindOfType(ctx))) {
8146 return false;
8147 }
8148 break;
8149
8150 case ObjCTypeParamVariance::Covariant:
8151 if (!canAssignObjCObjectTypes(ctx, lhsArgs[i], rhsArgs[i]))
8152 return false;
8153 break;
8154
8155 case ObjCTypeParamVariance::Contravariant:
8156 if (!canAssignObjCObjectTypes(ctx, rhsArgs[i], lhsArgs[i]))
8157 return false;
8158 break;
8159 }
8160 }
8161
8162 return true;
8163}
8164
8165QualType ASTContext::areCommonBaseCompatible(
8166 const ObjCObjectPointerType *Lptr,
8167 const ObjCObjectPointerType *Rptr) {
8168 const ObjCObjectType *LHS = Lptr->getObjectType();
8169 const ObjCObjectType *RHS = Rptr->getObjectType();
8170 const ObjCInterfaceDecl* LDecl = LHS->getInterface();
8171 const ObjCInterfaceDecl* RDecl = RHS->getInterface();
8172
8173 if (!LDecl || !RDecl)
8174 return {};
8175
8176 // When either LHS or RHS is a kindof type, we should return a kindof type.
8177 // For example, for common base of kindof(ASub1) and kindof(ASub2), we return
8178 // kindof(A).
8179 bool anyKindOf = LHS->isKindOfType() || RHS->isKindOfType();
8180
8181 // Follow the left-hand side up the class hierarchy until we either hit a
8182 // root or find the RHS. Record the ancestors in case we don't find it.
8183 llvm::SmallDenseMap<const ObjCInterfaceDecl *, const ObjCObjectType *, 4>
8184 LHSAncestors;
8185 while (true) {
8186 // Record this ancestor. We'll need this if the common type isn't in the
8187 // path from the LHS to the root.
8188 LHSAncestors[LHS->getInterface()->getCanonicalDecl()] = LHS;
8189
8190 if (declaresSameEntity(LHS->getInterface(), RDecl)) {
8191 // Get the type arguments.
8192 ArrayRef<QualType> LHSTypeArgs = LHS->getTypeArgsAsWritten();
8193 bool anyChanges = false;
8194 if (LHS->isSpecialized() && RHS->isSpecialized()) {
8195 // Both have type arguments, compare them.
8196 if (!sameObjCTypeArgs(*this, LHS->getInterface(),
8197 LHS->getTypeArgs(), RHS->getTypeArgs(),
8198 /*stripKindOf=*/true))
8199 return {};
8200 } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
8201 // If only one has type arguments, the result will not have type
8202 // arguments.
8203 LHSTypeArgs = {};
8204 anyChanges = true;
8205 }
8206
8207 // Compute the intersection of protocols.
8208 SmallVector<ObjCProtocolDecl *, 8> Protocols;
8209 getIntersectionOfProtocols(*this, LHS->getInterface(), Lptr, Rptr,
8210 Protocols);
8211 if (!Protocols.empty())
8212 anyChanges = true;
8213
8214 // If anything in the LHS will have changed, build a new result type.
8215 // If we need to return a kindof type but LHS is not a kindof type, we
8216 // build a new result type.
8217 if (anyChanges || LHS->isKindOfType() != anyKindOf) {
8218 QualType Result = getObjCInterfaceType(LHS->getInterface());
8219 Result = getObjCObjectType(Result, LHSTypeArgs, Protocols,
8220 anyKindOf || LHS->isKindOfType());
8221 return getObjCObjectPointerType(Result);
8222 }
8223
8224 return getObjCObjectPointerType(QualType(LHS, 0));
8225 }
8226
8227 // Find the superclass.
8228 QualType LHSSuperType = LHS->getSuperClassType();
8229 if (LHSSuperType.isNull())
8230 break;
8231
8232 LHS = LHSSuperType->castAs<ObjCObjectType>();
8233 }
8234
8235 // We didn't find anything by following the LHS to its root; now check
8236 // the RHS against the cached set of ancestors.
8237 while (true) {
8238 auto KnownLHS = LHSAncestors.find(RHS->getInterface()->getCanonicalDecl());
8239 if (KnownLHS != LHSAncestors.end()) {
8240 LHS = KnownLHS->second;
8241
8242 // Get the type arguments.
8243 ArrayRef<QualType> RHSTypeArgs = RHS->getTypeArgsAsWritten();
8244 bool anyChanges = false;
8245 if (LHS->isSpecialized() && RHS->isSpecialized()) {
8246 // Both have type arguments, compare them.
8247 if (!sameObjCTypeArgs(*this, LHS->getInterface(),
8248 LHS->getTypeArgs(), RHS->getTypeArgs(),
8249 /*stripKindOf=*/true))
8250 return {};
8251 } else if (LHS->isSpecialized() != RHS->isSpecialized()) {
8252 // If only one has type arguments, the result will not have type
8253 // arguments.
8254 RHSTypeArgs = {};
8255 anyChanges = true;
8256 }
8257
8258 // Compute the intersection of protocols.
8259 SmallVector<ObjCProtocolDecl *, 8> Protocols;
8260 getIntersectionOfProtocols(*this, RHS->getInterface(), Lptr, Rptr,
8261 Protocols);
8262 if (!Protocols.empty())
8263 anyChanges = true;
8264
8265 // If we need to return a kindof type but RHS is not a kindof type, we
8266 // build a new result type.
8267 if (anyChanges || RHS->isKindOfType() != anyKindOf) {
8268 QualType Result = getObjCInterfaceType(RHS->getInterface());
8269 Result = getObjCObjectType(Result, RHSTypeArgs, Protocols,
8270 anyKindOf || RHS->isKindOfType());
8271 return getObjCObjectPointerType(Result);
8272 }
8273
8274 return getObjCObjectPointerType(QualType(RHS, 0));
8275 }
8276
8277 // Find the superclass of the RHS.
8278 QualType RHSSuperType = RHS->getSuperClassType();
8279 if (RHSSuperType.isNull())
8280 break;
8281
8282 RHS = RHSSuperType->castAs<ObjCObjectType>();
8283 }
8284
8285 return {};
8286}
8287
8288bool ASTContext::canAssignObjCInterfaces(const ObjCObjectType *LHS,
8289 const ObjCObjectType *RHS) {
8290 assert(LHS->getInterface() && "LHS is not an interface type")((LHS->getInterface() && "LHS is not an interface type"
) ? static_cast<void> (0) : __assert_fail ("LHS->getInterface() && \"LHS is not an interface type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8290, __PRETTY_FUNCTION__))
;
8291 assert(RHS->getInterface() && "RHS is not an interface type")((RHS->getInterface() && "RHS is not an interface type"
) ? static_cast<void> (0) : __assert_fail ("RHS->getInterface() && \"RHS is not an interface type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8291, __PRETTY_FUNCTION__))
;
8292
8293 // Verify that the base decls are compatible: the RHS must be a subclass of
8294 // the LHS.
8295 ObjCInterfaceDecl *LHSInterface = LHS->getInterface();
8296 bool IsSuperClass = LHSInterface->isSuperClassOf(RHS->getInterface());
8297 if (!IsSuperClass)
8298 return false;
8299
8300 // If the LHS has protocol qualifiers, determine whether all of them are
8301 // satisfied by the RHS (i.e., the RHS has a superset of the protocols in the
8302 // LHS).
8303 if (LHS->getNumProtocols() > 0) {
8304 // OK if conversion of LHS to SuperClass results in narrowing of types
8305 // ; i.e., SuperClass may implement at least one of the protocols
8306 // in LHS's protocol list. Example, SuperObj<P1> = lhs<P1,P2> is ok.
8307 // But not SuperObj<P1,P2,P3> = lhs<P1,P2>.
8308 llvm::SmallPtrSet<ObjCProtocolDecl *, 8> SuperClassInheritedProtocols;
8309 CollectInheritedProtocols(RHS->getInterface(), SuperClassInheritedProtocols);
8310 // Also, if RHS has explicit quelifiers, include them for comparing with LHS's
8311 // qualifiers.
8312 for (auto *RHSPI : RHS->quals())
8313 CollectInheritedProtocols(RHSPI, SuperClassInheritedProtocols);
8314 // If there is no protocols associated with RHS, it is not a match.
8315 if (SuperClassInheritedProtocols.empty())
8316 return false;
8317
8318 for (const auto *LHSProto : LHS->quals()) {
8319 bool SuperImplementsProtocol = false;
8320 for (auto *SuperClassProto : SuperClassInheritedProtocols)
8321 if (SuperClassProto->lookupProtocolNamed(LHSProto->getIdentifier())) {
8322 SuperImplementsProtocol = true;
8323 break;
8324 }
8325 if (!SuperImplementsProtocol)
8326 return false;
8327 }
8328 }
8329
8330 // If the LHS is specialized, we may need to check type arguments.
8331 if (LHS->isSpecialized()) {
8332 // Follow the superclass chain until we've matched the LHS class in the
8333 // hierarchy. This substitutes type arguments through.
8334 const ObjCObjectType *RHSSuper = RHS;
8335 while (!declaresSameEntity(RHSSuper->getInterface(), LHSInterface))
8336 RHSSuper = RHSSuper->getSuperClassType()->castAs<ObjCObjectType>();
8337
8338 // If the RHS is specializd, compare type arguments.
8339 if (RHSSuper->isSpecialized() &&
8340 !sameObjCTypeArgs(*this, LHS->getInterface(),
8341 LHS->getTypeArgs(), RHSSuper->getTypeArgs(),
8342 /*stripKindOf=*/true)) {
8343 return false;
8344 }
8345 }
8346
8347 return true;
8348}
8349
8350bool ASTContext::areComparableObjCPointerTypes(QualType LHS, QualType RHS) {
8351 // get the "pointed to" types
8352 const auto *LHSOPT = LHS->getAs<ObjCObjectPointerType>();
8353 const auto *RHSOPT = RHS->getAs<ObjCObjectPointerType>();
8354
8355 if (!LHSOPT || !RHSOPT)
8356 return false;
8357
8358 return canAssignObjCInterfaces(LHSOPT, RHSOPT) ||
8359 canAssignObjCInterfaces(RHSOPT, LHSOPT);
8360}
8361
8362bool ASTContext::canBindObjCObjectType(QualType To, QualType From) {
8363 return canAssignObjCInterfaces(
8364 getObjCObjectPointerType(To)->getAs<ObjCObjectPointerType>(),
8365 getObjCObjectPointerType(From)->getAs<ObjCObjectPointerType>());
8366}
8367
8368/// typesAreCompatible - C99 6.7.3p9: For two qualified types to be compatible,
8369/// both shall have the identically qualified version of a compatible type.
8370/// C99 6.2.7p1: Two types have compatible types if their types are the
8371/// same. See 6.7.[2,3,5] for additional rules.
8372bool ASTContext::typesAreCompatible(QualType LHS, QualType RHS,
8373 bool CompareUnqualified) {
8374 if (getLangOpts().CPlusPlus)
8375 return hasSameType(LHS, RHS);
8376
8377 return !mergeTypes(LHS, RHS, false, CompareUnqualified).isNull();
8378}
8379
8380bool ASTContext::propertyTypesAreCompatible(QualType LHS, QualType RHS) {
8381 return typesAreCompatible(LHS, RHS);
8382}
8383
8384bool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) {
8385 return !mergeTypes(LHS, RHS, true).isNull();
8386}
8387
8388/// mergeTransparentUnionType - if T is a transparent union type and a member
8389/// of T is compatible with SubType, return the merged type, else return
8390/// QualType()
8391QualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType,
8392 bool OfBlockPointer,
8393 bool Unqualified) {
8394 if (const RecordType *UT = T->getAsUnionType()) {
8395 RecordDecl *UD = UT->getDecl();
8396 if (UD->hasAttr<TransparentUnionAttr>()) {
8397 for (const auto *I : UD->fields()) {
8398 QualType ET = I->getType().getUnqualifiedType();
8399 QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified);
8400 if (!MT.isNull())
8401 return MT;
8402 }
8403 }
8404 }
8405
8406 return {};
8407}
8408
8409/// mergeFunctionParameterTypes - merge two types which appear as function
8410/// parameter types
8411QualType ASTContext::mergeFunctionParameterTypes(QualType lhs, QualType rhs,
8412 bool OfBlockPointer,
8413 bool Unqualified) {
8414 // GNU extension: two types are compatible if they appear as a function
8415 // argument, one of the types is a transparent union type and the other
8416 // type is compatible with a union member
8417 QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer,
8418 Unqualified);
8419 if (!lmerge.isNull())
8420 return lmerge;
8421
8422 QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer,
8423 Unqualified);
8424 if (!rmerge.isNull())
8425 return rmerge;
8426
8427 return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified);
8428}
8429
8430QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs,
8431 bool OfBlockPointer,
8432 bool Unqualified) {
8433 const auto *lbase = lhs->getAs<FunctionType>();
8434 const auto *rbase = rhs->getAs<FunctionType>();
8435 const auto *lproto = dyn_cast<FunctionProtoType>(lbase);
8436 const auto *rproto = dyn_cast<FunctionProtoType>(rbase);
8437 bool allLTypes = true;
8438 bool allRTypes = true;
8439
8440 // Check return type
8441 QualType retType;
8442 if (OfBlockPointer) {
8443 QualType RHS = rbase->getReturnType();
8444 QualType LHS = lbase->getReturnType();
8445 bool UnqualifiedResult = Unqualified;
8446 if (!UnqualifiedResult)
8447 UnqualifiedResult = (!RHS.hasQualifiers() && LHS.hasQualifiers());
8448 retType = mergeTypes(LHS, RHS, true, UnqualifiedResult, true);
8449 }
8450 else
8451 retType = mergeTypes(lbase->getReturnType(), rbase->getReturnType(), false,
8452 Unqualified);
8453 if (retType.isNull())
8454 return {};
8455
8456 if (Unqualified)
8457 retType = retType.getUnqualifiedType();
8458
8459 CanQualType LRetType = getCanonicalType(lbase->getReturnType());
8460 CanQualType RRetType = getCanonicalType(rbase->getReturnType());
8461 if (Unqualified) {
8462 LRetType = LRetType.getUnqualifiedType();
8463 RRetType = RRetType.getUnqualifiedType();
8464 }
8465
8466 if (getCanonicalType(retType) != LRetType)
8467 allLTypes = false;
8468 if (getCanonicalType(retType) != RRetType)
8469 allRTypes = false;
8470
8471 // FIXME: double check this
8472 // FIXME: should we error if lbase->getRegParmAttr() != 0 &&
8473 // rbase->getRegParmAttr() != 0 &&
8474 // lbase->getRegParmAttr() != rbase->getRegParmAttr()?
8475 FunctionType::ExtInfo lbaseInfo = lbase->getExtInfo();
8476 FunctionType::ExtInfo rbaseInfo = rbase->getExtInfo();
8477
8478 // Compatible functions must have compatible calling conventions
8479 if (lbaseInfo.getCC() != rbaseInfo.getCC())
8480 return {};
8481
8482 // Regparm is part of the calling convention.
8483 if (lbaseInfo.getHasRegParm() != rbaseInfo.getHasRegParm())
8484 return {};
8485 if (lbaseInfo.getRegParm() != rbaseInfo.getRegParm())
8486 return {};
8487
8488 if (lbaseInfo.getProducesResult() != rbaseInfo.getProducesResult())
8489 return {};
8490 if (lbaseInfo.getNoCallerSavedRegs() != rbaseInfo.getNoCallerSavedRegs())
8491 return {};
8492 if (lbaseInfo.getNoCfCheck() != rbaseInfo.getNoCfCheck())
8493 return {};
8494
8495 // FIXME: some uses, e.g. conditional exprs, really want this to be 'both'.
8496 bool NoReturn = lbaseInfo.getNoReturn() || rbaseInfo.getNoReturn();
8497
8498 if (lbaseInfo.getNoReturn() != NoReturn)
8499 allLTypes = false;
8500 if (rbaseInfo.getNoReturn() != NoReturn)
8501 allRTypes = false;
8502
8503 FunctionType::ExtInfo einfo = lbaseInfo.withNoReturn(NoReturn);
8504
8505 if (lproto && rproto) { // two C99 style function prototypes
8506 assert(!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() &&((!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec
() && "C++ shouldn't be here") ? static_cast<void>
(0) : __assert_fail ("!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && \"C++ shouldn't be here\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8507, __PRETTY_FUNCTION__))
8507 "C++ shouldn't be here")((!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec
() && "C++ shouldn't be here") ? static_cast<void>
(0) : __assert_fail ("!lproto->hasExceptionSpec() && !rproto->hasExceptionSpec() && \"C++ shouldn't be here\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8507, __PRETTY_FUNCTION__))
;
8508 // Compatible functions must have the same number of parameters
8509 if (lproto->getNumParams() != rproto->getNumParams())
8510 return {};
8511
8512 // Variadic and non-variadic functions aren't compatible
8513 if (lproto->isVariadic() != rproto->isVariadic())
8514 return {};
8515
8516 if (lproto->getTypeQuals() != rproto->getTypeQuals())
8517 return {};
8518
8519 SmallVector<FunctionProtoType::ExtParameterInfo, 4> newParamInfos;
8520 bool canUseLeft, canUseRight;
8521 if (!mergeExtParameterInfo(lproto, rproto, canUseLeft, canUseRight,
8522 newParamInfos))
8523 return {};
8524
8525 if (!canUseLeft)
8526 allLTypes = false;
8527 if (!canUseRight)
8528 allRTypes = false;
8529
8530 // Check parameter type compatibility
8531 SmallVector<QualType, 10> types;
8532 for (unsigned i = 0, n = lproto->getNumParams(); i < n; i++) {
8533 QualType lParamType = lproto->getParamType(i).getUnqualifiedType();
8534 QualType rParamType = rproto->getParamType(i).getUnqualifiedType();
8535 QualType paramType = mergeFunctionParameterTypes(
8536 lParamType, rParamType, OfBlockPointer, Unqualified);
8537 if (paramType.isNull())
8538 return {};
8539
8540 if (Unqualified)
8541 paramType = paramType.getUnqualifiedType();
8542
8543 types.push_back(paramType);
8544 if (Unqualified) {
8545 lParamType = lParamType.getUnqualifiedType();
8546 rParamType = rParamType.getUnqualifiedType();
8547 }
8548
8549 if (getCanonicalType(paramType) != getCanonicalType(lParamType))
8550 allLTypes = false;
8551 if (getCanonicalType(paramType) != getCanonicalType(rParamType))
8552 allRTypes = false;
8553 }
8554
8555 if (allLTypes) return lhs;
8556 if (allRTypes) return rhs;
8557
8558 FunctionProtoType::ExtProtoInfo EPI = lproto->getExtProtoInfo();
8559 EPI.ExtInfo = einfo;
8560 EPI.ExtParameterInfos =
8561 newParamInfos.empty() ? nullptr : newParamInfos.data();
8562 return getFunctionType(retType, types, EPI);
8563 }
8564
8565 if (lproto) allRTypes = false;
8566 if (rproto) allLTypes = false;
8567
8568 const FunctionProtoType *proto = lproto ? lproto : rproto;
8569 if (proto) {
8570 assert(!proto->hasExceptionSpec() && "C++ shouldn't be here")((!proto->hasExceptionSpec() && "C++ shouldn't be here"
) ? static_cast<void> (0) : __assert_fail ("!proto->hasExceptionSpec() && \"C++ shouldn't be here\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8570, __PRETTY_FUNCTION__))
;
8571 if (proto->isVariadic())
8572 return {};
8573 // Check that the types are compatible with the types that
8574 // would result from default argument promotions (C99 6.7.5.3p15).
8575 // The only types actually affected are promotable integer
8576 // types and floats, which would be passed as a different
8577 // type depending on whether the prototype is visible.
8578 for (unsigned i = 0, n = proto->getNumParams(); i < n; ++i) {
8579 QualType paramTy = proto->getParamType(i);
8580
8581 // Look at the converted type of enum types, since that is the type used
8582 // to pass enum values.
8583 if (const auto *Enum = paramTy->getAs<EnumType>()) {
8584 paramTy = Enum->getDecl()->getIntegerType();
8585 if (paramTy.isNull())
8586 return {};
8587 }
8588
8589 if (paramTy->isPromotableIntegerType() ||
8590 getCanonicalType(paramTy).getUnqualifiedType() == FloatTy)
8591 return {};
8592 }
8593
8594 if (allLTypes) return lhs;
8595 if (allRTypes) return rhs;
8596
8597 FunctionProtoType::ExtProtoInfo EPI = proto->getExtProtoInfo();
8598 EPI.ExtInfo = einfo;
8599 return getFunctionType(retType, proto->getParamTypes(), EPI);
8600 }
8601
8602 if (allLTypes) return lhs;
8603 if (allRTypes) return rhs;
8604 return getFunctionNoProtoType(retType, einfo);
8605}
8606
8607/// Given that we have an enum type and a non-enum type, try to merge them.
8608static QualType mergeEnumWithInteger(ASTContext &Context, const EnumType *ET,
8609 QualType other, bool isBlockReturnType) {
8610 // C99 6.7.2.2p4: Each enumerated type shall be compatible with char,
8611 // a signed integer type, or an unsigned integer type.
8612 // Compatibility is based on the underlying type, not the promotion
8613 // type.
8614 QualType underlyingType = ET->getDecl()->getIntegerType();
8615 if (underlyingType.isNull())
8616 return {};
8617 if (Context.hasSameType(underlyingType, other))
8618 return other;
8619
8620 // In block return types, we're more permissive and accept any
8621 // integral type of the same size.
8622 if (isBlockReturnType && other->isIntegerType() &&
8623 Context.getTypeSize(underlyingType) == Context.getTypeSize(other))
8624 return other;
8625
8626 return {};
8627}
8628
8629QualType ASTContext::mergeTypes(QualType LHS, QualType RHS,
8630 bool OfBlockPointer,
8631 bool Unqualified, bool BlockReturnType) {
8632 // C++ [expr]: If an expression initially has the type "reference to T", the
8633 // type is adjusted to "T" prior to any further analysis, the expression
8634 // designates the object or function denoted by the reference, and the
8635 // expression is an lvalue unless the reference is an rvalue reference and
8636 // the expression is a function call (possibly inside parentheses).
8637 assert(!LHS->getAs<ReferenceType>() && "LHS is a reference type?")((!LHS->getAs<ReferenceType>() && "LHS is a reference type?"
) ? static_cast<void> (0) : __assert_fail ("!LHS->getAs<ReferenceType>() && \"LHS is a reference type?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8637, __PRETTY_FUNCTION__))
;
8638 assert(!RHS->getAs<ReferenceType>() && "RHS is a reference type?")((!RHS->getAs<ReferenceType>() && "RHS is a reference type?"
) ? static_cast<void> (0) : __assert_fail ("!RHS->getAs<ReferenceType>() && \"RHS is a reference type?\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8638, __PRETTY_FUNCTION__))
;
8639
8640 if (Unqualified) {
8641 LHS = LHS.getUnqualifiedType();
8642 RHS = RHS.getUnqualifiedType();
8643 }
8644
8645 QualType LHSCan = getCanonicalType(LHS),
8646 RHSCan = getCanonicalType(RHS);
8647
8648 // If two types are identical, they are compatible.
8649 if (LHSCan == RHSCan)
8650 return LHS;
8651
8652 // If the qualifiers are different, the types aren't compatible... mostly.
8653 Qualifiers LQuals = LHSCan.getLocalQualifiers();
8654 Qualifiers RQuals = RHSCan.getLocalQualifiers();
8655 if (LQuals != RQuals) {
8656 // If any of these qualifiers are different, we have a type
8657 // mismatch.
8658 if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
8659 LQuals.getAddressSpace() != RQuals.getAddressSpace() ||
8660 LQuals.getObjCLifetime() != RQuals.getObjCLifetime() ||
8661 LQuals.hasUnaligned() != RQuals.hasUnaligned())
8662 return {};
8663
8664 // Exactly one GC qualifier difference is allowed: __strong is
8665 // okay if the other type has no GC qualifier but is an Objective
8666 // C object pointer (i.e. implicitly strong by default). We fix
8667 // this by pretending that the unqualified type was actually
8668 // qualified __strong.
8669 Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
8670 Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
8671 assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements")(((GC_L != GC_R) && "unequal qualifier sets had only equal elements"
) ? static_cast<void> (0) : __assert_fail ("(GC_L != GC_R) && \"unequal qualifier sets had only equal elements\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8671, __PRETTY_FUNCTION__))
;
8672
8673 if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
8674 return {};
8675
8676 if (GC_L == Qualifiers::Strong && RHSCan->isObjCObjectPointerType()) {
8677 return mergeTypes(LHS, getObjCGCQualType(RHS, Qualifiers::Strong));
8678 }
8679 if (GC_R == Qualifiers::Strong && LHSCan->isObjCObjectPointerType()) {
8680 return mergeTypes(getObjCGCQualType(LHS, Qualifiers::Strong), RHS);
8681 }
8682 return {};
8683 }
8684
8685 // Okay, qualifiers are equal.
8686
8687 Type::TypeClass LHSClass = LHSCan->getTypeClass();
8688 Type::TypeClass RHSClass = RHSCan->getTypeClass();
8689
8690 // We want to consider the two function types to be the same for these
8691 // comparisons, just force one to the other.
8692 if (LHSClass == Type::FunctionProto) LHSClass = Type::FunctionNoProto;
8693 if (RHSClass == Type::FunctionProto) RHSClass = Type::FunctionNoProto;
8694
8695 // Same as above for arrays
8696 if (LHSClass == Type::VariableArray || LHSClass == Type::IncompleteArray)
8697 LHSClass = Type::ConstantArray;
8698 if (RHSClass == Type::VariableArray || RHSClass == Type::IncompleteArray)
8699 RHSClass = Type::ConstantArray;
8700
8701 // ObjCInterfaces are just specialized ObjCObjects.
8702 if (LHSClass == Type::ObjCInterface) LHSClass = Type::ObjCObject;
8703 if (RHSClass == Type::ObjCInterface) RHSClass = Type::ObjCObject;
8704
8705 // Canonicalize ExtVector -> Vector.
8706 if (LHSClass == Type::ExtVector) LHSClass = Type::Vector;
8707 if (RHSClass == Type::ExtVector) RHSClass = Type::Vector;
8708
8709 // If the canonical type classes don't match.
8710 if (LHSClass != RHSClass) {
8711 // Note that we only have special rules for turning block enum
8712 // returns into block int returns, not vice-versa.
8713 if (const auto *ETy = LHS->getAs<EnumType>()) {
8714 return mergeEnumWithInteger(*this, ETy, RHS, false);
8715 }
8716 if (const EnumType* ETy = RHS->getAs<EnumType>()) {
8717 return mergeEnumWithInteger(*this, ETy, LHS, BlockReturnType);
8718 }
8719 // allow block pointer type to match an 'id' type.
8720 if (OfBlockPointer && !BlockReturnType) {
8721 if (LHS->isObjCIdType() && RHS->isBlockPointerType())
8722 return LHS;
8723 if (RHS->isObjCIdType() && LHS->isBlockPointerType())
8724 return RHS;
8725 }
8726
8727 return {};
8728 }
8729
8730 // The canonical type classes match.
8731 switch (LHSClass) {
8732#define TYPE(Class, Base)
8733#define ABSTRACT_TYPE(Class, Base)
8734#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) case Type::Class:
8735#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
8736#define DEPENDENT_TYPE(Class, Base) case Type::Class:
8737#include "clang/AST/TypeNodes.def"
8738 llvm_unreachable("Non-canonical and dependent types shouldn't get here")::llvm::llvm_unreachable_internal("Non-canonical and dependent types shouldn't get here"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8738)
;
8739
8740 case Type::Auto:
8741 case Type::DeducedTemplateSpecialization:
8742 case Type::LValueReference:
8743 case Type::RValueReference:
8744 case Type::MemberPointer:
8745 llvm_unreachable("C++ should never be in mergeTypes")::llvm::llvm_unreachable_internal("C++ should never be in mergeTypes"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8745)
;
8746
8747 case Type::ObjCInterface:
8748 case Type::IncompleteArray:
8749 case Type::VariableArray:
8750 case Type::FunctionProto:
8751 case Type::ExtVector:
8752 llvm_unreachable("Types are eliminated above")::llvm::llvm_unreachable_internal("Types are eliminated above"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8752)
;
8753
8754 case Type::Pointer:
8755 {
8756 // Merge two pointer types, while trying to preserve typedef info
8757 QualType LHSPointee = LHS->getAs<PointerType>()->getPointeeType();
8758 QualType RHSPointee = RHS->getAs<PointerType>()->getPointeeType();
8759 if (Unqualified) {
8760 LHSPointee = LHSPointee.getUnqualifiedType();
8761 RHSPointee = RHSPointee.getUnqualifiedType();
8762 }
8763 QualType ResultType = mergeTypes(LHSPointee, RHSPointee, false,
8764 Unqualified);
8765 if (ResultType.isNull())
8766 return {};
8767 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
8768 return LHS;
8769 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
8770 return RHS;
8771 return getPointerType(ResultType);
8772 }
8773 case Type::BlockPointer:
8774 {
8775 // Merge two block pointer types, while trying to preserve typedef info
8776 QualType LHSPointee = LHS->getAs<BlockPointerType>()->getPointeeType();
8777 QualType RHSPointee = RHS->getAs<BlockPointerType>()->getPointeeType();
8778 if (Unqualified) {
8779 LHSPointee = LHSPointee.getUnqualifiedType();
8780 RHSPointee = RHSPointee.getUnqualifiedType();
8781 }
8782 if (getLangOpts().OpenCL) {
8783 Qualifiers LHSPteeQual = LHSPointee.getQualifiers();
8784 Qualifiers RHSPteeQual = RHSPointee.getQualifiers();
8785 // Blocks can't be an expression in a ternary operator (OpenCL v2.0
8786 // 6.12.5) thus the following check is asymmetric.
8787 if (!LHSPteeQual.isAddressSpaceSupersetOf(RHSPteeQual))
8788 return {};
8789 LHSPteeQual.removeAddressSpace();
8790 RHSPteeQual.removeAddressSpace();
8791 LHSPointee =
8792 QualType(LHSPointee.getTypePtr(), LHSPteeQual.getAsOpaqueValue());
8793 RHSPointee =
8794 QualType(RHSPointee.getTypePtr(), RHSPteeQual.getAsOpaqueValue());
8795 }
8796 QualType ResultType = mergeTypes(LHSPointee, RHSPointee, OfBlockPointer,
8797 Unqualified);
8798 if (ResultType.isNull())
8799 return {};
8800 if (getCanonicalType(LHSPointee) == getCanonicalType(ResultType))
8801 return LHS;
8802 if (getCanonicalType(RHSPointee) == getCanonicalType(ResultType))
8803 return RHS;
8804 return getBlockPointerType(ResultType);
8805 }
8806 case Type::Atomic:
8807 {
8808 // Merge two pointer types, while trying to preserve typedef info
8809 QualType LHSValue = LHS->getAs<AtomicType>()->getValueType();
8810 QualType RHSValue = RHS->getAs<AtomicType>()->getValueType();
8811 if (Unqualified) {
8812 LHSValue = LHSValue.getUnqualifiedType();
8813 RHSValue = RHSValue.getUnqualifiedType();
8814 }
8815 QualType ResultType = mergeTypes(LHSValue, RHSValue, false,
8816 Unqualified);
8817 if (ResultType.isNull())
8818 return {};
8819 if (getCanonicalType(LHSValue) == getCanonicalType(ResultType))
8820 return LHS;
8821 if (getCanonicalType(RHSValue) == getCanonicalType(ResultType))
8822 return RHS;
8823 return getAtomicType(ResultType);
8824 }
8825 case Type::ConstantArray:
8826 {
8827 const ConstantArrayType* LCAT = getAsConstantArrayType(LHS);
8828 const ConstantArrayType* RCAT = getAsConstantArrayType(RHS);
8829 if (LCAT && RCAT && RCAT->getSize() != LCAT->getSize())
8830 return {};
8831
8832 QualType LHSElem = getAsArrayType(LHS)->getElementType();
8833 QualType RHSElem = getAsArrayType(RHS)->getElementType();
8834 if (Unqualified) {
8835 LHSElem = LHSElem.getUnqualifiedType();
8836 RHSElem = RHSElem.getUnqualifiedType();
8837 }
8838
8839 QualType ResultType = mergeTypes(LHSElem, RHSElem, false, Unqualified);
8840 if (ResultType.isNull())
8841 return {};
8842
8843 const VariableArrayType* LVAT = getAsVariableArrayType(LHS);
8844 const VariableArrayType* RVAT = getAsVariableArrayType(RHS);
8845
8846 // If either side is a variable array, and both are complete, check whether
8847 // the current dimension is definite.
8848 if (LVAT || RVAT) {
8849 auto SizeFetch = [this](const VariableArrayType* VAT,
8850 const ConstantArrayType* CAT)
8851 -> std::pair<bool,llvm::APInt> {
8852 if (VAT) {
8853 llvm::APSInt TheInt;
8854 Expr *E = VAT->getSizeExpr();
8855 if (E && E->isIntegerConstantExpr(TheInt, *this))
8856 return std::make_pair(true, TheInt);
8857 else
8858 return std::make_pair(false, TheInt);
8859 } else if (CAT) {
8860 return std::make_pair(true, CAT->getSize());
8861 } else {
8862 return std::make_pair(false, llvm::APInt());
8863 }
8864 };
8865
8866 bool HaveLSize, HaveRSize;
8867 llvm::APInt LSize, RSize;
8868 std::tie(HaveLSize, LSize) = SizeFetch(LVAT, LCAT);
8869 std::tie(HaveRSize, RSize) = SizeFetch(RVAT, RCAT);
8870 if (HaveLSize && HaveRSize && !llvm::APInt::isSameValue(LSize, RSize))
8871 return {}; // Definite, but unequal, array dimension
8872 }
8873
8874 if (LCAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
8875 return LHS;
8876 if (RCAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
8877 return RHS;
8878 if (LCAT) return getConstantArrayType(ResultType, LCAT->getSize(),
8879 ArrayType::ArraySizeModifier(), 0);
8880 if (RCAT) return getConstantArrayType(ResultType, RCAT->getSize(),
8881 ArrayType::ArraySizeModifier(), 0);
8882 if (LVAT && getCanonicalType(LHSElem) == getCanonicalType(ResultType))
8883 return LHS;
8884 if (RVAT && getCanonicalType(RHSElem) == getCanonicalType(ResultType))
8885 return RHS;
8886 if (LVAT) {
8887 // FIXME: This isn't correct! But tricky to implement because
8888 // the array's size has to be the size of LHS, but the type
8889 // has to be different.
8890 return LHS;
8891 }
8892 if (RVAT) {
8893 // FIXME: This isn't correct! But tricky to implement because
8894 // the array's size has to be the size of RHS, but the type
8895 // has to be different.
8896 return RHS;
8897 }
8898 if (getCanonicalType(LHSElem) == getCanonicalType(ResultType)) return LHS;
8899 if (getCanonicalType(RHSElem) == getCanonicalType(ResultType)) return RHS;
8900 return getIncompleteArrayType(ResultType,
8901 ArrayType::ArraySizeModifier(), 0);
8902 }
8903 case Type::FunctionNoProto:
8904 return mergeFunctionTypes(LHS, RHS, OfBlockPointer, Unqualified);
8905 case Type::Record:
8906 case Type::Enum:
8907 return {};
8908 case Type::Builtin:
8909 // Only exactly equal builtin types are compatible, which is tested above.
8910 return {};
8911 case Type::Complex:
8912 // Distinct complex types are incompatible.
8913 return {};
8914 case Type::Vector:
8915 // FIXME: The merged type should be an ExtVector!
8916 if (areCompatVectorTypes(LHSCan->getAs<VectorType>(),
8917 RHSCan->getAs<VectorType>()))
8918 return LHS;
8919 return {};
8920 case Type::ObjCObject: {
8921 // Check if the types are assignment compatible.
8922 // FIXME: This should be type compatibility, e.g. whether
8923 // "LHS x; RHS x;" at global scope is legal.
8924 const auto *LHSIface = LHS->getAs<ObjCObjectType>();
8925 const auto *RHSIface = RHS->getAs<ObjCObjectType>();
8926 if (canAssignObjCInterfaces(LHSIface, RHSIface))
8927 return LHS;
8928
8929 return {};
8930 }
8931 case Type::ObjCObjectPointer:
8932 if (OfBlockPointer) {
8933 if (canAssignObjCInterfacesInBlockPointer(
8934 LHS->getAs<ObjCObjectPointerType>(),
8935 RHS->getAs<ObjCObjectPointerType>(),
8936 BlockReturnType))
8937 return LHS;
8938 return {};
8939 }
8940 if (canAssignObjCInterfaces(LHS->getAs<ObjCObjectPointerType>(),
8941 RHS->getAs<ObjCObjectPointerType>()))
8942 return LHS;
8943
8944 return {};
8945 case Type::Pipe:
8946 assert(LHS != RHS &&((LHS != RHS && "Equivalent pipe types should have already been handled!"
) ? static_cast<void> (0) : __assert_fail ("LHS != RHS && \"Equivalent pipe types should have already been handled!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8947, __PRETTY_FUNCTION__))
8947 "Equivalent pipe types should have already been handled!")((LHS != RHS && "Equivalent pipe types should have already been handled!"
) ? static_cast<void> (0) : __assert_fail ("LHS != RHS && \"Equivalent pipe types should have already been handled!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8947, __PRETTY_FUNCTION__))
;
8948 return {};
8949 }
8950
8951 llvm_unreachable("Invalid Type::Class!")::llvm::llvm_unreachable_internal("Invalid Type::Class!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8951)
;
8952}
8953
8954bool ASTContext::mergeExtParameterInfo(
8955 const FunctionProtoType *FirstFnType, const FunctionProtoType *SecondFnType,
8956 bool &CanUseFirst, bool &CanUseSecond,
8957 SmallVectorImpl<FunctionProtoType::ExtParameterInfo> &NewParamInfos) {
8958 assert(NewParamInfos.empty() && "param info list not empty")((NewParamInfos.empty() && "param info list not empty"
) ? static_cast<void> (0) : __assert_fail ("NewParamInfos.empty() && \"param info list not empty\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 8958, __PRETTY_FUNCTION__))
;
8959 CanUseFirst = CanUseSecond = true;
8960 bool FirstHasInfo = FirstFnType->hasExtParameterInfos();
8961 bool SecondHasInfo = SecondFnType->hasExtParameterInfos();
8962
8963 // Fast path: if the first type doesn't have ext parameter infos,
8964 // we match if and only if the second type also doesn't have them.
8965 if (!FirstHasInfo && !SecondHasInfo)
8966 return true;
8967
8968 bool NeedParamInfo = false;
8969 size_t E = FirstHasInfo ? FirstFnType->getExtParameterInfos().size()
8970 : SecondFnType->getExtParameterInfos().size();
8971
8972 for (size_t I = 0; I < E; ++I) {
8973 FunctionProtoType::ExtParameterInfo FirstParam, SecondParam;
8974 if (FirstHasInfo)
8975 FirstParam = FirstFnType->getExtParameterInfo(I);
8976 if (SecondHasInfo)
8977 SecondParam = SecondFnType->getExtParameterInfo(I);
8978
8979 // Cannot merge unless everything except the noescape flag matches.
8980 if (FirstParam.withIsNoEscape(false) != SecondParam.withIsNoEscape(false))
8981 return false;
8982
8983 bool FirstNoEscape = FirstParam.isNoEscape();
8984 bool SecondNoEscape = SecondParam.isNoEscape();
8985 bool IsNoEscape = FirstNoEscape && SecondNoEscape;
8986 NewParamInfos.push_back(FirstParam.withIsNoEscape(IsNoEscape));
8987 if (NewParamInfos.back().getOpaqueValue())
8988 NeedParamInfo = true;
8989 if (FirstNoEscape != IsNoEscape)
8990 CanUseFirst = false;
8991 if (SecondNoEscape != IsNoEscape)
8992 CanUseSecond = false;
8993 }
8994
8995 if (!NeedParamInfo)
8996 NewParamInfos.clear();
8997
8998 return true;
8999}
9000
9001void ASTContext::ResetObjCLayout(const ObjCContainerDecl *CD) {
9002 ObjCLayouts[CD] = nullptr;
9003}
9004
9005/// mergeObjCGCQualifiers - This routine merges ObjC's GC attribute of 'LHS' and
9006/// 'RHS' attributes and returns the merged version; including for function
9007/// return types.
9008QualType ASTContext::mergeObjCGCQualifiers(QualType LHS, QualType RHS) {
9009 QualType LHSCan = getCanonicalType(LHS),
9010 RHSCan = getCanonicalType(RHS);
9011 // If two types are identical, they are compatible.
9012 if (LHSCan == RHSCan)
9013 return LHS;
9014 if (RHSCan->isFunctionType()) {
9015 if (!LHSCan->isFunctionType())
9016 return {};
9017 QualType OldReturnType =
9018 cast<FunctionType>(RHSCan.getTypePtr())->getReturnType();
9019 QualType NewReturnType =
9020 cast<FunctionType>(LHSCan.getTypePtr())->getReturnType();
9021 QualType ResReturnType =
9022 mergeObjCGCQualifiers(NewReturnType, OldReturnType);
9023 if (ResReturnType.isNull())
9024 return {};
9025 if (ResReturnType == NewReturnType || ResReturnType == OldReturnType) {
9026 // id foo(); ... __strong id foo(); or: __strong id foo(); ... id foo();
9027 // In either case, use OldReturnType to build the new function type.
9028 const auto *F = LHS->getAs<FunctionType>();
9029 if (const auto *FPT = cast<FunctionProtoType>(F)) {
9030 FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
9031 EPI.ExtInfo = getFunctionExtInfo(LHS);
9032 QualType ResultType =
9033 getFunctionType(OldReturnType, FPT->getParamTypes(), EPI);
9034 return ResultType;
9035 }
9036 }
9037 return {};
9038 }
9039
9040 // If the qualifiers are different, the types can still be merged.
9041 Qualifiers LQuals = LHSCan.getLocalQualifiers();
9042 Qualifiers RQuals = RHSCan.getLocalQualifiers();
9043 if (LQuals != RQuals) {
9044 // If any of these qualifiers are different, we have a type mismatch.
9045 if (LQuals.getCVRQualifiers() != RQuals.getCVRQualifiers() ||
9046 LQuals.getAddressSpace() != RQuals.getAddressSpace())
9047 return {};
9048
9049 // Exactly one GC qualifier difference is allowed: __strong is
9050 // okay if the other type has no GC qualifier but is an Objective
9051 // C object pointer (i.e. implicitly strong by default). We fix
9052 // this by pretending that the unqualified type was actually
9053 // qualified __strong.
9054 Qualifiers::GC GC_L = LQuals.getObjCGCAttr();
9055 Qualifiers::GC GC_R = RQuals.getObjCGCAttr();
9056 assert((GC_L != GC_R) && "unequal qualifier sets had only equal elements")(((GC_L != GC_R) && "unequal qualifier sets had only equal elements"
) ? static_cast<void> (0) : __assert_fail ("(GC_L != GC_R) && \"unequal qualifier sets had only equal elements\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9056, __PRETTY_FUNCTION__))
;
9057
9058 if (GC_L == Qualifiers::Weak || GC_R == Qualifiers::Weak)
9059 return {};
9060
9061 if (GC_L == Qualifiers::Strong)
9062 return LHS;
9063 if (GC_R == Qualifiers::Strong)
9064 return RHS;
9065 return {};
9066 }
9067
9068 if (LHSCan->isObjCObjectPointerType() && RHSCan->isObjCObjectPointerType()) {
9069 QualType LHSBaseQT = LHS->getAs<ObjCObjectPointerType>()->getPointeeType();
9070 QualType RHSBaseQT = RHS->getAs<ObjCObjectPointerType>()->getPointeeType();
9071 QualType ResQT = mergeObjCGCQualifiers(LHSBaseQT, RHSBaseQT);
9072 if (ResQT == LHSBaseQT)
9073 return LHS;
9074 if (ResQT == RHSBaseQT)
9075 return RHS;
9076 }
9077 return {};
9078}
9079
9080//===----------------------------------------------------------------------===//
9081// Integer Predicates
9082//===----------------------------------------------------------------------===//
9083
9084unsigned ASTContext::getIntWidth(QualType T) const {
9085 if (const auto *ET = T->getAs<EnumType>())
9086 T = ET->getDecl()->getIntegerType();
9087 if (T->isBooleanType())
9088 return 1;
9089 // For builtin types, just use the standard type sizing method
9090 return (unsigned)getTypeSize(T);
9091}
9092
9093QualType ASTContext::getCorrespondingUnsignedType(QualType T) const {
9094 assert((T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType()) &&(((T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType
()) && "Unexpected type") ? static_cast<void> (
0) : __assert_fail ("(T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType()) && \"Unexpected type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9095, __PRETTY_FUNCTION__))
9095 "Unexpected type")(((T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType
()) && "Unexpected type") ? static_cast<void> (
0) : __assert_fail ("(T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType()) && \"Unexpected type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9095, __PRETTY_FUNCTION__))
;
9096
9097 // Turn <4 x signed int> -> <4 x unsigned int>
9098 if (const auto *VTy = T->getAs<VectorType>())
9099 return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()),
9100 VTy->getNumElements(), VTy->getVectorKind());
9101
9102 // For enums, we return the unsigned version of the base type.
9103 if (const auto *ETy = T->getAs<EnumType>())
9104 T = ETy->getDecl()->getIntegerType();
9105
9106 const auto *BTy = T->getAs<BuiltinType>();
9107 assert(BTy && "Unexpected signed integer or fixed point type")((BTy && "Unexpected signed integer or fixed point type"
) ? static_cast<void> (0) : __assert_fail ("BTy && \"Unexpected signed integer or fixed point type\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9107, __PRETTY_FUNCTION__))
;
9108 switch (BTy->getKind()) {
9109 case BuiltinType::Char_S:
9110 case BuiltinType::SChar:
9111 return UnsignedCharTy;
9112 case BuiltinType::Short:
9113 return UnsignedShortTy;
9114 case BuiltinType::Int:
9115 return UnsignedIntTy;
9116 case BuiltinType::Long:
9117 return UnsignedLongTy;
9118 case BuiltinType::LongLong:
9119 return UnsignedLongLongTy;
9120 case BuiltinType::Int128:
9121 return UnsignedInt128Ty;
9122
9123 case BuiltinType::ShortAccum:
9124 return UnsignedShortAccumTy;
9125 case BuiltinType::Accum:
9126 return UnsignedAccumTy;
9127 case BuiltinType::LongAccum:
9128 return UnsignedLongAccumTy;
9129 case BuiltinType::SatShortAccum:
9130 return SatUnsignedShortAccumTy;
9131 case BuiltinType::SatAccum:
9132 return SatUnsignedAccumTy;
9133 case BuiltinType::SatLongAccum:
9134 return SatUnsignedLongAccumTy;
9135 case BuiltinType::ShortFract:
9136 return UnsignedShortFractTy;
9137 case BuiltinType::Fract:
9138 return UnsignedFractTy;
9139 case BuiltinType::LongFract:
9140 return UnsignedLongFractTy;
9141 case BuiltinType::SatShortFract:
9142 return SatUnsignedShortFractTy;
9143 case BuiltinType::SatFract:
9144 return SatUnsignedFractTy;
9145 case BuiltinType::SatLongFract:
9146 return SatUnsignedLongFractTy;
9147 default:
9148 llvm_unreachable("Unexpected signed integer or fixed point type")::llvm::llvm_unreachable_internal("Unexpected signed integer or fixed point type"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9148)
;
9149 }
9150}
9151
9152ASTMutationListener::~ASTMutationListener() = default;
9153
9154void ASTMutationListener::DeducedReturnType(const FunctionDecl *FD,
9155 QualType ReturnType) {}
9156
9157//===----------------------------------------------------------------------===//
9158// Builtin Type Computation
9159//===----------------------------------------------------------------------===//
9160
9161/// DecodeTypeFromStr - This decodes one type descriptor from Str, advancing the
9162/// pointer over the consumed characters. This returns the resultant type. If
9163/// AllowTypeModifiers is false then modifier like * are not parsed, just basic
9164/// types. This allows "v2i*" to be parsed as a pointer to a v2i instead of
9165/// a vector of "i*".
9166///
9167/// RequiresICE is filled in on return to indicate whether the value is required
9168/// to be an Integer Constant Expression.
9169static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context,
9170 ASTContext::GetBuiltinTypeError &Error,
9171 bool &RequiresICE,
9172 bool AllowTypeModifiers) {
9173 // Modifiers.
9174 int HowLong = 0;
9175 bool Signed = false, Unsigned = false;
9176 RequiresICE = false;
9177
9178 // Read the prefixed modifiers first.
9179 bool Done = false;
9180 #ifndef NDEBUG
9181 bool IsSpecialLong = false;
9182 #endif
9183 while (!Done) {
9184 switch (*Str++) {
9185 default: Done = true; --Str; break;
9186 case 'I':
9187 RequiresICE = true;
9188 break;
9189 case 'S':
9190 assert(!Unsigned && "Can't use both 'S' and 'U' modifiers!")((!Unsigned && "Can't use both 'S' and 'U' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("!Unsigned && \"Can't use both 'S' and 'U' modifiers!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9190, __PRETTY_FUNCTION__))
;
9191 assert(!Signed && "Can't use 'S' modifier multiple times!")((!Signed && "Can't use 'S' modifier multiple times!"
) ? static_cast<void> (0) : __assert_fail ("!Signed && \"Can't use 'S' modifier multiple times!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9191, __PRETTY_FUNCTION__))
;
9192 Signed = true;
9193 break;
9194 case 'U':
9195 assert(!Signed && "Can't use both 'S' and 'U' modifiers!")((!Signed && "Can't use both 'S' and 'U' modifiers!")
? static_cast<void> (0) : __assert_fail ("!Signed && \"Can't use both 'S' and 'U' modifiers!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9195, __PRETTY_FUNCTION__))
;
9196 assert(!Unsigned && "Can't use 'U' modifier multiple times!")((!Unsigned && "Can't use 'U' modifier multiple times!"
) ? static_cast<void> (0) : __assert_fail ("!Unsigned && \"Can't use 'U' modifier multiple times!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9196, __PRETTY_FUNCTION__))
;
9197 Unsigned = true;
9198 break;
9199 case 'L':
9200 assert(!IsSpecialLong && "Can't use 'L' with 'W' or 'N' modifiers")((!IsSpecialLong && "Can't use 'L' with 'W' or 'N' modifiers"
) ? static_cast<void> (0) : __assert_fail ("!IsSpecialLong && \"Can't use 'L' with 'W' or 'N' modifiers\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9200, __PRETTY_FUNCTION__))
;
9201 assert(HowLong <= 2 && "Can't have LLLL modifier")((HowLong <= 2 && "Can't have LLLL modifier") ? static_cast
<void> (0) : __assert_fail ("HowLong <= 2 && \"Can't have LLLL modifier\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9201, __PRETTY_FUNCTION__))
;
9202 ++HowLong;
9203 break;
9204 case 'N':
9205 // 'N' behaves like 'L' for all non LP64 targets and 'int' otherwise.
9206 assert(!IsSpecialLong && "Can't use two 'N' or 'W' modifiers!")((!IsSpecialLong && "Can't use two 'N' or 'W' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("!IsSpecialLong && \"Can't use two 'N' or 'W' modifiers!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9206, __PRETTY_FUNCTION__))
;
9207 assert(HowLong == 0 && "Can't use both 'L' and 'N' modifiers!")((HowLong == 0 && "Can't use both 'L' and 'N' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("HowLong == 0 && \"Can't use both 'L' and 'N' modifiers!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9207, __PRETTY_FUNCTION__))
;
9208 #ifndef NDEBUG
9209 IsSpecialLong = true;
9210 #endif
9211 if (Context.getTargetInfo().getLongWidth() == 32)
9212 ++HowLong;
9213 break;
9214 case 'W':
9215 // This modifier represents int64 type.
9216 assert(!IsSpecialLong && "Can't use two 'N' or 'W' modifiers!")((!IsSpecialLong && "Can't use two 'N' or 'W' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("!IsSpecialLong && \"Can't use two 'N' or 'W' modifiers!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9216, __PRETTY_FUNCTION__))
;
9217 assert(HowLong == 0 && "Can't use both 'L' and 'W' modifiers!")((HowLong == 0 && "Can't use both 'L' and 'W' modifiers!"
) ? static_cast<void> (0) : __assert_fail ("HowLong == 0 && \"Can't use both 'L' and 'W' modifiers!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9217, __PRETTY_FUNCTION__))
;
9218 #ifndef NDEBUG
9219 IsSpecialLong = true;
9220 #endif
9221 switch (Context.getTargetInfo().getInt64Type()) {
9222 default:
9223 llvm_unreachable("Unexpected integer type")::llvm::llvm_unreachable_internal("Unexpected integer type", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9223)
;
9224 case TargetInfo::SignedLong:
9225 HowLong = 1;
9226 break;
9227 case TargetInfo::SignedLongLong:
9228 HowLong = 2;
9229 break;
9230 }
9231 break;
9232 }
9233 }
9234
9235 QualType Type;
9236
9237 // Read the base type.
9238 switch (*Str++) {
9239 default: llvm_unreachable("Unknown builtin type letter!")::llvm::llvm_unreachable_internal("Unknown builtin type letter!"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9239)
;
9240 case 'v':
9241 assert(HowLong == 0 && !Signed && !Unsigned &&((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers used with 'v'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'v'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9242, __PRETTY_FUNCTION__))
9242 "Bad modifiers used with 'v'!")((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers used with 'v'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'v'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9242, __PRETTY_FUNCTION__))
;
9243 Type = Context.VoidTy;
9244 break;
9245 case 'h':
9246 assert(HowLong == 0 && !Signed && !Unsigned &&((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers used with 'h'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'h'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9247, __PRETTY_FUNCTION__))
9247 "Bad modifiers used with 'h'!")((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers used with 'h'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'h'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9247, __PRETTY_FUNCTION__))
;
9248 Type = Context.HalfTy;
9249 break;
9250 case 'f':
9251 assert(HowLong == 0 && !Signed && !Unsigned &&((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers used with 'f'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'f'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9252, __PRETTY_FUNCTION__))
9252 "Bad modifiers used with 'f'!")((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers used with 'f'!") ? static_cast<void> (0
) : __assert_fail ("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers used with 'f'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9252, __PRETTY_FUNCTION__))
;
9253 Type = Context.FloatTy;
9254 break;
9255 case 'd':
9256 assert(HowLong < 3 && !Signed && !Unsigned &&((HowLong < 3 && !Signed && !Unsigned &&
"Bad modifiers used with 'd'!") ? static_cast<void> (0
) : __assert_fail ("HowLong < 3 && !Signed && !Unsigned && \"Bad modifiers used with 'd'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9257, __PRETTY_FUNCTION__))
9257 "Bad modifiers used with 'd'!")((HowLong < 3 && !Signed && !Unsigned &&
"Bad modifiers used with 'd'!") ? static_cast<void> (0
) : __assert_fail ("HowLong < 3 && !Signed && !Unsigned && \"Bad modifiers used with 'd'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9257, __PRETTY_FUNCTION__))
;
9258 if (HowLong == 1)
9259 Type = Context.LongDoubleTy;
9260 else if (HowLong == 2)
9261 Type = Context.Float128Ty;
9262 else
9263 Type = Context.DoubleTy;
9264 break;
9265 case 's':
9266 assert(HowLong == 0 && "Bad modifiers used with 's'!")((HowLong == 0 && "Bad modifiers used with 's'!") ? static_cast
<void> (0) : __assert_fail ("HowLong == 0 && \"Bad modifiers used with 's'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9266, __PRETTY_FUNCTION__))
;
9267 if (Unsigned)
9268 Type = Context.UnsignedShortTy;
9269 else
9270 Type = Context.ShortTy;
9271 break;
9272 case 'i':
9273 if (HowLong == 3)
9274 Type = Unsigned ? Context.UnsignedInt128Ty : Context.Int128Ty;
9275 else if (HowLong == 2)
9276 Type = Unsigned ? Context.UnsignedLongLongTy : Context.LongLongTy;
9277 else if (HowLong == 1)
9278 Type = Unsigned ? Context.UnsignedLongTy : Context.LongTy;
9279 else
9280 Type = Unsigned ? Context.UnsignedIntTy : Context.IntTy;
9281 break;
9282 case 'c':
9283 assert(HowLong == 0 && "Bad modifiers used with 'c'!")((HowLong == 0 && "Bad modifiers used with 'c'!") ? static_cast
<void> (0) : __assert_fail ("HowLong == 0 && \"Bad modifiers used with 'c'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9283, __PRETTY_FUNCTION__))
;
9284 if (Signed)
9285 Type = Context.SignedCharTy;
9286 else if (Unsigned)
9287 Type = Context.UnsignedCharTy;
9288 else
9289 Type = Context.CharTy;
9290 break;
9291 case 'b': // boolean
9292 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'b'!")((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers for 'b'!") ? static_cast<void> (0) : __assert_fail
("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers for 'b'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9292, __PRETTY_FUNCTION__))
;
9293 Type = Context.BoolTy;
9294 break;
9295 case 'z': // size_t.
9296 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'z'!")((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers for 'z'!") ? static_cast<void> (0) : __assert_fail
("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers for 'z'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9296, __PRETTY_FUNCTION__))
;
9297 Type = Context.getSizeType();
9298 break;
9299 case 'w': // wchar_t.
9300 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'w'!")((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers for 'w'!") ? static_cast<void> (0) : __assert_fail
("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers for 'w'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9300, __PRETTY_FUNCTION__))
;
9301 Type = Context.getWideCharType();
9302 break;
9303 case 'F':
9304 Type = Context.getCFConstantStringType();
9305 break;
9306 case 'G':
9307 Type = Context.getObjCIdType();
9308 break;
9309 case 'H':
9310 Type = Context.getObjCSelType();
9311 break;
9312 case 'M':
9313 Type = Context.getObjCSuperType();
9314 break;
9315 case 'a':
9316 Type = Context.getBuiltinVaListType();
9317 assert(!Type.isNull() && "builtin va list type not initialized!")((!Type.isNull() && "builtin va list type not initialized!"
) ? static_cast<void> (0) : __assert_fail ("!Type.isNull() && \"builtin va list type not initialized!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9317, __PRETTY_FUNCTION__))
;
9318 break;
9319 case 'A':
9320 // This is a "reference" to a va_list; however, what exactly
9321 // this means depends on how va_list is defined. There are two
9322 // different kinds of va_list: ones passed by value, and ones
9323 // passed by reference. An example of a by-value va_list is
9324 // x86, where va_list is a char*. An example of by-ref va_list
9325 // is x86-64, where va_list is a __va_list_tag[1]. For x86,
9326 // we want this argument to be a char*&; for x86-64, we want
9327 // it to be a __va_list_tag*.
9328 Type = Context.getBuiltinVaListType();
9329 assert(!Type.isNull() && "builtin va list type not initialized!")((!Type.isNull() && "builtin va list type not initialized!"
) ? static_cast<void> (0) : __assert_fail ("!Type.isNull() && \"builtin va list type not initialized!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9329, __PRETTY_FUNCTION__))
;
9330 if (Type->isArrayType())
9331 Type = Context.getArrayDecayedType(Type);
9332 else
9333 Type = Context.getLValueReferenceType(Type);
9334 break;
9335 case 'V': {
9336 char *End;
9337 unsigned NumElements = strtoul(Str, &End, 10);
9338 assert(End != Str && "Missing vector size")((End != Str && "Missing vector size") ? static_cast<
void> (0) : __assert_fail ("End != Str && \"Missing vector size\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9338, __PRETTY_FUNCTION__))
;
9339 Str = End;
9340
9341 QualType ElementType = DecodeTypeFromStr(Str, Context, Error,
9342 RequiresICE, false);
9343 assert(!RequiresICE && "Can't require vector ICE")((!RequiresICE && "Can't require vector ICE") ? static_cast
<void> (0) : __assert_fail ("!RequiresICE && \"Can't require vector ICE\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9343, __PRETTY_FUNCTION__))
;
9344
9345 // TODO: No way to make AltiVec vectors in builtins yet.
9346 Type = Context.getVectorType(ElementType, NumElements,
9347 VectorType::GenericVector);
9348 break;
9349 }
9350 case 'E': {
9351 char *End;
9352
9353 unsigned NumElements = strtoul(Str, &End, 10);
9354 assert(End != Str && "Missing vector size")((End != Str && "Missing vector size") ? static_cast<
void> (0) : __assert_fail ("End != Str && \"Missing vector size\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9354, __PRETTY_FUNCTION__))
;
9355
9356 Str = End;
9357
9358 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
9359 false);
9360 Type = Context.getExtVectorType(ElementType, NumElements);
9361 break;
9362 }
9363 case 'X': {
9364 QualType ElementType = DecodeTypeFromStr(Str, Context, Error, RequiresICE,
9365 false);
9366 assert(!RequiresICE && "Can't require complex ICE")((!RequiresICE && "Can't require complex ICE") ? static_cast
<void> (0) : __assert_fail ("!RequiresICE && \"Can't require complex ICE\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9366, __PRETTY_FUNCTION__))
;
9367 Type = Context.getComplexType(ElementType);
9368 break;
9369 }
9370 case 'Y':
9371 Type = Context.getPointerDiffType();
9372 break;
9373 case 'P':
9374 Type = Context.getFILEType();
9375 if (Type.isNull()) {
9376 Error = ASTContext::GE_Missing_stdio;
9377 return {};
9378 }
9379 break;
9380 case 'J':
9381 if (Signed)
9382 Type = Context.getsigjmp_bufType();
9383 else
9384 Type = Context.getjmp_bufType();
9385
9386 if (Type.isNull()) {
9387 Error = ASTContext::GE_Missing_setjmp;
9388 return {};
9389 }
9390 break;
9391 case 'K':
9392 assert(HowLong == 0 && !Signed && !Unsigned && "Bad modifiers for 'K'!")((HowLong == 0 && !Signed && !Unsigned &&
"Bad modifiers for 'K'!") ? static_cast<void> (0) : __assert_fail
("HowLong == 0 && !Signed && !Unsigned && \"Bad modifiers for 'K'!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9392, __PRETTY_FUNCTION__))
;
9393 Type = Context.getucontext_tType();
9394
9395 if (Type.isNull()) {
9396 Error = ASTContext::GE_Missing_ucontext;
9397 return {};
9398 }
9399 break;
9400 case 'p':
9401 Type = Context.getProcessIDType();
9402 break;
9403 }
9404
9405 // If there are modifiers and if we're allowed to parse them, go for it.
9406 Done = !AllowTypeModifiers;
9407 while (!Done) {
9408 switch (char c = *Str++) {
9409 default: Done = true; --Str; break;
9410 case '*':
9411 case '&': {
9412 // Both pointers and references can have their pointee types
9413 // qualified with an address space.
9414 char *End;
9415 unsigned AddrSpace = strtoul(Str, &End, 10);
9416 if (End != Str) {
9417 // Note AddrSpace == 0 is not the same as an unspecified address space.
9418 Type = Context.getAddrSpaceQualType(
9419 Type,
9420 Context.getLangASForBuiltinAddressSpace(AddrSpace));
9421 Str = End;
9422 }
9423 if (c == '*')
9424 Type = Context.getPointerType(Type);
9425 else
9426 Type = Context.getLValueReferenceType(Type);
9427 break;
9428 }
9429 // FIXME: There's no way to have a built-in with an rvalue ref arg.
9430 case 'C':
9431 Type = Type.withConst();
9432 break;
9433 case 'D':
9434 Type = Context.getVolatileType(Type);
9435 break;
9436 case 'R':
9437 Type = Type.withRestrict();
9438 break;
9439 }
9440 }
9441
9442 assert((!RequiresICE || Type->isIntegralOrEnumerationType()) &&(((!RequiresICE || Type->isIntegralOrEnumerationType()) &&
"Integer constant 'I' type must be an integer") ? static_cast
<void> (0) : __assert_fail ("(!RequiresICE || Type->isIntegralOrEnumerationType()) && \"Integer constant 'I' type must be an integer\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9443, __PRETTY_FUNCTION__))
9443 "Integer constant 'I' type must be an integer")(((!RequiresICE || Type->isIntegralOrEnumerationType()) &&
"Integer constant 'I' type must be an integer") ? static_cast
<void> (0) : __assert_fail ("(!RequiresICE || Type->isIntegralOrEnumerationType()) && \"Integer constant 'I' type must be an integer\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9443, __PRETTY_FUNCTION__))
;
9444
9445 return Type;
9446}
9447
9448/// GetBuiltinType - Return the type for the specified builtin.
9449QualType ASTContext::GetBuiltinType(unsigned Id,
9450 GetBuiltinTypeError &Error,
9451 unsigned *IntegerConstantArgs) const {
9452 const char *TypeStr = BuiltinInfo.getTypeString(Id);
9453
9454 SmallVector<QualType, 8> ArgTypes;
9455
9456 bool RequiresICE = false;
9457 Error = GE_None;
9458 QualType ResType = DecodeTypeFromStr(TypeStr, *this, Error,
9459 RequiresICE, true);
9460 if (Error != GE_None)
9461 return {};
9462
9463 assert(!RequiresICE && "Result of intrinsic cannot be required to be an ICE")((!RequiresICE && "Result of intrinsic cannot be required to be an ICE"
) ? static_cast<void> (0) : __assert_fail ("!RequiresICE && \"Result of intrinsic cannot be required to be an ICE\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9463, __PRETTY_FUNCTION__))
;
9464
9465 while (TypeStr[0] && TypeStr[0] != '.') {
9466 QualType Ty = DecodeTypeFromStr(TypeStr, *this, Error, RequiresICE, true);
9467 if (Error != GE_None)
9468 return {};
9469
9470 // If this argument is required to be an IntegerConstantExpression and the
9471 // caller cares, fill in the bitmask we return.
9472 if (RequiresICE && IntegerConstantArgs)
9473 *IntegerConstantArgs |= 1 << ArgTypes.size();
9474
9475 // Do array -> pointer decay. The builtin should use the decayed type.
9476 if (Ty->isArrayType())
9477 Ty = getArrayDecayedType(Ty);
9478
9479 ArgTypes.push_back(Ty);
9480 }
9481
9482 if (Id == Builtin::BI__GetExceptionInfo)
9483 return {};
9484
9485 assert((TypeStr[0] != '.' || TypeStr[1] == 0) &&(((TypeStr[0] != '.' || TypeStr[1] == 0) && "'.' should only occur at end of builtin type list!"
) ? static_cast<void> (0) : __assert_fail ("(TypeStr[0] != '.' || TypeStr[1] == 0) && \"'.' should only occur at end of builtin type list!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9486, __PRETTY_FUNCTION__))
9486 "'.' should only occur at end of builtin type list!")(((TypeStr[0] != '.' || TypeStr[1] == 0) && "'.' should only occur at end of builtin type list!"
) ? static_cast<void> (0) : __assert_fail ("(TypeStr[0] != '.' || TypeStr[1] == 0) && \"'.' should only occur at end of builtin type list!\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9486, __PRETTY_FUNCTION__))
;
9487
9488 FunctionType::ExtInfo EI(CC_C);
9489 if (BuiltinInfo.isNoReturn(Id)) EI = EI.withNoReturn(true);
9490
9491 bool Variadic = (TypeStr[0] == '.');
9492
9493 // We really shouldn't be making a no-proto type here.
9494 if (ArgTypes.empty() && Variadic && !getLangOpts().CPlusPlus)
9495 return getFunctionNoProtoType(ResType, EI);
9496
9497 FunctionProtoType::ExtProtoInfo EPI;
9498 EPI.ExtInfo = EI;
9499 EPI.Variadic = Variadic;
9500 if (getLangOpts().CPlusPlus && BuiltinInfo.isNoThrow(Id))
9501 EPI.ExceptionSpec.Type =
9502 getLangOpts().CPlusPlus11 ? EST_BasicNoexcept : EST_DynamicNone;
9503
9504 return getFunctionType(ResType, ArgTypes, EPI);
9505}
9506
9507static GVALinkage basicGVALinkageForFunction(const ASTContext &Context,
9508 const FunctionDecl *FD) {
9509 if (!FD->isExternallyVisible())
9510 return GVA_Internal;
9511
9512 // Non-user-provided functions get emitted as weak definitions with every
9513 // use, no matter whether they've been explicitly instantiated etc.
9514 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
9515 if (!MD->isUserProvided())
9516 return GVA_DiscardableODR;
9517
9518 GVALinkage External;
9519 switch (FD->getTemplateSpecializationKind()) {
9520 case TSK_Undeclared:
9521 case TSK_ExplicitSpecialization:
9522 External = GVA_StrongExternal;
9523 break;
9524
9525 case TSK_ExplicitInstantiationDefinition:
9526 return GVA_StrongODR;
9527
9528 // C++11 [temp.explicit]p10:
9529 // [ Note: The intent is that an inline function that is the subject of
9530 // an explicit instantiation declaration will still be implicitly
9531 // instantiated when used so that the body can be considered for
9532 // inlining, but that no out-of-line copy of the inline function would be
9533 // generated in the translation unit. -- end note ]
9534 case TSK_ExplicitInstantiationDeclaration:
9535 return GVA_AvailableExternally;
9536
9537 case TSK_ImplicitInstantiation:
9538 External = GVA_DiscardableODR;
9539 break;
9540 }
9541
9542 if (!FD->isInlined())
9543 return External;
9544
9545 if ((!Context.getLangOpts().CPlusPlus &&
9546 !Context.getTargetInfo().getCXXABI().isMicrosoft() &&
9547 !FD->hasAttr<DLLExportAttr>()) ||
9548 FD->hasAttr<GNUInlineAttr>()) {
9549 // FIXME: This doesn't match gcc's behavior for dllexport inline functions.
9550
9551 // GNU or C99 inline semantics. Determine whether this symbol should be
9552 // externally visible.
9553 if (FD->isInlineDefinitionExternallyVisible())
9554 return External;
9555
9556 // C99 inline semantics, where the symbol is not externally visible.
9557 return GVA_AvailableExternally;
9558 }
9559
9560 // Functions specified with extern and inline in -fms-compatibility mode
9561 // forcibly get emitted. While the body of the function cannot be later
9562 // replaced, the function definition cannot be discarded.
9563 if (FD->isMSExternInline())
9564 return GVA_StrongODR;
9565
9566 return GVA_DiscardableODR;
9567}
9568
9569static GVALinkage adjustGVALinkageForAttributes(const ASTContext &Context,
9570 const Decl *D, GVALinkage L) {
9571 // See http://msdn.microsoft.com/en-us/library/xa0d9ste.aspx
9572 // dllexport/dllimport on inline functions.
9573 if (D->hasAttr<DLLImportAttr>()) {
9574 if (L == GVA_DiscardableODR || L == GVA_StrongODR)
9575 return GVA_AvailableExternally;
9576 } else if (D->hasAttr<DLLExportAttr>()) {
9577 if (L == GVA_DiscardableODR)
9578 return GVA_StrongODR;
9579 } else if (Context.getLangOpts().CUDA && Context.getLangOpts().CUDAIsDevice &&
9580 D->hasAttr<CUDAGlobalAttr>()) {
9581 // Device-side functions with __global__ attribute must always be
9582 // visible externally so they can be launched from host.
9583 if (L == GVA_DiscardableODR || L == GVA_Internal)
9584 return GVA_StrongODR;
9585 }
9586 return L;
9587}
9588
9589/// Adjust the GVALinkage for a declaration based on what an external AST source
9590/// knows about whether there can be other definitions of this declaration.
9591static GVALinkage
9592adjustGVALinkageForExternalDefinitionKind(const ASTContext &Ctx, const Decl *D,
9593 GVALinkage L) {
9594 ExternalASTSource *Source = Ctx.getExternalSource();
9595 if (!Source)
9596 return L;
9597
9598 switch (Source->hasExternalDefinitions(D)) {
9599 case ExternalASTSource::EK_Never:
9600 // Other translation units rely on us to provide the definition.
9601 if (L == GVA_DiscardableODR)
9602 return GVA_StrongODR;
9603 break;
9604
9605 case ExternalASTSource::EK_Always:
9606 return GVA_AvailableExternally;
9607
9608 case ExternalASTSource::EK_ReplyHazy:
9609 break;
9610 }
9611 return L;
9612}
9613
9614GVALinkage ASTContext::GetGVALinkageForFunction(const FunctionDecl *FD) const {
9615 return adjustGVALinkageForExternalDefinitionKind(*this, FD,
9616 adjustGVALinkageForAttributes(*this, FD,
9617 basicGVALinkageForFunction(*this, FD)));
9618}
9619
9620static GVALinkage basicGVALinkageForVariable(const ASTContext &Context,
9621 const VarDecl *VD) {
9622 if (!VD->isExternallyVisible())
9623 return GVA_Internal;
9624
9625 if (VD->isStaticLocal()) {
9626 const DeclContext *LexicalContext = VD->getParentFunctionOrMethod();
9627 while (LexicalContext && !isa<FunctionDecl>(LexicalContext))
9628 LexicalContext = LexicalContext->getLexicalParent();
9629
9630 // ObjC Blocks can create local variables that don't have a FunctionDecl
9631 // LexicalContext.
9632 if (!LexicalContext)
9633 return GVA_DiscardableODR;
9634
9635 // Otherwise, let the static local variable inherit its linkage from the
9636 // nearest enclosing function.
9637 auto StaticLocalLinkage =
9638 Context.GetGVALinkageForFunction(cast<FunctionDecl>(LexicalContext));
9639
9640 // Itanium ABI 5.2.2: "Each COMDAT group [for a static local variable] must
9641 // be emitted in any object with references to the symbol for the object it
9642 // contains, whether inline or out-of-line."
9643 // Similar behavior is observed with MSVC. An alternative ABI could use
9644 // StrongODR/AvailableExternally to match the function, but none are
9645 // known/supported currently.
9646 if (StaticLocalLinkage == GVA_StrongODR ||
9647 StaticLocalLinkage == GVA_AvailableExternally)
9648 return GVA_DiscardableODR;
9649 return StaticLocalLinkage;
9650 }
9651
9652 // MSVC treats in-class initialized static data members as definitions.
9653 // By giving them non-strong linkage, out-of-line definitions won't
9654 // cause link errors.
9655 if (Context.isMSStaticDataMemberInlineDefinition(VD))
9656 return GVA_DiscardableODR;
9657
9658 // Most non-template variables have strong linkage; inline variables are
9659 // linkonce_odr or (occasionally, for compatibility) weak_odr.
9660 GVALinkage StrongLinkage;
9661 switch (Context.getInlineVariableDefinitionKind(VD)) {
9662 case ASTContext::InlineVariableDefinitionKind::None:
9663 StrongLinkage = GVA_StrongExternal;
9664 break;
9665 case ASTContext::InlineVariableDefinitionKind::Weak:
9666 case ASTContext::InlineVariableDefinitionKind::WeakUnknown:
9667 StrongLinkage = GVA_DiscardableODR;
9668 break;
9669 case ASTContext::InlineVariableDefinitionKind::Strong:
9670 StrongLinkage = GVA_StrongODR;
9671 break;
9672 }
9673
9674 switch (VD->getTemplateSpecializationKind()) {
9675 case TSK_Undeclared:
9676 return StrongLinkage;
9677
9678 case TSK_ExplicitSpecialization:
9679 return Context.getTargetInfo().getCXXABI().isMicrosoft() &&
9680 VD->isStaticDataMember()
9681 ? GVA_StrongODR
9682 : StrongLinkage;
9683
9684 case TSK_ExplicitInstantiationDefinition:
9685 return GVA_StrongODR;
9686
9687 case TSK_ExplicitInstantiationDeclaration:
9688 return GVA_AvailableExternally;
9689
9690 case TSK_ImplicitInstantiation:
9691 return GVA_DiscardableODR;
9692 }
9693
9694 llvm_unreachable("Invalid Linkage!")::llvm::llvm_unreachable_internal("Invalid Linkage!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9694)
;
9695}
9696
9697GVALinkage ASTContext::GetGVALinkageForVariable(const VarDecl *VD) {
9698 return adjustGVALinkageForExternalDefinitionKind(*this, VD,
9699 adjustGVALinkageForAttributes(*this, VD,
9700 basicGVALinkageForVariable(*this, VD)));
9701}
9702
9703bool ASTContext::DeclMustBeEmitted(const Decl *D) {
9704 if (const auto *VD = dyn_cast<VarDecl>(D)) {
9705 if (!VD->isFileVarDecl())
9706 return false;
9707 // Global named register variables (GNU extension) are never emitted.
9708 if (VD->getStorageClass() == SC_Register)
9709 return false;
9710 if (VD->getDescribedVarTemplate() ||
9711 isa<VarTemplatePartialSpecializationDecl>(VD))
9712 return false;
9713 } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
9714 // We never need to emit an uninstantiated function template.
9715 if (FD->getTemplatedKind() == FunctionDecl::TK_FunctionTemplate)
9716 return false;
9717 } else if (isa<PragmaCommentDecl>(D))
9718 return true;
9719 else if (isa<OMPThreadPrivateDecl>(D))
9720 return true;
9721 else if (isa<PragmaDetectMismatchDecl>(D))
9722 return true;
9723 else if (isa<OMPThreadPrivateDecl>(D))
9724 return !D->getDeclContext()->isDependentContext();
9725 else if (isa<OMPDeclareReductionDecl>(D))
9726 return !D->getDeclContext()->isDependentContext();
9727 else if (isa<ImportDecl>(D))
9728 return true;
9729 else
9730 return false;
9731
9732 if (D->isFromASTFile() && !LangOpts.BuildingPCHWithObjectFile) {
9733 assert(getExternalSource() && "It's from an AST file; must have a source.")((getExternalSource() && "It's from an AST file; must have a source."
) ? static_cast<void> (0) : __assert_fail ("getExternalSource() && \"It's from an AST file; must have a source.\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9733, __PRETTY_FUNCTION__))
;
9734 // On Windows, PCH files are built together with an object file. If this
9735 // declaration comes from such a PCH and DeclMustBeEmitted would return
9736 // true, it would have returned true and the decl would have been emitted
9737 // into that object file, so it doesn't need to be emitted here.
9738 // Note that decls are still emitted if they're referenced, as usual;
9739 // DeclMustBeEmitted is used to decide whether a decl must be emitted even
9740 // if it's not referenced.
9741 //
9742 // Explicit template instantiation definitions are tricky. If there was an
9743 // explicit template instantiation decl in the PCH before, it will look like
9744 // the definition comes from there, even if that was just the declaration.
9745 // (Explicit instantiation defs of variable templates always get emitted.)
9746 bool IsExpInstDef =
9747 isa<FunctionDecl>(D) &&
9748 cast<FunctionDecl>(D)->getTemplateSpecializationKind() ==
9749 TSK_ExplicitInstantiationDefinition;
9750
9751 // Implicit member function definitions, such as operator= might not be
9752 // marked as template specializations, since they're not coming from a
9753 // template but synthesized directly on the class.
9754 IsExpInstDef |=
9755 isa<CXXMethodDecl>(D) &&
9756 cast<CXXMethodDecl>(D)->getParent()->getTemplateSpecializationKind() ==
9757 TSK_ExplicitInstantiationDefinition;
9758
9759 if (getExternalSource()->DeclIsFromPCHWithObjectFile(D) && !IsExpInstDef)
9760 return false;
9761 }
9762
9763 // If this is a member of a class template, we do not need to emit it.
9764 if (D->getDeclContext()->isDependentContext())
9765 return false;
9766
9767 // Weak references don't produce any output by themselves.
9768 if (D->hasAttr<WeakRefAttr>())
9769 return false;
9770
9771 // Aliases and used decls are required.
9772 if (D->hasAttr<AliasAttr>() || D->hasAttr<UsedAttr>())
9773 return true;
9774
9775 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
9776 // Forward declarations aren't required.
9777 if (!FD->doesThisDeclarationHaveABody())
9778 return FD->doesDeclarationForceExternallyVisibleDefinition();
9779
9780 // Constructors and destructors are required.
9781 if (FD->hasAttr<ConstructorAttr>() || FD->hasAttr<DestructorAttr>())
9782 return true;
9783
9784 // The key function for a class is required. This rule only comes
9785 // into play when inline functions can be key functions, though.
9786 if (getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
9787 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
9788 const CXXRecordDecl *RD = MD->getParent();
9789 if (MD->isOutOfLine() && RD->isDynamicClass()) {
9790 const CXXMethodDecl *KeyFunc = getCurrentKeyFunction(RD);
9791 if (KeyFunc && KeyFunc->getCanonicalDecl() == MD->getCanonicalDecl())
9792 return true;
9793 }
9794 }
9795 }
9796
9797 GVALinkage Linkage = GetGVALinkageForFunction(FD);
9798
9799 // static, static inline, always_inline, and extern inline functions can
9800 // always be deferred. Normal inline functions can be deferred in C99/C++.
9801 // Implicit template instantiations can also be deferred in C++.
9802 return !isDiscardableGVALinkage(Linkage);
9803 }
9804
9805 const auto *VD = cast<VarDecl>(D);
9806 assert(VD->isFileVarDecl() && "Expected file scoped var")((VD->isFileVarDecl() && "Expected file scoped var"
) ? static_cast<void> (0) : __assert_fail ("VD->isFileVarDecl() && \"Expected file scoped var\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9806, __PRETTY_FUNCTION__))
;
9807
9808 // If the decl is marked as `declare target to`, it should be emitted for the
9809 // host and for the device.
9810 if (LangOpts.OpenMP &&
9811 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD))
9812 return true;
9813
9814 if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly &&
9815 !isMSStaticDataMemberInlineDefinition(VD))
9816 return false;
9817
9818 // Variables that can be needed in other TUs are required.
9819 auto Linkage = GetGVALinkageForVariable(VD);
9820 if (!isDiscardableGVALinkage(Linkage))
9821 return true;
9822
9823 // We never need to emit a variable that is available in another TU.
9824 if (Linkage == GVA_AvailableExternally)
9825 return false;
9826
9827 // Variables that have destruction with side-effects are required.
9828 if (VD->getType().isDestructedType())
9829 return true;
9830
9831 // Variables that have initialization with side-effects are required.
9832 if (VD->getInit() && VD->getInit()->HasSideEffects(*this) &&
9833 // We can get a value-dependent initializer during error recovery.
9834 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
9835 return true;
9836
9837 // Likewise, variables with tuple-like bindings are required if their
9838 // bindings have side-effects.
9839 if (const auto *DD = dyn_cast<DecompositionDecl>(VD))
9840 for (const auto *BD : DD->bindings())
9841 if (const auto *BindingVD = BD->getHoldingVar())
9842 if (DeclMustBeEmitted(BindingVD))
9843 return true;
9844
9845 return false;
9846}
9847
9848void ASTContext::forEachMultiversionedFunctionVersion(
9849 const FunctionDecl *FD,
9850 llvm::function_ref<void(FunctionDecl *)> Pred) const {
9851 assert(FD->isMultiVersion() && "Only valid for multiversioned functions")((FD->isMultiVersion() && "Only valid for multiversioned functions"
) ? static_cast<void> (0) : __assert_fail ("FD->isMultiVersion() && \"Only valid for multiversioned functions\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9851, __PRETTY_FUNCTION__))
;
9852 llvm::SmallDenseSet<const FunctionDecl*, 4> SeenDecls;
9853 FD = FD->getCanonicalDecl();
9854 for (auto *CurDecl :
9855 FD->getDeclContext()->getRedeclContext()->lookup(FD->getDeclName())) {
9856 FunctionDecl *CurFD = CurDecl->getAsFunction()->getCanonicalDecl();
9857 if (CurFD && hasSameType(CurFD->getType(), FD->getType()) &&
9858 std::end(SeenDecls) == llvm::find(SeenDecls, CurFD)) {
9859 SeenDecls.insert(CurFD);
9860 Pred(CurFD);
9861 }
9862 }
9863}
9864
9865CallingConv ASTContext::getDefaultCallingConvention(bool IsVariadic,
9866 bool IsCXXMethod) const {
9867 // Pass through to the C++ ABI object
9868 if (IsCXXMethod)
9869 return ABI->getDefaultMethodCallConv(IsVariadic);
9870
9871 switch (LangOpts.getDefaultCallingConv()) {
9872 case LangOptions::DCC_None:
9873 break;
9874 case LangOptions::DCC_CDecl:
9875 return CC_C;
9876 case LangOptions::DCC_FastCall:
9877 if (getTargetInfo().hasFeature("sse2") && !IsVariadic)
9878 return CC_X86FastCall;
9879 break;
9880 case LangOptions::DCC_StdCall:
9881 if (!IsVariadic)
9882 return CC_X86StdCall;
9883 break;
9884 case LangOptions::DCC_VectorCall:
9885 // __vectorcall cannot be applied to variadic functions.
9886 if (!IsVariadic)
9887 return CC_X86VectorCall;
9888 break;
9889 case LangOptions::DCC_RegCall:
9890 // __regcall cannot be applied to variadic functions.
9891 if (!IsVariadic)
9892 return CC_X86RegCall;
9893 break;
9894 }
9895 return Target->getDefaultCallingConv(TargetInfo::CCMT_Unknown);
9896}
9897
9898bool ASTContext::isNearlyEmpty(const CXXRecordDecl *RD) const {
9899 // Pass through to the C++ ABI object
9900 return ABI->isNearlyEmpty(RD);
9901}
9902
9903VTableContextBase *ASTContext::getVTableContext() {
9904 if (!VTContext.get()) {
9905 if (Target->getCXXABI().isMicrosoft())
9906 VTContext.reset(new MicrosoftVTableContext(*this));
9907 else
9908 VTContext.reset(new ItaniumVTableContext(*this));
9909 }
9910 return VTContext.get();
9911}
9912
9913MangleContext *ASTContext::createMangleContext() {
9914 switch (Target->getCXXABI().getKind()) {
9915 case TargetCXXABI::GenericAArch64:
9916 case TargetCXXABI::GenericItanium:
9917 case TargetCXXABI::GenericARM:
9918 case TargetCXXABI::GenericMIPS:
9919 case TargetCXXABI::iOS:
9920 case TargetCXXABI::iOS64:
9921 case TargetCXXABI::WebAssembly:
9922 case TargetCXXABI::WatchOS:
9923 return ItaniumMangleContext::create(*this, getDiagnostics());
9924 case TargetCXXABI::Microsoft:
9925 return MicrosoftMangleContext::create(*this, getDiagnostics());
9926 }
9927 llvm_unreachable("Unsupported ABI")::llvm::llvm_unreachable_internal("Unsupported ABI", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9927)
;
9928}
9929
9930CXXABI::~CXXABI() = default;
9931
9932size_t ASTContext::getSideTableAllocatedMemory() const {
9933 return ASTRecordLayouts.getMemorySize() +
9934 llvm::capacity_in_bytes(ObjCLayouts) +
9935 llvm::capacity_in_bytes(KeyFunctions) +
9936 llvm::capacity_in_bytes(ObjCImpls) +
9937 llvm::capacity_in_bytes(BlockVarCopyInits) +
9938 llvm::capacity_in_bytes(DeclAttrs) +
9939 llvm::capacity_in_bytes(TemplateOrInstantiation) +
9940 llvm::capacity_in_bytes(InstantiatedFromUsingDecl) +
9941 llvm::capacity_in_bytes(InstantiatedFromUsingShadowDecl) +
9942 llvm::capacity_in_bytes(InstantiatedFromUnnamedFieldDecl) +
9943 llvm::capacity_in_bytes(OverriddenMethods) +
9944 llvm::capacity_in_bytes(Types) +
9945 llvm::capacity_in_bytes(VariableArrayTypes) +
9946 llvm::capacity_in_bytes(ClassScopeSpecializationPattern);
9947}
9948
9949/// getIntTypeForBitwidth -
9950/// sets integer QualTy according to specified details:
9951/// bitwidth, signed/unsigned.
9952/// Returns empty type if there is no appropriate target types.
9953QualType ASTContext::getIntTypeForBitwidth(unsigned DestWidth,
9954 unsigned Signed) const {
9955 TargetInfo::IntType Ty = getTargetInfo().getIntTypeByWidth(DestWidth, Signed);
9956 CanQualType QualTy = getFromTargetType(Ty);
9957 if (!QualTy && DestWidth == 128)
9958 return Signed ? Int128Ty : UnsignedInt128Ty;
9959 return QualTy;
9960}
9961
9962/// getRealTypeForBitwidth -
9963/// sets floating point QualTy according to specified bitwidth.
9964/// Returns empty type if there is no appropriate target types.
9965QualType ASTContext::getRealTypeForBitwidth(unsigned DestWidth) const {
9966 TargetInfo::RealType Ty = getTargetInfo().getRealTypeByWidth(DestWidth);
9967 switch (Ty) {
9968 case TargetInfo::Float:
9969 return FloatTy;
9970 case TargetInfo::Double:
9971 return DoubleTy;
9972 case TargetInfo::LongDouble:
9973 return LongDoubleTy;
9974 case TargetInfo::Float128:
9975 return Float128Ty;
9976 case TargetInfo::NoFloat:
9977 return {};
9978 }
9979
9980 llvm_unreachable("Unhandled TargetInfo::RealType value")::llvm::llvm_unreachable_internal("Unhandled TargetInfo::RealType value"
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 9980)
;
9981}
9982
9983void ASTContext::setManglingNumber(const NamedDecl *ND, unsigned Number) {
9984 if (Number > 1)
9985 MangleNumbers[ND] = Number;
9986}
9987
9988unsigned ASTContext::getManglingNumber(const NamedDecl *ND) const {
9989 auto I = MangleNumbers.find(ND);
9990 return I != MangleNumbers.end() ? I->second : 1;
9991}
9992
9993void ASTContext::setStaticLocalNumber(const VarDecl *VD, unsigned Number) {
9994 if (Number > 1)
9995 StaticLocalNumbers[VD] = Number;
9996}
9997
9998unsigned ASTContext::getStaticLocalNumber(const VarDecl *VD) const {
9999 auto I = StaticLocalNumbers.find(VD);
10000 return I != StaticLocalNumbers.end() ? I->second : 1;
10001}
10002
10003MangleNumberingContext &
10004ASTContext::getManglingNumberContext(const DeclContext *DC) {
10005 assert(LangOpts.CPlusPlus)((LangOpts.CPlusPlus) ? static_cast<void> (0) : __assert_fail
("LangOpts.CPlusPlus", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10005, __PRETTY_FUNCTION__))
; // We don't need mangling numbers for plain C.
10006 std::unique_ptr<MangleNumberingContext> &MCtx = MangleNumberingContexts[DC];
10007 if (!MCtx)
10008 MCtx = createMangleNumberingContext();
10009 return *MCtx;
10010}
10011
10012std::unique_ptr<MangleNumberingContext>
10013ASTContext::createMangleNumberingContext() const {
10014 return ABI->createMangleNumberingContext();
10015}
10016
10017const CXXConstructorDecl *
10018ASTContext::getCopyConstructorForExceptionObject(CXXRecordDecl *RD) {
10019 return ABI->getCopyConstructorForExceptionObject(
10020 cast<CXXRecordDecl>(RD->getFirstDecl()));
10021}
10022
10023void ASTContext::addCopyConstructorForExceptionObject(CXXRecordDecl *RD,
10024 CXXConstructorDecl *CD) {
10025 return ABI->addCopyConstructorForExceptionObject(
10026 cast<CXXRecordDecl>(RD->getFirstDecl()),
10027 cast<CXXConstructorDecl>(CD->getFirstDecl()));
10028}
10029
10030void ASTContext::addTypedefNameForUnnamedTagDecl(TagDecl *TD,
10031 TypedefNameDecl *DD) {
10032 return ABI->addTypedefNameForUnnamedTagDecl(TD, DD);
10033}
10034
10035TypedefNameDecl *
10036ASTContext::getTypedefNameForUnnamedTagDecl(const TagDecl *TD) {
10037 return ABI->getTypedefNameForUnnamedTagDecl(TD);
10038}
10039
10040void ASTContext::addDeclaratorForUnnamedTagDecl(TagDecl *TD,
10041 DeclaratorDecl *DD) {
10042 return ABI->addDeclaratorForUnnamedTagDecl(TD, DD);
10043}
10044
10045DeclaratorDecl *ASTContext::getDeclaratorForUnnamedTagDecl(const TagDecl *TD) {
10046 return ABI->getDeclaratorForUnnamedTagDecl(TD);
10047}
10048
10049void ASTContext::setParameterIndex(const ParmVarDecl *D, unsigned int index) {
10050 ParamIndices[D] = index;
10051}
10052
10053unsigned ASTContext::getParameterIndex(const ParmVarDecl *D) const {
10054 ParameterIndexTable::const_iterator I = ParamIndices.find(D);
10055 assert(I != ParamIndices.end() &&((I != ParamIndices.end() && "ParmIndices lacks entry set by ParmVarDecl"
) ? static_cast<void> (0) : __assert_fail ("I != ParamIndices.end() && \"ParmIndices lacks entry set by ParmVarDecl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10056, __PRETTY_FUNCTION__))
10056 "ParmIndices lacks entry set by ParmVarDecl")((I != ParamIndices.end() && "ParmIndices lacks entry set by ParmVarDecl"
) ? static_cast<void> (0) : __assert_fail ("I != ParamIndices.end() && \"ParmIndices lacks entry set by ParmVarDecl\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10056, __PRETTY_FUNCTION__))
;
10057 return I->second;
10058}
10059
10060APValue *
10061ASTContext::getMaterializedTemporaryValue(const MaterializeTemporaryExpr *E,
10062 bool MayCreate) {
10063 assert(E && E->getStorageDuration() == SD_Static &&((E && E->getStorageDuration() == SD_Static &&
"don't need to cache the computed value for this temporary")
? static_cast<void> (0) : __assert_fail ("E && E->getStorageDuration() == SD_Static && \"don't need to cache the computed value for this temporary\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10064, __PRETTY_FUNCTION__))
10064 "don't need to cache the computed value for this temporary")((E && E->getStorageDuration() == SD_Static &&
"don't need to cache the computed value for this temporary")
? static_cast<void> (0) : __assert_fail ("E && E->getStorageDuration() == SD_Static && \"don't need to cache the computed value for this temporary\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10064, __PRETTY_FUNCTION__))
;
10065 if (MayCreate) {
10066 APValue *&MTVI = MaterializedTemporaryValues[E];
10067 if (!MTVI)
10068 MTVI = new (*this) APValue;
10069 return MTVI;
10070 }
10071
10072 return MaterializedTemporaryValues.lookup(E);
10073}
10074
10075bool ASTContext::AtomicUsesUnsupportedLibcall(const AtomicExpr *E) const {
10076 const llvm::Triple &T = getTargetInfo().getTriple();
10077 if (!T.isOSDarwin())
10078 return false;
10079
10080 if (!(T.isiOS() && T.isOSVersionLT(7)) &&
10081 !(T.isMacOSX() && T.isOSVersionLT(10, 9)))
10082 return false;
10083
10084 QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
10085 CharUnits sizeChars = getTypeSizeInChars(AtomicTy);
10086 uint64_t Size = sizeChars.getQuantity();
10087 CharUnits alignChars = getTypeAlignInChars(AtomicTy);
10088 unsigned Align = alignChars.getQuantity();
10089 unsigned MaxInlineWidthInBits = getTargetInfo().getMaxAtomicInlineWidth();
10090 return (Size != Align || toBits(sizeChars) > MaxInlineWidthInBits);
10091}
10092
10093static ast_type_traits::DynTypedNode getSingleDynTypedNodeFromParentMap(
10094 ASTContext::ParentMapPointers::mapped_type U) {
10095 if (const auto *D = U.dyn_cast<const Decl *>())
10096 return ast_type_traits::DynTypedNode::create(*D);
10097 if (const auto *S = U.dyn_cast<const Stmt *>())
10098 return ast_type_traits::DynTypedNode::create(*S);
10099 return *U.get<ast_type_traits::DynTypedNode *>();
10100}
10101
10102namespace {
10103
10104/// Template specializations to abstract away from pointers and TypeLocs.
10105/// @{
10106template <typename T>
10107ast_type_traits::DynTypedNode createDynTypedNode(const T &Node) {
10108 return ast_type_traits::DynTypedNode::create(*Node);
10109}
10110template <>
10111ast_type_traits::DynTypedNode createDynTypedNode(const TypeLoc &Node) {
10112 return ast_type_traits::DynTypedNode::create(Node);
10113}
10114template <>
10115ast_type_traits::DynTypedNode
10116createDynTypedNode(const NestedNameSpecifierLoc &Node) {
10117 return ast_type_traits::DynTypedNode::create(Node);
10118}
10119/// @}
10120
10121 /// A \c RecursiveASTVisitor that builds a map from nodes to their
10122 /// parents as defined by the \c RecursiveASTVisitor.
10123 ///
10124 /// Note that the relationship described here is purely in terms of AST
10125 /// traversal - there are other relationships (for example declaration context)
10126 /// in the AST that are better modeled by special matchers.
10127 ///
10128 /// FIXME: Currently only builds up the map using \c Stmt and \c Decl nodes.
10129 class ParentMapASTVisitor : public RecursiveASTVisitor<ParentMapASTVisitor> {
10130 public:
10131 /// Builds and returns the translation unit's parent map.
10132 ///
10133 /// The caller takes ownership of the returned \c ParentMap.
10134 static std::pair<ASTContext::ParentMapPointers *,
10135 ASTContext::ParentMapOtherNodes *>
10136 buildMap(TranslationUnitDecl &TU) {
10137 ParentMapASTVisitor Visitor(new ASTContext::ParentMapPointers,
10138 new ASTContext::ParentMapOtherNodes);
10139 Visitor.TraverseDecl(&TU);
3
Calling 'ParentMapASTVisitor::TraverseDecl'
10140 return std::make_pair(Visitor.Parents, Visitor.OtherParents);
10141 }
10142
10143 private:
10144 friend class RecursiveASTVisitor<ParentMapASTVisitor>;
10145
10146 using VisitorBase = RecursiveASTVisitor<ParentMapASTVisitor>;
10147
10148 ParentMapASTVisitor(ASTContext::ParentMapPointers *Parents,
10149 ASTContext::ParentMapOtherNodes *OtherParents)
10150 : Parents(Parents), OtherParents(OtherParents) {}
10151
10152 bool shouldVisitTemplateInstantiations() const {
10153 return true;
10154 }
10155
10156 bool shouldVisitImplicitCode() const {
10157 return true;
10158 }
10159
10160 template <typename T, typename MapNodeTy, typename BaseTraverseFn,
10161 typename MapTy>
10162 bool TraverseNode(T Node, MapNodeTy MapNode,
10163 BaseTraverseFn BaseTraverse, MapTy *Parents) {
10164 if (!Node)
5
Taking false branch
10165 return true;
10166 if (ParentStack.size() > 0) {
6
Assuming the condition is true
7
Taking true branch
10167 // FIXME: Currently we add the same parent multiple times, but only
10168 // when no memoization data is available for the type.
10169 // For example when we visit all subexpressions of template
10170 // instantiations; this is suboptimal, but benign: the only way to
10171 // visit those is with hasAncestor / hasParent, and those do not create
10172 // new matches.
10173 // The plan is to enable DynTypedNode to be storable in a map or hash
10174 // map. The main problem there is to implement hash functions /
10175 // comparison operators for all types that DynTypedNode supports that
10176 // do not have pointer identity.
10177 auto &NodeOrVector = (*Parents)[MapNode];
10178 if (NodeOrVector.isNull()) {
8
Taking true branch
10179 if (const auto *D = ParentStack.back().get<Decl>())
9
Taking false branch
10180 NodeOrVector = D;
10181 else if (const auto *S = ParentStack.back().get<Stmt>())
10
Taking false branch
10182 NodeOrVector = S;
10183 else
10184 NodeOrVector =
10185 new ast_type_traits::DynTypedNode(ParentStack.back());
11
Memory is allocated
10186 } else {
10187 if (!NodeOrVector.template is<ASTContext::ParentVector *>()) {
10188 auto *Vector = new ASTContext::ParentVector(
10189 1, getSingleDynTypedNodeFromParentMap(NodeOrVector));
10190 delete NodeOrVector
10191 .template dyn_cast<ast_type_traits::DynTypedNode *>();
10192 NodeOrVector = Vector;
10193 }
10194
10195 auto *Vector =
10196 NodeOrVector.template get<ASTContext::ParentVector *>();
10197 // Skip duplicates for types that have memoization data.
10198 // We must check that the type has memoization data before calling
10199 // std::find() because DynTypedNode::operator== can't compare all
10200 // types.
10201 bool Found = ParentStack.back().getMemoizationData() &&
10202 std::find(Vector->begin(), Vector->end(),
10203 ParentStack.back()) != Vector->end();
10204 if (!Found)
10205 Vector->push_back(ParentStack.back());
10206 }
10207 }
10208 ParentStack.push_back(createDynTypedNode(Node));
12
Potential memory leak
10209 bool Result = BaseTraverse();
10210 ParentStack.pop_back();
10211 return Result;
10212 }
10213
10214 bool TraverseDecl(Decl *DeclNode) {
10215 return TraverseNode(DeclNode, DeclNode,
4
Calling 'ParentMapASTVisitor::TraverseNode'
10216 [&] { return VisitorBase::TraverseDecl(DeclNode); },
10217 Parents);
10218 }
10219
10220 bool TraverseStmt(Stmt *StmtNode) {
10221 return TraverseNode(StmtNode, StmtNode,
10222 [&] { return VisitorBase::TraverseStmt(StmtNode); },
10223 Parents);
10224 }
10225
10226 bool TraverseTypeLoc(TypeLoc TypeLocNode) {
10227 return TraverseNode(
10228 TypeLocNode, ast_type_traits::DynTypedNode::create(TypeLocNode),
10229 [&] { return VisitorBase::TraverseTypeLoc(TypeLocNode); },
10230 OtherParents);
10231 }
10232
10233 bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLocNode) {
10234 return TraverseNode(
10235 NNSLocNode, ast_type_traits::DynTypedNode::create(NNSLocNode),
10236 [&] {
10237 return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode);
10238 },
10239 OtherParents);
10240 }
10241
10242 ASTContext::ParentMapPointers *Parents;
10243 ASTContext::ParentMapOtherNodes *OtherParents;
10244 llvm::SmallVector<ast_type_traits::DynTypedNode, 16> ParentStack;
10245 };
10246
10247} // namespace
10248
10249template <typename NodeTy, typename MapTy>
10250static ASTContext::DynTypedNodeList getDynNodeFromMap(const NodeTy &Node,
10251 const MapTy &Map) {
10252 auto I = Map.find(Node);
10253 if (I == Map.end()) {
10254 return llvm::ArrayRef<ast_type_traits::DynTypedNode>();
10255 }
10256 if (const auto *V =
10257 I->second.template dyn_cast<ASTContext::ParentVector *>()) {
10258 return llvm::makeArrayRef(*V);
10259 }
10260 return getSingleDynTypedNodeFromParentMap(I->second);
10261}
10262
10263ASTContext::DynTypedNodeList
10264ASTContext::getParents(const ast_type_traits::DynTypedNode &Node) {
10265 if (!PointerParents) {
1
Taking true branch
10266 // We always need to run over the whole translation unit, as
10267 // hasAncestor can escape any subtree.
10268 auto Maps = ParentMapASTVisitor::buildMap(*getTranslationUnitDecl());
2
Calling 'ParentMapASTVisitor::buildMap'
10269 PointerParents.reset(Maps.first);
10270 OtherParents.reset(Maps.second);
10271 }
10272 if (Node.getNodeKind().hasPointerIdentity())
10273 return getDynNodeFromMap(Node.getMemoizationData(), *PointerParents);
10274 return getDynNodeFromMap(Node, *OtherParents);
10275}
10276
10277bool
10278ASTContext::ObjCMethodsAreEqual(const ObjCMethodDecl *MethodDecl,
10279 const ObjCMethodDecl *MethodImpl) {
10280 // No point trying to match an unavailable/deprecated mothod.
10281 if (MethodDecl->hasAttr<UnavailableAttr>()
10282 || MethodDecl->hasAttr<DeprecatedAttr>())
10283 return false;
10284 if (MethodDecl->getObjCDeclQualifier() !=
10285 MethodImpl->getObjCDeclQualifier())
10286 return false;
10287 if (!hasSameType(MethodDecl->getReturnType(), MethodImpl->getReturnType()))
10288 return false;
10289
10290 if (MethodDecl->param_size() != MethodImpl->param_size())
10291 return false;
10292
10293 for (ObjCMethodDecl::param_const_iterator IM = MethodImpl->param_begin(),
10294 IF = MethodDecl->param_begin(), EM = MethodImpl->param_end(),
10295 EF = MethodDecl->param_end();
10296 IM != EM && IF != EF; ++IM, ++IF) {
10297 const ParmVarDecl *DeclVar = (*IF);
10298 const ParmVarDecl *ImplVar = (*IM);
10299 if (ImplVar->getObjCDeclQualifier() != DeclVar->getObjCDeclQualifier())
10300 return false;
10301 if (!hasSameType(DeclVar->getType(), ImplVar->getType()))
10302 return false;
10303 }
10304
10305 return (MethodDecl->isVariadic() == MethodImpl->isVariadic());
10306}
10307
10308uint64_t ASTContext::getTargetNullPointerValue(QualType QT) const {
10309 LangAS AS;
10310 if (QT->getUnqualifiedDesugaredType()->isNullPtrType())
10311 AS = LangAS::Default;
10312 else
10313 AS = QT->getPointeeType().getAddressSpace();
10314
10315 return getTargetInfo().getNullPointerValue(AS);
10316}
10317
10318unsigned ASTContext::getTargetAddressSpace(LangAS AS) const {
10319 if (isTargetAddressSpace(AS))
10320 return toTargetAddressSpace(AS);
10321 else
10322 return (*AddrSpaceMap)[(unsigned)AS];
10323}
10324
10325QualType ASTContext::getCorrespondingSaturatedType(QualType Ty) const {
10326 assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10326, __PRETTY_FUNCTION__))
;
10327
10328 if (Ty->isSaturatedFixedPointType()) return Ty;
10329
10330 const auto &BT = Ty->getAs<BuiltinType>();
10331 switch (BT->getKind()) {
10332 default:
10333 llvm_unreachable("Not a fixed point type!")::llvm::llvm_unreachable_internal("Not a fixed point type!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10333)
;
10334 case BuiltinType::ShortAccum:
10335 return SatShortAccumTy;
10336 case BuiltinType::Accum:
10337 return SatAccumTy;
10338 case BuiltinType::LongAccum:
10339 return SatLongAccumTy;
10340 case BuiltinType::UShortAccum:
10341 return SatUnsignedShortAccumTy;
10342 case BuiltinType::UAccum:
10343 return SatUnsignedAccumTy;
10344 case BuiltinType::ULongAccum:
10345 return SatUnsignedLongAccumTy;
10346 case BuiltinType::ShortFract:
10347 return SatShortFractTy;
10348 case BuiltinType::Fract:
10349 return SatFractTy;
10350 case BuiltinType::LongFract:
10351 return SatLongFractTy;
10352 case BuiltinType::UShortFract:
10353 return SatUnsignedShortFractTy;
10354 case BuiltinType::UFract:
10355 return SatUnsignedFractTy;
10356 case BuiltinType::ULongFract:
10357 return SatUnsignedLongFractTy;
10358 }
10359}
10360
10361LangAS ASTContext::getLangASForBuiltinAddressSpace(unsigned AS) const {
10362 if (LangOpts.OpenCL)
10363 return getTargetInfo().getOpenCLBuiltinAddressSpace(AS);
10364
10365 if (LangOpts.CUDA)
10366 return getTargetInfo().getCUDABuiltinAddressSpace(AS);
10367
10368 return getLangASFromTargetAS(AS);
10369}
10370
10371// Explicitly instantiate this in case a Redeclarable<T> is used from a TU that
10372// doesn't include ASTContext.h
10373template
10374clang::LazyGenerationalUpdatePtr<
10375 const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::ValueType
10376clang::LazyGenerationalUpdatePtr<
10377 const Decl *, Decl *, &ExternalASTSource::CompleteRedeclChain>::makeValue(
10378 const clang::ASTContext &Ctx, Decl *Value);
10379
10380unsigned char ASTContext::getFixedPointScale(QualType Ty) const {
10381 assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10381, __PRETTY_FUNCTION__))
;
10382
10383 const auto *BT = Ty->getAs<BuiltinType>();
10384 const TargetInfo &Target = getTargetInfo();
10385 switch (BT->getKind()) {
10386 default:
10387 llvm_unreachable("Not a fixed point type!")::llvm::llvm_unreachable_internal("Not a fixed point type!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10387)
;
10388 case BuiltinType::ShortAccum:
10389 case BuiltinType::SatShortAccum:
10390 return Target.getShortAccumScale();
10391 case BuiltinType::Accum:
10392 case BuiltinType::SatAccum:
10393 return Target.getAccumScale();
10394 case BuiltinType::LongAccum:
10395 case BuiltinType::SatLongAccum:
10396 return Target.getLongAccumScale();
10397 case BuiltinType::UShortAccum:
10398 case BuiltinType::SatUShortAccum:
10399 return Target.getUnsignedShortAccumScale();
10400 case BuiltinType::UAccum:
10401 case BuiltinType::SatUAccum:
10402 return Target.getUnsignedAccumScale();
10403 case BuiltinType::ULongAccum:
10404 case BuiltinType::SatULongAccum:
10405 return Target.getUnsignedLongAccumScale();
10406 case BuiltinType::ShortFract:
10407 case BuiltinType::SatShortFract:
10408 return Target.getShortFractScale();
10409 case BuiltinType::Fract:
10410 case BuiltinType::SatFract:
10411 return Target.getFractScale();
10412 case BuiltinType::LongFract:
10413 case BuiltinType::SatLongFract:
10414 return Target.getLongFractScale();
10415 case BuiltinType::UShortFract:
10416 case BuiltinType::SatUShortFract:
10417 return Target.getUnsignedShortFractScale();
10418 case BuiltinType::UFract:
10419 case BuiltinType::SatUFract:
10420 return Target.getUnsignedFractScale();
10421 case BuiltinType::ULongFract:
10422 case BuiltinType::SatULongFract:
10423 return Target.getUnsignedLongFractScale();
10424 }
10425}
10426
10427unsigned char ASTContext::getFixedPointIBits(QualType Ty) const {
10428 assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10428, __PRETTY_FUNCTION__))
;
10429
10430 const auto *BT = Ty->getAs<BuiltinType>();
10431 const TargetInfo &Target = getTargetInfo();
10432 switch (BT->getKind()) {
10433 default:
10434 llvm_unreachable("Not a fixed point type!")::llvm::llvm_unreachable_internal("Not a fixed point type!", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10434)
;
10435 case BuiltinType::ShortAccum:
10436 case BuiltinType::SatShortAccum:
10437 return Target.getShortAccumIBits();
10438 case BuiltinType::Accum:
10439 case BuiltinType::SatAccum:
10440 return Target.getAccumIBits();
10441 case BuiltinType::LongAccum:
10442 case BuiltinType::SatLongAccum:
10443 return Target.getLongAccumIBits();
10444 case BuiltinType::UShortAccum:
10445 case BuiltinType::SatUShortAccum:
10446 return Target.getUnsignedShortAccumIBits();
10447 case BuiltinType::UAccum:
10448 case BuiltinType::SatUAccum:
10449 return Target.getUnsignedAccumIBits();
10450 case BuiltinType::ULongAccum:
10451 case BuiltinType::SatULongAccum:
10452 return Target.getUnsignedLongAccumIBits();
10453 case BuiltinType::ShortFract:
10454 case BuiltinType::SatShortFract:
10455 case BuiltinType::Fract:
10456 case BuiltinType::SatFract:
10457 case BuiltinType::LongFract:
10458 case BuiltinType::SatLongFract:
10459 case BuiltinType::UShortFract:
10460 case BuiltinType::SatUShortFract:
10461 case BuiltinType::UFract:
10462 case BuiltinType::SatUFract:
10463 case BuiltinType::ULongFract:
10464 case BuiltinType::SatULongFract:
10465 return 0;
10466 }
10467}
10468
10469FixedPointSemantics ASTContext::getFixedPointSemantics(QualType Ty) const {
10470 assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10470, __PRETTY_FUNCTION__))
;
10471 bool isSigned = Ty->isSignedFixedPointType();
10472 return FixedPointSemantics(
10473 static_cast<unsigned>(getTypeSize(Ty)), getFixedPointScale(Ty), isSigned,
10474 Ty->isSaturatedFixedPointType(),
10475 !isSigned && getTargetInfo().doUnsignedFixedPointTypesHavePadding());
10476}
10477
10478APFixedPoint ASTContext::getFixedPointMax(QualType Ty) const {
10479 assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10479, __PRETTY_FUNCTION__))
;
10480 return APFixedPoint::getMax(getFixedPointSemantics(Ty));
10481}
10482
10483APFixedPoint ASTContext::getFixedPointMin(QualType Ty) const {
10484 assert(Ty->isFixedPointType())((Ty->isFixedPointType()) ? static_cast<void> (0) : __assert_fail
("Ty->isFixedPointType()", "/build/llvm-toolchain-snapshot-8~svn345461/tools/clang/lib/AST/ASTContext.cpp"
, 10484, __PRETTY_FUNCTION__))
;
10485 return APFixedPoint::getMin(getFixedPointSemantics(Ty));
10486}