clang 20.0.0git
Decl.cpp
Go to the documentation of this file.
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"
17#include "clang/AST/ASTLambda.h"
19#include "clang/AST/Attr.h"
21#include "clang/AST/DeclBase.h"
22#include "clang/AST/DeclCXX.h"
23#include "clang/AST/DeclObjC.h"
26#include "clang/AST/Expr.h"
27#include "clang/AST/ExprCXX.h"
29#include "clang/AST/ODRHash.h"
35#include "clang/AST/Stmt.h"
37#include "clang/AST/Type.h"
38#include "clang/AST/TypeLoc.h"
41#include "clang/Basic/LLVM.h"
43#include "clang/Basic/Linkage.h"
44#include "clang/Basic/Module.h"
54#include "llvm/ADT/APSInt.h"
55#include "llvm/ADT/ArrayRef.h"
56#include "llvm/ADT/STLExtras.h"
57#include "llvm/ADT/SmallVector.h"
58#include "llvm/ADT/StringRef.h"
59#include "llvm/ADT/StringSwitch.h"
60#include "llvm/Support/Casting.h"
61#include "llvm/Support/ErrorHandling.h"
62#include "llvm/Support/raw_ostream.h"
63#include "llvm/TargetParser/Triple.h"
64#include <algorithm>
65#include <cassert>
66#include <cstddef>
67#include <cstring>
68#include <memory>
69#include <optional>
70#include <string>
71#include <tuple>
72#include <type_traits>
73
74using namespace clang;
75
78}
79
80void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
81 SourceLocation Loc = this->Loc;
82 if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
83 if (Loc.isValid()) {
84 Loc.print(OS, Context.getSourceManager());
85 OS << ": ";
86 }
87 OS << Message;
88
89 if (auto *ND = dyn_cast_if_present<NamedDecl>(TheDecl)) {
90 OS << " '";
91 ND->getNameForDiagnostic(OS, Context.getPrintingPolicy(), true);
92 OS << "'";
93 }
94
95 OS << '\n';
96}
97
98// Defined here so that it can be inlined into its direct callers.
99bool Decl::isOutOfLine() const {
101}
102
103TranslationUnitDecl::TranslationUnitDecl(ASTContext &ctx)
104 : Decl(TranslationUnit, nullptr, SourceLocation()),
105 DeclContext(TranslationUnit), redeclarable_base(ctx), Ctx(ctx) {}
106
107//===----------------------------------------------------------------------===//
108// NamedDecl Implementation
109//===----------------------------------------------------------------------===//
110
111// Visibility rules aren't rigorously externally specified, but here
112// are the basic principles behind what we implement:
113//
114// 1. An explicit visibility attribute is generally a direct expression
115// of the user's intent and should be honored. Only the innermost
116// visibility attribute applies. If no visibility attribute applies,
117// global visibility settings are considered.
118//
119// 2. There is one caveat to the above: on or in a template pattern,
120// an explicit visibility attribute is just a default rule, and
121// visibility can be decreased by the visibility of template
122// arguments. But this, too, has an exception: an attribute on an
123// explicit specialization or instantiation causes all the visibility
124// restrictions of the template arguments to be ignored.
125//
126// 3. A variable that does not otherwise have explicit visibility can
127// be restricted by the visibility of its type.
128//
129// 4. A visibility restriction is explicit if it comes from an
130// attribute (or something like it), not a global visibility setting.
131// When emitting a reference to an external symbol, visibility
132// restrictions are ignored unless they are explicit.
133//
134// 5. When computing the visibility of a non-type, including a
135// non-type member of a class, only non-type visibility restrictions
136// are considered: the 'visibility' attribute, global value-visibility
137// settings, and a few special cases like __private_extern.
138//
139// 6. When computing the visibility of a type, including a type member
140// of a class, only type visibility restrictions are considered:
141// the 'type_visibility' attribute and global type-visibility settings.
142// However, a 'visibility' attribute counts as a 'type_visibility'
143// attribute on any declaration that only has the former.
144//
145// The visibility of a "secondary" entity, like a template argument,
146// is computed using the kind of that entity, not the kind of the
147// primary entity for which we are computing visibility. For example,
148// the visibility of a specialization of either of these templates:
149// template <class T, bool (&compare)(T, X)> bool has_match(list<T>, X);
150// template <class T, bool (&compare)(T, X)> class matcher;
151// is restricted according to the type visibility of the argument 'T',
152// the type visibility of 'bool(&)(T,X)', and the value visibility of
153// the argument function 'compare'. That 'has_match' is a value
154// and 'matcher' is a type only matters when looking for attributes
155// and settings from the immediate context.
156
157/// Does this computation kind permit us to consider additional
158/// visibility settings from attributes and the like?
160 return computation.IgnoreExplicitVisibility;
161}
162
163/// Given an LVComputationKind, return one of the same type/value sort
164/// that records that it already has explicit visibility.
167 Kind.IgnoreExplicitVisibility = true;
168 return Kind;
169}
170
171static std::optional<Visibility> getExplicitVisibility(const NamedDecl *D,
172 LVComputationKind kind) {
173 assert(!kind.IgnoreExplicitVisibility &&
174 "asking for explicit visibility when we shouldn't be");
175 return D->getExplicitVisibility(kind.getExplicitVisibilityKind());
176}
177
178/// Is the given declaration a "type" or a "value" for the purposes of
179/// visibility computation?
180static bool usesTypeVisibility(const NamedDecl *D) {
181 return isa<TypeDecl>(D) ||
182 isa<ClassTemplateDecl>(D) ||
183 isa<ObjCInterfaceDecl>(D);
184}
185
186/// Does the given declaration have member specialization information,
187/// and if so, is it an explicit specialization?
188template <class T>
189static std::enable_if_t<!std::is_base_of_v<RedeclarableTemplateDecl, T>, bool>
191 if (const MemberSpecializationInfo *member =
192 D->getMemberSpecializationInfo()) {
193 return member->isExplicitSpecialization();
194 }
195 return false;
196}
197
198/// For templates, this question is easier: a member template can't be
199/// explicitly instantiated, so there's a single bit indicating whether
200/// or not this is an explicit member specialization.
202 return D->isMemberSpecialization();
203}
204
205/// Given a visibility attribute, return the explicit visibility
206/// associated with it.
207template <class T>
208static Visibility getVisibilityFromAttr(const T *attr) {
209 switch (attr->getVisibility()) {
210 case T::Default:
211 return DefaultVisibility;
212 case T::Hidden:
213 return HiddenVisibility;
214 case T::Protected:
215 return ProtectedVisibility;
216 }
217 llvm_unreachable("bad visibility kind");
218}
219
220/// Return the explicit visibility of the given declaration.
221static std::optional<Visibility>
223 // If we're ultimately computing the visibility of a type, look for
224 // a 'type_visibility' attribute before looking for 'visibility'.
225 if (kind == NamedDecl::VisibilityForType) {
226 if (const auto *A = D->getAttr<TypeVisibilityAttr>()) {
227 return getVisibilityFromAttr(A);
228 }
229 }
230
231 // If this declaration has an explicit visibility attribute, use it.
232 if (const auto *A = D->getAttr<VisibilityAttr>()) {
233 return getVisibilityFromAttr(A);
234 }
235
236 return std::nullopt;
237}
238
239LinkageInfo LinkageComputer::getLVForType(const Type &T,
240 LVComputationKind computation) {
241 if (computation.IgnoreAllVisibility)
242 return LinkageInfo(T.getLinkage(), DefaultVisibility, true);
244}
245
246/// Get the most restrictive linkage for the types in the given
247/// template parameter list. For visibility purposes, template
248/// parameters are part of the signature of a template.
249LinkageInfo LinkageComputer::getLVForTemplateParameterList(
250 const TemplateParameterList *Params, LVComputationKind computation) {
251 LinkageInfo LV;
252 for (const NamedDecl *P : *Params) {
253 // Template type parameters are the most common and never
254 // contribute to visibility, pack or not.
255 if (isa<TemplateTypeParmDecl>(P))
256 continue;
257
258 // Non-type template parameters can be restricted by the value type, e.g.
259 // template <enum X> class A { ... };
260 // We have to be careful here, though, because we can be dealing with
261 // dependent types.
262 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
263 // Handle the non-pack case first.
264 if (!NTTP->isExpandedParameterPack()) {
265 if (!NTTP->getType()->isDependentType()) {
266 LV.merge(getLVForType(*NTTP->getType(), computation));
267 }
268 continue;
269 }
270
271 // Look at all the types in an expanded pack.
272 for (unsigned i = 0, n = NTTP->getNumExpansionTypes(); i != n; ++i) {
273 QualType type = NTTP->getExpansionType(i);
274 if (!type->isDependentType())
276 }
277 continue;
278 }
279
280 // Template template parameters can be restricted by their
281 // template parameters, recursively.
282 const auto *TTP = cast<TemplateTemplateParmDecl>(P);
283
284 // Handle the non-pack case first.
285 if (!TTP->isExpandedParameterPack()) {
286 LV.merge(getLVForTemplateParameterList(TTP->getTemplateParameters(),
287 computation));
288 continue;
289 }
290
291 // Look at all expansions in an expanded pack.
292 for (unsigned i = 0, n = TTP->getNumExpansionTemplateParameters();
293 i != n; ++i) {
294 LV.merge(getLVForTemplateParameterList(
295 TTP->getExpansionTemplateParameters(i), computation));
296 }
297 }
298
299 return LV;
300}
301
303 const Decl *Ret = nullptr;
304 const DeclContext *DC = D->getDeclContext();
305 while (DC->getDeclKind() != Decl::TranslationUnit) {
306 if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC))
307 Ret = cast<Decl>(DC);
308 DC = DC->getParent();
309 }
310 return Ret;
311}
312
313/// Get the most restrictive linkage for the types and
314/// declarations in the given template argument list.
315///
316/// Note that we don't take an LVComputationKind because we always
317/// want to honor the visibility of template arguments in the same way.
319LinkageComputer::getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args,
320 LVComputationKind computation) {
321 LinkageInfo LV;
322
323 for (const TemplateArgument &Arg : Args) {
324 switch (Arg.getKind()) {
328 continue;
329
331 LV.merge(getLVForType(*Arg.getAsType(), computation));
332 continue;
333
335 const NamedDecl *ND = Arg.getAsDecl();
336 assert(!usesTypeVisibility(ND));
337 LV.merge(getLVForDecl(ND, computation));
338 continue;
339 }
340
342 LV.merge(getTypeLinkageAndVisibility(Arg.getNullPtrType()));
343 continue;
344
346 LV.merge(getLVForValue(Arg.getAsStructuralValue(), computation));
347 continue;
348
351 if (TemplateDecl *Template =
352 Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl(
353 /*IgnoreDeduced=*/true))
354 LV.merge(getLVForDecl(Template, computation));
355 continue;
356
358 LV.merge(getLVForTemplateArgumentList(Arg.getPackAsArray(), computation));
359 continue;
360 }
361 llvm_unreachable("bad template argument kind");
362 }
363
364 return LV;
365}
366
368LinkageComputer::getLVForTemplateArgumentList(const TemplateArgumentList &TArgs,
369 LVComputationKind computation) {
370 return getLVForTemplateArgumentList(TArgs.asArray(), computation);
371}
372
374 const FunctionTemplateSpecializationInfo *specInfo) {
375 // Include visibility from the template parameters and arguments
376 // only if this is not an explicit instantiation or specialization
377 // with direct explicit visibility. (Implicit instantiations won't
378 // have a direct attribute.)
380 return true;
381
382 return !fn->hasAttr<VisibilityAttr>();
383}
384
385/// Merge in template-related linkage and visibility for the given
386/// function template specialization.
387///
388/// We don't need a computation kind here because we can assume
389/// LVForValue.
390///
391/// \param[out] LV the computation to use for the parent
392void LinkageComputer::mergeTemplateLV(
393 LinkageInfo &LV, const FunctionDecl *fn,
395 LVComputationKind computation) {
396 bool considerVisibility =
398
399 FunctionTemplateDecl *temp = specInfo->getTemplate();
400 // Merge information from the template declaration.
401 LinkageInfo tempLV = getLVForDecl(temp, computation);
402 // The linkage of the specialization should be consistent with the
403 // template declaration.
404 LV.setLinkage(tempLV.getLinkage());
405
406 // Merge information from the template parameters.
407 LinkageInfo paramsLV =
408 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
409 LV.mergeMaybeWithVisibility(paramsLV, considerVisibility);
410
411 // Merge information from the template arguments.
412 const TemplateArgumentList &templateArgs = *specInfo->TemplateArguments;
413 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
414 LV.mergeMaybeWithVisibility(argsLV, considerVisibility);
415}
416
417/// Does the given declaration have a direct visibility attribute
418/// that would match the given rules?
420 LVComputationKind computation) {
421 if (computation.IgnoreAllVisibility)
422 return false;
423
424 return (computation.isTypeVisibility() && D->hasAttr<TypeVisibilityAttr>()) ||
425 D->hasAttr<VisibilityAttr>();
426}
427
428/// Should we consider visibility associated with the template
429/// arguments and parameters of the given class template specialization?
432 LVComputationKind computation) {
433 // Include visibility from the template parameters and arguments
434 // only if this is not an explicit instantiation or specialization
435 // with direct explicit visibility (and note that implicit
436 // instantiations won't have a direct attribute).
437 //
438 // Furthermore, we want to ignore template parameters and arguments
439 // for an explicit specialization when computing the visibility of a
440 // member thereof with explicit visibility.
441 //
442 // This is a bit complex; let's unpack it.
443 //
444 // An explicit class specialization is an independent, top-level
445 // declaration. As such, if it or any of its members has an
446 // explicit visibility attribute, that must directly express the
447 // user's intent, and we should honor it. The same logic applies to
448 // an explicit instantiation of a member of such a thing.
449
450 // Fast path: if this is not an explicit instantiation or
451 // specialization, we always want to consider template-related
452 // visibility restrictions.
454 return true;
455
456 // This is the 'member thereof' check.
457 if (spec->isExplicitSpecialization() &&
458 hasExplicitVisibilityAlready(computation))
459 return false;
460
461 return !hasDirectVisibilityAttribute(spec, computation);
462}
463
464/// Merge in template-related linkage and visibility for the given
465/// class template specialization.
466void LinkageComputer::mergeTemplateLV(
468 LVComputationKind computation) {
469 bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
470
471 // Merge information from the template parameters, but ignore
472 // visibility if we're only considering template arguments.
474 // Merge information from the template declaration.
475 LinkageInfo tempLV = getLVForDecl(temp, computation);
476 // The linkage of the specialization should be consistent with the
477 // template declaration.
478 LV.setLinkage(tempLV.getLinkage());
479
480 LinkageInfo paramsLV =
481 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
482 LV.mergeMaybeWithVisibility(paramsLV,
483 considerVisibility && !hasExplicitVisibilityAlready(computation));
484
485 // Merge information from the template arguments. We ignore
486 // template-argument visibility if we've got an explicit
487 // instantiation with a visibility attribute.
488 const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
489 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
490 if (considerVisibility)
491 LV.mergeVisibility(argsLV);
492 LV.mergeExternalVisibility(argsLV);
493}
494
495/// Should we consider visibility associated with the template
496/// arguments and parameters of the given variable template
497/// specialization? As usual, follow class template specialization
498/// logic up to initialization.
501 LVComputationKind computation) {
502 // Include visibility from the template parameters and arguments
503 // only if this is not an explicit instantiation or specialization
504 // with direct explicit visibility (and note that implicit
505 // instantiations won't have a direct attribute).
507 return true;
508
509 // An explicit variable specialization is an independent, top-level
510 // declaration. As such, if it has an explicit visibility attribute,
511 // that must directly express the user's intent, and we should honor
512 // it.
513 if (spec->isExplicitSpecialization() &&
514 hasExplicitVisibilityAlready(computation))
515 return false;
516
517 return !hasDirectVisibilityAttribute(spec, computation);
518}
519
520/// Merge in template-related linkage and visibility for the given
521/// variable template specialization. As usual, follow class template
522/// specialization logic up to initialization.
523void LinkageComputer::mergeTemplateLV(LinkageInfo &LV,
525 LVComputationKind computation) {
526 bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
527
528 // Merge information from the template parameters, but ignore
529 // visibility if we're only considering template arguments.
531 LinkageInfo tempLV =
532 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
533 LV.mergeMaybeWithVisibility(tempLV,
534 considerVisibility && !hasExplicitVisibilityAlready(computation));
535
536 // Merge information from the template arguments. We ignore
537 // template-argument visibility if we've got an explicit
538 // instantiation with a visibility attribute.
539 const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
540 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
541 if (considerVisibility)
542 LV.mergeVisibility(argsLV);
543 LV.mergeExternalVisibility(argsLV);
544}
545
547 // FIXME: we should warn if -fvisibility-inlines-hidden is used with c.
548 const LangOptions &Opts = D->getASTContext().getLangOpts();
549 if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
550 return false;
551
552 const auto *FD = dyn_cast<FunctionDecl>(D);
553 if (!FD)
554 return false;
555
558 = FD->getTemplateSpecializationInfo()) {
559 TSK = spec->getTemplateSpecializationKind();
560 } else if (MemberSpecializationInfo *MSI =
561 FD->getMemberSpecializationInfo()) {
562 TSK = MSI->getTemplateSpecializationKind();
563 }
564
565 const FunctionDecl *Def = nullptr;
566 // InlineVisibilityHidden only applies to definitions, and
567 // isInlined() only gives meaningful answers on definitions
568 // anyway.
571 FD->hasBody(Def) && Def->isInlined() && !Def->hasAttr<GNUInlineAttr>();
572}
573
574template <typename T> static bool isFirstInExternCContext(T *D) {
575 const T *First = D->getFirstDecl();
576 return First->isInExternCContext();
577}
578
579static bool isSingleLineLanguageLinkage(const Decl &D) {
580 if (const auto *SD = dyn_cast<LinkageSpecDecl>(D.getDeclContext()))
581 if (!SD->hasBraces())
582 return true;
583 return false;
584}
585
587 return LinkageInfo::external();
588}
589
591 if (auto *TD = dyn_cast<TemplateDecl>(D))
592 D = TD->getTemplatedDecl();
593 if (D) {
594 if (auto *VD = dyn_cast<VarDecl>(D))
595 return VD->getStorageClass();
596 if (auto *FD = dyn_cast<FunctionDecl>(D))
597 return FD->getStorageClass();
598 }
599 return SC_None;
600}
601
603LinkageComputer::getLVForNamespaceScopeDecl(const NamedDecl *D,
604 LVComputationKind computation,
605 bool IgnoreVarTypeLinkage) {
607 "Not a name having namespace scope");
608 ASTContext &Context = D->getASTContext();
609 const auto *Var = dyn_cast<VarDecl>(D);
610
611 // C++ [basic.link]p3:
612 // A name having namespace scope (3.3.6) has internal linkage if it
613 // is the name of
614
616 (Context.getLangOpts().C23 && Var && Var->isConstexpr())) {
617 // - a variable, variable template, function, or function template
618 // that is explicitly declared static; or
619 // (This bullet corresponds to C99 6.2.2p3.)
620
621 // C23 6.2.2p3
622 // If the declaration of a file scope identifier for
623 // an object contains any of the storage-class specifiers static or
624 // constexpr then the identifier has internal linkage.
625 return LinkageInfo::internal();
626 }
627
628 if (Var) {
629 // - a non-template variable of non-volatile const-qualified type, unless
630 // - it is explicitly declared extern, or
631 // - it is declared in the purview of a module interface unit
632 // (outside the private-module-fragment, if any) or module partition, or
633 // - it is inline, or
634 // - it was previously declared and the prior declaration did not have
635 // internal linkage
636 // (There is no equivalent in C99.)
637 if (Context.getLangOpts().CPlusPlus && Var->getType().isConstQualified() &&
638 !Var->getType().isVolatileQualified() && !Var->isInline() &&
639 ![Var]() {
640 // Check if it is module purview except private module fragment
641 // and implementation unit.
642 if (auto *M = Var->getOwningModule())
643 return M->isInterfaceOrPartition() || M->isImplicitGlobalModule();
644 return false;
645 }() &&
646 !isa<VarTemplateSpecializationDecl>(Var) &&
647 !Var->getDescribedVarTemplate()) {
648 const VarDecl *PrevVar = Var->getPreviousDecl();
649 if (PrevVar)
650 return getLVForDecl(PrevVar, computation);
651
652 if (Var->getStorageClass() != SC_Extern &&
653 Var->getStorageClass() != SC_PrivateExtern &&
655 return LinkageInfo::internal();
656 }
657
658 for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar;
659 PrevVar = PrevVar->getPreviousDecl()) {
660 if (PrevVar->getStorageClass() == SC_PrivateExtern &&
661 Var->getStorageClass() == SC_None)
662 return getDeclLinkageAndVisibility(PrevVar);
663 // Explicitly declared static.
664 if (PrevVar->getStorageClass() == SC_Static)
665 return LinkageInfo::internal();
666 }
667 } else if (const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
668 // - a data member of an anonymous union.
669 const VarDecl *VD = IFD->getVarDecl();
670 assert(VD && "Expected a VarDecl in this IndirectFieldDecl!");
671 return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
672 }
673 assert(!isa<FieldDecl>(D) && "Didn't expect a FieldDecl!");
674
675 // FIXME: This gives internal linkage to names that should have no linkage
676 // (those not covered by [basic.link]p6).
677 if (D->isInAnonymousNamespace()) {
678 const auto *Var = dyn_cast<VarDecl>(D);
679 const auto *Func = dyn_cast<FunctionDecl>(D);
680 // FIXME: The check for extern "C" here is not justified by the standard
681 // wording, but we retain it from the pre-DR1113 model to avoid breaking
682 // code.
683 //
684 // C++11 [basic.link]p4:
685 // An unnamed namespace or a namespace declared directly or indirectly
686 // within an unnamed namespace has internal linkage.
687 if ((!Var || !isFirstInExternCContext(Var)) &&
689 return LinkageInfo::internal();
690 }
691
692 // Set up the defaults.
693
694 // C99 6.2.2p5:
695 // If the declaration of an identifier for an object has file
696 // scope and no storage-class specifier, its linkage is
697 // external.
699
700 if (!hasExplicitVisibilityAlready(computation)) {
701 if (std::optional<Visibility> Vis = getExplicitVisibility(D, computation)) {
702 LV.mergeVisibility(*Vis, true);
703 } else {
704 // If we're declared in a namespace with a visibility attribute,
705 // use that namespace's visibility, and it still counts as explicit.
706 for (const DeclContext *DC = D->getDeclContext();
707 !isa<TranslationUnitDecl>(DC);
708 DC = DC->getParent()) {
709 const auto *ND = dyn_cast<NamespaceDecl>(DC);
710 if (!ND) continue;
711 if (std::optional<Visibility> Vis =
712 getExplicitVisibility(ND, computation)) {
713 LV.mergeVisibility(*Vis, true);
714 break;
715 }
716 }
717 }
718
719 // Add in global settings if the above didn't give us direct visibility.
720 if (!LV.isVisibilityExplicit()) {
721 // Use global type/value visibility as appropriate.
722 Visibility globalVisibility =
723 computation.isValueVisibility()
724 ? Context.getLangOpts().getValueVisibilityMode()
725 : Context.getLangOpts().getTypeVisibilityMode();
726 LV.mergeVisibility(globalVisibility, /*explicit*/ false);
727
728 // If we're paying attention to global visibility, apply
729 // -finline-visibility-hidden if this is an inline method.
731 LV.mergeVisibility(HiddenVisibility, /*visibilityExplicit=*/false);
732 }
733 }
734
735 // C++ [basic.link]p4:
736
737 // A name having namespace scope that has not been given internal linkage
738 // above and that is the name of
739 // [...bullets...]
740 // has its linkage determined as follows:
741 // - if the enclosing namespace has internal linkage, the name has
742 // internal linkage; [handled above]
743 // - otherwise, if the declaration of the name is attached to a named
744 // module and is not exported, the name has module linkage;
745 // - otherwise, the name has external linkage.
746 // LV is currently set up to handle the last two bullets.
747 //
748 // The bullets are:
749
750 // - a variable; or
751 if (const auto *Var = dyn_cast<VarDecl>(D)) {
752 // GCC applies the following optimization to variables and static
753 // data members, but not to functions:
754 //
755 // Modify the variable's LV by the LV of its type unless this is
756 // C or extern "C". This follows from [basic.link]p9:
757 // A type without linkage shall not be used as the type of a
758 // variable or function with external linkage unless
759 // - the entity has C language linkage, or
760 // - the entity is declared within an unnamed namespace, or
761 // - the entity is not used or is defined in the same
762 // translation unit.
763 // and [basic.link]p10:
764 // ...the types specified by all declarations referring to a
765 // given variable or function shall be identical...
766 // C does not have an equivalent rule.
767 //
768 // Ignore this if we've got an explicit attribute; the user
769 // probably knows what they're doing.
770 //
771 // Note that we don't want to make the variable non-external
772 // because of this, but unique-external linkage suits us.
773
774 if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Var) &&
775 !IgnoreVarTypeLinkage) {
776 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
777 if (!isExternallyVisible(TypeLV.getLinkage()))
779 if (!LV.isVisibilityExplicit())
780 LV.mergeVisibility(TypeLV);
781 }
782
783 if (Var->getStorageClass() == SC_PrivateExtern)
785
786 // Note that Sema::MergeVarDecl already takes care of implementing
787 // C99 6.2.2p4 and propagating the visibility attribute, so we don't have
788 // to do it here.
789
790 // As per function and class template specializations (below),
791 // consider LV for the template and template arguments. We're at file
792 // scope, so we do not need to worry about nested specializations.
793 if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
794 mergeTemplateLV(LV, spec, computation);
795 }
796
797 // - a function; or
798 } else if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
799 // In theory, we can modify the function's LV by the LV of its
800 // type unless it has C linkage (see comment above about variables
801 // for justification). In practice, GCC doesn't do this, so it's
802 // just too painful to make work.
803
804 if (Function->getStorageClass() == SC_PrivateExtern)
806
807 // OpenMP target declare device functions are not callable from the host so
808 // they should not be exported from the device image. This applies to all
809 // functions as the host-callable kernel functions are emitted at codegen.
810 if (Context.getLangOpts().OpenMP &&
811 Context.getLangOpts().OpenMPIsTargetDevice &&
812 ((Context.getTargetInfo().getTriple().isAMDGPU() ||
813 Context.getTargetInfo().getTriple().isNVPTX()) ||
814 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Function)))
815 LV.mergeVisibility(HiddenVisibility, /*newExplicit=*/false);
816
817 // Note that Sema::MergeCompatibleFunctionDecls already takes care of
818 // merging storage classes and visibility attributes, so we don't have to
819 // look at previous decls in here.
820
821 // In C++, then if the type of the function uses a type with
822 // unique-external linkage, it's not legally usable from outside
823 // this translation unit. However, we should use the C linkage
824 // rules instead for extern "C" declarations.
825 if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Function)) {
826 // Only look at the type-as-written. Otherwise, deducing the return type
827 // of a function could change its linkage.
828 QualType TypeAsWritten = Function->getType();
829 if (TypeSourceInfo *TSI = Function->getTypeSourceInfo())
830 TypeAsWritten = TSI->getType();
831 if (!isExternallyVisible(TypeAsWritten->getLinkage()))
833 }
834
835 // Consider LV from the template and the template arguments.
836 // We're at file scope, so we do not need to worry about nested
837 // specializations.
839 = Function->getTemplateSpecializationInfo()) {
840 mergeTemplateLV(LV, Function, specInfo, computation);
841 }
842
843 // - a named class (Clause 9), or an unnamed class defined in a
844 // typedef declaration in which the class has the typedef name
845 // for linkage purposes (7.1.3); or
846 // - a named enumeration (7.2), or an unnamed enumeration
847 // defined in a typedef declaration in which the enumeration
848 // has the typedef name for linkage purposes (7.1.3); or
849 } else if (const auto *Tag = dyn_cast<TagDecl>(D)) {
850 // Unnamed tags have no linkage.
851 if (!Tag->hasNameForLinkage())
852 return LinkageInfo::none();
853
854 // If this is a class template specialization, consider the
855 // linkage of the template and template arguments. We're at file
856 // scope, so we do not need to worry about nested specializations.
857 if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
858 mergeTemplateLV(LV, spec, computation);
859 }
860
861 // FIXME: This is not part of the C++ standard any more.
862 // - an enumerator belonging to an enumeration with external linkage; or
863 } else if (isa<EnumConstantDecl>(D)) {
864 LinkageInfo EnumLV = getLVForDecl(cast<NamedDecl>(D->getDeclContext()),
865 computation);
866 if (!isExternalFormalLinkage(EnumLV.getLinkage()))
867 return LinkageInfo::none();
868 LV.merge(EnumLV);
869
870 // - a template
871 } else if (const auto *temp = dyn_cast<TemplateDecl>(D)) {
872 bool considerVisibility = !hasExplicitVisibilityAlready(computation);
873 LinkageInfo tempLV =
874 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
875 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
876
877 // An unnamed namespace or a namespace declared directly or indirectly
878 // within an unnamed namespace has internal linkage. All other namespaces
879 // have external linkage.
880 //
881 // We handled names in anonymous namespaces above.
882 } else if (isa<NamespaceDecl>(D)) {
883 return LV;
884
885 // By extension, we assign external linkage to Objective-C
886 // interfaces.
887 } else if (isa<ObjCInterfaceDecl>(D)) {
888 // fallout
889
890 } else if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
891 // A typedef declaration has linkage if it gives a type a name for
892 // linkage purposes.
893 if (!TD->getAnonDeclWithTypedefName(/*AnyRedecl*/true))
894 return LinkageInfo::none();
895
896 } else if (isa<MSGuidDecl>(D)) {
897 // A GUID behaves like an inline variable with external linkage. Fall
898 // through.
899
900 // Everything not covered here has no linkage.
901 } else {
902 return LinkageInfo::none();
903 }
904
905 // If we ended up with non-externally-visible linkage, visibility should
906 // always be default.
908 return LinkageInfo(LV.getLinkage(), DefaultVisibility, false);
909
910 return LV;
911}
912
914LinkageComputer::getLVForClassMember(const NamedDecl *D,
915 LVComputationKind computation,
916 bool IgnoreVarTypeLinkage) {
917 // Only certain class members have linkage. Note that fields don't
918 // really have linkage, but it's convenient to say they do for the
919 // purposes of calculating linkage of pointer-to-data-member
920 // template arguments.
921 //
922 // Templates also don't officially have linkage, but since we ignore
923 // the C++ standard and look at template arguments when determining
924 // linkage and visibility of a template specialization, we might hit
925 // a template template argument that way. If we do, we need to
926 // consider its linkage.
927 if (!(isa<CXXMethodDecl>(D) ||
928 isa<VarDecl>(D) ||
929 isa<FieldDecl>(D) ||
930 isa<IndirectFieldDecl>(D) ||
931 isa<TagDecl>(D) ||
932 isa<TemplateDecl>(D)))
933 return LinkageInfo::none();
934
935 LinkageInfo LV;
936
937 // If we have an explicit visibility attribute, merge that in.
938 if (!hasExplicitVisibilityAlready(computation)) {
939 if (std::optional<Visibility> Vis = getExplicitVisibility(D, computation))
940 LV.mergeVisibility(*Vis, true);
941 // If we're paying attention to global visibility, apply
942 // -finline-visibility-hidden if this is an inline method.
943 //
944 // Note that we do this before merging information about
945 // the class visibility.
947 LV.mergeVisibility(HiddenVisibility, /*visibilityExplicit=*/false);
948 }
949
950 // If this class member has an explicit visibility attribute, the only
951 // thing that can change its visibility is the template arguments, so
952 // only look for them when processing the class.
953 LVComputationKind classComputation = computation;
954 if (LV.isVisibilityExplicit())
955 classComputation = withExplicitVisibilityAlready(computation);
956
957 LinkageInfo classLV =
958 getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation);
959 // The member has the same linkage as the class. If that's not externally
960 // visible, we don't need to compute anything about the linkage.
961 // FIXME: If we're only computing linkage, can we bail out here?
962 if (!isExternallyVisible(classLV.getLinkage()))
963 return classLV;
964
965
966 // Otherwise, don't merge in classLV yet, because in certain cases
967 // we need to completely ignore the visibility from it.
968
969 // Specifically, if this decl exists and has an explicit attribute.
970 const NamedDecl *explicitSpecSuppressor = nullptr;
971
972 if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
973 // Only look at the type-as-written. Otherwise, deducing the return type
974 // of a function could change its linkage.
975 QualType TypeAsWritten = MD->getType();
976 if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
977 TypeAsWritten = TSI->getType();
978 if (!isExternallyVisible(TypeAsWritten->getLinkage()))
980
981 // If this is a method template specialization, use the linkage for
982 // the template parameters and arguments.
984 = MD->getTemplateSpecializationInfo()) {
985 mergeTemplateLV(LV, MD, spec, computation);
986 if (spec->isExplicitSpecialization()) {
987 explicitSpecSuppressor = MD;
988 } else if (isExplicitMemberSpecialization(spec->getTemplate())) {
989 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
990 }
991 } else if (isExplicitMemberSpecialization(MD)) {
992 explicitSpecSuppressor = MD;
993 }
994
995 // OpenMP target declare device functions are not callable from the host so
996 // they should not be exported from the device image. This applies to all
997 // functions as the host-callable kernel functions are emitted at codegen.
998 ASTContext &Context = D->getASTContext();
999 if (Context.getLangOpts().OpenMP &&
1000 Context.getLangOpts().OpenMPIsTargetDevice &&
1001 ((Context.getTargetInfo().getTriple().isAMDGPU() ||
1002 Context.getTargetInfo().getTriple().isNVPTX()) ||
1003 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(MD)))
1004 LV.mergeVisibility(HiddenVisibility, /*newExplicit=*/false);
1005
1006 } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
1007 if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
1008 mergeTemplateLV(LV, spec, computation);
1009 if (spec->isExplicitSpecialization()) {
1010 explicitSpecSuppressor = spec;
1011 } else {
1012 const ClassTemplateDecl *temp = spec->getSpecializedTemplate();
1014 explicitSpecSuppressor = temp->getTemplatedDecl();
1015 }
1016 }
1017 } else if (isExplicitMemberSpecialization(RD)) {
1018 explicitSpecSuppressor = RD;
1019 }
1020
1021 // Static data members.
1022 } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
1023 if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
1024 mergeTemplateLV(LV, spec, computation);
1025
1026 // Modify the variable's linkage by its type, but ignore the
1027 // type's visibility unless it's a definition.
1028 if (!IgnoreVarTypeLinkage) {
1029 LinkageInfo typeLV = getLVForType(*VD->getType(), computation);
1030 // FIXME: If the type's linkage is not externally visible, we can
1031 // give this static data member UniqueExternalLinkage.
1032 if (!LV.isVisibilityExplicit() && !classLV.isVisibilityExplicit())
1033 LV.mergeVisibility(typeLV);
1034 LV.mergeExternalVisibility(typeLV);
1035 }
1036
1038 explicitSpecSuppressor = VD;
1039 }
1040
1041 // Template members.
1042 } else if (const auto *temp = dyn_cast<TemplateDecl>(D)) {
1043 bool considerVisibility =
1044 (!LV.isVisibilityExplicit() &&
1045 !classLV.isVisibilityExplicit() &&
1046 !hasExplicitVisibilityAlready(computation));
1047 LinkageInfo tempLV =
1048 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
1049 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
1050
1051 if (const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
1052 if (isExplicitMemberSpecialization(redeclTemp)) {
1053 explicitSpecSuppressor = temp->getTemplatedDecl();
1054 }
1055 }
1056 }
1057
1058 // We should never be looking for an attribute directly on a template.
1059 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
1060
1061 // If this member is an explicit member specialization, and it has
1062 // an explicit attribute, ignore visibility from the parent.
1063 bool considerClassVisibility = true;
1064 if (explicitSpecSuppressor &&
1065 // optimization: hasDVA() is true only with explicit visibility.
1066 LV.isVisibilityExplicit() &&
1067 classLV.getVisibility() != DefaultVisibility &&
1068 hasDirectVisibilityAttribute(explicitSpecSuppressor, computation)) {
1069 considerClassVisibility = false;
1070 }
1071
1072 // Finally, merge in information from the class.
1073 LV.mergeMaybeWithVisibility(classLV, considerClassVisibility);
1074 return LV;
1075}
1076
1077void NamedDecl::anchor() {}
1078
1080 if (!hasCachedLinkage())
1081 return true;
1082
1085 .getLinkage();
1086 return L == getCachedLinkage();
1087}
1088
1089bool NamedDecl::isPlaceholderVar(const LangOptions &LangOpts) const {
1090 // [C++2c] [basic.scope.scope]/p5
1091 // A declaration is name-independent if its name is _ and it declares
1092 // - a variable with automatic storage duration,
1093 // - a structured binding not inhabiting a namespace scope,
1094 // - the variable introduced by an init-capture
1095 // - or a non-static data member.
1096
1097 if (!LangOpts.CPlusPlus || !getIdentifier() ||
1098 !getIdentifier()->isPlaceholder())
1099 return false;
1100 if (isa<FieldDecl>(this))
1101 return true;
1102 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(this)) {
1103 if (!getDeclContext()->isFunctionOrMethod() &&
1104 !getDeclContext()->isRecord())
1105 return false;
1106 const VarDecl *VD = IFD->getVarDecl();
1107 return !VD || VD->getStorageDuration() == SD_Automatic;
1108 }
1109 // and it declares a variable with automatic storage duration
1110 if (const auto *VD = dyn_cast<VarDecl>(this)) {
1111 if (isa<ParmVarDecl>(VD))
1112 return false;
1113 if (VD->isInitCapture())
1114 return true;
1116 }
1117 if (const auto *BD = dyn_cast<BindingDecl>(this);
1119 const VarDecl *VD = BD->getHoldingVar();
1121 }
1122 return false;
1123}
1124
1126NamedDecl::isReserved(const LangOptions &LangOpts) const {
1127 const IdentifierInfo *II = getIdentifier();
1128
1129 // This triggers at least for CXXLiteralIdentifiers, which we already checked
1130 // at lexing time.
1131 if (!II)
1133
1134 ReservedIdentifierStatus Status = II->isReserved(LangOpts);
1135 if (isReservedAtGlobalScope(Status) && !isReservedInAllContexts(Status)) {
1136 // This name is only reserved at global scope. Check if this declaration
1137 // conflicts with a global scope declaration.
1138 if (isa<ParmVarDecl>(this) || isTemplateParameter())
1140
1141 // C++ [dcl.link]/7:
1142 // Two declarations [conflict] if [...] one declares a function or
1143 // variable with C language linkage, and the other declares [...] a
1144 // variable that belongs to the global scope.
1145 //
1146 // Therefore names that are reserved at global scope are also reserved as
1147 // names of variables and functions with C language linkage.
1149 if (DC->isTranslationUnit())
1150 return Status;
1151 if (auto *VD = dyn_cast<VarDecl>(this))
1152 if (VD->isExternC())
1154 if (auto *FD = dyn_cast<FunctionDecl>(this))
1155 if (FD->isExternC())
1158 }
1159
1160 return Status;
1161}
1162
1164 StringRef name = getName();
1165 if (name.empty()) return SFF_None;
1166
1167 if (name.front() == 'C')
1168 if (name == "CFStringCreateWithFormat" ||
1169 name == "CFStringCreateWithFormatAndArguments" ||
1170 name == "CFStringAppendFormat" ||
1171 name == "CFStringAppendFormatAndArguments")
1172 return SFF_CFString;
1173 return SFF_None;
1174}
1175
1177 // We don't care about visibility here, so ask for the cheapest
1178 // possible visibility analysis.
1179 return LinkageComputer{}
1181 .getLinkage();
1182}
1183
1185 // FIXME: Handle isModulePrivate.
1186 switch (D->getModuleOwnershipKind()) {
1190 return false;
1193 return D->isInNamedModule();
1194 }
1195 llvm_unreachable("unexpected module ownership kind");
1196}
1197
1198/// Get the linkage from a semantic point of view. Entities in
1199/// anonymous namespaces are external (in c++98).
1201 Linkage InternalLinkage = getLinkageInternal();
1202
1203 // C++ [basic.link]p4.8:
1204 // - if the declaration of the name is attached to a named module and is not
1205 // exported
1206 // the name has module linkage;
1207 //
1208 // [basic.namespace.general]/p2
1209 // A namespace is never attached to a named module and never has a name with
1210 // module linkage.
1211 if (isInNamedModule() && InternalLinkage == Linkage::External &&
1213 cast<NamedDecl>(this->getCanonicalDecl())) &&
1214 !isa<NamespaceDecl>(this))
1215 InternalLinkage = Linkage::Module;
1216
1217 return clang::getFormalLinkage(InternalLinkage);
1218}
1219
1222}
1223
1224static std::optional<Visibility>
1227 bool IsMostRecent) {
1228 assert(!IsMostRecent || ND == ND->getMostRecentDecl());
1229
1230 // Check the declaration itself first.
1231 if (std::optional<Visibility> V = getVisibilityOf(ND, kind))
1232 return V;
1233
1234 // If this is a member class of a specialization of a class template
1235 // and the corresponding decl has explicit visibility, use that.
1236 if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
1237 CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass();
1238 if (InstantiatedFrom)
1239 return getVisibilityOf(InstantiatedFrom, kind);
1240 }
1241
1242 // If there wasn't explicit visibility there, and this is a
1243 // specialization of a class template, check for visibility
1244 // on the pattern.
1245 if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
1246 // Walk all the template decl till this point to see if there are
1247 // explicit visibility attributes.
1248 const auto *TD = spec->getSpecializedTemplate()->getTemplatedDecl();
1249 while (TD != nullptr) {
1250 auto Vis = getVisibilityOf(TD, kind);
1251 if (Vis != std::nullopt)
1252 return Vis;
1253 TD = TD->getPreviousDecl();
1254 }
1255 return std::nullopt;
1256 }
1257
1258 // Use the most recent declaration.
1259 if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
1260 const NamedDecl *MostRecent = ND->getMostRecentDecl();
1261 if (MostRecent != ND)
1262 return getExplicitVisibilityAux(MostRecent, kind, true);
1263 }
1264
1265 if (const auto *Var = dyn_cast<VarDecl>(ND)) {
1266 if (Var->isStaticDataMember()) {
1267 VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember();
1268 if (InstantiatedFrom)
1269 return getVisibilityOf(InstantiatedFrom, kind);
1270 }
1271
1272 if (const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
1273 return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
1274 kind);
1275
1276 return std::nullopt;
1277 }
1278 // Also handle function template specializations.
1279 if (const auto *fn = dyn_cast<FunctionDecl>(ND)) {
1280 // If the function is a specialization of a template with an
1281 // explicit visibility attribute, use that.
1282 if (FunctionTemplateSpecializationInfo *templateInfo
1284 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
1285 kind);
1286
1287 // If the function is a member of a specialization of a class template
1288 // and the corresponding decl has explicit visibility, use that.
1289 FunctionDecl *InstantiatedFrom = fn->getInstantiatedFromMemberFunction();
1290 if (InstantiatedFrom)
1291 return getVisibilityOf(InstantiatedFrom, kind);
1292
1293 return std::nullopt;
1294 }
1295
1296 // The visibility of a template is stored in the templated decl.
1297 if (const auto *TD = dyn_cast<TemplateDecl>(ND))
1298 return getVisibilityOf(TD->getTemplatedDecl(), kind);
1299
1300 return std::nullopt;
1301}
1302
1303std::optional<Visibility>
1305 return getExplicitVisibilityAux(this, kind, false);
1306}
1307
1308LinkageInfo LinkageComputer::getLVForClosure(const DeclContext *DC,
1309 Decl *ContextDecl,
1310 LVComputationKind computation) {
1311 // This lambda has its linkage/visibility determined by its owner.
1312 const NamedDecl *Owner;
1313 if (!ContextDecl)
1314 Owner = dyn_cast<NamedDecl>(DC);
1315 else if (isa<ParmVarDecl>(ContextDecl))
1316 Owner =
1317 dyn_cast<NamedDecl>(ContextDecl->getDeclContext()->getRedeclContext());
1318 else if (isa<ImplicitConceptSpecializationDecl>(ContextDecl)) {
1319 // Replace with the concept's owning decl, which is either a namespace or a
1320 // TU, so this needs a dyn_cast.
1321 Owner = dyn_cast<NamedDecl>(ContextDecl->getDeclContext());
1322 } else {
1323 Owner = cast<NamedDecl>(ContextDecl);
1324 }
1325
1326 if (!Owner)
1327 return LinkageInfo::none();
1328
1329 // If the owner has a deduced type, we need to skip querying the linkage and
1330 // visibility of that type, because it might involve this closure type. The
1331 // only effect of this is that we might give a lambda VisibleNoLinkage rather
1332 // than NoLinkage when we don't strictly need to, which is benign.
1333 auto *VD = dyn_cast<VarDecl>(Owner);
1334 LinkageInfo OwnerLV =
1335 VD && VD->getType()->getContainedDeducedType()
1336 ? computeLVForDecl(Owner, computation, /*IgnoreVarTypeLinkage*/true)
1337 : getLVForDecl(Owner, computation);
1338
1339 // A lambda never formally has linkage. But if the owner is externally
1340 // visible, then the lambda is too. We apply the same rules to blocks.
1341 if (!isExternallyVisible(OwnerLV.getLinkage()))
1342 return LinkageInfo::none();
1344 OwnerLV.isVisibilityExplicit());
1345}
1346
1347LinkageInfo LinkageComputer::getLVForLocalDecl(const NamedDecl *D,
1348 LVComputationKind computation) {
1349 if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
1350 if (Function->isInAnonymousNamespace() &&
1352 return LinkageInfo::internal();
1353
1354 // This is a "void f();" which got merged with a file static.
1355 if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
1356 return LinkageInfo::internal();
1357
1358 LinkageInfo LV;
1359 if (!hasExplicitVisibilityAlready(computation)) {
1360 if (std::optional<Visibility> Vis =
1361 getExplicitVisibility(Function, computation))
1362 LV.mergeVisibility(*Vis, true);
1363 }
1364
1365 // Note that Sema::MergeCompatibleFunctionDecls already takes care of
1366 // merging storage classes and visibility attributes, so we don't have to
1367 // look at previous decls in here.
1368
1369 return LV;
1370 }
1371
1372 if (const auto *Var = dyn_cast<VarDecl>(D)) {
1373 if (Var->hasExternalStorage()) {
1374 if (Var->isInAnonymousNamespace() && !isFirstInExternCContext(Var))
1375 return LinkageInfo::internal();
1376
1377 LinkageInfo LV;
1378 if (Var->getStorageClass() == SC_PrivateExtern)
1380 else if (!hasExplicitVisibilityAlready(computation)) {
1381 if (std::optional<Visibility> Vis =
1382 getExplicitVisibility(Var, computation))
1383 LV.mergeVisibility(*Vis, true);
1384 }
1385
1386 if (const VarDecl *Prev = Var->getPreviousDecl()) {
1387 LinkageInfo PrevLV = getLVForDecl(Prev, computation);
1388 if (PrevLV.getLinkage() != Linkage::Invalid)
1389 LV.setLinkage(PrevLV.getLinkage());
1390 LV.mergeVisibility(PrevLV);
1391 }
1392
1393 return LV;
1394 }
1395
1396 if (!Var->isStaticLocal())
1397 return LinkageInfo::none();
1398 }
1399
1400 ASTContext &Context = D->getASTContext();
1401 if (!Context.getLangOpts().CPlusPlus)
1402 return LinkageInfo::none();
1403
1404 const Decl *OuterD = getOutermostFuncOrBlockContext(D);
1405 if (!OuterD || OuterD->isInvalidDecl())
1406 return LinkageInfo::none();
1407
1408 LinkageInfo LV;
1409 if (const auto *BD = dyn_cast<BlockDecl>(OuterD)) {
1410 if (!BD->getBlockManglingNumber())
1411 return LinkageInfo::none();
1412
1413 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
1414 BD->getBlockManglingContextDecl(), computation);
1415 } else {
1416 const auto *FD = cast<FunctionDecl>(OuterD);
1417 if (!FD->isInlined() &&
1418 !isTemplateInstantiation(FD->getTemplateSpecializationKind()))
1419 return LinkageInfo::none();
1420
1421 // If a function is hidden by -fvisibility-inlines-hidden option and
1422 // is not explicitly attributed as a hidden function,
1423 // we should not make static local variables in the function hidden.
1424 LV = getLVForDecl(FD, computation);
1425 if (isa<VarDecl>(D) && useInlineVisibilityHidden(FD) &&
1426 !LV.isVisibilityExplicit() &&
1427 !Context.getLangOpts().VisibilityInlinesHiddenStaticLocalVar) {
1428 assert(cast<VarDecl>(D)->isStaticLocal());
1429 // If this was an implicitly hidden inline method, check again for
1430 // explicit visibility on the parent class, and use that for static locals
1431 // if present.
1432 if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
1433 LV = getLVForDecl(MD->getParent(), computation);
1434 if (!LV.isVisibilityExplicit()) {
1435 Visibility globalVisibility =
1436 computation.isValueVisibility()
1437 ? Context.getLangOpts().getValueVisibilityMode()
1438 : Context.getLangOpts().getTypeVisibilityMode();
1439 return LinkageInfo(Linkage::VisibleNone, globalVisibility,
1440 /*visibilityExplicit=*/false);
1441 }
1442 }
1443 }
1445 return LinkageInfo::none();
1448}
1449
1451 LVComputationKind computation,
1452 bool IgnoreVarTypeLinkage) {
1453 // Internal_linkage attribute overrides other considerations.
1454 if (D->hasAttr<InternalLinkageAttr>())
1455 return LinkageInfo::internal();
1456
1457 // Objective-C: treat all Objective-C declarations as having external
1458 // linkage.
1459 switch (D->getKind()) {
1460 default:
1461 break;
1462
1463 // Per C++ [basic.link]p2, only the names of objects, references,
1464 // functions, types, templates, namespaces, and values ever have linkage.
1465 //
1466 // Note that the name of a typedef, namespace alias, using declaration,
1467 // and so on are not the name of the corresponding type, namespace, or
1468 // declaration, so they do *not* have linkage.
1469 case Decl::ImplicitParam:
1470 case Decl::Label:
1471 case Decl::NamespaceAlias:
1472 case Decl::ParmVar:
1473 case Decl::Using:
1474 case Decl::UsingEnum:
1475 case Decl::UsingShadow:
1476 case Decl::UsingDirective:
1477 return LinkageInfo::none();
1478
1479 case Decl::EnumConstant:
1480 // C++ [basic.link]p4: an enumerator has the linkage of its enumeration.
1481 if (D->getASTContext().getLangOpts().CPlusPlus)
1482 return getLVForDecl(cast<EnumDecl>(D->getDeclContext()), computation);
1484
1485 case Decl::Typedef:
1486 case Decl::TypeAlias:
1487 // A typedef declaration has linkage if it gives a type a name for
1488 // linkage purposes.
1489 if (!cast<TypedefNameDecl>(D)
1490 ->getAnonDeclWithTypedefName(/*AnyRedecl*/true))
1491 return LinkageInfo::none();
1492 break;
1493
1494 case Decl::TemplateTemplateParm: // count these as external
1495 case Decl::NonTypeTemplateParm:
1496 case Decl::ObjCAtDefsField:
1497 case Decl::ObjCCategory:
1498 case Decl::ObjCCategoryImpl:
1499 case Decl::ObjCCompatibleAlias:
1500 case Decl::ObjCImplementation:
1501 case Decl::ObjCMethod:
1502 case Decl::ObjCProperty:
1503 case Decl::ObjCPropertyImpl:
1504 case Decl::ObjCProtocol:
1505 return getExternalLinkageFor(D);
1506
1507 case Decl::CXXRecord: {
1508 const auto *Record = cast<CXXRecordDecl>(D);
1509 if (Record->isLambda()) {
1510 if (Record->hasKnownLambdaInternalLinkage() ||
1511 !Record->getLambdaManglingNumber()) {
1512 // This lambda has no mangling number, so it's internal.
1513 return LinkageInfo::internal();
1514 }
1515
1516 return getLVForClosure(
1517 Record->getDeclContext()->getRedeclContext(),
1518 Record->getLambdaContextDecl(), computation);
1519 }
1520
1521 break;
1522 }
1523
1524 case Decl::TemplateParamObject: {
1525 // The template parameter object can be referenced from anywhere its type
1526 // and value can be referenced.
1527 auto *TPO = cast<TemplateParamObjectDecl>(D);
1528 LinkageInfo LV = getLVForType(*TPO->getType(), computation);
1529 LV.merge(getLVForValue(TPO->getValue(), computation));
1530 return LV;
1531 }
1532 }
1533
1534 // Handle linkage for namespace-scope names.
1536 return getLVForNamespaceScopeDecl(D, computation, IgnoreVarTypeLinkage);
1537
1538 // C++ [basic.link]p5:
1539 // In addition, a member function, static data member, a named
1540 // class or enumeration of class scope, or an unnamed class or
1541 // enumeration defined in a class-scope typedef declaration such
1542 // that the class or enumeration has the typedef name for linkage
1543 // purposes (7.1.3), has external linkage if the name of the class
1544 // has external linkage.
1545 if (D->getDeclContext()->isRecord())
1546 return getLVForClassMember(D, computation, IgnoreVarTypeLinkage);
1547
1548 // C++ [basic.link]p6:
1549 // The name of a function declared in block scope and the name of
1550 // an object declared by a block scope extern declaration have
1551 // linkage. If there is a visible declaration of an entity with
1552 // linkage having the same name and type, ignoring entities
1553 // declared outside the innermost enclosing namespace scope, the
1554 // block scope declaration declares that same entity and receives
1555 // the linkage of the previous declaration. If there is more than
1556 // one such matching entity, the program is ill-formed. Otherwise,
1557 // if no matching entity is found, the block scope entity receives
1558 // external linkage.
1560 return getLVForLocalDecl(D, computation);
1561
1562 // C++ [basic.link]p6:
1563 // Names not covered by these rules have no linkage.
1564 return LinkageInfo::none();
1565}
1566
1567/// getLVForDecl - Get the linkage and visibility for the given declaration.
1569 LVComputationKind computation) {
1570 // Internal_linkage attribute overrides other considerations.
1571 if (D->hasAttr<InternalLinkageAttr>())
1572 return LinkageInfo::internal();
1573
1574 if (computation.IgnoreAllVisibility && D->hasCachedLinkage())
1576
1577 if (std::optional<LinkageInfo> LI = lookup(D, computation))
1578 return *LI;
1579
1580 LinkageInfo LV = computeLVForDecl(D, computation);
1581 if (D->hasCachedLinkage())
1582 assert(D->getCachedLinkage() == LV.getLinkage());
1583
1585 cache(D, computation, LV);
1586
1587#ifndef NDEBUG
1588 // In C (because of gnu inline) and in c++ with microsoft extensions an
1589 // static can follow an extern, so we can have two decls with different
1590 // linkages.
1591 const LangOptions &Opts = D->getASTContext().getLangOpts();
1592 if (!Opts.CPlusPlus || Opts.MicrosoftExt)
1593 return LV;
1594
1595 // We have just computed the linkage for this decl. By induction we know
1596 // that all other computed linkages match, check that the one we just
1597 // computed also does.
1598 NamedDecl *Old = nullptr;
1599 for (auto *I : D->redecls()) {
1600 auto *T = cast<NamedDecl>(I);
1601 if (T == D)
1602 continue;
1603 if (!T->isInvalidDecl() && T->hasCachedLinkage()) {
1604 Old = T;
1605 break;
1606 }
1607 }
1608 assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage());
1609#endif
1610
1611 return LV;
1612}
1613
1618 LVComputationKind CK(EK);
1619 return getLVForDecl(D, D->getASTContext().getLangOpts().IgnoreXCOFFVisibility
1620 ? CK.forLinkageOnly()
1621 : CK);
1622}
1623
1625 if (isa<NamespaceDecl>(this))
1626 // Namespaces never have module linkage. It is the entities within them
1627 // that [may] do.
1628 return nullptr;
1629
1630 Module *M = getOwningModule();
1631 if (!M)
1632 return nullptr;
1633
1634 switch (M->Kind) {
1636 // Module map modules have no special linkage semantics.
1637 return nullptr;
1638
1643 return M;
1644
1648 // The global module shouldn't change the linkage.
1649 return nullptr;
1650
1652 // The private module fragment is part of its containing module for linkage
1653 // purposes.
1654 return M->Parent;
1655 }
1656
1657 llvm_unreachable("unknown module kind");
1658}
1659
1660void NamedDecl::printName(raw_ostream &OS, const PrintingPolicy &Policy) const {
1661 Name.print(OS, Policy);
1662}
1663
1664void NamedDecl::printName(raw_ostream &OS) const {
1665 printName(OS, getASTContext().getPrintingPolicy());
1666}
1667
1669 std::string QualName;
1670 llvm::raw_string_ostream OS(QualName);
1671 printQualifiedName(OS, getASTContext().getPrintingPolicy());
1672 return QualName;
1673}
1674
1675void NamedDecl::printQualifiedName(raw_ostream &OS) const {
1676 printQualifiedName(OS, getASTContext().getPrintingPolicy());
1677}
1678
1680 const PrintingPolicy &P) const {
1681 if (getDeclContext()->isFunctionOrMethod()) {
1682 // We do not print '(anonymous)' for function parameters without name.
1683 printName(OS, P);
1684 return;
1685 }
1687 if (getDeclName())
1688 OS << *this;
1689 else {
1690 // Give the printName override a chance to pick a different name before we
1691 // fall back to "(anonymous)".
1692 SmallString<64> NameBuffer;
1693 llvm::raw_svector_ostream NameOS(NameBuffer);
1694 printName(NameOS, P);
1695 if (NameBuffer.empty())
1696 OS << "(anonymous)";
1697 else
1698 OS << NameBuffer;
1699 }
1700}
1701
1702void NamedDecl::printNestedNameSpecifier(raw_ostream &OS) const {
1703 printNestedNameSpecifier(OS, getASTContext().getPrintingPolicy());
1704}
1705
1707 const PrintingPolicy &P) const {
1708 const DeclContext *Ctx = getDeclContext();
1709
1710 // For ObjC methods and properties, look through categories and use the
1711 // interface as context.
1712 if (auto *MD = dyn_cast<ObjCMethodDecl>(this)) {
1713 if (auto *ID = MD->getClassInterface())
1714 Ctx = ID;
1715 } else if (auto *PD = dyn_cast<ObjCPropertyDecl>(this)) {
1716 if (auto *MD = PD->getGetterMethodDecl())
1717 if (auto *ID = MD->getClassInterface())
1718 Ctx = ID;
1719 } else if (auto *ID = dyn_cast<ObjCIvarDecl>(this)) {
1720 if (auto *CI = ID->getContainingInterface())
1721 Ctx = CI;
1722 }
1723
1724 if (Ctx->isFunctionOrMethod())
1725 return;
1726
1727 using ContextsTy = SmallVector<const DeclContext *, 8>;
1728 ContextsTy Contexts;
1729
1730 // Collect named contexts.
1731 DeclarationName NameInScope = getDeclName();
1732 for (; Ctx; Ctx = Ctx->getParent()) {
1733 // Suppress anonymous namespace if requested.
1734 if (P.SuppressUnwrittenScope && isa<NamespaceDecl>(Ctx) &&
1735 cast<NamespaceDecl>(Ctx)->isAnonymousNamespace())
1736 continue;
1737
1738 // Suppress inline namespace if it doesn't make the result ambiguous.
1739 if (Ctx->isInlineNamespace() && NameInScope) {
1740 if (P.SuppressInlineNamespace ==
1742 (P.SuppressInlineNamespace ==
1744 cast<NamespaceDecl>(Ctx)->isRedundantInlineQualifierFor(
1745 NameInScope))) {
1746 continue;
1747 }
1748 }
1749
1750 // Skip non-named contexts such as linkage specifications and ExportDecls.
1751 const NamedDecl *ND = dyn_cast<NamedDecl>(Ctx);
1752 if (!ND)
1753 continue;
1754
1755 Contexts.push_back(Ctx);
1756 NameInScope = ND->getDeclName();
1757 }
1758
1759 for (const DeclContext *DC : llvm::reverse(Contexts)) {
1760 if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1761 OS << Spec->getName();
1762 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1764 OS, TemplateArgs.asArray(), P,
1765 Spec->getSpecializedTemplate()->getTemplateParameters());
1766 } else if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
1767 if (ND->isAnonymousNamespace()) {
1768 OS << (P.MSVCFormatting ? "`anonymous namespace\'"
1769 : "(anonymous namespace)");
1770 }
1771 else
1772 OS << *ND;
1773 } else if (const auto *RD = dyn_cast<RecordDecl>(DC)) {
1774 if (!RD->getIdentifier())
1775 OS << "(anonymous " << RD->getKindName() << ')';
1776 else
1777 OS << *RD;
1778 } else if (const auto *FD = dyn_cast<FunctionDecl>(DC)) {
1779 const FunctionProtoType *FT = nullptr;
1780 if (FD->hasWrittenPrototype())
1781 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>());
1782
1783 OS << *FD << '(';
1784 if (FT) {
1785 unsigned NumParams = FD->getNumParams();
1786 for (unsigned i = 0; i < NumParams; ++i) {
1787 if (i)
1788 OS << ", ";
1789 OS << FD->getParamDecl(i)->getType().stream(P);
1790 }
1791
1792 if (FT->isVariadic()) {
1793 if (NumParams > 0)
1794 OS << ", ";
1795 OS << "...";
1796 }
1797 }
1798 OS << ')';
1799 } else if (const auto *ED = dyn_cast<EnumDecl>(DC)) {
1800 // C++ [dcl.enum]p10: Each enum-name and each unscoped
1801 // enumerator is declared in the scope that immediately contains
1802 // the enum-specifier. Each scoped enumerator is declared in the
1803 // scope of the enumeration.
1804 // For the case of unscoped enumerator, do not include in the qualified
1805 // name any information about its enum enclosing scope, as its visibility
1806 // is global.
1807 if (ED->isScoped())
1808 OS << *ED;
1809 else
1810 continue;
1811 } else {
1812 OS << *cast<NamedDecl>(DC);
1813 }
1814 OS << "::";
1815 }
1816}
1817
1819 const PrintingPolicy &Policy,
1820 bool Qualified) const {
1821 if (Qualified)
1822 printQualifiedName(OS, Policy);
1823 else
1824 printName(OS, Policy);
1825}
1826
1827template<typename T> static bool isRedeclarableImpl(Redeclarable<T> *) {
1828 return true;
1829}
1830static bool isRedeclarableImpl(...) { return false; }
1832 switch (K) {
1833#define DECL(Type, Base) \
1834 case Decl::Type: \
1835 return isRedeclarableImpl((Type##Decl *)nullptr);
1836#define ABSTRACT_DECL(DECL)
1837#include "clang/AST/DeclNodes.inc"
1838 }
1839 llvm_unreachable("unknown decl kind");
1840}
1841
1843 bool IsKnownNewer) const {
1844 assert(getDeclName() == OldD->getDeclName() && "Declaration name mismatch");
1845
1846 // Never replace one imported declaration with another; we need both results
1847 // when re-exporting.
1848 if (OldD->isFromASTFile() && isFromASTFile())
1849 return false;
1850
1851 // A kind mismatch implies that the declaration is not replaced.
1852 if (OldD->getKind() != getKind())
1853 return false;
1854
1855 // For method declarations, we never replace. (Why?)
1856 if (isa<ObjCMethodDecl>(this))
1857 return false;
1858
1859 // For parameters, pick the newer one. This is either an error or (in
1860 // Objective-C) permitted as an extension.
1861 if (isa<ParmVarDecl>(this))
1862 return true;
1863
1864 // Inline namespaces can give us two declarations with the same
1865 // name and kind in the same scope but different contexts; we should
1866 // keep both declarations in this case.
1867 if (!this->getDeclContext()->getRedeclContext()->Equals(
1868 OldD->getDeclContext()->getRedeclContext()))
1869 return false;
1870
1871 // Using declarations can be replaced if they import the same name from the
1872 // same context.
1873 if (const auto *UD = dyn_cast<UsingDecl>(this)) {
1874 ASTContext &Context = getASTContext();
1875 return Context.getCanonicalNestedNameSpecifier(UD->getQualifier()) ==
1877 cast<UsingDecl>(OldD)->getQualifier());
1878 }
1879 if (const auto *UUVD = dyn_cast<UnresolvedUsingValueDecl>(this)) {
1880 ASTContext &Context = getASTContext();
1881 return Context.getCanonicalNestedNameSpecifier(UUVD->getQualifier()) ==
1883 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1884 }
1885
1886 if (isRedeclarable(getKind())) {
1887 if (getCanonicalDecl() != OldD->getCanonicalDecl())
1888 return false;
1889
1890 if (IsKnownNewer)
1891 return true;
1892
1893 // Check whether this is actually newer than OldD. We want to keep the
1894 // newer declaration. This loop will usually only iterate once, because
1895 // OldD is usually the previous declaration.
1896 for (const auto *D : redecls()) {
1897 if (D == OldD)
1898 break;
1899
1900 // If we reach the canonical declaration, then OldD is not actually older
1901 // than this one.
1902 //
1903 // FIXME: In this case, we should not add this decl to the lookup table.
1904 if (D->isCanonicalDecl())
1905 return false;
1906 }
1907
1908 // It's a newer declaration of the same kind of declaration in the same
1909 // scope: we want this decl instead of the existing one.
1910 return true;
1911 }
1912
1913 // In all other cases, we need to keep both declarations in case they have
1914 // different visibility. Any attempt to use the name will result in an
1915 // ambiguity if more than one is visible.
1916 return false;
1917}
1918
1920 switch (getFormalLinkage()) {
1921 case Linkage::Invalid:
1922 llvm_unreachable("Linkage hasn't been computed!");
1923 case Linkage::None:
1924 return false;
1925 case Linkage::Internal:
1926 return true;
1929 llvm_unreachable("Non-formal linkage is not allowed here!");
1930 case Linkage::Module:
1931 case Linkage::External:
1932 return true;
1933 }
1934 llvm_unreachable("Unhandled Linkage enum");
1935}
1936
1937NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
1938 NamedDecl *ND = this;
1939 if (auto *UD = dyn_cast<UsingShadowDecl>(ND))
1940 ND = UD->getTargetDecl();
1941
1942 if (auto *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1943 return AD->getClassInterface();
1944
1945 if (auto *AD = dyn_cast<NamespaceAliasDecl>(ND))
1946 return AD->getNamespace();
1947
1948 return ND;
1949}
1950
1952 if (!isCXXClassMember())
1953 return false;
1954
1955 const NamedDecl *D = this;
1956 if (isa<UsingShadowDecl>(D))
1957 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1958
1959 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
1960 return true;
1961 if (const auto *MD = dyn_cast_if_present<CXXMethodDecl>(D->getAsFunction()))
1962 return MD->isInstance();
1963 return false;
1964}
1965
1966//===----------------------------------------------------------------------===//
1967// DeclaratorDecl Implementation
1968//===----------------------------------------------------------------------===//
1969
1970template <typename DeclT>
1972 if (decl->getNumTemplateParameterLists() > 0)
1973 return decl->getTemplateParameterList(0)->getTemplateLoc();
1974 return decl->getInnerLocStart();
1975}
1976
1979 if (TSI) return TSI->getTypeLoc().getBeginLoc();
1980 return SourceLocation();
1981}
1982
1985 if (TSI) return TSI->getTypeLoc().getEndLoc();
1986 return SourceLocation();
1987}
1988
1990 if (QualifierLoc) {
1991 // Make sure the extended decl info is allocated.
1992 if (!hasExtInfo()) {
1993 // Save (non-extended) type source info pointer.
1994 auto *savedTInfo = cast<TypeSourceInfo *>(DeclInfo);
1995 // Allocate external info struct.
1996 DeclInfo = new (getASTContext()) ExtInfo;
1997 // Restore savedTInfo into (extended) decl info.
1998 getExtInfo()->TInfo = savedTInfo;
1999 }
2000 // Set qualifier info.
2001 getExtInfo()->QualifierLoc = QualifierLoc;
2002 } else if (hasExtInfo()) {
2003 // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
2004 getExtInfo()->QualifierLoc = QualifierLoc;
2005 }
2006}
2007
2009 assert(TrailingRequiresClause);
2010 // Make sure the extended decl info is allocated.
2011 if (!hasExtInfo()) {
2012 // Save (non-extended) type source info pointer.
2013 auto *savedTInfo = cast<TypeSourceInfo *>(DeclInfo);
2014 // Allocate external info struct.
2015 DeclInfo = new (getASTContext()) ExtInfo;
2016 // Restore savedTInfo into (extended) decl info.
2017 getExtInfo()->TInfo = savedTInfo;
2018 }
2019 // Set requires clause info.
2020 getExtInfo()->TrailingRequiresClause = TrailingRequiresClause;
2021}
2022
2025 assert(!TPLists.empty());
2026 // Make sure the extended decl info is allocated.
2027 if (!hasExtInfo()) {
2028 // Save (non-extended) type source info pointer.
2029 auto *savedTInfo = cast<TypeSourceInfo *>(DeclInfo);
2030 // Allocate external info struct.
2031 DeclInfo = new (getASTContext()) ExtInfo;
2032 // Restore savedTInfo into (extended) decl info.
2033 getExtInfo()->TInfo = savedTInfo;
2034 }
2035 // Set the template parameter lists info.
2036 getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
2037}
2038
2040 return getTemplateOrInnerLocStart(this);
2041}
2042
2043// Helper function: returns true if QT is or contains a type
2044// having a postfix component.
2045static bool typeIsPostfix(QualType QT) {
2046 while (true) {
2047 const Type* T = QT.getTypePtr();
2048 switch (T->getTypeClass()) {
2049 default:
2050 return false;
2051 case Type::Pointer:
2052 QT = cast<PointerType>(T)->getPointeeType();
2053 break;
2054 case Type::BlockPointer:
2055 QT = cast<BlockPointerType>(T)->getPointeeType();
2056 break;
2057 case Type::MemberPointer:
2058 QT = cast<MemberPointerType>(T)->getPointeeType();
2059 break;
2060 case Type::LValueReference:
2061 case Type::RValueReference:
2062 QT = cast<ReferenceType>(T)->getPointeeType();
2063 break;
2064 case Type::PackExpansion:
2065 QT = cast<PackExpansionType>(T)->getPattern();
2066 break;
2067 case Type::Paren:
2068 case Type::ConstantArray:
2069 case Type::DependentSizedArray:
2070 case Type::IncompleteArray:
2071 case Type::VariableArray:
2072 case Type::FunctionProto:
2073 case Type::FunctionNoProto:
2074 return true;
2075 }
2076 }
2077}
2078
2080 SourceLocation RangeEnd = getLocation();
2081 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
2082 // If the declaration has no name or the type extends past the name take the
2083 // end location of the type.
2084 if (!getDeclName() || typeIsPostfix(TInfo->getType()))
2085 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
2086 }
2087 return SourceRange(getOuterLocStart(), RangeEnd);
2088}
2089
2092 // Free previous template parameters (if any).
2093 if (NumTemplParamLists > 0) {
2094 Context.Deallocate(TemplParamLists);
2095 TemplParamLists = nullptr;
2097 }
2098 // Set info on matched template parameter lists (if any).
2099 if (!TPLists.empty()) {
2100 TemplParamLists = new (Context) TemplateParameterList *[TPLists.size()];
2101 NumTemplParamLists = TPLists.size();
2102 std::copy(TPLists.begin(), TPLists.end(), TemplParamLists);
2103 }
2104}
2105
2106//===----------------------------------------------------------------------===//
2107// VarDecl Implementation
2108//===----------------------------------------------------------------------===//
2109
2111 switch (SC) {
2112 case SC_None: break;
2113 case SC_Auto: return "auto";
2114 case SC_Extern: return "extern";
2115 case SC_PrivateExtern: return "__private_extern__";
2116 case SC_Register: return "register";
2117 case SC_Static: return "static";
2118 }
2119
2120 llvm_unreachable("Invalid storage class");
2121}
2122
2124 SourceLocation StartLoc, SourceLocation IdLoc,
2125 const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
2126 StorageClass SC)
2127 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
2129 static_assert(sizeof(VarDeclBitfields) <= sizeof(unsigned),
2130 "VarDeclBitfields too large!");
2131 static_assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned),
2132 "ParmVarDeclBitfields too large!");
2133 static_assert(sizeof(NonParmVarDeclBitfields) <= sizeof(unsigned),
2134 "NonParmVarDeclBitfields too large!");
2135 AllBits = 0;
2136 VarDeclBits.SClass = SC;
2137 // Everything else is implicitly initialized to false.
2138}
2139
2141 SourceLocation IdL, const IdentifierInfo *Id,
2143 return new (C, DC) VarDecl(Var, C, DC, StartL, IdL, Id, T, TInfo, S);
2144}
2145
2147 return new (C, ID)
2148 VarDecl(Var, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
2149 QualType(), nullptr, SC_None);
2150}
2151
2153 assert(isLegalForVariable(SC));
2154 VarDeclBits.SClass = SC;
2155}
2156
2158 switch (VarDeclBits.TSCSpec) {
2159 case TSCS_unspecified:
2160 if (!hasAttr<ThreadAttr>() &&
2161 !(getASTContext().getLangOpts().OpenMPUseTLS &&
2162 getASTContext().getTargetInfo().isTLSSupported() &&
2163 hasAttr<OMPThreadPrivateDeclAttr>()))
2164 return TLS_None;
2165 return ((getASTContext().getLangOpts().isCompatibleWithMSVC(
2167 hasAttr<OMPThreadPrivateDeclAttr>())
2168 ? TLS_Dynamic
2169 : TLS_Static;
2170 case TSCS___thread: // Fall through.
2171 case TSCS__Thread_local:
2172 return TLS_Static;
2173 case TSCS_thread_local:
2174 return TLS_Dynamic;
2175 }
2176 llvm_unreachable("Unknown thread storage class specifier!");
2177}
2178
2180 if (const Expr *Init = getInit()) {
2181 SourceLocation InitEnd = Init->getEndLoc();
2182 // If Init is implicit, ignore its source range and fallback on
2183 // DeclaratorDecl::getSourceRange() to handle postfix elements.
2184 if (InitEnd.isValid() && InitEnd != getLocation())
2185 return SourceRange(getOuterLocStart(), InitEnd);
2186 }
2188}
2189
2190template<typename T>
2192 // C++ [dcl.link]p1: All function types, function names with external linkage,
2193 // and variable names with external linkage have a language linkage.
2194 if (!D.hasExternalFormalLinkage())
2195 return NoLanguageLinkage;
2196
2197 // Language linkage is a C++ concept, but saying that everything else in C has
2198 // C language linkage fits the implementation nicely.
2199 if (!D.getASTContext().getLangOpts().CPlusPlus)
2200 return CLanguageLinkage;
2201
2202 // C++ [dcl.link]p4: A C language linkage is ignored in determining the
2203 // language linkage of the names of class members and the function type of
2204 // class member functions.
2205 const DeclContext *DC = D.getDeclContext();
2206 if (DC->isRecord())
2207 return CXXLanguageLinkage;
2208
2209 // If the first decl is in an extern "C" context, any other redeclaration
2210 // will have C language linkage. If the first one is not in an extern "C"
2211 // context, we would have reported an error for any other decl being in one.
2213 return CLanguageLinkage;
2214 return CXXLanguageLinkage;
2215}
2216
2217template<typename T>
2218static bool isDeclExternC(const T &D) {
2219 // Since the context is ignored for class members, they can only have C++
2220 // language linkage or no language linkage.
2221 const DeclContext *DC = D.getDeclContext();
2222 if (DC->isRecord()) {
2223 assert(D.getASTContext().getLangOpts().CPlusPlus);
2224 return false;
2225 }
2226
2227 return D.getLanguageLinkage() == CLanguageLinkage;
2228}
2229
2231 return getDeclLanguageLinkage(*this);
2232}
2233
2235 return isDeclExternC(*this);
2236}
2237
2240}
2241
2244}
2245
2247
2251 return DeclarationOnly;
2252
2253 // C++ [basic.def]p2:
2254 // A declaration is a definition unless [...] it contains the 'extern'
2255 // specifier or a linkage-specification and neither an initializer [...],
2256 // it declares a non-inline static data member in a class declaration [...],
2257 // it declares a static data member outside a class definition and the variable
2258 // was defined within the class with the constexpr specifier [...],
2259 // C++1y [temp.expl.spec]p15:
2260 // An explicit specialization of a static data member or an explicit
2261 // specialization of a static data member template is a definition if the
2262 // declaration includes an initializer; otherwise, it is a declaration.
2263 //
2264 // FIXME: How do you declare (but not define) a partial specialization of
2265 // a static data member template outside the containing class?
2266 if (isStaticDataMember()) {
2267 if (isOutOfLine() &&
2268 !(getCanonicalDecl()->isInline() &&
2270 (hasInit() ||
2271 // If the first declaration is out-of-line, this may be an
2272 // instantiation of an out-of-line partial specialization of a variable
2273 // template for which we have not yet instantiated the initializer.
2278 isa<VarTemplatePartialSpecializationDecl>(this)))
2279 return Definition;
2280 if (!isOutOfLine() && isInline())
2281 return Definition;
2282 return DeclarationOnly;
2283 }
2284 // C99 6.7p5:
2285 // A definition of an identifier is a declaration for that identifier that
2286 // [...] causes storage to be reserved for that object.
2287 // Note: that applies for all non-file-scope objects.
2288 // C99 6.9.2p1:
2289 // If the declaration of an identifier for an object has file scope and an
2290 // initializer, the declaration is an external definition for the identifier
2291 if (hasInit())
2292 return Definition;
2293
2294 if (hasDefiningAttr())
2295 return Definition;
2296
2297 if (const auto *SAA = getAttr<SelectAnyAttr>())
2298 if (!SAA->isInherited())
2299 return Definition;
2300
2301 // A variable template specialization (other than a static data member
2302 // template or an explicit specialization) is a declaration until we
2303 // instantiate its initializer.
2304 if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(this)) {
2305 if (VTSD->getTemplateSpecializationKind() != TSK_ExplicitSpecialization &&
2306 !isa<VarTemplatePartialSpecializationDecl>(VTSD) &&
2307 !VTSD->IsCompleteDefinition)
2308 return DeclarationOnly;
2309 }
2310
2311 if (hasExternalStorage())
2312 return DeclarationOnly;
2313
2314 // [dcl.link] p7:
2315 // A declaration directly contained in a linkage-specification is treated
2316 // as if it contains the extern specifier for the purpose of determining
2317 // the linkage of the declared name and whether it is a definition.
2318 if (isSingleLineLanguageLinkage(*this))
2319 return DeclarationOnly;
2320
2321 // C99 6.9.2p2:
2322 // A declaration of an object that has file scope without an initializer,
2323 // and without a storage class specifier or the scs 'static', constitutes
2324 // a tentative definition.
2325 // No such thing in C++.
2326 if (!C.getLangOpts().CPlusPlus && isFileVarDecl())
2327 return TentativeDefinition;
2328
2329 // What's left is (in C, block-scope) declarations without initializers or
2330 // external storage. These are definitions.
2331 return Definition;
2332}
2333
2337 return nullptr;
2338
2339 VarDecl *LastTentative = nullptr;
2340
2341 // Loop through the declaration chain, starting with the most recent.
2343 Decl = Decl->getPreviousDecl()) {
2344 Kind = Decl->isThisDeclarationADefinition();
2345 if (Kind == Definition)
2346 return nullptr;
2347 // Record the first (most recent) TentativeDefinition that is encountered.
2348 if (Kind == TentativeDefinition && !LastTentative)
2349 LastTentative = Decl;
2350 }
2351
2352 return LastTentative;
2353}
2354
2357 for (auto *I : First->redecls()) {
2358 if (I->isThisDeclarationADefinition(C) == Definition)
2359 return I;
2360 }
2361 return nullptr;
2362}
2363
2366
2367 const VarDecl *First = getFirstDecl();
2368 for (auto *I : First->redecls()) {
2369 Kind = std::max(Kind, I->isThisDeclarationADefinition(C));
2370 if (Kind == Definition)
2371 break;
2372 }
2373
2374 return Kind;
2375}
2376
2378 for (auto *I : redecls()) {
2379 if (auto Expr = I->getInit()) {
2380 D = I;
2381 return Expr;
2382 }
2383 }
2384 return nullptr;
2385}
2386
2387bool VarDecl::hasInit() const {
2388 if (auto *P = dyn_cast<ParmVarDecl>(this))
2389 if (P->hasUnparsedDefaultArg() || P->hasUninstantiatedDefaultArg())
2390 return false;
2391
2392 if (auto *Eval = getEvaluatedStmt())
2393 return Eval->Value.isValid();
2394
2395 return !Init.isNull();
2396}
2397
2399 if (!hasInit())
2400 return nullptr;
2401
2402 if (auto *S = dyn_cast<Stmt *>(Init))
2403 return cast<Expr>(S);
2404
2405 auto *Eval = getEvaluatedStmt();
2406
2407 return cast<Expr>(Eval->Value.get(
2408 Eval->Value.isOffset() ? getASTContext().getExternalSource() : nullptr));
2409}
2410
2412 if (auto *ES = Init.dyn_cast<EvaluatedStmt *>())
2413 return ES->Value.getAddressOfPointer(getASTContext().getExternalSource());
2414
2415 return Init.getAddrOfPtr1();
2416}
2417
2419 VarDecl *Def = nullptr;
2420 for (auto *I : redecls()) {
2421 if (I->hasInit())
2422 return I;
2423
2424 if (I->isThisDeclarationADefinition()) {
2425 if (isStaticDataMember())
2426 return I;
2427 Def = I;
2428 }
2429 }
2430 return Def;
2431}
2432
2434 if (Decl::isOutOfLine())
2435 return true;
2436
2437 if (!isStaticDataMember())
2438 return false;
2439
2440 // If this static data member was instantiated from a static data member of
2441 // a class template, check whether that static data member was defined
2442 // out-of-line.
2444 return VD->isOutOfLine();
2445
2446 return false;
2447}
2448
2450 if (auto *Eval = dyn_cast_if_present<EvaluatedStmt *>(Init)) {
2451 Eval->~EvaluatedStmt();
2452 getASTContext().Deallocate(Eval);
2453 }
2454
2455 Init = I;
2456}
2457
2459 const LangOptions &Lang = C.getLangOpts();
2460
2461 // OpenCL permits const integral variables to be used in constant
2462 // expressions, like in C++98.
2463 if (!Lang.CPlusPlus && !Lang.OpenCL && !Lang.C23)
2464 return false;
2465
2466 // Function parameters are never usable in constant expressions.
2467 if (isa<ParmVarDecl>(this))
2468 return false;
2469
2470 // The values of weak variables are never usable in constant expressions.
2471 if (isWeak())
2472 return false;
2473
2474 // In C++11, any variable of reference type can be used in a constant
2475 // expression if it is initialized by a constant expression.
2476 if (Lang.CPlusPlus11 && getType()->isReferenceType())
2477 return true;
2478
2479 // Only const objects can be used in constant expressions in C++. C++98 does
2480 // not require the variable to be non-volatile, but we consider this to be a
2481 // defect.
2482 if (!getType().isConstant(C) || getType().isVolatileQualified())
2483 return false;
2484
2485 // In C++, but not in C, const, non-volatile variables of integral or
2486 // enumeration types can be used in constant expressions.
2487 if (getType()->isIntegralOrEnumerationType() && !Lang.C23)
2488 return true;
2489
2490 // C23 6.6p7: An identifier that is:
2491 // ...
2492 // - declared with storage-class specifier constexpr and has an object type,
2493 // is a named constant, ... such a named constant is a constant expression
2494 // with the type and value of the declared object.
2495 // Additionally, in C++11, non-volatile constexpr variables can be used in
2496 // constant expressions.
2497 return (Lang.CPlusPlus11 || Lang.C23) && isConstexpr();
2498}
2499
2501 // C++2a [expr.const]p3:
2502 // A variable is usable in constant expressions after its initializing
2503 // declaration is encountered...
2504 const VarDecl *DefVD = nullptr;
2505 const Expr *Init = getAnyInitializer(DefVD);
2506 if (!Init || Init->isValueDependent() || getType()->isDependentType())
2507 return false;
2508 // ... if it is a constexpr variable, or it is of reference type or of
2509 // const-qualified integral or enumeration type, ...
2510 if (!DefVD->mightBeUsableInConstantExpressions(Context))
2511 return false;
2512 // ... and its initializer is a constant initializer.
2513 if ((Context.getLangOpts().CPlusPlus || getLangOpts().C23) &&
2514 !DefVD->hasConstantInitialization())
2515 return false;
2516 // C++98 [expr.const]p1:
2517 // An integral constant-expression can involve only [...] const variables
2518 // or static data members of integral or enumeration types initialized with
2519 // [integer] constant expressions (dcl.init)
2520 if ((Context.getLangOpts().CPlusPlus || Context.getLangOpts().OpenCL) &&
2521 !Context.getLangOpts().CPlusPlus11 && !DefVD->hasICEInitializer(Context))
2522 return false;
2523 return true;
2524}
2525
2526/// Convert the initializer for this declaration to the elaborated EvaluatedStmt
2527/// form, which contains extra information on the evaluated value of the
2528/// initializer.
2530 auto *Eval = dyn_cast_if_present<EvaluatedStmt *>(Init);
2531 if (!Eval) {
2532 // Note: EvaluatedStmt contains an APValue, which usually holds
2533 // resources not allocated from the ASTContext. We need to do some
2534 // work to avoid leaking those, but we do so in VarDecl::evaluateValue
2535 // where we can detect whether there's anything to clean up or not.
2536 Eval = new (getASTContext()) EvaluatedStmt;
2537 Eval->Value = cast<Stmt *>(Init);
2538 Init = Eval;
2539 }
2540 return Eval;
2541}
2542
2544 return dyn_cast_if_present<EvaluatedStmt *>(Init);
2545}
2546
2549 return evaluateValueImpl(Notes, hasConstantInitialization());
2550}
2551
2552APValue *VarDecl::evaluateValueImpl(SmallVectorImpl<PartialDiagnosticAt> &Notes,
2553 bool IsConstantInitialization) const {
2555
2556 const auto *Init = getInit();
2557 assert(!Init->isValueDependent());
2558
2559 // We only produce notes indicating why an initializer is non-constant the
2560 // first time it is evaluated. FIXME: The notes won't always be emitted the
2561 // first time we try evaluation, so might not be produced at all.
2562 if (Eval->WasEvaluated)
2563 return Eval->Evaluated.isAbsent() ? nullptr : &Eval->Evaluated;
2564
2565 if (Eval->IsEvaluating) {
2566 // FIXME: Produce a diagnostic for self-initialization.
2567 return nullptr;
2568 }
2569
2570 Eval->IsEvaluating = true;
2571
2572 ASTContext &Ctx = getASTContext();
2573 bool Result = Init->EvaluateAsInitializer(Eval->Evaluated, Ctx, this, Notes,
2574 IsConstantInitialization);
2575
2576 // In C++, or in C23 if we're initialising a 'constexpr' variable, this isn't
2577 // a constant initializer if we produced notes. In that case, we can't keep
2578 // the result, because it may only be correct under the assumption that the
2579 // initializer is a constant context.
2580 if (IsConstantInitialization &&
2581 (Ctx.getLangOpts().CPlusPlus ||
2582 (isConstexpr() && Ctx.getLangOpts().C23)) &&
2583 !Notes.empty())
2584 Result = false;
2585
2586 // Ensure the computed APValue is cleaned up later if evaluation succeeded,
2587 // or that it's empty (so that there's nothing to clean up) if evaluation
2588 // failed.
2589 if (!Result)
2590 Eval->Evaluated = APValue();
2591 else if (Eval->Evaluated.needsCleanup())
2592 Ctx.addDestruction(&Eval->Evaluated);
2593
2594 Eval->IsEvaluating = false;
2595 Eval->WasEvaluated = true;
2596
2597 return Result ? &Eval->Evaluated : nullptr;
2598}
2599
2601 if (EvaluatedStmt *Eval = getEvaluatedStmt())
2602 if (Eval->WasEvaluated)
2603 return &Eval->Evaluated;
2604
2605 return nullptr;
2606}
2607
2608bool VarDecl::hasICEInitializer(const ASTContext &Context) const {
2609 const Expr *Init = getInit();
2610 assert(Init && "no initializer");
2611
2613 if (!Eval->CheckedForICEInit) {
2614 Eval->CheckedForICEInit = true;
2615 Eval->HasICEInit = Init->isIntegerConstantExpr(Context);
2616 }
2617 return Eval->HasICEInit;
2618}
2619
2621 // In C, all globals and constexpr variables should have constant
2622 // initialization. For constexpr variables in C check that initializer is a
2623 // constant initializer because they can be used in constant expressions.
2625 !isConstexpr())
2626 return true;
2627
2628 // In C++, it depends on whether the evaluation at the point of definition
2629 // was evaluatable as a constant initializer.
2630 if (EvaluatedStmt *Eval = getEvaluatedStmt())
2631 return Eval->HasConstantInitialization;
2632
2633 return false;
2634}
2635
2639 // If we ask for the value before we know whether we have a constant
2640 // initializer, we can compute the wrong value (for example, due to
2641 // std::is_constant_evaluated()).
2642 assert(!Eval->WasEvaluated &&
2643 "already evaluated var value before checking for constant init");
2644 assert((getASTContext().getLangOpts().CPlusPlus ||
2646 "only meaningful in C++/C23");
2647
2648 assert(!getInit()->isValueDependent());
2649
2650 // Evaluate the initializer to check whether it's a constant expression.
2652 evaluateValueImpl(Notes, true) && Notes.empty();
2653
2654 // If evaluation as a constant initializer failed, allow re-evaluation as a
2655 // non-constant initializer if we later find we want the value.
2656 if (!Eval->HasConstantInitialization)
2657 Eval->WasEvaluated = false;
2658
2659 return Eval->HasConstantInitialization;
2660}
2661
2663 return isa<PackExpansionType>(getType());
2664}
2665
2666template<typename DeclT>
2667static DeclT *getDefinitionOrSelf(DeclT *D) {
2668 assert(D);
2669 if (auto *Def = D->getDefinition())
2670 return Def;
2671 return D;
2672}
2673
2675 return hasAttr<BlocksAttr>() && NonParmVarDeclBits.EscapingByref;
2676}
2677
2679 return hasAttr<BlocksAttr>() && !NonParmVarDeclBits.EscapingByref;
2680}
2681
2683 QualType T = getType();
2684 return T->isDependentType() || T->isUndeducedType() ||
2685 llvm::any_of(specific_attrs<AlignedAttr>(), [](const AlignedAttr *AA) {
2686 return AA->isAlignmentDependent();
2687 });
2688}
2689
2691 const VarDecl *VD = this;
2692
2693 // If this is an instantiated member, walk back to the template from which
2694 // it was instantiated.
2696 if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
2698 while (auto *NewVD = VD->getInstantiatedFromStaticDataMember())
2699 VD = NewVD;
2700 }
2701 }
2702
2703 // If it's an instantiated variable template specialization, find the
2704 // template or partial specialization from which it was instantiated.
2705 if (auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2706 if (isTemplateInstantiation(VDTemplSpec->getTemplateSpecializationKind())) {
2707 auto From = VDTemplSpec->getInstantiatedFrom();
2708 if (auto *VTD = From.dyn_cast<VarTemplateDecl *>()) {
2709 while (!VTD->isMemberSpecialization()) {
2710 auto *NewVTD = VTD->getInstantiatedFromMemberTemplate();
2711 if (!NewVTD)
2712 break;
2713 VTD = NewVTD;
2714 }
2715 return getDefinitionOrSelf(VTD->getTemplatedDecl());
2716 }
2717 if (auto *VTPSD =
2718 From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
2719 while (!VTPSD->isMemberSpecialization()) {
2720 auto *NewVTPSD = VTPSD->getInstantiatedFromMember();
2721 if (!NewVTPSD)
2722 break;
2723 VTPSD = NewVTPSD;
2724 }
2725 return getDefinitionOrSelf<VarDecl>(VTPSD);
2726 }
2727 }
2728 }
2729
2730 // If this is the pattern of a variable template, find where it was
2731 // instantiated from. FIXME: Is this necessary?
2732 if (VarTemplateDecl *VarTemplate = VD->getDescribedVarTemplate()) {
2733 while (!VarTemplate->isMemberSpecialization()) {
2734 auto *NewVT = VarTemplate->getInstantiatedFromMemberTemplate();
2735 if (!NewVT)
2736 break;
2737 VarTemplate = NewVT;
2738 }
2739
2740 return getDefinitionOrSelf(VarTemplate->getTemplatedDecl());
2741 }
2742
2743 if (VD == this)
2744 return nullptr;
2745 return getDefinitionOrSelf(const_cast<VarDecl*>(VD));
2746}
2747
2750 return cast<VarDecl>(MSI->getInstantiatedFrom());
2751
2752 return nullptr;
2753}
2754
2756 if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2757 return Spec->getSpecializationKind();
2758
2760 return MSI->getTemplateSpecializationKind();
2761
2762 return TSK_Undeclared;
2763}
2764
2768 return MSI->getTemplateSpecializationKind();
2769
2770 if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2771 return Spec->getSpecializationKind();
2772
2773 return TSK_Undeclared;
2774}
2775
2777 if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2778 return Spec->getPointOfInstantiation();
2779
2781 return MSI->getPointOfInstantiation();
2782
2783 return SourceLocation();
2784}
2785
2787 return dyn_cast_if_present<VarTemplateDecl *>(
2788 getASTContext().getTemplateOrSpecializationInfo(this));
2789}
2790
2793}
2794
2796 const auto &LangOpts = getASTContext().getLangOpts();
2797 // In CUDA mode without relocatable device code, variables of form 'extern
2798 // __shared__ Foo foo[]' are pointers to the base of the GPU core's shared
2799 // memory pool. These are never undefined variables, even if they appear
2800 // inside of an anon namespace or static function.
2801 //
2802 // With CUDA relocatable device code enabled, these variables don't get
2803 // special handling; they're treated like regular extern variables.
2804 if (LangOpts.CUDA && !LangOpts.GPURelocatableDeviceCode &&
2805 hasExternalStorage() && hasAttr<CUDASharedAttr>() &&
2806 isa<IncompleteArrayType>(getType()))
2807 return true;
2808
2809 return hasDefinition();
2810}
2811
2812bool VarDecl::isNoDestroy(const ASTContext &Ctx) const {
2813 if (!hasGlobalStorage())
2814 return false;
2815 if (hasAttr<NoDestroyAttr>())
2816 return true;
2817 if (hasAttr<AlwaysDestroyAttr>())
2818 return false;
2819
2821 RSDKind K = Ctx.getLangOpts().getRegisterStaticDestructors();
2822 return K == RSDKind::None ||
2823 (K == RSDKind::ThreadLocal && getTLSKind() == TLS_None);
2824}
2825
2828 if (EvaluatedStmt *Eval = getEvaluatedStmt())
2829 if (Eval->HasConstantDestruction)
2830 return QualType::DK_none;
2831
2832 if (isNoDestroy(Ctx))
2833 return QualType::DK_none;
2834
2835 return getType().isDestructedType();
2836}
2837
2839 assert(hasInit() && "Expect initializer to check for flexible array init");
2840 auto *Ty = getType()->getAs<RecordType>();
2841 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2842 return false;
2843 auto *List = dyn_cast<InitListExpr>(getInit()->IgnoreParens());
2844 if (!List)
2845 return false;
2846 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2847 auto InitTy = Ctx.getAsConstantArrayType(FlexibleInit->getType());
2848 if (!InitTy)
2849 return false;
2850 return !InitTy->isZeroSize();
2851}
2852
2854 assert(hasInit() && "Expect initializer to check for flexible array init");
2855 auto *Ty = getType()->getAs<RecordType>();
2856 if (!Ty || !Ty->getDecl()->hasFlexibleArrayMember())
2857 return CharUnits::Zero();
2858 auto *List = dyn_cast<InitListExpr>(getInit()->IgnoreParens());
2859 if (!List || List->getNumInits() == 0)
2860 return CharUnits::Zero();
2861 const Expr *FlexibleInit = List->getInit(List->getNumInits() - 1);
2862 auto InitTy = Ctx.getAsConstantArrayType(FlexibleInit->getType());
2863 if (!InitTy)
2864 return CharUnits::Zero();
2865 CharUnits FlexibleArraySize = Ctx.getTypeSizeInChars(InitTy);
2866 const ASTRecordLayout &RL = Ctx.getASTRecordLayout(Ty->getDecl());
2867 CharUnits FlexibleArrayOffset =
2869 if (FlexibleArrayOffset + FlexibleArraySize < RL.getSize())
2870 return CharUnits::Zero();
2871 return FlexibleArrayOffset + FlexibleArraySize - RL.getSize();
2872}
2873
2875 if (isStaticDataMember())
2876 // FIXME: Remove ?
2877 // return getASTContext().getInstantiatedFromStaticDataMember(this);
2878 return dyn_cast_if_present<MemberSpecializationInfo *>(
2879 getASTContext().getTemplateOrSpecializationInfo(this));
2880 return nullptr;
2881}
2882
2884 SourceLocation PointOfInstantiation) {
2885 assert((isa<VarTemplateSpecializationDecl>(this) ||
2887 "not a variable or static data member template specialization");
2888
2890 dyn_cast<VarTemplateSpecializationDecl>(this)) {
2891 Spec->setSpecializationKind(TSK);
2892 if (TSK != TSK_ExplicitSpecialization &&
2893 PointOfInstantiation.isValid() &&
2894 Spec->getPointOfInstantiation().isInvalid()) {
2895 Spec->setPointOfInstantiation(PointOfInstantiation);
2897 L->InstantiationRequested(this);
2898 }
2900 MSI->setTemplateSpecializationKind(TSK);
2901 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
2902 MSI->getPointOfInstantiation().isInvalid()) {
2903 MSI->setPointOfInstantiation(PointOfInstantiation);
2905 L->InstantiationRequested(this);
2906 }
2907 }
2908}
2909
2910void
2913 assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() &&
2914 "Previous template or instantiation?");
2916}
2917
2918//===----------------------------------------------------------------------===//
2919// ParmVarDecl Implementation
2920//===----------------------------------------------------------------------===//
2921
2923 SourceLocation StartLoc, SourceLocation IdLoc,
2924 const IdentifierInfo *Id, QualType T,
2925 TypeSourceInfo *TInfo, StorageClass S,
2926 Expr *DefArg) {
2927 return new (C, DC) ParmVarDecl(ParmVar, C, DC, StartLoc, IdLoc, Id, T, TInfo,
2928 S, DefArg);
2929}
2930
2933 QualType T = TSI ? TSI->getType() : getType();
2934 if (const auto *DT = dyn_cast<DecayedType>(T))
2935 return DT->getOriginalType();
2936 return T;
2937}
2938
2940 return new (C, ID)
2941 ParmVarDecl(ParmVar, C, nullptr, SourceLocation(), SourceLocation(),
2942 nullptr, QualType(), nullptr, SC_None, nullptr);
2943}
2944
2946 if (!hasInheritedDefaultArg()) {
2947 SourceRange ArgRange = getDefaultArgRange();
2948 if (ArgRange.isValid())
2949 return SourceRange(getOuterLocStart(), ArgRange.getEnd());
2950 }
2951
2952 // DeclaratorDecl considers the range of postfix types as overlapping with the
2953 // declaration name, but this is not the case with parameters in ObjC methods.
2954 if (isa<ObjCMethodDecl>(getDeclContext()))
2956
2958}
2959
2961 // ns_consumed only affects code generation in ARC
2962 if (hasAttr<NSConsumedAttr>())
2963 return getASTContext().getLangOpts().ObjCAutoRefCount;
2964
2965 // FIXME: isParamDestroyedInCallee() should probably imply
2966 // isDestructedType()
2967 const auto *RT = getType()->getAs<RecordType>();
2968 if (RT && RT->getDecl()->isParamDestroyedInCallee() &&
2970 return true;
2971
2972 return false;
2973}
2974
2976 assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!");
2977 assert(!hasUninstantiatedDefaultArg() &&
2978 "Default argument is not yet instantiated!");
2979
2980 Expr *Arg = getInit();
2981 if (auto *E = dyn_cast_if_present<FullExpr>(Arg))
2982 return E->getSubExpr();
2983
2984 return Arg;
2985}
2986
2988 ParmVarDeclBits.DefaultArgKind = DAK_Normal;
2989 Init = defarg;
2990}
2991
2993 switch (ParmVarDeclBits.DefaultArgKind) {
2994 case DAK_None:
2995 case DAK_Unparsed:
2996 // Nothing we can do here.
2997 return SourceRange();
2998
2999 case DAK_Uninstantiated:
3001
3002 case DAK_Normal:
3003 if (const Expr *E = getInit())
3004 return E->getSourceRange();
3005
3006 // Missing an actual expression, may be invalid.
3007 return SourceRange();
3008 }
3009 llvm_unreachable("Invalid default argument kind.");
3010}
3011
3013 ParmVarDeclBits.DefaultArgKind = DAK_Uninstantiated;
3014 Init = arg;
3015}
3016
3018 assert(hasUninstantiatedDefaultArg() &&
3019 "Wrong kind of initialization expression!");
3020 return cast_if_present<Expr>(cast<Stmt *>(Init));
3021}
3022
3024 // FIXME: We should just return false for DAK_None here once callers are
3025 // prepared for the case that we encountered an invalid default argument and
3026 // were unable to even build an invalid expression.
3028 !Init.isNull();
3029}
3030
3031void ParmVarDecl::setParameterIndexLarge(unsigned parameterIndex) {
3032 getASTContext().setParameterIndex(this, parameterIndex);
3033 ParmVarDeclBits.ParameterIndex = ParameterIndexSentinel;
3034}
3035
3036unsigned ParmVarDecl::getParameterIndexLarge() const {
3037 return getASTContext().getParameterIndex(this);
3038}
3039
3040//===----------------------------------------------------------------------===//
3041// FunctionDecl Implementation
3042//===----------------------------------------------------------------------===//
3043
3045 SourceLocation StartLoc,
3046 const DeclarationNameInfo &NameInfo, QualType T,
3047 TypeSourceInfo *TInfo, StorageClass S,
3048 bool UsesFPIntrin, bool isInlineSpecified,
3049 ConstexprSpecKind ConstexprKind,
3050 Expr *TrailingRequiresClause)
3051 : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
3052 StartLoc),
3053 DeclContext(DK), redeclarable_base(C), Body(), ODRHash(0),
3054 EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {
3055 assert(T.isNull() || T->isFunctionType());
3056 FunctionDeclBits.SClass = S;
3058 FunctionDeclBits.IsInlineSpecified = isInlineSpecified;
3059 FunctionDeclBits.IsVirtualAsWritten = false;
3060 FunctionDeclBits.IsPureVirtual = false;
3061 FunctionDeclBits.HasInheritedPrototype = false;
3062 FunctionDeclBits.HasWrittenPrototype = true;
3063 FunctionDeclBits.IsDeleted = false;
3064 FunctionDeclBits.IsTrivial = false;
3065 FunctionDeclBits.IsTrivialForCall = false;
3066 FunctionDeclBits.IsDefaulted = false;
3067 FunctionDeclBits.IsExplicitlyDefaulted = false;
3068 FunctionDeclBits.HasDefaultedOrDeletedInfo = false;
3069 FunctionDeclBits.IsIneligibleOrNotSelected = false;
3070 FunctionDeclBits.HasImplicitReturnZero = false;
3071 FunctionDeclBits.IsLateTemplateParsed = false;
3072 FunctionDeclBits.ConstexprKind = static_cast<uint64_t>(ConstexprKind);
3073 FunctionDeclBits.BodyContainsImmediateEscalatingExpression = false;
3074 FunctionDeclBits.InstantiationIsPending = false;
3075 FunctionDeclBits.UsesSEHTry = false;
3076 FunctionDeclBits.UsesFPIntrin = UsesFPIntrin;
3077 FunctionDeclBits.HasSkippedBody = false;
3078 FunctionDeclBits.WillHaveBody = false;
3079 FunctionDeclBits.IsMultiVersion = false;
3080 FunctionDeclBits.DeductionCandidateKind =
3081 static_cast<unsigned char>(DeductionCandidate::Normal);
3082 FunctionDeclBits.HasODRHash = false;
3083 FunctionDeclBits.FriendConstraintRefersToEnclosingTemplate = false;
3084 if (TrailingRequiresClause)
3085 setTrailingRequiresClause(TrailingRequiresClause);
3086}
3087
3089 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
3092 if (TemplateArgs)
3093 printTemplateArgumentList(OS, TemplateArgs->asArray(), Policy);
3094}
3095
3097 if (const auto *FT = getType()->getAs<FunctionProtoType>())
3098 return FT->isVariadic();
3099 return false;
3100}
3101
3104 ASTContext &Context, ArrayRef<DeclAccessPair> Lookups,
3105 StringLiteral *DeletedMessage) {
3106 static constexpr size_t Alignment =
3107 std::max({alignof(DefaultedOrDeletedFunctionInfo),
3108 alignof(DeclAccessPair), alignof(StringLiteral *)});
3109 size_t Size = totalSizeToAlloc<DeclAccessPair, StringLiteral *>(
3110 Lookups.size(), DeletedMessage != nullptr);
3111
3113 new (Context.Allocate(Size, Alignment)) DefaultedOrDeletedFunctionInfo;
3114 Info->NumLookups = Lookups.size();
3115 Info->HasDeletedMessage = DeletedMessage != nullptr;
3116
3117 std::uninitialized_copy(Lookups.begin(), Lookups.end(),
3118 Info->getTrailingObjects<DeclAccessPair>());
3119 if (DeletedMessage)
3120 *Info->getTrailingObjects<StringLiteral *>() = DeletedMessage;
3121 return Info;
3122}
3123
3126 assert(!FunctionDeclBits.HasDefaultedOrDeletedInfo && "already have this");
3127 assert(!Body && "can't replace function body with defaulted function info");
3128
3129 FunctionDeclBits.HasDefaultedOrDeletedInfo = true;
3131}
3132
3134 FunctionDeclBits.IsDeleted = D;
3135
3136 if (Message) {
3137 assert(isDeletedAsWritten() && "Function must be deleted");
3138 if (FunctionDeclBits.HasDefaultedOrDeletedInfo)
3140 else
3142 getASTContext(), /*Lookups=*/{}, Message));
3143 }
3144}
3145
3147 StringLiteral *Message) {
3148 // We should never get here with the DefaultedOrDeletedInfo populated, but
3149 // no space allocated for the deleted message, since that would require
3150 // recreating this, but setDefaultedOrDeletedInfo() disallows overwriting
3151 // an already existing DefaultedOrDeletedFunctionInfo.
3152 assert(HasDeletedMessage &&
3153 "No space to store a delete message in this DefaultedOrDeletedInfo");
3154 *getTrailingObjects<StringLiteral *>() = Message;
3155}
3156
3159 return FunctionDeclBits.HasDefaultedOrDeletedInfo ? DefaultedOrDeletedInfo
3160 : nullptr;
3161}
3162
3164 for (const auto *I : redecls()) {
3165 if (I->doesThisDeclarationHaveABody()) {
3166 Definition = I;
3167 return true;
3168 }
3169 }
3170
3171 return false;
3172}
3173
3175 const Stmt *S = getBody();
3176 if (!S) {
3177 // Since we don't have a body for this function, we don't know if it's
3178 // trivial or not.
3179 return false;
3180 }
3181
3182 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
3183 return true;
3184 return false;
3185}
3186
3188 if (!getFriendObjectKind())
3189 return false;
3190
3191 // Check for a friend function instantiated from a friend function
3192 // definition in a templated class.
3193 if (const FunctionDecl *InstantiatedFrom =
3195 return InstantiatedFrom->getFriendObjectKind() &&
3196 InstantiatedFrom->isThisDeclarationADefinition();
3197
3198 // Check for a friend function template instantiated from a friend
3199 // function template definition in a templated class.
3200 if (const FunctionTemplateDecl *Template = getDescribedFunctionTemplate()) {
3201 if (const FunctionTemplateDecl *InstantiatedFrom =
3203 return InstantiatedFrom->getFriendObjectKind() &&
3204 InstantiatedFrom->isThisDeclarationADefinition();
3205 }
3206
3207 return false;
3208}
3209
3211 bool CheckForPendingFriendDefinition) const {
3212 for (const FunctionDecl *FD : redecls()) {
3213 if (FD->isThisDeclarationADefinition()) {
3214 Definition = FD;
3215 return true;
3216 }
3217
3218 // If this is a friend function defined in a class template, it does not
3219 // have a body until it is used, nevertheless it is a definition, see
3220 // [temp.inst]p2:
3221 //
3222 // ... for the purpose of determining whether an instantiated redeclaration
3223 // is valid according to [basic.def.odr] and [class.mem], a declaration that
3224 // corresponds to a definition in the template is considered to be a
3225 // definition.
3226 //
3227 // The following code must produce redefinition error:
3228 //
3229 // template<typename T> struct C20 { friend void func_20() {} };
3230 // C20<int> c20i;
3231 // void func_20() {}
3232 //
3233 if (CheckForPendingFriendDefinition &&
3234 FD->isThisDeclarationInstantiatedFromAFriendDefinition()) {
3235 Definition = FD;
3236 return true;
3237 }
3238 }
3239
3240 return false;
3241}
3242
3244 if (!hasBody(Definition))
3245 return nullptr;
3246
3247 assert(!Definition->FunctionDeclBits.HasDefaultedOrDeletedInfo &&
3248 "definition should not have a body");
3249 if (Definition->Body)
3250 return Definition->Body.get(getASTContext().getExternalSource());
3251
3252 return nullptr;
3253}
3254
3256 FunctionDeclBits.HasDefaultedOrDeletedInfo = false;
3257 Body = LazyDeclStmtPtr(B);
3258 if (B)
3259 EndRangeLoc = B->getEndLoc();
3260}
3261
3263 FunctionDeclBits.IsPureVirtual = P;
3264 if (P)
3265 if (auto *Parent = dyn_cast<CXXRecordDecl>(getDeclContext()))
3266 Parent->markedVirtualFunctionPure();
3267}
3268
3269template<std::size_t Len>
3270static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) {
3271 const IdentifierInfo *II = ND->getIdentifier();
3272 return II && II->isStr(Str);
3273}
3274
3276 // C++23 [expr.const]/p17
3277 // An immediate-escalating function is
3278 // - the call operator of a lambda that is not declared with the consteval
3279 // specifier,
3280 if (isLambdaCallOperator(this) && !isConsteval())
3281 return true;
3282 // - a defaulted special member function that is not declared with the
3283 // consteval specifier,
3284 if (isDefaulted() && !isConsteval())
3285 return true;
3286
3287 if (auto *CD = dyn_cast<CXXConstructorDecl>(this);
3288 CD && CD->isInheritingConstructor())
3289 return CD->getInheritedConstructor().getConstructor();
3290
3291 // - a function that results from the instantiation of a templated entity
3292 // defined with the constexpr specifier.
3294 if (TK != TK_NonTemplate && TK != TK_DependentNonTemplate &&
3296 return true;
3297 return false;
3298}
3299
3301 // C++23 [expr.const]/p18
3302 // An immediate function is a function or constructor that is
3303 // - declared with the consteval specifier
3304 if (isConsteval())
3305 return true;
3306 // - an immediate-escalating function F whose function body contains an
3307 // immediate-escalating expression
3309 return true;
3310
3311 if (auto *CD = dyn_cast<CXXConstructorDecl>(this);
3312 CD && CD->isInheritingConstructor())
3313 return CD->getInheritedConstructor()
3314 .getConstructor()
3315 ->isImmediateFunction();
3316
3318 P && P->isImmediateFunction())
3319 return true;
3320
3321 if (const auto *MD = dyn_cast<CXXMethodDecl>(this);
3322 MD && MD->isLambdaStaticInvoker())
3323 return MD->getParent()->getLambdaCallOperator()->isImmediateFunction();
3324
3325 return false;
3326}
3327
3329 return isNamed(this, "main") && !getLangOpts().Freestanding &&
3330 !getLangOpts().HLSL &&
3332 isExternC());
3333}
3334
3336 const TranslationUnitDecl *TUnit =
3337 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
3338 if (!TUnit)
3339 return false;
3340
3341 // Even though we aren't really targeting MSVCRT if we are freestanding,
3342 // semantic analysis for these functions remains the same.
3343
3344 // MSVCRT entry points only exist on MSVCRT targets.
3345 if (!TUnit->getASTContext().getTargetInfo().getTriple().isOSMSVCRT())
3346 return false;
3347
3348 // Nameless functions like constructors cannot be entry points.
3349 if (!getIdentifier())
3350 return false;
3351
3352 return llvm::StringSwitch<bool>(getName())
3353 .Cases("main", // an ANSI console app
3354 "wmain", // a Unicode console App
3355 "WinMain", // an ANSI GUI app
3356 "wWinMain", // a Unicode GUI app
3357 "DllMain", // a DLL
3358 true)
3359 .Default(false);
3360}
3361
3363 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
3364 return false;
3365 if (getDeclName().getCXXOverloadedOperator() != OO_New &&
3366 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3367 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3368 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3369 return false;
3370
3372 return false;
3373
3374 const auto *proto = getType()->castAs<FunctionProtoType>();
3375 if (proto->getNumParams() != 2 || proto->isVariadic())
3376 return false;
3377
3378 const ASTContext &Context =
3379 cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
3380 ->getASTContext();
3381
3382 // The result type and first argument type are constant across all
3383 // these operators. The second argument must be exactly void*.
3384 return (proto->getParamType(1).getCanonicalType() == Context.VoidPtrTy);
3385}
3386
3388 std::optional<unsigned> *AlignmentParam, bool *IsNothrow) const {
3389 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
3390 return false;
3391 if (getDeclName().getCXXOverloadedOperator() != OO_New &&
3392 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3393 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3394 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3395 return false;
3396
3397 if (isa<CXXRecordDecl>(getDeclContext()))
3398 return false;
3399
3400 // This can only fail for an invalid 'operator new' declaration.
3402 return false;
3403
3404 const auto *FPT = getType()->castAs<FunctionProtoType>();
3405 if (FPT->getNumParams() == 0 || FPT->getNumParams() > 4 || FPT->isVariadic())
3406 return false;
3407
3408 // If this is a single-parameter function, it must be a replaceable global
3409 // allocation or deallocation function.
3410 if (FPT->getNumParams() == 1)
3411 return true;
3412
3413 unsigned Params = 1;
3414 QualType Ty = FPT->getParamType(Params);
3415 const ASTContext &Ctx = getASTContext();
3416
3417 auto Consume = [&] {
3418 ++Params;
3419 Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) : QualType();
3420 };
3421
3422 // In C++14, the next parameter can be a 'std::size_t' for sized delete.
3423 bool IsSizedDelete = false;
3424 if (Ctx.getLangOpts().SizedDeallocation &&
3425 (getDeclName().getCXXOverloadedOperator() == OO_Delete ||
3426 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
3427 Ctx.hasSameType(Ty, Ctx.getSizeType())) {
3428 IsSizedDelete = true;
3429 Consume();
3430 }
3431
3432 // In C++17, the next parameter can be a 'std::align_val_t' for aligned
3433 // new/delete.
3434 if (Ctx.getLangOpts().AlignedAllocation && !Ty.isNull() && Ty->isAlignValT()) {
3435 Consume();
3436 if (AlignmentParam)
3437 *AlignmentParam = Params;
3438 }
3439
3440 // If this is not a sized delete, the next parameter can be a
3441 // 'const std::nothrow_t&'.
3442 if (!IsSizedDelete && !Ty.isNull() && Ty->isReferenceType()) {
3443 Ty = Ty->getPointeeType();
3445 return false;
3446 if (Ty->isNothrowT()) {
3447 if (IsNothrow)
3448 *IsNothrow = true;
3449 Consume();
3450 }
3451 }
3452
3453 // Finally, recognize the not yet standard versions of new that take a
3454 // hot/cold allocation hint (__hot_cold_t). These are currently supported by
3455 // tcmalloc (see
3456 // https://github.com/google/tcmalloc/blob/220043886d4e2efff7a5702d5172cb8065253664/tcmalloc/malloc_extension.h#L53).
3457 if (!IsSizedDelete && !Ty.isNull() && Ty->isEnumeralType()) {
3458 QualType T = Ty;
3459 while (const auto *TD = T->getAs<TypedefType>())
3460 T = TD->getDecl()->getUnderlyingType();
3461 const IdentifierInfo *II =
3462 T->castAs<EnumType>()->getDecl()->getIdentifier();
3463 if (II && II->isStr("__hot_cold_t"))
3464 Consume();
3465 }
3466
3467 return Params == FPT->getNumParams();
3468}
3469
3471 if (!getBuiltinID())
3472 return false;
3473
3474 const FunctionDecl *Definition;
3475 if (!hasBody(Definition))
3476 return false;
3477
3478 if (!Definition->isInlineSpecified() ||
3479 !Definition->hasAttr<AlwaysInlineAttr>())
3480 return false;
3481
3482 ASTContext &Context = getASTContext();
3483 switch (Context.GetGVALinkageForFunction(Definition)) {
3484 case GVA_Internal:
3485 case GVA_DiscardableODR:
3486 case GVA_StrongODR:
3487 return false;
3489 case GVA_StrongExternal:
3490 return true;
3491 }
3492 llvm_unreachable("Unknown GVALinkage");
3493}
3494
3496 // C++ P0722:
3497 // Within a class C, a single object deallocation function with signature
3498 // (T, std::destroying_delete_t, <more params>)
3499 // is a destroying operator delete.
3500 if (!isa<CXXMethodDecl>(this) || getOverloadedOperator() != OO_Delete ||
3501 getNumParams() < 2)
3502 return false;
3503
3504 auto *RD = getParamDecl(1)->getType()->getAsCXXRecordDecl();
3505 return RD && RD->isInStdNamespace() && RD->getIdentifier() &&
3506 RD->getIdentifier()->isStr("destroying_delete_t");
3507}
3508
3510 return getDeclLanguageLinkage(*this);
3511}
3512
3514 return isDeclExternC(*this);
3515}
3516
3518 if (hasAttr<OpenCLKernelAttr>())
3519 return true;
3521}
3522
3525}
3526
3528 if (const auto *Method = dyn_cast<CXXMethodDecl>(this))
3529 return Method->isStatic();
3530
3532 return false;
3533
3534 for (const DeclContext *DC = getDeclContext();
3535 DC->isNamespace();
3536 DC = DC->getParent()) {
3537 if (const auto *Namespace = cast<NamespaceDecl>(DC)) {
3538 if (!Namespace->getDeclName())
3539 return false;
3540 }
3541 }
3542
3543 return true;
3544}
3545
3547 if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
3548 hasAttr<C11NoReturnAttr>())
3549 return true;
3550
3551 if (auto *FnTy = getType()->getAs<FunctionType>())
3552 return FnTy->getNoReturnAttr();
3553
3554 return false;
3555}
3556
3558 // C++20 [temp.friend]p9:
3559 // A non-template friend declaration with a requires-clause [or]
3560 // a friend function template with a constraint that depends on a template
3561 // parameter from an enclosing template [...] does not declare the same
3562 // function or function template as a declaration in any other scope.
3563
3564 // If this isn't a friend then it's not a member-like constrained friend.
3565 if (!getFriendObjectKind()) {
3566 return false;
3567 }
3568
3570 // If these friends don't have constraints, they aren't constrained, and
3571 // thus don't fall under temp.friend p9. Else the simple presence of a
3572 // constraint makes them unique.
3574 }
3575
3577}
3578
3580 if (hasAttr<TargetAttr>())
3582 if (hasAttr<TargetVersionAttr>())
3584 if (hasAttr<CPUDispatchAttr>())
3586 if (hasAttr<CPUSpecificAttr>())
3588 if (hasAttr<TargetClonesAttr>())
3591}
3592
3594 return isMultiVersion() && hasAttr<CPUDispatchAttr>();
3595}
3596
3598 return isMultiVersion() && hasAttr<CPUSpecificAttr>();
3599}
3600
3602 return isMultiVersion() &&
3603 (hasAttr<TargetAttr>() || hasAttr<TargetVersionAttr>());
3604}
3605
3607 if (!isMultiVersion())
3608 return false;
3609 if (hasAttr<TargetAttr>())
3610 return getAttr<TargetAttr>()->isDefaultVersion();
3611 return hasAttr<TargetVersionAttr>() &&
3612 getAttr<TargetVersionAttr>()->isDefaultVersion();
3613}
3614
3616 return isMultiVersion() && hasAttr<TargetClonesAttr>();
3617}
3618
3620 return isMultiVersion() && hasAttr<TargetVersionAttr>();
3621}
3622
3623void
3626
3628 FunctionTemplateDecl *PrevFunTmpl
3629 = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : nullptr;
3630 assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");
3631 FunTmpl->setPreviousDecl(PrevFunTmpl);
3632 }
3633
3634 if (PrevDecl && PrevDecl->isInlined())
3635 setImplicitlyInline(true);
3636}
3637
3639
3640/// Returns a value indicating whether this function corresponds to a builtin
3641/// function.
3642///
3643/// The function corresponds to a built-in function if it is declared at
3644/// translation scope or within an extern "C" block and its name matches with
3645/// the name of a builtin. The returned value will be 0 for functions that do
3646/// not correspond to a builtin, a value of type \c Builtin::ID if in the
3647/// target-independent range \c [1,Builtin::First), or a target-specific builtin
3648/// value.
3649///
3650/// \param ConsiderWrapperFunctions If true, we should consider wrapper
3651/// functions as their wrapped builtins. This shouldn't be done in general, but
3652/// it's useful in Sema to diagnose calls to wrappers based on their semantics.
3653unsigned FunctionDecl::getBuiltinID(bool ConsiderWrapperFunctions) const {
3654 unsigned BuiltinID = 0;
3655
3656 if (const auto *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
3657 BuiltinID = ABAA->getBuiltinName()->getBuiltinID();
3658 } else if (const auto *BAA = getAttr<BuiltinAliasAttr>()) {
3659 BuiltinID = BAA->getBuiltinName()->getBuiltinID();
3660 } else if (const auto *A = getAttr<BuiltinAttr>()) {
3661 BuiltinID = A->getID();
3662 }
3663
3664 if (!BuiltinID)
3665 return 0;
3666
3667 // If the function is marked "overloadable", it has a different mangled name
3668 // and is not the C library function.
3669 if (!ConsiderWrapperFunctions && hasAttr<OverloadableAttr>() &&
3670 (!hasAttr<ArmBuiltinAliasAttr>() && !hasAttr<BuiltinAliasAttr>()))
3671 return 0;
3672
3674 BuiltinID == Builtin::BI__builtin_counted_by_ref)
3675 return 0;
3676
3677 const ASTContext &Context = getASTContext();
3678 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
3679 return BuiltinID;
3680
3681 // This function has the name of a known C library
3682 // function. Determine whether it actually refers to the C library
3683 // function or whether it just has the same name.
3684
3685 // If this is a static function, it's not a builtin.
3686 if (!ConsiderWrapperFunctions && getStorageClass() == SC_Static)
3687 return 0;
3688
3689 // OpenCL v1.2 s6.9.f - The library functions defined in
3690 // the C99 standard headers are not available.
3691 if (Context.getLangOpts().OpenCL &&
3692 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
3693 return 0;
3694
3695 // CUDA does not have device-side standard library. printf and malloc are the
3696 // only special cases that are supported by device-side runtime.
3697 if (Context.getLangOpts().CUDA && hasAttr<CUDADeviceAttr>() &&
3698 !hasAttr<CUDAHostAttr>() &&
3699 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3700 return 0;
3701
3702 // As AMDGCN implementation of OpenMP does not have a device-side standard
3703 // library, none of the predefined library functions except printf and malloc
3704 // should be treated as a builtin i.e. 0 should be returned for them.
3705 if (Context.getTargetInfo().getTriple().isAMDGCN() &&
3706 Context.getLangOpts().OpenMPIsTargetDevice &&
3707 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
3708 !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3709 return 0;
3710
3711 return BuiltinID;
3712}
3713
3714/// getNumParams - Return the number of parameters this function must have
3715/// based on its FunctionType. This is the length of the ParamInfo array
3716/// after it has been created.
3718 const auto *FPT = getType()->getAs<FunctionProtoType>();
3719 return FPT ? FPT->getNumParams() : 0;
3720}
3721
3722void FunctionDecl::setParams(ASTContext &C,
3723 ArrayRef<ParmVarDecl *> NewParamInfo) {
3724 assert(!ParamInfo && "Already has param info!");
3725 assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!");
3726
3727 // Zero params -> null pointer.
3728 if (!NewParamInfo.empty()) {
3729 ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()];
3730 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3731 }
3732}
3733
3734/// getMinRequiredArguments - Returns the minimum number of arguments
3735/// needed to call this function. This may be fewer than the number of
3736/// function parameters, if some of the parameters have default
3737/// arguments (in C++) or are parameter packs (C++11).
3740 return getNumParams();
3741
3742 // Note that it is possible for a parameter with no default argument to
3743 // follow a parameter with a default argument.
3744 unsigned NumRequiredArgs = 0;
3745 unsigned MinParamsSoFar = 0;
3746 for (auto *Param : parameters()) {
3747 if (!Param->isParameterPack()) {
3748 ++MinParamsSoFar;
3749 if (!Param->hasDefaultArg())
3750 NumRequiredArgs = MinParamsSoFar;
3751 }
3752 }
3753 return NumRequiredArgs;
3754}
3755
3758}
3759
3761 return getNumParams() -
3762 static_cast<unsigned>(hasCXXExplicitFunctionObjectParameter());
3763}
3764
3766 return getMinRequiredArguments() -
3767 static_cast<unsigned>(hasCXXExplicitFunctionObjectParameter());
3768}
3769
3771 return getNumParams() == 1 ||
3772 (getNumParams() > 1 &&
3773 llvm::all_of(llvm::drop_begin(parameters()),
3774 [](ParmVarDecl *P) { return P->hasDefaultArg(); }));
3775}
3776
3777/// The combination of the extern and inline keywords under MSVC forces
3778/// the function to be required.
3779///
3780/// Note: This function assumes that we will only get called when isInlined()
3781/// would return true for this FunctionDecl.
3783 assert(isInlined() && "expected to get called on an inlined function!");
3784
3785 const ASTContext &Context = getASTContext();
3786 if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3787 !hasAttr<DLLExportAttr>())
3788 return false;
3789
3790 for (const FunctionDecl *FD = getMostRecentDecl(); FD;
3791 FD = FD->getPreviousDecl())
3792 if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
3793 return true;
3794
3795 return false;
3796}
3797
3798static bool redeclForcesDefMSVC(const FunctionDecl *Redecl) {
3799 if (Redecl->getStorageClass() != SC_Extern)
3800 return false;
3801
3802 for (const FunctionDecl *FD = Redecl->getPreviousDecl(); FD;
3803 FD = FD->getPreviousDecl())
3804 if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
3805 return false;
3806
3807 return true;
3808}
3809
3810static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
3811 // Only consider file-scope declarations in this test.
3812 if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
3813 return false;
3814
3815 // Only consider explicit declarations; the presence of a builtin for a
3816 // libcall shouldn't affect whether a definition is externally visible.
3817 if (Redecl->isImplicit())
3818 return false;
3819
3820 if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern)
3821 return true; // Not an inline definition
3822
3823 return false;
3824}
3825
3826/// For a function declaration in C or C++, determine whether this
3827/// declaration causes the definition to be externally visible.
3828///
3829/// For instance, this determines if adding the current declaration to the set
3830/// of redeclarations of the given functions causes
3831/// isInlineDefinitionExternallyVisible to change from false to true.
3833 assert(!doesThisDeclarationHaveABody() &&
3834 "Must have a declaration without a body.");
3835
3836 const ASTContext &Context = getASTContext();
3837
3838 if (Context.getLangOpts().MSVCCompat) {
3839 const FunctionDecl *Definition;
3840 if (hasBody(Definition) && Definition->isInlined() &&
3841 redeclForcesDefMSVC(this))
3842 return true;
3843 }
3844
3845 if (Context.getLangOpts().CPlusPlus)
3846 return false;
3847
3848 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3849 // With GNU inlining, a declaration with 'inline' but not 'extern', forces
3850 // an externally visible definition.
3851 //
3852 // FIXME: What happens if gnu_inline gets added on after the first
3853 // declaration?
3855 return false;
3856
3857 const FunctionDecl *Prev = this;
3858 bool FoundBody = false;
3859 while ((Prev = Prev->getPreviousDecl())) {
3860 FoundBody |= Prev->doesThisDeclarationHaveABody();
3861
3862 if (Prev->doesThisDeclarationHaveABody()) {
3863 // If it's not the case that both 'inline' and 'extern' are
3864 // specified on the definition, then it is always externally visible.
3865 if (!Prev->isInlineSpecified() ||
3866 Prev->getStorageClass() != SC_Extern)
3867 return false;
3868 } else if (Prev->isInlineSpecified() &&
3869 Prev->getStorageClass() != SC_Extern) {
3870 return false;
3871 }
3872 }
3873 return FoundBody;
3874 }
3875
3876 // C99 6.7.4p6:
3877 // [...] If all of the file scope declarations for a function in a
3878 // translation unit include the inline function specifier without extern,
3879 // then the definition in that translation unit is an inline definition.
3881 return false;
3882 const FunctionDecl *Prev = this;
3883 bool FoundBody = false;
3884 while ((Prev = Prev->getPreviousDecl())) {
3885 FoundBody |= Prev->doesThisDeclarationHaveABody();
3886 if (RedeclForcesDefC99(Prev))
3887 return false;
3888 }
3889 return FoundBody;
3890}
3891
3893 const TypeSourceInfo *TSI = getTypeSourceInfo();
3894 return TSI ? TSI->getTypeLoc().IgnoreParens().getAs<FunctionTypeLoc>()
3895 : FunctionTypeLoc();
3896}
3897
3900 if (!FTL)
3901 return SourceRange();
3902
3903 // Skip self-referential return types.
3905 SourceRange RTRange = FTL.getReturnLoc().getSourceRange();
3906 SourceLocation Boundary = getNameInfo().getBeginLoc();
3907 if (RTRange.isInvalid() || Boundary.isInvalid() ||
3908 !SM.isBeforeInTranslationUnit(RTRange.getEnd(), Boundary))
3909 return SourceRange();
3910
3911 return RTRange;
3912}
3913
3915 unsigned NP = getNumParams();
3916 SourceLocation EllipsisLoc = getEllipsisLoc();
3917
3918 if (NP == 0 && EllipsisLoc.isInvalid())
3919 return SourceRange();
3920
3922 NP > 0 ? ParamInfo[0]->getSourceRange().getBegin() : EllipsisLoc;
3923 SourceLocation End = EllipsisLoc.isValid()
3924 ? EllipsisLoc
3925 : ParamInfo[NP - 1]->getSourceRange().getEnd();
3926
3927 return SourceRange(Begin, End);
3928}
3929
3932 return FTL ? FTL.getExceptionSpecRange() : SourceRange();
3933}
3934
3935/// For an inline function definition in C, or for a gnu_inline function
3936/// in C++, determine whether the definition will be externally visible.
3937///
3938/// Inline function definitions are always available for inlining optimizations.
3939/// However, depending on the language dialect, declaration specifiers, and
3940/// attributes, the definition of an inline function may or may not be
3941/// "externally" visible to other translation units in the program.
3942///
3943/// In C99, inline definitions are not externally visible by default. However,
3944/// if even one of the global-scope declarations is marked "extern inline", the
3945/// inline definition becomes externally visible (C99 6.7.4p6).
3946///
3947/// In GNU89 mode, or if the gnu_inline attribute is attached to the function
3948/// definition, we use the GNU semantics for inline, which are nearly the
3949/// opposite of C99 semantics. In particular, "inline" by itself will create
3950/// an externally visible symbol, but "extern inline" will not create an
3951/// externally visible symbol.
3954 hasAttr<AliasAttr>()) &&
3955 "Must be a function definition");
3956 assert(isInlined() && "Function must be inline");
3957 ASTContext &Context = getASTContext();
3958
3959 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3960 // Note: If you change the logic here, please change
3961 // doesDeclarationForceExternallyVisibleDefinition as well.
3962 //
3963 // If it's not the case that both 'inline' and 'extern' are
3964 // specified on the definition, then this inline definition is
3965 // externally visible.
3966 if (Context.getLangOpts().CPlusPlus)
3967 return false;
3969 return true;
3970
3971 // If any declaration is 'inline' but not 'extern', then this definition
3972 // is externally visible.
3973 for (auto *Redecl : redecls()) {
3974 if (Redecl->isInlineSpecified() &&
3975 Redecl->getStorageClass() != SC_Extern)
3976 return true;
3977 }
3978
3979 return false;
3980 }
3981
3982 // The rest of this function is C-only.
3983 assert(!Context.getLangOpts().CPlusPlus &&
3984 "should not use C inline rules in C++");
3985
3986 // C99 6.7.4p6:
3987 // [...] If all of the file scope declarations for a function in a
3988 // translation unit include the inline function specifier without extern,
3989 // then the definition in that translation unit is an inline definition.
3990 for (auto *Redecl : redecls()) {
3991 if (RedeclForcesDefC99(Redecl))
3992 return true;
3993 }
3994
3995 // C99 6.7.4p6:
3996 // An inline definition does not provide an external definition for the
3997 // function, and does not forbid an external definition in another
3998 // translation unit.
3999 return false;
4000}
4001
4002/// getOverloadedOperator - Which C++ overloaded operator this
4003/// function represents, if any.
4005 if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
4007 return OO_None;
4008}
4009
4010/// getLiteralIdentifier - The literal suffix identifier this function
4011/// represents, if any.
4015 return nullptr;
4016}
4017
4019 if (TemplateOrSpecialization.isNull())
4020 return TK_NonTemplate;
4021 if (const auto *ND = dyn_cast<NamedDecl *>(TemplateOrSpecialization)) {
4022 if (isa<FunctionDecl>(ND))
4024 assert(isa<FunctionTemplateDecl>(ND) &&
4025 "No other valid types in NamedDecl");
4026 return TK_FunctionTemplate;
4027 }
4028 if (isa<MemberSpecializationInfo *>(TemplateOrSpecialization))
4030 if (isa<FunctionTemplateSpecializationInfo *>(TemplateOrSpecialization))
4032 if (isa<DependentFunctionTemplateSpecializationInfo *>(
4033 TemplateOrSpecialization))
4035
4036 llvm_unreachable("Did we miss a TemplateOrSpecialization type?");
4037}
4038
4041 return cast<FunctionDecl>(Info->getInstantiatedFrom());
4042
4043 return nullptr;
4044}
4045
4047 if (auto *MSI = dyn_cast_if_present<MemberSpecializationInfo *>(
4048 TemplateOrSpecialization))
4049 return MSI;
4050 if (auto *FTSI = dyn_cast_if_present<FunctionTemplateSpecializationInfo *>(
4051 TemplateOrSpecialization))
4052 return FTSI->getMemberSpecializationInfo();
4053 return nullptr;
4054}
4055
4056void
4057FunctionDecl::setInstantiationOfMemberFunction(ASTContext &C,
4058 FunctionDecl *FD,
4060 assert(TemplateOrSpecialization.isNull() &&
4061 "Member function is already a specialization");
4063 = new (C) MemberSpecializationInfo(FD, TSK);
4064 TemplateOrSpecialization = Info;
4065}
4066
4068 return dyn_cast_if_present<FunctionTemplateDecl>(
4069 dyn_cast_if_present<NamedDecl *>(TemplateOrSpecialization));
4070}
4071
4073 FunctionTemplateDecl *Template) {
4074 assert(TemplateOrSpecialization.isNull() &&
4075 "Member function is already a specialization");
4076 TemplateOrSpecialization = Template;
4077}
4078
4080 return isa<FunctionTemplateSpecializationInfo *>(TemplateOrSpecialization) ||
4081 isa<DependentFunctionTemplateSpecializationInfo *>(
4082 TemplateOrSpecialization);
4083}
4084
4086 assert(TemplateOrSpecialization.isNull() &&
4087 "Function is already a specialization");
4088 TemplateOrSpecialization = FD;
4089}
4090
4092 return dyn_cast_if_present<FunctionDecl>(
4093 TemplateOrSpecialization.dyn_cast<NamedDecl *>());
4094}
4095
4097 // If the function is invalid, it can't be implicitly instantiated.
4098 if (isInvalidDecl())
4099 return false;
4100
4102 case TSK_Undeclared:
4105 return false;
4106
4108 return true;
4109
4111 // Handled below.
4112 break;
4113 }
4114
4115 // Find the actual template from which we will instantiate.
4116 const FunctionDecl *PatternDecl = getTemplateInstantiationPattern();
4117 bool HasPattern = false;
4118 if (PatternDecl)
4119 HasPattern = PatternDecl->hasBody(PatternDecl);
4120
4121 // C++0x [temp.explicit]p9:
4122 // Except for inline functions, other explicit instantiation declarations
4123 // have the effect of suppressing the implicit instantiation of the entity
4124 // to which they refer.
4125 if (!HasPattern || !PatternDecl)
4126 return true;
4127
4128 return PatternDecl->isInlined();
4129}
4130
4132 // FIXME: Remove this, it's not clear what it means. (Which template
4133 // specialization kind?)
4135}
4136
4139 // If this is a generic lambda call operator specialization, its
4140 // instantiation pattern is always its primary template's pattern
4141 // even if its primary template was instantiated from another
4142 // member template (which happens with nested generic lambdas).
4143 // Since a lambda's call operator's body is transformed eagerly,
4144 // we don't have to go hunting for a prototype definition template
4145 // (i.e. instantiated-from-member-template) to use as an instantiation
4146 // pattern.
4147
4149 dyn_cast<CXXMethodDecl>(this))) {
4150 assert(getPrimaryTemplate() && "not a generic lambda call operator?");
4151 return getDefinitionOrSelf(getPrimaryTemplate()->getTemplatedDecl());
4152 }
4153
4154 // Check for a declaration of this function that was instantiated from a
4155 // friend definition.
4156 const FunctionDecl *FD = nullptr;
4157 if (!isDefined(FD, /*CheckForPendingFriendDefinition=*/true))
4158 FD = this;
4159
4161 if (ForDefinition &&
4163 return nullptr;
4164 return getDefinitionOrSelf(cast<FunctionDecl>(Info->getInstantiatedFrom()));
4165 }
4166
4167 if (ForDefinition &&
4169 return nullptr;
4170
4171 if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) {
4172 // If we hit a point where the user provided a specialization of this
4173 // template, we're done looking.
4174 while (!ForDefinition || !Primary->isMemberSpecialization()) {
4175 auto *NewPrimary = Primary->getInstantiatedFromMemberTemplate();
4176 if (!NewPrimary)
4177 break;
4178 Primary = NewPrimary;
4179 }
4180
4181 return getDefinitionOrSelf(Primary->getTemplatedDecl());
4182 }
4183
4184 return nullptr;
4185}
4186
4189 dyn_cast_if_present<FunctionTemplateSpecializationInfo *>(
4190 TemplateOrSpecialization)) {
4191 return Info->getTemplate();
4192 }
4193 return nullptr;
4194}
4195
4198 return dyn_cast_if_present<FunctionTemplateSpecializationInfo *>(
4199 TemplateOrSpecialization);
4200}
4201
4205 dyn_cast_if_present<FunctionTemplateSpecializationInfo *>(
4206 TemplateOrSpecialization)) {
4207 return Info->TemplateArguments;
4208 }
4209 return nullptr;
4210}
4211
4215 dyn_cast_if_present<FunctionTemplateSpecializationInfo *>(
4216 TemplateOrSpecialization)) {
4217 return Info->TemplateArgumentsAsWritten;
4218 }
4220 dyn_cast_if_present<DependentFunctionTemplateSpecializationInfo *>(
4221 TemplateOrSpecialization)) {
4222 return Info->TemplateArgumentsAsWritten;
4223 }
4224 return nullptr;
4225}
4226
4227void FunctionDecl::setFunctionTemplateSpecialization(
4228 ASTContext &C, FunctionTemplateDecl *Template,
4229 TemplateArgumentList *TemplateArgs, void *InsertPos,
4231 const TemplateArgumentListInfo *TemplateArgsAsWritten,
4232 SourceLocation PointOfInstantiation) {
4233 assert((TemplateOrSpecialization.isNull() ||
4234 isa<MemberSpecializationInfo *>(TemplateOrSpecialization)) &&
4235 "Member function is already a specialization");
4236 assert(TSK != TSK_Undeclared &&
4237 "Must specify the type of function template specialization");
4238 assert((TemplateOrSpecialization.isNull() ||
4241 "Member specialization must be an explicit specialization");
4244 C, this, Template, TSK, TemplateArgs, TemplateArgsAsWritten,
4245 PointOfInstantiation,
4246 dyn_cast_if_present<MemberSpecializationInfo *>(
4247 TemplateOrSpecialization));
4248 TemplateOrSpecialization = Info;
4249 Template->addSpecialization(Info, InsertPos);
4250}
4251
4253 ASTContext &Context, const UnresolvedSetImpl &Templates,
4254 const TemplateArgumentListInfo *TemplateArgs) {
4255 assert(TemplateOrSpecialization.isNull());
4258 TemplateArgs);
4259 TemplateOrSpecialization = Info;
4260}
4261
4264 return dyn_cast_if_present<DependentFunctionTemplateSpecializationInfo *>(
4265 TemplateOrSpecialization);
4266}
4267
4270 ASTContext &Context, const UnresolvedSetImpl &Candidates,
4271 const TemplateArgumentListInfo *TArgs) {
4272 const auto *TArgsWritten =
4273 TArgs ? ASTTemplateArgumentListInfo::Create(Context, *TArgs) : nullptr;
4274 return new (Context.Allocate(
4275 totalSizeToAlloc<FunctionTemplateDecl *>(Candidates.size())))
4276 DependentFunctionTemplateSpecializationInfo(Candidates, TArgsWritten);
4277}
4278
4279DependentFunctionTemplateSpecializationInfo::
4280 DependentFunctionTemplateSpecializationInfo(
4281 const UnresolvedSetImpl &Candidates,
4282 const ASTTemplateArgumentListInfo *TemplateArgsWritten)
4283 : NumCandidates(Candidates.size()),
4284 TemplateArgumentsAsWritten(TemplateArgsWritten) {
4285 std::transform(Candidates.begin(), Candidates.end(),
4286 getTrailingObjects<FunctionTemplateDecl *>(),
4287 [](NamedDecl *ND) {
4288 return cast<FunctionTemplateDecl>(ND->getUnderlyingDecl());
4289 });
4290}
4291
4293 // For a function template specialization, query the specialization
4294 // information object.
4296 dyn_cast_if_present<FunctionTemplateSpecializationInfo *>(
4297 TemplateOrSpecialization))
4298 return FTSInfo->getTemplateSpecializationKind();
4299
4300 if (MemberSpecializationInfo *MSInfo =
4301 dyn_cast_if_present<MemberSpecializationInfo *>(
4302 TemplateOrSpecialization))
4303 return MSInfo->getTemplateSpecializationKind();
4304
4305 // A dependent function template specialization is an explicit specialization,
4306 // except when it's a friend declaration.
4307 if (isa<DependentFunctionTemplateSpecializationInfo *>(
4308 TemplateOrSpecialization) &&
4311
4312 return TSK_Undeclared;
4313}
4314
4317 // This is the same as getTemplateSpecializationKind(), except that for a
4318 // function that is both a function template specialization and a member
4319 // specialization, we prefer the member specialization information. Eg:
4320 //
4321 // template<typename T> struct A {
4322 // template<typename U> void f() {}
4323 // template<> void f<int>() {}
4324 // };
4325 //
4326 // Within the templated CXXRecordDecl, A<T>::f<int> is a dependent function
4327 // template specialization; both getTemplateSpecializationKind() and
4328 // getTemplateSpecializationKindForInstantiation() will return
4329 // TSK_ExplicitSpecialization.
4330 //
4331 // For A<int>::f<int>():
4332 // * getTemplateSpecializationKind() will return TSK_ExplicitSpecialization
4333 // * getTemplateSpecializationKindForInstantiation() will return
4334 // TSK_ImplicitInstantiation
4335 //
4336 // This reflects the facts that A<int>::f<int> is an explicit specialization
4337 // of A<int>::f, and that A<int>::f<int> should be implicitly instantiated
4338 // from A::f<int> if a definition is needed.
4340 dyn_cast_if_present<FunctionTemplateSpecializationInfo *>(
4341 TemplateOrSpecialization)) {
4342 if (auto *MSInfo = FTSInfo->getMemberSpecializationInfo())
4343 return MSInfo->getTemplateSpecializationKind();
4344 return FTSInfo->getTemplateSpecializationKind();
4345 }
4346
4347 if (MemberSpecializationInfo *MSInfo =
4348 dyn_cast_if_present<MemberSpecializationInfo *>(
4349 TemplateOrSpecialization))
4350 return MSInfo->getTemplateSpecializationKind();
4351
4352 if (isa<DependentFunctionTemplateSpecializationInfo *>(
4353 TemplateOrSpecialization) &&
4356
4357 return TSK_Undeclared;
4358}
4359
4360void
4362 SourceLocation PointOfInstantiation) {
4364 dyn_cast<FunctionTemplateSpecializationInfo *>(
4365 TemplateOrSpecialization)) {
4366 FTSInfo->setTemplateSpecializationKind(TSK);
4367 if (TSK != TSK_ExplicitSpecialization &&
4368 PointOfInstantiation.isValid() &&
4369 FTSInfo->getPointOfInstantiation().isInvalid()) {
4370 FTSInfo->setPointOfInstantiation(PointOfInstantiation);
4372 L->InstantiationRequested(this);
4373 }
4374 } else if (MemberSpecializationInfo *MSInfo =
4375 dyn_cast<MemberSpecializationInfo *>(
4376 TemplateOrSpecialization)) {
4377 MSInfo->setTemplateSpecializationKind(TSK);
4378 if (TSK != TSK_ExplicitSpecialization &&
4379 PointOfInstantiation.isValid() &&
4380 MSInfo->getPointOfInstantiation().isInvalid()) {
4381 MSInfo->setPointOfInstantiation(PointOfInstantiation);
4383 L->InstantiationRequested(this);
4384 }
4385 } else
4386 llvm_unreachable("Function cannot have a template specialization kind");
4387}
4388
4391 = TemplateOrSpecialization.dyn_cast<
4393 return FTSInfo->getPointOfInstantiation();
4394 if (MemberSpecializationInfo *MSInfo =
4395 TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo *>())
4396 return MSInfo->getPointOfInstantiation();
4397
4398 return SourceLocation();
4399}
4400
4402 if (Decl::isOutOfLine())
4403 return true;
4404
4405 // If this function was instantiated from a member function of a
4406 // class template, check whether that member function was defined out-of-line.
4408 const FunctionDecl *Definition;
4409 if (FD->hasBody(Definition))
4410 return Definition->isOutOfLine();
4411 }
4412
4413 // If this function was instantiated from a function template,
4414 // check whether that function template was defined out-of-line.
4415 if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) {
4416 const FunctionDecl *Definition;
4417 if (FunTmpl->getTemplatedDecl()->hasBody(Definition))
4418 return Definition->isOutOfLine();
4419 }
4420
4421 return false;
4422}
4423
4425 return SourceRange(getOuterLocStart(), EndRangeLoc);
4426}
4427
4429 IdentifierInfo *FnInfo = getIdentifier();
4430
4431 if (!FnInfo)
4432 return 0;
4433
4434 // Builtin handling.
4435 switch (getBuiltinID()) {
4436 case Builtin::BI__builtin_memset:
4437 case Builtin::BI__builtin___memset_chk:
4438 case Builtin::BImemset:
4439 return Builtin::BImemset;
4440
4441 case Builtin::BI__builtin_memcpy:
4442 case Builtin::BI__builtin___memcpy_chk:
4443 case Builtin::BImemcpy:
4444 return Builtin::BImemcpy;
4445
4446 case Builtin::BI__builtin_mempcpy:
4447 case Builtin::BI__builtin___mempcpy_chk:
4448 case Builtin::BImempcpy:
4449 return Builtin::BImempcpy;
4450
4451 case Builtin::BI__builtin_memmove:
4452 case Builtin::BI__builtin___memmove_chk:
4453 case Builtin::BImemmove:
4454 return Builtin::BImemmove;
4455
4456 case Builtin::BIstrlcpy:
4457 case Builtin::BI__builtin___strlcpy_chk:
4458 return Builtin::BIstrlcpy;
4459
4460 case Builtin::BIstrlcat:
4461 case Builtin::BI__builtin___strlcat_chk:
4462 return Builtin::BIstrlcat;
4463
4464 case Builtin::BI__builtin_memcmp:
4465 case Builtin::BImemcmp:
4466 return Builtin::BImemcmp;
4467
4468 case Builtin::BI__builtin_bcmp:
4469 case Builtin::BIbcmp:
4470 return Builtin::BIbcmp;
4471
4472 case Builtin::BI__builtin_strncpy:
4473 case Builtin::BI__builtin___strncpy_chk:
4474 case Builtin::BIstrncpy:
4475 return Builtin::BIstrncpy;
4476
4477 case Builtin::BI__builtin_strncmp:
4478 case Builtin::BIstrncmp:
4479 return Builtin::BIstrncmp;
4480
4481 case Builtin::BI__builtin_strncasecmp:
4482 case Builtin::BIstrncasecmp:
4483 return Builtin::BIstrncasecmp;
4484
4485 case Builtin::BI__builtin_strncat:
4486 case Builtin::BI__builtin___strncat_chk:
4487 case Builtin::BIstrncat:
4488 return Builtin::BIstrncat;
4489
4490 case Builtin::BI__builtin_strndup:
4491 case Builtin::BIstrndup:
4492 return Builtin::BIstrndup;
4493
4494 case Builtin::BI__builtin_strlen:
4495 case Builtin::BIstrlen:
4496 return Builtin::BIstrlen;
4497
4498 case Builtin::BI__builtin_bzero:
4499 case Builtin::BIbzero:
4500 return Builtin::BIbzero;
4501
4502 case Builtin::BI__builtin_bcopy:
4503 case Builtin::BIbcopy:
4504 return Builtin::BIbcopy;
4505
4506 case Builtin::BIfree:
4507 return Builtin::BIfree;
4508
4509 default:
4510 if (isExternC()) {
4511 if (FnInfo->isStr("memset"))
4512 return Builtin::BImemset;
4513 if (FnInfo->isStr("memcpy"))
4514 return Builtin::BImemcpy;
4515 if (FnInfo->isStr("mempcpy"))
4516 return Builtin::BImempcpy;
4517 if (FnInfo->isStr("memmove"))
4518 return Builtin::BImemmove;
4519 if (FnInfo->isStr("memcmp"))
4520 return Builtin::BImemcmp;
4521 if (FnInfo->isStr("bcmp"))
4522 return Builtin::BIbcmp;
4523 if (FnInfo->isStr("strncpy"))
4524 return Builtin::BIstrncpy;
4525 if (FnInfo->isStr("strncmp"))
4526 return Builtin::BIstrncmp;
4527 if (FnInfo->isStr("strncasecmp"))
4528 return Builtin::BIstrncasecmp;
4529 if (FnInfo->isStr("strncat"))
4530 return Builtin::BIstrncat;
4531 if (FnInfo->isStr("strndup"))
4532 return Builtin::BIstrndup;
4533 if (FnInfo->isStr("strlen"))
4534 return Builtin::BIstrlen;
4535 if (FnInfo->isStr("bzero"))
4536 return Builtin::BIbzero;
4537 if (FnInfo->isStr("bcopy"))
4538 return Builtin::BIbcopy;
4539 } else if (isInStdNamespace()) {
4540 if (FnInfo->isStr("free"))
4541 return Builtin::BIfree;
4542 }
4543 break;
4544 }
4545 return 0;
4546}
4547
4549 assert(hasODRHash());
4550 return ODRHash;
4551}
4552
4554 if (hasODRHash())
4555 return ODRHash;
4556
4557 if (auto *FT = getInstantiatedFromMemberFunction()) {
4558 setHasODRHash(true);
4559 ODRHash = FT->getODRHash();
4560 return ODRHash;
4561 }
4562
4563 class ODRHash Hash;
4564 Hash.AddFunctionDecl(this);
4565 setHasODRHash(true);
4566 ODRHash = Hash.CalculateHash();
4567 return ODRHash;
4568}
4569
4570//===----------------------------------------------------------------------===//
4571// FieldDecl Implementation
4572//===----------------------------------------------------------------------===//
4573
4575 SourceLocation StartLoc, SourceLocation IdLoc,
4576 const IdentifierInfo *Id, QualType T,
4577 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
4578 InClassInitStyle InitStyle) {
4579 return new (C, DC) FieldDecl(Decl::Field, DC, StartLoc, IdLoc, Id, T, TInfo,
4580 BW, Mutable, InitStyle);
4581}
4582
4584 return new (C, ID) FieldDecl(Field, nullptr, SourceLocation(),
4585 SourceLocation(), nullptr, QualType(), nullptr,
4586 nullptr, false, ICIS_NoInit);
4587}
4588
4590 if (!isImplicit() || getDeclName())
4591 return false;
4592
4593 if (const auto *Record = getType()->getAs<RecordType>())
4594 return Record->getDecl()->isAnonymousStructOrUnion();
4595
4596 return false;
4597}
4598
4600 if (!hasInClassInitializer())
4601 return nullptr;
4602
4603 LazyDeclStmtPtr InitPtr = BitField ? InitAndBitWidth->Init : Init;
4604 return cast_if_present<Expr>(
4605 InitPtr.isOffset() ? InitPtr.get(getASTContext().getExternalSource())
4606 : InitPtr.get(nullptr));
4607}
4608
4610 setLazyInClassInitializer(LazyDeclStmtPtr(NewInit));
4611}
4612
4613void FieldDecl::setLazyInClassInitializer(LazyDeclStmtPtr NewInit) {
4615 if (BitField)
4616 InitAndBitWidth->Init = NewInit;
4617 else
4618 Init = NewInit;
4619}
4620
4622 assert(isBitField() && "not a bitfield");
4623 assert(isa<ConstantExpr>(getBitWidth()));
4624 assert(cast<ConstantExpr>(getBitWidth())->hasAPValueResult());
4625 assert(cast<ConstantExpr>(getBitWidth())->getAPValueResult().isInt());
4626 return cast<ConstantExpr>(getBitWidth())
4627 ->getAPValueResult()
4628 .getInt()
4629 .getZExtValue();
4630}
4631
4634 getBitWidthValue() == 0;
4635}
4636
4637bool FieldDecl::isZeroSize(const ASTContext &Ctx) const {
4639 return true;
4640
4641 // C++2a [intro.object]p7:
4642 // An object has nonzero size if it
4643 // -- is not a potentially-overlapping subobject, or
4644 if (!hasAttr<NoUniqueAddressAttr>())
4645 return false;
4646
4647 // -- is not of class type, or
4648 const auto *RT = getType()->getAs<RecordType>();
4649 if (!RT)
4650 return false;
4651 const RecordDecl *RD = RT->getDecl()->getDefinition();
4652 if (!RD) {
4653 assert(isInvalidDecl() && "valid field has incomplete type");
4654 return false;
4655 }
4656
4657 // -- [has] virtual member functions or virtual base classes, or
4658 // -- has subobjects of nonzero size or bit-fields of nonzero length
4659 const auto *CXXRD = cast<CXXRecordDecl>(RD);
4660 if (!CXXRD->isEmpty())
4661 return false;
4662
4663 // Otherwise, [...] the circumstances under which the object has zero size
4664 // are implementation-defined.
4665 if (!Ctx.getTargetInfo().getCXXABI().isMicrosoft())
4666 return true;
4667
4668 // MS ABI: has nonzero size if it is a class type with class type fields,
4669 // whether or not they have nonzero size
4670 return !llvm::any_of(CXXRD->fields(), [](const FieldDecl *Field) {
4671 return Field->getType()->getAs<RecordType>();
4672 });
4673}
4674
4676 return hasAttr<NoUniqueAddressAttr>() && getType()->getAsCXXRecordDecl();
4677}
4678
4679void FieldDecl::setCachedFieldIndex() const {
4680 assert(this == getCanonicalDecl() &&
4681 "should be called on the canonical decl");
4682
4683 unsigned Index = 0;
4684 const RecordDecl *RD = getParent()->getDefinition();
4685 assert(RD && "requested index for field of struct with no definition");
4686
4687 for (auto *Field : RD->fields()) {
4688 Field->getCanonicalDecl()->CachedFieldIndex = Index + 1;
4689 assert(Field->getCanonicalDecl()->CachedFieldIndex == Index + 1 &&
4690 "overflow in field numbering");
4691 ++Index;
4692 }
4693
4694 assert(CachedFieldIndex && "failed to find field in parent");
4695}
4696
4698 const Expr *FinalExpr = getInClassInitializer();
4699 if (!FinalExpr)
4700 FinalExpr = getBitWidth();
4701 if (FinalExpr)
4702 return SourceRange(getInnerLocStart(), FinalExpr->getEndLoc());
4704}
4705
4707 assert((getParent()->isLambda() || getParent()->isCapturedRecord()) &&
4708 "capturing type in non-lambda or captured record.");
4709 assert(StorageKind == ISK_NoInit && !BitField &&
4710 "bit-field or field with default member initializer cannot capture "
4711 "VLA type");
4712 StorageKind = ISK_CapturedVLAType;
4713 CapturedVLAType = VLAType;
4714}
4715
4716void FieldDecl::printName(raw_ostream &OS, const PrintingPolicy &Policy) const {
4717 // Print unnamed members using name of their type.
4719 this->getType().print(OS, Policy);
4720 return;
4721 }
4722 // Otherwise, do the normal printing.
4723 DeclaratorDecl::printName(OS, Policy);
4724}
4725
4727 const auto *CAT = getType()->getAs<CountAttributedType>();
4728 if (!CAT)
4729 return nullptr;
4730
4731 const auto *CountDRE = cast<DeclRefExpr>(CAT->getCountExpr());
4732 const auto *CountDecl = CountDRE->getDecl();
4733 if (const auto *IFD = dyn_cast<IndirectFieldDecl>(CountDecl))
4734 CountDecl = IFD->getAnonField();
4735
4736 return dyn_cast<FieldDecl>(CountDecl);
4737}
4738
4739//===----------------------------------------------------------------------===//
4740// TagDecl Implementation
4741//===----------------------------------------------------------------------===//
4742
4744 SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
4745 SourceLocation StartL)
4746 : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), redeclarable_base(C),
4747 TypedefNameDeclOrQualifier((TypedefNameDecl *)nullptr) {
4748 assert((DK != Enum || TK == TagTypeKind::Enum) &&
4749 "EnumDecl not matched with TagTypeKind::Enum");
4750 setPreviousDecl(PrevDecl);
4751 setTagKind(TK);
4752 setCompleteDefinition(false);
4753 setBeingDefined(false);
4755 setFreeStanding(false);
4757 TagDeclBits.IsThisDeclarationADemotedDefinition = false;
4758}
4759
4761 return getTemplateOrInnerLocStart(this);
4762}
4763
4765 SourceLocation RBraceLoc = BraceRange.getEnd();
4766 SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation();
4767 return SourceRange(getOuterLocStart(), E);
4768}
4769
4771
4773 TypedefNameDeclOrQualifier = TDD;
4774 if (const Type *T = getTypeForDecl()) {
4775 (void)T;
4776 assert(T->isLinkageValid());
4777 }
4778 assert(isLinkageValid());
4779}
4780
4782 setBeingDefined(true);
4783
4784 if (auto *D = dyn_cast<CXXRecordDecl>(this)) {
4785 struct CXXRecordDecl::DefinitionData *Data =
4786 new (getASTContext()) struct CXXRecordDecl::DefinitionData(D);
4787 for (auto *I : redecls())
4788 cast<CXXRecordDecl>(I)->DefinitionData = Data;
4789 }
4790}
4791
4793 assert((!isa<CXXRecordDecl>(this) ||
4794 cast<CXXRecordDecl>(this)->hasDefinition()) &&
4795 "definition completed but not started");
4796
4798 setBeingDefined(false);
4799
4801 L->CompletedTagDefinition(this);
4802}
4803
4806 return const_cast<TagDecl *>(this);
4807
4808 // If it's possible for us to have an out-of-date definition, check now.
4809 if (mayHaveOutOfDateDef()) {
4810 if (IdentifierInfo *II = getIdentifier()) {
4811 if (II->isOutOfDate()) {
4812 updateOutOfDate(*II);
4813 }
4814 }
4815 }
4816
4817 if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(this))
4818 return CXXRD->getDefinition();
4819
4820 for (auto *R : redecls())
4821 if (R->isCompleteDefinition())
4822 return R;
4823
4824 return nullptr;
4825}
4826
4828 if (QualifierLoc) {
4829 // Make sure the extended qualifier info is allocated.
4830 if (!hasExtInfo())
4831 TypedefNameDeclOrQualifier = new (getASTContext()) ExtInfo;
4832 // Set qualifier info.
4833 getExtInfo()->QualifierLoc = QualifierLoc;
4834 } else {
4835 // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
4836 if (hasExtInfo()) {
4837 if (getExtInfo()->NumTemplParamLists == 0) {
4838 getASTContext().Deallocate(getExtInfo());
4839 TypedefNameDeclOrQualifier = (TypedefNameDecl *)nullptr;
4840 }
4841 else
4842 getExtInfo()->QualifierLoc = QualifierLoc;
4843 }
4844 }
4845}
4846
4847void TagDecl::printName(raw_ostream &OS, const PrintingPolicy &Policy) const {
4849 // If the name is supposed to have an identifier but does not have one, then
4850 // the tag is anonymous and we should print it differently.
4851 if (Name.isIdentifier() && !Name.getAsIdentifierInfo()) {
4852 // If the caller wanted to print a qualified name, they've already printed
4853 // the scope. And if the caller doesn't want that, the scope information
4854 // is already printed as part of the type.
4855 PrintingPolicy Copy(Policy);
4856 Copy.SuppressScope = true;
4858 return;
4859 }
4860 // Otherwise, do the normal printing.
4861 Name.print(OS, Policy);
4862}
4863
4866 assert(!TPLists.empty());
4867 // Make sure the extended decl info is allocated.
4868 if (!hasExtInfo())
4869 // Allocate external info struct.
4870 TypedefNameDeclOrQualifier = new (getASTContext()) ExtInfo;
4871 // Set the template parameter lists info.
4872 getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
4873}
4874
4875//===----------------------------------------------------------------------===//
4876// EnumDecl Implementation
4877//===----------------------------------------------------------------------===//
4878
4879EnumDecl::EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
4880 SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
4881 bool Scoped, bool ScopedUsingClassTag, bool Fixed)
4882 : TagDecl(Enum, TagTypeKind::Enum, C, DC, IdLoc, Id, PrevDecl, StartLoc) {
4883 assert(Scoped || !ScopedUsingClassTag);
4884 IntegerType = nullptr;
4885 setNumPositiveBits(0);
4886 setNumNegativeBits(0);
4887 setScoped(Scoped);
4888 setScopedUsingClassTag(ScopedUsingClassTag);
4889 setFixed(Fixed);
4890 setHasODRHash(false);
4891 ODRHash = 0;
4892}
4893
4894void EnumDecl::anchor() {}
4895
4897 SourceLocation StartLoc, SourceLocation IdLoc,
4899 EnumDecl *PrevDecl, bool IsScoped,
4900 bool IsScopedUsingClassTag, bool IsFixed) {
4901 auto *Enum = new (C, DC) EnumDecl(C, DC, StartLoc, IdLoc, Id, PrevDecl,
4902 IsScoped, IsScopedUsingClassTag, IsFixed);
4903 Enum->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
4904 C.getTypeDeclType(Enum, PrevDecl);
4905 return Enum;
4906}
4907
4909 EnumDecl *Enum =
4910 new (C, ID) EnumDecl(C, nullptr, SourceLocation(), SourceLocation(),
4911 nullptr, nullptr, false, false, false);
4912 Enum->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
4913 return Enum;
4914}
4915
4917 if (const TypeSourceInfo *TI = getIntegerTypeSourceInfo())
4918 return TI->getTypeLoc().getSourceRange();
4919 return SourceRange();
4920}
4921
4923 QualType NewPromotionType,
4924 unsigned NumPositiveBits,
4925 unsigned NumNegativeBits) {
4926 assert(!isCompleteDefinition() && "Cannot redefine enums!");
4927 if (!IntegerType)
4928 IntegerType = NewType.getTypePtr();
4929 PromotionType = NewPromotionType;
4930 setNumPositiveBits(NumPositiveBits);
4931 setNumNegativeBits(NumNegativeBits);
4933}
4934
4936 if (const auto *A = getAttr<EnumExtensibilityAttr>())
4937 return A->getExtensibility() == EnumExtensibilityAttr::Closed;
4938 return true;
4939}
4940
4942 return isClosed() && hasAttr<FlagEnumAttr>();
4943}
4944
4946 return isClosed() && !hasAttr<FlagEnumAttr>();
4947}
4948
4951 return MSI->getTemplateSpecializationKind();
4952
4953 return TSK_Undeclared;
4954}
4955
4957 SourceLocation PointOfInstantiation) {
4959 assert(MSI && "Not an instantiated member enumeration?");
4961 if (TSK != TSK_ExplicitSpecialization &&
4962 PointOfInstantiation.isValid() &&
4964 MSI->setPointOfInstantiation(PointOfInstantiation);
4965}
4966
4969 if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
4971 while (auto *NewED = ED->getInstantiatedFromMemberEnum())
4972 ED = NewED;
4973 return getDefinitionOrSelf(ED);
4974 }
4975 }
4976
4978 "couldn't find pattern for enum instantiation");
4979 return nullptr;
4980}
4981
4983 if (SpecializationInfo)
4984 return cast<EnumDecl>(SpecializationInfo->getInstantiatedFrom());
4985
4986 return nullptr;
4987}
4988
4989void EnumDecl::setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
4991 assert(!SpecializationInfo && "Member enum is already a specialization");
4992 SpecializationInfo = new (C) MemberSpecializationInfo(ED, TSK);
4993}
4994
4996 if (hasODRHash())
4997 return ODRHash;
4998
4999 class ODRHash Hash;
5000 Hash.AddEnumDecl(this);
5001 setHasODRHash(true);
5002 ODRHash = Hash.CalculateHash();
5003 return ODRHash;
5004}
5005
5007 auto Res = TagDecl::getSourceRange();
5008 // Set end-point to enum-base, e.g. enum foo : ^bar
5009 if (auto *TSI = getIntegerTypeSourceInfo()) {
5010 // TagDecl doesn't know about the enum base.
5011 if (!getBraceRange().getEnd().isValid())
5012 Res.setEnd(TSI->getTypeLoc().getEndLoc());
5013 }
5014 return Res;
5015}
5016
5017void EnumDecl::getValueRange(llvm::APInt &Max, llvm::APInt &Min) const {
5018 unsigned Bitwidth = getASTContext().getIntWidth(getIntegerType());
5019 unsigned NumNegativeBits = getNumNegativeBits();
5020 unsigned NumPositiveBits = getNumPositiveBits();
5021
5022 if (NumNegativeBits) {
5023 unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
5024 Max = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
5025 Min = -Max;
5026 } else {
5027 Max = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
5028 Min = llvm::APInt::getZero(Bitwidth);
5029 }
5030}
5031
5032//===----------------------------------------------------------------------===//
5033// RecordDecl Implementation
5034//===----------------------------------------------------------------------===//
5035
5037 DeclContext *DC, SourceLocation StartLoc,
5039 RecordDecl *PrevDecl)
5040 : TagDecl(DK, TK, C, DC, IdLoc, Id, PrevDecl, StartLoc) {
5041 assert(classof(static_cast<Decl *>(this)) && "Invalid Kind!");
5044 setHasObjectMember(false);
5045 setHasVolatileMember(false);
5056 setIsRandomized(false);
5057 setODRHash(0);
5058}
5059
5061 SourceLocation StartLoc, SourceLocation IdLoc,
5062 IdentifierInfo *Id, RecordDecl* PrevDecl) {
5063 RecordDecl *R = new (C, DC) RecordDecl(Record, TK, C, DC,
5064 StartLoc, IdLoc, Id, PrevDecl);
5065 R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
5066
5067 C.getTypeDeclType(R, PrevDecl);
5068 return R;
5069}
5070
5072 GlobalDeclID ID) {
5073 RecordDecl *R = new (C, ID)
5075 SourceLocation(), nullptr, nullptr);
5076 R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
5077 return R;
5078}
5079
5081 return isImplicit() && getDeclName() && getDeclContext()->isRecord() &&
5082 cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName();
5083}
5084
5086 if (auto RD = dyn_cast<CXXRecordDecl>(this))
5087 return RD->isLambda();
5088 return false;
5089}
5090
5092 return hasAttr<CapturedRecordAttr>();
5093}
5094
5096 addAttr(CapturedRecordAttr::CreateImplicit(getASTContext()));
5097}
5098
5100 if (isUnion())
5101 return true;
5102
5103 if (const RecordDecl *Def = getDefinition()) {
5104 for (const FieldDecl *FD : Def->fields()) {
5105 const RecordType *RT = FD->getType()->getAs<RecordType>();
5106 if (RT && RT->getDecl()->isOrContainsUnion())
5107 return true;
5108 }
5109 }
5110
5111 return false;
5112}
5113
5116 LoadFieldsFromExternalStorage();
5117 // This is necessary for correctness for C++ with modules.
5118 // FIXME: Come up with a test case that breaks without definition.
5119 if (RecordDecl *D = getDefinition(); D && D != this)
5120 return D->field_begin();
5122}
5123
5124/// completeDefinition - Notes that the definition of this type is now
5125/// complete.
5127 assert(!isCompleteDefinition() && "Cannot redefine record!");
5129
5130 ASTContext &Ctx = getASTContext();
5131
5132 // Layouts are dumped when computed, so if we are dumping for all complete
5133 // types, we need to force usage to get types that wouldn't be used elsewhere.
5134 //
5135 // If the type is dependent, then we can't compute its layout because there
5136 // is no way for us to know the size or alignment of a dependent type. Also
5137 // ignore declarations marked as invalid since 'getASTRecordLayout()' asserts
5138 // on that.
5139 if (Ctx.getLangOpts().DumpRecordLayoutsComplete && !isDependentType() &&
5140 !isInvalidDecl())
5141 (void)Ctx.getASTRecordLayout(this);
5142}
5143
5144/// isMsStruct - Get whether or not this record uses ms_struct layout.
5145/// This which can be turned on with an attribute, pragma, or the
5146/// -mms-bitfields command-line option.
5148 return hasAttr<MSStructAttr>() || C.getLangOpts().MSBitfields == 1;
5149}
5150
5152 std::tie(FirstDecl, LastDecl) = DeclContext::BuildDeclChain(Decls, false);
5153 LastDecl->NextInContextAndBits.setPointer(nullptr);
5154 setIsRandomized(true);
5155}
5156
5157void RecordDecl::LoadFieldsFromExternalStorage() const {
5159 assert(hasExternalLexicalStorage() && Source && "No external storage?");
5160
5161 // Notify that we have a RecordDecl doing some initialization.
5162 ExternalASTSource::Deserializing TheFields(Source);
5163
5166 Source->FindExternalLexicalDecls(this, [](Decl::Kind K) {
5168 }, Decls);
5169
5170#ifndef NDEBUG
5171 // Check that all decls we got were FieldDecls.
5172 for (unsigned i=0, e=Decls.size(); i != e; ++i)
5173 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
5174#endif
5175
5176 if (Decls.empty())
5177 return;
5178
5179 auto [ExternalFirst, ExternalLast] =
5180 BuildDeclChain(Decls,
5181 /*FieldsAlreadyLoaded=*/false);
5182 ExternalLast->NextInContextAndBits.setPointer(FirstDecl);
5183 FirstDecl = ExternalFirst;
5184 if (!LastDecl)
5185 LastDecl = ExternalLast;
5186}
5187
5188bool RecordDecl::mayInsertExtraPadding(bool EmitRemark) const {
5189 ASTContext &Context = getASTContext();
5190 const SanitizerMask EnabledAsanMask = Context.getLangOpts().Sanitize.Mask &
5191 (SanitizerKind::Address | SanitizerKind::KernelAddress);
5192 if (!EnabledAsanMask || !Context.getLangOpts().SanitizeAddressFieldPadding)
5193 return false;
5194 const auto &NoSanitizeList = Context.getNoSanitizeList();
5195 const auto *CXXRD = dyn_cast<CXXRecordDecl>(this);
5196 // We may be able to relax some of these requirements.
5197 int ReasonToReject = -1;
5198 if (!CXXRD || CXXRD->isExternCContext())
5199 ReasonToReject = 0; // is not C++.
5200 else if (CXXRD->hasAttr<PackedAttr>())
5201 ReasonToReject = 1; // is packed.
5202 else if (CXXRD->isUnion())
5203 ReasonToReject = 2; // is a union.
5204 else if (CXXRD->isTriviallyCopyable())
5205 ReasonToReject = 3; // is trivially copyable.
5206 else if (CXXRD->hasTrivialDestructor())
5207 ReasonToReject = 4; // has trivial destructor.
5208 else if (CXXRD->isStandardLayout())
5209 ReasonToReject = 5; // is standard layout.
5210 else if (NoSanitizeList.containsLocation(EnabledAsanMask, getLocation(),
5211 "field-padding"))
5212 ReasonToReject = 6; // is in an excluded file.
5214 EnabledAsanMask, getQualifiedNameAsString(), "field-padding"))
5215 ReasonToReject = 7; // The type is excluded.
5216
5217 if (EmitRemark) {
5218 if (ReasonToReject >= 0)
5219 Context.getDiagnostics().Report(
5220 getLocation(),
5221 diag::remark_sanitize_address_insert_extra_padding_rejected)
5222 << getQualifiedNameAsString() << ReasonToReject;
5223 else
5224 Context.getDiagnostics().Report(
5225 getLocation(),
5226 diag::remark_sanitize_address_insert_extra_padding_accepted)
5228 }
5229 return ReasonToReject < 0;
5230}
5231
5233 for (const auto *I : fields()) {
5234 if (I->getIdentifier())
5235 return I;
5236
5237 if (const auto *RT = I->getType()->getAs<RecordType>())
5238 if (const FieldDecl *NamedDataMember =
5239 RT->getDecl()->findFirstNamedDataMember())
5240 return NamedDataMember;
5241 }
5242
5243 // We didn't find a named data member.
5244 return nullptr;
5245}
5246
5248 if (hasODRHash())
5249 return RecordDeclBits.ODRHash;
5250
5251 // Only calculate hash on first call of getODRHash per record.
5252 ODRHash Hash;
5253 Hash.AddRecordDecl(this);
5254 // For RecordDecl the ODRHash is stored in the remaining
5255 // bits of RecordDeclBits, adjust the hash to accommodate.
5256 static_assert(sizeof(Hash.CalculateHash()) * CHAR_BIT == 32);
5257 setODRHash(Hash.CalculateHash() >> (32 - NumOdrHashBits));
5258 return RecordDeclBits.ODRHash;
5259}
5260
5261//===----------------------------------------------------------------------===//
5262// BlockDecl Implementation
5263//===----------------------------------------------------------------------===//
5264
5266 : Decl(Block, DC, CaretLoc), DeclContext(Block) {
5267 setIsVariadic(false);
5268 setCapturesCXXThis(false);
5271 setDoesNotEscape(false);
5272 setCanAvoidCopyToHeap(false);
5273}
5274
5276 assert(!ParamInfo && "Already has param info!");
5277
5278 // Zero params -> null pointer.
5279 if (!NewParamInfo.empty()) {
5280 NumParams = NewParamInfo.size();
5281 ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()];
5282 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
5283 }
5284}
5285
5287 bool CapturesCXXThis) {
5288 this->setCapturesCXXThis(CapturesCXXThis);
5289 this->NumCaptures = Captures.size();
5290
5291 if (Captures.empty()) {
5292 this->Captures = nullptr;
5293 return;
5294 }
5295
5296 this->Captures = Captures.copy(Context).data();
5297}
5298
5299bool BlockDecl::capturesVariable(const VarDecl *variable) const {
5300 for (const auto &I : captures())
5301 // Only auto vars can be captured, so no redeclaration worries.
5302 if (I.getVariable() == variable)
5303 return true;
5304
5305 return false;
5306}
5307
5309 return SourceRange(getLocation(), Body ? Body->getEndLoc() : getLocation());
5310}
5311
5312//===----------------------------------------------------------------------===//
5313// Other Decl Allocation/Deallocation Method Implementations
5314//===----------------------------------------------------------------------===//
5315
5316void TranslationUnitDecl::anchor() {}
5317
5319 return new (C, (DeclContext *)nullptr) TranslationUnitDecl(C);
5320}
5321
5323 AnonymousNamespace = D;
5324
5325 if (ASTMutationListener *Listener = Ctx.getASTMutationListener())
5326 Listener->AddedAnonymousNamespace(this, D);
5327}
5328
5329void PragmaCommentDecl::anchor() {}
5330
5333 SourceLocation CommentLoc,
5334 PragmaMSCommentKind CommentKind,
5335 StringRef Arg) {
5336 PragmaCommentDecl *PCD =
5337 new (C, DC, additionalSizeToAlloc<char>(Arg.size() + 1))
5338 PragmaCommentDecl(DC, CommentLoc, CommentKind);
5339 memcpy(PCD->getTrailingObjects<char>(), Arg.data(), Arg.size());
5340 PCD->getTrailingObjects<char>()[Arg.size()] = '\0';
5341 return PCD;
5342}
5343
5346 unsigned ArgSize) {
5347 return new (C, ID, additionalSizeToAlloc<char>(ArgSize + 1))
5349}
5350
5351void PragmaDetectMismatchDecl::anchor() {}
5352
5355 SourceLocation Loc, StringRef Name,
5356 StringRef Value) {
5357 size_t ValueStart = Name.size() + 1;
5359 new (C, DC, additionalSizeToAlloc<char>(ValueStart + Value.size() + 1))
5360 PragmaDetectMismatchDecl(DC, Loc, ValueStart);
5361 memcpy(PDMD->getTrailingObjects<char>(), Name.data(), Name.size());
5362 PDMD->getTrailingObjects<char>()[Name.size()] = '\0';
5363 memcpy(PDMD->getTrailingObjects<char>() + ValueStart, Value.data(),
5364 Value.size());
5365 PDMD->getTrailingObjects<char>()[ValueStart + Value.size()] = '\0';
5366 return PDMD;
5367}
5368
5371 unsigned NameValueSize) {
5372 return new (C, ID, additionalSizeToAlloc<char>(NameValueSize + 1))
5374}
5375
5376void ExternCContextDecl::anchor() {}
5377
5379 TranslationUnitDecl *DC) {
5380 return new (C, DC) ExternCContextDecl(DC);
5381}
5382
5383void LabelDecl::anchor() {}
5384
5386 SourceLocation IdentL, IdentifierInfo *II) {
5387 return new (C, DC) LabelDecl(DC, IdentL, II, nullptr, IdentL);
5388}
5389
5391 SourceLocation IdentL, IdentifierInfo *II,
5392 SourceLocation GnuLabelL) {
5393 assert(GnuLabelL != IdentL && "Use this only for GNU local labels");
5394 return new (C, DC) LabelDecl(DC, IdentL, II, nullptr, GnuLabelL);
5395}
5396
5398 return new (C, ID) LabelDecl(nullptr, SourceLocation(), nullptr, nullptr,
5399 SourceLocation());
5400}
5401
5402void LabelDecl::setMSAsmLabel(StringRef Name) {
5403char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
5404 memcpy(Buffer, Name.data(), Name.size());
5405 Buffer[Name.size()] = '\0';
5406 MSAsmName = Buffer;
5407}
5408
5409void ValueDecl::anchor() {}
5410
5411bool ValueDecl::isWeak() const {
5412 auto *MostRecent = getMostRecentDecl();
5413 return MostRecent->hasAttr<WeakAttr>() ||
5414 MostRecent->hasAttr<WeakRefAttr>() || isWeakImported();
5415}
5416
5418 if (auto *Var = llvm::dyn_cast<VarDecl>(this))
5419 return Var->isInitCapture();
5420 return false;
5421}
5422
5423void ImplicitParamDecl::anchor() {}
5424
5426 SourceLocation IdLoc,
5428 ImplicitParamKind ParamKind) {
5429 return new (C, DC) ImplicitParamDecl(C, DC, IdLoc, Id, Type, ParamKind);
5430}
5431
5433 ImplicitParamKind ParamKind) {
5434 return new (C, nullptr) ImplicitParamDecl(C, Type, ParamKind);
5435}
5436
5438 GlobalDeclID ID) {
5440}
5441
5444 const DeclarationNameInfo &NameInfo, QualType T,
5445 TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin,
5446 bool isInlineSpecified, bool hasWrittenPrototype,
5447 ConstexprSpecKind ConstexprKind,
5448 Expr *TrailingRequiresClause) {
5449 FunctionDecl *New = new (C, DC) FunctionDecl(
5450 Function, C, DC, StartLoc, NameInfo, T, TInfo, SC, UsesFPIntrin,
5451 isInlineSpecified, ConstexprKind, TrailingRequiresClause);
5453 return New;
5454}
5455
5457 return new (C, ID) FunctionDecl(
5459 nullptr, SC_None, false, false, ConstexprSpecKind::Unspecified, nullptr);
5460}
5461
5463 return new (C, DC) BlockDecl(DC, L);
5464}
5465
5467 return new (C, ID) BlockDecl(nullptr, SourceLocation());
5468}
5469
5470OutlinedFunctionDecl::OutlinedFunctionDecl(DeclContext *DC, unsigned NumParams)
5471 : Decl(OutlinedFunction, DC, SourceLocation()),
5472 DeclContext(OutlinedFunction), NumParams(NumParams),
5473 BodyAndNothrow(nullptr, false) {}
5474
5476 DeclContext *DC,
5477 unsigned NumParams) {
5478 return new (C, DC, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5479 OutlinedFunctionDecl(DC, NumParams);
5480}
5481
5484 unsigned NumParams) {
5485 return new (C, ID, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5486 OutlinedFunctionDecl(nullptr, NumParams);
5487}
5488
5490 return BodyAndNothrow.getPointer();
5491}
5492void OutlinedFunctionDecl::setBody(Stmt *B) { BodyAndNothrow.setPointer(B); }
5493
5494bool OutlinedFunctionDecl::isNothrow() const { return BodyAndNothrow.getInt(); }
5496 BodyAndNothrow.setInt(Nothrow);
5497}
5498
5499CapturedDecl::CapturedDecl(DeclContext *DC, unsigned NumParams)
5500 : Decl(Captured, DC, SourceLocation()), DeclContext(Captured),
5501 NumParams(NumParams), ContextParam(0), BodyAndNothrow(nullptr, false) {}
5502
5504 unsigned NumParams) {
5505 return new (C, DC, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5506 CapturedDecl(DC, NumParams);
5507}
5508
5510 unsigned NumParams) {
5511 return new (C, ID, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
5512 CapturedDecl(nullptr, NumParams);
5513}
5514
5515Stmt *CapturedDecl::getBody() const { return BodyAndNothrow.getPointer(); }
5516void CapturedDecl::setBody(Stmt *B) { BodyAndNothrow.setPointer(B); }
5517
5518bool CapturedDecl::isNothrow() const { return BodyAndNothrow.getInt(); }
5519void CapturedDecl::setNothrow(bool Nothrow) { BodyAndNothrow.setInt(Nothrow); }
5520
5523 QualType T, Expr *E, const llvm::APSInt &V)
5524 : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt *)E) {
5525 setInitVal(C, V);
5526}
5527
5531 Expr *E, const llvm::APSInt &V) {
5532 return new (C, CD) EnumConstantDecl(C, CD, L, Id, T, E, V);
5533}
5534
5536 GlobalDeclID ID) {
5537 return new (C, ID) EnumConstantDecl(C, nullptr, SourceLocation(), nullptr,
5538 QualType(), nullptr, llvm::APSInt());
5539}
5540
5541void IndirectFieldDecl::anchor() {}
5542
5543IndirectFieldDecl::IndirectFieldDecl(ASTContext &C, DeclContext *DC,
5545 QualType T,
5547 : ValueDecl(IndirectField, DC, L, N, T), Chaining(CH.data()),
5548 ChainingSize(CH.size()) {
5549 // In C++, indirect field declarations conflict with tag declarations in the
5550 // same scope, so add them to IDNS_Tag so that tag redeclaration finds them.
5551 if (C.getLangOpts().CPlusPlus)
5553}
5554
5557 const IdentifierInfo *Id, QualType T,
5559 return new (C, DC) IndirectFieldDecl(C, DC, L, Id, T, CH);
5560}
5561
5563 GlobalDeclID ID) {
5564 return new (C, ID) IndirectFieldDecl(C, nullptr, SourceLocation(),
5565 DeclarationName(), QualType(), {});
5566}
5567
5570 if (Init)
5571 End = Init->getEndLoc();
5572 return SourceRange(getLocation(), End);
5573}
5574
5575void TypeDecl::anchor() {}
5576
5578 SourceLocation StartLoc, SourceLocation IdLoc,
5579 const IdentifierInfo *Id,
5580 TypeSourceInfo *TInfo) {
5581 return new (C, DC) TypedefDecl(C, DC, StartLoc, IdLoc, Id, TInfo);
5582}
5583
5584void TypedefNameDecl::anchor() {}
5585
5587 if (auto *TT = getTypeSourceInfo()->getType()->getAs<TagType>()) {
5588 auto *OwningTypedef = TT->getDecl()->getTypedefNameForAnonDecl();
5589 auto *ThisTypedef = this;
5590 if (AnyRedecl && OwningTypedef) {
5591 OwningTypedef = OwningTypedef->getCanonicalDecl();
5592 ThisTypedef = ThisTypedef->getCanonicalDecl();
5593 }
5594 if (OwningTypedef == ThisTypedef)
5595 return TT->getDecl();
5596 }
5597
5598 return nullptr;
5599}
5600
5601bool TypedefNameDecl::isTransparentTagSlow() const {
5602 auto determineIsTransparent = [&]() {
5603 if (auto *TT = getUnderlyingType()->getAs<TagType>()) {
5604 if (auto *TD = TT->getDecl()) {
5605 if (TD->getName() != getName())
5606 return false;
5607 SourceLocation TTLoc = getLocation();
5608 SourceLocation TDLoc = TD->getLocation();
5609 if (!TTLoc.isMacroID() || !TDLoc.isMacroID())
5610 return false;
5612 return SM.getSpellingLoc(TTLoc) == SM.getSpellingLoc(TDLoc);
5613 }
5614 }
5615 return false;
5616 };
5617
5618 bool isTransparent = determineIsTransparent();
5619 MaybeModedTInfo.setInt((isTransparent << 1) | 1);
5620 return isTransparent;
5621}
5622
5624 return new (C, ID) TypedefDecl(C, nullptr, SourceLocation(), SourceLocation(),
5625 nullptr, nullptr);
5626}
5627
5629 SourceLocation StartLoc,
5630 SourceLocation IdLoc,
5631 const IdentifierInfo *Id,
5632 TypeSourceInfo *TInfo) {
5633 return new (C, DC) TypeAliasDecl(C, DC, StartLoc, IdLoc, Id, TInfo);
5634}
5635
5637 GlobalDeclID ID) {
5638 return new (C, ID) TypeAliasDecl(C, nullptr, SourceLocation(),
5639 SourceLocation(), nullptr, nullptr);
5640}
5641
5643 SourceLocation RangeEnd = getLocation();
5644 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
5645 if (typeIsPostfix(TInfo->getType()))
5646 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
5647 }
5648 return SourceRange(getBeginLoc(), RangeEnd);
5649}
5650
5652 SourceLocation RangeEnd = getBeginLoc();
5653 if (TypeSourceInfo *TInfo = getTypeSourceInfo())
5654 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
5655 return SourceRange(getBeginLoc(), RangeEnd);
5656}
5657
5658void FileScopeAsmDecl::anchor() {}
5659
5661 StringLiteral *Str,
5662 SourceLocation AsmLoc,
5663 SourceLocation RParenLoc) {
5664 return new (C, DC) FileScopeAsmDecl(DC, Str, AsmLoc, RParenLoc);
5665}
5666
5668 GlobalDeclID ID) {
5669 return new (C, ID) FileScopeAsmDecl(nullptr, nullptr, SourceLocation(),
5670 SourceLocation());
5671}
5672
5673void TopLevelStmtDecl::anchor() {}
5674
5676 assert(C.getLangOpts().IncrementalExtensions &&
5677 "Must be used only in incremental mode");
5678
5679 SourceLocation Loc = Statement ? Statement->getBeginLoc() : SourceLocation();
5680 DeclContext *DC = C.getTranslationUnitDecl();
5681
5682 return new (C, DC) TopLevelStmtDecl(DC, Loc, Statement);
5683}
5684
5686 GlobalDeclID ID) {
5687 return new (C, ID)
5688 TopLevelStmtDecl(/*DC=*/nullptr, SourceLocation(), /*S=*/nullptr);
5689}
5690
5692 return SourceRange(getLocation(), Statement->getEndLoc());
5693}
5694
5696 assert(S);
5697 Statement = S;
5698 setLocation(Statement->getBeginLoc());
5699}
5700
5701void EmptyDecl::anchor() {}
5702
5704 return new (C, DC) EmptyDecl(DC, L);
5705}
5706
5708 return new (C, ID) EmptyDecl(nullptr, SourceLocation());
5709}
5710
5711HLSLBufferDecl::HLSLBufferDecl(DeclContext *DC, bool CBuffer,
5713 SourceLocation IDLoc, SourceLocation LBrace)
5714 : NamedDecl(Decl::Kind::HLSLBuffer, DC, IDLoc, DeclarationName(ID)),
5715 DeclContext(Decl::Kind::HLSLBuffer), LBraceLoc(LBrace), KwLoc(KwLoc),
5716 IsCBuffer(CBuffer) {}
5717
5719 DeclContext *LexicalParent, bool CBuffer,
5721 SourceLocation IDLoc,
5722 SourceLocation LBrace) {
5723 // For hlsl like this
5724 // cbuffer A {
5725 // cbuffer B {
5726 // }
5727 // }
5728 // compiler should treat it as
5729 // cbuffer A {
5730 // }
5731 // cbuffer B {
5732 // }
5733 // FIXME: support nested buffers if required for back-compat.
5734 DeclContext *DC = LexicalParent;
5736 new (C, DC) HLSLBufferDecl(DC, CBuffer, KwLoc, ID, IDLoc, LBrace);
5737 return Result;
5738}
5739
5741 GlobalDeclID ID) {
5742 return new (C, ID) HLSLBufferDecl(nullptr, false, SourceLocation(), nullptr,
5744}
5745
5746//===----------------------------------------------------------------------===//
5747// ImportDecl Implementation
5748//===----------------------------------------------------------------------===//
5749
5750/// Retrieve the number of module identifiers needed to name the given
5751/// module.
5752static unsigned getNumModuleIdentifiers(Module *Mod) {
5753 unsigned Result = 1;
5754 while (Mod->Parent) {
5755 Mod = Mod->Parent;
5756 ++Result;
5757 }
5758 return Result;
5759}
5760
5761ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
5762 Module *Imported,
5763 ArrayRef<SourceLocation> IdentifierLocs)
5764 : Decl(Import, DC, StartLoc), ImportedModule(Imported),
5765 NextLocalImportAndComplete(nullptr, true) {
5766 assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size());
5767 auto *StoredLocs = getTrailingObjects<SourceLocation>();
5768 std::uninitialized_copy(IdentifierLocs.begin(), IdentifierLocs.end(),
5769 StoredLocs);
5770}
5771
5772ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
5773 Module *Imported, SourceLocation EndLoc)
5774 : Decl(Import, DC, StartLoc), ImportedModule(Imported),
5775 NextLocalImportAndComplete(nullptr, false) {
5776 *getTrailingObjects<SourceLocation>() = EndLoc;
5777}
5778
5780 SourceLocation StartLoc, Module *Imported,
5781 ArrayRef<SourceLocation> IdentifierLocs) {
5782 return new (C, DC,
5783 additionalSizeToAlloc<SourceLocation>(IdentifierLocs.size()))
5784 ImportDecl(DC, StartLoc, Imported, IdentifierLocs);
5785}
5786
5788 SourceLocation StartLoc,
5789 Module *Imported,
5790 SourceLocation EndLoc) {
5791 ImportDecl *Import = new (C, DC, additionalSizeToAlloc<SourceLocation>(1))
5792 ImportDecl(DC, StartLoc, Imported, EndLoc);
5793 Import->setImplicit();
5794 return Import;
5795}
5796
5798 unsigned NumLocations) {
5799 return new (C, ID, additionalSizeToAlloc<SourceLocation>(NumLocations))
5801}
5802
5804 if (!isImportComplete())
5805 return {};
5806
5807 const auto *StoredLocs = getTrailingObjects<SourceLocation>();
5808 return llvm::ArrayRef(StoredLocs,
5810}
5811
5813 if (!isImportComplete())
5814 return SourceRange(getLocation(), *getTrailingObjects<SourceLocation>());
5815
5816 return SourceRange(getLocation(), getIdentifierLocs().back());
5817}
5818
5819//===----------------------------------------------------------------------===//
5820// ExportDecl Implementation
5821//===----------------------------------------------------------------------===//
5822
5823void ExportDecl::anchor() {}
5824
5826 SourceLocation ExportLoc) {
5827 return new (C, DC) ExportDecl(DC, ExportLoc);
5828}
5829
5831 return new (C, ID) ExportDecl(nullptr, SourceLocation());
5832}
5833
5835 bool IncludeLocallyStreaming) {
5836 if (IncludeLocallyStreaming)
5837 if (FD->hasAttr<ArmLocallyStreamingAttr>())
5838 return true;
5839
5840 if (const Type *Ty = FD->getType().getTypePtrOrNull())
5841 if (const auto *FPT = Ty->getAs<FunctionProtoType>())
5842 if (FPT->getAArch64SMEAttributes() &
5844 return true;
5845
5846 return false;
5847}
Defines the clang::ASTContext interface.
#define V(N, I)
Definition: ASTContext.h:3460
NodeId Parent
Definition: ASTDiff.cpp:191
This file provides some common utility functions for processing Lambda related AST Constructs.
StringRef P
static char ID
Definition: Arena.cpp:183
#define SM(sm)
Definition: Cuda.cpp:85
Defines enum values for all the target-independent builtin functions.
const Decl * D
enum clang::sema::@1727::IndirectLocalPathEntry::EntryKind Kind
Expr * E
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
static bool isFirstInExternCContext(T *D)
Definition: Decl.cpp:574
static bool isRedeclarableImpl(Redeclarable< T > *)
Definition: Decl.cpp:1827
static bool isDeclExternC(const T &D)
Definition: Decl.cpp:2218
static bool hasExplicitVisibilityAlready(LVComputationKind computation)
Does this computation kind permit us to consider additional visibility settings from attributes and t...
Definition: Decl.cpp:159
static bool RedeclForcesDefC99(const FunctionDecl *Redecl)
Definition: Decl.cpp:3810
static bool isExportedFromModuleInterfaceUnit(const NamedDecl *D)
Definition: Decl.cpp:1184
static bool isRedeclarable(Decl::Kind K)
Definition: Decl.cpp:1831
static bool redeclForcesDefMSVC(const FunctionDecl *Redecl)
Definition: Decl.cpp:3798
static bool usesTypeVisibility(const NamedDecl *D)
Is the given declaration a "type" or a "value" for the purposes of visibility computation?
Definition: Decl.cpp:180
static std::optional< Visibility > getVisibilityOf(const NamedDecl *D, NamedDecl::ExplicitVisibilityKind kind)
Return the explicit visibility of the given declaration.
Definition: Decl.cpp:222
static LanguageLinkage getDeclLanguageLinkage(const T &D)
Definition: Decl.cpp:2191
static LVComputationKind withExplicitVisibilityAlready(LVComputationKind Kind)
Given an LVComputationKind, return one of the same type/value sort that records that it already has e...
Definition: Decl.cpp:166
static std::enable_if_t<!std::is_base_of_v< RedeclarableTemplateDecl, T >, bool > isExplicitMemberSpecialization(const T *D)
Does the given declaration have member specialization information, and if so, is it an explicit speci...
Definition: Decl.cpp:190
static unsigned getNumModuleIdentifiers(Module *Mod)
Retrieve the number of module identifiers needed to name the given module.
Definition: Decl.cpp:5752
static bool isSingleLineLanguageLinkage(const Decl &D)
Definition: Decl.cpp:579
static bool useInlineVisibilityHidden(const NamedDecl *D)
Definition: Decl.cpp:546
static bool shouldConsiderTemplateVisibility(const FunctionDecl *fn, const FunctionTemplateSpecializationInfo *specInfo)
Definition: Decl.cpp:373
static bool hasDirectVisibilityAttribute(const NamedDecl *D, LVComputationKind computation)
Does the given declaration have a direct visibility attribute that would match the given rules?
Definition: Decl.cpp:419
static DeclT * getDefinitionOrSelf(DeclT *D)
Definition: Decl.cpp:2667
static Visibility getVisibilityFromAttr(const T *attr)
Given a visibility attribute, return the explicit visibility associated with it.
Definition: Decl.cpp:208
static const Decl * getOutermostFuncOrBlockContext(const Decl *D)
Definition: Decl.cpp:302
static bool typeIsPostfix(QualType QT)
Definition: Decl.cpp:2045
static LinkageInfo getExternalLinkageFor(const NamedDecl *D)
Definition: Decl.cpp:586
static StorageClass getStorageClass(const Decl *D)
Definition: Decl.cpp:590
static std::optional< Visibility > getExplicitVisibilityAux(const NamedDecl *ND, NamedDecl::ExplicitVisibilityKind kind, bool IsMostRecent)
Definition: Decl.cpp:1225
static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl)
Definition: Decl.cpp:1971
static bool isNamed(const NamedDecl *ND, const char(&Str)[Len])
Definition: Decl.cpp:3270
static std::optional< Visibility > getExplicitVisibility(const NamedDecl *D, LVComputationKind kind)
Definition: Decl.cpp:171
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
llvm::MachO::Record Record
Definition: MachO.h:31
Defines the clang::Module class, which describes a module in the source code.
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes,...
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream.
static std::string getName(const CallEvent &Call)
Defines the clang::SanitizerKind enum.
uint32_t Id
Definition: SemaARM.cpp:1136
SourceLocation Loc
Definition: SemaObjC.cpp:759
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines various enumerations that describe declaration and type specifiers.
Defines the TargetCXXABI class, which abstracts details of the C++ ABI that we're targeting.
Defines the clang::TypeLoc interface and its subclasses.
C Language Family Type Representation.
static const TypeInfo & getInfo(unsigned id)
Definition: Types.cpp:44
SourceLocation Begin
Defines the clang::Visibility enumeration and various utility functions.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
bool isAbsent() const
Definition: APValue.h:463
bool needsCleanup() const
Returns whether the object performed allocations.
Definition: APValue.cpp:438
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:188
SourceManager & getSourceManager()
Definition: ASTContext.h:741
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2922
unsigned getIntWidth(QualType T) const
void setTemplateOrSpecializationInfo(VarDecl *Inst, TemplateOrSpecializationInfo TSI)
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
ASTMutationListener * getASTMutationListener() const
Retrieve a pointer to the AST mutation listener associated with this AST context, if any.
Definition: ASTContext.h:1289
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2739
CanQualType VoidPtrTy
Definition: ASTContext.h:1187
void Deallocate(void *Ptr) const
Definition: ASTContext.h:760
Builtin::Context & BuiltinInfo
Definition: ASTContext.h:682
const LangOptions & getLangOpts() const
Definition: ASTContext.h:834
void setParameterIndex(const ParmVarDecl *D, unsigned index)
Used by ParmVarDecl to store on the side the index of the parameter when it exceeds the size of the n...
Decl * getPrimaryMergedDecl(Decl *D)
Definition: ASTContext.h:1097
const NoSanitizeList & getNoSanitizeList() const
Definition: ASTContext.h:844
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:733
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:754
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Note that the static data member Inst is an instantiation of the static data member template Tmpl of ...
DiagnosticsEngine & getDiagnostics() const
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:799
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void addDestruction(T *Ptr) const
If T isn't trivially destructible, calls AddDeallocation to register it for destruction.
Definition: ASTContext.h:3268
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1274
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
unsigned getParameterIndex(const ParmVarDecl *D) const
Used by ParmVarDecl to retrieve on the side the index of the parameter when it exceeds the size of th...
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:38
CharUnits getSize() const
getSize - Get the record size in characters.
Definition: RecordLayout.h:193
unsigned getFieldCount() const
getFieldCount - Get the number of fields in the layout.
Definition: RecordLayout.h:196
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:200
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4496
BlockDecl(DeclContext *DC, SourceLocation CaretLoc)
Definition: Decl.cpp:5265
void setParams(ArrayRef< ParmVarDecl * > NewParamInfo)
Definition: Decl.cpp:5275
void setDoesNotEscape(bool B=true)
Definition: Decl.h:4648
void setCapturesCXXThis(bool B=true)
Definition: Decl.h:4629
void setCanAvoidCopyToHeap(bool B=true)
Definition: Decl.h:4653
void setIsConversionFromLambda(bool val=true)
Definition: Decl.h:4643
void setBlockMissingReturnType(bool val=true)
Definition: Decl.h:4635
ArrayRef< Capture > captures() const
Definition: Decl.h:4623
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:5308
static BlockDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5466
void setIsVariadic(bool value)
Definition: Decl.h:4572
bool capturesVariable(const VarDecl *var) const
Definition: Decl.cpp:5299
void setCaptures(ASTContext &Context, ArrayRef< Capture > Captures, bool CapturesCXXThis)
Definition: Decl.cpp:5286
static BlockDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:5462
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc",...
Definition: Builtins.h:161
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
CXXRecordDecl * getInstantiatedFromMemberClass() const
If this record is an instantiation of a member class, retrieves the member class from which it was in...
Definition: DeclCXX.cpp:1982
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4772
void setBody(Stmt *B)
Definition: Decl.cpp:5516
static CapturedDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumParams)
Definition: Decl.cpp:5509
bool isNothrow() const
Definition: Decl.cpp:5518
void setNothrow(bool Nothrow=true)
Definition: Decl.cpp:5519
static CapturedDecl * Create(ASTContext &C, DeclContext *DC, unsigned NumParams)
Definition: Decl.cpp:5503
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.cpp:5515
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
Declaration of a class template.
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
Represents a class template specialization, which refers to a class template with a given set of temp...
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
bool isZeroSize() const
Return true if the size is zero.
Definition: Type.h:3686
Represents a sugar type with __counted_by or __sized_by annotations, including their _or_null variant...
Definition: Type.h:3307
A POD class for pairing a NamedDecl* with an access specifier.
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:2321
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition: DeclBase.h:2384
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1439
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:2104
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
Definition: DeclBase.h:2233
FunctionDeclBitfields FunctionDeclBits
Definition: DeclBase.h:2039
bool isFileContext() const
Definition: DeclBase.h:2175
static std::pair< Decl *, Decl * > BuildDeclChain(ArrayRef< Decl * > Decls, bool FieldsAlreadyLoaded)
Build up a chain of declarations.
Definition: DeclBase.cpp:1537
TagDeclBitfields TagDeclBits
Definition: DeclBase.h:2035
bool isExternCXXContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:1411
bool isNamespace() const
Definition: DeclBase.h:2193
bool isTranslationUnit() const
Definition: DeclBase.h:2180
bool isRecord() const
Definition: DeclBase.h:2184
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:2010
RecordDeclBitfields RecordDeclBits
Definition: DeclBase.h:2037
Decl * FirstDecl
FirstDecl - The first declaration stored within this declaration context.
Definition: DeclBase.h:2074
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:2679
Decl * LastDecl
LastDecl - The last declaration stored within this declaration context.
Definition: DeclBase.h:2080
bool isFunctionOrMethod() const
Definition: DeclBase.h:2156
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:1396
Decl::Kind getDeclKind() const
Definition: DeclBase.h:2097
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Definition: DeclBase.h:1054
bool isInStdNamespace() const
Definition: DeclBase.cpp:430
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
Definition: DeclBase.h:1219
T * getAttr() const
Definition: DeclBase.h:576
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:528
void addAttr(Attr *A)
Definition: DeclBase.cpp:1019
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:596
bool isInNamedModule() const
Whether this declaration comes from a named module.
Definition: DeclBase.cpp:1173
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:99
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition: DeclBase.cpp:848
ModuleOwnershipKind getModuleOwnershipKind() const
Get the kind of module ownership for this declaration.
Definition: DeclBase.h:869
ASTMutationListener * getASTMutationListener() const
Definition: DeclBase.cpp:538
bool hasCachedLinkage() const
Definition: DeclBase.h:424
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
@ FOK_None
Not a friend object.
Definition: DeclBase.h:1210
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:977
llvm::PointerIntPair< Decl *, 3, ModuleOwnershipKind > NextInContextAndBits
The next declaration within the same lexical DeclContext.
Definition: DeclBase.h:249
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition: DeclBase.h:835
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:254
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:786
Linkage getCachedLinkage() const
Definition: DeclBase.h:416
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:2784
bool isInvalidDecl() const
Definition: DeclBase.h:591
bool hasDefiningAttr() const
Return true if this declaration has an attribute which acts as definition of the entity,...
Definition: DeclBase.cpp:615
SourceLocation getLocation() const
Definition: DeclBase.h:442
IdentifierNamespace
IdentifierNamespace - The different namespaces in which declarations may appear.
Definition: DeclBase.h:115
@ IDNS_Tag
Tags, declared with 'struct foo;' and referenced with 'struct foo'.
Definition: DeclBase.h:125
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:1042
void setLocation(SourceLocation L)
Definition: DeclBase.h:443
DeclContext * getDeclContext()
Definition: DeclBase.h:451
bool isInAnonymousNamespace() const
Definition: DeclBase.cpp:420
void setCachedLinkage(Linkage L) const
Definition: DeclBase.h:420
friend class RecordDecl
Definition: DeclBase.h:330
void updateOutOfDate(IdentifierInfo &II) const
Update a potentially out-of-date declaration.
Definition: DeclBase.cpp:60
Module * getOwningModuleForLinkage() const
Get the module that owns this declaration for linkage purposes.
Definition: Decl.cpp:1624
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition: DeclBase.h:911
bool hasAttr() const
Definition: DeclBase.h:580
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:971
@ VisibleWhenImported
This declaration has an owning module, and is visible when that module is imported.
@ Unowned
This declaration is not owned by a module.
@ ReachableWhenImported
This declaration has an owning module, and is visible to lookups that occurs within that module.
@ ModulePrivate
This declaration has an owning module, but is only visible to lookups that occur within that module.
@ Visible
This declaration has an owning module, but is globally visible (typically because its owning module i...
Kind getKind() const
Definition: DeclBase.h:445
const LangOptions & getLangOpts() const LLVM_READONLY
Helper to get the language options from the ASTContext.
Definition: DeclBase.cpp:534
The name of a declaration.
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
const IdentifierInfo * getCXXLiteralIdentifier() const
If this name is the name of a literal operator, retrieve the identifier associated with it.
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:735
SourceLocation getTypeSpecEndLoc() const
Definition: Decl.cpp:1983
SourceLocation getInnerLocStart() const
Return start of source range ignoring outer template declarations.
Definition: Decl.h:777
SourceLocation getOuterLocStart() const
Return start of source range taking into account any outer template declarations.
Definition: Decl.cpp:2039
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2079
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1977
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:786
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:1989
void setTrailingRequiresClause(Expr *TrailingRequiresClause)
Definition: Decl.cpp:2008
Expr * getTrailingRequiresClause()
Get the constraint-expression introduced by the trailing requires-clause in the function/member decla...
Definition: Decl.h:810
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:764
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Definition: Decl.cpp:2023
Provides information about a dependent function-template specialization declaration.
Definition: DeclTemplate.h:693
static DependentFunctionTemplateSpecializationInfo * Create(ASTContext &Context, const UnresolvedSetImpl &Candidates, const TemplateArgumentListInfo *TemplateArgs)
Definition: Decl.cpp:4269
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1493
Represents an empty-declaration.
Definition: Decl.h:5011
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:5703
static EmptyDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5707
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:3291
EnumConstantDecl(const ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
Definition: Decl.cpp:5521
static EnumConstantDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5535
void setInitVal(const ASTContext &C, const llvm::APSInt &V)
Definition: Decl.h:3316
static EnumConstantDecl * Create(ASTContext &C, EnumDecl *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
Definition: Decl.cpp:5528
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:5568
Represents an enum.
Definition: Decl.h:3861
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization,...
Definition: Decl.h:4120
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
Definition: Decl.h:4058
unsigned getODRHash()
Definition: Decl.cpp:4995
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class,...
Definition: Decl.cpp:4956
static EnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl, bool IsScoped, bool IsScopedUsingClassTag, bool IsFixed)
Definition: Decl.cpp:4896
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists,...
Definition: Decl.h:4037
static EnumDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:4908
bool isClosedFlag() const
Returns true if this enum is annotated with flag_enum and isn't annotated with enum_extensibility(ope...
Definition: Decl.cpp:4941
SourceRange getIntegerTypeRange() const LLVM_READONLY
Retrieve the source range that covers the underlying type if specified.
Definition: Decl.cpp:4916
SourceRange getSourceRange() const override LLVM_READONLY
Overrides to provide correct range when there's an enum-base specifier with forward declarations.
Definition: Decl.cpp:5006
QualType getIntegerType() const
Return the integer type this enum decl corresponds to.
Definition: Decl.h:4021
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:4982
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum.
Definition: Decl.h:4047
TemplateSpecializationKind getTemplateSpecializationKind() const
If this enumeration is a member of a specialization of a templated class, determine what kind of temp...
Definition: Decl.cpp:4949
bool isClosed() const
Returns true if this enum is either annotated with enum_extensibility(closed) or isn't annotated with...
Definition: Decl.cpp:4935
EnumDecl * getTemplateInstantiationPattern() const
Retrieve the enum definition from which this enumeration could be instantiated, if it is an instantia...
Definition: Decl.cpp:4967
bool isClosedNonFlag() const
Returns true if this enum is annotated with neither flag_enum nor enum_extensibility(open).
Definition: Decl.cpp:4945
void getValueRange(llvm::APInt &Max, llvm::APInt &Min) const
Calculates the [Min,Max) values the enum can store based on the NumPositiveBits and NumNegativeBits.
Definition: Decl.cpp:5017
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums.
Definition: Type.h:6104
Represents a standard C++ module export declaration.
Definition: Decl.h:4964
static ExportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExportLoc)
Definition: Decl.cpp:5825
static ExportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5830
This represents one expression.
Definition: Expr.h:110
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition: Expr.h:175
QualType getType() const
Definition: Expr.h:142
Declaration context for names declared as extern "C" in C++.
Definition: Decl.h:226
static ExternCContextDecl * Create(const ASTContext &C, TranslationUnitDecl *TU)
Definition: Decl.cpp:5378
RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.
Abstract interface for external sources of AST nodes.
virtual void FindExternalLexicalDecls(const DeclContext *DC, llvm::function_ref< bool(Decl::Kind)> IsKindWeWant, SmallVectorImpl< Decl * > &Result)
Finds all declarations lexically contained within the given DeclContext, after applying an optional f...
Represents a member of a struct/union/class.
Definition: Decl.h:3033
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
Definition: Decl.cpp:4599
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:3136
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:3208
LazyDeclStmtPtr Init
Definition: Decl.h:3083
unsigned getBitWidthValue() const
Computes the bit width of this field, if this is a bit field.
Definition: Decl.cpp:4621
bool isAnonymousStructOrUnion() const
Determines whether this field is a representative for an anonymous struct or union.
Definition: Decl.cpp:4589
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4697
static FieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:4583
void setInClassInitializer(Expr *NewInit)
Set the C++11 in-class initializer for this member.
Definition: Decl.cpp:4609
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
Definition: Decl.h:3264
bool isZeroSize(const ASTContext &Ctx) const
Determine if this field is a subobject of zero size, that is, either a zero-length bit-field or a fie...
Definition: Decl.cpp:4637
InitAndBitWidthStorage * InitAndBitWidth
Definition: Decl.h:3087
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition: Decl.cpp:4574
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:3275
static bool classofKind(Kind K)
Definition: Decl.h:3280
bool isUnnamedBitField() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:3139
bool isZeroLengthBitField() const
Is this a zero-length bit-field? Such bit-fields aren't really bit-fields at all and instead act as a...
Definition: Decl.cpp:4632
Expr * getBitWidth() const
Returns the expression that represents the bit width, if this field is a bit field.
Definition: Decl.h:3149
void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override
Pretty-print the unqualified name of this declaration.
Definition: Decl.cpp:4716
const FieldDecl * findCountedByField() const
Find the FieldDecl specified in a FAM's "counted_by" attribute.
Definition: Decl.cpp:4726
bool isPotentiallyOverlapping() const
Determine if this field is of potentially-overlapping class type, that is, subobject with the [[no_un...
Definition: Decl.cpp:4675
void setCapturedVLAType(const VariableArrayType *VLAType)
Set the captured variable length array type for this field.
Definition: Decl.cpp:4706
const VariableArrayType * CapturedVLAType
Definition: Decl.h:3089
static FileScopeAsmDecl * Create(ASTContext &C, DeclContext *DC, StringLiteral *Str, SourceLocation AsmLoc, SourceLocation RParenLoc)
Definition: Decl.cpp:5660
static FileScopeAsmDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5667
Stashed information about a defaulted/deleted function body.
Definition: Decl.h:1963
static DefaultedOrDeletedFunctionInfo * Create(ASTContext &Context, ArrayRef< DeclAccessPair > Lookups, StringLiteral *DeletedMessage=nullptr)
Definition: Decl.cpp:3103
void setDeletedMessage(StringLiteral *Message)
Definition: Decl.cpp:3146
Represents a function declaration or definition.
Definition: Decl.h:1935
unsigned getMemoryFunctionKind() const
Identify a memory copying or setting function.
Definition: Decl.cpp:4428
bool isTargetClonesMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-clones functional...
Definition: Decl.cpp:3615
bool isMultiVersion() const
True if this function is considered a multiversioned function.
Definition: Decl.h:2565
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2672
bool hasTrivialBody() const
Returns whether the function has a trivial body that does not require any specific codegen.
Definition: Decl.cpp:3174
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:3738
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.cpp:4079
void setPreviousDeclaration(FunctionDecl *PrevDecl)
Definition: Decl.cpp:3624
void setDescribedFunctionTemplate(FunctionTemplateDecl *Template)
Definition: Decl.cpp:4072
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:4067
void setIsPureVirtual(bool P=true)
Definition: Decl.cpp:3262
bool isImmediateFunction() const
Definition: Decl.cpp:3300
void setDefaultedOrDeletedInfo(DefaultedOrDeletedFunctionInfo *Info)
Definition: Decl.cpp:3124
SourceLocation getEllipsisLoc() const
Returns the location of the ellipsis of a variadic function.
Definition: Decl.h:2158
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type.
Definition: Decl.cpp:3898
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
Definition: Decl.cpp:3495
static FunctionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5456
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
Definition: Decl.cpp:3653
SourceLocation getPointOfInstantiation() const
Retrieve the (first) point of instantiation of a function template specialization or a member of a cl...
Definition: Decl.cpp:4389
bool isMemberLikeConstrainedFriend() const
Determine whether a function is a friend function that cannot be redeclared outside of its class,...
Definition: Decl.cpp:3557
bool hasCXXExplicitFunctionObjectParameter() const
Definition: Decl.cpp:3756
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2796
bool UsesFPIntrin() const
Determine whether the function was declared in source context that requires constrained FP intrinsics...
Definition: Decl.h:2784
void setHasWrittenPrototype(bool P=true)
State that this function has a written prototype.
Definition: Decl.h:2381
bool isNoReturn() const
Determines whether this function is known to be 'noreturn', through an attribute on its declaration o...
Definition: Decl.cpp:3546
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2649
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
Definition: Decl.cpp:3597
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:4138
bool isMSExternInline() const
The combination of the extern and inline keywords under MSVC forces the function to be required.
Definition: Decl.cpp:3782
unsigned getMinRequiredExplicitArguments() const
Returns the minimum number of non-object arguments needed to call this function.
Definition: Decl.cpp:3765
bool BodyContainsImmediateEscalatingExpressions() const
Definition: Decl.h:2418
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
Definition: Decl.cpp:3509
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:4187
bool hasWrittenPrototype() const
Whether this function has a written prototype.
Definition: Decl.h:2376
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization,...
Definition: Decl.cpp:4046
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:4197
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3638
FunctionTypeLoc getFunctionTypeLoc() const
Find the source location information for how the type of this function was written.
Definition: Decl.cpp:3892
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:3096
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2261
bool isConstexprSpecified() const
Definition: Decl.h:2407
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
Definition: Decl.cpp:4263
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:4203
SourceRange getExceptionSpecSourceRange() const
Attempt to compute an informative source range covering the function exception specification,...
Definition: Decl.cpp:3930
bool hasBody() const override
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
Definition: Decl.h:2188
bool isMSVCRTEntryPoint() const
Determines whether this function is a MSVCRT user defined entry point.
Definition: Decl.cpp:3335
unsigned getODRHash()
Returns ODRHash of the function.
Definition: Decl.cpp:4553
TemplateSpecializationKind getTemplateSpecializationKindForInstantiation() const
Determine the kind of template specialization this function represents for the purpose of template in...
Definition: Decl.cpp:4316
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
Definition: Decl.cpp:4131
unsigned getNumNonObjectParams() const
Definition: Decl.cpp:3760
TemplatedKind
The kind of templated function a FunctionDecl can be.
Definition: Decl.h:1940
@ TK_MemberSpecialization
Definition: Decl.h:1947
@ TK_DependentNonTemplate
Definition: Decl.h:1956
@ TK_FunctionTemplateSpecialization
Definition: Decl.h:1951
@ TK_DependentFunctionTemplateSpecialization
Definition: Decl.h:1954
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2763
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function.
Definition: Decl.cpp:4401
bool isInlineBuiltinDeclaration() const
Determine if this function provides an inline implementation of a builtin.
Definition: Decl.cpp:3470
bool FriendConstraintRefersToEnclosingTemplate() const
Definition: Decl.h:2583
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:4018
void setInstantiatedFromDecl(FunctionDecl *FD)
Specify that this function declaration was instantiated from a FunctionDecl FD.
Definition: Decl.cpp:4085
bool isDeletedAsWritten() const
Definition: Decl.h:2472
bool isReservedGlobalPlacementOperator() const
Determines whether this operator new or delete is one of the reserved global placement operators: voi...
Definition: Decl.cpp:3362
void setDependentTemplateSpecialization(ASTContext &Context, const UnresolvedSetImpl &Templates, const TemplateArgumentListInfo *TemplateArgs)
Specifies that this function declaration is actually a dependent function template specialization.
Definition: Decl.cpp:4252
bool isInExternCContext() const
Determines whether this function's context is, or is nested within, a C++ extern "C" linkage spec.
Definition: Decl.cpp:3517
FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass S, bool UsesFPIntrin, bool isInlineSpecified, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
Definition: Decl.cpp:3044
bool isImplicitlyInstantiable() const
Determines whether this function is a function template specialization or a member of a class templat...
Definition: Decl.cpp:4096
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:3513
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.h:2235
bool isDefined() const
Definition: Decl.h:2211
LazyDeclStmtPtr Body
The body of the function.
Definition: Decl.h:2001
bool isImmediateEscalating() const
Definition: Decl.cpp:3275
DefaultedOrDeletedFunctionInfo * DefaultedOrDeletedInfo
Information about a future defaulted function definition.
Definition: Decl.h:2003
bool isInExternCXXContext() const
Determines whether this function's context is, or is nested within, a C++ extern "C++" linkage spec.
Definition: Decl.cpp:3523
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program.
Definition: Decl.cpp:3328
void setImplicitlyInline(bool I=true)
Flag that this function is implicitly inline.
Definition: Decl.h:2791
bool isTargetVersionMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-version functiona...
Definition: Decl.cpp:3619
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition: Decl.cpp:3387
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
Definition: Decl.h:2124
bool isThisDeclarationInstantiatedFromAFriendDefinition() const
Determine whether this specific declaration of the function is a friend declaration that was instanti...
Definition: Decl.cpp:3187
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
Definition: Decl.cpp:3593
bool isDefaulted() const
Whether this function is defaulted.
Definition: Decl.h:2313
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4424
FunctionDecl * getInstantiatedFromDecl() const
Definition: Decl.cpp:4091
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:4361
const IdentifierInfo * getLiteralIdentifier() const
getLiteralIdentifier - The literal suffix identifier this function represents, if any.
Definition: Decl.cpp:4012
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Definition: Decl.cpp:4004
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition: Decl.cpp:4292
bool doesDeclarationForceExternallyVisibleDefinition() const
For a function declaration in C or C++, determine whether this declaration causes the definition to b...
Definition: Decl.cpp:3832
bool isConsteval() const
Definition: Decl.h:2410
bool isTargetMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target functionality.
Definition: Decl.cpp:3601
void setBody(Stmt *B)
Definition: Decl.cpp:3255
bool isGlobal() const
Determines whether this is a global function.
Definition: Decl.cpp:3527
bool hasOneParamOrDefaultArgs() const
Determine whether this function has a single parameter, or multiple parameters where all but the firs...
Definition: Decl.cpp:3770
void setDeletedAsWritten(bool D=true, StringLiteral *Message=nullptr)
Definition: Decl.cpp:3133
bool isTargetMultiVersionDefault() const
True if this function is the default version of a multiversioned dispatch function as a part of the t...
Definition: Decl.cpp:3606
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization,...
Definition: Decl.cpp:4039
bool isInlineDefinitionExternallyVisible() const
For an inline function definition in C, or for a gnu_inline function in C++, determine whether the de...
Definition: Decl.cpp:3952
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3717
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:2146
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition: Decl.cpp:3163
SourceRange getParametersSourceRange() const
Attempt to compute an informative source range covering the function parameters, including the ellips...
Definition: Decl.cpp:3914
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2774
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
Definition: Decl.cpp:3579
DefaultedOrDeletedFunctionInfo * getDefalutedOrDeletedInfo() const
Definition: Decl.cpp:3158
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
Definition: Decl.cpp:3088
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Definition: Decl.h:2561
const ASTTemplateArgumentListInfo * getTemplateSpecializationArgsAsWritten() const
Retrieve the template argument list as written in the sources, if any.
Definition: Decl.cpp:4213
Represents a prototype with parameter type info, e.g.
Definition: Type.h:5108
unsigned getNumParams() const
Definition: Type.h:5361
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:5485
Declaration of a template function.
Definition: DeclTemplate.h:958
void addSpecialization(FunctionTemplateSpecializationInfo *Info, void *InsertPos)
Add a specialization of this function template.
FunctionTemplateDecl * getInstantiatedFromMemberTemplate() const
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:471
TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
Definition: DeclTemplate.h:485
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Definition: DeclTemplate.h:526
static FunctionTemplateSpecializationInfo * Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, TemplateSpecializationKind TSK, TemplateArgumentList *TemplateArgs, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI, MemberSpecializationInfo *MSInfo)
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
Definition: DeclTemplate.h:540
Wrapper for source info for functions.
Definition: TypeLoc.h:1460
SourceRange getExceptionSpecRange() const
Definition: TypeLoc.h:1512
TypeLoc getReturnLoc() const
Definition: TypeLoc.h:1541
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:4322
@ SME_PStateSMEnabledMask
Definition: Type.h:4588
HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
Definition: Decl.h:5026
static HLSLBufferDecl * Create(ASTContext &C, DeclContext *LexicalParent, bool CBuffer, SourceLocation KwLoc, IdentifierInfo *ID, SourceLocation IDLoc, SourceLocation LBrace)
Definition: Decl.cpp:5718
static HLSLBufferDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5740
One of these records is kept for each identifier that is lexed.
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine whether this is a name reserved for the implementation (C99 7.1.3, C++ [lib....
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:5425
static ImplicitParamDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5437
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:4885
static ImportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, ArrayRef< SourceLocation > IdentifierLocs)
Create a new module import declaration.
Definition: Decl.cpp:5779
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:5812
static ImportDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumLocations)
Create a new, deserialized module import declaration.
Definition: Decl.cpp:5797
ArrayRef< SourceLocation > getIdentifierLocs() const
Retrieves the locations of each of the identifiers that make up the complete module name in the impor...
Definition: Decl.cpp:5803
Module * getImportedModule() const
Retrieve the module that was imported by the import declaration.
Definition: Decl.h:4943
static ImportDecl * CreateImplicit(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, SourceLocation EndLoc)
Create a new module import declaration for an implicitly-generated import.
Definition: Decl.cpp:5787
Represents a field injected from an anonymous union/struct into the parent scope.
Definition: Decl.h:3335
static bool classofKind(Kind K)
Definition: Decl.h:3380
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, const IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl * > CH)
Definition: Decl.cpp:5556
static IndirectFieldDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5562
Represents the declaration of a label.
Definition: Decl.h:503
void setMSAsmLabel(StringRef Name)
Definition: Decl.cpp:5402
static LabelDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II)
Definition: Decl.cpp:5385
static LabelDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5397
RegisterStaticDestructorsKind
Controls which variables have static destructors registered.
Definition: LangOptions.h:474
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:500
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:506
LinkageInfo getTypeLinkageAndVisibility(const Type *T)
Definition: Type.cpp:4748
LinkageInfo computeLVForDecl(const NamedDecl *D, LVComputationKind computation, bool IgnoreVarTypeLinkage=false)
Definition: Decl.cpp:1450
LinkageInfo getLVForDecl(const NamedDecl *D, LVComputationKind computation)
getLVForDecl - Get the linkage and visibility for the given declaration.
Definition: Decl.cpp:1568
LinkageInfo getDeclLinkageAndVisibility(const NamedDecl *D)
Definition: Decl.cpp:1614
Visibility getVisibility() const
Definition: Visibility.h:89
static LinkageInfo external()
Definition: Visibility.h:72
static LinkageInfo none()
Definition: Visibility.h:81
void setLinkage(Linkage L)
Definition: Visibility.h:92
void mergeExternalVisibility(Linkage L)
Definition: Visibility.h:101
void mergeMaybeWithVisibility(LinkageInfo other, bool withVis)
Merge linkage and conditionally merge visibility.
Definition: Visibility.h:143
Linkage getLinkage() const
Definition: Visibility.h:88
static LinkageInfo internal()
Definition: Visibility.h:75
static LinkageInfo visible_none()
Definition: Visibility.h:84
static LinkageInfo uniqueExternal()
Definition: Visibility.h:78
void mergeVisibility(Visibility newVis, bool newExplicit)
Merge in the visibility 'newVis'.
Definition: Visibility.h:116
bool isVisibilityExplicit() const
Definition: Visibility.h:90
void merge(LinkageInfo other)
Merge both linkage and visibility.
Definition: Visibility.h:137
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:619
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the template specialization kind.
Definition: DeclTemplate.h:650
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:641
SourceLocation getPointOfInstantiation() const
Retrieve the first point of instantiation of this member.
Definition: DeclTemplate.h:659
void setPointOfInstantiation(SourceLocation POI)
Set the first point of instantiation.
Definition: DeclTemplate.h:664
NamedDecl * getInstantiatedFrom() const
Retrieve the member declaration from which this member was instantiated.
Definition: DeclTemplate.h:638
Describes a module or submodule.
Definition: Module.h:115
Module * Parent
The parent of this module.
Definition: Module.h:164
ModuleKind Kind
The kind of this module.
Definition: Module.h:160
@ ModuleImplementationUnit
This is a C++20 module implementation unit.
Definition: Module.h:138
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
Definition: Module.h:129
@ ImplicitGlobalModuleFragment
This is an implicit fragment of the global module which contains only language linkage declarations (...
Definition: Module.h:156
@ ModulePartitionInterface
This is a C++20 module partition interface.
Definition: Module.h:141
@ ModuleInterfaceUnit
This is a C++20 module interface unit.
Definition: Module.h:135
@ ModuleHeaderUnit
This is a C++20 header unit.
Definition: Module.h:132
@ ModulePartitionImplementation
This is a C++20 module partition implementation.
Definition: Module.h:144
@ PrivateModuleFragment
This is the private module fragment within some C++ module.
Definition: Module.h:151
@ ExplicitGlobalModuleFragment
This is the explicit Global Module Fragment of a modular TU.
Definition: Module.h:148
This represents a decl that may have a name.
Definition: Decl.h:253
ExplicitVisibilityKind
Kinds of explicit visibility.
Definition: Decl.h:431
@ VisibilityForValue
Do an LV computation for, ultimately, a non-type declaration.
Definition: Decl.h:440
@ VisibilityForType
Do an LV computation for, ultimately, a type.
Definition: Decl.h:435
Linkage getLinkageInternal() const
Determine what kind of linkage this entity has.
Definition: Decl.cpp:1176
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:274
LinkageInfo getLinkageAndVisibility() const
Determines the linkage and visibility of this entity.
Definition: Decl.cpp:1220
bool isLinkageValid() const
True if the computed linkage is valid.
Definition: Decl.cpp:1079
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:280
bool isPlaceholderVar(const LangOptions &LangOpts) const
Definition: Decl.cpp:1089
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:319
std::string getQualifiedNameAsString() const
Definition: Decl.cpp:1668
std::optional< Visibility > getExplicitVisibility(ExplicitVisibilityKind kind) const
If visibility was explicitly specified for this declaration, return that visibility.
Definition: Decl.cpp:1304
NamedDecl * getMostRecentDecl()
Definition: Decl.h:480
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
Definition: Decl.cpp:1818
bool declarationReplaces(const NamedDecl *OldD, bool IsKnownNewer=true) const
Determine whether this declaration, if known to be well-formed within its context,...
Definition: Decl.cpp:1842
ObjCStringFormatFamily getObjCFStringFormattingFamily() const
Definition: Decl.cpp:1163
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition: Decl.cpp:1200
void printQualifiedName(raw_ostream &OS) const
Returns a human-readable qualified name for this declaration, like A::B::i, for i being member of nam...
Definition: Decl.cpp:1675
virtual void printName(raw_ostream &OS, const PrintingPolicy &Policy) const
Pretty-print the unqualified name of this declaration.
Definition: Decl.cpp:1660
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1951
bool hasLinkage() const
Determine whether this declaration has linkage.
Definition: Decl.cpp:1919
ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const
Determine if the declaration obeys the reserved identifier rules of the given language.
Definition: Decl.cpp:1126
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:376
void printNestedNameSpecifier(raw_ostream &OS) const
Print only the nested name specifier part of a fully-qualified name, including the '::' at the end.
Definition: Decl.cpp:1702
Represent a C++ namespace.
Definition: Decl.h:551
A C++ nested-name-specifier augmented with source location information.
bool containsType(SanitizerMask Mask, StringRef MangledTypeName, StringRef Category=StringRef()) const
bool containsLocation(SanitizerMask Mask, SourceLocation Loc, StringRef Category=StringRef()) const
void AddEnumDecl(const EnumDecl *Enum)
Definition: ODRHash.cpp:755
void AddFunctionDecl(const FunctionDecl *Function, bool SkipBody=false)
Definition: ODRHash.cpp:662
void AddRecordDecl(const RecordDecl *Record)
Definition: ODRHash.cpp:617
unsigned CalculateHash()
Definition: ODRHash.cpp:226
Represents a partial function definition.
Definition: Decl.h:4703
bool isNothrow() const
Definition: Decl.cpp:5494
static OutlinedFunctionDecl * Create(ASTContext &C, DeclContext *DC, unsigned NumParams)
Definition: Decl.cpp:5475
void setNothrow(bool Nothrow=true)
Definition: Decl.cpp:5495
static OutlinedFunctionDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NumParams)
Definition: Decl.cpp:5483
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.cpp:5489
void setBody(Stmt *B)
Definition: Decl.cpp:5492
Represents a parameter to a function.
Definition: Decl.h:1725
void setDefaultArg(Expr *defarg)
Definition: Decl.cpp:2987
static ParmVarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:2939
bool hasUnparsedDefaultArg() const
Determines whether this parameter has a default argument that has not yet been parsed.
Definition: Decl.h:1854
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
Definition: Decl.cpp:2992
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:3012
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1858
bool isDestroyedInCallee() const
Determines whether this parameter is destroyed in the callee function.
Definition: Decl.cpp:2960
bool hasInheritedDefaultArg() const
Definition: Decl.h:1870
bool isExplicitObjectParameter() const
Definition: Decl.h:1813
QualType getOriginalType() const
Definition: Decl.cpp:2931
static ParmVarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.cpp:2922
Expr * getDefaultArg()
Definition: Decl.cpp:2975
Expr * getUninstantiatedDefaultArg()
Definition: Decl.cpp:3017
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
Definition: Decl.cpp:3023
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2945
Represents a #pragma comment line.
Definition: Decl.h:146
static PragmaCommentDecl * Create(const ASTContext &C, TranslationUnitDecl *DC, SourceLocation CommentLoc, PragmaMSCommentKind CommentKind, StringRef Arg)
Definition: Decl.cpp:5331
static PragmaCommentDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned ArgSize)
Definition: Decl.cpp:5344
Represents a #pragma detect_mismatch line.
Definition: Decl.h:180
static PragmaDetectMismatchDecl * Create(const ASTContext &C, TranslationUnitDecl *DC, SourceLocation Loc, StringRef Name, StringRef Value)
Definition: Decl.cpp:5354
static PragmaDetectMismatchDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID, unsigned NameValueSize)
Definition: Decl.cpp:5370
void print(raw_ostream &OS) const override
Definition: Decl.cpp:80
A (possibly-)qualified type.
Definition: Type.h:929
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:996
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:7937
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
Definition: Type.h:1531
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:7983
const Type * getTypePtrOrNull() const
Definition: Type.h:7941
Represents a struct/union/class.
Definition: Decl.h:4162
bool hasLoadedFieldsFromExternalStorage() const
Definition: Decl.h:4231
unsigned getODRHash()
Get precomputed ODRHash or add a new one.
Definition: Decl.cpp:5247
bool isLambda() const
Determine whether this record is a class describing a lambda function object.
Definition: Decl.cpp:5085
bool isMsStruct(const ASTContext &C) const
Get whether or not this is an ms_struct which can be turned on with an attribute, pragma,...
Definition: Decl.cpp:5147
void setAnonymousStructOrUnion(bool Anon)
Definition: Decl.h:4218
const FieldDecl * findFirstNamedDataMember() const
Finds the first data member which has a name.
Definition: Decl.cpp:5232
void setArgPassingRestrictions(RecordArgPassingKind Kind)
Definition: Decl.h:4308
void setNonTrivialToPrimitiveCopy(bool V)
Definition: Decl.h:4252
bool isCapturedRecord() const
Determine whether this record is a record for captured variables in CapturedStmt construct.
Definition: Decl.cpp:5091
void setHasNonTrivialToPrimitiveCopyCUnion(bool V)
Definition: Decl.h:4284
field_range fields() const
Definition: Decl.h:4376
void setHasNonTrivialToPrimitiveDestructCUnion(bool V)
Definition: Decl.h:4276
void setHasFlexibleArrayMember(bool V)
Definition: Decl.h:4199
void setParamDestroyedInCallee(bool V)
Definition: Decl.h:4316
void setNonTrivialToPrimitiveDestroy(bool V)
Definition: Decl.h:4260
void setHasObjectMember(bool val)
Definition: Decl.h:4223
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
Definition: Decl.cpp:5060
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:5080
void setHasVolatileMember(bool val)
Definition: Decl.h:4227
void setHasNonTrivialToPrimitiveDefaultInitializeCUnion(bool V)
Definition: Decl.h:4268
void reorderDecls(const SmallVectorImpl< Decl * > &Decls)
Definition: Decl.cpp:5151
void setIsRandomized(bool V)
Definition: Decl.h:4322
static RecordDecl * CreateDeserialized(const ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5071
bool mayInsertExtraPadding(bool EmitRemark=false) const
Whether we are allowed to insert extra padding between fields.
Definition: Decl.cpp:5188
static bool classof(const Decl *D)
Definition: Decl.h:4391
bool isOrContainsUnion() const
Returns whether this record is a union, or contains (at any nesting level) a union member.
Definition: Decl.cpp:5099
virtual void completeDefinition()
Note that the definition of this type is now complete.
Definition: Decl.cpp:5126
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:4361
void setCapturedRecord()
Mark the record as a record for captured variables in CapturedStmt construct.
Definition: Decl.cpp:5095
specific_decl_iterator< FieldDecl > field_iterator
Definition: Decl.h:4373
void setHasUninitializedExplicitInitFields(bool V)
Definition: Decl.h:4292
void setNonTrivialToPrimitiveDefaultInitialize(bool V)
Definition: Decl.h:4244
void setHasLoadedFieldsFromExternalStorage(bool val) const
Definition: Decl.h:4235
field_iterator field_begin() const
Definition: Decl.cpp:5114
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:6078
RecordDecl * getDecl() const
Definition: Type.h:6088
Declaration of a redeclarable template.
Definition: DeclTemplate.h:720
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:84
VarDecl * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:215
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:203
VarDecl * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
Definition: Redeclarable.h:225
void setPreviousDecl(FunctionDecl *PrevDecl)
Set the previous declaration.
Definition: Decl.h:5080
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:295
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
void print(raw_ostream &OS, const SourceManager &SM) const
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
bool isInvalid() const
SourceLocation getEnd() const
SourceLocation getBegin() const
bool isValid() const
Stmt - This represents one statement.
Definition: Stmt.h:84
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:358
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:334
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:346
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1778
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3578
void setTagKind(TagKind TK)
Definition: Decl.h:3777
void setCompleteDefinitionRequired(bool V=true)
True if this complete decl is required to be complete for some existing use.
Definition: Decl.h:3696
SourceRange getBraceRange() const
Definition: Decl.h:3657
TagDecl * getDefinition() const
Returns the TagDecl that actually defines this struct/union/class/enum.
Definition: Decl.cpp:4804
void setEmbeddedInDeclarator(bool isInDeclarator)
True if this tag declaration is "embedded" (i.e., defined or declared for the very first time) in the...
Definition: Decl.h:3711
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3681
void setMayHaveOutOfDateDef(bool V=true)
Indicates whether it is possible for declarations of this kind to have an out-of-date definition.
Definition: Decl.h:3639
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3806
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:4781
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:4770
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
Definition: Decl.cpp:4772
bool mayHaveOutOfDateDef() const
Indicates whether it is possible for declarations of this kind to have an out-of-date definition.
Definition: Decl.h:3727
SourceLocation getOuterLocStart() const
Return SourceLocation representing start of source range taking into account any outer template decla...
Definition: Decl.cpp:4760
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4764
bool isUnion() const
Definition: Decl.h:3784
void setBeingDefined(bool V=true)
True if this decl is currently being defined.
Definition: Decl.h:3633
void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc)
Definition: Decl.cpp:4827
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Definition: Decl.cpp:4864
void completeDefinition()
Completes the definition of this tag declaration.
Definition: Decl.cpp:4792
void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override
Pretty-print the unqualified name of this declaration.
Definition: Decl.cpp:4847
void setFreeStanding(bool isFreeStanding=true)
True if this tag is free standing, e.g. "struct foo;".
Definition: Decl.h:3719
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:3732
TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl, SourceLocation StartL)
Definition: Decl.cpp:4743
void setCompleteDefinition(bool V=true)
True if this decl has its body fully specified.
Definition: Decl.h:3684
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:136
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:1262
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1333
A convenient class for passing around template argument information.
Definition: TemplateBase.h:632
A template argument list.
Definition: DeclTemplate.h:250
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:280
Represents a template argument.
Definition: TemplateBase.h:61
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
Definition: TemplateBase.h:74
@ Template
The template argument is a template name that was provided for a template template parameter.
Definition: TemplateBase.h:93
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
Definition: TemplateBase.h:89
@ Pack
The template argument is actually a parameter pack.
Definition: TemplateBase.h:107
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:97
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:78
@ Type
The template argument is a type.
Definition: TemplateBase.h:70
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:67
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:82
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
Definition: TemplateBase.h:103
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:398
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:417
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:73
A declaration that models statements at global scope.
Definition: Decl.h:4459
static TopLevelStmtDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5685
static TopLevelStmtDecl * Create(ASTContext &C, Stmt *Statement)
Definition: Decl.cpp:5675
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:5691
void setStmt(Stmt *S)
Definition: Decl.cpp:5695
The top declaration context.
Definition: Decl.h:84
static TranslationUnitDecl * Create(ASTContext &C)
Definition: Decl.cpp:5318
ASTContext & getASTContext() const
Definition: Decl.h:120
void setAnonymousNamespace(NamespaceDecl *D)
Definition: Decl.cpp:5322
Represents the declaration of a typedef-name via a C++11 alias-declaration.
Definition: Decl.h:3549
static TypeAliasDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5636
static TypeAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:5628
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:5651
Represents a declaration of a type.
Definition: Decl.h:3384
const Type * getTypeForDecl() const
Definition: Decl.h:3409
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Decl.h:3412
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:89
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1257
SourceRange getSourceRange() const LLVM_READONLY
Get the full source range.
Definition: TypeLoc.h:153
SourceLocation getEndLoc() const
Get the end source location.
Definition: TypeLoc.cpp:235
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:192
A container of type source information.
Definition: Type.h:7908
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:256
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:7919
The base class of the type hierarchy.
Definition: Type.h:1828
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1916
bool isLinkageValid() const
True if the computed linkage is valid.
Definition: Type.cpp:4738
bool isNothrowT() const
Definition: Type.cpp:3104
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:8810
bool isReferenceType() const
Definition: Type.h:8210
bool isEnumeralType() const
Definition: Type.h:8296
bool isAlignValT() const
Definition: Type.cpp:3113
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:738
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2707
DeducedType * getContainedDeducedType() const
Get the DeducedType whose type will be deduced for a variable with an initializer of this type.
Definition: Type.cpp:2045
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 'auto' typ...
Definition: Type.h:8654
bool isFunctionType() const
Definition: Type.h:8188
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:4646
TypeClass getTypeClass() const
Definition: Type.h:2341
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:8741
Represents the declaration of a typedef-name via the 'typedef' type specifier.
Definition: Decl.h:3528
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:5577
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:5642
static TypedefDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:5623
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3427
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:3477
QualType getUnderlyingType() const
Definition: Decl.h:3482
TypedefNameDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this typedef-name.
Definition: Decl.h:3498
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes,...
Definition: Decl.cpp:5586
A set of unresolved declarations.
Definition: UnresolvedSet.h:62
unsigned size() const
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:671
QualType getType() const
Definition: Decl.h:682
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr.
Definition: Decl.cpp:5411
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.cpp:5417
Represents a variable declaration or definition.
Definition: Decl.h:882
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2786
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:2140
Stmt ** getInitAddress()
Retrieve the address of the initializer expression.
Definition: Decl.cpp:2411
DefinitionKind isThisDeclarationADefinition() const
Definition: Decl.h:1259
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1513
void setInstantiationOfStaticDataMember(VarDecl *VD, TemplateSpecializationKind TSK)
Specify that this variable is an instantiation of the static data member VD.
Definition: Decl.cpp:2911
TLSKind getTLSKind() const
Definition: Decl.cpp:2157
@ DAK_Unparsed
Definition: Decl.h:958
@ DAK_Normal
Definition: Decl.h:960
@ DAK_Uninstantiated
Definition: Decl.h:959
bool hasInit() const
Definition: Decl.cpp:2387
bool hasICEInitializer(const ASTContext &Context) const
Determine whether the initializer of this variable is an integer constant expression.
Definition: Decl.cpp:2608
ParmVarDeclBitfields ParmVarDeclBits
Definition: Decl.h:1075
DefinitionKind hasDefinition() const
Definition: Decl.h:1265
static const char * getStorageClassSpecifierString(StorageClass SC)
Return the string used to specify the storage class SC.
Definition: Decl.cpp:2110
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2179
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a static data member.
Definition: Decl.cpp:2433
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2246
bool hasFlexibleArrayInit(const ASTContext &Ctx) const
Whether this variable has a flexible array member initialized with one or more elements.
Definition: Decl.cpp:2838
bool isNoDestroy(const ASTContext &) const
Is destruction of this variable entirely suppressed? If so, the variable need not have a usable destr...
Definition: Decl.cpp:2812
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1522
void setStorageClass(StorageClass SC)
Definition: Decl.cpp:2152
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2547
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1234
static VarDecl * CreateDeserialized(ASTContext &C, GlobalDeclID ID)
Definition: Decl.cpp:2146
VarDecl * getTemplateInstantiationPattern() const
Retrieve the variable declaration from which this variable could be instantiated, if it is an instant...
Definition: Decl.cpp:2690
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1177
VarDeclBitfields VarDeclBits
Definition: Decl.h:1074
CharUnits getFlexibleArrayInitChars(const ASTContext &Ctx) const
If hasFlexibleArrayInit is true, compute the number of additional bytes necessary to store those elem...
Definition: Decl.cpp:2853
bool hasConstantInitialization() const
Determine whether this variable has constant initialization.
Definition: Decl.cpp:2620
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
Definition: Decl.cpp:2230
unsigned AllBits
Definition: Decl.h:1073
EvaluatedStmt * getEvaluatedStmt() const
Definition: Decl.cpp:2543
bool mightBeUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value might be usable in a constant expression, according to the re...
Definition: Decl.cpp:2458
EvaluatedStmt * ensureEvaluatedStmt() const
Convert the initializer for this declaration to the elaborated EvaluatedStmt form,...
Definition: Decl.cpp:2529
VarDecl * getInstantiatedFromStaticDataMember() const
If this variable is an instantiated static data member of a class template specialization,...
Definition: Decl.cpp:2748
bool isFileVarDecl() const
Returns true for file scoped variable declaration.
Definition: Decl.h:1293
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template,...
Definition: Decl.cpp:2883
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
Definition: Decl.cpp:2827
bool checkForConstantInitialization(SmallVectorImpl< PartialDiagnosticAt > &Notes) const
Evaluate the initializer of this variable to determine whether it's a constant initializer.
Definition: Decl.cpp:2636
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1495
const Expr * getInit() const
Definition: Decl.h:1319
bool isNonEscapingByref() const
Indicates the capture is a __block variable that is never captured by an escaping block.
Definition: Decl.cpp:2678
bool isInExternCContext() const
Determines whether this variable's context is, or is nested within, a C++ extern "C" linkage spec.
Definition: Decl.cpp:2238
NonParmVarDeclBitfields NonParmVarDeclBits
Definition: Decl.h:1076
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
Definition: Decl.h:1168
InitType Init
The initializer for this variable or, for a ParmVarDecl, the C++ default argument.
Definition: Decl.h:928
APValue * getEvaluatedValue() const
Return the already-evaluated value of this variable's initializer, or NULL if the value is not yet kn...
Definition: Decl.cpp:2600
VarDecl * getInitializingDeclaration()
Get the initializing declaration of this variable, if any.
Definition: Decl.cpp:2418
TLSKind
Kinds of thread-local storage.
Definition: Decl.h:900
@ TLS_Static
TLS with a known-constant initializer.
Definition: Decl.h:905
@ TLS_Dynamic
TLS with a dynamic initializer.
Definition: Decl.h:908
@ TLS_None
Not a TLS variable.
Definition: Decl.h:902
void setInit(Expr *I)
Definition: Decl.cpp:2449
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
Definition: Decl.cpp:2334
@ TentativeDefinition
This declaration is a tentative definition.
Definition: Decl.h:1249
@ DeclarationOnly
This declaration is only a declaration.
Definition: Decl.h:1246
@ Definition
This declaration is definitely a definition.
Definition: Decl.h:1252
void setDescribedVarTemplate(VarTemplateDecl *Template)
Definition: Decl.cpp:2791
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
Definition: Decl.cpp:2234
VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass SC)
Definition: Decl.cpp:2123
StorageDuration getStorageDuration() const
Get the storage duration of this variable, per C++ [basic.stc].
Definition: Decl.h:1180
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1119
bool isEscapingByref() const
Indicates the capture is a __block variable that is captured by a block that can potentially escape (...
Definition: Decl.cpp:2674
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
Definition: Decl.h:1420
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
Definition: Decl.cpp:2500
bool isInExternCXXContext() const
Determines whether this variable's context is, or is nested within, a C++ extern "C++" linkage spec.
Definition: Decl.cpp:2242
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2776
bool hasDependentAlignment() const
Determines if this variable's alignment is dependent.
Definition: Decl.cpp:2682
TemplateSpecializationKind getTemplateSpecializationKindForInstantiation() const
Get the template specialization kind of this variable for the purposes of template instantiation.
Definition: Decl.cpp:2766
VarDecl * getDefinition()
Definition: Decl.h:1281
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2755
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
Definition: Decl.h:1309
bool isKnownToBeDefined() const
Definition: Decl.cpp:2795
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack.
Definition: Decl.cpp:2662
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this variable is an instantiation of a static data member of a class template specialization,...
Definition: Decl.cpp:2874
Declaration of a variable template.
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
Represents a variable template specialization, which refers to a variable template with a given set o...
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration,...
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3809
Defines the Linkage enumeration and various utility functions.
Defines the clang::TargetInfo interface.
#define CHAR_BIT
Definition: limits.h:71
const internal::VariadicAllOfMatcher< Attr > attr
Matches attributes.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
The JSON file list parser is used to communicate input to InstallAPI.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
@ OO_None
Not an overloaded operator.
Definition: OperatorKinds.h:22
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:212
ObjCStringFormatFamily
@ CPlusPlus
Definition: LangStandard.h:55
@ GVA_StrongODR
Definition: Linkage.h:77
@ GVA_StrongExternal
Definition: Linkage.h:76
@ GVA_AvailableExternally
Definition: Linkage.h:74
@ GVA_DiscardableODR
Definition: Linkage.h:75
@ GVA_Internal
Definition: Linkage.h:73
bool isReservedInAllContexts(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved in all contexts.
PragmaMSCommentKind
Definition: PragmaKinds.h:14
@ PCK_Unknown
Definition: PragmaKinds.h:15
ConstexprSpecKind
Define the kind of constexpr specifier.
Definition: Specifiers.h:35
Decl * getPrimaryMergedDecl(Decl *D)
Get the primary declaration for a declaration from an AST file.
Definition: Decl.cpp:76
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:271
@ ICIS_NoInit
No in-class initializer.
Definition: Specifiers.h:272
LazyOffsetPtr< Stmt, uint64_t, &ExternalASTSource::GetExternalDeclStmt > LazyDeclStmtPtr
A lazy pointer to a statement.
Linkage getFormalLinkage(Linkage L)
Definition: Linkage.h:106
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have.
Definition: Linkage.h:63
@ CLanguageLinkage
Definition: Linkage.h:64
@ CXXLanguageLinkage
Definition: Linkage.h:65
@ NoLanguageLinkage
Definition: Linkage.h:66
StorageClass
Storage classes.
Definition: Specifiers.h:248
@ SC_Auto
Definition: Specifiers.h:256
@ SC_PrivateExtern
Definition: Specifiers.h:253
@ SC_Extern
Definition: Specifiers.h:251
@ SC_Register
Definition: Specifiers.h:257
@ SC_Static
Definition: Specifiers.h:252
@ SC_None
Definition: Specifiers.h:250
@ TSCS_thread_local
C++11 thread_local.
Definition: Specifiers.h:241
@ TSCS_unspecified
Definition: Specifiers.h:236
@ TSCS__Thread_local
C11 _Thread_local.
Definition: Specifiers.h:244
@ TSCS___thread
GNU __thread.
Definition: Specifiers.h:238
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition: Linkage.h:24
@ VisibleNone
No linkage according to the standard, but is visible from other translation units because of types de...
@ None
No linkage, which means that the entity is unique and can only be referred to from within its scope.
@ UniqueExternal
External linkage within a unique namespace.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ External
External linkage, which indicates that the entity can be referred to from other translation units.
@ Module
Module linkage, which indicates that the entity can be referred to from other translation units withi...
@ SD_Automatic
Automatic storage duration (most local variables).
Definition: Specifiers.h:329
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition: ASTLambda.h:28
@ Result
The result type of a method or function.
TagTypeKind
The kind of a tag type.
Definition: Type.h:6877
@ Struct
The "struct" keyword.
@ Enum
The "enum" keyword.
@ CanPassInRegs
The argument of this type can be passed directly in registers.
bool isLegalForVariable(StorageClass SC)
Checks whether the given storage class is legal for variables.
Definition: Specifiers.h:266
const FunctionProtoType * T
MultiVersionKind
Definition: Decl.h:1914
void printTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, const TemplateParameterList *TPL=nullptr)
Print a template argument list, including the '<' and '>' enclosing the template arguments.
bool isReservedAtGlobalScope(ReservedIdentifierStatus Status)
Determine whether an identifier is reserved for use as a name at global scope.
bool isExternalFormalLinkage(Linkage L)
Definition: Linkage.h:117
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:188
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition: Specifiers.h:206
@ TSK_ExplicitInstantiationDeclaration
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:202
@ TSK_ExplicitSpecialization
This template specialization was declared or defined by an explicit specialization (C++ [temp....
Definition: Specifiers.h:198
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:194
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
Definition: Specifiers.h:191
@ Enum
The "enum" keyword introduces the elaborated-type-specifier.
bool IsArmStreamingFunction(const FunctionDecl *FD, bool IncludeLocallyStreaming)
Returns whether the given FunctionDecl has an __arm[_locally]_streaming attribute.
Definition: Decl.cpp:5834
ReservedIdentifierStatus
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:90
ImplicitParamKind
Defines the kind of the implicit parameter: is this an implicit parameter with pointer to 'this',...
Definition: Decl.h:1661
@ Other
Other implicit parameter.
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:34
@ HiddenVisibility
Objects with "hidden" visibility are not seen by the dynamic linker.
Definition: Visibility.h:37
@ ProtectedVisibility
Objects with "protected" visibility are seen by the dynamic linker but always dynamically resolve to ...
Definition: Visibility.h:42
@ DefaultVisibility
Objects with "default" visibility are seen by the dynamic linker and act like normal objects.
Definition: Visibility.h:46
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
Definition: ASTLambda.h:60
#define true
Definition: stdbool.h:25
#define false
Definition: stdbool.h:26
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:676
static const ASTTemplateArgumentListInfo * Create(const ASTContext &C, const TemplateArgumentListInfo &List)
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:102
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
Structure used to store a statement, the constant value to which it was evaluated (if any),...
Definition: Decl.h:847
bool HasConstantDestruction
Whether this variable is known to have constant destruction.
Definition: Decl.h:865
bool WasEvaluated
Whether this statement was already evaluated.
Definition: Decl.h:849
bool CheckedForICEInit
Definition: Decl.h:870
LazyDeclStmtPtr Value
Definition: Decl.h:872
APValue Evaluated
Definition: Decl.h:873
bool IsEvaluating
Whether this statement is being evaluated.
Definition: Decl.h:852
bool HasConstantInitialization
Whether this variable is known to have constant initialization.
Definition: Decl.h:858
bool HasICEInit
In C++98, whether the initializer is an ICE.
Definition: Decl.h:869
Kinds of LV computation.
Definition: Linkage.h:29
bool isTypeVisibility() const
Definition: Linkage.h:53
unsigned IgnoreExplicitVisibility
Whether explicit visibility attributes should be ignored.
Definition: Linkage.h:37
unsigned IgnoreAllVisibility
Whether all visibility should be ignored.
Definition: Linkage.h:41
static LVComputationKind forLinkageOnly()
Do an LV computation when we only care about the linkage.
Definition: Linkage.h:61
bool isValueVisibility() const
Definition: Linkage.h:56
bool isOffset() const
Whether this pointer is currently stored as an offset.
T * get(ExternalASTSource *Source) const
Retrieve the pointer to the AST node that this lazy pointer points to.
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
A struct with extended info about a syntactic name qualifier, to be used for the case of out-of-line ...
Definition: Decl.h:708
TemplateParameterList ** TemplParamLists
A new-allocated array of size NumTemplParamLists, containing pointers to the "outer" template paramet...
Definition: Decl.h:722
NestedNameSpecifierLoc QualifierLoc
Definition: Decl.h:709
unsigned NumTemplParamLists
The number of "outer" template parameter lists.
Definition: Decl.h:715
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList * > TPLists)
Sets info about "outer" template parameter lists.
Definition: Decl.cpp:2090
SanitizerMask Mask
Bitmask of enabled sanitizers.
Definition: Sanitizers.h:196