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