Bug Summary

File:build-llvm/tools/clang/include/clang/AST/Attrs.inc
Warning:line 2305, column 5
Called C++ object pointer is null

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 Decl.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 -analyzer-config-compatibility-mode=true -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-9/lib/clang/9.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST -I /build/llvm-toolchain-snapshot-9~svn361465/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn361465/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn361465/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/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.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-9~svn361465/build-llvm/tools/clang/lib/AST -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn361465=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -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-2019-05-24-031927-21217-1 -x c++ /build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp -faddrsig

/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp

1//===- Decl.cpp - Declaration AST Node Implementation ---------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the Decl subclasses.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/Decl.h"
14#include "Linkage.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/ASTDiagnostic.h"
17#include "clang/AST/ASTLambda.h"
18#include "clang/AST/ASTMutationListener.h"
19#include "clang/AST/CanonicalType.h"
20#include "clang/AST/DeclBase.h"
21#include "clang/AST/DeclCXX.h"
22#include "clang/AST/DeclObjC.h"
23#include "clang/AST/DeclOpenMP.h"
24#include "clang/AST/DeclTemplate.h"
25#include "clang/AST/DeclarationName.h"
26#include "clang/AST/Expr.h"
27#include "clang/AST/ExprCXX.h"
28#include "clang/AST/ExternalASTSource.h"
29#include "clang/AST/ODRHash.h"
30#include "clang/AST/PrettyDeclStackTrace.h"
31#include "clang/AST/PrettyPrinter.h"
32#include "clang/AST/Redeclarable.h"
33#include "clang/AST/Stmt.h"
34#include "clang/AST/TemplateBase.h"
35#include "clang/AST/Type.h"
36#include "clang/AST/TypeLoc.h"
37#include "clang/Basic/Builtins.h"
38#include "clang/Basic/IdentifierTable.h"
39#include "clang/Basic/LLVM.h"
40#include "clang/Basic/LangOptions.h"
41#include "clang/Basic/Linkage.h"
42#include "clang/Basic/Module.h"
43#include "clang/Basic/PartialDiagnostic.h"
44#include "clang/Basic/SanitizerBlacklist.h"
45#include "clang/Basic/Sanitizers.h"
46#include "clang/Basic/SourceLocation.h"
47#include "clang/Basic/SourceManager.h"
48#include "clang/Basic/Specifiers.h"
49#include "clang/Basic/TargetCXXABI.h"
50#include "clang/Basic/TargetInfo.h"
51#include "clang/Basic/Visibility.h"
52#include "llvm/ADT/APSInt.h"
53#include "llvm/ADT/ArrayRef.h"
54#include "llvm/ADT/None.h"
55#include "llvm/ADT/Optional.h"
56#include "llvm/ADT/STLExtras.h"
57#include "llvm/ADT/SmallVector.h"
58#include "llvm/ADT/StringSwitch.h"
59#include "llvm/ADT/StringRef.h"
60#include "llvm/ADT/Triple.h"
61#include "llvm/Support/Casting.h"
62#include "llvm/Support/ErrorHandling.h"
63#include "llvm/Support/raw_ostream.h"
64#include <algorithm>
65#include <cassert>
66#include <cstddef>
67#include <cstring>
68#include <memory>
69#include <string>
70#include <tuple>
71#include <type_traits>
72
73using namespace clang;
74
75Decl *clang::getPrimaryMergedDecl(Decl *D) {
76 return D->getASTContext().getPrimaryMergedDecl(D);
77}
78
79void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
80 SourceLocation Loc = this->Loc;
81 if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
82 if (Loc.isValid()) {
83 Loc.print(OS, Context.getSourceManager());
84 OS << ": ";
85 }
86 OS << Message;
87
88 if (auto *ND = dyn_cast_or_null<NamedDecl>(TheDecl)) {
89 OS << " '";
90 ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), true);
91 OS << "'";
92 }
93
94 OS << '\n';
95}
96
97// Defined here so that it can be inlined into its direct callers.
98bool Decl::isOutOfLine() const {
99 return !getLexicalDeclContext()->Equals(getDeclContext());
100}
101
102TranslationUnitDecl::TranslationUnitDecl(ASTContext &ctx)
103 : Decl(TranslationUnit, nullptr, SourceLocation()),
104 DeclContext(TranslationUnit), Ctx(ctx) {}
105
106//===----------------------------------------------------------------------===//
107// NamedDecl Implementation
108//===----------------------------------------------------------------------===//
109
110// Visibility rules aren't rigorously externally specified, but here
111// are the basic principles behind what we implement:
112//
113// 1. An explicit visibility attribute is generally a direct expression
114// of the user's intent and should be honored. Only the innermost
115// visibility attribute applies. If no visibility attribute applies,
116// global visibility settings are considered.
117//
118// 2. There is one caveat to the above: on or in a template pattern,
119// an explicit visibility attribute is just a default rule, and
120// visibility can be decreased by the visibility of template
121// arguments. But this, too, has an exception: an attribute on an
122// explicit specialization or instantiation causes all the visibility
123// restrictions of the template arguments to be ignored.
124//
125// 3. A variable that does not otherwise have explicit visibility can
126// be restricted by the visibility of its type.
127//
128// 4. A visibility restriction is explicit if it comes from an
129// attribute (or something like it), not a global visibility setting.
130// When emitting a reference to an external symbol, visibility
131// restrictions are ignored unless they are explicit.
132//
133// 5. When computing the visibility of a non-type, including a
134// non-type member of a class, only non-type visibility restrictions
135// are considered: the 'visibility' attribute, global value-visibility
136// settings, and a few special cases like __private_extern.
137//
138// 6. When computing the visibility of a type, including a type member
139// of a class, only type visibility restrictions are considered:
140// the 'type_visibility' attribute and global type-visibility settings.
141// However, a 'visibility' attribute counts as a 'type_visibility'
142// attribute on any declaration that only has the former.
143//
144// The visibility of a "secondary" entity, like a template argument,
145// is computed using the kind of that entity, not the kind of the
146// primary entity for which we are computing visibility. For example,
147// the visibility of a specialization of either of these templates:
148// template <class T, bool (&compare)(T, X)> bool has_match(list<T>, X);
149// template <class T, bool (&compare)(T, X)> class matcher;
150// is restricted according to the type visibility of the argument 'T',
151// the type visibility of 'bool(&)(T,X)', and the value visibility of
152// the argument function 'compare'. That 'has_match' is a value
153// and 'matcher' is a type only matters when looking for attributes
154// and settings from the immediate context.
155
156/// Does this computation kind permit us to consider additional
157/// visibility settings from attributes and the like?
158static bool hasExplicitVisibilityAlready(LVComputationKind computation) {
159 return computation.IgnoreExplicitVisibility;
160}
161
162/// Given an LVComputationKind, return one of the same type/value sort
163/// that records that it already has explicit visibility.
164static LVComputationKind
165withExplicitVisibilityAlready(LVComputationKind Kind) {
166 Kind.IgnoreExplicitVisibility = true;
167 return Kind;
168}
169
170static Optional<Visibility> getExplicitVisibility(const NamedDecl *D,
171 LVComputationKind kind) {
172 assert(!kind.IgnoreExplicitVisibility &&((!kind.IgnoreExplicitVisibility && "asking for explicit visibility when we shouldn't be"
) ? static_cast<void> (0) : __assert_fail ("!kind.IgnoreExplicitVisibility && \"asking for explicit visibility when we shouldn't be\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 173, __PRETTY_FUNCTION__))
173 "asking for explicit visibility when we shouldn't be")((!kind.IgnoreExplicitVisibility && "asking for explicit visibility when we shouldn't be"
) ? static_cast<void> (0) : __assert_fail ("!kind.IgnoreExplicitVisibility && \"asking for explicit visibility when we shouldn't be\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 173, __PRETTY_FUNCTION__))
;
174 return D->getExplicitVisibility(kind.getExplicitVisibilityKind());
175}
176
177/// Is the given declaration a "type" or a "value" for the purposes of
178/// visibility computation?
179static bool usesTypeVisibility(const NamedDecl *D) {
180 return isa<TypeDecl>(D) ||
181 isa<ClassTemplateDecl>(D) ||
182 isa<ObjCInterfaceDecl>(D);
183}
184
185/// Does the given declaration have member specialization information,
186/// and if so, is it an explicit specialization?
187template <class T> static typename
188std::enable_if<!std::is_base_of<RedeclarableTemplateDecl, T>::value, bool>::type
189isExplicitMemberSpecialization(const T *D) {
190 if (const MemberSpecializationInfo *member =
191 D->getMemberSpecializationInfo()) {
192 return member->isExplicitSpecialization();
193 }
194 return false;
195}
196
197/// For templates, this question is easier: a member template can't be
198/// explicitly instantiated, so there's a single bit indicating whether
199/// or not this is an explicit member specialization.
200static bool isExplicitMemberSpecialization(const RedeclarableTemplateDecl *D) {
201 return D->isMemberSpecialization();
202}
203
204/// Given a visibility attribute, return the explicit visibility
205/// associated with it.
206template <class T>
207static Visibility getVisibilityFromAttr(const T *attr) {
208 switch (attr->getVisibility()) {
209 case T::Default:
210 return DefaultVisibility;
211 case T::Hidden:
212 return HiddenVisibility;
213 case T::Protected:
214 return ProtectedVisibility;
215 }
216 llvm_unreachable("bad visibility kind")::llvm::llvm_unreachable_internal("bad visibility kind", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 216)
;
217}
218
219/// Return the explicit visibility of the given declaration.
220static Optional<Visibility> getVisibilityOf(const NamedDecl *D,
221 NamedDecl::ExplicitVisibilityKind kind) {
222 // If we're ultimately computing the visibility of a type, look for
223 // a 'type_visibility' attribute before looking for 'visibility'.
224 if (kind == NamedDecl::VisibilityForType) {
225 if (const auto *A = D->getAttr<TypeVisibilityAttr>()) {
226 return getVisibilityFromAttr(A);
227 }
228 }
229
230 // If this declaration has an explicit visibility attribute, use it.
231 if (const auto *A = D->getAttr<VisibilityAttr>()) {
232 return getVisibilityFromAttr(A);
233 }
234
235 return None;
236}
237
238LinkageInfo LinkageComputer::getLVForType(const Type &T,
239 LVComputationKind computation) {
240 if (computation.IgnoreAllVisibility)
241 return LinkageInfo(T.getLinkage(), DefaultVisibility, true);
242 return getTypeLinkageAndVisibility(&T);
243}
244
245/// Get the most restrictive linkage for the types in the given
246/// template parameter list. For visibility purposes, template
247/// parameters are part of the signature of a template.
248LinkageInfo LinkageComputer::getLVForTemplateParameterList(
249 const TemplateParameterList *Params, LVComputationKind computation) {
250 LinkageInfo LV;
251 for (const NamedDecl *P : *Params) {
252 // Template type parameters are the most common and never
253 // contribute to visibility, pack or not.
254 if (isa<TemplateTypeParmDecl>(P))
255 continue;
256
257 // Non-type template parameters can be restricted by the value type, e.g.
258 // template <enum X> class A { ... };
259 // We have to be careful here, though, because we can be dealing with
260 // dependent types.
261 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
262 // Handle the non-pack case first.
263 if (!NTTP->isExpandedParameterPack()) {
264 if (!NTTP->getType()->isDependentType()) {
265 LV.merge(getLVForType(*NTTP->getType(), computation));
266 }
267 continue;
268 }
269
270 // Look at all the types in an expanded pack.
271 for (unsigned i = 0, n = NTTP->getNumExpansionTypes(); i != n; ++i) {
272 QualType type = NTTP->getExpansionType(i);
273 if (!type->isDependentType())
274 LV.merge(getTypeLinkageAndVisibility(type));
275 }
276 continue;
277 }
278
279 // Template template parameters can be restricted by their
280 // template parameters, recursively.
281 const auto *TTP = cast<TemplateTemplateParmDecl>(P);
282
283 // Handle the non-pack case first.
284 if (!TTP->isExpandedParameterPack()) {
285 LV.merge(getLVForTemplateParameterList(TTP->getTemplateParameters(),
286 computation));
287 continue;
288 }
289
290 // Look at all expansions in an expanded pack.
291 for (unsigned i = 0, n = TTP->getNumExpansionTemplateParameters();
292 i != n; ++i) {
293 LV.merge(getLVForTemplateParameterList(
294 TTP->getExpansionTemplateParameters(i), computation));
295 }
296 }
297
298 return LV;
299}
300
301static const Decl *getOutermostFuncOrBlockContext(const Decl *D) {
302 const Decl *Ret = nullptr;
303 const DeclContext *DC = D->getDeclContext();
304 while (DC->getDeclKind() != Decl::TranslationUnit) {
305 if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC))
306 Ret = cast<Decl>(DC);
307 DC = DC->getParent();
308 }
309 return Ret;
310}
311
312/// Get the most restrictive linkage for the types and
313/// declarations in the given template argument list.
314///
315/// Note that we don't take an LVComputationKind because we always
316/// want to honor the visibility of template arguments in the same way.
317LinkageInfo
318LinkageComputer::getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args,
319 LVComputationKind computation) {
320 LinkageInfo LV;
321
322 for (const TemplateArgument &Arg : Args) {
323 switch (Arg.getKind()) {
324 case TemplateArgument::Null:
325 case TemplateArgument::Integral:
326 case TemplateArgument::Expression:
327 continue;
328
329 case TemplateArgument::Type:
330 LV.merge(getLVForType(*Arg.getAsType(), computation));
331 continue;
332
333 case TemplateArgument::Declaration: {
334 const NamedDecl *ND = Arg.getAsDecl();
335 assert(!usesTypeVisibility(ND))((!usesTypeVisibility(ND)) ? static_cast<void> (0) : __assert_fail
("!usesTypeVisibility(ND)", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 335, __PRETTY_FUNCTION__))
;
336 LV.merge(getLVForDecl(ND, computation));
337 continue;
338 }
339
340 case TemplateArgument::NullPtr:
341 LV.merge(getTypeLinkageAndVisibility(Arg.getNullPtrType()));
342 continue;
343
344 case TemplateArgument::Template:
345 case TemplateArgument::TemplateExpansion:
346 if (TemplateDecl *Template =
347 Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
348 LV.merge(getLVForDecl(Template, computation));
349 continue;
350
351 case TemplateArgument::Pack:
352 LV.merge(getLVForTemplateArgumentList(Arg.getPackAsArray(), computation));
353 continue;
354 }
355 llvm_unreachable("bad template argument kind")::llvm::llvm_unreachable_internal("bad template argument kind"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 355)
;
356 }
357
358 return LV;
359}
360
361LinkageInfo
362LinkageComputer::getLVForTemplateArgumentList(const TemplateArgumentList &TArgs,
363 LVComputationKind computation) {
364 return getLVForTemplateArgumentList(TArgs.asArray(), computation);
365}
366
367static bool shouldConsiderTemplateVisibility(const FunctionDecl *fn,
368 const FunctionTemplateSpecializationInfo *specInfo) {
369 // Include visibility from the template parameters and arguments
370 // only if this is not an explicit instantiation or specialization
371 // with direct explicit visibility. (Implicit instantiations won't
372 // have a direct attribute.)
373 if (!specInfo->isExplicitInstantiationOrSpecialization())
374 return true;
375
376 return !fn->hasAttr<VisibilityAttr>();
377}
378
379/// Merge in template-related linkage and visibility for the given
380/// function template specialization.
381///
382/// We don't need a computation kind here because we can assume
383/// LVForValue.
384///
385/// \param[out] LV the computation to use for the parent
386void LinkageComputer::mergeTemplateLV(
387 LinkageInfo &LV, const FunctionDecl *fn,
388 const FunctionTemplateSpecializationInfo *specInfo,
389 LVComputationKind computation) {
390 bool considerVisibility =
391 shouldConsiderTemplateVisibility(fn, specInfo);
392
393 // Merge information from the template parameters.
394 FunctionTemplateDecl *temp = specInfo->getTemplate();
395 LinkageInfo tempLV =
396 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
397 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
398
399 // Merge information from the template arguments.
400 const TemplateArgumentList &templateArgs = *specInfo->TemplateArguments;
401 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
402 LV.mergeMaybeWithVisibility(argsLV, considerVisibility);
403}
404
405/// Does the given declaration have a direct visibility attribute
406/// that would match the given rules?
407static bool hasDirectVisibilityAttribute(const NamedDecl *D,
408 LVComputationKind computation) {
409 if (computation.IgnoreAllVisibility)
410 return false;
411
412 return (computation.isTypeVisibility() && D->hasAttr<TypeVisibilityAttr>()) ||
413 D->hasAttr<VisibilityAttr>();
414}
415
416/// Should we consider visibility associated with the template
417/// arguments and parameters of the given class template specialization?
418static bool shouldConsiderTemplateVisibility(
419 const ClassTemplateSpecializationDecl *spec,
420 LVComputationKind computation) {
421 // Include visibility from the template parameters and arguments
422 // only if this is not an explicit instantiation or specialization
423 // with direct explicit visibility (and note that implicit
424 // instantiations won't have a direct attribute).
425 //
426 // Furthermore, we want to ignore template parameters and arguments
427 // for an explicit specialization when computing the visibility of a
428 // member thereof with explicit visibility.
429 //
430 // This is a bit complex; let's unpack it.
431 //
432 // An explicit class specialization is an independent, top-level
433 // declaration. As such, if it or any of its members has an
434 // explicit visibility attribute, that must directly express the
435 // user's intent, and we should honor it. The same logic applies to
436 // an explicit instantiation of a member of such a thing.
437
438 // Fast path: if this is not an explicit instantiation or
439 // specialization, we always want to consider template-related
440 // visibility restrictions.
441 if (!spec->isExplicitInstantiationOrSpecialization())
442 return true;
443
444 // This is the 'member thereof' check.
445 if (spec->isExplicitSpecialization() &&
446 hasExplicitVisibilityAlready(computation))
447 return false;
448
449 return !hasDirectVisibilityAttribute(spec, computation);
450}
451
452/// Merge in template-related linkage and visibility for the given
453/// class template specialization.
454void LinkageComputer::mergeTemplateLV(
455 LinkageInfo &LV, const ClassTemplateSpecializationDecl *spec,
456 LVComputationKind computation) {
457 bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
458
459 // Merge information from the template parameters, but ignore
460 // visibility if we're only considering template arguments.
461
462 ClassTemplateDecl *temp = spec->getSpecializedTemplate();
463 LinkageInfo tempLV =
464 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
465 LV.mergeMaybeWithVisibility(tempLV,
466 considerVisibility && !hasExplicitVisibilityAlready(computation));
467
468 // Merge information from the template arguments. We ignore
469 // template-argument visibility if we've got an explicit
470 // instantiation with a visibility attribute.
471 const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
472 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
473 if (considerVisibility)
474 LV.mergeVisibility(argsLV);
475 LV.mergeExternalVisibility(argsLV);
476}
477
478/// Should we consider visibility associated with the template
479/// arguments and parameters of the given variable template
480/// specialization? As usual, follow class template specialization
481/// logic up to initialization.
482static bool shouldConsiderTemplateVisibility(
483 const VarTemplateSpecializationDecl *spec,
484 LVComputationKind computation) {
485 // Include visibility from the template parameters and arguments
486 // only if this is not an explicit instantiation or specialization
487 // with direct explicit visibility (and note that implicit
488 // instantiations won't have a direct attribute).
489 if (!spec->isExplicitInstantiationOrSpecialization())
490 return true;
491
492 // An explicit variable specialization is an independent, top-level
493 // declaration. As such, if it has an explicit visibility attribute,
494 // that must directly express the user's intent, and we should honor
495 // it.
496 if (spec->isExplicitSpecialization() &&
497 hasExplicitVisibilityAlready(computation))
498 return false;
499
500 return !hasDirectVisibilityAttribute(spec, computation);
501}
502
503/// Merge in template-related linkage and visibility for the given
504/// variable template specialization. As usual, follow class template
505/// specialization logic up to initialization.
506void LinkageComputer::mergeTemplateLV(LinkageInfo &LV,
507 const VarTemplateSpecializationDecl *spec,
508 LVComputationKind computation) {
509 bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
510
511 // Merge information from the template parameters, but ignore
512 // visibility if we're only considering template arguments.
513
514 VarTemplateDecl *temp = spec->getSpecializedTemplate();
515 LinkageInfo tempLV =
516 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
517 LV.mergeMaybeWithVisibility(tempLV,
518 considerVisibility && !hasExplicitVisibilityAlready(computation));
519
520 // Merge information from the template arguments. We ignore
521 // template-argument visibility if we've got an explicit
522 // instantiation with a visibility attribute.
523 const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
524 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
525 if (considerVisibility)
526 LV.mergeVisibility(argsLV);
527 LV.mergeExternalVisibility(argsLV);
528}
529
530static bool useInlineVisibilityHidden(const NamedDecl *D) {
531 // FIXME: we should warn if -fvisibility-inlines-hidden is used with c.
532 const LangOptions &Opts = D->getASTContext().getLangOpts();
533 if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
534 return false;
535
536 const auto *FD = dyn_cast<FunctionDecl>(D);
537 if (!FD)
538 return false;
539
540 TemplateSpecializationKind TSK = TSK_Undeclared;
541 if (FunctionTemplateSpecializationInfo *spec
542 = FD->getTemplateSpecializationInfo()) {
543 TSK = spec->getTemplateSpecializationKind();
544 } else if (MemberSpecializationInfo *MSI =
545 FD->getMemberSpecializationInfo()) {
546 TSK = MSI->getTemplateSpecializationKind();
547 }
548
549 const FunctionDecl *Def = nullptr;
550 // InlineVisibilityHidden only applies to definitions, and
551 // isInlined() only gives meaningful answers on definitions
552 // anyway.
553 return TSK != TSK_ExplicitInstantiationDeclaration &&
554 TSK != TSK_ExplicitInstantiationDefinition &&
555 FD->hasBody(Def) && Def->isInlined() && !Def->hasAttr<GNUInlineAttr>();
556}
557
558template <typename T> static bool isFirstInExternCContext(T *D) {
559 const T *First = D->getFirstDecl();
560 return First->isInExternCContext();
561}
562
563static bool isSingleLineLanguageLinkage(const Decl &D) {
564 if (const auto *SD = dyn_cast<LinkageSpecDecl>(D.getDeclContext()))
565 if (!SD->hasBraces())
566 return true;
567 return false;
568}
569
570/// Determine whether D is declared in the purview of a named module.
571static bool isInModulePurview(const NamedDecl *D) {
572 if (auto *M = D->getOwningModule())
573 return M->isModulePurview();
574 return false;
575}
576
577static bool isExportedFromModuleInterfaceUnit(const NamedDecl *D) {
578 // FIXME: Handle isModulePrivate.
579 switch (D->getModuleOwnershipKind()) {
580 case Decl::ModuleOwnershipKind::Unowned:
581 case Decl::ModuleOwnershipKind::ModulePrivate:
582 return false;
583 case Decl::ModuleOwnershipKind::Visible:
584 case Decl::ModuleOwnershipKind::VisibleWhenImported:
585 return isInModulePurview(D);
586 }
587 llvm_unreachable("unexpected module ownership kind")::llvm::llvm_unreachable_internal("unexpected module ownership kind"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 587)
;
588}
589
590static LinkageInfo getInternalLinkageFor(const NamedDecl *D) {
591 // Internal linkage declarations within a module interface unit are modeled
592 // as "module-internal linkage", which means that they have internal linkage
593 // formally but can be indirectly accessed from outside the module via inline
594 // functions and templates defined within the module.
595 if (isInModulePurview(D))
596 return LinkageInfo(ModuleInternalLinkage, DefaultVisibility, false);
597
598 return LinkageInfo::internal();
599}
600
601static LinkageInfo getExternalLinkageFor(const NamedDecl *D) {
602 // C++ Modules TS [basic.link]/6.8:
603 // - A name declared at namespace scope that does not have internal linkage
604 // by the previous rules and that is introduced by a non-exported
605 // declaration has module linkage.
606 if (isInModulePurview(D) && !isExportedFromModuleInterfaceUnit(
607 cast<NamedDecl>(D->getCanonicalDecl())))
608 return LinkageInfo(ModuleLinkage, DefaultVisibility, false);
609
610 return LinkageInfo::external();
611}
612
613static StorageClass getStorageClass(const Decl *D) {
614 if (auto *TD = dyn_cast<TemplateDecl>(D))
615 D = TD->getTemplatedDecl();
616 if (D) {
617 if (auto *VD = dyn_cast<VarDecl>(D))
618 return VD->getStorageClass();
619 if (auto *FD = dyn_cast<FunctionDecl>(D))
620 return FD->getStorageClass();
621 }
622 return SC_None;
623}
624
625LinkageInfo
626LinkageComputer::getLVForNamespaceScopeDecl(const NamedDecl *D,
627 LVComputationKind computation,
628 bool IgnoreVarTypeLinkage) {
629 assert(D->getDeclContext()->getRedeclContext()->isFileContext() &&((D->getDeclContext()->getRedeclContext()->isFileContext
() && "Not a name having namespace scope") ? static_cast
<void> (0) : __assert_fail ("D->getDeclContext()->getRedeclContext()->isFileContext() && \"Not a name having namespace scope\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 630, __PRETTY_FUNCTION__))
630 "Not a name having namespace scope")((D->getDeclContext()->getRedeclContext()->isFileContext
() && "Not a name having namespace scope") ? static_cast
<void> (0) : __assert_fail ("D->getDeclContext()->getRedeclContext()->isFileContext() && \"Not a name having namespace scope\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 630, __PRETTY_FUNCTION__))
;
631 ASTContext &Context = D->getASTContext();
632
633 // C++ [basic.link]p3:
634 // A name having namespace scope (3.3.6) has internal linkage if it
635 // is the name of
636
637 if (getStorageClass(D->getCanonicalDecl()) == SC_Static) {
638 // - a variable, variable template, function, or function template
639 // that is explicitly declared static; or
640 // (This bullet corresponds to C99 6.2.2p3.)
641 return getInternalLinkageFor(D);
642 }
643
644 if (const auto *Var = dyn_cast<VarDecl>(D)) {
645 // - a non-template variable of non-volatile const-qualified type, unless
646 // - it is explicitly declared extern, or
647 // - it is inline or exported, or
648 // - it was previously declared and the prior declaration did not have
649 // internal linkage
650 // (There is no equivalent in C99.)
651 if (Context.getLangOpts().CPlusPlus &&
652 Var->getType().isConstQualified() &&
653 !Var->getType().isVolatileQualified() &&
654 !Var->isInline() &&
655 !isExportedFromModuleInterfaceUnit(Var) &&
656 !isa<VarTemplateSpecializationDecl>(Var) &&
657 !Var->getDescribedVarTemplate()) {
658 const VarDecl *PrevVar = Var->getPreviousDecl();
659 if (PrevVar)
660 return getLVForDecl(PrevVar, computation);
661
662 if (Var->getStorageClass() != SC_Extern &&
663 Var->getStorageClass() != SC_PrivateExtern &&
664 !isSingleLineLanguageLinkage(*Var))
665 return getInternalLinkageFor(Var);
666 }
667
668 for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar;
669 PrevVar = PrevVar->getPreviousDecl()) {
670 if (PrevVar->getStorageClass() == SC_PrivateExtern &&
671 Var->getStorageClass() == SC_None)
672 return getDeclLinkageAndVisibility(PrevVar);
673 // Explicitly declared static.
674 if (PrevVar->getStorageClass() == SC_Static)
675 return getInternalLinkageFor(Var);
676 }
677 } else if (const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
678 // - a data member of an anonymous union.
679 const VarDecl *VD = IFD->getVarDecl();
680 assert(VD && "Expected a VarDecl in this IndirectFieldDecl!")((VD && "Expected a VarDecl in this IndirectFieldDecl!"
) ? static_cast<void> (0) : __assert_fail ("VD && \"Expected a VarDecl in this IndirectFieldDecl!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 680, __PRETTY_FUNCTION__))
;
681 return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
682 }
683 assert(!isa<FieldDecl>(D) && "Didn't expect a FieldDecl!")((!isa<FieldDecl>(D) && "Didn't expect a FieldDecl!"
) ? static_cast<void> (0) : __assert_fail ("!isa<FieldDecl>(D) && \"Didn't expect a FieldDecl!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 683, __PRETTY_FUNCTION__))
;
684
685 // FIXME: This gives internal linkage to names that should have no linkage
686 // (those not covered by [basic.link]p6).
687 if (D->isInAnonymousNamespace()) {
688 const auto *Var = dyn_cast<VarDecl>(D);
689 const auto *Func = dyn_cast<FunctionDecl>(D);
690 // FIXME: The check for extern "C" here is not justified by the standard
691 // wording, but we retain it from the pre-DR1113 model to avoid breaking
692 // code.
693 //
694 // C++11 [basic.link]p4:
695 // An unnamed namespace or a namespace declared directly or indirectly
696 // within an unnamed namespace has internal linkage.
697 if ((!Var || !isFirstInExternCContext(Var)) &&
698 (!Func || !isFirstInExternCContext(Func)))
699 return getInternalLinkageFor(D);
700 }
701
702 // Set up the defaults.
703
704 // C99 6.2.2p5:
705 // If the declaration of an identifier for an object has file
706 // scope and no storage-class specifier, its linkage is
707 // external.
708 LinkageInfo LV = getExternalLinkageFor(D);
709
710 if (!hasExplicitVisibilityAlready(computation)) {
711 if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) {
712 LV.mergeVisibility(*Vis, true);
713 } else {
714 // If we're declared in a namespace with a visibility attribute,
715 // use that namespace's visibility, and it still counts as explicit.
716 for (const DeclContext *DC = D->getDeclContext();
717 !isa<TranslationUnitDecl>(DC);
718 DC = DC->getParent()) {
719 const auto *ND = dyn_cast<NamespaceDecl>(DC);
720 if (!ND) continue;
721 if (Optional<Visibility> Vis = getExplicitVisibility(ND, computation)) {
722 LV.mergeVisibility(*Vis, true);
723 break;
724 }
725 }
726 }
727
728 // Add in global settings if the above didn't give us direct visibility.
729 if (!LV.isVisibilityExplicit()) {
730 // Use global type/value visibility as appropriate.
731 Visibility globalVisibility =
732 computation.isValueVisibility()
733 ? Context.getLangOpts().getValueVisibilityMode()
734 : Context.getLangOpts().getTypeVisibilityMode();
735 LV.mergeVisibility(globalVisibility, /*explicit*/ false);
736
737 // If we're paying attention to global visibility, apply
738 // -finline-visibility-hidden if this is an inline method.
739 if (useInlineVisibilityHidden(D))
740 LV.mergeVisibility(HiddenVisibility, /*visibilityExplicit=*/false);
741 }
742 }
743
744 // C++ [basic.link]p4:
745
746 // A name having namespace scope that has not been given internal linkage
747 // above and that is the name of
748 // [...bullets...]
749 // has its linkage determined as follows:
750 // - if the enclosing namespace has internal linkage, the name has
751 // internal linkage; [handled above]
752 // - otherwise, if the declaration of the name is attached to a named
753 // module and is not exported, the name has module linkage;
754 // - otherwise, the name has external linkage.
755 // LV is currently set up to handle the last two bullets.
756 //
757 // The bullets are:
758
759 // - a variable; or
760 if (const auto *Var = dyn_cast<VarDecl>(D)) {
761 // GCC applies the following optimization to variables and static
762 // data members, but not to functions:
763 //
764 // Modify the variable's LV by the LV of its type unless this is
765 // C or extern "C". This follows from [basic.link]p9:
766 // A type without linkage shall not be used as the type of a
767 // variable or function with external linkage unless
768 // - the entity has C language linkage, or
769 // - the entity is declared within an unnamed namespace, or
770 // - the entity is not used or is defined in the same
771 // translation unit.
772 // and [basic.link]p10:
773 // ...the types specified by all declarations referring to a
774 // given variable or function shall be identical...
775 // C does not have an equivalent rule.
776 //
777 // Ignore this if we've got an explicit attribute; the user
778 // probably knows what they're doing.
779 //
780 // Note that we don't want to make the variable non-external
781 // because of this, but unique-external linkage suits us.
782 if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Var) &&
783 !IgnoreVarTypeLinkage) {
784 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
785 if (!isExternallyVisible(TypeLV.getLinkage()))
786 return LinkageInfo::uniqueExternal();
787 if (!LV.isVisibilityExplicit())
788 LV.mergeVisibility(TypeLV);
789 }
790
791 if (Var->getStorageClass() == SC_PrivateExtern)
792 LV.mergeVisibility(HiddenVisibility, true);
793
794 // Note that Sema::MergeVarDecl already takes care of implementing
795 // C99 6.2.2p4 and propagating the visibility attribute, so we don't have
796 // to do it here.
797
798 // As per function and class template specializations (below),
799 // consider LV for the template and template arguments. We're at file
800 // scope, so we do not need to worry about nested specializations.
801 if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
802 mergeTemplateLV(LV, spec, computation);
803 }
804
805 // - a function; or
806 } else if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
807 // In theory, we can modify the function's LV by the LV of its
808 // type unless it has C linkage (see comment above about variables
809 // for justification). In practice, GCC doesn't do this, so it's
810 // just too painful to make work.
811
812 if (Function->getStorageClass() == SC_PrivateExtern)
813 LV.mergeVisibility(HiddenVisibility, true);
814
815 // Note that Sema::MergeCompatibleFunctionDecls already takes care of
816 // merging storage classes and visibility attributes, so we don't have to
817 // look at previous decls in here.
818
819 // In C++, then if the type of the function uses a type with
820 // unique-external linkage, it's not legally usable from outside
821 // this translation unit. However, we should use the C linkage
822 // rules instead for extern "C" declarations.
823 if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Function)) {
824 // Only look at the type-as-written. Otherwise, deducing the return type
825 // of a function could change its linkage.
826 QualType TypeAsWritten = Function->getType();
827 if (TypeSourceInfo *TSI = Function->getTypeSourceInfo())
828 TypeAsWritten = TSI->getType();
829 if (!isExternallyVisible(TypeAsWritten->getLinkage()))
830 return LinkageInfo::uniqueExternal();
831 }
832
833 // Consider LV from the template and the template arguments.
834 // We're at file scope, so we do not need to worry about nested
835 // specializations.
836 if (FunctionTemplateSpecializationInfo *specInfo
837 = Function->getTemplateSpecializationInfo()) {
838 mergeTemplateLV(LV, Function, specInfo, computation);
839 }
840
841 // - a named class (Clause 9), or an unnamed class defined in a
842 // typedef declaration in which the class has the typedef name
843 // for linkage purposes (7.1.3); or
844 // - a named enumeration (7.2), or an unnamed enumeration
845 // defined in a typedef declaration in which the enumeration
846 // has the typedef name for linkage purposes (7.1.3); or
847 } else if (const auto *Tag = dyn_cast<TagDecl>(D)) {
848 // Unnamed tags have no linkage.
849 if (!Tag->hasNameForLinkage())
850 return LinkageInfo::none();
851
852 // If this is a class template specialization, consider the
853 // linkage of the template and template arguments. We're at file
854 // scope, so we do not need to worry about nested specializations.
855 if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
856 mergeTemplateLV(LV, spec, computation);
857 }
858
859 // FIXME: This is not part of the C++ standard any more.
860 // - an enumerator belonging to an enumeration with external linkage; or
861 } else if (isa<EnumConstantDecl>(D)) {
862 LinkageInfo EnumLV = getLVForDecl(cast<NamedDecl>(D->getDeclContext()),
863 computation);
864 if (!isExternalFormalLinkage(EnumLV.getLinkage()))
865 return LinkageInfo::none();
866 LV.merge(EnumLV);
867
868 // - a template
869 } else if (const auto *temp = dyn_cast<TemplateDecl>(D)) {
870 bool considerVisibility = !hasExplicitVisibilityAlready(computation);
871 LinkageInfo tempLV =
872 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
873 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
874
875 // An unnamed namespace or a namespace declared directly or indirectly
876 // within an unnamed namespace has internal linkage. All other namespaces
877 // have external linkage.
878 //
879 // We handled names in anonymous namespaces above.
880 } else if (isa<NamespaceDecl>(D)) {
881 return LV;
882
883 // By extension, we assign external linkage to Objective-C
884 // interfaces.
885 } else if (isa<ObjCInterfaceDecl>(D)) {
886 // fallout
887
888 } else if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
889 // A typedef declaration has linkage if it gives a type a name for
890 // linkage purposes.
891 if (!TD->getAnonDeclWithTypedefName(/*AnyRedecl*/true))
892 return LinkageInfo::none();
893
894 // Everything not covered here has no linkage.
895 } else {
896 return LinkageInfo::none();
897 }
898
899 // If we ended up with non-externally-visible linkage, visibility should
900 // always be default.
901 if (!isExternallyVisible(LV.getLinkage()))
902 return LinkageInfo(LV.getLinkage(), DefaultVisibility, false);
903
904 return LV;
905}
906
907LinkageInfo
908LinkageComputer::getLVForClassMember(const NamedDecl *D,
909 LVComputationKind computation,
910 bool IgnoreVarTypeLinkage) {
911 // Only certain class members have linkage. Note that fields don't
912 // really have linkage, but it's convenient to say they do for the
913 // purposes of calculating linkage of pointer-to-data-member
914 // template arguments.
915 //
916 // Templates also don't officially have linkage, but since we ignore
917 // the C++ standard and look at template arguments when determining
918 // linkage and visibility of a template specialization, we might hit
919 // a template template argument that way. If we do, we need to
920 // consider its linkage.
921 if (!(isa<CXXMethodDecl>(D) ||
922 isa<VarDecl>(D) ||
923 isa<FieldDecl>(D) ||
924 isa<IndirectFieldDecl>(D) ||
925 isa<TagDecl>(D) ||
926 isa<TemplateDecl>(D)))
927 return LinkageInfo::none();
928
929 LinkageInfo LV;
930
931 // If we have an explicit visibility attribute, merge that in.
932 if (!hasExplicitVisibilityAlready(computation)) {
933 if (Optional<Visibility> Vis = getExplicitVisibility(D, computation))
934 LV.mergeVisibility(*Vis, true);
935 // If we're paying attention to global visibility, apply
936 // -finline-visibility-hidden if this is an inline method.
937 //
938 // Note that we do this before merging information about
939 // the class visibility.
940 if (!LV.isVisibilityExplicit() && useInlineVisibilityHidden(D))
941 LV.mergeVisibility(HiddenVisibility, /*visibilityExplicit=*/false);
942 }
943
944 // If this class member has an explicit visibility attribute, the only
945 // thing that can change its visibility is the template arguments, so
946 // only look for them when processing the class.
947 LVComputationKind classComputation = computation;
948 if (LV.isVisibilityExplicit())
949 classComputation = withExplicitVisibilityAlready(computation);
950
951 LinkageInfo classLV =
952 getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation);
953 // The member has the same linkage as the class. If that's not externally
954 // visible, we don't need to compute anything about the linkage.
955 // FIXME: If we're only computing linkage, can we bail out here?
956 if (!isExternallyVisible(classLV.getLinkage()))
957 return classLV;
958
959
960 // Otherwise, don't merge in classLV yet, because in certain cases
961 // we need to completely ignore the visibility from it.
962
963 // Specifically, if this decl exists and has an explicit attribute.
964 const NamedDecl *explicitSpecSuppressor = nullptr;
965
966 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
967 // Only look at the type-as-written. Otherwise, deducing the return type
968 // of a function could change its linkage.
969 QualType TypeAsWritten = MD->getType();
970 if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
971 TypeAsWritten = TSI->getType();
972 if (!isExternallyVisible(TypeAsWritten->getLinkage()))
973 return LinkageInfo::uniqueExternal();
974
975 // If this is a method template specialization, use the linkage for
976 // the template parameters and arguments.
977 if (FunctionTemplateSpecializationInfo *spec
978 = MD->getTemplateSpecializationInfo()) {
979 mergeTemplateLV(LV, MD, spec, computation);
980 if (spec->isExplicitSpecialization()) {
981 explicitSpecSuppressor = MD;
982 } else if (isExplicitMemberSpecialization(spec->getTemplate())) {
983 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
984 }
985 } else if (isExplicitMemberSpecialization(MD)) {
986 explicitSpecSuppressor = MD;
987 }
988
989 } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
990 if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
991 mergeTemplateLV(LV, spec, computation);
992 if (spec->isExplicitSpecialization()) {
993 explicitSpecSuppressor = spec;
994 } else {
995 const ClassTemplateDecl *temp = spec->getSpecializedTemplate();
996 if (isExplicitMemberSpecialization(temp)) {
997 explicitSpecSuppressor = temp->getTemplatedDecl();
998 }
999 }
1000 } else if (isExplicitMemberSpecialization(RD)) {
1001 explicitSpecSuppressor = RD;
1002 }
1003
1004 // Static data members.
1005 } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
1006 if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
1007 mergeTemplateLV(LV, spec, computation);
1008
1009 // Modify the variable's linkage by its type, but ignore the
1010 // type's visibility unless it's a definition.
1011 if (!IgnoreVarTypeLinkage) {
1012 LinkageInfo typeLV = getLVForType(*VD->getType(), computation);
1013 // FIXME: If the type's linkage is not externally visible, we can
1014 // give this static data member UniqueExternalLinkage.
1015 if (!LV.isVisibilityExplicit() && !classLV.isVisibilityExplicit())
1016 LV.mergeVisibility(typeLV);
1017 LV.mergeExternalVisibility(typeLV);
1018 }
1019
1020 if (isExplicitMemberSpecialization(VD)) {
1021 explicitSpecSuppressor = VD;
1022 }
1023
1024 // Template members.
1025 } else if (const auto *temp = dyn_cast<TemplateDecl>(D)) {
1026 bool considerVisibility =
1027 (!LV.isVisibilityExplicit() &&
1028 !classLV.isVisibilityExplicit() &&
1029 !hasExplicitVisibilityAlready(computation));
1030 LinkageInfo tempLV =
1031 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
1032 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
1033
1034 if (const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
1035 if (isExplicitMemberSpecialization(redeclTemp)) {
1036 explicitSpecSuppressor = temp->getTemplatedDecl();
1037 }
1038 }
1039 }
1040
1041 // We should never be looking for an attribute directly on a template.
1042 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor))((!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor
)) ? static_cast<void> (0) : __assert_fail ("!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor)"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1042, __PRETTY_FUNCTION__))
;
1043
1044 // If this member is an explicit member specialization, and it has
1045 // an explicit attribute, ignore visibility from the parent.
1046 bool considerClassVisibility = true;
1047 if (explicitSpecSuppressor &&
1048 // optimization: hasDVA() is true only with explicit visibility.
1049 LV.isVisibilityExplicit() &&
1050 classLV.getVisibility() != DefaultVisibility &&
1051 hasDirectVisibilityAttribute(explicitSpecSuppressor, computation)) {
1052 considerClassVisibility = false;
1053 }
1054
1055 // Finally, merge in information from the class.
1056 LV.mergeMaybeWithVisibility(classLV, considerClassVisibility);
1057 return LV;
1058}
1059
1060void NamedDecl::anchor() {}
1061
1062bool NamedDecl::isLinkageValid() const {
1063 if (!hasCachedLinkage())
1064 return true;
1065
1066 Linkage L = LinkageComputer{}
1067 .computeLVForDecl(this, LVComputationKind::forLinkageOnly())
1068 .getLinkage();
1069 return L == getCachedLinkage();
1070}
1071
1072ObjCStringFormatFamily NamedDecl::getObjCFStringFormattingFamily() const {
1073 StringRef name = getName();
1074 if (name.empty()) return SFF_None;
1075
1076 if (name.front() == 'C')
1077 if (name == "CFStringCreateWithFormat" ||
1078 name == "CFStringCreateWithFormatAndArguments" ||
1079 name == "CFStringAppendFormat" ||
1080 name == "CFStringAppendFormatAndArguments")
1081 return SFF_CFString;
1082 return SFF_None;
1083}
1084
1085Linkage NamedDecl::getLinkageInternal() const {
1086 // We don't care about visibility here, so ask for the cheapest
1087 // possible visibility analysis.
1088 return LinkageComputer{}
1089 .getLVForDecl(this, LVComputationKind::forLinkageOnly())
1090 .getLinkage();
1091}
1092
1093LinkageInfo NamedDecl::getLinkageAndVisibility() const {
1094 return LinkageComputer{}.getDeclLinkageAndVisibility(this);
1095}
1096
1097static Optional<Visibility>
1098getExplicitVisibilityAux(const NamedDecl *ND,
1099 NamedDecl::ExplicitVisibilityKind kind,
1100 bool IsMostRecent) {
1101 assert(!IsMostRecent || ND == ND->getMostRecentDecl())((!IsMostRecent || ND == ND->getMostRecentDecl()) ? static_cast
<void> (0) : __assert_fail ("!IsMostRecent || ND == ND->getMostRecentDecl()"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1101, __PRETTY_FUNCTION__))
;
1102
1103 // Check the declaration itself first.
1104 if (Optional<Visibility> V = getVisibilityOf(ND, kind))
1105 return V;
1106
1107 // If this is a member class of a specialization of a class template
1108 // and the corresponding decl has explicit visibility, use that.
1109 if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
1110 CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass();
1111 if (InstantiatedFrom)
1112 return getVisibilityOf(InstantiatedFrom, kind);
1113 }
1114
1115 // If there wasn't explicit visibility there, and this is a
1116 // specialization of a class template, check for visibility
1117 // on the pattern.
1118 if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
1119 // Walk all the template decl till this point to see if there are
1120 // explicit visibility attributes.
1121 const auto *TD = spec->getSpecializedTemplate()->getTemplatedDecl();
1122 while (TD != nullptr) {
1123 auto Vis = getVisibilityOf(TD, kind);
1124 if (Vis != None)
1125 return Vis;
1126 TD = TD->getPreviousDecl();
1127 }
1128 return None;
1129 }
1130
1131 // Use the most recent declaration.
1132 if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
1133 const NamedDecl *MostRecent = ND->getMostRecentDecl();
1134 if (MostRecent != ND)
1135 return getExplicitVisibilityAux(MostRecent, kind, true);
1136 }
1137
1138 if (const auto *Var = dyn_cast<VarDecl>(ND)) {
1139 if (Var->isStaticDataMember()) {
1140 VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember();
1141 if (InstantiatedFrom)
1142 return getVisibilityOf(InstantiatedFrom, kind);
1143 }
1144
1145 if (const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
1146 return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
1147 kind);
1148
1149 return None;
1150 }
1151 // Also handle function template specializations.
1152 if (const auto *fn = dyn_cast<FunctionDecl>(ND)) {
1153 // If the function is a specialization of a template with an
1154 // explicit visibility attribute, use that.
1155 if (FunctionTemplateSpecializationInfo *templateInfo
1156 = fn->getTemplateSpecializationInfo())
1157 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
1158 kind);
1159
1160 // If the function is a member of a specialization of a class template
1161 // and the corresponding decl has explicit visibility, use that.
1162 FunctionDecl *InstantiatedFrom = fn->getInstantiatedFromMemberFunction();
1163 if (InstantiatedFrom)
1164 return getVisibilityOf(InstantiatedFrom, kind);
1165
1166 return None;
1167 }
1168
1169 // The visibility of a template is stored in the templated decl.
1170 if (const auto *TD = dyn_cast<TemplateDecl>(ND))
1171 return getVisibilityOf(TD->getTemplatedDecl(), kind);
1172
1173 return None;
1174}
1175
1176Optional<Visibility>
1177NamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const {
1178 return getExplicitVisibilityAux(this, kind, false);
1179}
1180
1181LinkageInfo LinkageComputer::getLVForClosure(const DeclContext *DC,
1182 Decl *ContextDecl,
1183 LVComputationKind computation) {
1184 // This lambda has its linkage/visibility determined by its owner.
1185 const NamedDecl *Owner;
1186 if (!ContextDecl)
1187 Owner = dyn_cast<NamedDecl>(DC);
1188 else if (isa<ParmVarDecl>(ContextDecl))
1189 Owner =
1190 dyn_cast<NamedDecl>(ContextDecl->getDeclContext()->getRedeclContext());
1191 else
1192 Owner = cast<NamedDecl>(ContextDecl);
1193
1194 if (!Owner)
1195 return LinkageInfo::none();
1196
1197 // If the owner has a deduced type, we need to skip querying the linkage and
1198 // visibility of that type, because it might involve this closure type. The
1199 // only effect of this is that we might give a lambda VisibleNoLinkage rather
1200 // than NoLinkage when we don't strictly need to, which is benign.
1201 auto *VD = dyn_cast<VarDecl>(Owner);
1202 LinkageInfo OwnerLV =
1203 VD && VD->getType()->getContainedDeducedType()
1204 ? computeLVForDecl(Owner, computation, /*IgnoreVarTypeLinkage*/true)
1205 : getLVForDecl(Owner, computation);
1206
1207 // A lambda never formally has linkage. But if the owner is externally
1208 // visible, then the lambda is too. We apply the same rules to blocks.
1209 if (!isExternallyVisible(OwnerLV.getLinkage()))
1210 return LinkageInfo::none();
1211 return LinkageInfo(VisibleNoLinkage, OwnerLV.getVisibility(),
1212 OwnerLV.isVisibilityExplicit());
1213}
1214
1215LinkageInfo LinkageComputer::getLVForLocalDecl(const NamedDecl *D,
1216 LVComputationKind computation) {
1217 if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
1218 if (Function->isInAnonymousNamespace() &&
1219 !isFirstInExternCContext(Function))
1220 return getInternalLinkageFor(Function);
1221
1222 // This is a "void f();" which got merged with a file static.
1223 if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
1224 return getInternalLinkageFor(Function);
1225
1226 LinkageInfo LV;
1227 if (!hasExplicitVisibilityAlready(computation)) {
1228 if (Optional<Visibility> Vis =
1229 getExplicitVisibility(Function, computation))
1230 LV.mergeVisibility(*Vis, true);
1231 }
1232
1233 // Note that Sema::MergeCompatibleFunctionDecls already takes care of
1234 // merging storage classes and visibility attributes, so we don't have to
1235 // look at previous decls in here.
1236
1237 return LV;
1238 }
1239
1240 if (const auto *Var = dyn_cast<VarDecl>(D)) {
1241 if (Var->hasExternalStorage()) {
1242 if (Var->isInAnonymousNamespace() && !isFirstInExternCContext(Var))
1243 return getInternalLinkageFor(Var);
1244
1245 LinkageInfo LV;
1246 if (Var->getStorageClass() == SC_PrivateExtern)
1247 LV.mergeVisibility(HiddenVisibility, true);
1248 else if (!hasExplicitVisibilityAlready(computation)) {
1249 if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation))
1250 LV.mergeVisibility(*Vis, true);
1251 }
1252
1253 if (const VarDecl *Prev = Var->getPreviousDecl()) {
1254 LinkageInfo PrevLV = getLVForDecl(Prev, computation);
1255 if (PrevLV.getLinkage())
1256 LV.setLinkage(PrevLV.getLinkage());
1257 LV.mergeVisibility(PrevLV);
1258 }
1259
1260 return LV;
1261 }
1262
1263 if (!Var->isStaticLocal())
1264 return LinkageInfo::none();
1265 }
1266
1267 ASTContext &Context = D->getASTContext();
1268 if (!Context.getLangOpts().CPlusPlus)
1269 return LinkageInfo::none();
1270
1271 const Decl *OuterD = getOutermostFuncOrBlockContext(D);
1272 if (!OuterD || OuterD->isInvalidDecl())
1273 return LinkageInfo::none();
1274
1275 LinkageInfo LV;
1276 if (const auto *BD = dyn_cast<BlockDecl>(OuterD)) {
1277 if (!BD->getBlockManglingNumber())
1278 return LinkageInfo::none();
1279
1280 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
1281 BD->getBlockManglingContextDecl(), computation);
1282 } else {
1283 const auto *FD = cast<FunctionDecl>(OuterD);
1284 if (!FD->isInlined() &&
1285 !isTemplateInstantiation(FD->getTemplateSpecializationKind()))
1286 return LinkageInfo::none();
1287
1288 // If a function is hidden by -fvisibility-inlines-hidden option and
1289 // is not explicitly attributed as a hidden function,
1290 // we should not make static local variables in the function hidden.
1291 LV = getLVForDecl(FD, computation);
1292 if (isa<VarDecl>(D) && useInlineVisibilityHidden(FD) &&
1293 !LV.isVisibilityExplicit()) {
1294 assert(cast<VarDecl>(D)->isStaticLocal())((cast<VarDecl>(D)->isStaticLocal()) ? static_cast<
void> (0) : __assert_fail ("cast<VarDecl>(D)->isStaticLocal()"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1294, __PRETTY_FUNCTION__))
;
1295 // If this was an implicitly hidden inline method, check again for
1296 // explicit visibility on the parent class, and use that for static locals
1297 // if present.
1298 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1299 LV = getLVForDecl(MD->getParent(), computation);
1300 if (!LV.isVisibilityExplicit()) {
1301 Visibility globalVisibility =
1302 computation.isValueVisibility()
1303 ? Context.getLangOpts().getValueVisibilityMode()
1304 : Context.getLangOpts().getTypeVisibilityMode();
1305 return LinkageInfo(VisibleNoLinkage, globalVisibility,
1306 /*visibilityExplicit=*/false);
1307 }
1308 }
1309 }
1310 if (!isExternallyVisible(LV.getLinkage()))
1311 return LinkageInfo::none();
1312 return LinkageInfo(VisibleNoLinkage, LV.getVisibility(),
1313 LV.isVisibilityExplicit());
1314}
1315
1316static inline const CXXRecordDecl*
1317getOutermostEnclosingLambda(const CXXRecordDecl *Record) {
1318 const CXXRecordDecl *Ret = Record;
1319 while (Record && Record->isLambda()) {
1320 Ret = Record;
1321 if (!Record->getParent()) break;
1322 // Get the Containing Class of this Lambda Class
1323 Record = dyn_cast_or_null<CXXRecordDecl>(
1324 Record->getParent()->getParent());
1325 }
1326 return Ret;
1327}
1328
1329LinkageInfo LinkageComputer::computeLVForDecl(const NamedDecl *D,
1330 LVComputationKind computation,
1331 bool IgnoreVarTypeLinkage) {
1332 // Internal_linkage attribute overrides other considerations.
1333 if (D->hasAttr<InternalLinkageAttr>())
1334 return getInternalLinkageFor(D);
1335
1336 // Objective-C: treat all Objective-C declarations as having external
1337 // linkage.
1338 switch (D->getKind()) {
1339 default:
1340 break;
1341
1342 // Per C++ [basic.link]p2, only the names of objects, references,
1343 // functions, types, templates, namespaces, and values ever have linkage.
1344 //
1345 // Note that the name of a typedef, namespace alias, using declaration,
1346 // and so on are not the name of the corresponding type, namespace, or
1347 // declaration, so they do *not* have linkage.
1348 case Decl::ImplicitParam:
1349 case Decl::Label:
1350 case Decl::NamespaceAlias:
1351 case Decl::ParmVar:
1352 case Decl::Using:
1353 case Decl::UsingShadow:
1354 case Decl::UsingDirective:
1355 return LinkageInfo::none();
1356
1357 case Decl::EnumConstant:
1358 // C++ [basic.link]p4: an enumerator has the linkage of its enumeration.
1359 if (D->getASTContext().getLangOpts().CPlusPlus)
1360 return getLVForDecl(cast<EnumDecl>(D->getDeclContext()), computation);
1361 return LinkageInfo::visible_none();
1362
1363 case Decl::Typedef:
1364 case Decl::TypeAlias:
1365 // A typedef declaration has linkage if it gives a type a name for
1366 // linkage purposes.
1367 if (!cast<TypedefNameDecl>(D)
1368 ->getAnonDeclWithTypedefName(/*AnyRedecl*/true))
1369 return LinkageInfo::none();
1370 break;
1371
1372 case Decl::TemplateTemplateParm: // count these as external
1373 case Decl::NonTypeTemplateParm:
1374 case Decl::ObjCAtDefsField:
1375 case Decl::ObjCCategory:
1376 case Decl::ObjCCategoryImpl:
1377 case Decl::ObjCCompatibleAlias:
1378 case Decl::ObjCImplementation:
1379 case Decl::ObjCMethod:
1380 case Decl::ObjCProperty:
1381 case Decl::ObjCPropertyImpl:
1382 case Decl::ObjCProtocol:
1383 return getExternalLinkageFor(D);
1384
1385 case Decl::CXXRecord: {
1386 const auto *Record = cast<CXXRecordDecl>(D);
1387 if (Record->isLambda()) {
1388 if (!Record->getLambdaManglingNumber()) {
1389 // This lambda has no mangling number, so it's internal.
1390 return getInternalLinkageFor(D);
1391 }
1392
1393 // This lambda has its linkage/visibility determined:
1394 // - either by the outermost lambda if that lambda has no mangling
1395 // number.
1396 // - or by the parent of the outer most lambda
1397 // This prevents infinite recursion in settings such as nested lambdas
1398 // used in NSDMI's, for e.g.
1399 // struct L {
1400 // int t{};
1401 // int t2 = ([](int a) { return [](int b) { return b; };})(t)(t);
1402 // };
1403 const CXXRecordDecl *OuterMostLambda =
1404 getOutermostEnclosingLambda(Record);
1405 if (!OuterMostLambda->getLambdaManglingNumber())
1406 return getInternalLinkageFor(D);
1407
1408 return getLVForClosure(
1409 OuterMostLambda->getDeclContext()->getRedeclContext(),
1410 OuterMostLambda->getLambdaContextDecl(), computation);
1411 }
1412
1413 break;
1414 }
1415 }
1416
1417 // Handle linkage for namespace-scope names.
1418 if (D->getDeclContext()->getRedeclContext()->isFileContext())
1419 return getLVForNamespaceScopeDecl(D, computation, IgnoreVarTypeLinkage);
1420
1421 // C++ [basic.link]p5:
1422 // In addition, a member function, static data member, a named
1423 // class or enumeration of class scope, or an unnamed class or
1424 // enumeration defined in a class-scope typedef declaration such
1425 // that the class or enumeration has the typedef name for linkage
1426 // purposes (7.1.3), has external linkage if the name of the class
1427 // has external linkage.
1428 if (D->getDeclContext()->isRecord())
1429 return getLVForClassMember(D, computation, IgnoreVarTypeLinkage);
1430
1431 // C++ [basic.link]p6:
1432 // The name of a function declared in block scope and the name of
1433 // an object declared by a block scope extern declaration have
1434 // linkage. If there is a visible declaration of an entity with
1435 // linkage having the same name and type, ignoring entities
1436 // declared outside the innermost enclosing namespace scope, the
1437 // block scope declaration declares that same entity and receives
1438 // the linkage of the previous declaration. If there is more than
1439 // one such matching entity, the program is ill-formed. Otherwise,
1440 // if no matching entity is found, the block scope entity receives
1441 // external linkage.
1442 if (D->getDeclContext()->isFunctionOrMethod())
1443 return getLVForLocalDecl(D, computation);
1444
1445 // C++ [basic.link]p6:
1446 // Names not covered by these rules have no linkage.
1447 return LinkageInfo::none();
1448}
1449
1450/// getLVForDecl - Get the linkage and visibility for the given declaration.
1451LinkageInfo LinkageComputer::getLVForDecl(const NamedDecl *D,
1452 LVComputationKind computation) {
1453 // Internal_linkage attribute overrides other considerations.
1454 if (D->hasAttr<InternalLinkageAttr>())
1455 return getInternalLinkageFor(D);
1456
1457 if (computation.IgnoreAllVisibility && D->hasCachedLinkage())
1458 return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false);
1459
1460 if (llvm::Optional<LinkageInfo> LI = lookup(D, computation))
1461 return *LI;
1462
1463 LinkageInfo LV = computeLVForDecl(D, computation);
1464 if (D->hasCachedLinkage())
1465 assert(D->getCachedLinkage() == LV.getLinkage())((D->getCachedLinkage() == LV.getLinkage()) ? static_cast<
void> (0) : __assert_fail ("D->getCachedLinkage() == LV.getLinkage()"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1465, __PRETTY_FUNCTION__))
;
1466
1467 D->setCachedLinkage(LV.getLinkage());
1468 cache(D, computation, LV);
1469
1470#ifndef NDEBUG
1471 // In C (because of gnu inline) and in c++ with microsoft extensions an
1472 // static can follow an extern, so we can have two decls with different
1473 // linkages.
1474 const LangOptions &Opts = D->getASTContext().getLangOpts();
1475 if (!Opts.CPlusPlus || Opts.MicrosoftExt)
1476 return LV;
1477
1478 // We have just computed the linkage for this decl. By induction we know
1479 // that all other computed linkages match, check that the one we just
1480 // computed also does.
1481 NamedDecl *Old = nullptr;
1482 for (auto I : D->redecls()) {
1483 auto *T = cast<NamedDecl>(I);
1484 if (T == D)
1485 continue;
1486 if (!T->isInvalidDecl() && T->hasCachedLinkage()) {
1487 Old = T;
1488 break;
1489 }
1490 }
1491 assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage())((!Old || Old->getCachedLinkage() == D->getCachedLinkage
()) ? static_cast<void> (0) : __assert_fail ("!Old || Old->getCachedLinkage() == D->getCachedLinkage()"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1491, __PRETTY_FUNCTION__))
;
1492#endif
1493
1494 return LV;
1495}
1496
1497LinkageInfo LinkageComputer::getDeclLinkageAndVisibility(const NamedDecl *D) {
1498 return getLVForDecl(D,
1499 LVComputationKind(usesTypeVisibility(D)
1500 ? NamedDecl::VisibilityForType
1501 : NamedDecl::VisibilityForValue));
1502}
1503
1504Module *Decl::getOwningModuleForLinkage(bool IgnoreLinkage) const {
1505 Module *M = getOwningModule();
1506 if (!M)
1507 return nullptr;
1508
1509 switch (M->Kind) {
1510 case Module::ModuleMapModule:
1511 // Module map modules have no special linkage semantics.
1512 return nullptr;
1513
1514 case Module::ModuleInterfaceUnit:
1515 return M;
1516
1517 case Module::GlobalModuleFragment: {
1518 // External linkage declarations in the global module have no owning module
1519 // for linkage purposes. But internal linkage declarations in the global
1520 // module fragment of a particular module are owned by that module for
1521 // linkage purposes.
1522 if (IgnoreLinkage)
1523 return nullptr;
1524 bool InternalLinkage;
1525 if (auto *ND = dyn_cast<NamedDecl>(this))
1526 InternalLinkage = !ND->hasExternalFormalLinkage();
1527 else {
1528 auto *NSD = dyn_cast<NamespaceDecl>(this);
1529 InternalLinkage = (NSD && NSD->isAnonymousNamespace()) ||
1530 isInAnonymousNamespace();
1531 }
1532 return InternalLinkage ? M->Parent : nullptr;
1533 }
1534
1535 case Module::PrivateModuleFragment:
1536 // The private module fragment is part of its containing module for linkage
1537 // purposes.
1538 return M->Parent;
1539 }
1540
1541 llvm_unreachable("unknown module kind")::llvm::llvm_unreachable_internal("unknown module kind", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1541)
;
1542}
1543
1544void NamedDecl::printName(raw_ostream &os) const {
1545 os << Name;
1546}
1547
1548std::string NamedDecl::getQualifiedNameAsString() const {
1549 std::string QualName;
1550 llvm::raw_string_ostream OS(QualName);
1551 printQualifiedName(OS, getASTContext().getPrintingPolicy());
1552 return OS.str();
1553}
1554
1555void NamedDecl::printQualifiedName(raw_ostream &OS) const {
1556 printQualifiedName(OS, getASTContext().getPrintingPolicy());
1557}
1558
1559void NamedDecl::printQualifiedName(raw_ostream &OS,
1560 const PrintingPolicy &P) const {
1561 const DeclContext *Ctx = getDeclContext();
1562
1563 // For ObjC methods and properties, look through categories and use the
1564 // interface as context.
1565 if (auto *MD = dyn_cast<ObjCMethodDecl>(this))
1566 if (auto *ID = MD->getClassInterface())
1567 Ctx = ID;
1568 if (auto *PD = dyn_cast<ObjCPropertyDecl>(this)) {
1569 if (auto *MD = PD->getGetterMethodDecl())
1570 if (auto *ID = MD->getClassInterface())
1571 Ctx = ID;
1572 }
1573
1574 if (Ctx->isFunctionOrMethod()) {
1575 printName(OS);
1576 return;
1577 }
1578
1579 using ContextsTy = SmallVector<const DeclContext *, 8>;
1580 ContextsTy Contexts;
1581
1582 // Collect named contexts.
1583 while (Ctx) {
1584 if (isa<NamedDecl>(Ctx))
1585 Contexts.push_back(Ctx);
1586 Ctx = Ctx->getParent();
1587 }
1588
1589 for (const DeclContext *DC : llvm::reverse(Contexts)) {
1590 if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1591 OS << Spec->getName();
1592 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1593 printTemplateArgumentList(OS, TemplateArgs.asArray(), P);
1594 } else if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
1595 if (P.SuppressUnwrittenScope &&
1596 (ND->isAnonymousNamespace() || ND->isInline()))
1597 continue;
1598 if (ND->isAnonymousNamespace()) {
1599 OS << (P.MSVCFormatting ? "`anonymous namespace\'"
1600 : "(anonymous namespace)");
1601 }
1602 else
1603 OS << *ND;
1604 } else if (const auto *RD = dyn_cast<RecordDecl>(DC)) {
1605 if (!RD->getIdentifier())
1606 OS << "(anonymous " << RD->getKindName() << ')';
1607 else
1608 OS << *RD;
1609 } else if (const auto *FD = dyn_cast<FunctionDecl>(DC)) {
1610 const FunctionProtoType *FT = nullptr;
1611 if (FD->hasWrittenPrototype())
1612 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>());
1613
1614 OS << *FD << '(';
1615 if (FT) {
1616 unsigned NumParams = FD->getNumParams();
1617 for (unsigned i = 0; i < NumParams; ++i) {
1618 if (i)
1619 OS << ", ";
1620 OS << FD->getParamDecl(i)->getType().stream(P);
1621 }
1622
1623 if (FT->isVariadic()) {
1624 if (NumParams > 0)
1625 OS << ", ";
1626 OS << "...";
1627 }
1628 }
1629 OS << ')';
1630 } else if (const auto *ED = dyn_cast<EnumDecl>(DC)) {
1631 // C++ [dcl.enum]p10: Each enum-name and each unscoped
1632 // enumerator is declared in the scope that immediately contains
1633 // the enum-specifier. Each scoped enumerator is declared in the
1634 // scope of the enumeration.
1635 // For the case of unscoped enumerator, do not include in the qualified
1636 // name any information about its enum enclosing scope, as its visibility
1637 // is global.
1638 if (ED->isScoped())
1639 OS << *ED;
1640 else
1641 continue;
1642 } else {
1643 OS << *cast<NamedDecl>(DC);
1644 }
1645 OS << "::";
1646 }
1647
1648 if (getDeclName() || isa<DecompositionDecl>(this))
1649 OS << *this;
1650 else
1651 OS << "(anonymous)";
1652}
1653
1654void NamedDecl::getNameForDiagnostic(raw_ostream &OS,
1655 const PrintingPolicy &Policy,
1656 bool Qualified) const {
1657 if (Qualified)
1658 printQualifiedName(OS, Policy);
1659 else
1660 printName(OS);
1661}
1662
1663template<typename T> static bool isRedeclarableImpl(Redeclarable<T> *) {
1664 return true;
1665}
1666static bool isRedeclarableImpl(...) { return false; }
1667static bool isRedeclarable(Decl::Kind K) {
1668 switch (K) {
1669#define DECL(Type, Base) \
1670 case Decl::Type: \
1671 return isRedeclarableImpl((Type##Decl *)nullptr);
1672#define ABSTRACT_DECL(DECL)
1673#include "clang/AST/DeclNodes.inc"
1674 }
1675 llvm_unreachable("unknown decl kind")::llvm::llvm_unreachable_internal("unknown decl kind", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1675)
;
1676}
1677
1678bool NamedDecl::declarationReplaces(NamedDecl *OldD, bool IsKnownNewer) const {
1679 assert(getDeclName() == OldD->getDeclName() && "Declaration name mismatch")((getDeclName() == OldD->getDeclName() && "Declaration name mismatch"
) ? static_cast<void> (0) : __assert_fail ("getDeclName() == OldD->getDeclName() && \"Declaration name mismatch\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1679, __PRETTY_FUNCTION__))
;
1680
1681 // Never replace one imported declaration with another; we need both results
1682 // when re-exporting.
1683 if (OldD->isFromASTFile() && isFromASTFile())
1684 return false;
1685
1686 // A kind mismatch implies that the declaration is not replaced.
1687 if (OldD->getKind() != getKind())
1688 return false;
1689
1690 // For method declarations, we never replace. (Why?)
1691 if (isa<ObjCMethodDecl>(this))
1692 return false;
1693
1694 // For parameters, pick the newer one. This is either an error or (in
1695 // Objective-C) permitted as an extension.
1696 if (isa<ParmVarDecl>(this))
1697 return true;
1698
1699 // Inline namespaces can give us two declarations with the same
1700 // name and kind in the same scope but different contexts; we should
1701 // keep both declarations in this case.
1702 if (!this->getDeclContext()->getRedeclContext()->Equals(
1703 OldD->getDeclContext()->getRedeclContext()))
1704 return false;
1705
1706 // Using declarations can be replaced if they import the same name from the
1707 // same context.
1708 if (auto *UD = dyn_cast<UsingDecl>(this)) {
1709 ASTContext &Context = getASTContext();
1710 return Context.getCanonicalNestedNameSpecifier(UD->getQualifier()) ==
1711 Context.getCanonicalNestedNameSpecifier(
1712 cast<UsingDecl>(OldD)->getQualifier());
1713 }
1714 if (auto *UUVD = dyn_cast<UnresolvedUsingValueDecl>(this)) {
1715 ASTContext &Context = getASTContext();
1716 return Context.getCanonicalNestedNameSpecifier(UUVD->getQualifier()) ==
1717 Context.getCanonicalNestedNameSpecifier(
1718 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1719 }
1720
1721 if (isRedeclarable(getKind())) {
1722 if (getCanonicalDecl() != OldD->getCanonicalDecl())
1723 return false;
1724
1725 if (IsKnownNewer)
1726 return true;
1727
1728 // Check whether this is actually newer than OldD. We want to keep the
1729 // newer declaration. This loop will usually only iterate once, because
1730 // OldD is usually the previous declaration.
1731 for (auto D : redecls()) {
1732 if (D == OldD)
1733 break;
1734
1735 // If we reach the canonical declaration, then OldD is not actually older
1736 // than this one.
1737 //
1738 // FIXME: In this case, we should not add this decl to the lookup table.
1739 if (D->isCanonicalDecl())
1740 return false;
1741 }
1742
1743 // It's a newer declaration of the same kind of declaration in the same
1744 // scope: we want this decl instead of the existing one.
1745 return true;
1746 }
1747
1748 // In all other cases, we need to keep both declarations in case they have
1749 // different visibility. Any attempt to use the name will result in an
1750 // ambiguity if more than one is visible.
1751 return false;
1752}
1753
1754bool NamedDecl::hasLinkage() const {
1755 return getFormalLinkage() != NoLinkage;
1756}
1757
1758NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
1759 NamedDecl *ND = this;
1760 while (auto *UD = dyn_cast<UsingShadowDecl>(ND))
1761 ND = UD->getTargetDecl();
1762
1763 if (auto *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1764 return AD->getClassInterface();
1765
1766 if (auto *AD = dyn_cast<NamespaceAliasDecl>(ND))
1767 return AD->getNamespace();
1768
1769 return ND;
1770}
1771
1772bool NamedDecl::isCXXInstanceMember() const {
1773 if (!isCXXClassMember())
1774 return false;
1775
1776 const NamedDecl *D = this;
1777 if (isa<UsingShadowDecl>(D))
1778 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1779
1780 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
1781 return true;
1782 if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()))
1783 return MD->isInstance();
1784 return false;
1785}
1786
1787//===----------------------------------------------------------------------===//
1788// DeclaratorDecl Implementation
1789//===----------------------------------------------------------------------===//
1790
1791template <typename DeclT>
1792static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl) {
1793 if (decl->getNumTemplateParameterLists() > 0)
1794 return decl->getTemplateParameterList(0)->getTemplateLoc();
1795 else
1796 return decl->getInnerLocStart();
1797}
1798
1799SourceLocation DeclaratorDecl::getTypeSpecStartLoc() const {
1800 TypeSourceInfo *TSI = getTypeSourceInfo();
1801 if (TSI) return TSI->getTypeLoc().getBeginLoc();
1802 return SourceLocation();
1803}
1804
1805void DeclaratorDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) {
1806 if (QualifierLoc) {
1807 // Make sure the extended decl info is allocated.
1808 if (!hasExtInfo()) {
1809 // Save (non-extended) type source info pointer.
1810 auto *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
1811 // Allocate external info struct.
1812 DeclInfo = new (getASTContext()) ExtInfo;
1813 // Restore savedTInfo into (extended) decl info.
1814 getExtInfo()->TInfo = savedTInfo;
1815 }
1816 // Set qualifier info.
1817 getExtInfo()->QualifierLoc = QualifierLoc;
1818 } else {
1819 // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
1820 if (hasExtInfo()) {
1821 if (getExtInfo()->NumTemplParamLists == 0) {
1822 // Save type source info pointer.
1823 TypeSourceInfo *savedTInfo = getExtInfo()->TInfo;
1824 // Deallocate the extended decl info.
1825 getASTContext().Deallocate(getExtInfo());
1826 // Restore savedTInfo into (non-extended) decl info.
1827 DeclInfo = savedTInfo;
1828 }
1829 else
1830 getExtInfo()->QualifierLoc = QualifierLoc;
1831 }
1832 }
1833}
1834
1835void DeclaratorDecl::setTemplateParameterListsInfo(
1836 ASTContext &Context, ArrayRef<TemplateParameterList *> TPLists) {
1837 assert(!TPLists.empty())((!TPLists.empty()) ? static_cast<void> (0) : __assert_fail
("!TPLists.empty()", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1837, __PRETTY_FUNCTION__))
;
1838 // Make sure the extended decl info is allocated.
1839 if (!hasExtInfo()) {
1840 // Save (non-extended) type source info pointer.
1841 auto *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
1842 // Allocate external info struct.
1843 DeclInfo = new (getASTContext()) ExtInfo;
1844 // Restore savedTInfo into (extended) decl info.
1845 getExtInfo()->TInfo = savedTInfo;
1846 }
1847 // Set the template parameter lists info.
1848 getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
1849}
1850
1851SourceLocation DeclaratorDecl::getOuterLocStart() const {
1852 return getTemplateOrInnerLocStart(this);
1853}
1854
1855// Helper function: returns true if QT is or contains a type
1856// having a postfix component.
1857static bool typeIsPostfix(QualType QT) {
1858 while (true) {
1859 const Type* T = QT.getTypePtr();
1860 switch (T->getTypeClass()) {
1861 default:
1862 return false;
1863 case Type::Pointer:
1864 QT = cast<PointerType>(T)->getPointeeType();
1865 break;
1866 case Type::BlockPointer:
1867 QT = cast<BlockPointerType>(T)->getPointeeType();
1868 break;
1869 case Type::MemberPointer:
1870 QT = cast<MemberPointerType>(T)->getPointeeType();
1871 break;
1872 case Type::LValueReference:
1873 case Type::RValueReference:
1874 QT = cast<ReferenceType>(T)->getPointeeType();
1875 break;
1876 case Type::PackExpansion:
1877 QT = cast<PackExpansionType>(T)->getPattern();
1878 break;
1879 case Type::Paren:
1880 case Type::ConstantArray:
1881 case Type::DependentSizedArray:
1882 case Type::IncompleteArray:
1883 case Type::VariableArray:
1884 case Type::FunctionProto:
1885 case Type::FunctionNoProto:
1886 return true;
1887 }
1888 }
1889}
1890
1891SourceRange DeclaratorDecl::getSourceRange() const {
1892 SourceLocation RangeEnd = getLocation();
1893 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
1894 // If the declaration has no name or the type extends past the name take the
1895 // end location of the type.
1896 if (!getDeclName() || typeIsPostfix(TInfo->getType()))
1897 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
1898 }
1899 return SourceRange(getOuterLocStart(), RangeEnd);
1900}
1901
1902void QualifierInfo::setTemplateParameterListsInfo(
1903 ASTContext &Context, ArrayRef<TemplateParameterList *> TPLists) {
1904 // Free previous template parameters (if any).
1905 if (NumTemplParamLists > 0) {
1906 Context.Deallocate(TemplParamLists);
1907 TemplParamLists = nullptr;
1908 NumTemplParamLists = 0;
1909 }
1910 // Set info on matched template parameter lists (if any).
1911 if (!TPLists.empty()) {
1912 TemplParamLists = new (Context) TemplateParameterList *[TPLists.size()];
1913 NumTemplParamLists = TPLists.size();
1914 std::copy(TPLists.begin(), TPLists.end(), TemplParamLists);
1915 }
1916}
1917
1918//===----------------------------------------------------------------------===//
1919// VarDecl Implementation
1920//===----------------------------------------------------------------------===//
1921
1922const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) {
1923 switch (SC) {
1924 case SC_None: break;
1925 case SC_Auto: return "auto";
1926 case SC_Extern: return "extern";
1927 case SC_PrivateExtern: return "__private_extern__";
1928 case SC_Register: return "register";
1929 case SC_Static: return "static";
1930 }
1931
1932 llvm_unreachable("Invalid storage class")::llvm::llvm_unreachable_internal("Invalid storage class", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1932)
;
1933}
1934
1935VarDecl::VarDecl(Kind DK, ASTContext &C, DeclContext *DC,
1936 SourceLocation StartLoc, SourceLocation IdLoc,
1937 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
1938 StorageClass SC)
1939 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
1940 redeclarable_base(C) {
1941 static_assert(sizeof(VarDeclBitfields) <= sizeof(unsigned),
1942 "VarDeclBitfields too large!");
1943 static_assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned),
1944 "ParmVarDeclBitfields too large!");
1945 static_assert(sizeof(NonParmVarDeclBitfields) <= sizeof(unsigned),
1946 "NonParmVarDeclBitfields too large!");
1947 AllBits = 0;
1948 VarDeclBits.SClass = SC;
1949 // Everything else is implicitly initialized to false.
1950}
1951
1952VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC,
1953 SourceLocation StartL, SourceLocation IdL,
1954 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
1955 StorageClass S) {
1956 return new (C, DC) VarDecl(Var, C, DC, StartL, IdL, Id, T, TInfo, S);
1957}
1958
1959VarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1960 return new (C, ID)
1961 VarDecl(Var, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1962 QualType(), nullptr, SC_None);
1963}
1964
1965void VarDecl::setStorageClass(StorageClass SC) {
1966 assert(isLegalForVariable(SC))((isLegalForVariable(SC)) ? static_cast<void> (0) : __assert_fail
("isLegalForVariable(SC)", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1966, __PRETTY_FUNCTION__))
;
1967 VarDeclBits.SClass = SC;
1968}
1969
1970VarDecl::TLSKind VarDecl::getTLSKind() const {
1971 switch (VarDeclBits.TSCSpec) {
1972 case TSCS_unspecified:
1973 if (!hasAttr<ThreadAttr>() &&
1974 !(getASTContext().getLangOpts().OpenMPUseTLS &&
1975 getASTContext().getTargetInfo().isTLSSupported() &&
1976 hasAttr<OMPThreadPrivateDeclAttr>()))
1977 return TLS_None;
1978 return ((getASTContext().getLangOpts().isCompatibleWithMSVC(
1979 LangOptions::MSVC2015)) ||
1980 hasAttr<OMPThreadPrivateDeclAttr>())
1981 ? TLS_Dynamic
1982 : TLS_Static;
1983 case TSCS___thread: // Fall through.
1984 case TSCS__Thread_local:
1985 return TLS_Static;
1986 case TSCS_thread_local:
1987 return TLS_Dynamic;
1988 }
1989 llvm_unreachable("Unknown thread storage class specifier!")::llvm::llvm_unreachable_internal("Unknown thread storage class specifier!"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 1989)
;
1990}
1991
1992SourceRange VarDecl::getSourceRange() const {
1993 if (const Expr *Init = getInit()) {
1994 SourceLocation InitEnd = Init->getEndLoc();
1995 // If Init is implicit, ignore its source range and fallback on
1996 // DeclaratorDecl::getSourceRange() to handle postfix elements.
1997 if (InitEnd.isValid() && InitEnd != getLocation())
1998 return SourceRange(getOuterLocStart(), InitEnd);
1999 }
2000 return DeclaratorDecl::getSourceRange();
2001}
2002
2003template<typename T>
2004static LanguageLinkage getDeclLanguageLinkage(const T &D) {
2005 // C++ [dcl.link]p1: All function types, function names with external linkage,
2006 // and variable names with external linkage have a language linkage.
2007 if (!D.hasExternalFormalLinkage())
2008 return NoLanguageLinkage;
2009
2010 // Language linkage is a C++ concept, but saying that everything else in C has
2011 // C language linkage fits the implementation nicely.
2012 ASTContext &Context = D.getASTContext();
2013 if (!Context.getLangOpts().CPlusPlus)
2014 return CLanguageLinkage;
2015
2016 // C++ [dcl.link]p4: A C language linkage is ignored in determining the
2017 // language linkage of the names of class members and the function type of
2018 // class member functions.
2019 const DeclContext *DC = D.getDeclContext();
2020 if (DC->isRecord())
2021 return CXXLanguageLinkage;
2022
2023 // If the first decl is in an extern "C" context, any other redeclaration
2024 // will have C language linkage. If the first one is not in an extern "C"
2025 // context, we would have reported an error for any other decl being in one.
2026 if (isFirstInExternCContext(&D))
2027 return CLanguageLinkage;
2028 return CXXLanguageLinkage;
2029}
2030
2031template<typename T>
2032static bool isDeclExternC(const T &D) {
2033 // Since the context is ignored for class members, they can only have C++
2034 // language linkage or no language linkage.
2035 const DeclContext *DC = D.getDeclContext();
2036 if (DC->isRecord()) {
2037 assert(D.getASTContext().getLangOpts().CPlusPlus)((D.getASTContext().getLangOpts().CPlusPlus) ? static_cast<
void> (0) : __assert_fail ("D.getASTContext().getLangOpts().CPlusPlus"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2037, __PRETTY_FUNCTION__))
;
2038 return false;
2039 }
2040
2041 return D.getLanguageLinkage() == CLanguageLinkage;
2042}
2043
2044LanguageLinkage VarDecl::getLanguageLinkage() const {
2045 return getDeclLanguageLinkage(*this);
2046}
2047
2048bool VarDecl::isExternC() const {
2049 return isDeclExternC(*this);
2050}
2051
2052bool VarDecl::isInExternCContext() const {
2053 return getLexicalDeclContext()->isExternCContext();
2054}
2055
2056bool VarDecl::isInExternCXXContext() const {
2057 return getLexicalDeclContext()->isExternCXXContext();
2058}
2059
2060VarDecl *VarDecl::getCanonicalDecl() { return getFirstDecl(); }
2061
2062VarDecl::DefinitionKind
2063VarDecl::isThisDeclarationADefinition(ASTContext &C) const {
2064 if (isThisDeclarationADemotedDefinition())
2065 return DeclarationOnly;
2066
2067 // C++ [basic.def]p2:
2068 // A declaration is a definition unless [...] it contains the 'extern'
2069 // specifier or a linkage-specification and neither an initializer [...],
2070 // it declares a non-inline static data member in a class declaration [...],
2071 // it declares a static data member outside a class definition and the variable
2072 // was defined within the class with the constexpr specifier [...],
2073 // C++1y [temp.expl.spec]p15:
2074 // An explicit specialization of a static data member or an explicit
2075 // specialization of a static data member template is a definition if the
2076 // declaration includes an initializer; otherwise, it is a declaration.
2077 //
2078 // FIXME: How do you declare (but not define) a partial specialization of
2079 // a static data member template outside the containing class?
2080 if (isStaticDataMember()) {
2081 if (isOutOfLine() &&
2082 !(getCanonicalDecl()->isInline() &&
2083 getCanonicalDecl()->isConstexpr()) &&
2084 (hasInit() ||
2085 // If the first declaration is out-of-line, this may be an
2086 // instantiation of an out-of-line partial specialization of a variable
2087 // template for which we have not yet instantiated the initializer.
2088 (getFirstDecl()->isOutOfLine()
2089 ? getTemplateSpecializationKind() == TSK_Undeclared
2090 : getTemplateSpecializationKind() !=
2091 TSK_ExplicitSpecialization) ||
2092 isa<VarTemplatePartialSpecializationDecl>(this)))
2093 return Definition;
2094 else if (!isOutOfLine() && isInline())
2095 return Definition;
2096 else
2097 return DeclarationOnly;
2098 }
2099 // C99 6.7p5:
2100 // A definition of an identifier is a declaration for that identifier that
2101 // [...] causes storage to be reserved for that object.
2102 // Note: that applies for all non-file-scope objects.
2103 // C99 6.9.2p1:
2104 // If the declaration of an identifier for an object has file scope and an
2105 // initializer, the declaration is an external definition for the identifier
2106 if (hasInit())
2107 return Definition;
2108
2109 if (hasDefiningAttr())
2110 return Definition;
2111
2112 if (const auto *SAA = getAttr<SelectAnyAttr>())
2113 if (!SAA->isInherited())
2114 return Definition;
2115
2116 // A variable template specialization (other than a static data member
2117 // template or an explicit specialization) is a declaration until we
2118 // instantiate its initializer.
2119 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(this)) {
2120 if (VTSD->getTemplateSpecializationKind() != TSK_ExplicitSpecialization &&
2121 !isa<VarTemplatePartialSpecializationDecl>(VTSD) &&
2122 !VTSD->IsCompleteDefinition)
2123 return DeclarationOnly;
2124 }
2125
2126 if (hasExternalStorage())
2127 return DeclarationOnly;
2128
2129 // [dcl.link] p7:
2130 // A declaration directly contained in a linkage-specification is treated
2131 // as if it contains the extern specifier for the purpose of determining
2132 // the linkage of the declared name and whether it is a definition.
2133 if (isSingleLineLanguageLinkage(*this))
2134 return DeclarationOnly;
2135
2136 // C99 6.9.2p2:
2137 // A declaration of an object that has file scope without an initializer,
2138 // and without a storage class specifier or the scs 'static', constitutes
2139 // a tentative definition.
2140 // No such thing in C++.
2141 if (!C.getLangOpts().CPlusPlus && isFileVarDecl())
2142 return TentativeDefinition;
2143
2144 // What's left is (in C, block-scope) declarations without initializers or
2145 // external storage. These are definitions.
2146 return Definition;
2147}
2148
2149VarDecl *VarDecl::getActingDefinition() {
2150 DefinitionKind Kind = isThisDeclarationADefinition();
2151 if (Kind != TentativeDefinition)
2152 return nullptr;
2153
2154 VarDecl *LastTentative = nullptr;
2155 VarDecl *First = getFirstDecl();
2156 for (auto I : First->redecls()) {
2157 Kind = I->isThisDeclarationADefinition();
2158 if (Kind == Definition)
2159 return nullptr;
2160 else if (Kind == TentativeDefinition)
2161 LastTentative = I;
2162 }
2163 return LastTentative;
2164}
2165
2166VarDecl *VarDecl::getDefinition(ASTContext &C) {
2167 VarDecl *First = getFirstDecl();
2168 for (auto I : First->redecls()) {
2169 if (I->isThisDeclarationADefinition(C) == Definition)
2170 return I;
2171 }
2172 return nullptr;
2173}
2174
2175VarDecl::DefinitionKind VarDecl::hasDefinition(ASTContext &C) const {
2176 DefinitionKind Kind = DeclarationOnly;
2177
2178 const VarDecl *First = getFirstDecl();
2179 for (auto I : First->redecls()) {
2180 Kind = std::max(Kind, I->isThisDeclarationADefinition(C));
2181 if (Kind == Definition)
2182 break;
2183 }
2184
2185 return Kind;
2186}
2187
2188const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const {
2189 for (auto I : redecls()) {
2190 if (auto Expr = I->getInit()) {
2191 D = I;
2192 return Expr;
2193 }
2194 }
2195 return nullptr;
2196}
2197
2198bool VarDecl::hasInit() const {
2199 if (auto *P = dyn_cast<ParmVarDecl>(this))
2200 if (P->hasUnparsedDefaultArg() || P->hasUninstantiatedDefaultArg())
2201 return false;
2202
2203 return !Init.isNull();
2204}
2205
2206Expr *VarDecl::getInit() {
2207 if (!hasInit())
2208 return nullptr;
2209
2210 if (auto *S = Init.dyn_cast<Stmt *>())
2211 return cast<Expr>(S);
2212
2213 return cast_or_null<Expr>(Init.get<EvaluatedStmt *>()->Value);
2214}
2215
2216Stmt **VarDecl::getInitAddress() {
2217 if (auto *ES = Init.dyn_cast<EvaluatedStmt *>())
2218 return &ES->Value;
2219
2220 return Init.getAddrOfPtr1();
2221}
2222
2223bool VarDecl::isOutOfLine() const {
2224 if (Decl::isOutOfLine())
2225 return true;
2226
2227 if (!isStaticDataMember())
2228 return false;
2229
2230 // If this static data member was instantiated from a static data member of
2231 // a class template, check whether that static data member was defined
2232 // out-of-line.
2233 if (VarDecl *VD = getInstantiatedFromStaticDataMember())
2234 return VD->isOutOfLine();
2235
2236 return false;
2237}
2238
2239void VarDecl::setInit(Expr *I) {
2240 if (auto *Eval = Init.dyn_cast<EvaluatedStmt *>()) {
2241 Eval->~EvaluatedStmt();
2242 getASTContext().Deallocate(Eval);
2243 }
2244
2245 Init = I;
2246}
2247
2248bool VarDecl::isUsableInConstantExpressions(ASTContext &C) const {
2249 const LangOptions &Lang = C.getLangOpts();
2250
2251 if (!Lang.CPlusPlus)
2252 return false;
2253
2254 // In C++11, any variable of reference type can be used in a constant
2255 // expression if it is initialized by a constant expression.
2256 if (Lang.CPlusPlus11 && getType()->isReferenceType())
2257 return true;
2258
2259 // Only const objects can be used in constant expressions in C++. C++98 does
2260 // not require the variable to be non-volatile, but we consider this to be a
2261 // defect.
2262 if (!getType().isConstQualified() || getType().isVolatileQualified())
2263 return false;
2264
2265 // In C++, const, non-volatile variables of integral or enumeration types
2266 // can be used in constant expressions.
2267 if (getType()->isIntegralOrEnumerationType())
2268 return true;
2269
2270 // Additionally, in C++11, non-volatile constexpr variables can be used in
2271 // constant expressions.
2272 return Lang.CPlusPlus11 && isConstexpr();
2273}
2274
2275/// Convert the initializer for this declaration to the elaborated EvaluatedStmt
2276/// form, which contains extra information on the evaluated value of the
2277/// initializer.
2278EvaluatedStmt *VarDecl::ensureEvaluatedStmt() const {
2279 auto *Eval = Init.dyn_cast<EvaluatedStmt *>();
2280 if (!Eval) {
2281 // Note: EvaluatedStmt contains an APValue, which usually holds
2282 // resources not allocated from the ASTContext. We need to do some
2283 // work to avoid leaking those, but we do so in VarDecl::evaluateValue
2284 // where we can detect whether there's anything to clean up or not.
2285 Eval = new (getASTContext()) EvaluatedStmt;
2286 Eval->Value = Init.get<Stmt *>();
2287 Init = Eval;
2288 }
2289 return Eval;
2290}
2291
2292APValue *VarDecl::evaluateValue() const {
2293 SmallVector<PartialDiagnosticAt, 8> Notes;
2294 return evaluateValue(Notes);
2295}
2296
2297APValue *VarDecl::evaluateValue(
2298 SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
2299 EvaluatedStmt *Eval = ensureEvaluatedStmt();
2300
2301 // We only produce notes indicating why an initializer is non-constant the
2302 // first time it is evaluated. FIXME: The notes won't always be emitted the
2303 // first time we try evaluation, so might not be produced at all.
2304 if (Eval->WasEvaluated)
2305 return Eval->Evaluated.isAbsent() ? nullptr : &Eval->Evaluated;
2306
2307 const auto *Init = cast<Expr>(Eval->Value);
2308 assert(!Init->isValueDependent())((!Init->isValueDependent()) ? static_cast<void> (0)
: __assert_fail ("!Init->isValueDependent()", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2308, __PRETTY_FUNCTION__))
;
2309
2310 if (Eval->IsEvaluating) {
2311 // FIXME: Produce a diagnostic for self-initialization.
2312 Eval->CheckedICE = true;
2313 Eval->IsICE = false;
2314 return nullptr;
2315 }
2316
2317 Eval->IsEvaluating = true;
2318
2319 bool Result = Init->EvaluateAsInitializer(Eval->Evaluated, getASTContext(),
2320 this, Notes);
2321
2322 // Ensure the computed APValue is cleaned up later if evaluation succeeded,
2323 // or that it's empty (so that there's nothing to clean up) if evaluation
2324 // failed.
2325 if (!Result)
2326 Eval->Evaluated = APValue();
2327 else if (Eval->Evaluated.needsCleanup())
2328 getASTContext().addDestruction(&Eval->Evaluated);
2329
2330 Eval->IsEvaluating = false;
2331 Eval->WasEvaluated = true;
2332
2333 // In C++11, we have determined whether the initializer was a constant
2334 // expression as a side-effect.
2335 if (getASTContext().getLangOpts().CPlusPlus11 && !Eval->CheckedICE) {
2336 Eval->CheckedICE = true;
2337 Eval->IsICE = Result && Notes.empty();
2338 }
2339
2340 return Result ? &Eval->Evaluated : nullptr;
2341}
2342
2343APValue *VarDecl::getEvaluatedValue() const {
2344 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>())
2345 if (Eval->WasEvaluated)
2346 return &Eval->Evaluated;
2347
2348 return nullptr;
2349}
2350
2351bool VarDecl::isInitKnownICE() const {
2352 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>())
2353 return Eval->CheckedICE;
2354
2355 return false;
2356}
2357
2358bool VarDecl::isInitICE() const {
2359 assert(isInitKnownICE() &&((isInitKnownICE() && "Check whether we already know that the initializer is an ICE"
) ? static_cast<void> (0) : __assert_fail ("isInitKnownICE() && \"Check whether we already know that the initializer is an ICE\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2360, __PRETTY_FUNCTION__))
2360 "Check whether we already know that the initializer is an ICE")((isInitKnownICE() && "Check whether we already know that the initializer is an ICE"
) ? static_cast<void> (0) : __assert_fail ("isInitKnownICE() && \"Check whether we already know that the initializer is an ICE\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2360, __PRETTY_FUNCTION__))
;
2361 return Init.get<EvaluatedStmt *>()->IsICE;
2362}
2363
2364bool VarDecl::checkInitIsICE() const {
2365 // Initializers of weak variables are never ICEs.
2366 if (isWeak())
2367 return false;
2368
2369 EvaluatedStmt *Eval = ensureEvaluatedStmt();
2370 if (Eval->CheckedICE)
2371 // We have already checked whether this subexpression is an
2372 // integral constant expression.
2373 return Eval->IsICE;
2374
2375 const auto *Init = cast<Expr>(Eval->Value);
2376 assert(!Init->isValueDependent())((!Init->isValueDependent()) ? static_cast<void> (0)
: __assert_fail ("!Init->isValueDependent()", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2376, __PRETTY_FUNCTION__))
;
2377
2378 // In C++11, evaluate the initializer to check whether it's a constant
2379 // expression.
2380 if (getASTContext().getLangOpts().CPlusPlus11) {
2381 SmallVector<PartialDiagnosticAt, 8> Notes;
2382 evaluateValue(Notes);
2383 return Eval->IsICE;
2384 }
2385
2386 // It's an ICE whether or not the definition we found is
2387 // out-of-line. See DR 721 and the discussion in Clang PR
2388 // 6206 for details.
2389
2390 if (Eval->CheckingICE)
2391 return false;
2392 Eval->CheckingICE = true;
2393
2394 Eval->IsICE = Init->isIntegerConstantExpr(getASTContext());
2395 Eval->CheckingICE = false;
2396 Eval->CheckedICE = true;
2397 return Eval->IsICE;
2398}
2399
2400bool VarDecl::isParameterPack() const {
2401 return isa<PackExpansionType>(getType());
2402}
2403
2404template<typename DeclT>
2405static DeclT *getDefinitionOrSelf(DeclT *D) {
2406 assert(D)((D) ? static_cast<void> (0) : __assert_fail ("D", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2406, __PRETTY_FUNCTION__))
;
2407 if (auto *Def = D->getDefinition())
2408 return Def;
2409 return D;
2410}
2411
2412bool VarDecl::isEscapingByref() const {
2413 return hasAttr<BlocksAttr>() && NonParmVarDeclBits.EscapingByref;
2414}
2415
2416bool VarDecl::isNonEscapingByref() const {
2417 return hasAttr<BlocksAttr>() && !NonParmVarDeclBits.EscapingByref;
2418}
2419
2420VarDecl *VarDecl::getTemplateInstantiationPattern() const {
2421 const VarDecl *VD = this;
2422
2423 // If this is an instantiated member, walk back to the template from which
2424 // it was instantiated.
2425 if (MemberSpecializationInfo *MSInfo = VD->getMemberSpecializationInfo()) {
2426 if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
2427 VD = VD->getInstantiatedFromStaticDataMember();
2428 while (auto *NewVD = VD->getInstantiatedFromStaticDataMember())
2429 VD = NewVD;
2430 }
2431 }
2432
2433 // If it's an instantiated variable template specialization, find the
2434 // template or partial specialization from which it was instantiated.
2435 if (auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2436 if (isTemplateInstantiation(VDTemplSpec->getTemplateSpecializationKind())) {
2437 auto From = VDTemplSpec->getInstantiatedFrom();
2438 if (auto *VTD = From.dyn_cast<VarTemplateDecl *>()) {
2439 while (!VTD->isMemberSpecialization()) {
2440 auto *NewVTD = VTD->getInstantiatedFromMemberTemplate();
2441 if (!NewVTD)
2442 break;
2443 VTD = NewVTD;
2444 }
2445 return getDefinitionOrSelf(VTD->getTemplatedDecl());
2446 }
2447 if (auto *VTPSD =
2448 From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
2449 while (!VTPSD->isMemberSpecialization()) {
2450 auto *NewVTPSD = VTPSD->getInstantiatedFromMember();
2451 if (!NewVTPSD)
2452 break;
2453 VTPSD = NewVTPSD;
2454 }
2455 return getDefinitionOrSelf<VarDecl>(VTPSD);
2456 }
2457 }
2458 }
2459
2460 // If this is the pattern of a variable template, find where it was
2461 // instantiated from. FIXME: Is this necessary?
2462 if (VarTemplateDecl *VarTemplate = VD->getDescribedVarTemplate()) {
2463 while (!VarTemplate->isMemberSpecialization()) {
2464 auto *NewVT = VarTemplate->getInstantiatedFromMemberTemplate();
2465 if (!NewVT)
2466 break;
2467 VarTemplate = NewVT;
2468 }
2469
2470 return getDefinitionOrSelf(VarTemplate->getTemplatedDecl());
2471 }
2472
2473 if (VD == this)
2474 return nullptr;
2475 return getDefinitionOrSelf(const_cast<VarDecl*>(VD));
2476}
2477
2478VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const {
2479 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2480 return cast<VarDecl>(MSI->getInstantiatedFrom());
2481
2482 return nullptr;
2483}
2484
2485TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const {
2486 if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2487 return Spec->getSpecializationKind();
2488
2489 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2490 return MSI->getTemplateSpecializationKind();
2491
2492 return TSK_Undeclared;
2493}
2494
2495TemplateSpecializationKind
2496VarDecl::getTemplateSpecializationKindForInstantiation() const {
2497 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2498 return MSI->getTemplateSpecializationKind();
2499
2500 if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2501 return Spec->getSpecializationKind();
2502
2503 return TSK_Undeclared;
2504}
2505
2506SourceLocation VarDecl::getPointOfInstantiation() const {
2507 if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2508 return Spec->getPointOfInstantiation();
2509
2510 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2511 return MSI->getPointOfInstantiation();
2512
2513 return SourceLocation();
2514}
2515
2516VarTemplateDecl *VarDecl::getDescribedVarTemplate() const {
2517 return getASTContext().getTemplateOrSpecializationInfo(this)
2518 .dyn_cast<VarTemplateDecl *>();
2519}
2520
2521void VarDecl::setDescribedVarTemplate(VarTemplateDecl *Template) {
2522 getASTContext().setTemplateOrSpecializationInfo(this, Template);
2523}
2524
2525bool VarDecl::isKnownToBeDefined() const {
2526 const auto &LangOpts = getASTContext().getLangOpts();
2527 // In CUDA mode without relocatable device code, variables of form 'extern
2528 // __shared__ Foo foo[]' are pointers to the base of the GPU core's shared
2529 // memory pool. These are never undefined variables, even if they appear
2530 // inside of an anon namespace or static function.
2531 //
2532 // With CUDA relocatable device code enabled, these variables don't get
2533 // special handling; they're treated like regular extern variables.
2534 if (LangOpts.CUDA && !LangOpts.GPURelocatableDeviceCode &&
2535 hasExternalStorage() && hasAttr<CUDASharedAttr>() &&
2536 isa<IncompleteArrayType>(getType()))
2537 return true;
2538
2539 return hasDefinition();
2540}
2541
2542bool VarDecl::isNoDestroy(const ASTContext &Ctx) const {
2543 return hasGlobalStorage() && (hasAttr<NoDestroyAttr>() ||
2544 (!Ctx.getLangOpts().RegisterStaticDestructors &&
2545 !hasAttr<AlwaysDestroyAttr>()));
2546}
2547
2548MemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const {
2549 if (isStaticDataMember())
2550 // FIXME: Remove ?
2551 // return getASTContext().getInstantiatedFromStaticDataMember(this);
2552 return getASTContext().getTemplateOrSpecializationInfo(this)
2553 .dyn_cast<MemberSpecializationInfo *>();
2554 return nullptr;
2555}
2556
2557void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2558 SourceLocation PointOfInstantiation) {
2559 assert((isa<VarTemplateSpecializationDecl>(this) ||(((isa<VarTemplateSpecializationDecl>(this) || getMemberSpecializationInfo
()) && "not a variable or static data member template specialization"
) ? static_cast<void> (0) : __assert_fail ("(isa<VarTemplateSpecializationDecl>(this) || getMemberSpecializationInfo()) && \"not a variable or static data member template specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2561, __PRETTY_FUNCTION__))
2560 getMemberSpecializationInfo()) &&(((isa<VarTemplateSpecializationDecl>(this) || getMemberSpecializationInfo
()) && "not a variable or static data member template specialization"
) ? static_cast<void> (0) : __assert_fail ("(isa<VarTemplateSpecializationDecl>(this) || getMemberSpecializationInfo()) && \"not a variable or static data member template specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2561, __PRETTY_FUNCTION__))
2561 "not a variable or static data member template specialization")(((isa<VarTemplateSpecializationDecl>(this) || getMemberSpecializationInfo
()) && "not a variable or static data member template specialization"
) ? static_cast<void> (0) : __assert_fail ("(isa<VarTemplateSpecializationDecl>(this) || getMemberSpecializationInfo()) && \"not a variable or static data member template specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2561, __PRETTY_FUNCTION__))
;
2562
2563 if (VarTemplateSpecializationDecl *Spec =
2564 dyn_cast<VarTemplateSpecializationDecl>(this)) {
2565 Spec->setSpecializationKind(TSK);
2566 if (TSK != TSK_ExplicitSpecialization &&
2567 PointOfInstantiation.isValid() &&
2568 Spec->getPointOfInstantiation().isInvalid()) {
2569 Spec->setPointOfInstantiation(PointOfInstantiation);
2570 if (ASTMutationListener *L = getASTContext().getASTMutationListener())
2571 L->InstantiationRequested(this);
2572 }
2573 } else if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) {
2574 MSI->setTemplateSpecializationKind(TSK);
2575 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
2576 MSI->getPointOfInstantiation().isInvalid()) {
2577 MSI->setPointOfInstantiation(PointOfInstantiation);
2578 if (ASTMutationListener *L = getASTContext().getASTMutationListener())
2579 L->InstantiationRequested(this);
2580 }
2581 }
2582}
2583
2584void
2585VarDecl::setInstantiationOfStaticDataMember(VarDecl *VD,
2586 TemplateSpecializationKind TSK) {
2587 assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() &&((getASTContext().getTemplateOrSpecializationInfo(this).isNull
() && "Previous template or instantiation?") ? static_cast
<void> (0) : __assert_fail ("getASTContext().getTemplateOrSpecializationInfo(this).isNull() && \"Previous template or instantiation?\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2588, __PRETTY_FUNCTION__))
2588 "Previous template or instantiation?")((getASTContext().getTemplateOrSpecializationInfo(this).isNull
() && "Previous template or instantiation?") ? static_cast
<void> (0) : __assert_fail ("getASTContext().getTemplateOrSpecializationInfo(this).isNull() && \"Previous template or instantiation?\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2588, __PRETTY_FUNCTION__))
;
2589 getASTContext().setInstantiatedFromStaticDataMember(this, VD, TSK);
2590}
2591
2592//===----------------------------------------------------------------------===//
2593// ParmVarDecl Implementation
2594//===----------------------------------------------------------------------===//
2595
2596ParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC,
2597 SourceLocation StartLoc,
2598 SourceLocation IdLoc, IdentifierInfo *Id,
2599 QualType T, TypeSourceInfo *TInfo,
2600 StorageClass S, Expr *DefArg) {
2601 return new (C, DC) ParmVarDecl(ParmVar, C, DC, StartLoc, IdLoc, Id, T, TInfo,
2602 S, DefArg);
2603}
2604
2605QualType ParmVarDecl::getOriginalType() const {
2606 TypeSourceInfo *TSI = getTypeSourceInfo();
2607 QualType T = TSI ? TSI->getType() : getType();
2608 if (const auto *DT = dyn_cast<DecayedType>(T))
2609 return DT->getOriginalType();
2610 return T;
2611}
2612
2613ParmVarDecl *ParmVarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2614 return new (C, ID)
2615 ParmVarDecl(ParmVar, C, nullptr, SourceLocation(), SourceLocation(),
2616 nullptr, QualType(), nullptr, SC_None, nullptr);
2617}
2618
2619SourceRange ParmVarDecl::getSourceRange() const {
2620 if (!hasInheritedDefaultArg()) {
2621 SourceRange ArgRange = getDefaultArgRange();
2622 if (ArgRange.isValid())
2623 return SourceRange(getOuterLocStart(), ArgRange.getEnd());
2624 }
2625
2626 // DeclaratorDecl considers the range of postfix types as overlapping with the
2627 // declaration name, but this is not the case with parameters in ObjC methods.
2628 if (isa<ObjCMethodDecl>(getDeclContext()))
2629 return SourceRange(DeclaratorDecl::getBeginLoc(), getLocation());
2630
2631 return DeclaratorDecl::getSourceRange();
2632}
2633
2634Expr *ParmVarDecl::getDefaultArg() {
2635 assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!")((!hasUnparsedDefaultArg() && "Default argument is not yet parsed!"
) ? static_cast<void> (0) : __assert_fail ("!hasUnparsedDefaultArg() && \"Default argument is not yet parsed!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2635, __PRETTY_FUNCTION__))
;
2636 assert(!hasUninstantiatedDefaultArg() &&((!hasUninstantiatedDefaultArg() && "Default argument is not yet instantiated!"
) ? static_cast<void> (0) : __assert_fail ("!hasUninstantiatedDefaultArg() && \"Default argument is not yet instantiated!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2637, __PRETTY_FUNCTION__))
2637 "Default argument is not yet instantiated!")((!hasUninstantiatedDefaultArg() && "Default argument is not yet instantiated!"
) ? static_cast<void> (0) : __assert_fail ("!hasUninstantiatedDefaultArg() && \"Default argument is not yet instantiated!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2637, __PRETTY_FUNCTION__))
;
2638
2639 Expr *Arg = getInit();
2640 if (auto *E = dyn_cast_or_null<FullExpr>(Arg))
2641 return E->getSubExpr();
2642
2643 return Arg;
2644}
2645
2646void ParmVarDecl::setDefaultArg(Expr *defarg) {
2647 ParmVarDeclBits.DefaultArgKind = DAK_Normal;
2648 Init = defarg;
2649}
2650
2651SourceRange ParmVarDecl::getDefaultArgRange() const {
2652 switch (ParmVarDeclBits.DefaultArgKind) {
2653 case DAK_None:
2654 case DAK_Unparsed:
2655 // Nothing we can do here.
2656 return SourceRange();
2657
2658 case DAK_Uninstantiated:
2659 return getUninstantiatedDefaultArg()->getSourceRange();
2660
2661 case DAK_Normal:
2662 if (const Expr *E = getInit())
2663 return E->getSourceRange();
2664
2665 // Missing an actual expression, may be invalid.
2666 return SourceRange();
2667 }
2668 llvm_unreachable("Invalid default argument kind.")::llvm::llvm_unreachable_internal("Invalid default argument kind."
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2668)
;
2669}
2670
2671void ParmVarDecl::setUninstantiatedDefaultArg(Expr *arg) {
2672 ParmVarDeclBits.DefaultArgKind = DAK_Uninstantiated;
2673 Init = arg;
2674}
2675
2676Expr *ParmVarDecl::getUninstantiatedDefaultArg() {
2677 assert(hasUninstantiatedDefaultArg() &&((hasUninstantiatedDefaultArg() && "Wrong kind of initialization expression!"
) ? static_cast<void> (0) : __assert_fail ("hasUninstantiatedDefaultArg() && \"Wrong kind of initialization expression!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2678, __PRETTY_FUNCTION__))
2678 "Wrong kind of initialization expression!")((hasUninstantiatedDefaultArg() && "Wrong kind of initialization expression!"
) ? static_cast<void> (0) : __assert_fail ("hasUninstantiatedDefaultArg() && \"Wrong kind of initialization expression!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2678, __PRETTY_FUNCTION__))
;
2679 return cast_or_null<Expr>(Init.get<Stmt *>());
2680}
2681
2682bool ParmVarDecl::hasDefaultArg() const {
2683 // FIXME: We should just return false for DAK_None here once callers are
2684 // prepared for the case that we encountered an invalid default argument and
2685 // were unable to even build an invalid expression.
2686 return hasUnparsedDefaultArg() || hasUninstantiatedDefaultArg() ||
2687 !Init.isNull();
2688}
2689
2690void ParmVarDecl::setParameterIndexLarge(unsigned parameterIndex) {
2691 getASTContext().setParameterIndex(this, parameterIndex);
2692 ParmVarDeclBits.ParameterIndex = ParameterIndexSentinel;
2693}
2694
2695unsigned ParmVarDecl::getParameterIndexLarge() const {
2696 return getASTContext().getParameterIndex(this);
2697}
2698
2699//===----------------------------------------------------------------------===//
2700// FunctionDecl Implementation
2701//===----------------------------------------------------------------------===//
2702
2703FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
2704 SourceLocation StartLoc,
2705 const DeclarationNameInfo &NameInfo, QualType T,
2706 TypeSourceInfo *TInfo, StorageClass S,
2707 bool isInlineSpecified, bool isConstexprSpecified)
2708 : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
2709 StartLoc),
2710 DeclContext(DK), redeclarable_base(C), ODRHash(0),
2711 EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {
2712 assert(T.isNull() || T->isFunctionType())((T.isNull() || T->isFunctionType()) ? static_cast<void
> (0) : __assert_fail ("T.isNull() || T->isFunctionType()"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2712, __PRETTY_FUNCTION__))
;
2713 FunctionDeclBits.SClass = S;
2714 FunctionDeclBits.IsInline = isInlineSpecified;
2715 FunctionDeclBits.IsInlineSpecified = isInlineSpecified;
2716 FunctionDeclBits.IsVirtualAsWritten = false;
2717 FunctionDeclBits.IsPure = false;
2718 FunctionDeclBits.HasInheritedPrototype = false;
2719 FunctionDeclBits.HasWrittenPrototype = true;
2720 FunctionDeclBits.IsDeleted = false;
2721 FunctionDeclBits.IsTrivial = false;
2722 FunctionDeclBits.IsTrivialForCall = false;
2723 FunctionDeclBits.IsDefaulted = false;
2724 FunctionDeclBits.IsExplicitlyDefaulted = false;
2725 FunctionDeclBits.HasImplicitReturnZero = false;
2726 FunctionDeclBits.IsLateTemplateParsed = false;
2727 FunctionDeclBits.IsConstexpr = isConstexprSpecified;
2728 FunctionDeclBits.InstantiationIsPending = false;
2729 FunctionDeclBits.UsesSEHTry = false;
2730 FunctionDeclBits.HasSkippedBody = false;
2731 FunctionDeclBits.WillHaveBody = false;
2732 FunctionDeclBits.IsMultiVersion = false;
2733 FunctionDeclBits.IsCopyDeductionCandidate = false;
2734 FunctionDeclBits.HasODRHash = false;
2735}
2736
2737void FunctionDecl::getNameForDiagnostic(
2738 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
2739 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
2740 const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs();
2741 if (TemplateArgs)
2742 printTemplateArgumentList(OS, TemplateArgs->asArray(), Policy);
2743}
2744
2745bool FunctionDecl::isVariadic() const {
2746 if (const auto *FT = getType()->getAs<FunctionProtoType>())
2747 return FT->isVariadic();
2748 return false;
2749}
2750
2751bool FunctionDecl::hasBody(const FunctionDecl *&Definition) const {
2752 for (auto I : redecls()) {
2753 if (I->doesThisDeclarationHaveABody()) {
2754 Definition = I;
2755 return true;
2756 }
2757 }
2758
2759 return false;
2760}
2761
2762bool FunctionDecl::hasTrivialBody() const
2763{
2764 Stmt *S = getBody();
2765 if (!S) {
2766 // Since we don't have a body for this function, we don't know if it's
2767 // trivial or not.
2768 return false;
2769 }
2770
2771 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
2772 return true;
2773 return false;
2774}
2775
2776bool FunctionDecl::isDefined(const FunctionDecl *&Definition) const {
2777 for (auto I : redecls()) {
2778 if (I->isThisDeclarationADefinition()) {
2779 Definition = I;
2780 return true;
2781 }
2782 }
2783
2784 return false;
2785}
2786
2787Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const {
2788 if (!hasBody(Definition))
2789 return nullptr;
2790
2791 if (Definition->Body)
2792 return Definition->Body.get(getASTContext().getExternalSource());
2793
2794 return nullptr;
2795}
2796
2797void FunctionDecl::setBody(Stmt *B) {
2798 Body = B;
2799 if (B)
2800 EndRangeLoc = B->getEndLoc();
2801}
2802
2803void FunctionDecl::setPure(bool P) {
2804 FunctionDeclBits.IsPure = P;
2805 if (P)
2806 if (auto *Parent = dyn_cast<CXXRecordDecl>(getDeclContext()))
2807 Parent->markedVirtualFunctionPure();
2808}
2809
2810template<std::size_t Len>
2811static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) {
2812 IdentifierInfo *II = ND->getIdentifier();
2813 return II && II->isStr(Str);
2814}
2815
2816bool FunctionDecl::isMain() const {
2817 const TranslationUnitDecl *tunit =
2818 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
2819 return tunit &&
2820 !tunit->getASTContext().getLangOpts().Freestanding &&
2821 isNamed(this, "main");
2822}
2823
2824bool FunctionDecl::isMSVCRTEntryPoint() const {
2825 const TranslationUnitDecl *TUnit =
2826 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
2827 if (!TUnit)
2828 return false;
2829
2830 // Even though we aren't really targeting MSVCRT if we are freestanding,
2831 // semantic analysis for these functions remains the same.
2832
2833 // MSVCRT entry points only exist on MSVCRT targets.
2834 if (!TUnit->getASTContext().getTargetInfo().getTriple().isOSMSVCRT())
2835 return false;
2836
2837 // Nameless functions like constructors cannot be entry points.
2838 if (!getIdentifier())
2839 return false;
2840
2841 return llvm::StringSwitch<bool>(getName())
2842 .Cases("main", // an ANSI console app
2843 "wmain", // a Unicode console App
2844 "WinMain", // an ANSI GUI app
2845 "wWinMain", // a Unicode GUI app
2846 "DllMain", // a DLL
2847 true)
2848 .Default(false);
2849}
2850
2851bool FunctionDecl::isReservedGlobalPlacementOperator() const {
2852 assert(getDeclName().getNameKind() == DeclarationName::CXXOperatorName)((getDeclName().getNameKind() == DeclarationName::CXXOperatorName
) ? static_cast<void> (0) : __assert_fail ("getDeclName().getNameKind() == DeclarationName::CXXOperatorName"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2852, __PRETTY_FUNCTION__))
;
2853 assert(getDeclName().getCXXOverloadedOperator() == OO_New ||((getDeclName().getCXXOverloadedOperator() == OO_New || getDeclName
().getCXXOverloadedOperator() == OO_Delete || getDeclName().getCXXOverloadedOperator
() == OO_Array_New || getDeclName().getCXXOverloadedOperator(
) == OO_Array_Delete) ? static_cast<void> (0) : __assert_fail
("getDeclName().getCXXOverloadedOperator() == OO_New || getDeclName().getCXXOverloadedOperator() == OO_Delete || getDeclName().getCXXOverloadedOperator() == OO_Array_New || getDeclName().getCXXOverloadedOperator() == OO_Array_Delete"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2856, __PRETTY_FUNCTION__))
2854 getDeclName().getCXXOverloadedOperator() == OO_Delete ||((getDeclName().getCXXOverloadedOperator() == OO_New || getDeclName
().getCXXOverloadedOperator() == OO_Delete || getDeclName().getCXXOverloadedOperator
() == OO_Array_New || getDeclName().getCXXOverloadedOperator(
) == OO_Array_Delete) ? static_cast<void> (0) : __assert_fail
("getDeclName().getCXXOverloadedOperator() == OO_New || getDeclName().getCXXOverloadedOperator() == OO_Delete || getDeclName().getCXXOverloadedOperator() == OO_Array_New || getDeclName().getCXXOverloadedOperator() == OO_Array_Delete"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2856, __PRETTY_FUNCTION__))
2855 getDeclName().getCXXOverloadedOperator() == OO_Array_New ||((getDeclName().getCXXOverloadedOperator() == OO_New || getDeclName
().getCXXOverloadedOperator() == OO_Delete || getDeclName().getCXXOverloadedOperator
() == OO_Array_New || getDeclName().getCXXOverloadedOperator(
) == OO_Array_Delete) ? static_cast<void> (0) : __assert_fail
("getDeclName().getCXXOverloadedOperator() == OO_New || getDeclName().getCXXOverloadedOperator() == OO_Delete || getDeclName().getCXXOverloadedOperator() == OO_Array_New || getDeclName().getCXXOverloadedOperator() == OO_Array_Delete"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2856, __PRETTY_FUNCTION__))
2856 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete)((getDeclName().getCXXOverloadedOperator() == OO_New || getDeclName
().getCXXOverloadedOperator() == OO_Delete || getDeclName().getCXXOverloadedOperator
() == OO_Array_New || getDeclName().getCXXOverloadedOperator(
) == OO_Array_Delete) ? static_cast<void> (0) : __assert_fail
("getDeclName().getCXXOverloadedOperator() == OO_New || getDeclName().getCXXOverloadedOperator() == OO_Delete || getDeclName().getCXXOverloadedOperator() == OO_Array_New || getDeclName().getCXXOverloadedOperator() == OO_Array_Delete"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 2856, __PRETTY_FUNCTION__))
;
2857
2858 if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
2859 return false;
2860
2861 const auto *proto = getType()->castAs<FunctionProtoType>();
2862 if (proto->getNumParams() != 2 || proto->isVariadic())
2863 return false;
2864
2865 ASTContext &Context =
2866 cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
2867 ->getASTContext();
2868
2869 // The result type and first argument type are constant across all
2870 // these operators. The second argument must be exactly void*.
2871 return (proto->getParamType(1).getCanonicalType() == Context.VoidPtrTy);
2872}
2873
2874bool FunctionDecl::isReplaceableGlobalAllocationFunction(bool *IsAligned) const {
2875 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
2876 return false;
2877 if (getDeclName().getCXXOverloadedOperator() != OO_New &&
2878 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
2879 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
2880 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
2881 return false;
2882
2883 if (isa<CXXRecordDecl>(getDeclContext()))
2884 return false;
2885
2886 // This can only fail for an invalid 'operator new' declaration.
2887 if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
2888 return false;
2889
2890 const auto *FPT = getType()->castAs<FunctionProtoType>();
2891 if (FPT->getNumParams() == 0 || FPT->getNumParams() > 3 || FPT->isVariadic())
2892 return false;
2893
2894 // If this is a single-parameter function, it must be a replaceable global
2895 // allocation or deallocation function.
2896 if (FPT->getNumParams() == 1)
2897 return true;
2898
2899 unsigned Params = 1;
2900 QualType Ty = FPT->getParamType(Params);
2901 ASTContext &Ctx = getASTContext();
2902
2903 auto Consume = [&] {
2904 ++Params;
2905 Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) : QualType();
2906 };
2907
2908 // In C++14, the next parameter can be a 'std::size_t' for sized delete.
2909 bool IsSizedDelete = false;
2910 if (Ctx.getLangOpts().SizedDeallocation &&
2911 (getDeclName().getCXXOverloadedOperator() == OO_Delete ||
2912 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
2913 Ctx.hasSameType(Ty, Ctx.getSizeType())) {
2914 IsSizedDelete = true;
2915 Consume();
2916 }
2917
2918 // In C++17, the next parameter can be a 'std::align_val_t' for aligned
2919 // new/delete.
2920 if (Ctx.getLangOpts().AlignedAllocation && !Ty.isNull() && Ty->isAlignValT()) {
2921 if (IsAligned)
2922 *IsAligned = true;
2923 Consume();
2924 }
2925
2926 // Finally, if this is not a sized delete, the final parameter can
2927 // be a 'const std::nothrow_t&'.
2928 if (!IsSizedDelete && !Ty.isNull() && Ty->isReferenceType()) {
2929 Ty = Ty->getPointeeType();
2930 if (Ty.getCVRQualifiers() != Qualifiers::Const)
2931 return false;
2932 const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
2933 if (RD && isNamed(RD, "nothrow_t") && RD->isInStdNamespace())
2934 Consume();
2935 }
2936
2937 return Params == FPT->getNumParams();
2938}
2939
2940bool FunctionDecl::isDestroyingOperatorDelete() const {
2941 // C++ P0722:
2942 // Within a class C, a single object deallocation function with signature
2943 // (T, std::destroying_delete_t, <more params>)
2944 // is a destroying operator delete.
2945 if (!isa<CXXMethodDecl>(this) || getOverloadedOperator() != OO_Delete ||
2946 getNumParams() < 2)
2947 return false;
2948
2949 auto *RD = getParamDecl(1)->getType()->getAsCXXRecordDecl();
2950 return RD && RD->isInStdNamespace() && RD->getIdentifier() &&
2951 RD->getIdentifier()->isStr("destroying_delete_t");
2952}
2953
2954LanguageLinkage FunctionDecl::getLanguageLinkage() const {
2955 return getDeclLanguageLinkage(*this);
2956}
2957
2958bool FunctionDecl::isExternC() const {
2959 return isDeclExternC(*this);
2960}
2961
2962bool FunctionDecl::isInExternCContext() const {
2963 if (hasAttr<OpenCLKernelAttr>())
2964 return true;
2965 return getLexicalDeclContext()->isExternCContext();
2966}
2967
2968bool FunctionDecl::isInExternCXXContext() const {
2969 return getLexicalDeclContext()->isExternCXXContext();
2970}
2971
2972bool FunctionDecl::isGlobal() const {
2973 if (const auto *Method = dyn_cast<CXXMethodDecl>(this))
2974 return Method->isStatic();
2975
2976 if (getCanonicalDecl()->getStorageClass() == SC_Static)
2977 return false;
2978
2979 for (const DeclContext *DC = getDeclContext();
2980 DC->isNamespace();
2981 DC = DC->getParent()) {
2982 if (const auto *Namespace = cast<NamespaceDecl>(DC)) {
2983 if (!Namespace->getDeclName())
2984 return false;
2985 break;
2986 }
2987 }
2988
2989 return true;
2990}
2991
2992bool FunctionDecl::isNoReturn() const {
2993 if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
2994 hasAttr<C11NoReturnAttr>())
2995 return true;
2996
2997 if (auto *FnTy = getType()->getAs<FunctionType>())
2998 return FnTy->getNoReturnAttr();
2999
3000 return false;
3001}
3002
3003
3004MultiVersionKind FunctionDecl::getMultiVersionKind() const {
3005 if (hasAttr<TargetAttr>())
3006 return MultiVersionKind::Target;
3007 if (hasAttr<CPUDispatchAttr>())
3008 return MultiVersionKind::CPUDispatch;
3009 if (hasAttr<CPUSpecificAttr>())
3010 return MultiVersionKind::CPUSpecific;
3011 return MultiVersionKind::None;
3012}
3013
3014bool FunctionDecl::isCPUDispatchMultiVersion() const {
3015 return isMultiVersion() && hasAttr<CPUDispatchAttr>();
3016}
3017
3018bool FunctionDecl::isCPUSpecificMultiVersion() const {
3019 return isMultiVersion() && hasAttr<CPUSpecificAttr>();
3020}
3021
3022bool FunctionDecl::isTargetMultiVersion() const {
3023 return isMultiVersion() && hasAttr<TargetAttr>();
3024}
3025
3026void
3027FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) {
3028 redeclarable_base::setPreviousDecl(PrevDecl);
3029
3030 if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) {
3031 FunctionTemplateDecl *PrevFunTmpl
3032 = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : nullptr;
3033 assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch")(((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch"
) ? static_cast<void> (0) : __assert_fail ("(!PrevDecl || PrevFunTmpl) && \"Function/function template mismatch\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3033, __PRETTY_FUNCTION__))
;
3034 FunTmpl->setPreviousDecl(PrevFunTmpl);
3035 }
3036
3037 if (PrevDecl && PrevDecl->isInlined())
3038 setImplicitlyInline(true);
3039}
3040
3041FunctionDecl *FunctionDecl::getCanonicalDecl() { return getFirstDecl(); }
3042
3043/// Returns a value indicating whether this function corresponds to a builtin
3044/// function.
3045///
3046/// The function corresponds to a built-in function if it is declared at
3047/// translation scope or within an extern "C" block and its name matches with
3048/// the name of a builtin. The returned value will be 0 for functions that do
3049/// not correspond to a builtin, a value of type \c Builtin::ID if in the
3050/// target-independent range \c [1,Builtin::First), or a target-specific builtin
3051/// value.
3052///
3053/// \param ConsiderWrapperFunctions If true, we should consider wrapper
3054/// functions as their wrapped builtins. This shouldn't be done in general, but
3055/// it's useful in Sema to diagnose calls to wrappers based on their semantics.
3056unsigned FunctionDecl::getBuiltinID(bool ConsiderWrapperFunctions) const {
3057 if (!getIdentifier())
3058 return 0;
3059
3060 unsigned BuiltinID = getIdentifier()->getBuiltinID();
3061 if (!BuiltinID)
3062 return 0;
3063
3064 ASTContext &Context = getASTContext();
3065 if (Context.getLangOpts().CPlusPlus) {
3066 const auto *LinkageDecl =
3067 dyn_cast<LinkageSpecDecl>(getFirstDecl()->getDeclContext());
3068 // In C++, the first declaration of a builtin is always inside an implicit
3069 // extern "C".
3070 // FIXME: A recognised library function may not be directly in an extern "C"
3071 // declaration, for instance "extern "C" { namespace std { decl } }".
3072 if (!LinkageDecl) {
3073 if (BuiltinID == Builtin::BI__GetExceptionInfo &&
3074 Context.getTargetInfo().getCXXABI().isMicrosoft())
3075 return Builtin::BI__GetExceptionInfo;
3076 return 0;
3077 }
3078 if (LinkageDecl->getLanguage() != LinkageSpecDecl::lang_c)
3079 return 0;
3080 }
3081
3082 // If the function is marked "overloadable", it has a different mangled name
3083 // and is not the C library function.
3084 if (!ConsiderWrapperFunctions && hasAttr<OverloadableAttr>())
3085 return 0;
3086
3087 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
3088 return BuiltinID;
3089
3090 // This function has the name of a known C library
3091 // function. Determine whether it actually refers to the C library
3092 // function or whether it just has the same name.
3093
3094 // If this is a static function, it's not a builtin.
3095 if (!ConsiderWrapperFunctions && getStorageClass() == SC_Static)
3096 return 0;
3097
3098 // OpenCL v1.2 s6.9.f - The library functions defined in
3099 // the C99 standard headers are not available.
3100 if (Context.getLangOpts().OpenCL &&
3101 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
3102 return 0;
3103
3104 // CUDA does not have device-side standard library. printf and malloc are the
3105 // only special cases that are supported by device-side runtime.
3106 if (Context.getLangOpts().CUDA && hasAttr<CUDADeviceAttr>() &&
3107 !hasAttr<CUDAHostAttr>() &&
3108 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3109 return 0;
3110
3111 return BuiltinID;
3112}
3113
3114/// getNumParams - Return the number of parameters this function must have
3115/// based on its FunctionType. This is the length of the ParamInfo array
3116/// after it has been created.
3117unsigned FunctionDecl::getNumParams() const {
3118 const auto *FPT = getType()->getAs<FunctionProtoType>();
3119 return FPT ? FPT->getNumParams() : 0;
3120}
3121
3122void FunctionDecl::setParams(ASTContext &C,
3123 ArrayRef<ParmVarDecl *> NewParamInfo) {
3124 assert(!ParamInfo && "Already has param info!")((!ParamInfo && "Already has param info!") ? static_cast
<void> (0) : __assert_fail ("!ParamInfo && \"Already has param info!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3124, __PRETTY_FUNCTION__))
;
3125 assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!")((NewParamInfo.size() == getNumParams() && "Parameter count mismatch!"
) ? static_cast<void> (0) : __assert_fail ("NewParamInfo.size() == getNumParams() && \"Parameter count mismatch!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3125, __PRETTY_FUNCTION__))
;
3126
3127 // Zero params -> null pointer.
3128 if (!NewParamInfo.empty()) {
3129 ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()];
3130 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3131 }
3132}
3133
3134/// getMinRequiredArguments - Returns the minimum number of arguments
3135/// needed to call this function. This may be fewer than the number of
3136/// function parameters, if some of the parameters have default
3137/// arguments (in C++) or are parameter packs (C++11).
3138unsigned FunctionDecl::getMinRequiredArguments() const {
3139 if (!getASTContext().getLangOpts().CPlusPlus)
3140 return getNumParams();
3141
3142 unsigned NumRequiredArgs = 0;
3143 for (auto *Param : parameters())
3144 if (!Param->isParameterPack() && !Param->hasDefaultArg())
3145 ++NumRequiredArgs;
3146 return NumRequiredArgs;
3147}
3148
3149/// The combination of the extern and inline keywords under MSVC forces
3150/// the function to be required.
3151///
3152/// Note: This function assumes that we will only get called when isInlined()
3153/// would return true for this FunctionDecl.
3154bool FunctionDecl::isMSExternInline() const {
3155 assert(isInlined() && "expected to get called on an inlined function!")((isInlined() && "expected to get called on an inlined function!"
) ? static_cast<void> (0) : __assert_fail ("isInlined() && \"expected to get called on an inlined function!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3155, __PRETTY_FUNCTION__))
;
3156
3157 const ASTContext &Context = getASTContext();
3158 if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3159 !hasAttr<DLLExportAttr>())
3160 return false;
3161
3162 for (const FunctionDecl *FD = getMostRecentDecl(); FD;
3163 FD = FD->getPreviousDecl())
3164 if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
3165 return true;
3166
3167 return false;
3168}
3169
3170static bool redeclForcesDefMSVC(const FunctionDecl *Redecl) {
3171 if (Redecl->getStorageClass() != SC_Extern)
3172 return false;
3173
3174 for (const FunctionDecl *FD = Redecl->getPreviousDecl(); FD;
3175 FD = FD->getPreviousDecl())
3176 if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
3177 return false;
3178
3179 return true;
3180}
3181
3182static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
3183 // Only consider file-scope declarations in this test.
3184 if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
3185 return false;
3186
3187 // Only consider explicit declarations; the presence of a builtin for a
3188 // libcall shouldn't affect whether a definition is externally visible.
3189 if (Redecl->isImplicit())
3190 return false;
3191
3192 if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern)
3193 return true; // Not an inline definition
3194
3195 return false;
3196}
3197
3198/// For a function declaration in C or C++, determine whether this
3199/// declaration causes the definition to be externally visible.
3200///
3201/// For instance, this determines if adding the current declaration to the set
3202/// of redeclarations of the given functions causes
3203/// isInlineDefinitionExternallyVisible to change from false to true.
3204bool FunctionDecl::doesDeclarationForceExternallyVisibleDefinition() const {
3205 assert(!doesThisDeclarationHaveABody() &&((!doesThisDeclarationHaveABody() && "Must have a declaration without a body."
) ? static_cast<void> (0) : __assert_fail ("!doesThisDeclarationHaveABody() && \"Must have a declaration without a body.\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3206, __PRETTY_FUNCTION__))
3206 "Must have a declaration without a body.")((!doesThisDeclarationHaveABody() && "Must have a declaration without a body."
) ? static_cast<void> (0) : __assert_fail ("!doesThisDeclarationHaveABody() && \"Must have a declaration without a body.\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3206, __PRETTY_FUNCTION__))
;
3207
3208 ASTContext &Context = getASTContext();
3209
3210 if (Context.getLangOpts().MSVCCompat) {
3211 const FunctionDecl *Definition;
3212 if (hasBody(Definition) && Definition->isInlined() &&
3213 redeclForcesDefMSVC(this))
3214 return true;
3215 }
3216
3217 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3218 // With GNU inlining, a declaration with 'inline' but not 'extern', forces
3219 // an externally visible definition.
3220 //
3221 // FIXME: What happens if gnu_inline gets added on after the first
3222 // declaration?
3223 if (!isInlineSpecified() || getStorageClass() == SC_Extern)
3224 return false;
3225
3226 const FunctionDecl *Prev = this;
3227 bool FoundBody = false;
3228 while ((Prev = Prev->getPreviousDecl())) {
3229 FoundBody |= Prev->Body.isValid();
3230
3231 if (Prev->Body) {
3232 // If it's not the case that both 'inline' and 'extern' are
3233 // specified on the definition, then it is always externally visible.
3234 if (!Prev->isInlineSpecified() ||
3235 Prev->getStorageClass() != SC_Extern)
3236 return false;
3237 } else if (Prev->isInlineSpecified() &&
3238 Prev->getStorageClass() != SC_Extern) {
3239 return false;
3240 }
3241 }
3242 return FoundBody;
3243 }
3244
3245 if (Context.getLangOpts().CPlusPlus)
3246 return false;
3247
3248 // C99 6.7.4p6:
3249 // [...] If all of the file scope declarations for a function in a
3250 // translation unit include the inline function specifier without extern,
3251 // then the definition in that translation unit is an inline definition.
3252 if (isInlineSpecified() && getStorageClass() != SC_Extern)
3253 return false;
3254 const FunctionDecl *Prev = this;
3255 bool FoundBody = false;
3256 while ((Prev = Prev->getPreviousDecl())) {
3257 FoundBody |= Prev->Body.isValid();
3258 if (RedeclForcesDefC99(Prev))
3259 return false;
3260 }
3261 return FoundBody;
3262}
3263
3264SourceRange FunctionDecl::getReturnTypeSourceRange() const {
3265 const TypeSourceInfo *TSI = getTypeSourceInfo();
3266 if (!TSI)
3267 return SourceRange();
3268 FunctionTypeLoc FTL =
3269 TSI->getTypeLoc().IgnoreParens().getAs<FunctionTypeLoc>();
3270 if (!FTL)
3271 return SourceRange();
3272
3273 // Skip self-referential return types.
3274 const SourceManager &SM = getASTContext().getSourceManager();
3275 SourceRange RTRange = FTL.getReturnLoc().getSourceRange();
3276 SourceLocation Boundary = getNameInfo().getBeginLoc();
3277 if (RTRange.isInvalid() || Boundary.isInvalid() ||
3278 !SM.isBeforeInTranslationUnit(RTRange.getEnd(), Boundary))
3279 return SourceRange();
3280
3281 return RTRange;
3282}
3283
3284SourceRange FunctionDecl::getExceptionSpecSourceRange() const {
3285 const TypeSourceInfo *TSI = getTypeSourceInfo();
3286 if (!TSI)
3287 return SourceRange();
3288 FunctionTypeLoc FTL =
3289 TSI->getTypeLoc().IgnoreParens().getAs<FunctionTypeLoc>();
3290 if (!FTL)
3291 return SourceRange();
3292
3293 return FTL.getExceptionSpecRange();
3294}
3295
3296/// For an inline function definition in C, or for a gnu_inline function
3297/// in C++, determine whether the definition will be externally visible.
3298///
3299/// Inline function definitions are always available for inlining optimizations.
3300/// However, depending on the language dialect, declaration specifiers, and
3301/// attributes, the definition of an inline function may or may not be
3302/// "externally" visible to other translation units in the program.
3303///
3304/// In C99, inline definitions are not externally visible by default. However,
3305/// if even one of the global-scope declarations is marked "extern inline", the
3306/// inline definition becomes externally visible (C99 6.7.4p6).
3307///
3308/// In GNU89 mode, or if the gnu_inline attribute is attached to the function
3309/// definition, we use the GNU semantics for inline, which are nearly the
3310/// opposite of C99 semantics. In particular, "inline" by itself will create
3311/// an externally visible symbol, but "extern inline" will not create an
3312/// externally visible symbol.
3313bool FunctionDecl::isInlineDefinitionExternallyVisible() const {
3314 assert((doesThisDeclarationHaveABody() || willHaveBody()) &&(((doesThisDeclarationHaveABody() || willHaveBody()) &&
"Must be a function definition") ? static_cast<void> (
0) : __assert_fail ("(doesThisDeclarationHaveABody() || willHaveBody()) && \"Must be a function definition\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3315, __PRETTY_FUNCTION__))
3315 "Must be a function definition")(((doesThisDeclarationHaveABody() || willHaveBody()) &&
"Must be a function definition") ? static_cast<void> (
0) : __assert_fail ("(doesThisDeclarationHaveABody() || willHaveBody()) && \"Must be a function definition\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3315, __PRETTY_FUNCTION__))
;
3316 assert(isInlined() && "Function must be inline")((isInlined() && "Function must be inline") ? static_cast
<void> (0) : __assert_fail ("isInlined() && \"Function must be inline\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3316, __PRETTY_FUNCTION__))
;
3317 ASTContext &Context = getASTContext();
3318
3319 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3320 // Note: If you change the logic here, please change
3321 // doesDeclarationForceExternallyVisibleDefinition as well.
3322 //
3323 // If it's not the case that both 'inline' and 'extern' are
3324 // specified on the definition, then this inline definition is
3325 // externally visible.
3326 if (!(isInlineSpecified() && getStorageClass() == SC_Extern))
3327 return true;
3328
3329 // If any declaration is 'inline' but not 'extern', then this definition
3330 // is externally visible.
3331 for (auto Redecl : redecls()) {
3332 if (Redecl->isInlineSpecified() &&
3333 Redecl->getStorageClass() != SC_Extern)
3334 return true;
3335 }
3336
3337 return false;
3338 }
3339
3340 // The rest of this function is C-only.
3341 assert(!Context.getLangOpts().CPlusPlus &&((!Context.getLangOpts().CPlusPlus && "should not use C inline rules in C++"
) ? static_cast<void> (0) : __assert_fail ("!Context.getLangOpts().CPlusPlus && \"should not use C inline rules in C++\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3342, __PRETTY_FUNCTION__))
3342 "should not use C inline rules in C++")((!Context.getLangOpts().CPlusPlus && "should not use C inline rules in C++"
) ? static_cast<void> (0) : __assert_fail ("!Context.getLangOpts().CPlusPlus && \"should not use C inline rules in C++\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3342, __PRETTY_FUNCTION__))
;
3343
3344 // C99 6.7.4p6:
3345 // [...] If all of the file scope declarations for a function in a
3346 // translation unit include the inline function specifier without extern,
3347 // then the definition in that translation unit is an inline definition.
3348 for (auto Redecl : redecls()) {
3349 if (RedeclForcesDefC99(Redecl))
3350 return true;
3351 }
3352
3353 // C99 6.7.4p6:
3354 // An inline definition does not provide an external definition for the
3355 // function, and does not forbid an external definition in another
3356 // translation unit.
3357 return false;
3358}
3359
3360/// getOverloadedOperator - Which C++ overloaded operator this
3361/// function represents, if any.
3362OverloadedOperatorKind FunctionDecl::getOverloadedOperator() const {
3363 if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
3364 return getDeclName().getCXXOverloadedOperator();
3365 else
3366 return OO_None;
3367}
3368
3369/// getLiteralIdentifier - The literal suffix identifier this function
3370/// represents, if any.
3371const IdentifierInfo *FunctionDecl::getLiteralIdentifier() const {
3372 if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName)
3373 return getDeclName().getCXXLiteralIdentifier();
3374 else
3375 return nullptr;
3376}
3377
3378FunctionDecl::TemplatedKind FunctionDecl::getTemplatedKind() const {
3379 if (TemplateOrSpecialization.isNull())
3380 return TK_NonTemplate;
3381 if (TemplateOrSpecialization.is<FunctionTemplateDecl *>())
3382 return TK_FunctionTemplate;
3383 if (TemplateOrSpecialization.is<MemberSpecializationInfo *>())
3384 return TK_MemberSpecialization;
3385 if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>())
3386 return TK_FunctionTemplateSpecialization;
3387 if (TemplateOrSpecialization.is
3388 <DependentFunctionTemplateSpecializationInfo*>())
3389 return TK_DependentFunctionTemplateSpecialization;
3390
3391 llvm_unreachable("Did we miss a TemplateOrSpecialization type?")::llvm::llvm_unreachable_internal("Did we miss a TemplateOrSpecialization type?"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3391)
;
3392}
3393
3394FunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const {
3395 if (MemberSpecializationInfo *Info = getMemberSpecializationInfo())
3396 return cast<FunctionDecl>(Info->getInstantiatedFrom());
3397
3398 return nullptr;
3399}
3400
3401MemberSpecializationInfo *FunctionDecl::getMemberSpecializationInfo() const {
3402 if (auto *MSI =
3403 TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo *>())
3404 return MSI;
3405 if (auto *FTSI = TemplateOrSpecialization
3406 .dyn_cast<FunctionTemplateSpecializationInfo *>())
3407 return FTSI->getMemberSpecializationInfo();
3408 return nullptr;
3409}
3410
3411void
3412FunctionDecl::setInstantiationOfMemberFunction(ASTContext &C,
3413 FunctionDecl *FD,
3414 TemplateSpecializationKind TSK) {
3415 assert(TemplateOrSpecialization.isNull() &&((TemplateOrSpecialization.isNull() && "Member function is already a specialization"
) ? static_cast<void> (0) : __assert_fail ("TemplateOrSpecialization.isNull() && \"Member function is already a specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3416, __PRETTY_FUNCTION__))
3416 "Member function is already a specialization")((TemplateOrSpecialization.isNull() && "Member function is already a specialization"
) ? static_cast<void> (0) : __assert_fail ("TemplateOrSpecialization.isNull() && \"Member function is already a specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3416, __PRETTY_FUNCTION__))
;
3417 MemberSpecializationInfo *Info
3418 = new (C) MemberSpecializationInfo(FD, TSK);
3419 TemplateOrSpecialization = Info;
3420}
3421
3422FunctionTemplateDecl *FunctionDecl::getDescribedFunctionTemplate() const {
3423 return TemplateOrSpecialization.dyn_cast<FunctionTemplateDecl *>();
3424}
3425
3426void FunctionDecl::setDescribedFunctionTemplate(FunctionTemplateDecl *Template) {
3427 assert(TemplateOrSpecialization.isNull() &&((TemplateOrSpecialization.isNull() && "Member function is already a specialization"
) ? static_cast<void> (0) : __assert_fail ("TemplateOrSpecialization.isNull() && \"Member function is already a specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3428, __PRETTY_FUNCTION__))
3428 "Member function is already a specialization")((TemplateOrSpecialization.isNull() && "Member function is already a specialization"
) ? static_cast<void> (0) : __assert_fail ("TemplateOrSpecialization.isNull() && \"Member function is already a specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3428, __PRETTY_FUNCTION__))
;
3429 TemplateOrSpecialization = Template;
3430}
3431
3432bool FunctionDecl::isImplicitlyInstantiable() const {
3433 // If the function is invalid, it can't be implicitly instantiated.
3434 if (isInvalidDecl())
3435 return false;
3436
3437 switch (getTemplateSpecializationKindForInstantiation()) {
3438 case TSK_Undeclared:
3439 case TSK_ExplicitInstantiationDefinition:
3440 case TSK_ExplicitSpecialization:
3441 return false;
3442
3443 case TSK_ImplicitInstantiation:
3444 return true;
3445
3446 case TSK_ExplicitInstantiationDeclaration:
3447 // Handled below.
3448 break;
3449 }
3450
3451 // Find the actual template from which we will instantiate.
3452 const FunctionDecl *PatternDecl = getTemplateInstantiationPattern();
3453 bool HasPattern = false;
3454 if (PatternDecl)
3455 HasPattern = PatternDecl->hasBody(PatternDecl);
3456
3457 // C++0x [temp.explicit]p9:
3458 // Except for inline functions, other explicit instantiation declarations
3459 // have the effect of suppressing the implicit instantiation of the entity
3460 // to which they refer.
3461 if (!HasPattern || !PatternDecl)
3462 return true;
3463
3464 return PatternDecl->isInlined();
3465}
3466
3467bool FunctionDecl::isTemplateInstantiation() const {
3468 // FIXME: Remove this, it's not clear what it means. (Which template
3469 // specialization kind?)
3470 return clang::isTemplateInstantiation(getTemplateSpecializationKind());
3471}
3472
3473FunctionDecl *FunctionDecl::getTemplateInstantiationPattern() const {
3474 // If this is a generic lambda call operator specialization, its
3475 // instantiation pattern is always its primary template's pattern
3476 // even if its primary template was instantiated from another
3477 // member template (which happens with nested generic lambdas).
3478 // Since a lambda's call operator's body is transformed eagerly,
3479 // we don't have to go hunting for a prototype definition template
3480 // (i.e. instantiated-from-member-template) to use as an instantiation
3481 // pattern.
3482
3483 if (isGenericLambdaCallOperatorSpecialization(
3484 dyn_cast<CXXMethodDecl>(this))) {
3485 assert(getPrimaryTemplate() && "not a generic lambda call operator?")((getPrimaryTemplate() && "not a generic lambda call operator?"
) ? static_cast<void> (0) : __assert_fail ("getPrimaryTemplate() && \"not a generic lambda call operator?\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3485, __PRETTY_FUNCTION__))
;
3486 return getDefinitionOrSelf(getPrimaryTemplate()->getTemplatedDecl());
3487 }
3488
3489 if (MemberSpecializationInfo *Info = getMemberSpecializationInfo()) {
3490 if (!clang::isTemplateInstantiation(Info->getTemplateSpecializationKind()))
3491 return nullptr;
3492 return getDefinitionOrSelf(cast<FunctionDecl>(Info->getInstantiatedFrom()));
3493 }
3494
3495 if (!clang::isTemplateInstantiation(getTemplateSpecializationKind()))
3496 return nullptr;
3497
3498 if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) {
3499 // If we hit a point where the user provided a specialization of this
3500 // template, we're done looking.
3501 while (!Primary->isMemberSpecialization()) {
3502 auto *NewPrimary = Primary->getInstantiatedFromMemberTemplate();
3503 if (!NewPrimary)
3504 break;
3505 Primary = NewPrimary;
3506 }
3507
3508 return getDefinitionOrSelf(Primary->getTemplatedDecl());
3509 }
3510
3511 return nullptr;
3512}
3513
3514FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const {
3515 if (FunctionTemplateSpecializationInfo *Info
3516 = TemplateOrSpecialization
3517 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3518 return Info->getTemplate();
3519 }
3520 return nullptr;
3521}
3522
3523FunctionTemplateSpecializationInfo *
3524FunctionDecl::getTemplateSpecializationInfo() const {
3525 return TemplateOrSpecialization
3526 .dyn_cast<FunctionTemplateSpecializationInfo *>();
3527}
3528
3529const TemplateArgumentList *
3530FunctionDecl::getTemplateSpecializationArgs() const {
3531 if (FunctionTemplateSpecializationInfo *Info
3532 = TemplateOrSpecialization
3533 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3534 return Info->TemplateArguments;
3535 }
3536 return nullptr;
3537}
3538
3539const ASTTemplateArgumentListInfo *
3540FunctionDecl::getTemplateSpecializationArgsAsWritten() const {
3541 if (FunctionTemplateSpecializationInfo *Info
3542 = TemplateOrSpecialization
3543 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3544 return Info->TemplateArgumentsAsWritten;
3545 }
3546 return nullptr;
3547}
3548
3549void
3550FunctionDecl::setFunctionTemplateSpecialization(ASTContext &C,
3551 FunctionTemplateDecl *Template,
3552 const TemplateArgumentList *TemplateArgs,
3553 void *InsertPos,
3554 TemplateSpecializationKind TSK,
3555 const TemplateArgumentListInfo *TemplateArgsAsWritten,
3556 SourceLocation PointOfInstantiation) {
3557 assert((TemplateOrSpecialization.isNull() ||(((TemplateOrSpecialization.isNull() || TemplateOrSpecialization
.is<MemberSpecializationInfo *>()) && "Member function is already a specialization"
) ? static_cast<void> (0) : __assert_fail ("(TemplateOrSpecialization.isNull() || TemplateOrSpecialization.is<MemberSpecializationInfo *>()) && \"Member function is already a specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3559, __PRETTY_FUNCTION__))
3558 TemplateOrSpecialization.is<MemberSpecializationInfo *>()) &&(((TemplateOrSpecialization.isNull() || TemplateOrSpecialization
.is<MemberSpecializationInfo *>()) && "Member function is already a specialization"
) ? static_cast<void> (0) : __assert_fail ("(TemplateOrSpecialization.isNull() || TemplateOrSpecialization.is<MemberSpecializationInfo *>()) && \"Member function is already a specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3559, __PRETTY_FUNCTION__))
3559 "Member function is already a specialization")(((TemplateOrSpecialization.isNull() || TemplateOrSpecialization
.is<MemberSpecializationInfo *>()) && "Member function is already a specialization"
) ? static_cast<void> (0) : __assert_fail ("(TemplateOrSpecialization.isNull() || TemplateOrSpecialization.is<MemberSpecializationInfo *>()) && \"Member function is already a specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3559, __PRETTY_FUNCTION__))
;
3560 assert(TSK != TSK_Undeclared &&((TSK != TSK_Undeclared && "Must specify the type of function template specialization"
) ? static_cast<void> (0) : __assert_fail ("TSK != TSK_Undeclared && \"Must specify the type of function template specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3561, __PRETTY_FUNCTION__))
3561 "Must specify the type of function template specialization")((TSK != TSK_Undeclared && "Must specify the type of function template specialization"
) ? static_cast<void> (0) : __assert_fail ("TSK != TSK_Undeclared && \"Must specify the type of function template specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3561, __PRETTY_FUNCTION__))
;
3562 assert((TemplateOrSpecialization.isNull() ||(((TemplateOrSpecialization.isNull() || TSK == TSK_ExplicitSpecialization
) && "Member specialization must be an explicit specialization"
) ? static_cast<void> (0) : __assert_fail ("(TemplateOrSpecialization.isNull() || TSK == TSK_ExplicitSpecialization) && \"Member specialization must be an explicit specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3564, __PRETTY_FUNCTION__))
3563 TSK == TSK_ExplicitSpecialization) &&(((TemplateOrSpecialization.isNull() || TSK == TSK_ExplicitSpecialization
) && "Member specialization must be an explicit specialization"
) ? static_cast<void> (0) : __assert_fail ("(TemplateOrSpecialization.isNull() || TSK == TSK_ExplicitSpecialization) && \"Member specialization must be an explicit specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3564, __PRETTY_FUNCTION__))
3564 "Member specialization must be an explicit specialization")(((TemplateOrSpecialization.isNull() || TSK == TSK_ExplicitSpecialization
) && "Member specialization must be an explicit specialization"
) ? static_cast<void> (0) : __assert_fail ("(TemplateOrSpecialization.isNull() || TSK == TSK_ExplicitSpecialization) && \"Member specialization must be an explicit specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3564, __PRETTY_FUNCTION__))
;
3565 FunctionTemplateSpecializationInfo *Info =
3566 FunctionTemplateSpecializationInfo::Create(
3567 C, this, Template, TSK, TemplateArgs, TemplateArgsAsWritten,
3568 PointOfInstantiation,
3569 TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo *>());
3570 TemplateOrSpecialization = Info;
3571 Template->addSpecialization(Info, InsertPos);
3572}
3573
3574void
3575FunctionDecl::setDependentTemplateSpecialization(ASTContext &Context,
3576 const UnresolvedSetImpl &Templates,
3577 const TemplateArgumentListInfo &TemplateArgs) {
3578 assert(TemplateOrSpecialization.isNull())((TemplateOrSpecialization.isNull()) ? static_cast<void>
(0) : __assert_fail ("TemplateOrSpecialization.isNull()", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3578, __PRETTY_FUNCTION__))
;
3579 DependentFunctionTemplateSpecializationInfo *Info =
3580 DependentFunctionTemplateSpecializationInfo::Create(Context, Templates,
3581 TemplateArgs);
3582 TemplateOrSpecialization = Info;
3583}
3584
3585DependentFunctionTemplateSpecializationInfo *
3586FunctionDecl::getDependentSpecializationInfo() const {
3587 return TemplateOrSpecialization
3588 .dyn_cast<DependentFunctionTemplateSpecializationInfo *>();
3589}
3590
3591DependentFunctionTemplateSpecializationInfo *
3592DependentFunctionTemplateSpecializationInfo::Create(
3593 ASTContext &Context, const UnresolvedSetImpl &Ts,
3594 const TemplateArgumentListInfo &TArgs) {
3595 void *Buffer = Context.Allocate(
3596 totalSizeToAlloc<TemplateArgumentLoc, FunctionTemplateDecl *>(
3597 TArgs.size(), Ts.size()));
3598 return new (Buffer) DependentFunctionTemplateSpecializationInfo(Ts, TArgs);
3599}
3600
3601DependentFunctionTemplateSpecializationInfo::
3602DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts,
3603 const TemplateArgumentListInfo &TArgs)
3604 : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) {
3605 NumTemplates = Ts.size();
3606 NumArgs = TArgs.size();
3607
3608 FunctionTemplateDecl **TsArray = getTrailingObjects<FunctionTemplateDecl *>();
3609 for (unsigned I = 0, E = Ts.size(); I != E; ++I)
3610 TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl());
3611
3612 TemplateArgumentLoc *ArgsArray = getTrailingObjects<TemplateArgumentLoc>();
3613 for (unsigned I = 0, E = TArgs.size(); I != E; ++I)
3614 new (&ArgsArray[I]) TemplateArgumentLoc(TArgs[I]);
3615}
3616
3617TemplateSpecializationKind FunctionDecl::getTemplateSpecializationKind() const {
3618 // For a function template specialization, query the specialization
3619 // information object.
3620 if (FunctionTemplateSpecializationInfo *FTSInfo =
3621 TemplateOrSpecialization
3622 .dyn_cast<FunctionTemplateSpecializationInfo *>())
3623 return FTSInfo->getTemplateSpecializationKind();
3624
3625 if (MemberSpecializationInfo *MSInfo =
3626 TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo *>())
3627 return MSInfo->getTemplateSpecializationKind();
3628
3629 return TSK_Undeclared;
3630}
3631
3632TemplateSpecializationKind
3633FunctionDecl::getTemplateSpecializationKindForInstantiation() const {
3634 // This is the same as getTemplateSpecializationKind(), except that for a
3635 // function that is both a function template specialization and a member
3636 // specialization, we prefer the member specialization information. Eg:
3637 //
3638 // template<typename T> struct A {
3639 // template<typename U> void f() {}
3640 // template<> void f<int>() {}
3641 // };
3642 //
3643 // For A<int>::f<int>():
3644 // * getTemplateSpecializationKind() will return TSK_ExplicitSpecialization
3645 // * getTemplateSpecializationKindForInstantiation() will return
3646 // TSK_ImplicitInstantiation
3647 //
3648 // This reflects the facts that A<int>::f<int> is an explicit specialization
3649 // of A<int>::f, and that A<int>::f<int> should be implicitly instantiated
3650 // from A::f<int> if a definition is needed.
3651 if (FunctionTemplateSpecializationInfo *FTSInfo =
3652 TemplateOrSpecialization
3653 .dyn_cast<FunctionTemplateSpecializationInfo *>()) {
3654 if (auto *MSInfo = FTSInfo->getMemberSpecializationInfo())
3655 return MSInfo->getTemplateSpecializationKind();
3656 return FTSInfo->getTemplateSpecializationKind();
3657 }
3658
3659 if (MemberSpecializationInfo *MSInfo =
3660 TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo *>())
3661 return MSInfo->getTemplateSpecializationKind();
3662
3663 return TSK_Undeclared;
3664}
3665
3666void
3667FunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3668 SourceLocation PointOfInstantiation) {
3669 if (FunctionTemplateSpecializationInfo *FTSInfo
3670 = TemplateOrSpecialization.dyn_cast<
3671 FunctionTemplateSpecializationInfo*>()) {
3672 FTSInfo->setTemplateSpecializationKind(TSK);
3673 if (TSK != TSK_ExplicitSpecialization &&
3674 PointOfInstantiation.isValid() &&
3675 FTSInfo->getPointOfInstantiation().isInvalid()) {
3676 FTSInfo->setPointOfInstantiation(PointOfInstantiation);
3677 if (ASTMutationListener *L = getASTContext().getASTMutationListener())
3678 L->InstantiationRequested(this);
3679 }
3680 } else if (MemberSpecializationInfo *MSInfo
3681 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) {
3682 MSInfo->setTemplateSpecializationKind(TSK);
3683 if (TSK != TSK_ExplicitSpecialization &&
3684 PointOfInstantiation.isValid() &&
3685 MSInfo->getPointOfInstantiation().isInvalid()) {
3686 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3687 if (ASTMutationListener *L = getASTContext().getASTMutationListener())
3688 L->InstantiationRequested(this);
3689 }
3690 } else
3691 llvm_unreachable("Function cannot have a template specialization kind")::llvm::llvm_unreachable_internal("Function cannot have a template specialization kind"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3691)
;
3692}
3693
3694SourceLocation FunctionDecl::getPointOfInstantiation() const {
3695 if (FunctionTemplateSpecializationInfo *FTSInfo
3696 = TemplateOrSpecialization.dyn_cast<
3697 FunctionTemplateSpecializationInfo*>())
3698 return FTSInfo->getPointOfInstantiation();
3699 else if (MemberSpecializationInfo *MSInfo
3700 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>())
3701 return MSInfo->getPointOfInstantiation();
3702
3703 return SourceLocation();
3704}
3705
3706bool FunctionDecl::isOutOfLine() const {
3707 if (Decl::isOutOfLine())
3708 return true;
3709
3710 // If this function was instantiated from a member function of a
3711 // class template, check whether that member function was defined out-of-line.
3712 if (FunctionDecl *FD = getInstantiatedFromMemberFunction()) {
3713 const FunctionDecl *Definition;
3714 if (FD->hasBody(Definition))
3715 return Definition->isOutOfLine();
3716 }
3717
3718 // If this function was instantiated from a function template,
3719 // check whether that function template was defined out-of-line.
3720 if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) {
3721 const FunctionDecl *Definition;
3722 if (FunTmpl->getTemplatedDecl()->hasBody(Definition))
3723 return Definition->isOutOfLine();
3724 }
3725
3726 return false;
3727}
3728
3729SourceRange FunctionDecl::getSourceRange() const {
3730 return SourceRange(getOuterLocStart(), EndRangeLoc);
3731}
3732
3733unsigned FunctionDecl::getMemoryFunctionKind() const {
3734 IdentifierInfo *FnInfo = getIdentifier();
3735
3736 if (!FnInfo)
3737 return 0;
3738
3739 // Builtin handling.
3740 switch (getBuiltinID()) {
3741 case Builtin::BI__builtin_memset:
3742 case Builtin::BI__builtin___memset_chk:
3743 case Builtin::BImemset:
3744 return Builtin::BImemset;
3745
3746 case Builtin::BI__builtin_memcpy:
3747 case Builtin::BI__builtin___memcpy_chk:
3748 case Builtin::BImemcpy:
3749 return Builtin::BImemcpy;
3750
3751 case Builtin::BI__builtin_memmove:
3752 case Builtin::BI__builtin___memmove_chk:
3753 case Builtin::BImemmove:
3754 return Builtin::BImemmove;
3755
3756// case Builtin::BIstrlcpy:
3757// case Builtin::BI__builtin___strlcpy_chk:
3758// return Builtin::BIstrlcpy;
3759
3760// case Builtin::BIstrlcat:
3761// case Builtin::BI__builtin___strlcat_chk:
3762// return Builtin::BIstrlcat;
3763
3764 case Builtin::BI__builtin_memcmp:
3765 case Builtin::BImemcmp:
3766 return Builtin::BImemcmp;
3767
3768 case Builtin::BI__builtin_bcmp:
3769 case Builtin::BIbcmp:
3770 return Builtin::BIbcmp;
3771
3772 case Builtin::BI__builtin_strncpy:
3773 case Builtin::BI__builtin___strncpy_chk:
3774 case Builtin::BIstrncpy:
3775 return Builtin::BIstrncpy;
3776
3777 case Builtin::BI__builtin_strncmp:
3778 case Builtin::BIstrncmp:
3779 return Builtin::BIstrncmp;
3780
3781 case Builtin::BI__builtin_strncasecmp:
3782 case Builtin::BIstrncasecmp:
3783 return Builtin::BIstrncasecmp;
3784
3785 case Builtin::BI__builtin_strncat:
3786 case Builtin::BI__builtin___strncat_chk:
3787 case Builtin::BIstrncat:
3788 return Builtin::BIstrncat;
3789
3790 case Builtin::BI__builtin_strndup:
3791 case Builtin::BIstrndup:
3792 return Builtin::BIstrndup;
3793
3794 case Builtin::BI__builtin_strlen:
3795 case Builtin::BIstrlen:
3796 return Builtin::BIstrlen;
3797
3798 case Builtin::BI__builtin_bzero:
3799 case Builtin::BIbzero:
3800 return Builtin::BIbzero;
3801
3802 default:
3803 if (isExternC()) {
3804 if (FnInfo->isStr("memset"))
3805 return Builtin::BImemset;
3806 else if (FnInfo->isStr("memcpy"))
3807 return Builtin::BImemcpy;
3808 else if (FnInfo->isStr("memmove"))
3809 return Builtin::BImemmove;
3810 else if (FnInfo->isStr("memcmp"))
3811 return Builtin::BImemcmp;
3812 else if (FnInfo->isStr("bcmp"))
3813 return Builtin::BIbcmp;
3814 else if (FnInfo->isStr("strncpy"))
3815 return Builtin::BIstrncpy;
3816 else if (FnInfo->isStr("strncmp"))
3817 return Builtin::BIstrncmp;
3818 else if (FnInfo->isStr("strncasecmp"))
3819 return Builtin::BIstrncasecmp;
3820 else if (FnInfo->isStr("strncat"))
3821 return Builtin::BIstrncat;
3822 else if (FnInfo->isStr("strndup"))
3823 return Builtin::BIstrndup;
3824 else if (FnInfo->isStr("strlen"))
3825 return Builtin::BIstrlen;
3826 else if (FnInfo->isStr("bzero"))
3827 return Builtin::BIbzero;
3828 }
3829 break;
3830 }
3831 return 0;
3832}
3833
3834unsigned FunctionDecl::getODRHash() const {
3835 assert(hasODRHash())((hasODRHash()) ? static_cast<void> (0) : __assert_fail
("hasODRHash()", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3835, __PRETTY_FUNCTION__))
;
3836 return ODRHash;
3837}
3838
3839unsigned FunctionDecl::getODRHash() {
3840 if (hasODRHash())
3841 return ODRHash;
3842
3843 if (auto *FT = getInstantiatedFromMemberFunction()) {
3844 setHasODRHash(true);
3845 ODRHash = FT->getODRHash();
3846 return ODRHash;
3847 }
3848
3849 class ODRHash Hash;
3850 Hash.AddFunctionDecl(this);
3851 setHasODRHash(true);
3852 ODRHash = Hash.CalculateHash();
3853 return ODRHash;
3854}
3855
3856//===----------------------------------------------------------------------===//
3857// FieldDecl Implementation
3858//===----------------------------------------------------------------------===//
3859
3860FieldDecl *FieldDecl::Create(const ASTContext &C, DeclContext *DC,
3861 SourceLocation StartLoc, SourceLocation IdLoc,
3862 IdentifierInfo *Id, QualType T,
3863 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
3864 InClassInitStyle InitStyle) {
3865 return new (C, DC) FieldDecl(Decl::Field, DC, StartLoc, IdLoc, Id, T, TInfo,
3866 BW, Mutable, InitStyle);
3867}
3868
3869FieldDecl *FieldDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3870 return new (C, ID) FieldDecl(Field, nullptr, SourceLocation(),
3871 SourceLocation(), nullptr, QualType(), nullptr,
3872 nullptr, false, ICIS_NoInit);
3873}
3874
3875bool FieldDecl::isAnonymousStructOrUnion() const {
3876 if (!isImplicit() || getDeclName())
3877 return false;
3878
3879 if (const auto *Record = getType()->getAs<RecordType>())
3880 return Record->getDecl()->isAnonymousStructOrUnion();
3881
3882 return false;
3883}
3884
3885unsigned FieldDecl::getBitWidthValue(const ASTContext &Ctx) const {
3886 assert(isBitField() && "not a bitfield")((isBitField() && "not a bitfield") ? static_cast<
void> (0) : __assert_fail ("isBitField() && \"not a bitfield\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3886, __PRETTY_FUNCTION__))
;
3887 return getBitWidth()->EvaluateKnownConstInt(Ctx).getZExtValue();
3888}
3889
3890bool FieldDecl::isZeroLengthBitField(const ASTContext &Ctx) const {
3891 return isUnnamedBitfield() && !getBitWidth()->isValueDependent() &&
3892 getBitWidthValue(Ctx) == 0;
3893}
3894
3895unsigned FieldDecl::getFieldIndex() const {
3896 const FieldDecl *Canonical = getCanonicalDecl();
3897 if (Canonical != this)
3898 return Canonical->getFieldIndex();
3899
3900 if (CachedFieldIndex) return CachedFieldIndex - 1;
3901
3902 unsigned Index = 0;
3903 const RecordDecl *RD = getParent()->getDefinition();
3904 assert(RD && "requested index for field of struct with no definition")((RD && "requested index for field of struct with no definition"
) ? static_cast<void> (0) : __assert_fail ("RD && \"requested index for field of struct with no definition\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3904, __PRETTY_FUNCTION__))
;
3905
3906 for (auto *Field : RD->fields()) {
3907 Field->getCanonicalDecl()->CachedFieldIndex = Index + 1;
3908 ++Index;
3909 }
3910
3911 assert(CachedFieldIndex && "failed to find field in parent")((CachedFieldIndex && "failed to find field in parent"
) ? static_cast<void> (0) : __assert_fail ("CachedFieldIndex && \"failed to find field in parent\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3911, __PRETTY_FUNCTION__))
;
3912 return CachedFieldIndex - 1;
3913}
3914
3915SourceRange FieldDecl::getSourceRange() const {
3916 const Expr *FinalExpr = getInClassInitializer();
3917 if (!FinalExpr)
3918 FinalExpr = getBitWidth();
3919 if (FinalExpr)
3920 return SourceRange(getInnerLocStart(), FinalExpr->getEndLoc());
3921 return DeclaratorDecl::getSourceRange();
3922}
3923
3924void FieldDecl::setCapturedVLAType(const VariableArrayType *VLAType) {
3925 assert((getParent()->isLambda() || getParent()->isCapturedRecord()) &&(((getParent()->isLambda() || getParent()->isCapturedRecord
()) && "capturing type in non-lambda or captured record."
) ? static_cast<void> (0) : __assert_fail ("(getParent()->isLambda() || getParent()->isCapturedRecord()) && \"capturing type in non-lambda or captured record.\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3926, __PRETTY_FUNCTION__))
3926 "capturing type in non-lambda or captured record.")(((getParent()->isLambda() || getParent()->isCapturedRecord
()) && "capturing type in non-lambda or captured record."
) ? static_cast<void> (0) : __assert_fail ("(getParent()->isLambda() || getParent()->isCapturedRecord()) && \"capturing type in non-lambda or captured record.\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3926, __PRETTY_FUNCTION__))
;
3927 assert(InitStorage.getInt() == ISK_NoInit &&((InitStorage.getInt() == ISK_NoInit && InitStorage.getPointer
() == nullptr && "bit width, initializer or captured type already set"
) ? static_cast<void> (0) : __assert_fail ("InitStorage.getInt() == ISK_NoInit && InitStorage.getPointer() == nullptr && \"bit width, initializer or captured type already set\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3929, __PRETTY_FUNCTION__))
3928 InitStorage.getPointer() == nullptr &&((InitStorage.getInt() == ISK_NoInit && InitStorage.getPointer
() == nullptr && "bit width, initializer or captured type already set"
) ? static_cast<void> (0) : __assert_fail ("InitStorage.getInt() == ISK_NoInit && InitStorage.getPointer() == nullptr && \"bit width, initializer or captured type already set\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3929, __PRETTY_FUNCTION__))
3929 "bit width, initializer or captured type already set")((InitStorage.getInt() == ISK_NoInit && InitStorage.getPointer
() == nullptr && "bit width, initializer or captured type already set"
) ? static_cast<void> (0) : __assert_fail ("InitStorage.getInt() == ISK_NoInit && InitStorage.getPointer() == nullptr && \"bit width, initializer or captured type already set\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3929, __PRETTY_FUNCTION__))
;
3930 InitStorage.setPointerAndInt(const_cast<VariableArrayType *>(VLAType),
3931 ISK_CapturedVLAType);
3932}
3933
3934//===----------------------------------------------------------------------===//
3935// TagDecl Implementation
3936//===----------------------------------------------------------------------===//
3937
3938TagDecl::TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3939 SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
3940 SourceLocation StartL)
3941 : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), redeclarable_base(C),
3942 TypedefNameDeclOrQualifier((TypedefNameDecl *)nullptr) {
3943 assert((DK != Enum || TK == TTK_Enum) &&(((DK != Enum || TK == TTK_Enum) && "EnumDecl not matched with TTK_Enum"
) ? static_cast<void> (0) : __assert_fail ("(DK != Enum || TK == TTK_Enum) && \"EnumDecl not matched with TTK_Enum\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3944, __PRETTY_FUNCTION__))
3944 "EnumDecl not matched with TTK_Enum")(((DK != Enum || TK == TTK_Enum) && "EnumDecl not matched with TTK_Enum"
) ? static_cast<void> (0) : __assert_fail ("(DK != Enum || TK == TTK_Enum) && \"EnumDecl not matched with TTK_Enum\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3944, __PRETTY_FUNCTION__))
;
3945 setPreviousDecl(PrevDecl);
3946 setTagKind(TK);
3947 setCompleteDefinition(false);
3948 setBeingDefined(false);
3949 setEmbeddedInDeclarator(false);
3950 setFreeStanding(false);
3951 setCompleteDefinitionRequired(false);
3952}
3953
3954SourceLocation TagDecl::getOuterLocStart() const {
3955 return getTemplateOrInnerLocStart(this);
3956}
3957
3958SourceRange TagDecl::getSourceRange() const {
3959 SourceLocation RBraceLoc = BraceRange.getEnd();
3960 SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation();
3961 return SourceRange(getOuterLocStart(), E);
3962}
3963
3964TagDecl *TagDecl::getCanonicalDecl() { return getFirstDecl(); }
3965
3966void TagDecl::setTypedefNameForAnonDecl(TypedefNameDecl *TDD) {
3967 TypedefNameDeclOrQualifier = TDD;
3968 if (const Type *T = getTypeForDecl()) {
3969 (void)T;
3970 assert(T->isLinkageValid())((T->isLinkageValid()) ? static_cast<void> (0) : __assert_fail
("T->isLinkageValid()", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3970, __PRETTY_FUNCTION__))
;
3971 }
3972 assert(isLinkageValid())((isLinkageValid()) ? static_cast<void> (0) : __assert_fail
("isLinkageValid()", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3972, __PRETTY_FUNCTION__))
;
3973}
3974
3975void TagDecl::startDefinition() {
3976 setBeingDefined(true);
3977
3978 if (auto *D = dyn_cast<CXXRecordDecl>(this)) {
3979 struct CXXRecordDecl::DefinitionData *Data =
3980 new (getASTContext()) struct CXXRecordDecl::DefinitionData(D);
3981 for (auto I : redecls())
3982 cast<CXXRecordDecl>(I)->DefinitionData = Data;
3983 }
3984}
3985
3986void TagDecl::completeDefinition() {
3987 assert((!isa<CXXRecordDecl>(this) ||(((!isa<CXXRecordDecl>(this) || cast<CXXRecordDecl>
(this)->hasDefinition()) && "definition completed but not started"
) ? static_cast<void> (0) : __assert_fail ("(!isa<CXXRecordDecl>(this) || cast<CXXRecordDecl>(this)->hasDefinition()) && \"definition completed but not started\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3989, __PRETTY_FUNCTION__))
3988 cast<CXXRecordDecl>(this)->hasDefinition()) &&(((!isa<CXXRecordDecl>(this) || cast<CXXRecordDecl>
(this)->hasDefinition()) && "definition completed but not started"
) ? static_cast<void> (0) : __assert_fail ("(!isa<CXXRecordDecl>(this) || cast<CXXRecordDecl>(this)->hasDefinition()) && \"definition completed but not started\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3989, __PRETTY_FUNCTION__))
3989 "definition completed but not started")(((!isa<CXXRecordDecl>(this) || cast<CXXRecordDecl>
(this)->hasDefinition()) && "definition completed but not started"
) ? static_cast<void> (0) : __assert_fail ("(!isa<CXXRecordDecl>(this) || cast<CXXRecordDecl>(this)->hasDefinition()) && \"definition completed but not started\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 3989, __PRETTY_FUNCTION__))
;
3990
3991 setCompleteDefinition(true);
3992 setBeingDefined(false);
3993
3994 if (ASTMutationListener *L = getASTMutationListener())
3995 L->CompletedTagDefinition(this);
3996}
3997
3998TagDecl *TagDecl::getDefinition() const {
3999 if (isCompleteDefinition())
4000 return const_cast<TagDecl *>(this);
4001
4002 // If it's possible for us to have an out-of-date definition, check now.
4003 if (mayHaveOutOfDateDef()) {
4004 if (IdentifierInfo *II = getIdentifier()) {
4005 if (II->isOutOfDate()) {
4006 updateOutOfDate(*II);
4007 }
4008 }
4009 }
4010
4011 if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(this))
4012 return CXXRD->getDefinition();
4013
4014 for (auto R : redecls())
4015 if (R->isCompleteDefinition())
4016 return R;
4017
4018 return nullptr;
4019}
4020
4021void TagDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) {
4022 if (QualifierLoc) {
4023 // Make sure the extended qualifier info is allocated.
4024 if (!hasExtInfo())
4025 TypedefNameDeclOrQualifier = new (getASTContext()) ExtInfo;
4026 // Set qualifier info.
4027 getExtInfo()->QualifierLoc = QualifierLoc;
4028 } else {
4029 // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
4030 if (hasExtInfo()) {
4031 if (getExtInfo()->NumTemplParamLists == 0) {
4032 getASTContext().Deallocate(getExtInfo());
4033 TypedefNameDeclOrQualifier = (TypedefNameDecl *)nullptr;
4034 }
4035 else
4036 getExtInfo()->QualifierLoc = QualifierLoc;
4037 }
4038 }
4039}
4040
4041void TagDecl::setTemplateParameterListsInfo(
4042 ASTContext &Context, ArrayRef<TemplateParameterList *> TPLists) {
4043 assert(!TPLists.empty())((!TPLists.empty()) ? static_cast<void> (0) : __assert_fail
("!TPLists.empty()", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4043, __PRETTY_FUNCTION__))
;
4044 // Make sure the extended decl info is allocated.
4045 if (!hasExtInfo())
4046 // Allocate external info struct.
4047 TypedefNameDeclOrQualifier = new (getASTContext()) ExtInfo;
4048 // Set the template parameter lists info.
4049 getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
4050}
4051
4052//===----------------------------------------------------------------------===//
4053// EnumDecl Implementation
4054//===----------------------------------------------------------------------===//
4055
4056EnumDecl::EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
4057 SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
4058 bool Scoped, bool ScopedUsingClassTag, bool Fixed)
4059 : TagDecl(Enum, TTK_Enum, C, DC, IdLoc, Id, PrevDecl, StartLoc) {
4060 assert(Scoped || !ScopedUsingClassTag)((Scoped || !ScopedUsingClassTag) ? static_cast<void> (
0) : __assert_fail ("Scoped || !ScopedUsingClassTag", "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4060, __PRETTY_FUNCTION__))
;
4061 IntegerType = nullptr;
4062 setNumPositiveBits(0);
4063 setNumNegativeBits(0);
4064 setScoped(Scoped);
4065 setScopedUsingClassTag(ScopedUsingClassTag);
4066 setFixed(Fixed);
4067 setHasODRHash(false);
4068 ODRHash = 0;
4069}
4070
4071void EnumDecl::anchor() {}
4072
4073EnumDecl *EnumDecl::Create(ASTContext &C, DeclContext *DC,
4074 SourceLocation StartLoc, SourceLocation IdLoc,
4075 IdentifierInfo *Id,
4076 EnumDecl *PrevDecl, bool IsScoped,
4077 bool IsScopedUsingClassTag, bool IsFixed) {
4078 auto *Enum = new (C, DC) EnumDecl(C, DC, StartLoc, IdLoc, Id, PrevDecl,
4079 IsScoped, IsScopedUsingClassTag, IsFixed);
4080 Enum->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
4081 C.getTypeDeclType(Enum, PrevDecl);
4082 return Enum;
4083}
4084
4085EnumDecl *EnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
4086 EnumDecl *Enum =
4087 new (C, ID) EnumDecl(C, nullptr, SourceLocation(), SourceLocation(),
4088 nullptr, nullptr, false, false, false);
4089 Enum->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
4090 return Enum;
4091}
4092
4093SourceRange EnumDecl::getIntegerTypeRange() const {
4094 if (const TypeSourceInfo *TI = getIntegerTypeSourceInfo())
4095 return TI->getTypeLoc().getSourceRange();
4096 return SourceRange();
4097}
4098
4099void EnumDecl::completeDefinition(QualType NewType,
4100 QualType NewPromotionType,
4101 unsigned NumPositiveBits,
4102 unsigned NumNegativeBits) {
4103 assert(!isCompleteDefinition() && "Cannot redefine enums!")((!isCompleteDefinition() && "Cannot redefine enums!"
) ? static_cast<void> (0) : __assert_fail ("!isCompleteDefinition() && \"Cannot redefine enums!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4103, __PRETTY_FUNCTION__))
;
4104 if (!IntegerType)
4105 IntegerType = NewType.getTypePtr();
4106 PromotionType = NewPromotionType;
4107 setNumPositiveBits(NumPositiveBits);
4108 setNumNegativeBits(NumNegativeBits);
4109 TagDecl::completeDefinition();
4110}
4111
4112bool EnumDecl::isClosed() const {
4113 if (const auto *A = getAttr<EnumExtensibilityAttr>())
4114 return A->getExtensibility() == EnumExtensibilityAttr::Closed;
4115 return true;
4116}
4117
4118bool EnumDecl::isClosedFlag() const {
4119 return isClosed() && hasAttr<FlagEnumAttr>();
4120}
4121
4122bool EnumDecl::isClosedNonFlag() const {
4123 return isClosed() && !hasAttr<FlagEnumAttr>();
4124}
4125
4126TemplateSpecializationKind EnumDecl::getTemplateSpecializationKind() const {
4127 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
4128 return MSI->getTemplateSpecializationKind();
4129
4130 return TSK_Undeclared;
4131}
4132
4133void EnumDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
4134 SourceLocation PointOfInstantiation) {
4135 MemberSpecializationInfo *MSI = getMemberSpecializationInfo();
4136 assert(MSI && "Not an instantiated member enumeration?")((MSI && "Not an instantiated member enumeration?") ?
static_cast<void> (0) : __assert_fail ("MSI && \"Not an instantiated member enumeration?\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4136, __PRETTY_FUNCTION__))
;
4137 MSI->setTemplateSpecializationKind(TSK);
4138 if (TSK != TSK_ExplicitSpecialization &&
4139 PointOfInstantiation.isValid() &&
4140 MSI->getPointOfInstantiation().isInvalid())
4141 MSI->setPointOfInstantiation(PointOfInstantiation);
4142}
4143
4144EnumDecl *EnumDecl::getTemplateInstantiationPattern() const {
4145 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
4146 if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
4147 EnumDecl *ED = getInstantiatedFromMemberEnum();
4148 while (auto *NewED = ED->getInstantiatedFromMemberEnum())
4149 ED = NewED;
4150 return getDefinitionOrSelf(ED);
4151 }
4152 }
4153
4154 assert(!isTemplateInstantiation(getTemplateSpecializationKind()) &&((!isTemplateInstantiation(getTemplateSpecializationKind()) &&
"couldn't find pattern for enum instantiation") ? static_cast
<void> (0) : __assert_fail ("!isTemplateInstantiation(getTemplateSpecializationKind()) && \"couldn't find pattern for enum instantiation\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4155, __PRETTY_FUNCTION__))
4155 "couldn't find pattern for enum instantiation")((!isTemplateInstantiation(getTemplateSpecializationKind()) &&
"couldn't find pattern for enum instantiation") ? static_cast
<void> (0) : __assert_fail ("!isTemplateInstantiation(getTemplateSpecializationKind()) && \"couldn't find pattern for enum instantiation\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4155, __PRETTY_FUNCTION__))
;
4156 return nullptr;
4157}
4158
4159EnumDecl *EnumDecl::getInstantiatedFromMemberEnum() const {
4160 if (SpecializationInfo)
4161 return cast<EnumDecl>(SpecializationInfo->getInstantiatedFrom());
4162
4163 return nullptr;
4164}
4165
4166void EnumDecl::setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
4167 TemplateSpecializationKind TSK) {
4168 assert(!SpecializationInfo && "Member enum is already a specialization")((!SpecializationInfo && "Member enum is already a specialization"
) ? static_cast<void> (0) : __assert_fail ("!SpecializationInfo && \"Member enum is already a specialization\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4168, __PRETTY_FUNCTION__))
;
4169 SpecializationInfo = new (C) MemberSpecializationInfo(ED, TSK);
4170}
4171
4172unsigned EnumDecl::getODRHash() {
4173 if (hasODRHash())
4174 return ODRHash;
4175
4176 class ODRHash Hash;
4177 Hash.AddEnumDecl(this);
4178 setHasODRHash(true);
4179 ODRHash = Hash.CalculateHash();
4180 return ODRHash;
4181}
4182
4183//===----------------------------------------------------------------------===//
4184// RecordDecl Implementation
4185//===----------------------------------------------------------------------===//
4186
4187RecordDecl::RecordDecl(Kind DK, TagKind TK, const ASTContext &C,
4188 DeclContext *DC, SourceLocation StartLoc,
4189 SourceLocation IdLoc, IdentifierInfo *Id,
4190 RecordDecl *PrevDecl)
4191 : TagDecl(DK, TK, C, DC, IdLoc, Id, PrevDecl, StartLoc) {
4192 assert(classof(static_cast<Decl *>(this)) && "Invalid Kind!")((classof(static_cast<Decl *>(this)) && "Invalid Kind!"
) ? static_cast<void> (0) : __assert_fail ("classof(static_cast<Decl *>(this)) && \"Invalid Kind!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4192, __PRETTY_FUNCTION__))
;
4193 setHasFlexibleArrayMember(false);
4194 setAnonymousStructOrUnion(false);
4195 setHasObjectMember(false);
4196 setHasVolatileMember(false);
4197 setHasLoadedFieldsFromExternalStorage(false);
4198 setNonTrivialToPrimitiveDefaultInitialize(false);
4199 setNonTrivialToPrimitiveCopy(false);
4200 setNonTrivialToPrimitiveDestroy(false);
4201 setParamDestroyedInCallee(false);
4202 setArgPassingRestrictions(APK_CanPassInRegs);
4203}
4204
4205RecordDecl *RecordDecl::Create(const ASTContext &C, TagKind TK, DeclContext *DC,
4206 SourceLocation StartLoc, SourceLocation IdLoc,
4207 IdentifierInfo *Id, RecordDecl* PrevDecl) {
4208 RecordDecl *R = new (C, DC) RecordDecl(Record, TK, C, DC,
4209 StartLoc, IdLoc, Id, PrevDecl);
4210 R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
4211
4212 C.getTypeDeclType(R, PrevDecl);
4213 return R;
4214}
4215
4216RecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
4217 RecordDecl *R =
4218 new (C, ID) RecordDecl(Record, TTK_Struct, C, nullptr, SourceLocation(),
4219 SourceLocation(), nullptr, nullptr);
4220 R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
4221 return R;
4222}
4223
4224bool RecordDecl::isInjectedClassName() const {
4225 return isImplicit() && getDeclName() && getDeclContext()->isRecord() &&
4226 cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName();
4227}
4228
4229bool RecordDecl::isLambda() const {
4230 if (auto RD = dyn_cast<CXXRecordDecl>(this))
4231 return RD->isLambda();
4232 return false;
4233}
4234
4235bool RecordDecl::isCapturedRecord() const {
4236 return hasAttr<CapturedRecordAttr>();
4237}
4238
4239void RecordDecl::setCapturedRecord() {
4240 addAttr(CapturedRecordAttr::CreateImplicit(getASTContext()));
1
Calling 'CapturedRecordAttr::CreateImplicit'
4241}
4242
4243RecordDecl::field_iterator RecordDecl::field_begin() const {
4244 if (hasExternalLexicalStorage() && !hasLoadedFieldsFromExternalStorage())
4245 LoadFieldsFromExternalStorage();
4246
4247 return field_iterator(decl_iterator(FirstDecl));
4248}
4249
4250/// completeDefinition - Notes that the definition of this type is now
4251/// complete.
4252void RecordDecl::completeDefinition() {
4253 assert(!isCompleteDefinition() && "Cannot redefine record!")((!isCompleteDefinition() && "Cannot redefine record!"
) ? static_cast<void> (0) : __assert_fail ("!isCompleteDefinition() && \"Cannot redefine record!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4253, __PRETTY_FUNCTION__))
;
4254 TagDecl::completeDefinition();
4255}
4256
4257/// isMsStruct - Get whether or not this record uses ms_struct layout.
4258/// This which can be turned on with an attribute, pragma, or the
4259/// -mms-bitfields command-line option.
4260bool RecordDecl::isMsStruct(const ASTContext &C) const {
4261 return hasAttr<MSStructAttr>() || C.getLangOpts().MSBitfields == 1;
4262}
4263
4264void RecordDecl::LoadFieldsFromExternalStorage() const {
4265 ExternalASTSource *Source = getASTContext().getExternalSource();
4266 assert(hasExternalLexicalStorage() && Source && "No external storage?")((hasExternalLexicalStorage() && Source && "No external storage?"
) ? static_cast<void> (0) : __assert_fail ("hasExternalLexicalStorage() && Source && \"No external storage?\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4266, __PRETTY_FUNCTION__))
;
4267
4268 // Notify that we have a RecordDecl doing some initialization.
4269 ExternalASTSource::Deserializing TheFields(Source);
4270
4271 SmallVector<Decl*, 64> Decls;
4272 setHasLoadedFieldsFromExternalStorage(true);
4273 Source->FindExternalLexicalDecls(this, [](Decl::Kind K) {
4274 return FieldDecl::classofKind(K) || IndirectFieldDecl::classofKind(K);
4275 }, Decls);
4276
4277#ifndef NDEBUG
4278 // Check that all decls we got were FieldDecls.
4279 for (unsigned i=0, e=Decls.size(); i != e; ++i)
4280 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]))((isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>
(Decls[i])) ? static_cast<void> (0) : __assert_fail ("isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i])"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4280, __PRETTY_FUNCTION__))
;
4281#endif
4282
4283 if (Decls.empty())
4284 return;
4285
4286 std::tie(FirstDecl, LastDecl) = BuildDeclChain(Decls,
4287 /*FieldsAlreadyLoaded=*/false);
4288}
4289
4290bool RecordDecl::mayInsertExtraPadding(bool EmitRemark) const {
4291 ASTContext &Context = getASTContext();
4292 const SanitizerMask EnabledAsanMask = Context.getLangOpts().Sanitize.Mask &
4293 (SanitizerKind::Address | SanitizerKind::KernelAddress);
4294 if (!EnabledAsanMask || !Context.getLangOpts().SanitizeAddressFieldPadding)
4295 return false;
4296 const auto &Blacklist = Context.getSanitizerBlacklist();
4297 const auto *CXXRD = dyn_cast<CXXRecordDecl>(this);
4298 // We may be able to relax some of these requirements.
4299 int ReasonToReject = -1;
4300 if (!CXXRD || CXXRD->isExternCContext())
4301 ReasonToReject = 0; // is not C++.
4302 else if (CXXRD->hasAttr<PackedAttr>())
4303 ReasonToReject = 1; // is packed.
4304 else if (CXXRD->isUnion())
4305 ReasonToReject = 2; // is a union.
4306 else if (CXXRD->isTriviallyCopyable())
4307 ReasonToReject = 3; // is trivially copyable.
4308 else if (CXXRD->hasTrivialDestructor())
4309 ReasonToReject = 4; // has trivial destructor.
4310 else if (CXXRD->isStandardLayout())
4311 ReasonToReject = 5; // is standard layout.
4312 else if (Blacklist.isBlacklistedLocation(EnabledAsanMask, getLocation(),
4313 "field-padding"))
4314 ReasonToReject = 6; // is in a blacklisted file.
4315 else if (Blacklist.isBlacklistedType(EnabledAsanMask,
4316 getQualifiedNameAsString(),
4317 "field-padding"))
4318 ReasonToReject = 7; // is blacklisted.
4319
4320 if (EmitRemark) {
4321 if (ReasonToReject >= 0)
4322 Context.getDiagnostics().Report(
4323 getLocation(),
4324 diag::remark_sanitize_address_insert_extra_padding_rejected)
4325 << getQualifiedNameAsString() << ReasonToReject;
4326 else
4327 Context.getDiagnostics().Report(
4328 getLocation(),
4329 diag::remark_sanitize_address_insert_extra_padding_accepted)
4330 << getQualifiedNameAsString();
4331 }
4332 return ReasonToReject < 0;
4333}
4334
4335const FieldDecl *RecordDecl::findFirstNamedDataMember() const {
4336 for (const auto *I : fields()) {
4337 if (I->getIdentifier())
4338 return I;
4339
4340 if (const auto *RT = I->getType()->getAs<RecordType>())
4341 if (const FieldDecl *NamedDataMember =
4342 RT->getDecl()->findFirstNamedDataMember())
4343 return NamedDataMember;
4344 }
4345
4346 // We didn't find a named data member.
4347 return nullptr;
4348}
4349
4350//===----------------------------------------------------------------------===//
4351// BlockDecl Implementation
4352//===----------------------------------------------------------------------===//
4353
4354BlockDecl::BlockDecl(DeclContext *DC, SourceLocation CaretLoc)
4355 : Decl(Block, DC, CaretLoc), DeclContext(Block) {
4356 setIsVariadic(false);
4357 setCapturesCXXThis(false);
4358 setBlockMissingReturnType(true);
4359 setIsConversionFromLambda(false);
4360 setDoesNotEscape(false);
4361 setCanAvoidCopyToHeap(false);
4362}
4363
4364void BlockDecl::setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
4365 assert(!ParamInfo && "Already has param info!")((!ParamInfo && "Already has param info!") ? static_cast
<void> (0) : __assert_fail ("!ParamInfo && \"Already has param info!\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4365, __PRETTY_FUNCTION__))
;
4366
4367 // Zero params -> null pointer.
4368 if (!NewParamInfo.empty()) {
4369 NumParams = NewParamInfo.size();
4370 ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()];
4371 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
4372 }
4373}
4374
4375void BlockDecl::setCaptures(ASTContext &Context, ArrayRef<Capture> Captures,
4376 bool CapturesCXXThis) {
4377 this->setCapturesCXXThis(CapturesCXXThis);
4378 this->NumCaptures = Captures.size();
4379
4380 if (Captures.empty()) {
4381 this->Captures = nullptr;
4382 return;
4383 }
4384
4385 this->Captures = Captures.copy(Context).data();
4386}
4387
4388bool BlockDecl::capturesVariable(const VarDecl *variable) const {
4389 for (const auto &I : captures())
4390 // Only auto vars can be captured, so no redeclaration worries.
4391 if (I.getVariable() == variable)
4392 return true;
4393
4394 return false;
4395}
4396
4397SourceRange BlockDecl::getSourceRange() const {
4398 return SourceRange(getLocation(), Body ? Body->getEndLoc() : getLocation());
4399}
4400
4401//===----------------------------------------------------------------------===//
4402// Other Decl Allocation/Deallocation Method Implementations
4403//===----------------------------------------------------------------------===//
4404
4405void TranslationUnitDecl::anchor() {}
4406
4407TranslationUnitDecl *TranslationUnitDecl::Create(ASTContext &C) {
4408 return new (C, (DeclContext *)nullptr) TranslationUnitDecl(C);
4409}
4410
4411void PragmaCommentDecl::anchor() {}
4412
4413PragmaCommentDecl *PragmaCommentDecl::Create(const ASTContext &C,
4414 TranslationUnitDecl *DC,
4415 SourceLocation CommentLoc,
4416 PragmaMSCommentKind CommentKind,
4417 StringRef Arg) {
4418 PragmaCommentDecl *PCD =
4419 new (C, DC, additionalSizeToAlloc<char>(Arg.size() + 1))
4420 PragmaCommentDecl(DC, CommentLoc, CommentKind);
4421 memcpy(PCD->getTrailingObjects<char>(), Arg.data(), Arg.size());
4422 PCD->getTrailingObjects<char>()[Arg.size()] = '\0';
4423 return PCD;
4424}
4425
4426PragmaCommentDecl *PragmaCommentDecl::CreateDeserialized(ASTContext &C,
4427 unsigned ID,
4428 unsigned ArgSize) {
4429 return new (C, ID, additionalSizeToAlloc<char>(ArgSize + 1))
4430 PragmaCommentDecl(nullptr, SourceLocation(), PCK_Unknown);
4431}
4432
4433void PragmaDetectMismatchDecl::anchor() {}
4434
4435PragmaDetectMismatchDecl *
4436PragmaDetectMismatchDecl::Create(const ASTContext &C, TranslationUnitDecl *DC,
4437 SourceLocation Loc, StringRef Name,
4438 StringRef Value) {
4439 size_t ValueStart = Name.size() + 1;
4440 PragmaDetectMismatchDecl *PDMD =
4441 new (C, DC, additionalSizeToAlloc<char>(ValueStart + Value.size() + 1))
4442 PragmaDetectMismatchDecl(DC, Loc, ValueStart);
4443 memcpy(PDMD->getTrailingObjects<char>(), Name.data(), Name.size());
4444 PDMD->getTrailingObjects<char>()[Name.size()] = '\0';
4445 memcpy(PDMD->getTrailingObjects<char>() + ValueStart, Value.data(),
4446 Value.size());
4447 PDMD->getTrailingObjects<char>()[ValueStart + Value.size()] = '\0';
4448 return PDMD;
4449}
4450
4451PragmaDetectMismatchDecl *
4452PragmaDetectMismatchDecl::CreateDeserialized(ASTContext &C, unsigned ID,
4453 unsigned NameValueSize) {
4454 return new (C, ID, additionalSizeToAlloc<char>(NameValueSize + 1))
4455 PragmaDetectMismatchDecl(nullptr, SourceLocation(), 0);
4456}
4457
4458void ExternCContextDecl::anchor() {}
4459
4460ExternCContextDecl *ExternCContextDecl::Create(const ASTContext &C,
4461 TranslationUnitDecl *DC) {
4462 return new (C, DC) ExternCContextDecl(DC);
4463}
4464
4465void LabelDecl::anchor() {}
4466
4467LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC,
4468 SourceLocation IdentL, IdentifierInfo *II) {
4469 return new (C, DC) LabelDecl(DC, IdentL, II, nullptr, IdentL);
4470}
4471
4472LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC,
4473 SourceLocation IdentL, IdentifierInfo *II,
4474 SourceLocation GnuLabelL) {
4475 assert(GnuLabelL != IdentL && "Use this only for GNU local labels")((GnuLabelL != IdentL && "Use this only for GNU local labels"
) ? static_cast<void> (0) : __assert_fail ("GnuLabelL != IdentL && \"Use this only for GNU local labels\""
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4475, __PRETTY_FUNCTION__))
;
4476 return new (C, DC) LabelDecl(DC, IdentL, II, nullptr, GnuLabelL);
4477}
4478
4479LabelDecl *LabelDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
4480 return new (C, ID) LabelDecl(nullptr, SourceLocation(), nullptr, nullptr,
4481 SourceLocation());
4482}
4483
4484void LabelDecl::setMSAsmLabel(StringRef Name) {
4485 char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
4486 memcpy(Buffer, Name.data(), Name.size());
4487 Buffer[Name.size()] = '\0';
4488 MSAsmName = Buffer;
4489}
4490
4491void ValueDecl::anchor() {}
4492
4493bool ValueDecl::isWeak() const {
4494 for (const auto *I : attrs())
4495 if (isa<WeakAttr>(I) || isa<WeakRefAttr>(I))
4496 return true;
4497
4498 return isWeakImported();
4499}
4500
4501void ImplicitParamDecl::anchor() {}
4502
4503ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, DeclContext *DC,
4504 SourceLocation IdLoc,
4505 IdentifierInfo *Id, QualType Type,
4506 ImplicitParamKind ParamKind) {
4507 return new (C, DC) ImplicitParamDecl(C, DC, IdLoc, Id, Type, ParamKind);
4508}
4509
4510ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, QualType Type,
4511 ImplicitParamKind ParamKind) {
4512 return new (C, nullptr) ImplicitParamDecl(C, Type, ParamKind);
4513}
4514
4515ImplicitParamDecl *ImplicitParamDecl::CreateDeserialized(ASTContext &C,
4516 unsigned ID) {
4517 return new (C, ID) ImplicitParamDecl(C, QualType(), ImplicitParamKind::Other);
4518}
4519
4520FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC,
4521 SourceLocation StartLoc,
4522 const DeclarationNameInfo &NameInfo,
4523 QualType T, TypeSourceInfo *TInfo,
4524 StorageClass SC,
4525 bool isInlineSpecified,
4526 bool hasWrittenPrototype,
4527 bool isConstexprSpecified) {
4528 FunctionDecl *New =
4529 new (C, DC) FunctionDecl(Function, C, DC, StartLoc, NameInfo, T, TInfo,
4530 SC, isInlineSpecified, isConstexprSpecified);
4531 New->setHasWrittenPrototype(hasWrittenPrototype);
4532 return New;
4533}
4534
4535FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
4536 return new (C, ID) FunctionDecl(Function, C, nullptr, SourceLocation(),
4537 DeclarationNameInfo(), QualType(), nullptr,
4538 SC_None, false, false);
4539}
4540
4541BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
4542 return new (C, DC) BlockDecl(DC, L);
4543}
4544
4545BlockDecl *BlockDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
4546 return new (C, ID) BlockDecl(nullptr, SourceLocation());
4547}
4548
4549CapturedDecl::CapturedDecl(DeclContext *DC, unsigned NumParams)
4550 : Decl(Captured, DC, SourceLocation()), DeclContext(Captured),
4551 NumParams(NumParams), ContextParam(0), BodyAndNothrow(nullptr, false) {}
4552
4553CapturedDecl *CapturedDecl::Create(ASTContext &C, DeclContext *DC,
4554 unsigned NumParams) {
4555 return new (C, DC, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
4556 CapturedDecl(DC, NumParams);
4557}
4558
4559CapturedDecl *CapturedDecl::CreateDeserialized(ASTContext &C, unsigned ID,
4560 unsigned NumParams) {
4561 return new (C, ID, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
4562 CapturedDecl(nullptr, NumParams);
4563}
4564
4565Stmt *CapturedDecl::getBody() const { return BodyAndNothrow.getPointer(); }
4566void CapturedDecl::setBody(Stmt *B) { BodyAndNothrow.setPointer(B); }
4567
4568bool CapturedDecl::isNothrow() const { return BodyAndNothrow.getInt(); }
4569void CapturedDecl::setNothrow(bool Nothrow) { BodyAndNothrow.setInt(Nothrow); }
4570
4571EnumConstantDecl *EnumConstantDecl::Create(ASTContext &C, EnumDecl *CD,
4572 SourceLocation L,
4573 IdentifierInfo *Id, QualType T,
4574 Expr *E, const llvm::APSInt &V) {
4575 return new (C, CD) EnumConstantDecl(CD, L, Id, T, E, V);
4576}
4577
4578EnumConstantDecl *
4579EnumConstantDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
4580 return new (C, ID) EnumConstantDecl(nullptr, SourceLocation(), nullptr,
4581 QualType(), nullptr, llvm::APSInt());
4582}
4583
4584void IndirectFieldDecl::anchor() {}
4585
4586IndirectFieldDecl::IndirectFieldDecl(ASTContext &C, DeclContext *DC,
4587 SourceLocation L, DeclarationName N,
4588 QualType T,
4589 MutableArrayRef<NamedDecl *> CH)
4590 : ValueDecl(IndirectField, DC, L, N, T), Chaining(CH.data()),
4591 ChainingSize(CH.size()) {
4592 // In C++, indirect field declarations conflict with tag declarations in the
4593 // same scope, so add them to IDNS_Tag so that tag redeclaration finds them.
4594 if (C.getLangOpts().CPlusPlus)
4595 IdentifierNamespace |= IDNS_Tag;
4596}
4597
4598IndirectFieldDecl *
4599IndirectFieldDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
4600 IdentifierInfo *Id, QualType T,
4601 llvm::MutableArrayRef<NamedDecl *> CH) {
4602 return new (C, DC) IndirectFieldDecl(C, DC, L, Id, T, CH);
4603}
4604
4605IndirectFieldDecl *IndirectFieldDecl::CreateDeserialized(ASTContext &C,
4606 unsigned ID) {
4607 return new (C, ID) IndirectFieldDecl(C, nullptr, SourceLocation(),
4608 DeclarationName(), QualType(), None);
4609}
4610
4611SourceRange EnumConstantDecl::getSourceRange() const {
4612 SourceLocation End = getLocation();
4613 if (Init)
4614 End = Init->getEndLoc();
4615 return SourceRange(getLocation(), End);
4616}
4617
4618void TypeDecl::anchor() {}
4619
4620TypedefDecl *TypedefDecl::Create(ASTContext &C, DeclContext *DC,
4621 SourceLocation StartLoc, SourceLocation IdLoc,
4622 IdentifierInfo *Id, TypeSourceInfo *TInfo) {
4623 return new (C, DC) TypedefDecl(C, DC, StartLoc, IdLoc, Id, TInfo);
4624}
4625
4626void TypedefNameDecl::anchor() {}
4627
4628TagDecl *TypedefNameDecl::getAnonDeclWithTypedefName(bool AnyRedecl) const {
4629 if (auto *TT = getTypeSourceInfo()->getType()->getAs<TagType>()) {
4630 auto *OwningTypedef = TT->getDecl()->getTypedefNameForAnonDecl();
4631 auto *ThisTypedef = this;
4632 if (AnyRedecl && OwningTypedef) {
4633 OwningTypedef = OwningTypedef->getCanonicalDecl();
4634 ThisTypedef = ThisTypedef->getCanonicalDecl();
4635 }
4636 if (OwningTypedef == ThisTypedef)
4637 return TT->getDecl();
4638 }
4639
4640 return nullptr;
4641}
4642
4643bool TypedefNameDecl::isTransparentTagSlow() const {
4644 auto determineIsTransparent = [&]() {
4645 if (auto *TT = getUnderlyingType()->getAs<TagType>()) {
4646 if (auto *TD = TT->getDecl()) {
4647 if (TD->getName() != getName())
4648 return false;
4649 SourceLocation TTLoc = getLocation();
4650 SourceLocation TDLoc = TD->getLocation();
4651 if (!TTLoc.isMacroID() || !TDLoc.isMacroID())
4652 return false;
4653 SourceManager &SM = getASTContext().getSourceManager();
4654 return SM.getSpellingLoc(TTLoc) == SM.getSpellingLoc(TDLoc);
4655 }
4656 }
4657 return false;
4658 };
4659
4660 bool isTransparent = determineIsTransparent();
4661 MaybeModedTInfo.setInt((isTransparent << 1) | 1);
4662 return isTransparent;
4663}
4664
4665TypedefDecl *TypedefDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
4666 return new (C, ID) TypedefDecl(C, nullptr, SourceLocation(), SourceLocation(),
4667 nullptr, nullptr);
4668}
4669
4670TypeAliasDecl *TypeAliasDecl::Create(ASTContext &C, DeclContext *DC,
4671 SourceLocation StartLoc,
4672 SourceLocation IdLoc, IdentifierInfo *Id,
4673 TypeSourceInfo *TInfo) {
4674 return new (C, DC) TypeAliasDecl(C, DC, StartLoc, IdLoc, Id, TInfo);
4675}
4676
4677TypeAliasDecl *TypeAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
4678 return new (C, ID) TypeAliasDecl(C, nullptr, SourceLocation(),
4679 SourceLocation(), nullptr, nullptr);
4680}
4681
4682SourceRange TypedefDecl::getSourceRange() const {
4683 SourceLocation RangeEnd = getLocation();
4684 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
4685 if (typeIsPostfix(TInfo->getType()))
4686 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
4687 }
4688 return SourceRange(getBeginLoc(), RangeEnd);
4689}
4690
4691SourceRange TypeAliasDecl::getSourceRange() const {
4692 SourceLocation RangeEnd = getBeginLoc();
4693 if (TypeSourceInfo *TInfo = getTypeSourceInfo())
4694 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
4695 return SourceRange(getBeginLoc(), RangeEnd);
4696}
4697
4698void FileScopeAsmDecl::anchor() {}
4699
4700FileScopeAsmDecl *FileScopeAsmDecl::Create(ASTContext &C, DeclContext *DC,
4701 StringLiteral *Str,
4702 SourceLocation AsmLoc,
4703 SourceLocation RParenLoc) {
4704 return new (C, DC) FileScopeAsmDecl(DC, Str, AsmLoc, RParenLoc);
4705}
4706
4707FileScopeAsmDecl *FileScopeAsmDecl::CreateDeserialized(ASTContext &C,
4708 unsigned ID) {
4709 return new (C, ID) FileScopeAsmDecl(nullptr, nullptr, SourceLocation(),
4710 SourceLocation());
4711}
4712
4713void EmptyDecl::anchor() {}
4714
4715EmptyDecl *EmptyDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
4716 return new (C, DC) EmptyDecl(DC, L);
4717}
4718
4719EmptyDecl *EmptyDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
4720 return new (C, ID) EmptyDecl(nullptr, SourceLocation());
4721}
4722
4723//===----------------------------------------------------------------------===//
4724// ImportDecl Implementation
4725//===----------------------------------------------------------------------===//
4726
4727/// Retrieve the number of module identifiers needed to name the given
4728/// module.
4729static unsigned getNumModuleIdentifiers(Module *Mod) {
4730 unsigned Result = 1;
4731 while (Mod->Parent) {
4732 Mod = Mod->Parent;
4733 ++Result;
4734 }
4735 return Result;
4736}
4737
4738ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
4739 Module *Imported,
4740 ArrayRef<SourceLocation> IdentifierLocs)
4741 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, true) {
4742 assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size())((getNumModuleIdentifiers(Imported) == IdentifierLocs.size())
? static_cast<void> (0) : __assert_fail ("getNumModuleIdentifiers(Imported) == IdentifierLocs.size()"
, "/build/llvm-toolchain-snapshot-9~svn361465/tools/clang/lib/AST/Decl.cpp"
, 4742, __PRETTY_FUNCTION__))
;
4743 auto *StoredLocs = getTrailingObjects<SourceLocation>();
4744 std::uninitialized_copy(IdentifierLocs.begin(), IdentifierLocs.end(),
4745 StoredLocs);
4746}
4747
4748ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
4749 Module *Imported, SourceLocation EndLoc)
4750 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, false) {
4751 *getTrailingObjects<SourceLocation>() = EndLoc;
4752}
4753
4754ImportDecl *ImportDecl::Create(ASTContext &C, DeclContext *DC,
4755 SourceLocation StartLoc, Module *Imported,
4756 ArrayRef<SourceLocation> IdentifierLocs) {
4757 return new (C, DC,
4758 additionalSizeToAlloc<SourceLocation>(IdentifierLocs.size()))
4759 ImportDecl(DC, StartLoc, Imported, IdentifierLocs);
4760}
4761
4762ImportDecl *ImportDecl::CreateImplicit(ASTContext &C, DeclContext *DC,
4763 SourceLocation StartLoc,
4764 Module *Imported,
4765 SourceLocation EndLoc) {
4766 ImportDecl *Import = new (C, DC, additionalSizeToAlloc<SourceLocation>(1))
4767 ImportDecl(DC, StartLoc, Imported, EndLoc);
4768 Import->setImplicit();
4769 return Import;
4770}
4771
4772ImportDecl *ImportDecl::CreateDeserialized(ASTContext &C, unsigned ID,
4773 unsigned NumLocations) {
4774 return new (C, ID, additionalSizeToAlloc<SourceLocation>(NumLocations))
4775 ImportDecl(EmptyShell());
4776}
4777
4778ArrayRef<SourceLocation> ImportDecl::getIdentifierLocs() const {
4779 if (!ImportedAndComplete.getInt())
4780 return None;
4781
4782 const auto *StoredLocs = getTrailingObjects<SourceLocation>();
4783 return llvm::makeArrayRef(StoredLocs,
4784 getNumModuleIdentifiers(getImportedModule()));
4785}
4786
4787SourceRange ImportDecl::getSourceRange() const {
4788 if (!ImportedAndComplete.getInt())
4789 return SourceRange(getLocation(), *getTrailingObjects<SourceLocation>());
4790
4791 return SourceRange(getLocation(), getIdentifierLocs().back());
4792}
4793
4794//===----------------------------------------------------------------------===//
4795// ExportDecl Implementation
4796//===----------------------------------------------------------------------===//
4797
4798void ExportDecl::anchor() {}
4799
4800ExportDecl *ExportDecl::Create(ASTContext &C, DeclContext *DC,
4801 SourceLocation ExportLoc) {
4802 return new (C, DC) ExportDecl(DC, ExportLoc);
4803}
4804
4805ExportDecl *ExportDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
4806 return new (C, ID) ExportDecl(nullptr, SourceLocation());
4807}

/build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/include/clang/AST/Attrs.inc

1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Attribute classes' definitions *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9#ifndef LLVM_CLANG_ATTR_CLASSES_INC
10#define LLVM_CLANG_ATTR_CLASSES_INC
11
12class AArch64VectorPcsAttr : public InheritableAttr {
13public:
14 static AArch64VectorPcsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
15 auto *A = new (Ctx) AArch64VectorPcsAttr(Loc, Ctx, 0);
16 A->setImplicit(true);
17 return A;
18 }
19
20 AArch64VectorPcsAttr(SourceRange R, ASTContext &Ctx
21 , unsigned SI
22 )
23 : InheritableAttr(attr::AArch64VectorPcs, R, SI, false, false)
24 {
25 }
26
27 AArch64VectorPcsAttr *clone(ASTContext &C) const;
28 void printPretty(raw_ostream &OS,
29 const PrintingPolicy &Policy) const;
30 const char *getSpelling() const;
31
32
33 static bool classof(const Attr *A) { return A->getKind() == attr::AArch64VectorPcs; }
34};
35
36class AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr {
37Expr * min;
38
39Expr * max;
40
41public:
42 static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Loc = SourceRange()) {
43 auto *A = new (Ctx) AMDGPUFlatWorkGroupSizeAttr(Loc, Ctx, Min, Max, 0);
44 A->setImplicit(true);
45 return A;
46 }
47
48 AMDGPUFlatWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx
49 , Expr * Min
50 , Expr * Max
51 , unsigned SI
52 )
53 : InheritableAttr(attr::AMDGPUFlatWorkGroupSize, R, SI, false, false)
54 , min(Min)
55 , max(Max)
56 {
57 }
58
59 AMDGPUFlatWorkGroupSizeAttr *clone(ASTContext &C) const;
60 void printPretty(raw_ostream &OS,
61 const PrintingPolicy &Policy) const;
62 const char *getSpelling() const;
63 Expr * getMin() const {
64 return min;
65 }
66
67 Expr * getMax() const {
68 return max;
69 }
70
71
72
73 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUFlatWorkGroupSize; }
74};
75
76class AMDGPUNumSGPRAttr : public InheritableAttr {
77unsigned numSGPR;
78
79public:
80 static AMDGPUNumSGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumSGPR, SourceRange Loc = SourceRange()) {
81 auto *A = new (Ctx) AMDGPUNumSGPRAttr(Loc, Ctx, NumSGPR, 0);
82 A->setImplicit(true);
83 return A;
84 }
85
86 AMDGPUNumSGPRAttr(SourceRange R, ASTContext &Ctx
87 , unsigned NumSGPR
88 , unsigned SI
89 )
90 : InheritableAttr(attr::AMDGPUNumSGPR, R, SI, false, false)
91 , numSGPR(NumSGPR)
92 {
93 }
94
95 AMDGPUNumSGPRAttr *clone(ASTContext &C) const;
96 void printPretty(raw_ostream &OS,
97 const PrintingPolicy &Policy) const;
98 const char *getSpelling() const;
99 unsigned getNumSGPR() const {
100 return numSGPR;
101 }
102
103
104
105 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumSGPR; }
106};
107
108class AMDGPUNumVGPRAttr : public InheritableAttr {
109unsigned numVGPR;
110
111public:
112 static AMDGPUNumVGPRAttr *CreateImplicit(ASTContext &Ctx, unsigned NumVGPR, SourceRange Loc = SourceRange()) {
113 auto *A = new (Ctx) AMDGPUNumVGPRAttr(Loc, Ctx, NumVGPR, 0);
114 A->setImplicit(true);
115 return A;
116 }
117
118 AMDGPUNumVGPRAttr(SourceRange R, ASTContext &Ctx
119 , unsigned NumVGPR
120 , unsigned SI
121 )
122 : InheritableAttr(attr::AMDGPUNumVGPR, R, SI, false, false)
123 , numVGPR(NumVGPR)
124 {
125 }
126
127 AMDGPUNumVGPRAttr *clone(ASTContext &C) const;
128 void printPretty(raw_ostream &OS,
129 const PrintingPolicy &Policy) const;
130 const char *getSpelling() const;
131 unsigned getNumVGPR() const {
132 return numVGPR;
133 }
134
135
136
137 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUNumVGPR; }
138};
139
140class AMDGPUWavesPerEUAttr : public InheritableAttr {
141Expr * min;
142
143Expr * max;
144
145public:
146 static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Loc = SourceRange()) {
147 auto *A = new (Ctx) AMDGPUWavesPerEUAttr(Loc, Ctx, Min, Max, 0);
148 A->setImplicit(true);
149 return A;
150 }
151
152 AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
153 , Expr * Min
154 , Expr * Max
155 , unsigned SI
156 )
157 : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false)
158 , min(Min)
159 , max(Max)
160 {
161 }
162
163 AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
164 , Expr * Min
165 , unsigned SI
166 )
167 : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false)
168 , min(Min)
169 , max()
170 {
171 }
172
173 AMDGPUWavesPerEUAttr *clone(ASTContext &C) const;
174 void printPretty(raw_ostream &OS,
175 const PrintingPolicy &Policy) const;
176 const char *getSpelling() const;
177 Expr * getMin() const {
178 return min;
179 }
180
181 Expr * getMax() const {
182 return max;
183 }
184
185
186
187 static bool classof(const Attr *A) { return A->getKind() == attr::AMDGPUWavesPerEU; }
188};
189
190class ARMInterruptAttr : public InheritableAttr {
191public:
192 enum InterruptType {
193 IRQ,
194 FIQ,
195 SWI,
196 ABORT,
197 UNDEF,
198 Generic
199 };
200private:
201 InterruptType interrupt;
202
203public:
204 static ARMInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
205 auto *A = new (Ctx) ARMInterruptAttr(Loc, Ctx, Interrupt, 0);
206 A->setImplicit(true);
207 return A;
208 }
209
210 ARMInterruptAttr(SourceRange R, ASTContext &Ctx
211 , InterruptType Interrupt
212 , unsigned SI
213 )
214 : InheritableAttr(attr::ARMInterrupt, R, SI, false, false)
215 , interrupt(Interrupt)
216 {
217 }
218
219 ARMInterruptAttr(SourceRange R, ASTContext &Ctx
220 , unsigned SI
221 )
222 : InheritableAttr(attr::ARMInterrupt, R, SI, false, false)
223 , interrupt(InterruptType(0))
224 {
225 }
226
227 ARMInterruptAttr *clone(ASTContext &C) const;
228 void printPretty(raw_ostream &OS,
229 const PrintingPolicy &Policy) const;
230 const char *getSpelling() const;
231 InterruptType getInterrupt() const {
232 return interrupt;
233 }
234
235 static bool ConvertStrToInterruptType(StringRef Val, InterruptType &Out) {
236 Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
237 .Case("IRQ", ARMInterruptAttr::IRQ)
238 .Case("FIQ", ARMInterruptAttr::FIQ)
239 .Case("SWI", ARMInterruptAttr::SWI)
240 .Case("ABORT", ARMInterruptAttr::ABORT)
241 .Case("UNDEF", ARMInterruptAttr::UNDEF)
242 .Case("", ARMInterruptAttr::Generic)
243 .Default(Optional<InterruptType>());
244 if (R) {
245 Out = *R;
246 return true;
247 }
248 return false;
249 }
250
251 static const char *ConvertInterruptTypeToStr(InterruptType Val) {
252 switch(Val) {
253 case ARMInterruptAttr::IRQ: return "IRQ";
254 case ARMInterruptAttr::FIQ: return "FIQ";
255 case ARMInterruptAttr::SWI: return "SWI";
256 case ARMInterruptAttr::ABORT: return "ABORT";
257 case ARMInterruptAttr::UNDEF: return "UNDEF";
258 case ARMInterruptAttr::Generic: return "";
259 }
260 llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 260)
;
261 }
262
263
264 static bool classof(const Attr *A) { return A->getKind() == attr::ARMInterrupt; }
265};
266
267class AVRInterruptAttr : public InheritableAttr {
268public:
269 static AVRInterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
270 auto *A = new (Ctx) AVRInterruptAttr(Loc, Ctx, 0);
271 A->setImplicit(true);
272 return A;
273 }
274
275 AVRInterruptAttr(SourceRange R, ASTContext &Ctx
276 , unsigned SI
277 )
278 : InheritableAttr(attr::AVRInterrupt, R, SI, false, false)
279 {
280 }
281
282 AVRInterruptAttr *clone(ASTContext &C) const;
283 void printPretty(raw_ostream &OS,
284 const PrintingPolicy &Policy) const;
285 const char *getSpelling() const;
286
287
288 static bool classof(const Attr *A) { return A->getKind() == attr::AVRInterrupt; }
289};
290
291class AVRSignalAttr : public InheritableAttr {
292public:
293 static AVRSignalAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
294 auto *A = new (Ctx) AVRSignalAttr(Loc, Ctx, 0);
295 A->setImplicit(true);
296 return A;
297 }
298
299 AVRSignalAttr(SourceRange R, ASTContext &Ctx
300 , unsigned SI
301 )
302 : InheritableAttr(attr::AVRSignal, R, SI, false, false)
303 {
304 }
305
306 AVRSignalAttr *clone(ASTContext &C) const;
307 void printPretty(raw_ostream &OS,
308 const PrintingPolicy &Policy) const;
309 const char *getSpelling() const;
310
311
312 static bool classof(const Attr *A) { return A->getKind() == attr::AVRSignal; }
313};
314
315class AbiTagAttr : public Attr {
316 unsigned tags_Size;
317 StringRef *tags_;
318
319public:
320 static AbiTagAttr *CreateImplicit(ASTContext &Ctx, StringRef *Tags, unsigned TagsSize, SourceRange Loc = SourceRange()) {
321 auto *A = new (Ctx) AbiTagAttr(Loc, Ctx, Tags, TagsSize, 0);
322 A->setImplicit(true);
323 return A;
324 }
325
326 AbiTagAttr(SourceRange R, ASTContext &Ctx
327 , StringRef *Tags, unsigned TagsSize
328 , unsigned SI
329 )
330 : Attr(attr::AbiTag, R, SI, false)
331 , tags_Size(TagsSize), tags_(new (Ctx, 16) StringRef[tags_Size])
332 {
333 for (size_t I = 0, E = tags_Size; I != E;
334 ++I) {
335 StringRef Ref = Tags[I];
336 if (!Ref.empty()) {
337 char *Mem = new (Ctx, 1) char[Ref.size()];
338 std::memcpy(Mem, Ref.data(), Ref.size());
339 tags_[I] = StringRef(Mem, Ref.size());
340 }
341 }
342 }
343
344 AbiTagAttr(SourceRange R, ASTContext &Ctx
345 , unsigned SI
346 )
347 : Attr(attr::AbiTag, R, SI, false)
348 , tags_Size(0), tags_(nullptr)
349 {
350 }
351
352 AbiTagAttr *clone(ASTContext &C) const;
353 void printPretty(raw_ostream &OS,
354 const PrintingPolicy &Policy) const;
355 const char *getSpelling() const;
356 typedef StringRef* tags_iterator;
357 tags_iterator tags_begin() const { return tags_; }
358 tags_iterator tags_end() const { return tags_ + tags_Size; }
359 unsigned tags_size() const { return tags_Size; }
360 llvm::iterator_range<tags_iterator> tags() const { return llvm::make_range(tags_begin(), tags_end()); }
361
362
363
364
365 static bool classof(const Attr *A) { return A->getKind() == attr::AbiTag; }
366};
367
368class AcquireCapabilityAttr : public InheritableAttr {
369 unsigned args_Size;
370 Expr * *args_;
371
372public:
373 enum Spelling {
374 GNU_acquire_capability = 0,
375 CXX11_clang_acquire_capability = 1,
376 GNU_acquire_shared_capability = 2,
377 CXX11_clang_acquire_shared_capability = 3,
378 GNU_exclusive_lock_function = 4,
379 GNU_shared_lock_function = 5
380 };
381
382 static AcquireCapabilityAttr *CreateImplicit(ASTContext &Ctx, Spelling S, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
383 auto *A = new (Ctx) AcquireCapabilityAttr(Loc, Ctx, Args, ArgsSize, S);
384 A->setImplicit(true);
385 return A;
386 }
387
388 AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
389 , Expr * *Args, unsigned ArgsSize
390 , unsigned SI
391 )
392 : InheritableAttr(attr::AcquireCapability, R, SI, true, true)
393 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
394 {
395 std::copy(Args, Args + args_Size, args_);
396 }
397
398 AcquireCapabilityAttr(SourceRange R, ASTContext &Ctx
399 , unsigned SI
400 )
401 : InheritableAttr(attr::AcquireCapability, R, SI, true, true)
402 , args_Size(0), args_(nullptr)
403 {
404 }
405
406 AcquireCapabilityAttr *clone(ASTContext &C) const;
407 void printPretty(raw_ostream &OS,
408 const PrintingPolicy &Policy) const;
409 const char *getSpelling() const;
410 Spelling getSemanticSpelling() const {
411 switch (SpellingListIndex) {
412 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 412)
;
413 case 0: return GNU_acquire_capability;
414 case 1: return CXX11_clang_acquire_capability;
415 case 2: return GNU_acquire_shared_capability;
416 case 3: return CXX11_clang_acquire_shared_capability;
417 case 4: return GNU_exclusive_lock_function;
418 case 5: return GNU_shared_lock_function;
419 }
420 }
421 bool isShared() const { return SpellingListIndex == 2 ||
422 SpellingListIndex == 3 ||
423 SpellingListIndex == 5; }
424 typedef Expr ** args_iterator;
425 args_iterator args_begin() const { return args_; }
426 args_iterator args_end() const { return args_ + args_Size; }
427 unsigned args_size() const { return args_Size; }
428 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
429
430
431
432
433 static bool classof(const Attr *A) { return A->getKind() == attr::AcquireCapability; }
434};
435
436class AcquiredAfterAttr : public InheritableAttr {
437 unsigned args_Size;
438 Expr * *args_;
439
440public:
441 static AcquiredAfterAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
442 auto *A = new (Ctx) AcquiredAfterAttr(Loc, Ctx, Args, ArgsSize, 0);
443 A->setImplicit(true);
444 return A;
445 }
446
447 AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
448 , Expr * *Args, unsigned ArgsSize
449 , unsigned SI
450 )
451 : InheritableAttr(attr::AcquiredAfter, R, SI, true, true)
452 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
453 {
454 std::copy(Args, Args + args_Size, args_);
455 }
456
457 AcquiredAfterAttr(SourceRange R, ASTContext &Ctx
458 , unsigned SI
459 )
460 : InheritableAttr(attr::AcquiredAfter, R, SI, true, true)
461 , args_Size(0), args_(nullptr)
462 {
463 }
464
465 AcquiredAfterAttr *clone(ASTContext &C) const;
466 void printPretty(raw_ostream &OS,
467 const PrintingPolicy &Policy) const;
468 const char *getSpelling() const;
469 typedef Expr ** args_iterator;
470 args_iterator args_begin() const { return args_; }
471 args_iterator args_end() const { return args_ + args_Size; }
472 unsigned args_size() const { return args_Size; }
473 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
474
475
476
477
478 static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredAfter; }
479};
480
481class AcquiredBeforeAttr : public InheritableAttr {
482 unsigned args_Size;
483 Expr * *args_;
484
485public:
486 static AcquiredBeforeAttr *CreateImplicit(ASTContext &Ctx, Expr * *Args, unsigned ArgsSize, SourceRange Loc = SourceRange()) {
487 auto *A = new (Ctx) AcquiredBeforeAttr(Loc, Ctx, Args, ArgsSize, 0);
488 A->setImplicit(true);
489 return A;
490 }
491
492 AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
493 , Expr * *Args, unsigned ArgsSize
494 , unsigned SI
495 )
496 : InheritableAttr(attr::AcquiredBefore, R, SI, true, true)
497 , args_Size(ArgsSize), args_(new (Ctx, 16) Expr *[args_Size])
498 {
499 std::copy(Args, Args + args_Size, args_);
500 }
501
502 AcquiredBeforeAttr(SourceRange R, ASTContext &Ctx
503 , unsigned SI
504 )
505 : InheritableAttr(attr::AcquiredBefore, R, SI, true, true)
506 , args_Size(0), args_(nullptr)
507 {
508 }
509
510 AcquiredBeforeAttr *clone(ASTContext &C) const;
511 void printPretty(raw_ostream &OS,
512 const PrintingPolicy &Policy) const;
513 const char *getSpelling() const;
514 typedef Expr ** args_iterator;
515 args_iterator args_begin() const { return args_; }
516 args_iterator args_end() const { return args_ + args_Size; }
517 unsigned args_size() const { return args_Size; }
518 llvm::iterator_range<args_iterator> args() const { return llvm::make_range(args_begin(), args_end()); }
519
520
521
522
523 static bool classof(const Attr *A) { return A->getKind() == attr::AcquiredBefore; }
524};
525
526class AddressSpaceAttr : public TypeAttr {
527int addressSpace;
528
529public:
530 static AddressSpaceAttr *CreateImplicit(ASTContext &Ctx, int AddressSpace, SourceRange Loc = SourceRange()) {
531 auto *A = new (Ctx) AddressSpaceAttr(Loc, Ctx, AddressSpace, 0);
532 A->setImplicit(true);
533 return A;
534 }
535
536 AddressSpaceAttr(SourceRange R, ASTContext &Ctx
537 , int AddressSpace
538 , unsigned SI
539 )
540 : TypeAttr(attr::AddressSpace, R, SI, false)
541 , addressSpace(AddressSpace)
542 {
543 }
544
545 AddressSpaceAttr *clone(ASTContext &C) const;
546 void printPretty(raw_ostream &OS,
547 const PrintingPolicy &Policy) const;
548 const char *getSpelling() const;
549 int getAddressSpace() const {
550 return addressSpace;
551 }
552
553
554
555 static bool classof(const Attr *A) { return A->getKind() == attr::AddressSpace; }
556};
557
558class AliasAttr : public Attr {
559unsigned aliaseeLength;
560char *aliasee;
561
562public:
563 static AliasAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Aliasee, SourceRange Loc = SourceRange()) {
564 auto *A = new (Ctx) AliasAttr(Loc, Ctx, Aliasee, 0);
565 A->setImplicit(true);
566 return A;
567 }
568
569 AliasAttr(SourceRange R, ASTContext &Ctx
570 , llvm::StringRef Aliasee
571 , unsigned SI
572 )
573 : Attr(attr::Alias, R, SI, false)
574 , aliaseeLength(Aliasee.size()),aliasee(new (Ctx, 1) char[aliaseeLength])
575 {
576 if (!Aliasee.empty())
577 std::memcpy(aliasee, Aliasee.data(), aliaseeLength);
578 }
579
580 AliasAttr *clone(ASTContext &C) const;
581 void printPretty(raw_ostream &OS,
582 const PrintingPolicy &Policy) const;
583 const char *getSpelling() const;
584 llvm::StringRef getAliasee() const {
585 return llvm::StringRef(aliasee, aliaseeLength);
586 }
587 unsigned getAliaseeLength() const {
588 return aliaseeLength;
589 }
590 void setAliasee(ASTContext &C, llvm::StringRef S) {
591 aliaseeLength = S.size();
592 this->aliasee = new (C, 1) char [aliaseeLength];
593 if (!S.empty())
594 std::memcpy(this->aliasee, S.data(), aliaseeLength);
595 }
596
597
598
599 static bool classof(const Attr *A) { return A->getKind() == attr::Alias; }
600};
601
602class AlignMac68kAttr : public InheritableAttr {
603public:
604 static AlignMac68kAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
605 auto *A = new (Ctx) AlignMac68kAttr(Loc, Ctx, 0);
606 A->setImplicit(true);
607 return A;
608 }
609
610 AlignMac68kAttr(SourceRange R, ASTContext &Ctx
611 , unsigned SI
612 )
613 : InheritableAttr(attr::AlignMac68k, R, SI, false, false)
614 {
615 }
616
617 AlignMac68kAttr *clone(ASTContext &C) const;
618 void printPretty(raw_ostream &OS,
619 const PrintingPolicy &Policy) const;
620 const char *getSpelling() const;
621
622
623 static bool classof(const Attr *A) { return A->getKind() == attr::AlignMac68k; }
624};
625
626class AlignValueAttr : public Attr {
627Expr * alignment;
628
629public:
630 static AlignValueAttr *CreateImplicit(ASTContext &Ctx, Expr * Alignment, SourceRange Loc = SourceRange()) {
631 auto *A = new (Ctx) AlignValueAttr(Loc, Ctx, Alignment, 0);
632 A->setImplicit(true);
633 return A;
634 }
635
636 AlignValueAttr(SourceRange R, ASTContext &Ctx
637 , Expr * Alignment
638 , unsigned SI
639 )
640 : Attr(attr::AlignValue, R, SI, false)
641 , alignment(Alignment)
642 {
643 }
644
645 AlignValueAttr *clone(ASTContext &C) const;
646 void printPretty(raw_ostream &OS,
647 const PrintingPolicy &Policy) const;
648 const char *getSpelling() const;
649 Expr * getAlignment() const {
650 return alignment;
651 }
652
653
654
655 static bool classof(const Attr *A) { return A->getKind() == attr::AlignValue; }
656};
657
658class AlignedAttr : public InheritableAttr {
659bool isalignmentExpr;
660union {
661Expr *alignmentExpr;
662TypeSourceInfo *alignmentType;
663};
664
665public:
666 enum Spelling {
667 GNU_aligned = 0,
668 CXX11_gnu_aligned = 1,
669 Declspec_align = 2,
670 Keyword_alignas = 3,
671 Keyword_Alignas = 4
672 };
673
674 static AlignedAttr *CreateImplicit(ASTContext &Ctx, Spelling S, bool IsAlignmentExpr, void *Alignment, SourceRange Loc = SourceRange()) {
675 auto *A = new (Ctx) AlignedAttr(Loc, Ctx, IsAlignmentExpr, Alignment, S);
676 A->setImplicit(true);
677 return A;
678 }
679
680 AlignedAttr(SourceRange R, ASTContext &Ctx
681 , bool IsAlignmentExpr, void *Alignment
682 , unsigned SI
683 )
684 : InheritableAttr(attr::Aligned, R, SI, false, false)
685 , isalignmentExpr(IsAlignmentExpr)
686 {
687 if (isalignmentExpr)
688 alignmentExpr = reinterpret_cast<Expr *>(Alignment);
689 else
690 alignmentType = reinterpret_cast<TypeSourceInfo *>(Alignment);
691 }
692
693 AlignedAttr(SourceRange R, ASTContext &Ctx
694 , unsigned SI
695 )
696 : InheritableAttr(attr::Aligned, R, SI, false, false)
697 , isalignmentExpr(false)
698 {
699 }
700
701 AlignedAttr *clone(ASTContext &C) const;
702 void printPretty(raw_ostream &OS,
703 const PrintingPolicy &Policy) const;
704 const char *getSpelling() const;
705 Spelling getSemanticSpelling() const {
706 switch (SpellingListIndex) {
707 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 707)
;
708 case 0: return GNU_aligned;
709 case 1: return CXX11_gnu_aligned;
710 case 2: return Declspec_align;
711 case 3: return Keyword_alignas;
712 case 4: return Keyword_Alignas;
713 }
714 }
715 bool isGNU() const { return SpellingListIndex == 0 ||
716 SpellingListIndex == 1; }
717 bool isC11() const { return SpellingListIndex == 4; }
718 bool isAlignas() const { return SpellingListIndex == 3 ||
719 SpellingListIndex == 4; }
720 bool isDeclspec() const { return SpellingListIndex == 2; }
721 bool isAlignmentDependent() const;
722 unsigned getAlignment(ASTContext &Ctx) const;
723 bool isAlignmentExpr() const {
724 return isalignmentExpr;
725 }
726 Expr *getAlignmentExpr() const {
727 assert(isalignmentExpr)((isalignmentExpr) ? static_cast<void> (0) : __assert_fail
("isalignmentExpr", "/build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 727, __PRETTY_FUNCTION__))
;
728 return alignmentExpr;
729 }
730 TypeSourceInfo *getAlignmentType() const {
731 assert(!isalignmentExpr)((!isalignmentExpr) ? static_cast<void> (0) : __assert_fail
("!isalignmentExpr", "/build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 731, __PRETTY_FUNCTION__))
;
732 return alignmentType;
733 }
734
735
736
737 static bool classof(const Attr *A) { return A->getKind() == attr::Aligned; }
738};
739
740class AllocAlignAttr : public InheritableAttr {
741ParamIdx paramIndex;
742
743public:
744 static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, SourceRange Loc = SourceRange()) {
745 auto *A = new (Ctx) AllocAlignAttr(Loc, Ctx, ParamIndex, 0);
746 A->setImplicit(true);
747 return A;
748 }
749
750 AllocAlignAttr(SourceRange R, ASTContext &Ctx
751 , ParamIdx ParamIndex
752 , unsigned SI
753 )
754 : InheritableAttr(attr::AllocAlign, R, SI, false, false)
755 , paramIndex(ParamIndex)
756 {
757 }
758
759 AllocAlignAttr *clone(ASTContext &C) const;
760 void printPretty(raw_ostream &OS,
761 const PrintingPolicy &Policy) const;
762 const char *getSpelling() const;
763 ParamIdx getParamIndex() const {
764 return paramIndex;
765 }
766
767
768
769 static bool classof(const Attr *A) { return A->getKind() == attr::AllocAlign; }
770};
771
772class AllocSizeAttr : public InheritableAttr {
773ParamIdx elemSizeParam;
774
775ParamIdx numElemsParam;
776
777public:
778 static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, SourceRange Loc = SourceRange()) {
779 auto *A = new (Ctx) AllocSizeAttr(Loc, Ctx, ElemSizeParam, NumElemsParam, 0);
780 A->setImplicit(true);
781 return A;
782 }
783
784 AllocSizeAttr(SourceRange R, ASTContext &Ctx
785 , ParamIdx ElemSizeParam
786 , ParamIdx NumElemsParam
787 , unsigned SI
788 )
789 : InheritableAttr(attr::AllocSize, R, SI, false, false)
790 , elemSizeParam(ElemSizeParam)
791 , numElemsParam(NumElemsParam)
792 {
793 }
794
795 AllocSizeAttr(SourceRange R, ASTContext &Ctx
796 , ParamIdx ElemSizeParam
797 , unsigned SI
798 )
799 : InheritableAttr(attr::AllocSize, R, SI, false, false)
800 , elemSizeParam(ElemSizeParam)
801 , numElemsParam()
802 {
803 }
804
805 AllocSizeAttr *clone(ASTContext &C) const;
806 void printPretty(raw_ostream &OS,
807 const PrintingPolicy &Policy) const;
808 const char *getSpelling() const;
809 ParamIdx getElemSizeParam() const {
810 return elemSizeParam;
811 }
812
813 ParamIdx getNumElemsParam() const {
814 return numElemsParam;
815 }
816
817
818
819 static bool classof(const Attr *A) { return A->getKind() == attr::AllocSize; }
820};
821
822class AlwaysDestroyAttr : public InheritableAttr {
823public:
824 static AlwaysDestroyAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
825 auto *A = new (Ctx) AlwaysDestroyAttr(Loc, Ctx, 0);
826 A->setImplicit(true);
827 return A;
828 }
829
830 AlwaysDestroyAttr(SourceRange R, ASTContext &Ctx
831 , unsigned SI
832 )
833 : InheritableAttr(attr::AlwaysDestroy, R, SI, false, false)
834 {
835 }
836
837 AlwaysDestroyAttr *clone(ASTContext &C) const;
838 void printPretty(raw_ostream &OS,
839 const PrintingPolicy &Policy) const;
840 const char *getSpelling() const;
841
842
843 static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysDestroy; }
844};
845
846class AlwaysInlineAttr : public InheritableAttr {
847public:
848 enum Spelling {
849 GNU_always_inline = 0,
850 CXX11_gnu_always_inline = 1,
851 Keyword_forceinline = 2
852 };
853
854 static AlwaysInlineAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
855 auto *A = new (Ctx) AlwaysInlineAttr(Loc, Ctx, S);
856 A->setImplicit(true);
857 return A;
858 }
859
860 AlwaysInlineAttr(SourceRange R, ASTContext &Ctx
861 , unsigned SI
862 )
863 : InheritableAttr(attr::AlwaysInline, R, SI, false, false)
864 {
865 }
866
867 AlwaysInlineAttr *clone(ASTContext &C) const;
868 void printPretty(raw_ostream &OS,
869 const PrintingPolicy &Policy) const;
870 const char *getSpelling() const;
871 Spelling getSemanticSpelling() const {
872 switch (SpellingListIndex) {
873 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 873)
;
874 case 0: return GNU_always_inline;
875 case 1: return CXX11_gnu_always_inline;
876 case 2: return Keyword_forceinline;
877 }
878 }
879
880
881 static bool classof(const Attr *A) { return A->getKind() == attr::AlwaysInline; }
882};
883
884class AnalyzerNoReturnAttr : public InheritableAttr {
885public:
886 static AnalyzerNoReturnAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
887 auto *A = new (Ctx) AnalyzerNoReturnAttr(Loc, Ctx, 0);
888 A->setImplicit(true);
889 return A;
890 }
891
892 AnalyzerNoReturnAttr(SourceRange R, ASTContext &Ctx
893 , unsigned SI
894 )
895 : InheritableAttr(attr::AnalyzerNoReturn, R, SI, false, false)
896 {
897 }
898
899 AnalyzerNoReturnAttr *clone(ASTContext &C) const;
900 void printPretty(raw_ostream &OS,
901 const PrintingPolicy &Policy) const;
902 const char *getSpelling() const;
903
904
905 static bool classof(const Attr *A) { return A->getKind() == attr::AnalyzerNoReturn; }
906};
907
908class AnnotateAttr : public InheritableParamAttr {
909unsigned annotationLength;
910char *annotation;
911
912public:
913 static AnnotateAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Annotation, SourceRange Loc = SourceRange()) {
914 auto *A = new (Ctx) AnnotateAttr(Loc, Ctx, Annotation, 0);
915 A->setImplicit(true);
916 return A;
917 }
918
919 AnnotateAttr(SourceRange R, ASTContext &Ctx
920 , llvm::StringRef Annotation
921 , unsigned SI
922 )
923 : InheritableParamAttr(attr::Annotate, R, SI, false, false)
924 , annotationLength(Annotation.size()),annotation(new (Ctx, 1) char[annotationLength])
925 {
926 if (!Annotation.empty())
927 std::memcpy(annotation, Annotation.data(), annotationLength);
928 }
929
930 AnnotateAttr *clone(ASTContext &C) const;
931 void printPretty(raw_ostream &OS,
932 const PrintingPolicy &Policy) const;
933 const char *getSpelling() const;
934 llvm::StringRef getAnnotation() const {
935 return llvm::StringRef(annotation, annotationLength);
936 }
937 unsigned getAnnotationLength() const {
938 return annotationLength;
939 }
940 void setAnnotation(ASTContext &C, llvm::StringRef S) {
941 annotationLength = S.size();
942 this->annotation = new (C, 1) char [annotationLength];
943 if (!S.empty())
944 std::memcpy(this->annotation, S.data(), annotationLength);
945 }
946
947
948
949 static bool classof(const Attr *A) { return A->getKind() == attr::Annotate; }
950};
951
952class AnyX86InterruptAttr : public InheritableAttr {
953public:
954 static AnyX86InterruptAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
955 auto *A = new (Ctx) AnyX86InterruptAttr(Loc, Ctx, 0);
956 A->setImplicit(true);
957 return A;
958 }
959
960 AnyX86InterruptAttr(SourceRange R, ASTContext &Ctx
961 , unsigned SI
962 )
963 : InheritableAttr(attr::AnyX86Interrupt, R, SI, false, false)
964 {
965 }
966
967 AnyX86InterruptAttr *clone(ASTContext &C) const;
968 void printPretty(raw_ostream &OS,
969 const PrintingPolicy &Policy) const;
970 const char *getSpelling() const;
971
972
973 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86Interrupt; }
974};
975
976class AnyX86NoCallerSavedRegistersAttr : public InheritableAttr {
977public:
978 static AnyX86NoCallerSavedRegistersAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
979 auto *A = new (Ctx) AnyX86NoCallerSavedRegistersAttr(Loc, Ctx, 0);
980 A->setImplicit(true);
981 return A;
982 }
983
984 AnyX86NoCallerSavedRegistersAttr(SourceRange R, ASTContext &Ctx
985 , unsigned SI
986 )
987 : InheritableAttr(attr::AnyX86NoCallerSavedRegisters, R, SI, false, false)
988 {
989 }
990
991 AnyX86NoCallerSavedRegistersAttr *clone(ASTContext &C) const;
992 void printPretty(raw_ostream &OS,
993 const PrintingPolicy &Policy) const;
994 const char *getSpelling() const;
995
996
997 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCallerSavedRegisters; }
998};
999
1000class AnyX86NoCfCheckAttr : public InheritableAttr {
1001public:
1002 static AnyX86NoCfCheckAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1003 auto *A = new (Ctx) AnyX86NoCfCheckAttr(Loc, Ctx, 0);
1004 A->setImplicit(true);
1005 return A;
1006 }
1007
1008 AnyX86NoCfCheckAttr(SourceRange R, ASTContext &Ctx
1009 , unsigned SI
1010 )
1011 : InheritableAttr(attr::AnyX86NoCfCheck, R, SI, false, false)
1012 {
1013 }
1014
1015 AnyX86NoCfCheckAttr *clone(ASTContext &C) const;
1016 void printPretty(raw_ostream &OS,
1017 const PrintingPolicy &Policy) const;
1018 const char *getSpelling() const;
1019
1020
1021 static bool classof(const Attr *A) { return A->getKind() == attr::AnyX86NoCfCheck; }
1022};
1023
1024class ArcWeakrefUnavailableAttr : public InheritableAttr {
1025public:
1026 static ArcWeakrefUnavailableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1027 auto *A = new (Ctx) ArcWeakrefUnavailableAttr(Loc, Ctx, 0);
1028 A->setImplicit(true);
1029 return A;
1030 }
1031
1032 ArcWeakrefUnavailableAttr(SourceRange R, ASTContext &Ctx
1033 , unsigned SI
1034 )
1035 : InheritableAttr(attr::ArcWeakrefUnavailable, R, SI, false, false)
1036 {
1037 }
1038
1039 ArcWeakrefUnavailableAttr *clone(ASTContext &C) const;
1040 void printPretty(raw_ostream &OS,
1041 const PrintingPolicy &Policy) const;
1042 const char *getSpelling() const;
1043
1044
1045 static bool classof(const Attr *A) { return A->getKind() == attr::ArcWeakrefUnavailable; }
1046};
1047
1048class ArgumentWithTypeTagAttr : public InheritableAttr {
1049IdentifierInfo * argumentKind;
1050
1051ParamIdx argumentIdx;
1052
1053ParamIdx typeTagIdx;
1054
1055bool isPointer;
1056
1057public:
1058 enum Spelling {
1059 GNU_argument_with_type_tag = 0,
1060 CXX11_clang_argument_with_type_tag = 1,
1061 C2x_clang_argument_with_type_tag = 2,
1062 GNU_pointer_with_type_tag = 3,
1063 CXX11_clang_pointer_with_type_tag = 4,
1064 C2x_clang_pointer_with_type_tag = 5
1065 };
1066
1067 static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, bool IsPointer, SourceRange Loc = SourceRange()) {
1068 auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, IsPointer, S);
1069 A->setImplicit(true);
1070 return A;
1071 }
1072
1073 static ArgumentWithTypeTagAttr *CreateImplicit(ASTContext &Ctx, Spelling S, IdentifierInfo * ArgumentKind, ParamIdx ArgumentIdx, ParamIdx TypeTagIdx, SourceRange Loc = SourceRange()) {
1074 auto *A = new (Ctx) ArgumentWithTypeTagAttr(Loc, Ctx, ArgumentKind, ArgumentIdx, TypeTagIdx, S);
1075 A->setImplicit(true);
1076 return A;
1077 }
1078
1079 ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx
1080 , IdentifierInfo * ArgumentKind
1081 , ParamIdx ArgumentIdx
1082 , ParamIdx TypeTagIdx
1083 , bool IsPointer
1084 , unsigned SI
1085 )
1086 : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false)
1087 , argumentKind(ArgumentKind)
1088 , argumentIdx(ArgumentIdx)
1089 , typeTagIdx(TypeTagIdx)
1090 , isPointer(IsPointer)
1091 {
1092 }
1093
1094 ArgumentWithTypeTagAttr(SourceRange R, ASTContext &Ctx
1095 , IdentifierInfo * ArgumentKind
1096 , ParamIdx ArgumentIdx
1097 , ParamIdx TypeTagIdx
1098 , unsigned SI
1099 )
1100 : InheritableAttr(attr::ArgumentWithTypeTag, R, SI, false, false)
1101 , argumentKind(ArgumentKind)
1102 , argumentIdx(ArgumentIdx)
1103 , typeTagIdx(TypeTagIdx)
1104 , isPointer()
1105 {
1106 }
1107
1108 ArgumentWithTypeTagAttr *clone(ASTContext &C) const;
1109 void printPretty(raw_ostream &OS,
1110 const PrintingPolicy &Policy) const;
1111 const char *getSpelling() const;
1112 Spelling getSemanticSpelling() const {
1113 switch (SpellingListIndex) {
1114 default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn361465/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1114)
;
1115 case 0: return GNU_argument_with_type_tag;
1116 case 1: return CXX11_clang_argument_with_type_tag;
1117 case 2: return C2x_clang_argument_with_type_tag;
1118 case 3: return GNU_pointer_with_type_tag;
1119 case 4: return CXX11_clang_pointer_with_type_tag;
1120 case 5: return C2x_clang_pointer_with_type_tag;
1121 }
1122 }
1123 IdentifierInfo * getArgumentKind() const {
1124 return argumentKind;
1125 }
1126
1127 ParamIdx getArgumentIdx() const {
1128 return argumentIdx;
1129 }
1130
1131 ParamIdx getTypeTagIdx() const {
1132 return typeTagIdx;
1133 }
1134
1135 bool getIsPointer() const {
1136 return isPointer;
1137 }
1138
1139
1140
1141 static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; }
1142};
1143
1144class ArtificialAttr : public InheritableAttr {
1145public:
1146 static ArtificialAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
1147 auto *A = new (Ctx) ArtificialAttr(Loc, Ctx, 0);
1148 A->setImplicit(true);
1149 return A;
1150 }
1151
1152 ArtificialAttr(SourceRange R, ASTContext &Ctx
1153 , unsigned SI
1154 )
1155 : InheritableAttr(attr::Artificial, R, SI, false, false)
1156 {
1157 }
1158
1159 ArtificialAttr *clone(ASTContext &C) const;
1160 void printPretty(raw_ostream &OS,
1161 const PrintingPolicy &Policy) const;
1162 const char *getSpelling() const;
1163
1164
1165 static bool classof(const Attr *A) { return A->getKind() == attr::Artificial; }
1166};
1167
1168class AsmLabelAttr : public InheritableAttr {
1169unsigned labelLength;
1170char *label;
1171
1172public:
1173 static AsmLabelAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Label, SourceRange Loc = SourceRange()) {
1174 auto *A = new (Ctx) AsmLabelAttr(Loc, Ctx, Label, 0);
1175 A->setImplicit(true);
1176 return A;
1177 }
1178
1179 AsmLabelAttr(SourceRange R, ASTContext &Ctx
1180 , llvm::StringRef Label
1181 , unsigned SI
1182 )
1183 : InheritableAttr(attr::AsmLabel, R, SI, false, false)
1184 , labelLength(Label.size()),label(new (Ctx, 1) char[labelLength])
1185 {
1186 if (!Label.empty())
1187 std::memcpy(label, Label.data(), labelLength);
1188 }
1189
1190 AsmLabelAttr *clone(ASTContext &C) const;
1191 void printPretty(raw_ostream &OS,
1192 const PrintingPolicy &Policy) const;
1193 const char *getSpelling() const;
1194 llvm::StringRef getLabel() const {
1195 return llvm::StringRef(label, labelLength);
1196 }
1197 unsigned getLabelLength() const {
1198 return labelLength;