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