Decl.cpp revision 263508
1//===--- Decl.cpp - Declaration AST Node Implementation -------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the Decl subclasses. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/Decl.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/ASTMutationListener.h" 17#include "clang/AST/Attr.h" 18#include "clang/AST/DeclCXX.h" 19#include "clang/AST/DeclObjC.h" 20#include "clang/AST/DeclTemplate.h" 21#include "clang/AST/Expr.h" 22#include "clang/AST/ExprCXX.h" 23#include "clang/AST/PrettyPrinter.h" 24#include "clang/AST/Stmt.h" 25#include "clang/AST/TypeLoc.h" 26#include "clang/Basic/Builtins.h" 27#include "clang/Basic/IdentifierTable.h" 28#include "clang/Basic/Module.h" 29#include "clang/Basic/Specifiers.h" 30#include "clang/Basic/TargetInfo.h" 31#include "llvm/Support/ErrorHandling.h" 32#include "llvm/Support/type_traits.h" 33#include <algorithm> 34 35using namespace clang; 36 37Decl *clang::getPrimaryMergedDecl(Decl *D) { 38 return D->getASTContext().getPrimaryMergedDecl(D); 39} 40 41//===----------------------------------------------------------------------===// 42// NamedDecl Implementation 43//===----------------------------------------------------------------------===// 44 45// Visibility rules aren't rigorously externally specified, but here 46// are the basic principles behind what we implement: 47// 48// 1. An explicit visibility attribute is generally a direct expression 49// of the user's intent and should be honored. Only the innermost 50// visibility attribute applies. If no visibility attribute applies, 51// global visibility settings are considered. 52// 53// 2. There is one caveat to the above: on or in a template pattern, 54// an explicit visibility attribute is just a default rule, and 55// visibility can be decreased by the visibility of template 56// arguments. But this, too, has an exception: an attribute on an 57// explicit specialization or instantiation causes all the visibility 58// restrictions of the template arguments to be ignored. 59// 60// 3. A variable that does not otherwise have explicit visibility can 61// be restricted by the visibility of its type. 62// 63// 4. A visibility restriction is explicit if it comes from an 64// attribute (or something like it), not a global visibility setting. 65// When emitting a reference to an external symbol, visibility 66// restrictions are ignored unless they are explicit. 67// 68// 5. When computing the visibility of a non-type, including a 69// non-type member of a class, only non-type visibility restrictions 70// are considered: the 'visibility' attribute, global value-visibility 71// settings, and a few special cases like __private_extern. 72// 73// 6. When computing the visibility of a type, including a type member 74// of a class, only type visibility restrictions are considered: 75// the 'type_visibility' attribute and global type-visibility settings. 76// However, a 'visibility' attribute counts as a 'type_visibility' 77// attribute on any declaration that only has the former. 78// 79// The visibility of a "secondary" entity, like a template argument, 80// is computed using the kind of that entity, not the kind of the 81// primary entity for which we are computing visibility. For example, 82// the visibility of a specialization of either of these templates: 83// template <class T, bool (&compare)(T, X)> bool has_match(list<T>, X); 84// template <class T, bool (&compare)(T, X)> class matcher; 85// is restricted according to the type visibility of the argument 'T', 86// the type visibility of 'bool(&)(T,X)', and the value visibility of 87// the argument function 'compare'. That 'has_match' is a value 88// and 'matcher' is a type only matters when looking for attributes 89// and settings from the immediate context. 90 91const unsigned IgnoreExplicitVisibilityBit = 2; 92const unsigned IgnoreAllVisibilityBit = 4; 93 94/// Kinds of LV computation. The linkage side of the computation is 95/// always the same, but different things can change how visibility is 96/// computed. 97enum LVComputationKind { 98 /// Do an LV computation for, ultimately, a type. 99 /// Visibility may be restricted by type visibility settings and 100 /// the visibility of template arguments. 101 LVForType = NamedDecl::VisibilityForType, 102 103 /// Do an LV computation for, ultimately, a non-type declaration. 104 /// Visibility may be restricted by value visibility settings and 105 /// the visibility of template arguments. 106 LVForValue = NamedDecl::VisibilityForValue, 107 108 /// Do an LV computation for, ultimately, a type that already has 109 /// some sort of explicit visibility. Visibility may only be 110 /// restricted by the visibility of template arguments. 111 LVForExplicitType = (LVForType | IgnoreExplicitVisibilityBit), 112 113 /// Do an LV computation for, ultimately, a non-type declaration 114 /// that already has some sort of explicit visibility. Visibility 115 /// may only be restricted by the visibility of template arguments. 116 LVForExplicitValue = (LVForValue | IgnoreExplicitVisibilityBit), 117 118 /// Do an LV computation when we only care about the linkage. 119 LVForLinkageOnly = 120 LVForValue | IgnoreExplicitVisibilityBit | IgnoreAllVisibilityBit 121}; 122 123/// Does this computation kind permit us to consider additional 124/// visibility settings from attributes and the like? 125static bool hasExplicitVisibilityAlready(LVComputationKind computation) { 126 return ((unsigned(computation) & IgnoreExplicitVisibilityBit) != 0); 127} 128 129/// Given an LVComputationKind, return one of the same type/value sort 130/// that records that it already has explicit visibility. 131static LVComputationKind 132withExplicitVisibilityAlready(LVComputationKind oldKind) { 133 LVComputationKind newKind = 134 static_cast<LVComputationKind>(unsigned(oldKind) | 135 IgnoreExplicitVisibilityBit); 136 assert(oldKind != LVForType || newKind == LVForExplicitType); 137 assert(oldKind != LVForValue || newKind == LVForExplicitValue); 138 assert(oldKind != LVForExplicitType || newKind == LVForExplicitType); 139 assert(oldKind != LVForExplicitValue || newKind == LVForExplicitValue); 140 return newKind; 141} 142 143static Optional<Visibility> getExplicitVisibility(const NamedDecl *D, 144 LVComputationKind kind) { 145 assert(!hasExplicitVisibilityAlready(kind) && 146 "asking for explicit visibility when we shouldn't be"); 147 return D->getExplicitVisibility((NamedDecl::ExplicitVisibilityKind) kind); 148} 149 150/// Is the given declaration a "type" or a "value" for the purposes of 151/// visibility computation? 152static bool usesTypeVisibility(const NamedDecl *D) { 153 return isa<TypeDecl>(D) || 154 isa<ClassTemplateDecl>(D) || 155 isa<ObjCInterfaceDecl>(D); 156} 157 158/// Does the given declaration have member specialization information, 159/// and if so, is it an explicit specialization? 160template <class T> static typename 161llvm::enable_if_c<!llvm::is_base_of<RedeclarableTemplateDecl, T>::value, 162 bool>::type 163isExplicitMemberSpecialization(const T *D) { 164 if (const MemberSpecializationInfo *member = 165 D->getMemberSpecializationInfo()) { 166 return member->isExplicitSpecialization(); 167 } 168 return false; 169} 170 171/// For templates, this question is easier: a member template can't be 172/// explicitly instantiated, so there's a single bit indicating whether 173/// or not this is an explicit member specialization. 174static bool isExplicitMemberSpecialization(const RedeclarableTemplateDecl *D) { 175 return D->isMemberSpecialization(); 176} 177 178/// Given a visibility attribute, return the explicit visibility 179/// associated with it. 180template <class T> 181static Visibility getVisibilityFromAttr(const T *attr) { 182 switch (attr->getVisibility()) { 183 case T::Default: 184 return DefaultVisibility; 185 case T::Hidden: 186 return HiddenVisibility; 187 case T::Protected: 188 return ProtectedVisibility; 189 } 190 llvm_unreachable("bad visibility kind"); 191} 192 193/// Return the explicit visibility of the given declaration. 194static Optional<Visibility> getVisibilityOf(const NamedDecl *D, 195 NamedDecl::ExplicitVisibilityKind kind) { 196 // If we're ultimately computing the visibility of a type, look for 197 // a 'type_visibility' attribute before looking for 'visibility'. 198 if (kind == NamedDecl::VisibilityForType) { 199 if (const TypeVisibilityAttr *A = D->getAttr<TypeVisibilityAttr>()) { 200 return getVisibilityFromAttr(A); 201 } 202 } 203 204 // If this declaration has an explicit visibility attribute, use it. 205 if (const VisibilityAttr *A = D->getAttr<VisibilityAttr>()) { 206 return getVisibilityFromAttr(A); 207 } 208 209 // If we're on Mac OS X, an 'availability' for Mac OS X attribute 210 // implies visibility(default). 211 if (D->getASTContext().getTargetInfo().getTriple().isOSDarwin()) { 212 for (specific_attr_iterator<AvailabilityAttr> 213 A = D->specific_attr_begin<AvailabilityAttr>(), 214 AEnd = D->specific_attr_end<AvailabilityAttr>(); 215 A != AEnd; ++A) 216 if ((*A)->getPlatform()->getName().equals("macosx")) 217 return DefaultVisibility; 218 } 219 220 return None; 221} 222 223static LinkageInfo 224getLVForType(const Type &T, LVComputationKind computation) { 225 if (computation == LVForLinkageOnly) 226 return LinkageInfo(T.getLinkage(), DefaultVisibility, true); 227 return T.getLinkageAndVisibility(); 228} 229 230/// \brief Get the most restrictive linkage for the types in the given 231/// template parameter list. For visibility purposes, template 232/// parameters are part of the signature of a template. 233static LinkageInfo 234getLVForTemplateParameterList(const TemplateParameterList *params, 235 LVComputationKind computation) { 236 LinkageInfo LV; 237 for (TemplateParameterList::const_iterator P = params->begin(), 238 PEnd = params->end(); 239 P != PEnd; ++P) { 240 241 // Template type parameters are the most common and never 242 // contribute to visibility, pack or not. 243 if (isa<TemplateTypeParmDecl>(*P)) 244 continue; 245 246 // Non-type template parameters can be restricted by the value type, e.g. 247 // template <enum X> class A { ... }; 248 // We have to be careful here, though, because we can be dealing with 249 // dependent types. 250 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 251 // Handle the non-pack case first. 252 if (!NTTP->isExpandedParameterPack()) { 253 if (!NTTP->getType()->isDependentType()) { 254 LV.merge(getLVForType(*NTTP->getType(), computation)); 255 } 256 continue; 257 } 258 259 // Look at all the types in an expanded pack. 260 for (unsigned i = 0, n = NTTP->getNumExpansionTypes(); i != n; ++i) { 261 QualType type = NTTP->getExpansionType(i); 262 if (!type->isDependentType()) 263 LV.merge(type->getLinkageAndVisibility()); 264 } 265 continue; 266 } 267 268 // Template template parameters can be restricted by their 269 // template parameters, recursively. 270 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 271 272 // Handle the non-pack case first. 273 if (!TTP->isExpandedParameterPack()) { 274 LV.merge(getLVForTemplateParameterList(TTP->getTemplateParameters(), 275 computation)); 276 continue; 277 } 278 279 // Look at all expansions in an expanded pack. 280 for (unsigned i = 0, n = TTP->getNumExpansionTemplateParameters(); 281 i != n; ++i) { 282 LV.merge(getLVForTemplateParameterList( 283 TTP->getExpansionTemplateParameters(i), computation)); 284 } 285 } 286 287 return LV; 288} 289 290/// getLVForDecl - Get the linkage and visibility for the given declaration. 291static LinkageInfo getLVForDecl(const NamedDecl *D, 292 LVComputationKind computation); 293 294static const Decl *getOutermostFuncOrBlockContext(const Decl *D) { 295 const Decl *Ret = NULL; 296 const DeclContext *DC = D->getDeclContext(); 297 while (DC->getDeclKind() != Decl::TranslationUnit) { 298 if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC)) 299 Ret = cast<Decl>(DC); 300 DC = DC->getParent(); 301 } 302 return Ret; 303} 304 305/// \brief Get the most restrictive linkage for the types and 306/// declarations in the given template argument list. 307/// 308/// Note that we don't take an LVComputationKind because we always 309/// want to honor the visibility of template arguments in the same way. 310static LinkageInfo 311getLVForTemplateArgumentList(ArrayRef<TemplateArgument> args, 312 LVComputationKind computation) { 313 LinkageInfo LV; 314 315 for (unsigned i = 0, e = args.size(); i != e; ++i) { 316 const TemplateArgument &arg = args[i]; 317 switch (arg.getKind()) { 318 case TemplateArgument::Null: 319 case TemplateArgument::Integral: 320 case TemplateArgument::Expression: 321 continue; 322 323 case TemplateArgument::Type: 324 LV.merge(getLVForType(*arg.getAsType(), computation)); 325 continue; 326 327 case TemplateArgument::Declaration: 328 if (NamedDecl *ND = dyn_cast<NamedDecl>(arg.getAsDecl())) { 329 assert(!usesTypeVisibility(ND)); 330 LV.merge(getLVForDecl(ND, computation)); 331 } 332 continue; 333 334 case TemplateArgument::NullPtr: 335 LV.merge(arg.getNullPtrType()->getLinkageAndVisibility()); 336 continue; 337 338 case TemplateArgument::Template: 339 case TemplateArgument::TemplateExpansion: 340 if (TemplateDecl *Template 341 = arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl()) 342 LV.merge(getLVForDecl(Template, computation)); 343 continue; 344 345 case TemplateArgument::Pack: 346 LV.merge(getLVForTemplateArgumentList(arg.getPackAsArray(), computation)); 347 continue; 348 } 349 llvm_unreachable("bad template argument kind"); 350 } 351 352 return LV; 353} 354 355static LinkageInfo 356getLVForTemplateArgumentList(const TemplateArgumentList &TArgs, 357 LVComputationKind computation) { 358 return getLVForTemplateArgumentList(TArgs.asArray(), computation); 359} 360 361static bool shouldConsiderTemplateVisibility(const FunctionDecl *fn, 362 const FunctionTemplateSpecializationInfo *specInfo) { 363 // Include visibility from the template parameters and arguments 364 // only if this is not an explicit instantiation or specialization 365 // with direct explicit visibility. (Implicit instantiations won't 366 // have a direct attribute.) 367 if (!specInfo->isExplicitInstantiationOrSpecialization()) 368 return true; 369 370 return !fn->hasAttr<VisibilityAttr>(); 371} 372 373/// Merge in template-related linkage and visibility for the given 374/// function template specialization. 375/// 376/// We don't need a computation kind here because we can assume 377/// LVForValue. 378/// 379/// \param[out] LV the computation to use for the parent 380static void 381mergeTemplateLV(LinkageInfo &LV, const FunctionDecl *fn, 382 const FunctionTemplateSpecializationInfo *specInfo, 383 LVComputationKind computation) { 384 bool considerVisibility = 385 shouldConsiderTemplateVisibility(fn, specInfo); 386 387 // Merge information from the template parameters. 388 FunctionTemplateDecl *temp = specInfo->getTemplate(); 389 LinkageInfo tempLV = 390 getLVForTemplateParameterList(temp->getTemplateParameters(), computation); 391 LV.mergeMaybeWithVisibility(tempLV, considerVisibility); 392 393 // Merge information from the template arguments. 394 const TemplateArgumentList &templateArgs = *specInfo->TemplateArguments; 395 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation); 396 LV.mergeMaybeWithVisibility(argsLV, considerVisibility); 397} 398 399/// Does the given declaration have a direct visibility attribute 400/// that would match the given rules? 401static bool hasDirectVisibilityAttribute(const NamedDecl *D, 402 LVComputationKind computation) { 403 switch (computation) { 404 case LVForType: 405 case LVForExplicitType: 406 if (D->hasAttr<TypeVisibilityAttr>()) 407 return true; 408 // fallthrough 409 case LVForValue: 410 case LVForExplicitValue: 411 if (D->hasAttr<VisibilityAttr>()) 412 return true; 413 return false; 414 case LVForLinkageOnly: 415 return false; 416 } 417 llvm_unreachable("bad visibility computation kind"); 418} 419 420/// Should we consider visibility associated with the template 421/// arguments and parameters of the given class template specialization? 422static bool shouldConsiderTemplateVisibility( 423 const ClassTemplateSpecializationDecl *spec, 424 LVComputationKind computation) { 425 // Include visibility from the template parameters and arguments 426 // only if this is not an explicit instantiation or specialization 427 // with direct explicit visibility (and note that implicit 428 // instantiations won't have a direct attribute). 429 // 430 // Furthermore, we want to ignore template parameters and arguments 431 // for an explicit specialization when computing the visibility of a 432 // member thereof with explicit visibility. 433 // 434 // This is a bit complex; let's unpack it. 435 // 436 // An explicit class specialization is an independent, top-level 437 // declaration. As such, if it or any of its members has an 438 // explicit visibility attribute, that must directly express the 439 // user's intent, and we should honor it. The same logic applies to 440 // an explicit instantiation of a member of such a thing. 441 442 // Fast path: if this is not an explicit instantiation or 443 // specialization, we always want to consider template-related 444 // visibility restrictions. 445 if (!spec->isExplicitInstantiationOrSpecialization()) 446 return true; 447 448 // This is the 'member thereof' check. 449 if (spec->isExplicitSpecialization() && 450 hasExplicitVisibilityAlready(computation)) 451 return false; 452 453 return !hasDirectVisibilityAttribute(spec, computation); 454} 455 456/// Merge in template-related linkage and visibility for the given 457/// class template specialization. 458static void mergeTemplateLV(LinkageInfo &LV, 459 const ClassTemplateSpecializationDecl *spec, 460 LVComputationKind computation) { 461 bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation); 462 463 // Merge information from the template parameters, but ignore 464 // visibility if we're only considering template arguments. 465 466 ClassTemplateDecl *temp = spec->getSpecializedTemplate(); 467 LinkageInfo tempLV = 468 getLVForTemplateParameterList(temp->getTemplateParameters(), computation); 469 LV.mergeMaybeWithVisibility(tempLV, 470 considerVisibility && !hasExplicitVisibilityAlready(computation)); 471 472 // Merge information from the template arguments. We ignore 473 // template-argument visibility if we've got an explicit 474 // instantiation with a visibility attribute. 475 const TemplateArgumentList &templateArgs = spec->getTemplateArgs(); 476 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation); 477 if (considerVisibility) 478 LV.mergeVisibility(argsLV); 479 LV.mergeExternalVisibility(argsLV); 480} 481 482static bool useInlineVisibilityHidden(const NamedDecl *D) { 483 // FIXME: we should warn if -fvisibility-inlines-hidden is used with c. 484 const LangOptions &Opts = D->getASTContext().getLangOpts(); 485 if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden) 486 return false; 487 488 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 489 if (!FD) 490 return false; 491 492 TemplateSpecializationKind TSK = TSK_Undeclared; 493 if (FunctionTemplateSpecializationInfo *spec 494 = FD->getTemplateSpecializationInfo()) { 495 TSK = spec->getTemplateSpecializationKind(); 496 } else if (MemberSpecializationInfo *MSI = 497 FD->getMemberSpecializationInfo()) { 498 TSK = MSI->getTemplateSpecializationKind(); 499 } 500 501 const FunctionDecl *Def = 0; 502 // InlineVisibilityHidden only applies to definitions, and 503 // isInlined() only gives meaningful answers on definitions 504 // anyway. 505 return TSK != TSK_ExplicitInstantiationDeclaration && 506 TSK != TSK_ExplicitInstantiationDefinition && 507 FD->hasBody(Def) && Def->isInlined() && !Def->hasAttr<GNUInlineAttr>(); 508} 509 510template <typename T> static bool isFirstInExternCContext(T *D) { 511 const T *First = D->getFirstDecl(); 512 return First->isInExternCContext(); 513} 514 515static bool isSingleLineExternC(const Decl &D) { 516 if (const LinkageSpecDecl *SD = dyn_cast<LinkageSpecDecl>(D.getDeclContext())) 517 if (SD->getLanguage() == LinkageSpecDecl::lang_c && !SD->hasBraces()) 518 return true; 519 return false; 520} 521 522static LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D, 523 LVComputationKind computation) { 524 assert(D->getDeclContext()->getRedeclContext()->isFileContext() && 525 "Not a name having namespace scope"); 526 ASTContext &Context = D->getASTContext(); 527 528 // C++ [basic.link]p3: 529 // A name having namespace scope (3.3.6) has internal linkage if it 530 // is the name of 531 // - an object, reference, function or function template that is 532 // explicitly declared static; or, 533 // (This bullet corresponds to C99 6.2.2p3.) 534 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) { 535 // Explicitly declared static. 536 if (Var->getStorageClass() == SC_Static) 537 return LinkageInfo::internal(); 538 539 // - a non-volatile object or reference that is explicitly declared const 540 // or constexpr and neither explicitly declared extern nor previously 541 // declared to have external linkage; or (there is no equivalent in C99) 542 if (Context.getLangOpts().CPlusPlus && 543 Var->getType().isConstQualified() && 544 !Var->getType().isVolatileQualified()) { 545 const VarDecl *PrevVar = Var->getPreviousDecl(); 546 if (PrevVar) 547 return getLVForDecl(PrevVar, computation); 548 549 if (Var->getStorageClass() != SC_Extern && 550 Var->getStorageClass() != SC_PrivateExtern && 551 !isSingleLineExternC(*Var)) 552 return LinkageInfo::internal(); 553 } 554 555 for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar; 556 PrevVar = PrevVar->getPreviousDecl()) { 557 if (PrevVar->getStorageClass() == SC_PrivateExtern && 558 Var->getStorageClass() == SC_None) 559 return PrevVar->getLinkageAndVisibility(); 560 // Explicitly declared static. 561 if (PrevVar->getStorageClass() == SC_Static) 562 return LinkageInfo::internal(); 563 } 564 } else if (isa<FunctionDecl>(D) || isa<FunctionTemplateDecl>(D)) { 565 // C++ [temp]p4: 566 // A non-member function template can have internal linkage; any 567 // other template name shall have external linkage. 568 const FunctionDecl *Function = 0; 569 if (const FunctionTemplateDecl *FunTmpl 570 = dyn_cast<FunctionTemplateDecl>(D)) 571 Function = FunTmpl->getTemplatedDecl(); 572 else 573 Function = cast<FunctionDecl>(D); 574 575 // Explicitly declared static. 576 if (Function->getCanonicalDecl()->getStorageClass() == SC_Static) 577 return LinkageInfo(InternalLinkage, DefaultVisibility, false); 578 } 579 // - a data member of an anonymous union. 580 assert(!isa<IndirectFieldDecl>(D) && "Didn't expect an IndirectFieldDecl!"); 581 assert(!isa<FieldDecl>(D) && "Didn't expect a FieldDecl!"); 582 583 if (D->isInAnonymousNamespace()) { 584 const VarDecl *Var = dyn_cast<VarDecl>(D); 585 const FunctionDecl *Func = dyn_cast<FunctionDecl>(D); 586 if ((!Var || !isFirstInExternCContext(Var)) && 587 (!Func || !isFirstInExternCContext(Func))) 588 return LinkageInfo::uniqueExternal(); 589 } 590 591 // Set up the defaults. 592 593 // C99 6.2.2p5: 594 // If the declaration of an identifier for an object has file 595 // scope and no storage-class specifier, its linkage is 596 // external. 597 LinkageInfo LV; 598 599 if (!hasExplicitVisibilityAlready(computation)) { 600 if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) { 601 LV.mergeVisibility(*Vis, true); 602 } else { 603 // If we're declared in a namespace with a visibility attribute, 604 // use that namespace's visibility, and it still counts as explicit. 605 for (const DeclContext *DC = D->getDeclContext(); 606 !isa<TranslationUnitDecl>(DC); 607 DC = DC->getParent()) { 608 const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC); 609 if (!ND) continue; 610 if (Optional<Visibility> Vis = getExplicitVisibility(ND, computation)) { 611 LV.mergeVisibility(*Vis, true); 612 break; 613 } 614 } 615 } 616 617 // Add in global settings if the above didn't give us direct visibility. 618 if (!LV.isVisibilityExplicit()) { 619 // Use global type/value visibility as appropriate. 620 Visibility globalVisibility; 621 if (computation == LVForValue) { 622 globalVisibility = Context.getLangOpts().getValueVisibilityMode(); 623 } else { 624 assert(computation == LVForType); 625 globalVisibility = Context.getLangOpts().getTypeVisibilityMode(); 626 } 627 LV.mergeVisibility(globalVisibility, /*explicit*/ false); 628 629 // If we're paying attention to global visibility, apply 630 // -finline-visibility-hidden if this is an inline method. 631 if (useInlineVisibilityHidden(D)) 632 LV.mergeVisibility(HiddenVisibility, true); 633 } 634 } 635 636 // C++ [basic.link]p4: 637 638 // A name having namespace scope has external linkage if it is the 639 // name of 640 // 641 // - an object or reference, unless it has internal linkage; or 642 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) { 643 // GCC applies the following optimization to variables and static 644 // data members, but not to functions: 645 // 646 // Modify the variable's LV by the LV of its type unless this is 647 // C or extern "C". This follows from [basic.link]p9: 648 // A type without linkage shall not be used as the type of a 649 // variable or function with external linkage unless 650 // - the entity has C language linkage, or 651 // - the entity is declared within an unnamed namespace, or 652 // - the entity is not used or is defined in the same 653 // translation unit. 654 // and [basic.link]p10: 655 // ...the types specified by all declarations referring to a 656 // given variable or function shall be identical... 657 // C does not have an equivalent rule. 658 // 659 // Ignore this if we've got an explicit attribute; the user 660 // probably knows what they're doing. 661 // 662 // Note that we don't want to make the variable non-external 663 // because of this, but unique-external linkage suits us. 664 if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Var)) { 665 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation); 666 if (TypeLV.getLinkage() != ExternalLinkage) 667 return LinkageInfo::uniqueExternal(); 668 if (!LV.isVisibilityExplicit()) 669 LV.mergeVisibility(TypeLV); 670 } 671 672 if (Var->getStorageClass() == SC_PrivateExtern) 673 LV.mergeVisibility(HiddenVisibility, true); 674 675 // Note that Sema::MergeVarDecl already takes care of implementing 676 // C99 6.2.2p4 and propagating the visibility attribute, so we don't have 677 // to do it here. 678 679 // - a function, unless it has internal linkage; or 680 } else if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 681 // In theory, we can modify the function's LV by the LV of its 682 // type unless it has C linkage (see comment above about variables 683 // for justification). In practice, GCC doesn't do this, so it's 684 // just too painful to make work. 685 686 if (Function->getStorageClass() == SC_PrivateExtern) 687 LV.mergeVisibility(HiddenVisibility, true); 688 689 // Note that Sema::MergeCompatibleFunctionDecls already takes care of 690 // merging storage classes and visibility attributes, so we don't have to 691 // look at previous decls in here. 692 693 // In C++, then if the type of the function uses a type with 694 // unique-external linkage, it's not legally usable from outside 695 // this translation unit. However, we should use the C linkage 696 // rules instead for extern "C" declarations. 697 if (Context.getLangOpts().CPlusPlus && 698 !Function->isInExternCContext()) { 699 // Only look at the type-as-written. If this function has an auto-deduced 700 // return type, we can't compute the linkage of that type because it could 701 // require looking at the linkage of this function, and we don't need this 702 // for correctness because the type is not part of the function's 703 // signature. 704 // FIXME: This is a hack. We should be able to solve this circularity and 705 // the one in getLVForClassMember for Functions some other way. 706 QualType TypeAsWritten = Function->getType(); 707 if (TypeSourceInfo *TSI = Function->getTypeSourceInfo()) 708 TypeAsWritten = TSI->getType(); 709 if (TypeAsWritten->getLinkage() == UniqueExternalLinkage) 710 return LinkageInfo::uniqueExternal(); 711 } 712 713 // Consider LV from the template and the template arguments. 714 // We're at file scope, so we do not need to worry about nested 715 // specializations. 716 if (FunctionTemplateSpecializationInfo *specInfo 717 = Function->getTemplateSpecializationInfo()) { 718 mergeTemplateLV(LV, Function, specInfo, computation); 719 } 720 721 // - a named class (Clause 9), or an unnamed class defined in a 722 // typedef declaration in which the class has the typedef name 723 // for linkage purposes (7.1.3); or 724 // - a named enumeration (7.2), or an unnamed enumeration 725 // defined in a typedef declaration in which the enumeration 726 // has the typedef name for linkage purposes (7.1.3); or 727 } else if (const TagDecl *Tag = dyn_cast<TagDecl>(D)) { 728 // Unnamed tags have no linkage. 729 if (!Tag->hasNameForLinkage()) 730 return LinkageInfo::none(); 731 732 // If this is a class template specialization, consider the 733 // linkage of the template and template arguments. We're at file 734 // scope, so we do not need to worry about nested specializations. 735 if (const ClassTemplateSpecializationDecl *spec 736 = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) { 737 mergeTemplateLV(LV, spec, computation); 738 } 739 740 // - an enumerator belonging to an enumeration with external linkage; 741 } else if (isa<EnumConstantDecl>(D)) { 742 LinkageInfo EnumLV = getLVForDecl(cast<NamedDecl>(D->getDeclContext()), 743 computation); 744 if (!isExternalFormalLinkage(EnumLV.getLinkage())) 745 return LinkageInfo::none(); 746 LV.merge(EnumLV); 747 748 // - a template, unless it is a function template that has 749 // internal linkage (Clause 14); 750 } else if (const TemplateDecl *temp = dyn_cast<TemplateDecl>(D)) { 751 bool considerVisibility = !hasExplicitVisibilityAlready(computation); 752 LinkageInfo tempLV = 753 getLVForTemplateParameterList(temp->getTemplateParameters(), computation); 754 LV.mergeMaybeWithVisibility(tempLV, considerVisibility); 755 756 // - a namespace (7.3), unless it is declared within an unnamed 757 // namespace. 758 } else if (isa<NamespaceDecl>(D) && !D->isInAnonymousNamespace()) { 759 return LV; 760 761 // By extension, we assign external linkage to Objective-C 762 // interfaces. 763 } else if (isa<ObjCInterfaceDecl>(D)) { 764 // fallout 765 766 // Everything not covered here has no linkage. 767 } else { 768 return LinkageInfo::none(); 769 } 770 771 // If we ended up with non-external linkage, visibility should 772 // always be default. 773 if (LV.getLinkage() != ExternalLinkage) 774 return LinkageInfo(LV.getLinkage(), DefaultVisibility, false); 775 776 return LV; 777} 778 779static LinkageInfo getLVForClassMember(const NamedDecl *D, 780 LVComputationKind computation) { 781 // Only certain class members have linkage. Note that fields don't 782 // really have linkage, but it's convenient to say they do for the 783 // purposes of calculating linkage of pointer-to-data-member 784 // template arguments. 785 if (!(isa<CXXMethodDecl>(D) || 786 isa<VarDecl>(D) || 787 isa<FieldDecl>(D) || 788 isa<IndirectFieldDecl>(D) || 789 isa<TagDecl>(D))) 790 return LinkageInfo::none(); 791 792 LinkageInfo LV; 793 794 // If we have an explicit visibility attribute, merge that in. 795 if (!hasExplicitVisibilityAlready(computation)) { 796 if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) 797 LV.mergeVisibility(*Vis, true); 798 // If we're paying attention to global visibility, apply 799 // -finline-visibility-hidden if this is an inline method. 800 // 801 // Note that we do this before merging information about 802 // the class visibility. 803 if (!LV.isVisibilityExplicit() && useInlineVisibilityHidden(D)) 804 LV.mergeVisibility(HiddenVisibility, true); 805 } 806 807 // If this class member has an explicit visibility attribute, the only 808 // thing that can change its visibility is the template arguments, so 809 // only look for them when processing the class. 810 LVComputationKind classComputation = computation; 811 if (LV.isVisibilityExplicit()) 812 classComputation = withExplicitVisibilityAlready(computation); 813 814 LinkageInfo classLV = 815 getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation); 816 // If the class already has unique-external linkage, we can't improve. 817 if (classLV.getLinkage() == UniqueExternalLinkage) 818 return LinkageInfo::uniqueExternal(); 819 820 if (!isExternallyVisible(classLV.getLinkage())) 821 return LinkageInfo::none(); 822 823 824 // Otherwise, don't merge in classLV yet, because in certain cases 825 // we need to completely ignore the visibility from it. 826 827 // Specifically, if this decl exists and has an explicit attribute. 828 const NamedDecl *explicitSpecSuppressor = 0; 829 830 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 831 // If the type of the function uses a type with unique-external 832 // linkage, it's not legally usable from outside this translation unit. 833 // But only look at the type-as-written. If this function has an auto-deduced 834 // return type, we can't compute the linkage of that type because it could 835 // require looking at the linkage of this function, and we don't need this 836 // for correctness because the type is not part of the function's 837 // signature. 838 // FIXME: This is a hack. We should be able to solve this circularity and the 839 // one in getLVForNamespaceScopeDecl for Functions some other way. 840 { 841 QualType TypeAsWritten = MD->getType(); 842 if (TypeSourceInfo *TSI = MD->getTypeSourceInfo()) 843 TypeAsWritten = TSI->getType(); 844 if (TypeAsWritten->getLinkage() == UniqueExternalLinkage) 845 return LinkageInfo::uniqueExternal(); 846 } 847 // If this is a method template specialization, use the linkage for 848 // the template parameters and arguments. 849 if (FunctionTemplateSpecializationInfo *spec 850 = MD->getTemplateSpecializationInfo()) { 851 mergeTemplateLV(LV, MD, spec, computation); 852 if (spec->isExplicitSpecialization()) { 853 explicitSpecSuppressor = MD; 854 } else if (isExplicitMemberSpecialization(spec->getTemplate())) { 855 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl(); 856 } 857 } else if (isExplicitMemberSpecialization(MD)) { 858 explicitSpecSuppressor = MD; 859 } 860 861 } else if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 862 if (const ClassTemplateSpecializationDecl *spec 863 = dyn_cast<ClassTemplateSpecializationDecl>(RD)) { 864 mergeTemplateLV(LV, spec, computation); 865 if (spec->isExplicitSpecialization()) { 866 explicitSpecSuppressor = spec; 867 } else { 868 const ClassTemplateDecl *temp = spec->getSpecializedTemplate(); 869 if (isExplicitMemberSpecialization(temp)) { 870 explicitSpecSuppressor = temp->getTemplatedDecl(); 871 } 872 } 873 } else if (isExplicitMemberSpecialization(RD)) { 874 explicitSpecSuppressor = RD; 875 } 876 877 // Static data members. 878 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 879 // Modify the variable's linkage by its type, but ignore the 880 // type's visibility unless it's a definition. 881 LinkageInfo typeLV = getLVForType(*VD->getType(), computation); 882 if (!LV.isVisibilityExplicit() && !classLV.isVisibilityExplicit()) 883 LV.mergeVisibility(typeLV); 884 LV.mergeExternalVisibility(typeLV); 885 886 if (isExplicitMemberSpecialization(VD)) { 887 explicitSpecSuppressor = VD; 888 } 889 890 // Template members. 891 } else if (const TemplateDecl *temp = dyn_cast<TemplateDecl>(D)) { 892 bool considerVisibility = 893 (!LV.isVisibilityExplicit() && 894 !classLV.isVisibilityExplicit() && 895 !hasExplicitVisibilityAlready(computation)); 896 LinkageInfo tempLV = 897 getLVForTemplateParameterList(temp->getTemplateParameters(), computation); 898 LV.mergeMaybeWithVisibility(tempLV, considerVisibility); 899 900 if (const RedeclarableTemplateDecl *redeclTemp = 901 dyn_cast<RedeclarableTemplateDecl>(temp)) { 902 if (isExplicitMemberSpecialization(redeclTemp)) { 903 explicitSpecSuppressor = temp->getTemplatedDecl(); 904 } 905 } 906 } 907 908 // We should never be looking for an attribute directly on a template. 909 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor)); 910 911 // If this member is an explicit member specialization, and it has 912 // an explicit attribute, ignore visibility from the parent. 913 bool considerClassVisibility = true; 914 if (explicitSpecSuppressor && 915 // optimization: hasDVA() is true only with explicit visibility. 916 LV.isVisibilityExplicit() && 917 classLV.getVisibility() != DefaultVisibility && 918 hasDirectVisibilityAttribute(explicitSpecSuppressor, computation)) { 919 considerClassVisibility = false; 920 } 921 922 // Finally, merge in information from the class. 923 LV.mergeMaybeWithVisibility(classLV, considerClassVisibility); 924 return LV; 925} 926 927void NamedDecl::anchor() { } 928 929static LinkageInfo computeLVForDecl(const NamedDecl *D, 930 LVComputationKind computation); 931 932bool NamedDecl::isLinkageValid() const { 933 if (!hasCachedLinkage()) 934 return true; 935 936 return computeLVForDecl(this, LVForLinkageOnly).getLinkage() == 937 getCachedLinkage(); 938} 939 940Linkage NamedDecl::getLinkageInternal() const { 941 // We don't care about visibility here, so ask for the cheapest 942 // possible visibility analysis. 943 return getLVForDecl(this, LVForLinkageOnly).getLinkage(); 944} 945 946LinkageInfo NamedDecl::getLinkageAndVisibility() const { 947 LVComputationKind computation = 948 (usesTypeVisibility(this) ? LVForType : LVForValue); 949 return getLVForDecl(this, computation); 950} 951 952static Optional<Visibility> 953getExplicitVisibilityAux(const NamedDecl *ND, 954 NamedDecl::ExplicitVisibilityKind kind, 955 bool IsMostRecent) { 956 assert(!IsMostRecent || ND == ND->getMostRecentDecl()); 957 958 // Check the declaration itself first. 959 if (Optional<Visibility> V = getVisibilityOf(ND, kind)) 960 return V; 961 962 // If this is a member class of a specialization of a class template 963 // and the corresponding decl has explicit visibility, use that. 964 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(ND)) { 965 CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass(); 966 if (InstantiatedFrom) 967 return getVisibilityOf(InstantiatedFrom, kind); 968 } 969 970 // If there wasn't explicit visibility there, and this is a 971 // specialization of a class template, check for visibility 972 // on the pattern. 973 if (const ClassTemplateSpecializationDecl *spec 974 = dyn_cast<ClassTemplateSpecializationDecl>(ND)) 975 return getVisibilityOf(spec->getSpecializedTemplate()->getTemplatedDecl(), 976 kind); 977 978 // Use the most recent declaration. 979 if (!IsMostRecent && !isa<NamespaceDecl>(ND)) { 980 const NamedDecl *MostRecent = ND->getMostRecentDecl(); 981 if (MostRecent != ND) 982 return getExplicitVisibilityAux(MostRecent, kind, true); 983 } 984 985 if (const VarDecl *Var = dyn_cast<VarDecl>(ND)) { 986 if (Var->isStaticDataMember()) { 987 VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember(); 988 if (InstantiatedFrom) 989 return getVisibilityOf(InstantiatedFrom, kind); 990 } 991 992 return None; 993 } 994 // Also handle function template specializations. 995 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND)) { 996 // If the function is a specialization of a template with an 997 // explicit visibility attribute, use that. 998 if (FunctionTemplateSpecializationInfo *templateInfo 999 = fn->getTemplateSpecializationInfo()) 1000 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(), 1001 kind); 1002 1003 // If the function is a member of a specialization of a class template 1004 // and the corresponding decl has explicit visibility, use that. 1005 FunctionDecl *InstantiatedFrom = fn->getInstantiatedFromMemberFunction(); 1006 if (InstantiatedFrom) 1007 return getVisibilityOf(InstantiatedFrom, kind); 1008 1009 return None; 1010 } 1011 1012 // The visibility of a template is stored in the templated decl. 1013 if (const TemplateDecl *TD = dyn_cast<TemplateDecl>(ND)) 1014 return getVisibilityOf(TD->getTemplatedDecl(), kind); 1015 1016 return None; 1017} 1018 1019Optional<Visibility> 1020NamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const { 1021 return getExplicitVisibilityAux(this, kind, false); 1022} 1023 1024static LinkageInfo getLVForClosure(const DeclContext *DC, Decl *ContextDecl, 1025 LVComputationKind computation) { 1026 // This lambda has its linkage/visibility determined by its owner. 1027 if (ContextDecl) { 1028 if (isa<ParmVarDecl>(ContextDecl)) 1029 DC = ContextDecl->getDeclContext()->getRedeclContext(); 1030 else 1031 return getLVForDecl(cast<NamedDecl>(ContextDecl), computation); 1032 } 1033 1034 if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC)) 1035 return getLVForDecl(ND, computation); 1036 1037 return LinkageInfo::external(); 1038} 1039 1040static LinkageInfo getLVForLocalDecl(const NamedDecl *D, 1041 LVComputationKind computation) { 1042 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 1043 if (Function->isInAnonymousNamespace() && 1044 !Function->isInExternCContext()) 1045 return LinkageInfo::uniqueExternal(); 1046 1047 // This is a "void f();" which got merged with a file static. 1048 if (Function->getCanonicalDecl()->getStorageClass() == SC_Static) 1049 return LinkageInfo::internal(); 1050 1051 LinkageInfo LV; 1052 if (!hasExplicitVisibilityAlready(computation)) { 1053 if (Optional<Visibility> Vis = 1054 getExplicitVisibility(Function, computation)) 1055 LV.mergeVisibility(*Vis, true); 1056 } 1057 1058 // Note that Sema::MergeCompatibleFunctionDecls already takes care of 1059 // merging storage classes and visibility attributes, so we don't have to 1060 // look at previous decls in here. 1061 1062 return LV; 1063 } 1064 1065 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) { 1066 if (Var->hasExternalStorage()) { 1067 if (Var->isInAnonymousNamespace() && !Var->isInExternCContext()) 1068 return LinkageInfo::uniqueExternal(); 1069 1070 LinkageInfo LV; 1071 if (Var->getStorageClass() == SC_PrivateExtern) 1072 LV.mergeVisibility(HiddenVisibility, true); 1073 else if (!hasExplicitVisibilityAlready(computation)) { 1074 if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation)) 1075 LV.mergeVisibility(*Vis, true); 1076 } 1077 1078 if (const VarDecl *Prev = Var->getPreviousDecl()) { 1079 LinkageInfo PrevLV = getLVForDecl(Prev, computation); 1080 if (PrevLV.getLinkage()) 1081 LV.setLinkage(PrevLV.getLinkage()); 1082 LV.mergeVisibility(PrevLV); 1083 } 1084 1085 return LV; 1086 } 1087 1088 if (!Var->isStaticLocal()) 1089 return LinkageInfo::none(); 1090 } 1091 1092 ASTContext &Context = D->getASTContext(); 1093 if (!Context.getLangOpts().CPlusPlus) 1094 return LinkageInfo::none(); 1095 1096 const Decl *OuterD = getOutermostFuncOrBlockContext(D); 1097 if (!OuterD) 1098 return LinkageInfo::none(); 1099 1100 LinkageInfo LV; 1101 if (const BlockDecl *BD = dyn_cast<BlockDecl>(OuterD)) { 1102 if (!BD->getBlockManglingNumber()) 1103 return LinkageInfo::none(); 1104 1105 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(), 1106 BD->getBlockManglingContextDecl(), computation); 1107 } else { 1108 const FunctionDecl *FD = cast<FunctionDecl>(OuterD); 1109 if (!FD->isInlined() && 1110 FD->getTemplateSpecializationKind() == TSK_Undeclared) 1111 return LinkageInfo::none(); 1112 1113 LV = getLVForDecl(FD, computation); 1114 } 1115 if (!isExternallyVisible(LV.getLinkage())) 1116 return LinkageInfo::none(); 1117 return LinkageInfo(VisibleNoLinkage, LV.getVisibility(), 1118 LV.isVisibilityExplicit()); 1119} 1120 1121static inline const CXXRecordDecl* 1122getOutermostEnclosingLambda(const CXXRecordDecl *Record) { 1123 const CXXRecordDecl *Ret = Record; 1124 while (Record && Record->isLambda()) { 1125 Ret = Record; 1126 if (!Record->getParent()) break; 1127 // Get the Containing Class of this Lambda Class 1128 Record = dyn_cast_or_null<CXXRecordDecl>( 1129 Record->getParent()->getParent()); 1130 } 1131 return Ret; 1132} 1133 1134static LinkageInfo computeLVForDecl(const NamedDecl *D, 1135 LVComputationKind computation) { 1136 // Objective-C: treat all Objective-C declarations as having external 1137 // linkage. 1138 switch (D->getKind()) { 1139 default: 1140 break; 1141 case Decl::ParmVar: 1142 return LinkageInfo::none(); 1143 case Decl::TemplateTemplateParm: // count these as external 1144 case Decl::NonTypeTemplateParm: 1145 case Decl::ObjCAtDefsField: 1146 case Decl::ObjCCategory: 1147 case Decl::ObjCCategoryImpl: 1148 case Decl::ObjCCompatibleAlias: 1149 case Decl::ObjCImplementation: 1150 case Decl::ObjCMethod: 1151 case Decl::ObjCProperty: 1152 case Decl::ObjCPropertyImpl: 1153 case Decl::ObjCProtocol: 1154 return LinkageInfo::external(); 1155 1156 case Decl::CXXRecord: { 1157 const CXXRecordDecl *Record = cast<CXXRecordDecl>(D); 1158 if (Record->isLambda()) { 1159 if (!Record->getLambdaManglingNumber()) { 1160 // This lambda has no mangling number, so it's internal. 1161 return LinkageInfo::internal(); 1162 } 1163 1164 // This lambda has its linkage/visibility determined: 1165 // - either by the outermost lambda if that lambda has no mangling 1166 // number. 1167 // - or by the parent of the outer most lambda 1168 // This prevents infinite recursion in settings such as nested lambdas 1169 // used in NSDMI's, for e.g. 1170 // struct L { 1171 // int t{}; 1172 // int t2 = ([](int a) { return [](int b) { return b; };})(t)(t); 1173 // }; 1174 const CXXRecordDecl *OuterMostLambda = 1175 getOutermostEnclosingLambda(Record); 1176 if (!OuterMostLambda->getLambdaManglingNumber()) 1177 return LinkageInfo::internal(); 1178 1179 return getLVForClosure( 1180 OuterMostLambda->getDeclContext()->getRedeclContext(), 1181 OuterMostLambda->getLambdaContextDecl(), computation); 1182 } 1183 1184 break; 1185 } 1186 } 1187 1188 // Handle linkage for namespace-scope names. 1189 if (D->getDeclContext()->getRedeclContext()->isFileContext()) 1190 return getLVForNamespaceScopeDecl(D, computation); 1191 1192 // C++ [basic.link]p5: 1193 // In addition, a member function, static data member, a named 1194 // class or enumeration of class scope, or an unnamed class or 1195 // enumeration defined in a class-scope typedef declaration such 1196 // that the class or enumeration has the typedef name for linkage 1197 // purposes (7.1.3), has external linkage if the name of the class 1198 // has external linkage. 1199 if (D->getDeclContext()->isRecord()) 1200 return getLVForClassMember(D, computation); 1201 1202 // C++ [basic.link]p6: 1203 // The name of a function declared in block scope and the name of 1204 // an object declared by a block scope extern declaration have 1205 // linkage. If there is a visible declaration of an entity with 1206 // linkage having the same name and type, ignoring entities 1207 // declared outside the innermost enclosing namespace scope, the 1208 // block scope declaration declares that same entity and receives 1209 // the linkage of the previous declaration. If there is more than 1210 // one such matching entity, the program is ill-formed. Otherwise, 1211 // if no matching entity is found, the block scope entity receives 1212 // external linkage. 1213 if (D->getDeclContext()->isFunctionOrMethod()) 1214 return getLVForLocalDecl(D, computation); 1215 1216 // C++ [basic.link]p6: 1217 // Names not covered by these rules have no linkage. 1218 return LinkageInfo::none(); 1219} 1220 1221namespace clang { 1222class LinkageComputer { 1223public: 1224 static LinkageInfo getLVForDecl(const NamedDecl *D, 1225 LVComputationKind computation) { 1226 if (computation == LVForLinkageOnly && D->hasCachedLinkage()) 1227 return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false); 1228 1229 LinkageInfo LV = computeLVForDecl(D, computation); 1230 if (D->hasCachedLinkage()) 1231 assert(D->getCachedLinkage() == LV.getLinkage()); 1232 1233 D->setCachedLinkage(LV.getLinkage()); 1234 1235#ifndef NDEBUG 1236 // In C (because of gnu inline) and in c++ with microsoft extensions an 1237 // static can follow an extern, so we can have two decls with different 1238 // linkages. 1239 const LangOptions &Opts = D->getASTContext().getLangOpts(); 1240 if (!Opts.CPlusPlus || Opts.MicrosoftExt) 1241 return LV; 1242 1243 // We have just computed the linkage for this decl. By induction we know 1244 // that all other computed linkages match, check that the one we just 1245 // computed 1246 // also does. 1247 NamedDecl *Old = NULL; 1248 for (NamedDecl::redecl_iterator I = D->redecls_begin(), 1249 E = D->redecls_end(); 1250 I != E; ++I) { 1251 NamedDecl *T = cast<NamedDecl>(*I); 1252 if (T == D) 1253 continue; 1254 if (T->hasCachedLinkage()) { 1255 Old = T; 1256 break; 1257 } 1258 } 1259 assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage()); 1260#endif 1261 1262 return LV; 1263 } 1264}; 1265} 1266 1267static LinkageInfo getLVForDecl(const NamedDecl *D, 1268 LVComputationKind computation) { 1269 return clang::LinkageComputer::getLVForDecl(D, computation); 1270} 1271 1272std::string NamedDecl::getQualifiedNameAsString() const { 1273 return getQualifiedNameAsString(getASTContext().getPrintingPolicy()); 1274} 1275 1276std::string NamedDecl::getQualifiedNameAsString(const PrintingPolicy &P) const { 1277 std::string QualName; 1278 llvm::raw_string_ostream OS(QualName); 1279 printQualifiedName(OS, P); 1280 return OS.str(); 1281} 1282 1283void NamedDecl::printQualifiedName(raw_ostream &OS) const { 1284 printQualifiedName(OS, getASTContext().getPrintingPolicy()); 1285} 1286 1287void NamedDecl::printQualifiedName(raw_ostream &OS, 1288 const PrintingPolicy &P) const { 1289 const DeclContext *Ctx = getDeclContext(); 1290 1291 if (Ctx->isFunctionOrMethod()) { 1292 printName(OS); 1293 return; 1294 } 1295 1296 typedef SmallVector<const DeclContext *, 8> ContextsTy; 1297 ContextsTy Contexts; 1298 1299 // Collect contexts. 1300 while (Ctx && isa<NamedDecl>(Ctx)) { 1301 Contexts.push_back(Ctx); 1302 Ctx = Ctx->getParent(); 1303 } 1304 1305 for (ContextsTy::reverse_iterator I = Contexts.rbegin(), E = Contexts.rend(); 1306 I != E; ++I) { 1307 if (const ClassTemplateSpecializationDecl *Spec 1308 = dyn_cast<ClassTemplateSpecializationDecl>(*I)) { 1309 OS << Spec->getName(); 1310 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1311 TemplateSpecializationType::PrintTemplateArgumentList(OS, 1312 TemplateArgs.data(), 1313 TemplateArgs.size(), 1314 P); 1315 } else if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(*I)) { 1316 if (ND->isAnonymousNamespace()) 1317 OS << "<anonymous namespace>"; 1318 else 1319 OS << *ND; 1320 } else if (const RecordDecl *RD = dyn_cast<RecordDecl>(*I)) { 1321 if (!RD->getIdentifier()) 1322 OS << "<anonymous " << RD->getKindName() << '>'; 1323 else 1324 OS << *RD; 1325 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { 1326 const FunctionProtoType *FT = 0; 1327 if (FD->hasWrittenPrototype()) 1328 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>()); 1329 1330 OS << *FD << '('; 1331 if (FT) { 1332 unsigned NumParams = FD->getNumParams(); 1333 for (unsigned i = 0; i < NumParams; ++i) { 1334 if (i) 1335 OS << ", "; 1336 OS << FD->getParamDecl(i)->getType().stream(P); 1337 } 1338 1339 if (FT->isVariadic()) { 1340 if (NumParams > 0) 1341 OS << ", "; 1342 OS << "..."; 1343 } 1344 } 1345 OS << ')'; 1346 } else { 1347 OS << *cast<NamedDecl>(*I); 1348 } 1349 OS << "::"; 1350 } 1351 1352 if (getDeclName()) 1353 OS << *this; 1354 else 1355 OS << "<anonymous>"; 1356} 1357 1358void NamedDecl::getNameForDiagnostic(raw_ostream &OS, 1359 const PrintingPolicy &Policy, 1360 bool Qualified) const { 1361 if (Qualified) 1362 printQualifiedName(OS, Policy); 1363 else 1364 printName(OS); 1365} 1366 1367bool NamedDecl::declarationReplaces(NamedDecl *OldD) const { 1368 assert(getDeclName() == OldD->getDeclName() && "Declaration name mismatch"); 1369 1370 // UsingDirectiveDecl's are not really NamedDecl's, and all have same name. 1371 // We want to keep it, unless it nominates same namespace. 1372 if (getKind() == Decl::UsingDirective) { 1373 return cast<UsingDirectiveDecl>(this)->getNominatedNamespace() 1374 ->getOriginalNamespace() == 1375 cast<UsingDirectiveDecl>(OldD)->getNominatedNamespace() 1376 ->getOriginalNamespace(); 1377 } 1378 1379 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) 1380 // For function declarations, we keep track of redeclarations. 1381 return FD->getPreviousDecl() == OldD; 1382 1383 // For function templates, the underlying function declarations are linked. 1384 if (const FunctionTemplateDecl *FunctionTemplate 1385 = dyn_cast<FunctionTemplateDecl>(this)) 1386 if (const FunctionTemplateDecl *OldFunctionTemplate 1387 = dyn_cast<FunctionTemplateDecl>(OldD)) 1388 return FunctionTemplate->getTemplatedDecl() 1389 ->declarationReplaces(OldFunctionTemplate->getTemplatedDecl()); 1390 1391 // For method declarations, we keep track of redeclarations. 1392 if (isa<ObjCMethodDecl>(this)) 1393 return false; 1394 1395 if (isa<ObjCInterfaceDecl>(this) && isa<ObjCCompatibleAliasDecl>(OldD)) 1396 return true; 1397 1398 if (isa<UsingShadowDecl>(this) && isa<UsingShadowDecl>(OldD)) 1399 return cast<UsingShadowDecl>(this)->getTargetDecl() == 1400 cast<UsingShadowDecl>(OldD)->getTargetDecl(); 1401 1402 if (isa<UsingDecl>(this) && isa<UsingDecl>(OldD)) { 1403 ASTContext &Context = getASTContext(); 1404 return Context.getCanonicalNestedNameSpecifier( 1405 cast<UsingDecl>(this)->getQualifier()) == 1406 Context.getCanonicalNestedNameSpecifier( 1407 cast<UsingDecl>(OldD)->getQualifier()); 1408 } 1409 1410 if (isa<UnresolvedUsingValueDecl>(this) && 1411 isa<UnresolvedUsingValueDecl>(OldD)) { 1412 ASTContext &Context = getASTContext(); 1413 return Context.getCanonicalNestedNameSpecifier( 1414 cast<UnresolvedUsingValueDecl>(this)->getQualifier()) == 1415 Context.getCanonicalNestedNameSpecifier( 1416 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier()); 1417 } 1418 1419 // A typedef of an Objective-C class type can replace an Objective-C class 1420 // declaration or definition, and vice versa. 1421 if ((isa<TypedefNameDecl>(this) && isa<ObjCInterfaceDecl>(OldD)) || 1422 (isa<ObjCInterfaceDecl>(this) && isa<TypedefNameDecl>(OldD))) 1423 return true; 1424 1425 // For non-function declarations, if the declarations are of the 1426 // same kind then this must be a redeclaration, or semantic analysis 1427 // would not have given us the new declaration. 1428 return this->getKind() == OldD->getKind(); 1429} 1430 1431bool NamedDecl::hasLinkage() const { 1432 return getFormalLinkage() != NoLinkage; 1433} 1434 1435NamedDecl *NamedDecl::getUnderlyingDeclImpl() { 1436 NamedDecl *ND = this; 1437 while (UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(ND)) 1438 ND = UD->getTargetDecl(); 1439 1440 if (ObjCCompatibleAliasDecl *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND)) 1441 return AD->getClassInterface(); 1442 1443 return ND; 1444} 1445 1446bool NamedDecl::isCXXInstanceMember() const { 1447 if (!isCXXClassMember()) 1448 return false; 1449 1450 const NamedDecl *D = this; 1451 if (isa<UsingShadowDecl>(D)) 1452 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 1453 1454 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D)) 1455 return true; 1456 if (isa<CXXMethodDecl>(D)) 1457 return cast<CXXMethodDecl>(D)->isInstance(); 1458 if (isa<FunctionTemplateDecl>(D)) 1459 return cast<CXXMethodDecl>(cast<FunctionTemplateDecl>(D) 1460 ->getTemplatedDecl())->isInstance(); 1461 return false; 1462} 1463 1464//===----------------------------------------------------------------------===// 1465// DeclaratorDecl Implementation 1466//===----------------------------------------------------------------------===// 1467 1468template <typename DeclT> 1469static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl) { 1470 if (decl->getNumTemplateParameterLists() > 0) 1471 return decl->getTemplateParameterList(0)->getTemplateLoc(); 1472 else 1473 return decl->getInnerLocStart(); 1474} 1475 1476SourceLocation DeclaratorDecl::getTypeSpecStartLoc() const { 1477 TypeSourceInfo *TSI = getTypeSourceInfo(); 1478 if (TSI) return TSI->getTypeLoc().getBeginLoc(); 1479 return SourceLocation(); 1480} 1481 1482void DeclaratorDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) { 1483 if (QualifierLoc) { 1484 // Make sure the extended decl info is allocated. 1485 if (!hasExtInfo()) { 1486 // Save (non-extended) type source info pointer. 1487 TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>(); 1488 // Allocate external info struct. 1489 DeclInfo = new (getASTContext()) ExtInfo; 1490 // Restore savedTInfo into (extended) decl info. 1491 getExtInfo()->TInfo = savedTInfo; 1492 } 1493 // Set qualifier info. 1494 getExtInfo()->QualifierLoc = QualifierLoc; 1495 } else { 1496 // Here Qualifier == 0, i.e., we are removing the qualifier (if any). 1497 if (hasExtInfo()) { 1498 if (getExtInfo()->NumTemplParamLists == 0) { 1499 // Save type source info pointer. 1500 TypeSourceInfo *savedTInfo = getExtInfo()->TInfo; 1501 // Deallocate the extended decl info. 1502 getASTContext().Deallocate(getExtInfo()); 1503 // Restore savedTInfo into (non-extended) decl info. 1504 DeclInfo = savedTInfo; 1505 } 1506 else 1507 getExtInfo()->QualifierLoc = QualifierLoc; 1508 } 1509 } 1510} 1511 1512void 1513DeclaratorDecl::setTemplateParameterListsInfo(ASTContext &Context, 1514 unsigned NumTPLists, 1515 TemplateParameterList **TPLists) { 1516 assert(NumTPLists > 0); 1517 // Make sure the extended decl info is allocated. 1518 if (!hasExtInfo()) { 1519 // Save (non-extended) type source info pointer. 1520 TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>(); 1521 // Allocate external info struct. 1522 DeclInfo = new (getASTContext()) ExtInfo; 1523 // Restore savedTInfo into (extended) decl info. 1524 getExtInfo()->TInfo = savedTInfo; 1525 } 1526 // Set the template parameter lists info. 1527 getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists); 1528} 1529 1530SourceLocation DeclaratorDecl::getOuterLocStart() const { 1531 return getTemplateOrInnerLocStart(this); 1532} 1533 1534namespace { 1535 1536// Helper function: returns true if QT is or contains a type 1537// having a postfix component. 1538bool typeIsPostfix(clang::QualType QT) { 1539 while (true) { 1540 const Type* T = QT.getTypePtr(); 1541 switch (T->getTypeClass()) { 1542 default: 1543 return false; 1544 case Type::Pointer: 1545 QT = cast<PointerType>(T)->getPointeeType(); 1546 break; 1547 case Type::BlockPointer: 1548 QT = cast<BlockPointerType>(T)->getPointeeType(); 1549 break; 1550 case Type::MemberPointer: 1551 QT = cast<MemberPointerType>(T)->getPointeeType(); 1552 break; 1553 case Type::LValueReference: 1554 case Type::RValueReference: 1555 QT = cast<ReferenceType>(T)->getPointeeType(); 1556 break; 1557 case Type::PackExpansion: 1558 QT = cast<PackExpansionType>(T)->getPattern(); 1559 break; 1560 case Type::Paren: 1561 case Type::ConstantArray: 1562 case Type::DependentSizedArray: 1563 case Type::IncompleteArray: 1564 case Type::VariableArray: 1565 case Type::FunctionProto: 1566 case Type::FunctionNoProto: 1567 return true; 1568 } 1569 } 1570} 1571 1572} // namespace 1573 1574SourceRange DeclaratorDecl::getSourceRange() const { 1575 SourceLocation RangeEnd = getLocation(); 1576 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) { 1577 if (typeIsPostfix(TInfo->getType())) 1578 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd(); 1579 } 1580 return SourceRange(getOuterLocStart(), RangeEnd); 1581} 1582 1583void 1584QualifierInfo::setTemplateParameterListsInfo(ASTContext &Context, 1585 unsigned NumTPLists, 1586 TemplateParameterList **TPLists) { 1587 assert((NumTPLists == 0 || TPLists != 0) && 1588 "Empty array of template parameters with positive size!"); 1589 1590 // Free previous template parameters (if any). 1591 if (NumTemplParamLists > 0) { 1592 Context.Deallocate(TemplParamLists); 1593 TemplParamLists = 0; 1594 NumTemplParamLists = 0; 1595 } 1596 // Set info on matched template parameter lists (if any). 1597 if (NumTPLists > 0) { 1598 TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 1599 NumTemplParamLists = NumTPLists; 1600 for (unsigned i = NumTPLists; i-- > 0; ) 1601 TemplParamLists[i] = TPLists[i]; 1602 } 1603} 1604 1605//===----------------------------------------------------------------------===// 1606// VarDecl Implementation 1607//===----------------------------------------------------------------------===// 1608 1609const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) { 1610 switch (SC) { 1611 case SC_None: break; 1612 case SC_Auto: return "auto"; 1613 case SC_Extern: return "extern"; 1614 case SC_OpenCLWorkGroupLocal: return "<<work-group-local>>"; 1615 case SC_PrivateExtern: return "__private_extern__"; 1616 case SC_Register: return "register"; 1617 case SC_Static: return "static"; 1618 } 1619 1620 llvm_unreachable("Invalid storage class"); 1621} 1622 1623VarDecl::VarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc, 1624 SourceLocation IdLoc, IdentifierInfo *Id, QualType T, 1625 TypeSourceInfo *TInfo, StorageClass SC) 1626 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc), Init() { 1627 assert(sizeof(VarDeclBitfields) <= sizeof(unsigned)); 1628 assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned)); 1629 AllBits = 0; 1630 VarDeclBits.SClass = SC; 1631 // Everything else is implicitly initialized to false. 1632} 1633 1634VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC, 1635 SourceLocation StartL, SourceLocation IdL, 1636 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, 1637 StorageClass S) { 1638 return new (C) VarDecl(Var, DC, StartL, IdL, Id, T, TInfo, S); 1639} 1640 1641VarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1642 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(VarDecl)); 1643 return new (Mem) VarDecl(Var, 0, SourceLocation(), SourceLocation(), 0, 1644 QualType(), 0, SC_None); 1645} 1646 1647void VarDecl::setStorageClass(StorageClass SC) { 1648 assert(isLegalForVariable(SC)); 1649 VarDeclBits.SClass = SC; 1650} 1651 1652SourceRange VarDecl::getSourceRange() const { 1653 if (const Expr *Init = getInit()) { 1654 SourceLocation InitEnd = Init->getLocEnd(); 1655 // If Init is implicit, ignore its source range and fallback on 1656 // DeclaratorDecl::getSourceRange() to handle postfix elements. 1657 if (InitEnd.isValid() && InitEnd != getLocation()) 1658 return SourceRange(getOuterLocStart(), InitEnd); 1659 } 1660 return DeclaratorDecl::getSourceRange(); 1661} 1662 1663template<typename T> 1664static LanguageLinkage getLanguageLinkageTemplate(const T &D) { 1665 // C++ [dcl.link]p1: All function types, function names with external linkage, 1666 // and variable names with external linkage have a language linkage. 1667 if (!D.hasExternalFormalLinkage()) 1668 return NoLanguageLinkage; 1669 1670 // Language linkage is a C++ concept, but saying that everything else in C has 1671 // C language linkage fits the implementation nicely. 1672 ASTContext &Context = D.getASTContext(); 1673 if (!Context.getLangOpts().CPlusPlus) 1674 return CLanguageLinkage; 1675 1676 // C++ [dcl.link]p4: A C language linkage is ignored in determining the 1677 // language linkage of the names of class members and the function type of 1678 // class member functions. 1679 const DeclContext *DC = D.getDeclContext(); 1680 if (DC->isRecord()) 1681 return CXXLanguageLinkage; 1682 1683 // If the first decl is in an extern "C" context, any other redeclaration 1684 // will have C language linkage. If the first one is not in an extern "C" 1685 // context, we would have reported an error for any other decl being in one. 1686 if (isFirstInExternCContext(&D)) 1687 return CLanguageLinkage; 1688 return CXXLanguageLinkage; 1689} 1690 1691template<typename T> 1692static bool isExternCTemplate(const T &D) { 1693 // Since the context is ignored for class members, they can only have C++ 1694 // language linkage or no language linkage. 1695 const DeclContext *DC = D.getDeclContext(); 1696 if (DC->isRecord()) { 1697 assert(D.getASTContext().getLangOpts().CPlusPlus); 1698 return false; 1699 } 1700 1701 return D.getLanguageLinkage() == CLanguageLinkage; 1702} 1703 1704LanguageLinkage VarDecl::getLanguageLinkage() const { 1705 return getLanguageLinkageTemplate(*this); 1706} 1707 1708bool VarDecl::isExternC() const { 1709 return isExternCTemplate(*this); 1710} 1711 1712bool VarDecl::isInExternCContext() const { 1713 return getLexicalDeclContext()->isExternCContext(); 1714} 1715 1716bool VarDecl::isInExternCXXContext() const { 1717 return getLexicalDeclContext()->isExternCXXContext(); 1718} 1719 1720VarDecl *VarDecl::getCanonicalDecl() { return getFirstDecl(); } 1721 1722VarDecl::DefinitionKind VarDecl::isThisDeclarationADefinition( 1723 ASTContext &C) const 1724{ 1725 // C++ [basic.def]p2: 1726 // A declaration is a definition unless [...] it contains the 'extern' 1727 // specifier or a linkage-specification and neither an initializer [...], 1728 // it declares a static data member in a class declaration [...]. 1729 // C++1y [temp.expl.spec]p15: 1730 // An explicit specialization of a static data member or an explicit 1731 // specialization of a static data member template is a definition if the 1732 // declaration includes an initializer; otherwise, it is a declaration. 1733 // 1734 // FIXME: How do you declare (but not define) a partial specialization of 1735 // a static data member template outside the containing class? 1736 if (isStaticDataMember()) { 1737 if (isOutOfLine() && 1738 (hasInit() || 1739 // If the first declaration is out-of-line, this may be an 1740 // instantiation of an out-of-line partial specialization of a variable 1741 // template for which we have not yet instantiated the initializer. 1742 (getFirstDecl()->isOutOfLine() 1743 ? getTemplateSpecializationKind() == TSK_Undeclared 1744 : getTemplateSpecializationKind() != 1745 TSK_ExplicitSpecialization) || 1746 isa<VarTemplatePartialSpecializationDecl>(this))) 1747 return Definition; 1748 else 1749 return DeclarationOnly; 1750 } 1751 // C99 6.7p5: 1752 // A definition of an identifier is a declaration for that identifier that 1753 // [...] causes storage to be reserved for that object. 1754 // Note: that applies for all non-file-scope objects. 1755 // C99 6.9.2p1: 1756 // If the declaration of an identifier for an object has file scope and an 1757 // initializer, the declaration is an external definition for the identifier 1758 if (hasInit()) 1759 return Definition; 1760 1761 if (hasAttr<AliasAttr>()) 1762 return Definition; 1763 1764 // A variable template specialization (other than a static data member 1765 // template or an explicit specialization) is a declaration until we 1766 // instantiate its initializer. 1767 if (isa<VarTemplateSpecializationDecl>(this) && 1768 getTemplateSpecializationKind() != TSK_ExplicitSpecialization) 1769 return DeclarationOnly; 1770 1771 if (hasExternalStorage()) 1772 return DeclarationOnly; 1773 1774 // [dcl.link] p7: 1775 // A declaration directly contained in a linkage-specification is treated 1776 // as if it contains the extern specifier for the purpose of determining 1777 // the linkage of the declared name and whether it is a definition. 1778 if (isSingleLineExternC(*this)) 1779 return DeclarationOnly; 1780 1781 // C99 6.9.2p2: 1782 // A declaration of an object that has file scope without an initializer, 1783 // and without a storage class specifier or the scs 'static', constitutes 1784 // a tentative definition. 1785 // No such thing in C++. 1786 if (!C.getLangOpts().CPlusPlus && isFileVarDecl()) 1787 return TentativeDefinition; 1788 1789 // What's left is (in C, block-scope) declarations without initializers or 1790 // external storage. These are definitions. 1791 return Definition; 1792} 1793 1794VarDecl *VarDecl::getActingDefinition() { 1795 DefinitionKind Kind = isThisDeclarationADefinition(); 1796 if (Kind != TentativeDefinition) 1797 return 0; 1798 1799 VarDecl *LastTentative = 0; 1800 VarDecl *First = getFirstDecl(); 1801 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 1802 I != E; ++I) { 1803 Kind = (*I)->isThisDeclarationADefinition(); 1804 if (Kind == Definition) 1805 return 0; 1806 else if (Kind == TentativeDefinition) 1807 LastTentative = *I; 1808 } 1809 return LastTentative; 1810} 1811 1812VarDecl *VarDecl::getDefinition(ASTContext &C) { 1813 VarDecl *First = getFirstDecl(); 1814 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 1815 I != E; ++I) { 1816 if ((*I)->isThisDeclarationADefinition(C) == Definition) 1817 return *I; 1818 } 1819 return 0; 1820} 1821 1822VarDecl::DefinitionKind VarDecl::hasDefinition(ASTContext &C) const { 1823 DefinitionKind Kind = DeclarationOnly; 1824 1825 const VarDecl *First = getFirstDecl(); 1826 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 1827 I != E; ++I) { 1828 Kind = std::max(Kind, (*I)->isThisDeclarationADefinition(C)); 1829 if (Kind == Definition) 1830 break; 1831 } 1832 1833 return Kind; 1834} 1835 1836const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const { 1837 redecl_iterator I = redecls_begin(), E = redecls_end(); 1838 while (I != E && !I->getInit()) 1839 ++I; 1840 1841 if (I != E) { 1842 D = *I; 1843 return I->getInit(); 1844 } 1845 return 0; 1846} 1847 1848bool VarDecl::isOutOfLine() const { 1849 if (Decl::isOutOfLine()) 1850 return true; 1851 1852 if (!isStaticDataMember()) 1853 return false; 1854 1855 // If this static data member was instantiated from a static data member of 1856 // a class template, check whether that static data member was defined 1857 // out-of-line. 1858 if (VarDecl *VD = getInstantiatedFromStaticDataMember()) 1859 return VD->isOutOfLine(); 1860 1861 return false; 1862} 1863 1864VarDecl *VarDecl::getOutOfLineDefinition() { 1865 if (!isStaticDataMember()) 1866 return 0; 1867 1868 for (VarDecl::redecl_iterator RD = redecls_begin(), RDEnd = redecls_end(); 1869 RD != RDEnd; ++RD) { 1870 if (RD->getLexicalDeclContext()->isFileContext()) 1871 return *RD; 1872 } 1873 1874 return 0; 1875} 1876 1877void VarDecl::setInit(Expr *I) { 1878 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) { 1879 Eval->~EvaluatedStmt(); 1880 getASTContext().Deallocate(Eval); 1881 } 1882 1883 Init = I; 1884} 1885 1886bool VarDecl::isUsableInConstantExpressions(ASTContext &C) const { 1887 const LangOptions &Lang = C.getLangOpts(); 1888 1889 if (!Lang.CPlusPlus) 1890 return false; 1891 1892 // In C++11, any variable of reference type can be used in a constant 1893 // expression if it is initialized by a constant expression. 1894 if (Lang.CPlusPlus11 && getType()->isReferenceType()) 1895 return true; 1896 1897 // Only const objects can be used in constant expressions in C++. C++98 does 1898 // not require the variable to be non-volatile, but we consider this to be a 1899 // defect. 1900 if (!getType().isConstQualified() || getType().isVolatileQualified()) 1901 return false; 1902 1903 // In C++, const, non-volatile variables of integral or enumeration types 1904 // can be used in constant expressions. 1905 if (getType()->isIntegralOrEnumerationType()) 1906 return true; 1907 1908 // Additionally, in C++11, non-volatile constexpr variables can be used in 1909 // constant expressions. 1910 return Lang.CPlusPlus11 && isConstexpr(); 1911} 1912 1913/// Convert the initializer for this declaration to the elaborated EvaluatedStmt 1914/// form, which contains extra information on the evaluated value of the 1915/// initializer. 1916EvaluatedStmt *VarDecl::ensureEvaluatedStmt() const { 1917 EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>(); 1918 if (!Eval) { 1919 Stmt *S = Init.get<Stmt *>(); 1920 // Note: EvaluatedStmt contains an APValue, which usually holds 1921 // resources not allocated from the ASTContext. We need to do some 1922 // work to avoid leaking those, but we do so in VarDecl::evaluateValue 1923 // where we can detect whether there's anything to clean up or not. 1924 Eval = new (getASTContext()) EvaluatedStmt; 1925 Eval->Value = S; 1926 Init = Eval; 1927 } 1928 return Eval; 1929} 1930 1931APValue *VarDecl::evaluateValue() const { 1932 SmallVector<PartialDiagnosticAt, 8> Notes; 1933 return evaluateValue(Notes); 1934} 1935 1936namespace { 1937// Destroy an APValue that was allocated in an ASTContext. 1938void DestroyAPValue(void* UntypedValue) { 1939 static_cast<APValue*>(UntypedValue)->~APValue(); 1940} 1941} // namespace 1942 1943APValue *VarDecl::evaluateValue( 1944 SmallVectorImpl<PartialDiagnosticAt> &Notes) const { 1945 EvaluatedStmt *Eval = ensureEvaluatedStmt(); 1946 1947 // We only produce notes indicating why an initializer is non-constant the 1948 // first time it is evaluated. FIXME: The notes won't always be emitted the 1949 // first time we try evaluation, so might not be produced at all. 1950 if (Eval->WasEvaluated) 1951 return Eval->Evaluated.isUninit() ? 0 : &Eval->Evaluated; 1952 1953 const Expr *Init = cast<Expr>(Eval->Value); 1954 assert(!Init->isValueDependent()); 1955 1956 if (Eval->IsEvaluating) { 1957 // FIXME: Produce a diagnostic for self-initialization. 1958 Eval->CheckedICE = true; 1959 Eval->IsICE = false; 1960 return 0; 1961 } 1962 1963 Eval->IsEvaluating = true; 1964 1965 bool Result = Init->EvaluateAsInitializer(Eval->Evaluated, getASTContext(), 1966 this, Notes); 1967 1968 // Ensure the computed APValue is cleaned up later if evaluation succeeded, 1969 // or that it's empty (so that there's nothing to clean up) if evaluation 1970 // failed. 1971 if (!Result) 1972 Eval->Evaluated = APValue(); 1973 else if (Eval->Evaluated.needsCleanup()) 1974 getASTContext().AddDeallocation(DestroyAPValue, &Eval->Evaluated); 1975 1976 Eval->IsEvaluating = false; 1977 Eval->WasEvaluated = true; 1978 1979 // In C++11, we have determined whether the initializer was a constant 1980 // expression as a side-effect. 1981 if (getASTContext().getLangOpts().CPlusPlus11 && !Eval->CheckedICE) { 1982 Eval->CheckedICE = true; 1983 Eval->IsICE = Result && Notes.empty(); 1984 } 1985 1986 return Result ? &Eval->Evaluated : 0; 1987} 1988 1989bool VarDecl::checkInitIsICE() const { 1990 // Initializers of weak variables are never ICEs. 1991 if (isWeak()) 1992 return false; 1993 1994 EvaluatedStmt *Eval = ensureEvaluatedStmt(); 1995 if (Eval->CheckedICE) 1996 // We have already checked whether this subexpression is an 1997 // integral constant expression. 1998 return Eval->IsICE; 1999 2000 const Expr *Init = cast<Expr>(Eval->Value); 2001 assert(!Init->isValueDependent()); 2002 2003 // In C++11, evaluate the initializer to check whether it's a constant 2004 // expression. 2005 if (getASTContext().getLangOpts().CPlusPlus11) { 2006 SmallVector<PartialDiagnosticAt, 8> Notes; 2007 evaluateValue(Notes); 2008 return Eval->IsICE; 2009 } 2010 2011 // It's an ICE whether or not the definition we found is 2012 // out-of-line. See DR 721 and the discussion in Clang PR 2013 // 6206 for details. 2014 2015 if (Eval->CheckingICE) 2016 return false; 2017 Eval->CheckingICE = true; 2018 2019 Eval->IsICE = Init->isIntegerConstantExpr(getASTContext()); 2020 Eval->CheckingICE = false; 2021 Eval->CheckedICE = true; 2022 return Eval->IsICE; 2023} 2024 2025VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const { 2026 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 2027 return cast<VarDecl>(MSI->getInstantiatedFrom()); 2028 2029 return 0; 2030} 2031 2032TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const { 2033 if (const VarTemplateSpecializationDecl *Spec = 2034 dyn_cast<VarTemplateSpecializationDecl>(this)) 2035 return Spec->getSpecializationKind(); 2036 2037 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 2038 return MSI->getTemplateSpecializationKind(); 2039 2040 return TSK_Undeclared; 2041} 2042 2043SourceLocation VarDecl::getPointOfInstantiation() const { 2044 if (const VarTemplateSpecializationDecl *Spec = 2045 dyn_cast<VarTemplateSpecializationDecl>(this)) 2046 return Spec->getPointOfInstantiation(); 2047 2048 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 2049 return MSI->getPointOfInstantiation(); 2050 2051 return SourceLocation(); 2052} 2053 2054VarTemplateDecl *VarDecl::getDescribedVarTemplate() const { 2055 return getASTContext().getTemplateOrSpecializationInfo(this) 2056 .dyn_cast<VarTemplateDecl *>(); 2057} 2058 2059void VarDecl::setDescribedVarTemplate(VarTemplateDecl *Template) { 2060 getASTContext().setTemplateOrSpecializationInfo(this, Template); 2061} 2062 2063MemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const { 2064 if (isStaticDataMember()) 2065 // FIXME: Remove ? 2066 // return getASTContext().getInstantiatedFromStaticDataMember(this); 2067 return getASTContext().getTemplateOrSpecializationInfo(this) 2068 .dyn_cast<MemberSpecializationInfo *>(); 2069 return 0; 2070} 2071 2072void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 2073 SourceLocation PointOfInstantiation) { 2074 assert((isa<VarTemplateSpecializationDecl>(this) || 2075 getMemberSpecializationInfo()) && 2076 "not a variable or static data member template specialization"); 2077 2078 if (VarTemplateSpecializationDecl *Spec = 2079 dyn_cast<VarTemplateSpecializationDecl>(this)) { 2080 Spec->setSpecializationKind(TSK); 2081 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() && 2082 Spec->getPointOfInstantiation().isInvalid()) 2083 Spec->setPointOfInstantiation(PointOfInstantiation); 2084 } 2085 2086 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) { 2087 MSI->setTemplateSpecializationKind(TSK); 2088 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() && 2089 MSI->getPointOfInstantiation().isInvalid()) 2090 MSI->setPointOfInstantiation(PointOfInstantiation); 2091 } 2092} 2093 2094void 2095VarDecl::setInstantiationOfStaticDataMember(VarDecl *VD, 2096 TemplateSpecializationKind TSK) { 2097 assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() && 2098 "Previous template or instantiation?"); 2099 getASTContext().setInstantiatedFromStaticDataMember(this, VD, TSK); 2100} 2101 2102//===----------------------------------------------------------------------===// 2103// ParmVarDecl Implementation 2104//===----------------------------------------------------------------------===// 2105 2106ParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC, 2107 SourceLocation StartLoc, 2108 SourceLocation IdLoc, IdentifierInfo *Id, 2109 QualType T, TypeSourceInfo *TInfo, 2110 StorageClass S, Expr *DefArg) { 2111 return new (C) ParmVarDecl(ParmVar, DC, StartLoc, IdLoc, Id, T, TInfo, 2112 S, DefArg); 2113} 2114 2115QualType ParmVarDecl::getOriginalType() const { 2116 TypeSourceInfo *TSI = getTypeSourceInfo(); 2117 QualType T = TSI ? TSI->getType() : getType(); 2118 if (const DecayedType *DT = dyn_cast<DecayedType>(T)) 2119 return DT->getOriginalType(); 2120 return T; 2121} 2122 2123ParmVarDecl *ParmVarDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2124 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ParmVarDecl)); 2125 return new (Mem) ParmVarDecl(ParmVar, 0, SourceLocation(), SourceLocation(), 2126 0, QualType(), 0, SC_None, 0); 2127} 2128 2129SourceRange ParmVarDecl::getSourceRange() const { 2130 if (!hasInheritedDefaultArg()) { 2131 SourceRange ArgRange = getDefaultArgRange(); 2132 if (ArgRange.isValid()) 2133 return SourceRange(getOuterLocStart(), ArgRange.getEnd()); 2134 } 2135 2136 // DeclaratorDecl considers the range of postfix types as overlapping with the 2137 // declaration name, but this is not the case with parameters in ObjC methods. 2138 if (isa<ObjCMethodDecl>(getDeclContext())) 2139 return SourceRange(DeclaratorDecl::getLocStart(), getLocation()); 2140 2141 return DeclaratorDecl::getSourceRange(); 2142} 2143 2144Expr *ParmVarDecl::getDefaultArg() { 2145 assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!"); 2146 assert(!hasUninstantiatedDefaultArg() && 2147 "Default argument is not yet instantiated!"); 2148 2149 Expr *Arg = getInit(); 2150 if (ExprWithCleanups *E = dyn_cast_or_null<ExprWithCleanups>(Arg)) 2151 return E->getSubExpr(); 2152 2153 return Arg; 2154} 2155 2156SourceRange ParmVarDecl::getDefaultArgRange() const { 2157 if (const Expr *E = getInit()) 2158 return E->getSourceRange(); 2159 2160 if (hasUninstantiatedDefaultArg()) 2161 return getUninstantiatedDefaultArg()->getSourceRange(); 2162 2163 return SourceRange(); 2164} 2165 2166bool ParmVarDecl::isParameterPack() const { 2167 return isa<PackExpansionType>(getType()); 2168} 2169 2170void ParmVarDecl::setParameterIndexLarge(unsigned parameterIndex) { 2171 getASTContext().setParameterIndex(this, parameterIndex); 2172 ParmVarDeclBits.ParameterIndex = ParameterIndexSentinel; 2173} 2174 2175unsigned ParmVarDecl::getParameterIndexLarge() const { 2176 return getASTContext().getParameterIndex(this); 2177} 2178 2179//===----------------------------------------------------------------------===// 2180// FunctionDecl Implementation 2181//===----------------------------------------------------------------------===// 2182 2183void FunctionDecl::getNameForDiagnostic( 2184 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const { 2185 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified); 2186 const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs(); 2187 if (TemplateArgs) 2188 TemplateSpecializationType::PrintTemplateArgumentList( 2189 OS, TemplateArgs->data(), TemplateArgs->size(), Policy); 2190} 2191 2192bool FunctionDecl::isVariadic() const { 2193 if (const FunctionProtoType *FT = getType()->getAs<FunctionProtoType>()) 2194 return FT->isVariadic(); 2195 return false; 2196} 2197 2198bool FunctionDecl::hasBody(const FunctionDecl *&Definition) const { 2199 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 2200 if (I->Body || I->IsLateTemplateParsed) { 2201 Definition = *I; 2202 return true; 2203 } 2204 } 2205 2206 return false; 2207} 2208 2209bool FunctionDecl::hasTrivialBody() const 2210{ 2211 Stmt *S = getBody(); 2212 if (!S) { 2213 // Since we don't have a body for this function, we don't know if it's 2214 // trivial or not. 2215 return false; 2216 } 2217 2218 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty()) 2219 return true; 2220 return false; 2221} 2222 2223bool FunctionDecl::isDefined(const FunctionDecl *&Definition) const { 2224 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 2225 if (I->IsDeleted || I->IsDefaulted || I->Body || I->IsLateTemplateParsed || 2226 I->hasAttr<AliasAttr>()) { 2227 Definition = I->IsDeleted ? I->getCanonicalDecl() : *I; 2228 return true; 2229 } 2230 } 2231 2232 return false; 2233} 2234 2235Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const { 2236 if (!hasBody(Definition)) 2237 return 0; 2238 2239 if (Definition->Body) 2240 return Definition->Body.get(getASTContext().getExternalSource()); 2241 2242 return 0; 2243} 2244 2245void FunctionDecl::setBody(Stmt *B) { 2246 Body = B; 2247 if (B) 2248 EndRangeLoc = B->getLocEnd(); 2249} 2250 2251void FunctionDecl::setPure(bool P) { 2252 IsPure = P; 2253 if (P) 2254 if (CXXRecordDecl *Parent = dyn_cast<CXXRecordDecl>(getDeclContext())) 2255 Parent->markedVirtualFunctionPure(); 2256} 2257 2258template<std::size_t Len> 2259static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) { 2260 IdentifierInfo *II = ND->getIdentifier(); 2261 return II && II->isStr(Str); 2262} 2263 2264bool FunctionDecl::isMain() const { 2265 const TranslationUnitDecl *tunit = 2266 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext()); 2267 return tunit && 2268 !tunit->getASTContext().getLangOpts().Freestanding && 2269 isNamed(this, "main"); 2270} 2271 2272bool FunctionDecl::isMSVCRTEntryPoint() const { 2273 const TranslationUnitDecl *TUnit = 2274 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext()); 2275 if (!TUnit) 2276 return false; 2277 2278 // Even though we aren't really targeting MSVCRT if we are freestanding, 2279 // semantic analysis for these functions remains the same. 2280 2281 // MSVCRT entry points only exist on MSVCRT targets. 2282 if (!TUnit->getASTContext().getTargetInfo().getTriple().isOSMSVCRT()) 2283 return false; 2284 2285 // Nameless functions like constructors cannot be entry points. 2286 if (!getIdentifier()) 2287 return false; 2288 2289 return llvm::StringSwitch<bool>(getName()) 2290 .Cases("main", // an ANSI console app 2291 "wmain", // a Unicode console App 2292 "WinMain", // an ANSI GUI app 2293 "wWinMain", // a Unicode GUI app 2294 "DllMain", // a DLL 2295 true) 2296 .Default(false); 2297} 2298 2299bool FunctionDecl::isReservedGlobalPlacementOperator() const { 2300 assert(getDeclName().getNameKind() == DeclarationName::CXXOperatorName); 2301 assert(getDeclName().getCXXOverloadedOperator() == OO_New || 2302 getDeclName().getCXXOverloadedOperator() == OO_Delete || 2303 getDeclName().getCXXOverloadedOperator() == OO_Array_New || 2304 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete); 2305 2306 if (isa<CXXRecordDecl>(getDeclContext())) return false; 2307 assert(getDeclContext()->getRedeclContext()->isTranslationUnit()); 2308 2309 const FunctionProtoType *proto = getType()->castAs<FunctionProtoType>(); 2310 if (proto->getNumArgs() != 2 || proto->isVariadic()) return false; 2311 2312 ASTContext &Context = 2313 cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext()) 2314 ->getASTContext(); 2315 2316 // The result type and first argument type are constant across all 2317 // these operators. The second argument must be exactly void*. 2318 return (proto->getArgType(1).getCanonicalType() == Context.VoidPtrTy); 2319} 2320 2321static bool isNamespaceStd(const DeclContext *DC) { 2322 const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC->getRedeclContext()); 2323 return ND && isNamed(ND, "std") && 2324 ND->getParent()->getRedeclContext()->isTranslationUnit(); 2325} 2326 2327bool FunctionDecl::isReplaceableGlobalAllocationFunction() const { 2328 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName) 2329 return false; 2330 if (getDeclName().getCXXOverloadedOperator() != OO_New && 2331 getDeclName().getCXXOverloadedOperator() != OO_Delete && 2332 getDeclName().getCXXOverloadedOperator() != OO_Array_New && 2333 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) 2334 return false; 2335 2336 if (isa<CXXRecordDecl>(getDeclContext())) 2337 return false; 2338 assert(getDeclContext()->getRedeclContext()->isTranslationUnit()); 2339 2340 const FunctionProtoType *FPT = getType()->castAs<FunctionProtoType>(); 2341 if (FPT->getNumArgs() > 2 || FPT->isVariadic()) 2342 return false; 2343 2344 // If this is a single-parameter function, it must be a replaceable global 2345 // allocation or deallocation function. 2346 if (FPT->getNumArgs() == 1) 2347 return true; 2348 2349 // Otherwise, we're looking for a second parameter whose type is 2350 // 'const std::nothrow_t &', or, in C++1y, 'std::size_t'. 2351 QualType Ty = FPT->getArgType(1); 2352 ASTContext &Ctx = getASTContext(); 2353 if (Ctx.getLangOpts().SizedDeallocation && 2354 Ctx.hasSameType(Ty, Ctx.getSizeType())) 2355 return true; 2356 if (!Ty->isReferenceType()) 2357 return false; 2358 Ty = Ty->getPointeeType(); 2359 if (Ty.getCVRQualifiers() != Qualifiers::Const) 2360 return false; 2361 // FIXME: Recognise nothrow_t in an inline namespace inside std? 2362 const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 2363 return RD && isNamed(RD, "nothrow_t") && isNamespaceStd(RD->getDeclContext()); 2364} 2365 2366FunctionDecl * 2367FunctionDecl::getCorrespondingUnsizedGlobalDeallocationFunction() const { 2368 ASTContext &Ctx = getASTContext(); 2369 if (!Ctx.getLangOpts().SizedDeallocation) 2370 return 0; 2371 2372 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName) 2373 return 0; 2374 if (getDeclName().getCXXOverloadedOperator() != OO_Delete && 2375 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) 2376 return 0; 2377 if (isa<CXXRecordDecl>(getDeclContext())) 2378 return 0; 2379 assert(getDeclContext()->getRedeclContext()->isTranslationUnit()); 2380 2381 if (getNumParams() != 2 || isVariadic() || 2382 !Ctx.hasSameType(getType()->castAs<FunctionProtoType>()->getArgType(1), 2383 Ctx.getSizeType())) 2384 return 0; 2385 2386 // This is a sized deallocation function. Find the corresponding unsized 2387 // deallocation function. 2388 lookup_const_result R = getDeclContext()->lookup(getDeclName()); 2389 for (lookup_const_result::iterator RI = R.begin(), RE = R.end(); RI != RE; 2390 ++RI) 2391 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*RI)) 2392 if (FD->getNumParams() == 1 && !FD->isVariadic()) 2393 return FD; 2394 return 0; 2395} 2396 2397LanguageLinkage FunctionDecl::getLanguageLinkage() const { 2398 return getLanguageLinkageTemplate(*this); 2399} 2400 2401bool FunctionDecl::isExternC() const { 2402 return isExternCTemplate(*this); 2403} 2404 2405bool FunctionDecl::isInExternCContext() const { 2406 return getLexicalDeclContext()->isExternCContext(); 2407} 2408 2409bool FunctionDecl::isInExternCXXContext() const { 2410 return getLexicalDeclContext()->isExternCXXContext(); 2411} 2412 2413bool FunctionDecl::isGlobal() const { 2414 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(this)) 2415 return Method->isStatic(); 2416 2417 if (getCanonicalDecl()->getStorageClass() == SC_Static) 2418 return false; 2419 2420 for (const DeclContext *DC = getDeclContext(); 2421 DC->isNamespace(); 2422 DC = DC->getParent()) { 2423 if (const NamespaceDecl *Namespace = cast<NamespaceDecl>(DC)) { 2424 if (!Namespace->getDeclName()) 2425 return false; 2426 break; 2427 } 2428 } 2429 2430 return true; 2431} 2432 2433bool FunctionDecl::isNoReturn() const { 2434 return hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() || 2435 hasAttr<C11NoReturnAttr>() || 2436 getType()->getAs<FunctionType>()->getNoReturnAttr(); 2437} 2438 2439void 2440FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) { 2441 redeclarable_base::setPreviousDecl(PrevDecl); 2442 2443 if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) { 2444 FunctionTemplateDecl *PrevFunTmpl 2445 = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : 0; 2446 assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch"); 2447 FunTmpl->setPreviousDecl(PrevFunTmpl); 2448 } 2449 2450 if (PrevDecl && PrevDecl->IsInline) 2451 IsInline = true; 2452} 2453 2454const FunctionDecl *FunctionDecl::getCanonicalDecl() const { 2455 return getFirstDecl(); 2456} 2457 2458FunctionDecl *FunctionDecl::getCanonicalDecl() { return getFirstDecl(); } 2459 2460/// \brief Returns a value indicating whether this function 2461/// corresponds to a builtin function. 2462/// 2463/// The function corresponds to a built-in function if it is 2464/// declared at translation scope or within an extern "C" block and 2465/// its name matches with the name of a builtin. The returned value 2466/// will be 0 for functions that do not correspond to a builtin, a 2467/// value of type \c Builtin::ID if in the target-independent range 2468/// \c [1,Builtin::First), or a target-specific builtin value. 2469unsigned FunctionDecl::getBuiltinID() const { 2470 if (!getIdentifier()) 2471 return 0; 2472 2473 unsigned BuiltinID = getIdentifier()->getBuiltinID(); 2474 if (!BuiltinID) 2475 return 0; 2476 2477 ASTContext &Context = getASTContext(); 2478 if (Context.getLangOpts().CPlusPlus) { 2479 const LinkageSpecDecl *LinkageDecl = dyn_cast<LinkageSpecDecl>( 2480 getFirstDecl()->getDeclContext()); 2481 // In C++, the first declaration of a builtin is always inside an implicit 2482 // extern "C". 2483 // FIXME: A recognised library function may not be directly in an extern "C" 2484 // declaration, for instance "extern "C" { namespace std { decl } }". 2485 if (!LinkageDecl || LinkageDecl->getLanguage() != LinkageSpecDecl::lang_c) 2486 return 0; 2487 } 2488 2489 // If the function is marked "overloadable", it has a different mangled name 2490 // and is not the C library function. 2491 if (getAttr<OverloadableAttr>()) 2492 return 0; 2493 2494 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) 2495 return BuiltinID; 2496 2497 // This function has the name of a known C library 2498 // function. Determine whether it actually refers to the C library 2499 // function or whether it just has the same name. 2500 2501 // If this is a static function, it's not a builtin. 2502 if (getStorageClass() == SC_Static) 2503 return 0; 2504 2505 return BuiltinID; 2506} 2507 2508 2509/// getNumParams - Return the number of parameters this function must have 2510/// based on its FunctionType. This is the length of the ParamInfo array 2511/// after it has been created. 2512unsigned FunctionDecl::getNumParams() const { 2513 const FunctionType *FT = getType()->castAs<FunctionType>(); 2514 if (isa<FunctionNoProtoType>(FT)) 2515 return 0; 2516 return cast<FunctionProtoType>(FT)->getNumArgs(); 2517 2518} 2519 2520void FunctionDecl::setParams(ASTContext &C, 2521 ArrayRef<ParmVarDecl *> NewParamInfo) { 2522 assert(ParamInfo == 0 && "Already has param info!"); 2523 assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!"); 2524 2525 // Zero params -> null pointer. 2526 if (!NewParamInfo.empty()) { 2527 ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()]; 2528 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo); 2529 } 2530} 2531 2532void FunctionDecl::setDeclsInPrototypeScope(ArrayRef<NamedDecl *> NewDecls) { 2533 assert(DeclsInPrototypeScope.empty() && "Already has prototype decls!"); 2534 2535 if (!NewDecls.empty()) { 2536 NamedDecl **A = new (getASTContext()) NamedDecl*[NewDecls.size()]; 2537 std::copy(NewDecls.begin(), NewDecls.end(), A); 2538 DeclsInPrototypeScope = ArrayRef<NamedDecl *>(A, NewDecls.size()); 2539 } 2540} 2541 2542/// getMinRequiredArguments - Returns the minimum number of arguments 2543/// needed to call this function. This may be fewer than the number of 2544/// function parameters, if some of the parameters have default 2545/// arguments (in C++) or the last parameter is a parameter pack. 2546unsigned FunctionDecl::getMinRequiredArguments() const { 2547 if (!getASTContext().getLangOpts().CPlusPlus) 2548 return getNumParams(); 2549 2550 unsigned NumRequiredArgs = getNumParams(); 2551 2552 // If the last parameter is a parameter pack, we don't need an argument for 2553 // it. 2554 if (NumRequiredArgs > 0 && 2555 getParamDecl(NumRequiredArgs - 1)->isParameterPack()) 2556 --NumRequiredArgs; 2557 2558 // If this parameter has a default argument, we don't need an argument for 2559 // it. 2560 while (NumRequiredArgs > 0 && 2561 getParamDecl(NumRequiredArgs-1)->hasDefaultArg()) 2562 --NumRequiredArgs; 2563 2564 // We might have parameter packs before the end. These can't be deduced, 2565 // but they can still handle multiple arguments. 2566 unsigned ArgIdx = NumRequiredArgs; 2567 while (ArgIdx > 0) { 2568 if (getParamDecl(ArgIdx - 1)->isParameterPack()) 2569 NumRequiredArgs = ArgIdx; 2570 2571 --ArgIdx; 2572 } 2573 2574 return NumRequiredArgs; 2575} 2576 2577static bool RedeclForcesDefC99(const FunctionDecl *Redecl) { 2578 // Only consider file-scope declarations in this test. 2579 if (!Redecl->getLexicalDeclContext()->isTranslationUnit()) 2580 return false; 2581 2582 // Only consider explicit declarations; the presence of a builtin for a 2583 // libcall shouldn't affect whether a definition is externally visible. 2584 if (Redecl->isImplicit()) 2585 return false; 2586 2587 if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern) 2588 return true; // Not an inline definition 2589 2590 return false; 2591} 2592 2593/// \brief For a function declaration in C or C++, determine whether this 2594/// declaration causes the definition to be externally visible. 2595/// 2596/// Specifically, this determines if adding the current declaration to the set 2597/// of redeclarations of the given functions causes 2598/// isInlineDefinitionExternallyVisible to change from false to true. 2599bool FunctionDecl::doesDeclarationForceExternallyVisibleDefinition() const { 2600 assert(!doesThisDeclarationHaveABody() && 2601 "Must have a declaration without a body."); 2602 2603 ASTContext &Context = getASTContext(); 2604 2605 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) { 2606 // With GNU inlining, a declaration with 'inline' but not 'extern', forces 2607 // an externally visible definition. 2608 // 2609 // FIXME: What happens if gnu_inline gets added on after the first 2610 // declaration? 2611 if (!isInlineSpecified() || getStorageClass() == SC_Extern) 2612 return false; 2613 2614 const FunctionDecl *Prev = this; 2615 bool FoundBody = false; 2616 while ((Prev = Prev->getPreviousDecl())) { 2617 FoundBody |= Prev->Body.isValid(); 2618 2619 if (Prev->Body) { 2620 // If it's not the case that both 'inline' and 'extern' are 2621 // specified on the definition, then it is always externally visible. 2622 if (!Prev->isInlineSpecified() || 2623 Prev->getStorageClass() != SC_Extern) 2624 return false; 2625 } else if (Prev->isInlineSpecified() && 2626 Prev->getStorageClass() != SC_Extern) { 2627 return false; 2628 } 2629 } 2630 return FoundBody; 2631 } 2632 2633 if (Context.getLangOpts().CPlusPlus) 2634 return false; 2635 2636 // C99 6.7.4p6: 2637 // [...] If all of the file scope declarations for a function in a 2638 // translation unit include the inline function specifier without extern, 2639 // then the definition in that translation unit is an inline definition. 2640 if (isInlineSpecified() && getStorageClass() != SC_Extern) 2641 return false; 2642 const FunctionDecl *Prev = this; 2643 bool FoundBody = false; 2644 while ((Prev = Prev->getPreviousDecl())) { 2645 FoundBody |= Prev->Body.isValid(); 2646 if (RedeclForcesDefC99(Prev)) 2647 return false; 2648 } 2649 return FoundBody; 2650} 2651 2652/// \brief For an inline function definition in C, or for a gnu_inline function 2653/// in C++, determine whether the definition will be externally visible. 2654/// 2655/// Inline function definitions are always available for inlining optimizations. 2656/// However, depending on the language dialect, declaration specifiers, and 2657/// attributes, the definition of an inline function may or may not be 2658/// "externally" visible to other translation units in the program. 2659/// 2660/// In C99, inline definitions are not externally visible by default. However, 2661/// if even one of the global-scope declarations is marked "extern inline", the 2662/// inline definition becomes externally visible (C99 6.7.4p6). 2663/// 2664/// In GNU89 mode, or if the gnu_inline attribute is attached to the function 2665/// definition, we use the GNU semantics for inline, which are nearly the 2666/// opposite of C99 semantics. In particular, "inline" by itself will create 2667/// an externally visible symbol, but "extern inline" will not create an 2668/// externally visible symbol. 2669bool FunctionDecl::isInlineDefinitionExternallyVisible() const { 2670 assert(doesThisDeclarationHaveABody() && "Must have the function definition"); 2671 assert(isInlined() && "Function must be inline"); 2672 ASTContext &Context = getASTContext(); 2673 2674 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) { 2675 // Note: If you change the logic here, please change 2676 // doesDeclarationForceExternallyVisibleDefinition as well. 2677 // 2678 // If it's not the case that both 'inline' and 'extern' are 2679 // specified on the definition, then this inline definition is 2680 // externally visible. 2681 if (!(isInlineSpecified() && getStorageClass() == SC_Extern)) 2682 return true; 2683 2684 // If any declaration is 'inline' but not 'extern', then this definition 2685 // is externally visible. 2686 for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end(); 2687 Redecl != RedeclEnd; 2688 ++Redecl) { 2689 if (Redecl->isInlineSpecified() && 2690 Redecl->getStorageClass() != SC_Extern) 2691 return true; 2692 } 2693 2694 return false; 2695 } 2696 2697 // The rest of this function is C-only. 2698 assert(!Context.getLangOpts().CPlusPlus && 2699 "should not use C inline rules in C++"); 2700 2701 // C99 6.7.4p6: 2702 // [...] If all of the file scope declarations for a function in a 2703 // translation unit include the inline function specifier without extern, 2704 // then the definition in that translation unit is an inline definition. 2705 for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end(); 2706 Redecl != RedeclEnd; 2707 ++Redecl) { 2708 if (RedeclForcesDefC99(*Redecl)) 2709 return true; 2710 } 2711 2712 // C99 6.7.4p6: 2713 // An inline definition does not provide an external definition for the 2714 // function, and does not forbid an external definition in another 2715 // translation unit. 2716 return false; 2717} 2718 2719/// getOverloadedOperator - Which C++ overloaded operator this 2720/// function represents, if any. 2721OverloadedOperatorKind FunctionDecl::getOverloadedOperator() const { 2722 if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName) 2723 return getDeclName().getCXXOverloadedOperator(); 2724 else 2725 return OO_None; 2726} 2727 2728/// getLiteralIdentifier - The literal suffix identifier this function 2729/// represents, if any. 2730const IdentifierInfo *FunctionDecl::getLiteralIdentifier() const { 2731 if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName) 2732 return getDeclName().getCXXLiteralIdentifier(); 2733 else 2734 return 0; 2735} 2736 2737FunctionDecl::TemplatedKind FunctionDecl::getTemplatedKind() const { 2738 if (TemplateOrSpecialization.isNull()) 2739 return TK_NonTemplate; 2740 if (TemplateOrSpecialization.is<FunctionTemplateDecl *>()) 2741 return TK_FunctionTemplate; 2742 if (TemplateOrSpecialization.is<MemberSpecializationInfo *>()) 2743 return TK_MemberSpecialization; 2744 if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>()) 2745 return TK_FunctionTemplateSpecialization; 2746 if (TemplateOrSpecialization.is 2747 <DependentFunctionTemplateSpecializationInfo*>()) 2748 return TK_DependentFunctionTemplateSpecialization; 2749 2750 llvm_unreachable("Did we miss a TemplateOrSpecialization type?"); 2751} 2752 2753FunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const { 2754 if (MemberSpecializationInfo *Info = getMemberSpecializationInfo()) 2755 return cast<FunctionDecl>(Info->getInstantiatedFrom()); 2756 2757 return 0; 2758} 2759 2760void 2761FunctionDecl::setInstantiationOfMemberFunction(ASTContext &C, 2762 FunctionDecl *FD, 2763 TemplateSpecializationKind TSK) { 2764 assert(TemplateOrSpecialization.isNull() && 2765 "Member function is already a specialization"); 2766 MemberSpecializationInfo *Info 2767 = new (C) MemberSpecializationInfo(FD, TSK); 2768 TemplateOrSpecialization = Info; 2769} 2770 2771bool FunctionDecl::isImplicitlyInstantiable() const { 2772 // If the function is invalid, it can't be implicitly instantiated. 2773 if (isInvalidDecl()) 2774 return false; 2775 2776 switch (getTemplateSpecializationKind()) { 2777 case TSK_Undeclared: 2778 case TSK_ExplicitInstantiationDefinition: 2779 return false; 2780 2781 case TSK_ImplicitInstantiation: 2782 return true; 2783 2784 // It is possible to instantiate TSK_ExplicitSpecialization kind 2785 // if the FunctionDecl has a class scope specialization pattern. 2786 case TSK_ExplicitSpecialization: 2787 return getClassScopeSpecializationPattern() != 0; 2788 2789 case TSK_ExplicitInstantiationDeclaration: 2790 // Handled below. 2791 break; 2792 } 2793 2794 // Find the actual template from which we will instantiate. 2795 const FunctionDecl *PatternDecl = getTemplateInstantiationPattern(); 2796 bool HasPattern = false; 2797 if (PatternDecl) 2798 HasPattern = PatternDecl->hasBody(PatternDecl); 2799 2800 // C++0x [temp.explicit]p9: 2801 // Except for inline functions, other explicit instantiation declarations 2802 // have the effect of suppressing the implicit instantiation of the entity 2803 // to which they refer. 2804 if (!HasPattern || !PatternDecl) 2805 return true; 2806 2807 return PatternDecl->isInlined(); 2808} 2809 2810bool FunctionDecl::isTemplateInstantiation() const { 2811 switch (getTemplateSpecializationKind()) { 2812 case TSK_Undeclared: 2813 case TSK_ExplicitSpecialization: 2814 return false; 2815 case TSK_ImplicitInstantiation: 2816 case TSK_ExplicitInstantiationDeclaration: 2817 case TSK_ExplicitInstantiationDefinition: 2818 return true; 2819 } 2820 llvm_unreachable("All TSK values handled."); 2821} 2822 2823FunctionDecl *FunctionDecl::getTemplateInstantiationPattern() const { 2824 // Handle class scope explicit specialization special case. 2825 if (getTemplateSpecializationKind() == TSK_ExplicitSpecialization) 2826 return getClassScopeSpecializationPattern(); 2827 2828 if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) { 2829 while (Primary->getInstantiatedFromMemberTemplate()) { 2830 // If we have hit a point where the user provided a specialization of 2831 // this template, we're done looking. 2832 if (Primary->isMemberSpecialization()) 2833 break; 2834 2835 Primary = Primary->getInstantiatedFromMemberTemplate(); 2836 } 2837 2838 return Primary->getTemplatedDecl(); 2839 } 2840 2841 return getInstantiatedFromMemberFunction(); 2842} 2843 2844FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const { 2845 if (FunctionTemplateSpecializationInfo *Info 2846 = TemplateOrSpecialization 2847 .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 2848 return Info->Template.getPointer(); 2849 } 2850 return 0; 2851} 2852 2853FunctionDecl *FunctionDecl::getClassScopeSpecializationPattern() const { 2854 return getASTContext().getClassScopeSpecializationPattern(this); 2855} 2856 2857const TemplateArgumentList * 2858FunctionDecl::getTemplateSpecializationArgs() const { 2859 if (FunctionTemplateSpecializationInfo *Info 2860 = TemplateOrSpecialization 2861 .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 2862 return Info->TemplateArguments; 2863 } 2864 return 0; 2865} 2866 2867const ASTTemplateArgumentListInfo * 2868FunctionDecl::getTemplateSpecializationArgsAsWritten() const { 2869 if (FunctionTemplateSpecializationInfo *Info 2870 = TemplateOrSpecialization 2871 .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 2872 return Info->TemplateArgumentsAsWritten; 2873 } 2874 return 0; 2875} 2876 2877void 2878FunctionDecl::setFunctionTemplateSpecialization(ASTContext &C, 2879 FunctionTemplateDecl *Template, 2880 const TemplateArgumentList *TemplateArgs, 2881 void *InsertPos, 2882 TemplateSpecializationKind TSK, 2883 const TemplateArgumentListInfo *TemplateArgsAsWritten, 2884 SourceLocation PointOfInstantiation) { 2885 assert(TSK != TSK_Undeclared && 2886 "Must specify the type of function template specialization"); 2887 FunctionTemplateSpecializationInfo *Info 2888 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>(); 2889 if (!Info) 2890 Info = FunctionTemplateSpecializationInfo::Create(C, this, Template, TSK, 2891 TemplateArgs, 2892 TemplateArgsAsWritten, 2893 PointOfInstantiation); 2894 TemplateOrSpecialization = Info; 2895 Template->addSpecialization(Info, InsertPos); 2896} 2897 2898void 2899FunctionDecl::setDependentTemplateSpecialization(ASTContext &Context, 2900 const UnresolvedSetImpl &Templates, 2901 const TemplateArgumentListInfo &TemplateArgs) { 2902 assert(TemplateOrSpecialization.isNull()); 2903 size_t Size = sizeof(DependentFunctionTemplateSpecializationInfo); 2904 Size += Templates.size() * sizeof(FunctionTemplateDecl*); 2905 Size += TemplateArgs.size() * sizeof(TemplateArgumentLoc); 2906 void *Buffer = Context.Allocate(Size); 2907 DependentFunctionTemplateSpecializationInfo *Info = 2908 new (Buffer) DependentFunctionTemplateSpecializationInfo(Templates, 2909 TemplateArgs); 2910 TemplateOrSpecialization = Info; 2911} 2912 2913DependentFunctionTemplateSpecializationInfo:: 2914DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts, 2915 const TemplateArgumentListInfo &TArgs) 2916 : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) { 2917 2918 d.NumTemplates = Ts.size(); 2919 d.NumArgs = TArgs.size(); 2920 2921 FunctionTemplateDecl **TsArray = 2922 const_cast<FunctionTemplateDecl**>(getTemplates()); 2923 for (unsigned I = 0, E = Ts.size(); I != E; ++I) 2924 TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl()); 2925 2926 TemplateArgumentLoc *ArgsArray = 2927 const_cast<TemplateArgumentLoc*>(getTemplateArgs()); 2928 for (unsigned I = 0, E = TArgs.size(); I != E; ++I) 2929 new (&ArgsArray[I]) TemplateArgumentLoc(TArgs[I]); 2930} 2931 2932TemplateSpecializationKind FunctionDecl::getTemplateSpecializationKind() const { 2933 // For a function template specialization, query the specialization 2934 // information object. 2935 FunctionTemplateSpecializationInfo *FTSInfo 2936 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>(); 2937 if (FTSInfo) 2938 return FTSInfo->getTemplateSpecializationKind(); 2939 2940 MemberSpecializationInfo *MSInfo 2941 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>(); 2942 if (MSInfo) 2943 return MSInfo->getTemplateSpecializationKind(); 2944 2945 return TSK_Undeclared; 2946} 2947 2948void 2949FunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 2950 SourceLocation PointOfInstantiation) { 2951 if (FunctionTemplateSpecializationInfo *FTSInfo 2952 = TemplateOrSpecialization.dyn_cast< 2953 FunctionTemplateSpecializationInfo*>()) { 2954 FTSInfo->setTemplateSpecializationKind(TSK); 2955 if (TSK != TSK_ExplicitSpecialization && 2956 PointOfInstantiation.isValid() && 2957 FTSInfo->getPointOfInstantiation().isInvalid()) 2958 FTSInfo->setPointOfInstantiation(PointOfInstantiation); 2959 } else if (MemberSpecializationInfo *MSInfo 2960 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) { 2961 MSInfo->setTemplateSpecializationKind(TSK); 2962 if (TSK != TSK_ExplicitSpecialization && 2963 PointOfInstantiation.isValid() && 2964 MSInfo->getPointOfInstantiation().isInvalid()) 2965 MSInfo->setPointOfInstantiation(PointOfInstantiation); 2966 } else 2967 llvm_unreachable("Function cannot have a template specialization kind"); 2968} 2969 2970SourceLocation FunctionDecl::getPointOfInstantiation() const { 2971 if (FunctionTemplateSpecializationInfo *FTSInfo 2972 = TemplateOrSpecialization.dyn_cast< 2973 FunctionTemplateSpecializationInfo*>()) 2974 return FTSInfo->getPointOfInstantiation(); 2975 else if (MemberSpecializationInfo *MSInfo 2976 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) 2977 return MSInfo->getPointOfInstantiation(); 2978 2979 return SourceLocation(); 2980} 2981 2982bool FunctionDecl::isOutOfLine() const { 2983 if (Decl::isOutOfLine()) 2984 return true; 2985 2986 // If this function was instantiated from a member function of a 2987 // class template, check whether that member function was defined out-of-line. 2988 if (FunctionDecl *FD = getInstantiatedFromMemberFunction()) { 2989 const FunctionDecl *Definition; 2990 if (FD->hasBody(Definition)) 2991 return Definition->isOutOfLine(); 2992 } 2993 2994 // If this function was instantiated from a function template, 2995 // check whether that function template was defined out-of-line. 2996 if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) { 2997 const FunctionDecl *Definition; 2998 if (FunTmpl->getTemplatedDecl()->hasBody(Definition)) 2999 return Definition->isOutOfLine(); 3000 } 3001 3002 return false; 3003} 3004 3005SourceRange FunctionDecl::getSourceRange() const { 3006 return SourceRange(getOuterLocStart(), EndRangeLoc); 3007} 3008 3009unsigned FunctionDecl::getMemoryFunctionKind() const { 3010 IdentifierInfo *FnInfo = getIdentifier(); 3011 3012 if (!FnInfo) 3013 return 0; 3014 3015 // Builtin handling. 3016 switch (getBuiltinID()) { 3017 case Builtin::BI__builtin_memset: 3018 case Builtin::BI__builtin___memset_chk: 3019 case Builtin::BImemset: 3020 return Builtin::BImemset; 3021 3022 case Builtin::BI__builtin_memcpy: 3023 case Builtin::BI__builtin___memcpy_chk: 3024 case Builtin::BImemcpy: 3025 return Builtin::BImemcpy; 3026 3027 case Builtin::BI__builtin_memmove: 3028 case Builtin::BI__builtin___memmove_chk: 3029 case Builtin::BImemmove: 3030 return Builtin::BImemmove; 3031 3032 case Builtin::BIstrlcpy: 3033 return Builtin::BIstrlcpy; 3034 case Builtin::BIstrlcat: 3035 return Builtin::BIstrlcat; 3036 3037 case Builtin::BI__builtin_memcmp: 3038 case Builtin::BImemcmp: 3039 return Builtin::BImemcmp; 3040 3041 case Builtin::BI__builtin_strncpy: 3042 case Builtin::BI__builtin___strncpy_chk: 3043 case Builtin::BIstrncpy: 3044 return Builtin::BIstrncpy; 3045 3046 case Builtin::BI__builtin_strncmp: 3047 case Builtin::BIstrncmp: 3048 return Builtin::BIstrncmp; 3049 3050 case Builtin::BI__builtin_strncasecmp: 3051 case Builtin::BIstrncasecmp: 3052 return Builtin::BIstrncasecmp; 3053 3054 case Builtin::BI__builtin_strncat: 3055 case Builtin::BI__builtin___strncat_chk: 3056 case Builtin::BIstrncat: 3057 return Builtin::BIstrncat; 3058 3059 case Builtin::BI__builtin_strndup: 3060 case Builtin::BIstrndup: 3061 return Builtin::BIstrndup; 3062 3063 case Builtin::BI__builtin_strlen: 3064 case Builtin::BIstrlen: 3065 return Builtin::BIstrlen; 3066 3067 default: 3068 if (isExternC()) { 3069 if (FnInfo->isStr("memset")) 3070 return Builtin::BImemset; 3071 else if (FnInfo->isStr("memcpy")) 3072 return Builtin::BImemcpy; 3073 else if (FnInfo->isStr("memmove")) 3074 return Builtin::BImemmove; 3075 else if (FnInfo->isStr("memcmp")) 3076 return Builtin::BImemcmp; 3077 else if (FnInfo->isStr("strncpy")) 3078 return Builtin::BIstrncpy; 3079 else if (FnInfo->isStr("strncmp")) 3080 return Builtin::BIstrncmp; 3081 else if (FnInfo->isStr("strncasecmp")) 3082 return Builtin::BIstrncasecmp; 3083 else if (FnInfo->isStr("strncat")) 3084 return Builtin::BIstrncat; 3085 else if (FnInfo->isStr("strndup")) 3086 return Builtin::BIstrndup; 3087 else if (FnInfo->isStr("strlen")) 3088 return Builtin::BIstrlen; 3089 } 3090 break; 3091 } 3092 return 0; 3093} 3094 3095//===----------------------------------------------------------------------===// 3096// FieldDecl Implementation 3097//===----------------------------------------------------------------------===// 3098 3099FieldDecl *FieldDecl::Create(const ASTContext &C, DeclContext *DC, 3100 SourceLocation StartLoc, SourceLocation IdLoc, 3101 IdentifierInfo *Id, QualType T, 3102 TypeSourceInfo *TInfo, Expr *BW, bool Mutable, 3103 InClassInitStyle InitStyle) { 3104 return new (C) FieldDecl(Decl::Field, DC, StartLoc, IdLoc, Id, T, TInfo, 3105 BW, Mutable, InitStyle); 3106} 3107 3108FieldDecl *FieldDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3109 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FieldDecl)); 3110 return new (Mem) FieldDecl(Field, 0, SourceLocation(), SourceLocation(), 3111 0, QualType(), 0, 0, false, ICIS_NoInit); 3112} 3113 3114bool FieldDecl::isAnonymousStructOrUnion() const { 3115 if (!isImplicit() || getDeclName()) 3116 return false; 3117 3118 if (const RecordType *Record = getType()->getAs<RecordType>()) 3119 return Record->getDecl()->isAnonymousStructOrUnion(); 3120 3121 return false; 3122} 3123 3124unsigned FieldDecl::getBitWidthValue(const ASTContext &Ctx) const { 3125 assert(isBitField() && "not a bitfield"); 3126 Expr *BitWidth = InitializerOrBitWidth.getPointer(); 3127 return BitWidth->EvaluateKnownConstInt(Ctx).getZExtValue(); 3128} 3129 3130unsigned FieldDecl::getFieldIndex() const { 3131 const FieldDecl *Canonical = getCanonicalDecl(); 3132 if (Canonical != this) 3133 return Canonical->getFieldIndex(); 3134 3135 if (CachedFieldIndex) return CachedFieldIndex - 1; 3136 3137 unsigned Index = 0; 3138 const RecordDecl *RD = getParent(); 3139 3140 for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end(); 3141 I != E; ++I, ++Index) 3142 I->getCanonicalDecl()->CachedFieldIndex = Index + 1; 3143 3144 assert(CachedFieldIndex && "failed to find field in parent"); 3145 return CachedFieldIndex - 1; 3146} 3147 3148SourceRange FieldDecl::getSourceRange() const { 3149 if (const Expr *E = InitializerOrBitWidth.getPointer()) 3150 return SourceRange(getInnerLocStart(), E->getLocEnd()); 3151 return DeclaratorDecl::getSourceRange(); 3152} 3153 3154void FieldDecl::setBitWidth(Expr *Width) { 3155 assert(!InitializerOrBitWidth.getPointer() && !hasInClassInitializer() && 3156 "bit width or initializer already set"); 3157 InitializerOrBitWidth.setPointer(Width); 3158} 3159 3160void FieldDecl::setInClassInitializer(Expr *Init) { 3161 assert(!InitializerOrBitWidth.getPointer() && hasInClassInitializer() && 3162 "bit width or initializer already set"); 3163 InitializerOrBitWidth.setPointer(Init); 3164} 3165 3166//===----------------------------------------------------------------------===// 3167// TagDecl Implementation 3168//===----------------------------------------------------------------------===// 3169 3170SourceLocation TagDecl::getOuterLocStart() const { 3171 return getTemplateOrInnerLocStart(this); 3172} 3173 3174SourceRange TagDecl::getSourceRange() const { 3175 SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation(); 3176 return SourceRange(getOuterLocStart(), E); 3177} 3178 3179TagDecl *TagDecl::getCanonicalDecl() { return getFirstDecl(); } 3180 3181void TagDecl::setTypedefNameForAnonDecl(TypedefNameDecl *TDD) { 3182 NamedDeclOrQualifier = TDD; 3183 if (TypeForDecl) 3184 assert(TypeForDecl->isLinkageValid()); 3185 assert(isLinkageValid()); 3186} 3187 3188void TagDecl::startDefinition() { 3189 IsBeingDefined = true; 3190 3191 if (CXXRecordDecl *D = dyn_cast<CXXRecordDecl>(this)) { 3192 struct CXXRecordDecl::DefinitionData *Data = 3193 new (getASTContext()) struct CXXRecordDecl::DefinitionData(D); 3194 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) 3195 cast<CXXRecordDecl>(*I)->DefinitionData = Data; 3196 } 3197} 3198 3199void TagDecl::completeDefinition() { 3200 assert((!isa<CXXRecordDecl>(this) || 3201 cast<CXXRecordDecl>(this)->hasDefinition()) && 3202 "definition completed but not started"); 3203 3204 IsCompleteDefinition = true; 3205 IsBeingDefined = false; 3206 3207 if (ASTMutationListener *L = getASTMutationListener()) 3208 L->CompletedTagDefinition(this); 3209} 3210 3211TagDecl *TagDecl::getDefinition() const { 3212 if (isCompleteDefinition()) 3213 return const_cast<TagDecl *>(this); 3214 3215 // If it's possible for us to have an out-of-date definition, check now. 3216 if (MayHaveOutOfDateDef) { 3217 if (IdentifierInfo *II = getIdentifier()) { 3218 if (II->isOutOfDate()) { 3219 updateOutOfDate(*II); 3220 } 3221 } 3222 } 3223 3224 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(this)) 3225 return CXXRD->getDefinition(); 3226 3227 for (redecl_iterator R = redecls_begin(), REnd = redecls_end(); 3228 R != REnd; ++R) 3229 if (R->isCompleteDefinition()) 3230 return *R; 3231 3232 return 0; 3233} 3234 3235void TagDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) { 3236 if (QualifierLoc) { 3237 // Make sure the extended qualifier info is allocated. 3238 if (!hasExtInfo()) 3239 NamedDeclOrQualifier = new (getASTContext()) ExtInfo; 3240 // Set qualifier info. 3241 getExtInfo()->QualifierLoc = QualifierLoc; 3242 } else { 3243 // Here Qualifier == 0, i.e., we are removing the qualifier (if any). 3244 if (hasExtInfo()) { 3245 if (getExtInfo()->NumTemplParamLists == 0) { 3246 getASTContext().Deallocate(getExtInfo()); 3247 NamedDeclOrQualifier = (TypedefNameDecl*) 0; 3248 } 3249 else 3250 getExtInfo()->QualifierLoc = QualifierLoc; 3251 } 3252 } 3253} 3254 3255void TagDecl::setTemplateParameterListsInfo(ASTContext &Context, 3256 unsigned NumTPLists, 3257 TemplateParameterList **TPLists) { 3258 assert(NumTPLists > 0); 3259 // Make sure the extended decl info is allocated. 3260 if (!hasExtInfo()) 3261 // Allocate external info struct. 3262 NamedDeclOrQualifier = new (getASTContext()) ExtInfo; 3263 // Set the template parameter lists info. 3264 getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists); 3265} 3266 3267//===----------------------------------------------------------------------===// 3268// EnumDecl Implementation 3269//===----------------------------------------------------------------------===// 3270 3271void EnumDecl::anchor() { } 3272 3273EnumDecl *EnumDecl::Create(ASTContext &C, DeclContext *DC, 3274 SourceLocation StartLoc, SourceLocation IdLoc, 3275 IdentifierInfo *Id, 3276 EnumDecl *PrevDecl, bool IsScoped, 3277 bool IsScopedUsingClassTag, bool IsFixed) { 3278 EnumDecl *Enum = new (C) EnumDecl(DC, StartLoc, IdLoc, Id, PrevDecl, 3279 IsScoped, IsScopedUsingClassTag, IsFixed); 3280 Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3281 C.getTypeDeclType(Enum, PrevDecl); 3282 return Enum; 3283} 3284 3285EnumDecl *EnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3286 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(EnumDecl)); 3287 EnumDecl *Enum = new (Mem) EnumDecl(0, SourceLocation(), SourceLocation(), 3288 0, 0, false, false, false); 3289 Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3290 return Enum; 3291} 3292 3293void EnumDecl::completeDefinition(QualType NewType, 3294 QualType NewPromotionType, 3295 unsigned NumPositiveBits, 3296 unsigned NumNegativeBits) { 3297 assert(!isCompleteDefinition() && "Cannot redefine enums!"); 3298 if (!IntegerType) 3299 IntegerType = NewType.getTypePtr(); 3300 PromotionType = NewPromotionType; 3301 setNumPositiveBits(NumPositiveBits); 3302 setNumNegativeBits(NumNegativeBits); 3303 TagDecl::completeDefinition(); 3304} 3305 3306TemplateSpecializationKind EnumDecl::getTemplateSpecializationKind() const { 3307 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 3308 return MSI->getTemplateSpecializationKind(); 3309 3310 return TSK_Undeclared; 3311} 3312 3313void EnumDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 3314 SourceLocation PointOfInstantiation) { 3315 MemberSpecializationInfo *MSI = getMemberSpecializationInfo(); 3316 assert(MSI && "Not an instantiated member enumeration?"); 3317 MSI->setTemplateSpecializationKind(TSK); 3318 if (TSK != TSK_ExplicitSpecialization && 3319 PointOfInstantiation.isValid() && 3320 MSI->getPointOfInstantiation().isInvalid()) 3321 MSI->setPointOfInstantiation(PointOfInstantiation); 3322} 3323 3324EnumDecl *EnumDecl::getInstantiatedFromMemberEnum() const { 3325 if (SpecializationInfo) 3326 return cast<EnumDecl>(SpecializationInfo->getInstantiatedFrom()); 3327 3328 return 0; 3329} 3330 3331void EnumDecl::setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED, 3332 TemplateSpecializationKind TSK) { 3333 assert(!SpecializationInfo && "Member enum is already a specialization"); 3334 SpecializationInfo = new (C) MemberSpecializationInfo(ED, TSK); 3335} 3336 3337//===----------------------------------------------------------------------===// 3338// RecordDecl Implementation 3339//===----------------------------------------------------------------------===// 3340 3341RecordDecl::RecordDecl(Kind DK, TagKind TK, DeclContext *DC, 3342 SourceLocation StartLoc, SourceLocation IdLoc, 3343 IdentifierInfo *Id, RecordDecl *PrevDecl) 3344 : TagDecl(DK, TK, DC, IdLoc, Id, PrevDecl, StartLoc) { 3345 HasFlexibleArrayMember = false; 3346 AnonymousStructOrUnion = false; 3347 HasObjectMember = false; 3348 HasVolatileMember = false; 3349 LoadedFieldsFromExternalStorage = false; 3350 assert(classof(static_cast<Decl*>(this)) && "Invalid Kind!"); 3351} 3352 3353RecordDecl *RecordDecl::Create(const ASTContext &C, TagKind TK, DeclContext *DC, 3354 SourceLocation StartLoc, SourceLocation IdLoc, 3355 IdentifierInfo *Id, RecordDecl* PrevDecl) { 3356 RecordDecl* R = new (C) RecordDecl(Record, TK, DC, StartLoc, IdLoc, Id, 3357 PrevDecl); 3358 R->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3359 3360 C.getTypeDeclType(R, PrevDecl); 3361 return R; 3362} 3363 3364RecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) { 3365 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(RecordDecl)); 3366 RecordDecl *R = new (Mem) RecordDecl(Record, TTK_Struct, 0, SourceLocation(), 3367 SourceLocation(), 0, 0); 3368 R->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3369 return R; 3370} 3371 3372bool RecordDecl::isInjectedClassName() const { 3373 return isImplicit() && getDeclName() && getDeclContext()->isRecord() && 3374 cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName(); 3375} 3376 3377RecordDecl::field_iterator RecordDecl::field_begin() const { 3378 if (hasExternalLexicalStorage() && !LoadedFieldsFromExternalStorage) 3379 LoadFieldsFromExternalStorage(); 3380 3381 return field_iterator(decl_iterator(FirstDecl)); 3382} 3383 3384/// completeDefinition - Notes that the definition of this type is now 3385/// complete. 3386void RecordDecl::completeDefinition() { 3387 assert(!isCompleteDefinition() && "Cannot redefine record!"); 3388 TagDecl::completeDefinition(); 3389} 3390 3391/// isMsStruct - Get whether or not this record uses ms_struct layout. 3392/// This which can be turned on with an attribute, pragma, or the 3393/// -mms-bitfields command-line option. 3394bool RecordDecl::isMsStruct(const ASTContext &C) const { 3395 return hasAttr<MsStructAttr>() || C.getLangOpts().MSBitfields == 1; 3396} 3397 3398static bool isFieldOrIndirectField(Decl::Kind K) { 3399 return FieldDecl::classofKind(K) || IndirectFieldDecl::classofKind(K); 3400} 3401 3402void RecordDecl::LoadFieldsFromExternalStorage() const { 3403 ExternalASTSource *Source = getASTContext().getExternalSource(); 3404 assert(hasExternalLexicalStorage() && Source && "No external storage?"); 3405 3406 // Notify that we have a RecordDecl doing some initialization. 3407 ExternalASTSource::Deserializing TheFields(Source); 3408 3409 SmallVector<Decl*, 64> Decls; 3410 LoadedFieldsFromExternalStorage = true; 3411 switch (Source->FindExternalLexicalDecls(this, isFieldOrIndirectField, 3412 Decls)) { 3413 case ELR_Success: 3414 break; 3415 3416 case ELR_AlreadyLoaded: 3417 case ELR_Failure: 3418 return; 3419 } 3420 3421#ifndef NDEBUG 3422 // Check that all decls we got were FieldDecls. 3423 for (unsigned i=0, e=Decls.size(); i != e; ++i) 3424 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i])); 3425#endif 3426 3427 if (Decls.empty()) 3428 return; 3429 3430 llvm::tie(FirstDecl, LastDecl) = BuildDeclChain(Decls, 3431 /*FieldsAlreadyLoaded=*/false); 3432} 3433 3434//===----------------------------------------------------------------------===// 3435// BlockDecl Implementation 3436//===----------------------------------------------------------------------===// 3437 3438void BlockDecl::setParams(ArrayRef<ParmVarDecl *> NewParamInfo) { 3439 assert(ParamInfo == 0 && "Already has param info!"); 3440 3441 // Zero params -> null pointer. 3442 if (!NewParamInfo.empty()) { 3443 NumParams = NewParamInfo.size(); 3444 ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()]; 3445 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo); 3446 } 3447} 3448 3449void BlockDecl::setCaptures(ASTContext &Context, 3450 const Capture *begin, 3451 const Capture *end, 3452 bool capturesCXXThis) { 3453 CapturesCXXThis = capturesCXXThis; 3454 3455 if (begin == end) { 3456 NumCaptures = 0; 3457 Captures = 0; 3458 return; 3459 } 3460 3461 NumCaptures = end - begin; 3462 3463 // Avoid new Capture[] because we don't want to provide a default 3464 // constructor. 3465 size_t allocationSize = NumCaptures * sizeof(Capture); 3466 void *buffer = Context.Allocate(allocationSize, /*alignment*/sizeof(void*)); 3467 memcpy(buffer, begin, allocationSize); 3468 Captures = static_cast<Capture*>(buffer); 3469} 3470 3471bool BlockDecl::capturesVariable(const VarDecl *variable) const { 3472 for (capture_const_iterator 3473 i = capture_begin(), e = capture_end(); i != e; ++i) 3474 // Only auto vars can be captured, so no redeclaration worries. 3475 if (i->getVariable() == variable) 3476 return true; 3477 3478 return false; 3479} 3480 3481SourceRange BlockDecl::getSourceRange() const { 3482 return SourceRange(getLocation(), Body? Body->getLocEnd() : getLocation()); 3483} 3484 3485//===----------------------------------------------------------------------===// 3486// Other Decl Allocation/Deallocation Method Implementations 3487//===----------------------------------------------------------------------===// 3488 3489void TranslationUnitDecl::anchor() { } 3490 3491TranslationUnitDecl *TranslationUnitDecl::Create(ASTContext &C) { 3492 return new (C) TranslationUnitDecl(C); 3493} 3494 3495void LabelDecl::anchor() { } 3496 3497LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC, 3498 SourceLocation IdentL, IdentifierInfo *II) { 3499 return new (C) LabelDecl(DC, IdentL, II, 0, IdentL); 3500} 3501 3502LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC, 3503 SourceLocation IdentL, IdentifierInfo *II, 3504 SourceLocation GnuLabelL) { 3505 assert(GnuLabelL != IdentL && "Use this only for GNU local labels"); 3506 return new (C) LabelDecl(DC, IdentL, II, 0, GnuLabelL); 3507} 3508 3509LabelDecl *LabelDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3510 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(LabelDecl)); 3511 return new (Mem) LabelDecl(0, SourceLocation(), 0, 0, SourceLocation()); 3512} 3513 3514void ValueDecl::anchor() { } 3515 3516bool ValueDecl::isWeak() const { 3517 for (attr_iterator I = attr_begin(), E = attr_end(); I != E; ++I) 3518 if (isa<WeakAttr>(*I) || isa<WeakRefAttr>(*I)) 3519 return true; 3520 3521 return isWeakImported(); 3522} 3523 3524void ImplicitParamDecl::anchor() { } 3525 3526ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, DeclContext *DC, 3527 SourceLocation IdLoc, 3528 IdentifierInfo *Id, 3529 QualType Type) { 3530 return new (C) ImplicitParamDecl(DC, IdLoc, Id, Type); 3531} 3532 3533ImplicitParamDecl *ImplicitParamDecl::CreateDeserialized(ASTContext &C, 3534 unsigned ID) { 3535 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ImplicitParamDecl)); 3536 return new (Mem) ImplicitParamDecl(0, SourceLocation(), 0, QualType()); 3537} 3538 3539FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC, 3540 SourceLocation StartLoc, 3541 const DeclarationNameInfo &NameInfo, 3542 QualType T, TypeSourceInfo *TInfo, 3543 StorageClass SC, 3544 bool isInlineSpecified, 3545 bool hasWrittenPrototype, 3546 bool isConstexprSpecified) { 3547 FunctionDecl *New = new (C) FunctionDecl(Function, DC, StartLoc, NameInfo, 3548 T, TInfo, SC, 3549 isInlineSpecified, 3550 isConstexprSpecified); 3551 New->HasWrittenPrototype = hasWrittenPrototype; 3552 return New; 3553} 3554 3555FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3556 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FunctionDecl)); 3557 return new (Mem) FunctionDecl(Function, 0, SourceLocation(), 3558 DeclarationNameInfo(), QualType(), 0, 3559 SC_None, false, false); 3560} 3561 3562BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) { 3563 return new (C) BlockDecl(DC, L); 3564} 3565 3566BlockDecl *BlockDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3567 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(BlockDecl)); 3568 return new (Mem) BlockDecl(0, SourceLocation()); 3569} 3570 3571MSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C, 3572 unsigned ID) { 3573 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(MSPropertyDecl)); 3574 return new (Mem) MSPropertyDecl(0, SourceLocation(), DeclarationName(), 3575 QualType(), 0, SourceLocation(), 3576 0, 0); 3577} 3578 3579CapturedDecl *CapturedDecl::Create(ASTContext &C, DeclContext *DC, 3580 unsigned NumParams) { 3581 unsigned Size = sizeof(CapturedDecl) + NumParams * sizeof(ImplicitParamDecl*); 3582 return new (C.Allocate(Size)) CapturedDecl(DC, NumParams); 3583} 3584 3585CapturedDecl *CapturedDecl::CreateDeserialized(ASTContext &C, unsigned ID, 3586 unsigned NumParams) { 3587 unsigned Size = sizeof(CapturedDecl) + NumParams * sizeof(ImplicitParamDecl*); 3588 void *Mem = AllocateDeserializedDecl(C, ID, Size); 3589 return new (Mem) CapturedDecl(0, NumParams); 3590} 3591 3592EnumConstantDecl *EnumConstantDecl::Create(ASTContext &C, EnumDecl *CD, 3593 SourceLocation L, 3594 IdentifierInfo *Id, QualType T, 3595 Expr *E, const llvm::APSInt &V) { 3596 return new (C) EnumConstantDecl(CD, L, Id, T, E, V); 3597} 3598 3599EnumConstantDecl * 3600EnumConstantDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3601 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(EnumConstantDecl)); 3602 return new (Mem) EnumConstantDecl(0, SourceLocation(), 0, QualType(), 0, 3603 llvm::APSInt()); 3604} 3605 3606void IndirectFieldDecl::anchor() { } 3607 3608IndirectFieldDecl * 3609IndirectFieldDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, 3610 IdentifierInfo *Id, QualType T, NamedDecl **CH, 3611 unsigned CHS) { 3612 return new (C) IndirectFieldDecl(DC, L, Id, T, CH, CHS); 3613} 3614 3615IndirectFieldDecl *IndirectFieldDecl::CreateDeserialized(ASTContext &C, 3616 unsigned ID) { 3617 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(IndirectFieldDecl)); 3618 return new (Mem) IndirectFieldDecl(0, SourceLocation(), DeclarationName(), 3619 QualType(), 0, 0); 3620} 3621 3622SourceRange EnumConstantDecl::getSourceRange() const { 3623 SourceLocation End = getLocation(); 3624 if (Init) 3625 End = Init->getLocEnd(); 3626 return SourceRange(getLocation(), End); 3627} 3628 3629void TypeDecl::anchor() { } 3630 3631TypedefDecl *TypedefDecl::Create(ASTContext &C, DeclContext *DC, 3632 SourceLocation StartLoc, SourceLocation IdLoc, 3633 IdentifierInfo *Id, TypeSourceInfo *TInfo) { 3634 return new (C) TypedefDecl(DC, StartLoc, IdLoc, Id, TInfo); 3635} 3636 3637void TypedefNameDecl::anchor() { } 3638 3639TypedefDecl *TypedefDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3640 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TypedefDecl)); 3641 return new (Mem) TypedefDecl(0, SourceLocation(), SourceLocation(), 0, 0); 3642} 3643 3644TypeAliasDecl *TypeAliasDecl::Create(ASTContext &C, DeclContext *DC, 3645 SourceLocation StartLoc, 3646 SourceLocation IdLoc, IdentifierInfo *Id, 3647 TypeSourceInfo *TInfo) { 3648 return new (C) TypeAliasDecl(DC, StartLoc, IdLoc, Id, TInfo); 3649} 3650 3651TypeAliasDecl *TypeAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3652 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TypeAliasDecl)); 3653 return new (Mem) TypeAliasDecl(0, SourceLocation(), SourceLocation(), 0, 0); 3654} 3655 3656SourceRange TypedefDecl::getSourceRange() const { 3657 SourceLocation RangeEnd = getLocation(); 3658 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) { 3659 if (typeIsPostfix(TInfo->getType())) 3660 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd(); 3661 } 3662 return SourceRange(getLocStart(), RangeEnd); 3663} 3664 3665SourceRange TypeAliasDecl::getSourceRange() const { 3666 SourceLocation RangeEnd = getLocStart(); 3667 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) 3668 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd(); 3669 return SourceRange(getLocStart(), RangeEnd); 3670} 3671 3672void FileScopeAsmDecl::anchor() { } 3673 3674FileScopeAsmDecl *FileScopeAsmDecl::Create(ASTContext &C, DeclContext *DC, 3675 StringLiteral *Str, 3676 SourceLocation AsmLoc, 3677 SourceLocation RParenLoc) { 3678 return new (C) FileScopeAsmDecl(DC, Str, AsmLoc, RParenLoc); 3679} 3680 3681FileScopeAsmDecl *FileScopeAsmDecl::CreateDeserialized(ASTContext &C, 3682 unsigned ID) { 3683 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FileScopeAsmDecl)); 3684 return new (Mem) FileScopeAsmDecl(0, 0, SourceLocation(), SourceLocation()); 3685} 3686 3687void EmptyDecl::anchor() {} 3688 3689EmptyDecl *EmptyDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) { 3690 return new (C) EmptyDecl(DC, L); 3691} 3692 3693EmptyDecl *EmptyDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3694 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(EmptyDecl)); 3695 return new (Mem) EmptyDecl(0, SourceLocation()); 3696} 3697 3698//===----------------------------------------------------------------------===// 3699// ImportDecl Implementation 3700//===----------------------------------------------------------------------===// 3701 3702/// \brief Retrieve the number of module identifiers needed to name the given 3703/// module. 3704static unsigned getNumModuleIdentifiers(Module *Mod) { 3705 unsigned Result = 1; 3706 while (Mod->Parent) { 3707 Mod = Mod->Parent; 3708 ++Result; 3709 } 3710 return Result; 3711} 3712 3713ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc, 3714 Module *Imported, 3715 ArrayRef<SourceLocation> IdentifierLocs) 3716 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, true), 3717 NextLocalImport() 3718{ 3719 assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size()); 3720 SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(this + 1); 3721 memcpy(StoredLocs, IdentifierLocs.data(), 3722 IdentifierLocs.size() * sizeof(SourceLocation)); 3723} 3724 3725ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc, 3726 Module *Imported, SourceLocation EndLoc) 3727 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, false), 3728 NextLocalImport() 3729{ 3730 *reinterpret_cast<SourceLocation *>(this + 1) = EndLoc; 3731} 3732 3733ImportDecl *ImportDecl::Create(ASTContext &C, DeclContext *DC, 3734 SourceLocation StartLoc, Module *Imported, 3735 ArrayRef<SourceLocation> IdentifierLocs) { 3736 void *Mem = C.Allocate(sizeof(ImportDecl) + 3737 IdentifierLocs.size() * sizeof(SourceLocation)); 3738 return new (Mem) ImportDecl(DC, StartLoc, Imported, IdentifierLocs); 3739} 3740 3741ImportDecl *ImportDecl::CreateImplicit(ASTContext &C, DeclContext *DC, 3742 SourceLocation StartLoc, 3743 Module *Imported, 3744 SourceLocation EndLoc) { 3745 void *Mem = C.Allocate(sizeof(ImportDecl) + sizeof(SourceLocation)); 3746 ImportDecl *Import = new (Mem) ImportDecl(DC, StartLoc, Imported, EndLoc); 3747 Import->setImplicit(); 3748 return Import; 3749} 3750 3751ImportDecl *ImportDecl::CreateDeserialized(ASTContext &C, unsigned ID, 3752 unsigned NumLocations) { 3753 void *Mem = AllocateDeserializedDecl(C, ID, 3754 (sizeof(ImportDecl) + 3755 NumLocations * sizeof(SourceLocation))); 3756 return new (Mem) ImportDecl(EmptyShell()); 3757} 3758 3759ArrayRef<SourceLocation> ImportDecl::getIdentifierLocs() const { 3760 if (!ImportedAndComplete.getInt()) 3761 return None; 3762 3763 const SourceLocation *StoredLocs 3764 = reinterpret_cast<const SourceLocation *>(this + 1); 3765 return ArrayRef<SourceLocation>(StoredLocs, 3766 getNumModuleIdentifiers(getImportedModule())); 3767} 3768 3769SourceRange ImportDecl::getSourceRange() const { 3770 if (!ImportedAndComplete.getInt()) 3771 return SourceRange(getLocation(), 3772 *reinterpret_cast<const SourceLocation *>(this + 1)); 3773 3774 return SourceRange(getLocation(), getIdentifierLocs().back()); 3775} 3776