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