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 35 using namespace clang; 36 37 Decl *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 91 const unsigned IgnoreExplicitVisibilityBit = 2; 92 const 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. 97 enum 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? 125 static 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. 131 static LVComputationKind 132 withExplicitVisibilityAlready(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 143 static 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? 152 static 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? 160 template <class T> static typename 161 llvm::enable_if_c<!llvm::is_base_of<RedeclarableTemplateDecl, T>::value, 162 bool>::type 163 isExplicitMemberSpecialization(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. 174 static bool isExplicitMemberSpecialization(const RedeclarableTemplateDecl *D) { 175 return D->isMemberSpecialization(); 176 } 177 178 /// Given a visibility attribute, return the explicit visibility 179 /// associated with it. 180 template <class T> 181 static 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. 194 static 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 223 static LinkageInfo 224 getLVForType(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. 233 static LinkageInfo 234 getLVForTemplateParameterList(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. 291 static LinkageInfo getLVForDecl(const NamedDecl *D, 292 LVComputationKind computation); 293 294 static 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. 310 static LinkageInfo 311 getLVForTemplateArgumentList(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 355 static LinkageInfo 356 getLVForTemplateArgumentList(const TemplateArgumentList &TArgs, 357 LVComputationKind computation) { 358 return getLVForTemplateArgumentList(TArgs.asArray(), computation); 359 } 360 361 static 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 380 static void 381 mergeTemplateLV(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? 401 static 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? 422 static 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. 458 static 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 482 static 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 510 template <typename T> static bool isFirstInExternCContext(T *D) { 511 const T *First = D->getFirstDecl(); 512 return First->isInExternCContext(); 513 } 514 515 static 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 522 static 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 779 static 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 927 void NamedDecl::anchor() { } 928 929 static LinkageInfo computeLVForDecl(const NamedDecl *D, 930 LVComputationKind computation); 931 932 bool NamedDecl::isLinkageValid() const { 933 if (!hasCachedLinkage()) 934 return true; 935 936 return computeLVForDecl(this, LVForLinkageOnly).getLinkage() == 937 getCachedLinkage(); 938 } 939 940 Linkage 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 946 LinkageInfo NamedDecl::getLinkageAndVisibility() const { 947 LVComputationKind computation = 948 (usesTypeVisibility(this) ? LVForType : LVForValue); 949 return getLVForDecl(this, computation); 950 } 951 952 Optional<Visibility> 953 NamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const { 954 // Check the declaration itself first. 955 if (Optional<Visibility> V = getVisibilityOf(this, kind)) 956 return V; 957 958 // If this is a member class of a specialization of a class template 959 // and the corresponding decl has explicit visibility, use that. 960 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(this)) { 961 CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass(); 962 if (InstantiatedFrom) 963 return getVisibilityOf(InstantiatedFrom, kind); 964 } 965 966 // If there wasn't explicit visibility there, and this is a 967 // specialization of a class template, check for visibility 968 // on the pattern. 969 if (const ClassTemplateSpecializationDecl *spec 970 = dyn_cast<ClassTemplateSpecializationDecl>(this)) 971 return getVisibilityOf(spec->getSpecializedTemplate()->getTemplatedDecl(), 972 kind); 973 974 // Use the most recent declaration. 975 const NamedDecl *MostRecent = getMostRecentDecl(); 976 if (MostRecent != this) 977 return MostRecent->getExplicitVisibility(kind); 978 979 if (const VarDecl *Var = dyn_cast<VarDecl>(this)) { 980 if (Var->isStaticDataMember()) { 981 VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember(); 982 if (InstantiatedFrom) 983 return getVisibilityOf(InstantiatedFrom, kind); 984 } 985 986 return None; 987 } 988 // Also handle function template specializations. 989 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(this)) { 990 // If the function is a specialization of a template with an 991 // explicit visibility attribute, use that. 992 if (FunctionTemplateSpecializationInfo *templateInfo 993 = fn->getTemplateSpecializationInfo()) 994 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(), 995 kind); 996 997 // If the function is a member of a specialization of a class template 998 // and the corresponding decl has explicit visibility, use that. 999 FunctionDecl *InstantiatedFrom = fn->getInstantiatedFromMemberFunction(); 1000 if (InstantiatedFrom) 1001 return getVisibilityOf(InstantiatedFrom, kind); 1002 1003 return None; 1004 } 1005 1006 // The visibility of a template is stored in the templated decl. 1007 if (const TemplateDecl *TD = dyn_cast<TemplateDecl>(this)) 1008 return getVisibilityOf(TD->getTemplatedDecl(), kind); 1009 1010 return None; 1011 } 1012 1013 static LinkageInfo getLVForClosure(const DeclContext *DC, Decl *ContextDecl, 1014 LVComputationKind computation) { 1015 // This lambda has its linkage/visibility determined by its owner. 1016 if (ContextDecl) { 1017 if (isa<ParmVarDecl>(ContextDecl)) 1018 DC = ContextDecl->getDeclContext()->getRedeclContext(); 1019 else 1020 return getLVForDecl(cast<NamedDecl>(ContextDecl), computation); 1021 } 1022 1023 if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC)) 1024 return getLVForDecl(ND, computation); 1025 1026 return LinkageInfo::external(); 1027 } 1028 1029 static LinkageInfo getLVForLocalDecl(const NamedDecl *D, 1030 LVComputationKind computation) { 1031 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 1032 if (Function->isInAnonymousNamespace() && 1033 !Function->isInExternCContext()) 1034 return LinkageInfo::uniqueExternal(); 1035 1036 // This is a "void f();" which got merged with a file static. 1037 if (Function->getCanonicalDecl()->getStorageClass() == SC_Static) 1038 return LinkageInfo::internal(); 1039 1040 LinkageInfo LV; 1041 if (!hasExplicitVisibilityAlready(computation)) { 1042 if (Optional<Visibility> Vis = 1043 getExplicitVisibility(Function, computation)) 1044 LV.mergeVisibility(*Vis, true); 1045 } 1046 1047 // Note that Sema::MergeCompatibleFunctionDecls already takes care of 1048 // merging storage classes and visibility attributes, so we don't have to 1049 // look at previous decls in here. 1050 1051 return LV; 1052 } 1053 1054 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) { 1055 if (Var->hasExternalStorage()) { 1056 if (Var->isInAnonymousNamespace() && !Var->isInExternCContext()) 1057 return LinkageInfo::uniqueExternal(); 1058 1059 LinkageInfo LV; 1060 if (Var->getStorageClass() == SC_PrivateExtern) 1061 LV.mergeVisibility(HiddenVisibility, true); 1062 else if (!hasExplicitVisibilityAlready(computation)) { 1063 if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation)) 1064 LV.mergeVisibility(*Vis, true); 1065 } 1066 1067 if (const VarDecl *Prev = Var->getPreviousDecl()) { 1068 LinkageInfo PrevLV = getLVForDecl(Prev, computation); 1069 if (PrevLV.getLinkage()) 1070 LV.setLinkage(PrevLV.getLinkage()); 1071 LV.mergeVisibility(PrevLV); 1072 } 1073 1074 return LV; 1075 } 1076 1077 if (!Var->isStaticLocal()) 1078 return LinkageInfo::none(); 1079 } 1080 1081 ASTContext &Context = D->getASTContext(); 1082 if (!Context.getLangOpts().CPlusPlus) 1083 return LinkageInfo::none(); 1084 1085 const Decl *OuterD = getOutermostFuncOrBlockContext(D); 1086 if (!OuterD) 1087 return LinkageInfo::none(); 1088 1089 LinkageInfo LV; 1090 if (const BlockDecl *BD = dyn_cast<BlockDecl>(OuterD)) { 1091 if (!BD->getBlockManglingNumber()) 1092 return LinkageInfo::none(); 1093 1094 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(), 1095 BD->getBlockManglingContextDecl(), computation); 1096 } else { 1097 const FunctionDecl *FD = cast<FunctionDecl>(OuterD); 1098 if (!FD->isInlined() && 1099 FD->getTemplateSpecializationKind() == TSK_Undeclared) 1100 return LinkageInfo::none(); 1101 1102 LV = getLVForDecl(FD, computation); 1103 } 1104 if (!isExternallyVisible(LV.getLinkage())) 1105 return LinkageInfo::none(); 1106 return LinkageInfo(VisibleNoLinkage, LV.getVisibility(), 1107 LV.isVisibilityExplicit()); 1108 } 1109 1110 static inline const CXXRecordDecl* 1111 getOutermostEnclosingLambda(const CXXRecordDecl *Record) { 1112 const CXXRecordDecl *Ret = Record; 1113 while (Record && Record->isLambda()) { 1114 Ret = Record; 1115 if (!Record->getParent()) break; 1116 // Get the Containing Class of this Lambda Class 1117 Record = dyn_cast_or_null<CXXRecordDecl>( 1118 Record->getParent()->getParent()); 1119 } 1120 return Ret; 1121 } 1122 1123 static LinkageInfo computeLVForDecl(const NamedDecl *D, 1124 LVComputationKind computation) { 1125 // Objective-C: treat all Objective-C declarations as having external 1126 // linkage. 1127 switch (D->getKind()) { 1128 default: 1129 break; 1130 case Decl::ParmVar: 1131 return LinkageInfo::none(); 1132 case Decl::TemplateTemplateParm: // count these as external 1133 case Decl::NonTypeTemplateParm: 1134 case Decl::ObjCAtDefsField: 1135 case Decl::ObjCCategory: 1136 case Decl::ObjCCategoryImpl: 1137 case Decl::ObjCCompatibleAlias: 1138 case Decl::ObjCImplementation: 1139 case Decl::ObjCMethod: 1140 case Decl::ObjCProperty: 1141 case Decl::ObjCPropertyImpl: 1142 case Decl::ObjCProtocol: 1143 return LinkageInfo::external(); 1144 1145 case Decl::CXXRecord: { 1146 const CXXRecordDecl *Record = cast<CXXRecordDecl>(D); 1147 if (Record->isLambda()) { 1148 if (!Record->getLambdaManglingNumber()) { 1149 // This lambda has no mangling number, so it's internal. 1150 return LinkageInfo::internal(); 1151 } 1152 1153 // This lambda has its linkage/visibility determined: 1154 // - either by the outermost lambda if that lambda has no mangling 1155 // number. 1156 // - or by the parent of the outer most lambda 1157 // This prevents infinite recursion in settings such as nested lambdas 1158 // used in NSDMI's, for e.g. 1159 // struct L { 1160 // int t{}; 1161 // int t2 = ([](int a) { return [](int b) { return b; };})(t)(t); 1162 // }; 1163 const CXXRecordDecl *OuterMostLambda = 1164 getOutermostEnclosingLambda(Record); 1165 if (!OuterMostLambda->getLambdaManglingNumber()) 1166 return LinkageInfo::internal(); 1167 1168 return getLVForClosure( 1169 OuterMostLambda->getDeclContext()->getRedeclContext(), 1170 OuterMostLambda->getLambdaContextDecl(), computation); 1171 } 1172 1173 break; 1174 } 1175 } 1176 1177 // Handle linkage for namespace-scope names. 1178 if (D->getDeclContext()->getRedeclContext()->isFileContext()) 1179 return getLVForNamespaceScopeDecl(D, computation); 1180 1181 // C++ [basic.link]p5: 1182 // In addition, a member function, static data member, a named 1183 // class or enumeration of class scope, or an unnamed class or 1184 // enumeration defined in a class-scope typedef declaration such 1185 // that the class or enumeration has the typedef name for linkage 1186 // purposes (7.1.3), has external linkage if the name of the class 1187 // has external linkage. 1188 if (D->getDeclContext()->isRecord()) 1189 return getLVForClassMember(D, computation); 1190 1191 // C++ [basic.link]p6: 1192 // The name of a function declared in block scope and the name of 1193 // an object declared by a block scope extern declaration have 1194 // linkage. If there is a visible declaration of an entity with 1195 // linkage having the same name and type, ignoring entities 1196 // declared outside the innermost enclosing namespace scope, the 1197 // block scope declaration declares that same entity and receives 1198 // the linkage of the previous declaration. If there is more than 1199 // one such matching entity, the program is ill-formed. Otherwise, 1200 // if no matching entity is found, the block scope entity receives 1201 // external linkage. 1202 if (D->getDeclContext()->isFunctionOrMethod()) 1203 return getLVForLocalDecl(D, computation); 1204 1205 // C++ [basic.link]p6: 1206 // Names not covered by these rules have no linkage. 1207 return LinkageInfo::none(); 1208 } 1209 1210 namespace clang { 1211 class LinkageComputer { 1212 public: 1213 static LinkageInfo getLVForDecl(const NamedDecl *D, 1214 LVComputationKind computation) { 1215 if (computation == LVForLinkageOnly && D->hasCachedLinkage()) 1216 return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false); 1217 1218 LinkageInfo LV = computeLVForDecl(D, computation); 1219 if (D->hasCachedLinkage()) 1220 assert(D->getCachedLinkage() == LV.getLinkage()); 1221 1222 D->setCachedLinkage(LV.getLinkage()); 1223 1224 #ifndef NDEBUG 1225 // In C (because of gnu inline) and in c++ with microsoft extensions an 1226 // static can follow an extern, so we can have two decls with different 1227 // linkages. 1228 const LangOptions &Opts = D->getASTContext().getLangOpts(); 1229 if (!Opts.CPlusPlus || Opts.MicrosoftExt) 1230 return LV; 1231 1232 // We have just computed the linkage for this decl. By induction we know 1233 // that all other computed linkages match, check that the one we just 1234 // computed 1235 // also does. 1236 NamedDecl *Old = NULL; 1237 for (NamedDecl::redecl_iterator I = D->redecls_begin(), 1238 E = D->redecls_end(); 1239 I != E; ++I) { 1240 NamedDecl *T = cast<NamedDecl>(*I); 1241 if (T == D) 1242 continue; 1243 if (T->hasCachedLinkage()) { 1244 Old = T; 1245 break; 1246 } 1247 } 1248 assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage()); 1249 #endif 1250 1251 return LV; 1252 } 1253 }; 1254 } 1255 1256 static LinkageInfo getLVForDecl(const NamedDecl *D, 1257 LVComputationKind computation) { 1258 return clang::LinkageComputer::getLVForDecl(D, computation); 1259 } 1260 1261 std::string NamedDecl::getQualifiedNameAsString() const { 1262 return getQualifiedNameAsString(getASTContext().getPrintingPolicy()); 1263 } 1264 1265 std::string NamedDecl::getQualifiedNameAsString(const PrintingPolicy &P) const { 1266 std::string QualName; 1267 llvm::raw_string_ostream OS(QualName); 1268 printQualifiedName(OS, P); 1269 return OS.str(); 1270 } 1271 1272 void NamedDecl::printQualifiedName(raw_ostream &OS) const { 1273 printQualifiedName(OS, getASTContext().getPrintingPolicy()); 1274 } 1275 1276 void NamedDecl::printQualifiedName(raw_ostream &OS, 1277 const PrintingPolicy &P) const { 1278 const DeclContext *Ctx = getDeclContext(); 1279 1280 if (Ctx->isFunctionOrMethod()) { 1281 printName(OS); 1282 return; 1283 } 1284 1285 typedef SmallVector<const DeclContext *, 8> ContextsTy; 1286 ContextsTy Contexts; 1287 1288 // Collect contexts. 1289 while (Ctx && isa<NamedDecl>(Ctx)) { 1290 Contexts.push_back(Ctx); 1291 Ctx = Ctx->getParent(); 1292 } 1293 1294 for (ContextsTy::reverse_iterator I = Contexts.rbegin(), E = Contexts.rend(); 1295 I != E; ++I) { 1296 if (const ClassTemplateSpecializationDecl *Spec 1297 = dyn_cast<ClassTemplateSpecializationDecl>(*I)) { 1298 OS << Spec->getName(); 1299 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1300 TemplateSpecializationType::PrintTemplateArgumentList(OS, 1301 TemplateArgs.data(), 1302 TemplateArgs.size(), 1303 P); 1304 } else if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(*I)) { 1305 if (ND->isAnonymousNamespace()) 1306 OS << "<anonymous namespace>"; 1307 else 1308 OS << *ND; 1309 } else if (const RecordDecl *RD = dyn_cast<RecordDecl>(*I)) { 1310 if (!RD->getIdentifier()) 1311 OS << "<anonymous " << RD->getKindName() << '>'; 1312 else 1313 OS << *RD; 1314 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { 1315 const FunctionProtoType *FT = 0; 1316 if (FD->hasWrittenPrototype()) 1317 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>()); 1318 1319 OS << *FD << '('; 1320 if (FT) { 1321 unsigned NumParams = FD->getNumParams(); 1322 for (unsigned i = 0; i < NumParams; ++i) { 1323 if (i) 1324 OS << ", "; 1325 OS << FD->getParamDecl(i)->getType().stream(P); 1326 } 1327 1328 if (FT->isVariadic()) { 1329 if (NumParams > 0) 1330 OS << ", "; 1331 OS << "..."; 1332 } 1333 } 1334 OS << ')'; 1335 } else { 1336 OS << *cast<NamedDecl>(*I); 1337 } 1338 OS << "::"; 1339 } 1340 1341 if (getDeclName()) 1342 OS << *this; 1343 else 1344 OS << "<anonymous>"; 1345 } 1346 1347 void NamedDecl::getNameForDiagnostic(raw_ostream &OS, 1348 const PrintingPolicy &Policy, 1349 bool Qualified) const { 1350 if (Qualified) 1351 printQualifiedName(OS, Policy); 1352 else 1353 printName(OS); 1354 } 1355 1356 bool NamedDecl::declarationReplaces(NamedDecl *OldD) const { 1357 assert(getDeclName() == OldD->getDeclName() && "Declaration name mismatch"); 1358 1359 // UsingDirectiveDecl's are not really NamedDecl's, and all have same name. 1360 // We want to keep it, unless it nominates same namespace. 1361 if (getKind() == Decl::UsingDirective) { 1362 return cast<UsingDirectiveDecl>(this)->getNominatedNamespace() 1363 ->getOriginalNamespace() == 1364 cast<UsingDirectiveDecl>(OldD)->getNominatedNamespace() 1365 ->getOriginalNamespace(); 1366 } 1367 1368 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) 1369 // For function declarations, we keep track of redeclarations. 1370 return FD->getPreviousDecl() == OldD; 1371 1372 // For function templates, the underlying function declarations are linked. 1373 if (const FunctionTemplateDecl *FunctionTemplate 1374 = dyn_cast<FunctionTemplateDecl>(this)) 1375 if (const FunctionTemplateDecl *OldFunctionTemplate 1376 = dyn_cast<FunctionTemplateDecl>(OldD)) 1377 return FunctionTemplate->getTemplatedDecl() 1378 ->declarationReplaces(OldFunctionTemplate->getTemplatedDecl()); 1379 1380 // For method declarations, we keep track of redeclarations. 1381 if (isa<ObjCMethodDecl>(this)) 1382 return false; 1383 1384 if (isa<ObjCInterfaceDecl>(this) && isa<ObjCCompatibleAliasDecl>(OldD)) 1385 return true; 1386 1387 if (isa<UsingShadowDecl>(this) && isa<UsingShadowDecl>(OldD)) 1388 return cast<UsingShadowDecl>(this)->getTargetDecl() == 1389 cast<UsingShadowDecl>(OldD)->getTargetDecl(); 1390 1391 if (isa<UsingDecl>(this) && isa<UsingDecl>(OldD)) { 1392 ASTContext &Context = getASTContext(); 1393 return Context.getCanonicalNestedNameSpecifier( 1394 cast<UsingDecl>(this)->getQualifier()) == 1395 Context.getCanonicalNestedNameSpecifier( 1396 cast<UsingDecl>(OldD)->getQualifier()); 1397 } 1398 1399 if (isa<UnresolvedUsingValueDecl>(this) && 1400 isa<UnresolvedUsingValueDecl>(OldD)) { 1401 ASTContext &Context = getASTContext(); 1402 return Context.getCanonicalNestedNameSpecifier( 1403 cast<UnresolvedUsingValueDecl>(this)->getQualifier()) == 1404 Context.getCanonicalNestedNameSpecifier( 1405 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier()); 1406 } 1407 1408 // A typedef of an Objective-C class type can replace an Objective-C class 1409 // declaration or definition, and vice versa. 1410 if ((isa<TypedefNameDecl>(this) && isa<ObjCInterfaceDecl>(OldD)) || 1411 (isa<ObjCInterfaceDecl>(this) && isa<TypedefNameDecl>(OldD))) 1412 return true; 1413 1414 // For non-function declarations, if the declarations are of the 1415 // same kind then this must be a redeclaration, or semantic analysis 1416 // would not have given us the new declaration. 1417 return this->getKind() == OldD->getKind(); 1418 } 1419 1420 bool NamedDecl::hasLinkage() const { 1421 return getFormalLinkage() != NoLinkage; 1422 } 1423 1424 NamedDecl *NamedDecl::getUnderlyingDeclImpl() { 1425 NamedDecl *ND = this; 1426 while (UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(ND)) 1427 ND = UD->getTargetDecl(); 1428 1429 if (ObjCCompatibleAliasDecl *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND)) 1430 return AD->getClassInterface(); 1431 1432 return ND; 1433 } 1434 1435 bool NamedDecl::isCXXInstanceMember() const { 1436 if (!isCXXClassMember()) 1437 return false; 1438 1439 const NamedDecl *D = this; 1440 if (isa<UsingShadowDecl>(D)) 1441 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 1442 1443 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D)) 1444 return true; 1445 if (isa<CXXMethodDecl>(D)) 1446 return cast<CXXMethodDecl>(D)->isInstance(); 1447 if (isa<FunctionTemplateDecl>(D)) 1448 return cast<CXXMethodDecl>(cast<FunctionTemplateDecl>(D) 1449 ->getTemplatedDecl())->isInstance(); 1450 return false; 1451 } 1452 1453 //===----------------------------------------------------------------------===// 1454 // DeclaratorDecl Implementation 1455 //===----------------------------------------------------------------------===// 1456 1457 template <typename DeclT> 1458 static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl) { 1459 if (decl->getNumTemplateParameterLists() > 0) 1460 return decl->getTemplateParameterList(0)->getTemplateLoc(); 1461 else 1462 return decl->getInnerLocStart(); 1463 } 1464 1465 SourceLocation DeclaratorDecl::getTypeSpecStartLoc() const { 1466 TypeSourceInfo *TSI = getTypeSourceInfo(); 1467 if (TSI) return TSI->getTypeLoc().getBeginLoc(); 1468 return SourceLocation(); 1469 } 1470 1471 void DeclaratorDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) { 1472 if (QualifierLoc) { 1473 // Make sure the extended decl info is allocated. 1474 if (!hasExtInfo()) { 1475 // Save (non-extended) type source info pointer. 1476 TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>(); 1477 // Allocate external info struct. 1478 DeclInfo = new (getASTContext()) ExtInfo; 1479 // Restore savedTInfo into (extended) decl info. 1480 getExtInfo()->TInfo = savedTInfo; 1481 } 1482 // Set qualifier info. 1483 getExtInfo()->QualifierLoc = QualifierLoc; 1484 } else { 1485 // Here Qualifier == 0, i.e., we are removing the qualifier (if any). 1486 if (hasExtInfo()) { 1487 if (getExtInfo()->NumTemplParamLists == 0) { 1488 // Save type source info pointer. 1489 TypeSourceInfo *savedTInfo = getExtInfo()->TInfo; 1490 // Deallocate the extended decl info. 1491 getASTContext().Deallocate(getExtInfo()); 1492 // Restore savedTInfo into (non-extended) decl info. 1493 DeclInfo = savedTInfo; 1494 } 1495 else 1496 getExtInfo()->QualifierLoc = QualifierLoc; 1497 } 1498 } 1499 } 1500 1501 void 1502 DeclaratorDecl::setTemplateParameterListsInfo(ASTContext &Context, 1503 unsigned NumTPLists, 1504 TemplateParameterList **TPLists) { 1505 assert(NumTPLists > 0); 1506 // Make sure the extended decl info is allocated. 1507 if (!hasExtInfo()) { 1508 // Save (non-extended) type source info pointer. 1509 TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>(); 1510 // Allocate external info struct. 1511 DeclInfo = new (getASTContext()) ExtInfo; 1512 // Restore savedTInfo into (extended) decl info. 1513 getExtInfo()->TInfo = savedTInfo; 1514 } 1515 // Set the template parameter lists info. 1516 getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists); 1517 } 1518 1519 SourceLocation DeclaratorDecl::getOuterLocStart() const { 1520 return getTemplateOrInnerLocStart(this); 1521 } 1522 1523 namespace { 1524 1525 // Helper function: returns true if QT is or contains a type 1526 // having a postfix component. 1527 bool typeIsPostfix(clang::QualType QT) { 1528 while (true) { 1529 const Type* T = QT.getTypePtr(); 1530 switch (T->getTypeClass()) { 1531 default: 1532 return false; 1533 case Type::Pointer: 1534 QT = cast<PointerType>(T)->getPointeeType(); 1535 break; 1536 case Type::BlockPointer: 1537 QT = cast<BlockPointerType>(T)->getPointeeType(); 1538 break; 1539 case Type::MemberPointer: 1540 QT = cast<MemberPointerType>(T)->getPointeeType(); 1541 break; 1542 case Type::LValueReference: 1543 case Type::RValueReference: 1544 QT = cast<ReferenceType>(T)->getPointeeType(); 1545 break; 1546 case Type::PackExpansion: 1547 QT = cast<PackExpansionType>(T)->getPattern(); 1548 break; 1549 case Type::Paren: 1550 case Type::ConstantArray: 1551 case Type::DependentSizedArray: 1552 case Type::IncompleteArray: 1553 case Type::VariableArray: 1554 case Type::FunctionProto: 1555 case Type::FunctionNoProto: 1556 return true; 1557 } 1558 } 1559 } 1560 1561 } // namespace 1562 1563 SourceRange DeclaratorDecl::getSourceRange() const { 1564 SourceLocation RangeEnd = getLocation(); 1565 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) { 1566 if (typeIsPostfix(TInfo->getType())) 1567 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd(); 1568 } 1569 return SourceRange(getOuterLocStart(), RangeEnd); 1570 } 1571 1572 void 1573 QualifierInfo::setTemplateParameterListsInfo(ASTContext &Context, 1574 unsigned NumTPLists, 1575 TemplateParameterList **TPLists) { 1576 assert((NumTPLists == 0 || TPLists != 0) && 1577 "Empty array of template parameters with positive size!"); 1578 1579 // Free previous template parameters (if any). 1580 if (NumTemplParamLists > 0) { 1581 Context.Deallocate(TemplParamLists); 1582 TemplParamLists = 0; 1583 NumTemplParamLists = 0; 1584 } 1585 // Set info on matched template parameter lists (if any). 1586 if (NumTPLists > 0) { 1587 TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 1588 NumTemplParamLists = NumTPLists; 1589 for (unsigned i = NumTPLists; i-- > 0; ) 1590 TemplParamLists[i] = TPLists[i]; 1591 } 1592 } 1593 1594 //===----------------------------------------------------------------------===// 1595 // VarDecl Implementation 1596 //===----------------------------------------------------------------------===// 1597 1598 const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) { 1599 switch (SC) { 1600 case SC_None: break; 1601 case SC_Auto: return "auto"; 1602 case SC_Extern: return "extern"; 1603 case SC_OpenCLWorkGroupLocal: return "<<work-group-local>>"; 1604 case SC_PrivateExtern: return "__private_extern__"; 1605 case SC_Register: return "register"; 1606 case SC_Static: return "static"; 1607 } 1608 1609 llvm_unreachable("Invalid storage class"); 1610 } 1611 1612 VarDecl::VarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc, 1613 SourceLocation IdLoc, IdentifierInfo *Id, QualType T, 1614 TypeSourceInfo *TInfo, StorageClass SC) 1615 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc), Init() { 1616 assert(sizeof(VarDeclBitfields) <= sizeof(unsigned)); 1617 assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned)); 1618 AllBits = 0; 1619 VarDeclBits.SClass = SC; 1620 // Everything else is implicitly initialized to false. 1621 } 1622 1623 VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC, 1624 SourceLocation StartL, SourceLocation IdL, 1625 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, 1626 StorageClass S) { 1627 return new (C) VarDecl(Var, DC, StartL, IdL, Id, T, TInfo, S); 1628 } 1629 1630 VarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1631 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(VarDecl)); 1632 return new (Mem) VarDecl(Var, 0, SourceLocation(), SourceLocation(), 0, 1633 QualType(), 0, SC_None); 1634 } 1635 1636 void VarDecl::setStorageClass(StorageClass SC) { 1637 assert(isLegalForVariable(SC)); 1638 VarDeclBits.SClass = SC; 1639 } 1640 1641 SourceRange VarDecl::getSourceRange() const { 1642 if (const Expr *Init = getInit()) { 1643 SourceLocation InitEnd = Init->getLocEnd(); 1644 // If Init is implicit, ignore its source range and fallback on 1645 // DeclaratorDecl::getSourceRange() to handle postfix elements. 1646 if (InitEnd.isValid() && InitEnd != getLocation()) 1647 return SourceRange(getOuterLocStart(), InitEnd); 1648 } 1649 return DeclaratorDecl::getSourceRange(); 1650 } 1651 1652 template<typename T> 1653 static LanguageLinkage getLanguageLinkageTemplate(const T &D) { 1654 // C++ [dcl.link]p1: All function types, function names with external linkage, 1655 // and variable names with external linkage have a language linkage. 1656 if (!D.hasExternalFormalLinkage()) 1657 return NoLanguageLinkage; 1658 1659 // Language linkage is a C++ concept, but saying that everything else in C has 1660 // C language linkage fits the implementation nicely. 1661 ASTContext &Context = D.getASTContext(); 1662 if (!Context.getLangOpts().CPlusPlus) 1663 return CLanguageLinkage; 1664 1665 // C++ [dcl.link]p4: A C language linkage is ignored in determining the 1666 // language linkage of the names of class members and the function type of 1667 // class member functions. 1668 const DeclContext *DC = D.getDeclContext(); 1669 if (DC->isRecord()) 1670 return CXXLanguageLinkage; 1671 1672 // If the first decl is in an extern "C" context, any other redeclaration 1673 // will have C language linkage. If the first one is not in an extern "C" 1674 // context, we would have reported an error for any other decl being in one. 1675 if (isFirstInExternCContext(&D)) 1676 return CLanguageLinkage; 1677 return CXXLanguageLinkage; 1678 } 1679 1680 template<typename T> 1681 static bool isExternCTemplate(const T &D) { 1682 // Since the context is ignored for class members, they can only have C++ 1683 // language linkage or no language linkage. 1684 const DeclContext *DC = D.getDeclContext(); 1685 if (DC->isRecord()) { 1686 assert(D.getASTContext().getLangOpts().CPlusPlus); 1687 return false; 1688 } 1689 1690 return D.getLanguageLinkage() == CLanguageLinkage; 1691 } 1692 1693 LanguageLinkage VarDecl::getLanguageLinkage() const { 1694 return getLanguageLinkageTemplate(*this); 1695 } 1696 1697 bool VarDecl::isExternC() const { 1698 return isExternCTemplate(*this); 1699 } 1700 1701 bool VarDecl::isInExternCContext() const { 1702 return getLexicalDeclContext()->isExternCContext(); 1703 } 1704 1705 bool VarDecl::isInExternCXXContext() const { 1706 return getLexicalDeclContext()->isExternCXXContext(); 1707 } 1708 1709 VarDecl *VarDecl::getCanonicalDecl() { return getFirstDecl(); } 1710 1711 VarDecl::DefinitionKind VarDecl::isThisDeclarationADefinition( 1712 ASTContext &C) const 1713 { 1714 // C++ [basic.def]p2: 1715 // A declaration is a definition unless [...] it contains the 'extern' 1716 // specifier or a linkage-specification and neither an initializer [...], 1717 // it declares a static data member in a class declaration [...]. 1718 // C++1y [temp.expl.spec]p15: 1719 // An explicit specialization of a static data member or an explicit 1720 // specialization of a static data member template is a definition if the 1721 // declaration includes an initializer; otherwise, it is a declaration. 1722 // 1723 // FIXME: How do you declare (but not define) a partial specialization of 1724 // a static data member template outside the containing class? 1725 if (isStaticDataMember()) { 1726 if (isOutOfLine() && 1727 (hasInit() || 1728 // If the first declaration is out-of-line, this may be an 1729 // instantiation of an out-of-line partial specialization of a variable 1730 // template for which we have not yet instantiated the initializer. 1731 (getFirstDecl()->isOutOfLine() 1732 ? getTemplateSpecializationKind() == TSK_Undeclared 1733 : getTemplateSpecializationKind() != 1734 TSK_ExplicitSpecialization) || 1735 isa<VarTemplatePartialSpecializationDecl>(this))) 1736 return Definition; 1737 else 1738 return DeclarationOnly; 1739 } 1740 // C99 6.7p5: 1741 // A definition of an identifier is a declaration for that identifier that 1742 // [...] causes storage to be reserved for that object. 1743 // Note: that applies for all non-file-scope objects. 1744 // C99 6.9.2p1: 1745 // If the declaration of an identifier for an object has file scope and an 1746 // initializer, the declaration is an external definition for the identifier 1747 if (hasInit()) 1748 return Definition; 1749 1750 if (hasAttr<AliasAttr>()) 1751 return Definition; 1752 1753 // A variable template specialization (other than a static data member 1754 // template or an explicit specialization) is a declaration until we 1755 // instantiate its initializer. 1756 if (isa<VarTemplateSpecializationDecl>(this) && 1757 getTemplateSpecializationKind() != TSK_ExplicitSpecialization) 1758 return DeclarationOnly; 1759 1760 if (hasExternalStorage()) 1761 return DeclarationOnly; 1762 1763 // [dcl.link] p7: 1764 // A declaration directly contained in a linkage-specification is treated 1765 // as if it contains the extern specifier for the purpose of determining 1766 // the linkage of the declared name and whether it is a definition. 1767 if (isSingleLineExternC(*this)) 1768 return DeclarationOnly; 1769 1770 // C99 6.9.2p2: 1771 // A declaration of an object that has file scope without an initializer, 1772 // and without a storage class specifier or the scs 'static', constitutes 1773 // a tentative definition. 1774 // No such thing in C++. 1775 if (!C.getLangOpts().CPlusPlus && isFileVarDecl()) 1776 return TentativeDefinition; 1777 1778 // What's left is (in C, block-scope) declarations without initializers or 1779 // external storage. These are definitions. 1780 return Definition; 1781 } 1782 1783 VarDecl *VarDecl::getActingDefinition() { 1784 DefinitionKind Kind = isThisDeclarationADefinition(); 1785 if (Kind != TentativeDefinition) 1786 return 0; 1787 1788 VarDecl *LastTentative = 0; 1789 VarDecl *First = getFirstDecl(); 1790 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 1791 I != E; ++I) { 1792 Kind = (*I)->isThisDeclarationADefinition(); 1793 if (Kind == Definition) 1794 return 0; 1795 else if (Kind == TentativeDefinition) 1796 LastTentative = *I; 1797 } 1798 return LastTentative; 1799 } 1800 1801 VarDecl *VarDecl::getDefinition(ASTContext &C) { 1802 VarDecl *First = getFirstDecl(); 1803 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 1804 I != E; ++I) { 1805 if ((*I)->isThisDeclarationADefinition(C) == Definition) 1806 return *I; 1807 } 1808 return 0; 1809 } 1810 1811 VarDecl::DefinitionKind VarDecl::hasDefinition(ASTContext &C) const { 1812 DefinitionKind Kind = DeclarationOnly; 1813 1814 const VarDecl *First = getFirstDecl(); 1815 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 1816 I != E; ++I) { 1817 Kind = std::max(Kind, (*I)->isThisDeclarationADefinition(C)); 1818 if (Kind == Definition) 1819 break; 1820 } 1821 1822 return Kind; 1823 } 1824 1825 const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const { 1826 redecl_iterator I = redecls_begin(), E = redecls_end(); 1827 while (I != E && !I->getInit()) 1828 ++I; 1829 1830 if (I != E) { 1831 D = *I; 1832 return I->getInit(); 1833 } 1834 return 0; 1835 } 1836 1837 bool VarDecl::isOutOfLine() const { 1838 if (Decl::isOutOfLine()) 1839 return true; 1840 1841 if (!isStaticDataMember()) 1842 return false; 1843 1844 // If this static data member was instantiated from a static data member of 1845 // a class template, check whether that static data member was defined 1846 // out-of-line. 1847 if (VarDecl *VD = getInstantiatedFromStaticDataMember()) 1848 return VD->isOutOfLine(); 1849 1850 return false; 1851 } 1852 1853 VarDecl *VarDecl::getOutOfLineDefinition() { 1854 if (!isStaticDataMember()) 1855 return 0; 1856 1857 for (VarDecl::redecl_iterator RD = redecls_begin(), RDEnd = redecls_end(); 1858 RD != RDEnd; ++RD) { 1859 if (RD->getLexicalDeclContext()->isFileContext()) 1860 return *RD; 1861 } 1862 1863 return 0; 1864 } 1865 1866 void VarDecl::setInit(Expr *I) { 1867 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) { 1868 Eval->~EvaluatedStmt(); 1869 getASTContext().Deallocate(Eval); 1870 } 1871 1872 Init = I; 1873 } 1874 1875 bool VarDecl::isUsableInConstantExpressions(ASTContext &C) const { 1876 const LangOptions &Lang = C.getLangOpts(); 1877 1878 if (!Lang.CPlusPlus) 1879 return false; 1880 1881 // In C++11, any variable of reference type can be used in a constant 1882 // expression if it is initialized by a constant expression. 1883 if (Lang.CPlusPlus11 && getType()->isReferenceType()) 1884 return true; 1885 1886 // Only const objects can be used in constant expressions in C++. C++98 does 1887 // not require the variable to be non-volatile, but we consider this to be a 1888 // defect. 1889 if (!getType().isConstQualified() || getType().isVolatileQualified()) 1890 return false; 1891 1892 // In C++, const, non-volatile variables of integral or enumeration types 1893 // can be used in constant expressions. 1894 if (getType()->isIntegralOrEnumerationType()) 1895 return true; 1896 1897 // Additionally, in C++11, non-volatile constexpr variables can be used in 1898 // constant expressions. 1899 return Lang.CPlusPlus11 && isConstexpr(); 1900 } 1901 1902 /// Convert the initializer for this declaration to the elaborated EvaluatedStmt 1903 /// form, which contains extra information on the evaluated value of the 1904 /// initializer. 1905 EvaluatedStmt *VarDecl::ensureEvaluatedStmt() const { 1906 EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>(); 1907 if (!Eval) { 1908 Stmt *S = Init.get<Stmt *>(); 1909 // Note: EvaluatedStmt contains an APValue, which usually holds 1910 // resources not allocated from the ASTContext. We need to do some 1911 // work to avoid leaking those, but we do so in VarDecl::evaluateValue 1912 // where we can detect whether there's anything to clean up or not. 1913 Eval = new (getASTContext()) EvaluatedStmt; 1914 Eval->Value = S; 1915 Init = Eval; 1916 } 1917 return Eval; 1918 } 1919 1920 APValue *VarDecl::evaluateValue() const { 1921 SmallVector<PartialDiagnosticAt, 8> Notes; 1922 return evaluateValue(Notes); 1923 } 1924 1925 namespace { 1926 // Destroy an APValue that was allocated in an ASTContext. 1927 void DestroyAPValue(void* UntypedValue) { 1928 static_cast<APValue*>(UntypedValue)->~APValue(); 1929 } 1930 } // namespace 1931 1932 APValue *VarDecl::evaluateValue( 1933 SmallVectorImpl<PartialDiagnosticAt> &Notes) const { 1934 EvaluatedStmt *Eval = ensureEvaluatedStmt(); 1935 1936 // We only produce notes indicating why an initializer is non-constant the 1937 // first time it is evaluated. FIXME: The notes won't always be emitted the 1938 // first time we try evaluation, so might not be produced at all. 1939 if (Eval->WasEvaluated) 1940 return Eval->Evaluated.isUninit() ? 0 : &Eval->Evaluated; 1941 1942 const Expr *Init = cast<Expr>(Eval->Value); 1943 assert(!Init->isValueDependent()); 1944 1945 if (Eval->IsEvaluating) { 1946 // FIXME: Produce a diagnostic for self-initialization. 1947 Eval->CheckedICE = true; 1948 Eval->IsICE = false; 1949 return 0; 1950 } 1951 1952 Eval->IsEvaluating = true; 1953 1954 bool Result = Init->EvaluateAsInitializer(Eval->Evaluated, getASTContext(), 1955 this, Notes); 1956 1957 // Ensure the computed APValue is cleaned up later if evaluation succeeded, 1958 // or that it's empty (so that there's nothing to clean up) if evaluation 1959 // failed. 1960 if (!Result) 1961 Eval->Evaluated = APValue(); 1962 else if (Eval->Evaluated.needsCleanup()) 1963 getASTContext().AddDeallocation(DestroyAPValue, &Eval->Evaluated); 1964 1965 Eval->IsEvaluating = false; 1966 Eval->WasEvaluated = true; 1967 1968 // In C++11, we have determined whether the initializer was a constant 1969 // expression as a side-effect. 1970 if (getASTContext().getLangOpts().CPlusPlus11 && !Eval->CheckedICE) { 1971 Eval->CheckedICE = true; 1972 Eval->IsICE = Result && Notes.empty(); 1973 } 1974 1975 return Result ? &Eval->Evaluated : 0; 1976 } 1977 1978 bool VarDecl::checkInitIsICE() const { 1979 // Initializers of weak variables are never ICEs. 1980 if (isWeak()) 1981 return false; 1982 1983 EvaluatedStmt *Eval = ensureEvaluatedStmt(); 1984 if (Eval->CheckedICE) 1985 // We have already checked whether this subexpression is an 1986 // integral constant expression. 1987 return Eval->IsICE; 1988 1989 const Expr *Init = cast<Expr>(Eval->Value); 1990 assert(!Init->isValueDependent()); 1991 1992 // In C++11, evaluate the initializer to check whether it's a constant 1993 // expression. 1994 if (getASTContext().getLangOpts().CPlusPlus11) { 1995 SmallVector<PartialDiagnosticAt, 8> Notes; 1996 evaluateValue(Notes); 1997 return Eval->IsICE; 1998 } 1999 2000 // It's an ICE whether or not the definition we found is 2001 // out-of-line. See DR 721 and the discussion in Clang PR 2002 // 6206 for details. 2003 2004 if (Eval->CheckingICE) 2005 return false; 2006 Eval->CheckingICE = true; 2007 2008 Eval->IsICE = Init->isIntegerConstantExpr(getASTContext()); 2009 Eval->CheckingICE = false; 2010 Eval->CheckedICE = true; 2011 return Eval->IsICE; 2012 } 2013 2014 VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const { 2015 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 2016 return cast<VarDecl>(MSI->getInstantiatedFrom()); 2017 2018 return 0; 2019 } 2020 2021 TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const { 2022 if (const VarTemplateSpecializationDecl *Spec = 2023 dyn_cast<VarTemplateSpecializationDecl>(this)) 2024 return Spec->getSpecializationKind(); 2025 2026 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 2027 return MSI->getTemplateSpecializationKind(); 2028 2029 return TSK_Undeclared; 2030 } 2031 2032 SourceLocation VarDecl::getPointOfInstantiation() const { 2033 if (const VarTemplateSpecializationDecl *Spec = 2034 dyn_cast<VarTemplateSpecializationDecl>(this)) 2035 return Spec->getPointOfInstantiation(); 2036 2037 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 2038 return MSI->getPointOfInstantiation(); 2039 2040 return SourceLocation(); 2041 } 2042 2043 VarTemplateDecl *VarDecl::getDescribedVarTemplate() const { 2044 return getASTContext().getTemplateOrSpecializationInfo(this) 2045 .dyn_cast<VarTemplateDecl *>(); 2046 } 2047 2048 void VarDecl::setDescribedVarTemplate(VarTemplateDecl *Template) { 2049 getASTContext().setTemplateOrSpecializationInfo(this, Template); 2050 } 2051 2052 MemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const { 2053 if (isStaticDataMember()) 2054 // FIXME: Remove ? 2055 // return getASTContext().getInstantiatedFromStaticDataMember(this); 2056 return getASTContext().getTemplateOrSpecializationInfo(this) 2057 .dyn_cast<MemberSpecializationInfo *>(); 2058 return 0; 2059 } 2060 2061 void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 2062 SourceLocation PointOfInstantiation) { 2063 assert((isa<VarTemplateSpecializationDecl>(this) || 2064 getMemberSpecializationInfo()) && 2065 "not a variable or static data member template specialization"); 2066 2067 if (VarTemplateSpecializationDecl *Spec = 2068 dyn_cast<VarTemplateSpecializationDecl>(this)) { 2069 Spec->setSpecializationKind(TSK); 2070 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() && 2071 Spec->getPointOfInstantiation().isInvalid()) 2072 Spec->setPointOfInstantiation(PointOfInstantiation); 2073 } 2074 2075 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) { 2076 MSI->setTemplateSpecializationKind(TSK); 2077 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() && 2078 MSI->getPointOfInstantiation().isInvalid()) 2079 MSI->setPointOfInstantiation(PointOfInstantiation); 2080 } 2081 } 2082 2083 void 2084 VarDecl::setInstantiationOfStaticDataMember(VarDecl *VD, 2085 TemplateSpecializationKind TSK) { 2086 assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() && 2087 "Previous template or instantiation?"); 2088 getASTContext().setInstantiatedFromStaticDataMember(this, VD, TSK); 2089 } 2090 2091 //===----------------------------------------------------------------------===// 2092 // ParmVarDecl Implementation 2093 //===----------------------------------------------------------------------===// 2094 2095 ParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC, 2096 SourceLocation StartLoc, 2097 SourceLocation IdLoc, IdentifierInfo *Id, 2098 QualType T, TypeSourceInfo *TInfo, 2099 StorageClass S, Expr *DefArg) { 2100 return new (C) ParmVarDecl(ParmVar, DC, StartLoc, IdLoc, Id, T, TInfo, 2101 S, DefArg); 2102 } 2103 2104 QualType ParmVarDecl::getOriginalType() const { 2105 TypeSourceInfo *TSI = getTypeSourceInfo(); 2106 QualType T = TSI ? TSI->getType() : getType(); 2107 if (const DecayedType *DT = dyn_cast<DecayedType>(T)) 2108 return DT->getOriginalType(); 2109 return T; 2110 } 2111 2112 ParmVarDecl *ParmVarDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2113 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ParmVarDecl)); 2114 return new (Mem) ParmVarDecl(ParmVar, 0, SourceLocation(), SourceLocation(), 2115 0, QualType(), 0, SC_None, 0); 2116 } 2117 2118 SourceRange ParmVarDecl::getSourceRange() const { 2119 if (!hasInheritedDefaultArg()) { 2120 SourceRange ArgRange = getDefaultArgRange(); 2121 if (ArgRange.isValid()) 2122 return SourceRange(getOuterLocStart(), ArgRange.getEnd()); 2123 } 2124 2125 // DeclaratorDecl considers the range of postfix types as overlapping with the 2126 // declaration name, but this is not the case with parameters in ObjC methods. 2127 if (isa<ObjCMethodDecl>(getDeclContext())) 2128 return SourceRange(DeclaratorDecl::getLocStart(), getLocation()); 2129 2130 return DeclaratorDecl::getSourceRange(); 2131 } 2132 2133 Expr *ParmVarDecl::getDefaultArg() { 2134 assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!"); 2135 assert(!hasUninstantiatedDefaultArg() && 2136 "Default argument is not yet instantiated!"); 2137 2138 Expr *Arg = getInit(); 2139 if (ExprWithCleanups *E = dyn_cast_or_null<ExprWithCleanups>(Arg)) 2140 return E->getSubExpr(); 2141 2142 return Arg; 2143 } 2144 2145 SourceRange ParmVarDecl::getDefaultArgRange() const { 2146 if (const Expr *E = getInit()) 2147 return E->getSourceRange(); 2148 2149 if (hasUninstantiatedDefaultArg()) 2150 return getUninstantiatedDefaultArg()->getSourceRange(); 2151 2152 return SourceRange(); 2153 } 2154 2155 bool ParmVarDecl::isParameterPack() const { 2156 return isa<PackExpansionType>(getType()); 2157 } 2158 2159 void ParmVarDecl::setParameterIndexLarge(unsigned parameterIndex) { 2160 getASTContext().setParameterIndex(this, parameterIndex); 2161 ParmVarDeclBits.ParameterIndex = ParameterIndexSentinel; 2162 } 2163 2164 unsigned ParmVarDecl::getParameterIndexLarge() const { 2165 return getASTContext().getParameterIndex(this); 2166 } 2167 2168 //===----------------------------------------------------------------------===// 2169 // FunctionDecl Implementation 2170 //===----------------------------------------------------------------------===// 2171 2172 void FunctionDecl::getNameForDiagnostic( 2173 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const { 2174 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified); 2175 const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs(); 2176 if (TemplateArgs) 2177 TemplateSpecializationType::PrintTemplateArgumentList( 2178 OS, TemplateArgs->data(), TemplateArgs->size(), Policy); 2179 } 2180 2181 bool FunctionDecl::isVariadic() const { 2182 if (const FunctionProtoType *FT = getType()->getAs<FunctionProtoType>()) 2183 return FT->isVariadic(); 2184 return false; 2185 } 2186 2187 bool FunctionDecl::hasBody(const FunctionDecl *&Definition) const { 2188 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 2189 if (I->Body || I->IsLateTemplateParsed) { 2190 Definition = *I; 2191 return true; 2192 } 2193 } 2194 2195 return false; 2196 } 2197 2198 bool FunctionDecl::hasTrivialBody() const 2199 { 2200 Stmt *S = getBody(); 2201 if (!S) { 2202 // Since we don't have a body for this function, we don't know if it's 2203 // trivial or not. 2204 return false; 2205 } 2206 2207 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty()) 2208 return true; 2209 return false; 2210 } 2211 2212 bool FunctionDecl::isDefined(const FunctionDecl *&Definition) const { 2213 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 2214 if (I->IsDeleted || I->IsDefaulted || I->Body || I->IsLateTemplateParsed || 2215 I->hasAttr<AliasAttr>()) { 2216 Definition = I->IsDeleted ? I->getCanonicalDecl() : *I; 2217 return true; 2218 } 2219 } 2220 2221 return false; 2222 } 2223 2224 Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const { 2225 if (!hasBody(Definition)) 2226 return 0; 2227 2228 if (Definition->Body) 2229 return Definition->Body.get(getASTContext().getExternalSource()); 2230 2231 return 0; 2232 } 2233 2234 void FunctionDecl::setBody(Stmt *B) { 2235 Body = B; 2236 if (B) 2237 EndRangeLoc = B->getLocEnd(); 2238 } 2239 2240 void FunctionDecl::setPure(bool P) { 2241 IsPure = P; 2242 if (P) 2243 if (CXXRecordDecl *Parent = dyn_cast<CXXRecordDecl>(getDeclContext())) 2244 Parent->markedVirtualFunctionPure(); 2245 } 2246 2247 template<std::size_t Len> 2248 static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) { 2249 IdentifierInfo *II = ND->getIdentifier(); 2250 return II && II->isStr(Str); 2251 } 2252 2253 bool FunctionDecl::isMain() const { 2254 const TranslationUnitDecl *tunit = 2255 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext()); 2256 return tunit && 2257 !tunit->getASTContext().getLangOpts().Freestanding && 2258 isNamed(this, "main"); 2259 } 2260 2261 bool FunctionDecl::isMSVCRTEntryPoint() const { 2262 const TranslationUnitDecl *TUnit = 2263 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext()); 2264 if (!TUnit) 2265 return false; 2266 2267 // Even though we aren't really targeting MSVCRT if we are freestanding, 2268 // semantic analysis for these functions remains the same. 2269 2270 // MSVCRT entry points only exist on MSVCRT targets. 2271 if (!TUnit->getASTContext().getTargetInfo().getTriple().isOSMSVCRT()) 2272 return false; 2273 2274 // Nameless functions like constructors cannot be entry points. 2275 if (!getIdentifier()) 2276 return false; 2277 2278 return llvm::StringSwitch<bool>(getName()) 2279 .Cases("main", // an ANSI console app 2280 "wmain", // a Unicode console App 2281 "WinMain", // an ANSI GUI app 2282 "wWinMain", // a Unicode GUI app 2283 "DllMain", // a DLL 2284 true) 2285 .Default(false); 2286 } 2287 2288 bool FunctionDecl::isReservedGlobalPlacementOperator() const { 2289 assert(getDeclName().getNameKind() == DeclarationName::CXXOperatorName); 2290 assert(getDeclName().getCXXOverloadedOperator() == OO_New || 2291 getDeclName().getCXXOverloadedOperator() == OO_Delete || 2292 getDeclName().getCXXOverloadedOperator() == OO_Array_New || 2293 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete); 2294 2295 if (isa<CXXRecordDecl>(getDeclContext())) return false; 2296 assert(getDeclContext()->getRedeclContext()->isTranslationUnit()); 2297 2298 const FunctionProtoType *proto = getType()->castAs<FunctionProtoType>(); 2299 if (proto->getNumArgs() != 2 || proto->isVariadic()) return false; 2300 2301 ASTContext &Context = 2302 cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext()) 2303 ->getASTContext(); 2304 2305 // The result type and first argument type are constant across all 2306 // these operators. The second argument must be exactly void*. 2307 return (proto->getArgType(1).getCanonicalType() == Context.VoidPtrTy); 2308 } 2309 2310 static bool isNamespaceStd(const DeclContext *DC) { 2311 const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC->getRedeclContext()); 2312 return ND && isNamed(ND, "std") && 2313 ND->getParent()->getRedeclContext()->isTranslationUnit(); 2314 } 2315 2316 bool FunctionDecl::isReplaceableGlobalAllocationFunction() const { 2317 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName) 2318 return false; 2319 if (getDeclName().getCXXOverloadedOperator() != OO_New && 2320 getDeclName().getCXXOverloadedOperator() != OO_Delete && 2321 getDeclName().getCXXOverloadedOperator() != OO_Array_New && 2322 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) 2323 return false; 2324 2325 if (isa<CXXRecordDecl>(getDeclContext())) 2326 return false; 2327 assert(getDeclContext()->getRedeclContext()->isTranslationUnit()); 2328 2329 const FunctionProtoType *FPT = getType()->castAs<FunctionProtoType>(); 2330 if (FPT->getNumArgs() > 2 || FPT->isVariadic()) 2331 return false; 2332 2333 // If this is a single-parameter function, it must be a replaceable global 2334 // allocation or deallocation function. 2335 if (FPT->getNumArgs() == 1) 2336 return true; 2337 2338 // Otherwise, we're looking for a second parameter whose type is 2339 // 'const std::nothrow_t &', or, in C++1y, 'std::size_t'. 2340 QualType Ty = FPT->getArgType(1); 2341 ASTContext &Ctx = getASTContext(); 2342 if (Ctx.getLangOpts().SizedDeallocation && 2343 Ctx.hasSameType(Ty, Ctx.getSizeType())) 2344 return true; 2345 if (!Ty->isReferenceType()) 2346 return false; 2347 Ty = Ty->getPointeeType(); 2348 if (Ty.getCVRQualifiers() != Qualifiers::Const) 2349 return false; 2350 // FIXME: Recognise nothrow_t in an inline namespace inside std? 2351 const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 2352 return RD && isNamed(RD, "nothrow_t") && isNamespaceStd(RD->getDeclContext()); 2353 } 2354 2355 FunctionDecl * 2356 FunctionDecl::getCorrespondingUnsizedGlobalDeallocationFunction() const { 2357 ASTContext &Ctx = getASTContext(); 2358 if (!Ctx.getLangOpts().SizedDeallocation) 2359 return 0; 2360 2361 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName) 2362 return 0; 2363 if (getDeclName().getCXXOverloadedOperator() != OO_Delete && 2364 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) 2365 return 0; 2366 if (isa<CXXRecordDecl>(getDeclContext())) 2367 return 0; 2368 assert(getDeclContext()->getRedeclContext()->isTranslationUnit()); 2369 2370 if (getNumParams() != 2 || isVariadic() || 2371 !Ctx.hasSameType(getType()->castAs<FunctionProtoType>()->getArgType(1), 2372 Ctx.getSizeType())) 2373 return 0; 2374 2375 // This is a sized deallocation function. Find the corresponding unsized 2376 // deallocation function. 2377 lookup_const_result R = getDeclContext()->lookup(getDeclName()); 2378 for (lookup_const_result::iterator RI = R.begin(), RE = R.end(); RI != RE; 2379 ++RI) 2380 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*RI)) 2381 if (FD->getNumParams() == 1 && !FD->isVariadic()) 2382 return FD; 2383 return 0; 2384 } 2385 2386 LanguageLinkage FunctionDecl::getLanguageLinkage() const { 2387 return getLanguageLinkageTemplate(*this); 2388 } 2389 2390 bool FunctionDecl::isExternC() const { 2391 return isExternCTemplate(*this); 2392 } 2393 2394 bool FunctionDecl::isInExternCContext() const { 2395 return getLexicalDeclContext()->isExternCContext(); 2396 } 2397 2398 bool FunctionDecl::isInExternCXXContext() const { 2399 return getLexicalDeclContext()->isExternCXXContext(); 2400 } 2401 2402 bool FunctionDecl::isGlobal() const { 2403 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(this)) 2404 return Method->isStatic(); 2405 2406 if (getCanonicalDecl()->getStorageClass() == SC_Static) 2407 return false; 2408 2409 for (const DeclContext *DC = getDeclContext(); 2410 DC->isNamespace(); 2411 DC = DC->getParent()) { 2412 if (const NamespaceDecl *Namespace = cast<NamespaceDecl>(DC)) { 2413 if (!Namespace->getDeclName()) 2414 return false; 2415 break; 2416 } 2417 } 2418 2419 return true; 2420 } 2421 2422 bool FunctionDecl::isNoReturn() const { 2423 return hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() || 2424 hasAttr<C11NoReturnAttr>() || 2425 getType()->getAs<FunctionType>()->getNoReturnAttr(); 2426 } 2427 2428 void 2429 FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) { 2430 redeclarable_base::setPreviousDecl(PrevDecl); 2431 2432 if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) { 2433 FunctionTemplateDecl *PrevFunTmpl 2434 = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : 0; 2435 assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch"); 2436 FunTmpl->setPreviousDecl(PrevFunTmpl); 2437 } 2438 2439 if (PrevDecl && PrevDecl->IsInline) 2440 IsInline = true; 2441 } 2442 2443 const FunctionDecl *FunctionDecl::getCanonicalDecl() const { 2444 return getFirstDecl(); 2445 } 2446 2447 FunctionDecl *FunctionDecl::getCanonicalDecl() { return getFirstDecl(); } 2448 2449 /// \brief Returns a value indicating whether this function 2450 /// corresponds to a builtin function. 2451 /// 2452 /// The function corresponds to a built-in function if it is 2453 /// declared at translation scope or within an extern "C" block and 2454 /// its name matches with the name of a builtin. The returned value 2455 /// will be 0 for functions that do not correspond to a builtin, a 2456 /// value of type \c Builtin::ID if in the target-independent range 2457 /// \c [1,Builtin::First), or a target-specific builtin value. 2458 unsigned FunctionDecl::getBuiltinID() const { 2459 if (!getIdentifier()) 2460 return 0; 2461 2462 unsigned BuiltinID = getIdentifier()->getBuiltinID(); 2463 if (!BuiltinID) 2464 return 0; 2465 2466 ASTContext &Context = getASTContext(); 2467 if (Context.getLangOpts().CPlusPlus) { 2468 const LinkageSpecDecl *LinkageDecl = dyn_cast<LinkageSpecDecl>( 2469 getFirstDecl()->getDeclContext()); 2470 // In C++, the first declaration of a builtin is always inside an implicit 2471 // extern "C". 2472 // FIXME: A recognised library function may not be directly in an extern "C" 2473 // declaration, for instance "extern "C" { namespace std { decl } }". 2474 if (!LinkageDecl || LinkageDecl->getLanguage() != LinkageSpecDecl::lang_c) 2475 return 0; 2476 } 2477 2478 // If the function is marked "overloadable", it has a different mangled name 2479 // and is not the C library function. 2480 if (getAttr<OverloadableAttr>()) 2481 return 0; 2482 2483 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) 2484 return BuiltinID; 2485 2486 // This function has the name of a known C library 2487 // function. Determine whether it actually refers to the C library 2488 // function or whether it just has the same name. 2489 2490 // If this is a static function, it's not a builtin. 2491 if (getStorageClass() == SC_Static) 2492 return 0; 2493 2494 return BuiltinID; 2495 } 2496 2497 2498 /// getNumParams - Return the number of parameters this function must have 2499 /// based on its FunctionType. This is the length of the ParamInfo array 2500 /// after it has been created. 2501 unsigned FunctionDecl::getNumParams() const { 2502 const FunctionType *FT = getType()->castAs<FunctionType>(); 2503 if (isa<FunctionNoProtoType>(FT)) 2504 return 0; 2505 return cast<FunctionProtoType>(FT)->getNumArgs(); 2506 2507 } 2508 2509 void FunctionDecl::setParams(ASTContext &C, 2510 ArrayRef<ParmVarDecl *> NewParamInfo) { 2511 assert(ParamInfo == 0 && "Already has param info!"); 2512 assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!"); 2513 2514 // Zero params -> null pointer. 2515 if (!NewParamInfo.empty()) { 2516 ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()]; 2517 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo); 2518 } 2519 } 2520 2521 void FunctionDecl::setDeclsInPrototypeScope(ArrayRef<NamedDecl *> NewDecls) { 2522 assert(DeclsInPrototypeScope.empty() && "Already has prototype decls!"); 2523 2524 if (!NewDecls.empty()) { 2525 NamedDecl **A = new (getASTContext()) NamedDecl*[NewDecls.size()]; 2526 std::copy(NewDecls.begin(), NewDecls.end(), A); 2527 DeclsInPrototypeScope = ArrayRef<NamedDecl *>(A, NewDecls.size()); 2528 } 2529 } 2530 2531 /// getMinRequiredArguments - Returns the minimum number of arguments 2532 /// needed to call this function. This may be fewer than the number of 2533 /// function parameters, if some of the parameters have default 2534 /// arguments (in C++) or the last parameter is a parameter pack. 2535 unsigned FunctionDecl::getMinRequiredArguments() const { 2536 if (!getASTContext().getLangOpts().CPlusPlus) 2537 return getNumParams(); 2538 2539 unsigned NumRequiredArgs = getNumParams(); 2540 2541 // If the last parameter is a parameter pack, we don't need an argument for 2542 // it. 2543 if (NumRequiredArgs > 0 && 2544 getParamDecl(NumRequiredArgs - 1)->isParameterPack()) 2545 --NumRequiredArgs; 2546 2547 // If this parameter has a default argument, we don't need an argument for 2548 // it. 2549 while (NumRequiredArgs > 0 && 2550 getParamDecl(NumRequiredArgs-1)->hasDefaultArg()) 2551 --NumRequiredArgs; 2552 2553 // We might have parameter packs before the end. These can't be deduced, 2554 // but they can still handle multiple arguments. 2555 unsigned ArgIdx = NumRequiredArgs; 2556 while (ArgIdx > 0) { 2557 if (getParamDecl(ArgIdx - 1)->isParameterPack()) 2558 NumRequiredArgs = ArgIdx; 2559 2560 --ArgIdx; 2561 } 2562 2563 return NumRequiredArgs; 2564 } 2565 2566 static bool RedeclForcesDefC99(const FunctionDecl *Redecl) { 2567 // Only consider file-scope declarations in this test. 2568 if (!Redecl->getLexicalDeclContext()->isTranslationUnit()) 2569 return false; 2570 2571 // Only consider explicit declarations; the presence of a builtin for a 2572 // libcall shouldn't affect whether a definition is externally visible. 2573 if (Redecl->isImplicit()) 2574 return false; 2575 2576 if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern) 2577 return true; // Not an inline definition 2578 2579 return false; 2580 } 2581 2582 /// \brief For a function declaration in C or C++, determine whether this 2583 /// declaration causes the definition to be externally visible. 2584 /// 2585 /// Specifically, this determines if adding the current declaration to the set 2586 /// of redeclarations of the given functions causes 2587 /// isInlineDefinitionExternallyVisible to change from false to true. 2588 bool FunctionDecl::doesDeclarationForceExternallyVisibleDefinition() const { 2589 assert(!doesThisDeclarationHaveABody() && 2590 "Must have a declaration without a body."); 2591 2592 ASTContext &Context = getASTContext(); 2593 2594 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) { 2595 // With GNU inlining, a declaration with 'inline' but not 'extern', forces 2596 // an externally visible definition. 2597 // 2598 // FIXME: What happens if gnu_inline gets added on after the first 2599 // declaration? 2600 if (!isInlineSpecified() || getStorageClass() == SC_Extern) 2601 return false; 2602 2603 const FunctionDecl *Prev = this; 2604 bool FoundBody = false; 2605 while ((Prev = Prev->getPreviousDecl())) { 2606 FoundBody |= Prev->Body.isValid(); 2607 2608 if (Prev->Body) { 2609 // If it's not the case that both 'inline' and 'extern' are 2610 // specified on the definition, then it is always externally visible. 2611 if (!Prev->isInlineSpecified() || 2612 Prev->getStorageClass() != SC_Extern) 2613 return false; 2614 } else if (Prev->isInlineSpecified() && 2615 Prev->getStorageClass() != SC_Extern) { 2616 return false; 2617 } 2618 } 2619 return FoundBody; 2620 } 2621 2622 if (Context.getLangOpts().CPlusPlus) 2623 return false; 2624 2625 // C99 6.7.4p6: 2626 // [...] If all of the file scope declarations for a function in a 2627 // translation unit include the inline function specifier without extern, 2628 // then the definition in that translation unit is an inline definition. 2629 if (isInlineSpecified() && getStorageClass() != SC_Extern) 2630 return false; 2631 const FunctionDecl *Prev = this; 2632 bool FoundBody = false; 2633 while ((Prev = Prev->getPreviousDecl())) { 2634 FoundBody |= Prev->Body.isValid(); 2635 if (RedeclForcesDefC99(Prev)) 2636 return false; 2637 } 2638 return FoundBody; 2639 } 2640 2641 /// \brief For an inline function definition in C, or for a gnu_inline function 2642 /// in C++, determine whether the definition will be externally visible. 2643 /// 2644 /// Inline function definitions are always available for inlining optimizations. 2645 /// However, depending on the language dialect, declaration specifiers, and 2646 /// attributes, the definition of an inline function may or may not be 2647 /// "externally" visible to other translation units in the program. 2648 /// 2649 /// In C99, inline definitions are not externally visible by default. However, 2650 /// if even one of the global-scope declarations is marked "extern inline", the 2651 /// inline definition becomes externally visible (C99 6.7.4p6). 2652 /// 2653 /// In GNU89 mode, or if the gnu_inline attribute is attached to the function 2654 /// definition, we use the GNU semantics for inline, which are nearly the 2655 /// opposite of C99 semantics. In particular, "inline" by itself will create 2656 /// an externally visible symbol, but "extern inline" will not create an 2657 /// externally visible symbol. 2658 bool FunctionDecl::isInlineDefinitionExternallyVisible() const { 2659 assert(doesThisDeclarationHaveABody() && "Must have the function definition"); 2660 assert(isInlined() && "Function must be inline"); 2661 ASTContext &Context = getASTContext(); 2662 2663 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) { 2664 // Note: If you change the logic here, please change 2665 // doesDeclarationForceExternallyVisibleDefinition as well. 2666 // 2667 // If it's not the case that both 'inline' and 'extern' are 2668 // specified on the definition, then this inline definition is 2669 // externally visible. 2670 if (!(isInlineSpecified() && getStorageClass() == SC_Extern)) 2671 return true; 2672 2673 // If any declaration is 'inline' but not 'extern', then this definition 2674 // is externally visible. 2675 for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end(); 2676 Redecl != RedeclEnd; 2677 ++Redecl) { 2678 if (Redecl->isInlineSpecified() && 2679 Redecl->getStorageClass() != SC_Extern) 2680 return true; 2681 } 2682 2683 return false; 2684 } 2685 2686 // The rest of this function is C-only. 2687 assert(!Context.getLangOpts().CPlusPlus && 2688 "should not use C inline rules in C++"); 2689 2690 // C99 6.7.4p6: 2691 // [...] If all of the file scope declarations for a function in a 2692 // translation unit include the inline function specifier without extern, 2693 // then the definition in that translation unit is an inline definition. 2694 for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end(); 2695 Redecl != RedeclEnd; 2696 ++Redecl) { 2697 if (RedeclForcesDefC99(*Redecl)) 2698 return true; 2699 } 2700 2701 // C99 6.7.4p6: 2702 // An inline definition does not provide an external definition for the 2703 // function, and does not forbid an external definition in another 2704 // translation unit. 2705 return false; 2706 } 2707 2708 /// getOverloadedOperator - Which C++ overloaded operator this 2709 /// function represents, if any. 2710 OverloadedOperatorKind FunctionDecl::getOverloadedOperator() const { 2711 if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName) 2712 return getDeclName().getCXXOverloadedOperator(); 2713 else 2714 return OO_None; 2715 } 2716 2717 /// getLiteralIdentifier - The literal suffix identifier this function 2718 /// represents, if any. 2719 const IdentifierInfo *FunctionDecl::getLiteralIdentifier() const { 2720 if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName) 2721 return getDeclName().getCXXLiteralIdentifier(); 2722 else 2723 return 0; 2724 } 2725 2726 FunctionDecl::TemplatedKind FunctionDecl::getTemplatedKind() const { 2727 if (TemplateOrSpecialization.isNull()) 2728 return TK_NonTemplate; 2729 if (TemplateOrSpecialization.is<FunctionTemplateDecl *>()) 2730 return TK_FunctionTemplate; 2731 if (TemplateOrSpecialization.is<MemberSpecializationInfo *>()) 2732 return TK_MemberSpecialization; 2733 if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>()) 2734 return TK_FunctionTemplateSpecialization; 2735 if (TemplateOrSpecialization.is 2736 <DependentFunctionTemplateSpecializationInfo*>()) 2737 return TK_DependentFunctionTemplateSpecialization; 2738 2739 llvm_unreachable("Did we miss a TemplateOrSpecialization type?"); 2740 } 2741 2742 FunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const { 2743 if (MemberSpecializationInfo *Info = getMemberSpecializationInfo()) 2744 return cast<FunctionDecl>(Info->getInstantiatedFrom()); 2745 2746 return 0; 2747 } 2748 2749 void 2750 FunctionDecl::setInstantiationOfMemberFunction(ASTContext &C, 2751 FunctionDecl *FD, 2752 TemplateSpecializationKind TSK) { 2753 assert(TemplateOrSpecialization.isNull() && 2754 "Member function is already a specialization"); 2755 MemberSpecializationInfo *Info 2756 = new (C) MemberSpecializationInfo(FD, TSK); 2757 TemplateOrSpecialization = Info; 2758 } 2759 2760 bool FunctionDecl::isImplicitlyInstantiable() const { 2761 // If the function is invalid, it can't be implicitly instantiated. 2762 if (isInvalidDecl()) 2763 return false; 2764 2765 switch (getTemplateSpecializationKind()) { 2766 case TSK_Undeclared: 2767 case TSK_ExplicitInstantiationDefinition: 2768 return false; 2769 2770 case TSK_ImplicitInstantiation: 2771 return true; 2772 2773 // It is possible to instantiate TSK_ExplicitSpecialization kind 2774 // if the FunctionDecl has a class scope specialization pattern. 2775 case TSK_ExplicitSpecialization: 2776 return getClassScopeSpecializationPattern() != 0; 2777 2778 case TSK_ExplicitInstantiationDeclaration: 2779 // Handled below. 2780 break; 2781 } 2782 2783 // Find the actual template from which we will instantiate. 2784 const FunctionDecl *PatternDecl = getTemplateInstantiationPattern(); 2785 bool HasPattern = false; 2786 if (PatternDecl) 2787 HasPattern = PatternDecl->hasBody(PatternDecl); 2788 2789 // C++0x [temp.explicit]p9: 2790 // Except for inline functions, other explicit instantiation declarations 2791 // have the effect of suppressing the implicit instantiation of the entity 2792 // to which they refer. 2793 if (!HasPattern || !PatternDecl) 2794 return true; 2795 2796 return PatternDecl->isInlined(); 2797 } 2798 2799 bool FunctionDecl::isTemplateInstantiation() const { 2800 switch (getTemplateSpecializationKind()) { 2801 case TSK_Undeclared: 2802 case TSK_ExplicitSpecialization: 2803 return false; 2804 case TSK_ImplicitInstantiation: 2805 case TSK_ExplicitInstantiationDeclaration: 2806 case TSK_ExplicitInstantiationDefinition: 2807 return true; 2808 } 2809 llvm_unreachable("All TSK values handled."); 2810 } 2811 2812 FunctionDecl *FunctionDecl::getTemplateInstantiationPattern() const { 2813 // Handle class scope explicit specialization special case. 2814 if (getTemplateSpecializationKind() == TSK_ExplicitSpecialization) 2815 return getClassScopeSpecializationPattern(); 2816 2817 if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) { 2818 while (Primary->getInstantiatedFromMemberTemplate()) { 2819 // If we have hit a point where the user provided a specialization of 2820 // this template, we're done looking. 2821 if (Primary->isMemberSpecialization()) 2822 break; 2823 2824 Primary = Primary->getInstantiatedFromMemberTemplate(); 2825 } 2826 2827 return Primary->getTemplatedDecl(); 2828 } 2829 2830 return getInstantiatedFromMemberFunction(); 2831 } 2832 2833 FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const { 2834 if (FunctionTemplateSpecializationInfo *Info 2835 = TemplateOrSpecialization 2836 .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 2837 return Info->Template.getPointer(); 2838 } 2839 return 0; 2840 } 2841 2842 FunctionDecl *FunctionDecl::getClassScopeSpecializationPattern() const { 2843 return getASTContext().getClassScopeSpecializationPattern(this); 2844 } 2845 2846 const TemplateArgumentList * 2847 FunctionDecl::getTemplateSpecializationArgs() const { 2848 if (FunctionTemplateSpecializationInfo *Info 2849 = TemplateOrSpecialization 2850 .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 2851 return Info->TemplateArguments; 2852 } 2853 return 0; 2854 } 2855 2856 const ASTTemplateArgumentListInfo * 2857 FunctionDecl::getTemplateSpecializationArgsAsWritten() const { 2858 if (FunctionTemplateSpecializationInfo *Info 2859 = TemplateOrSpecialization 2860 .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 2861 return Info->TemplateArgumentsAsWritten; 2862 } 2863 return 0; 2864 } 2865 2866 void 2867 FunctionDecl::setFunctionTemplateSpecialization(ASTContext &C, 2868 FunctionTemplateDecl *Template, 2869 const TemplateArgumentList *TemplateArgs, 2870 void *InsertPos, 2871 TemplateSpecializationKind TSK, 2872 const TemplateArgumentListInfo *TemplateArgsAsWritten, 2873 SourceLocation PointOfInstantiation) { 2874 assert(TSK != TSK_Undeclared && 2875 "Must specify the type of function template specialization"); 2876 FunctionTemplateSpecializationInfo *Info 2877 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>(); 2878 if (!Info) 2879 Info = FunctionTemplateSpecializationInfo::Create(C, this, Template, TSK, 2880 TemplateArgs, 2881 TemplateArgsAsWritten, 2882 PointOfInstantiation); 2883 TemplateOrSpecialization = Info; 2884 Template->addSpecialization(Info, InsertPos); 2885 } 2886 2887 void 2888 FunctionDecl::setDependentTemplateSpecialization(ASTContext &Context, 2889 const UnresolvedSetImpl &Templates, 2890 const TemplateArgumentListInfo &TemplateArgs) { 2891 assert(TemplateOrSpecialization.isNull()); 2892 size_t Size = sizeof(DependentFunctionTemplateSpecializationInfo); 2893 Size += Templates.size() * sizeof(FunctionTemplateDecl*); 2894 Size += TemplateArgs.size() * sizeof(TemplateArgumentLoc); 2895 void *Buffer = Context.Allocate(Size); 2896 DependentFunctionTemplateSpecializationInfo *Info = 2897 new (Buffer) DependentFunctionTemplateSpecializationInfo(Templates, 2898 TemplateArgs); 2899 TemplateOrSpecialization = Info; 2900 } 2901 2902 DependentFunctionTemplateSpecializationInfo:: 2903 DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts, 2904 const TemplateArgumentListInfo &TArgs) 2905 : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) { 2906 2907 d.NumTemplates = Ts.size(); 2908 d.NumArgs = TArgs.size(); 2909 2910 FunctionTemplateDecl **TsArray = 2911 const_cast<FunctionTemplateDecl**>(getTemplates()); 2912 for (unsigned I = 0, E = Ts.size(); I != E; ++I) 2913 TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl()); 2914 2915 TemplateArgumentLoc *ArgsArray = 2916 const_cast<TemplateArgumentLoc*>(getTemplateArgs()); 2917 for (unsigned I = 0, E = TArgs.size(); I != E; ++I) 2918 new (&ArgsArray[I]) TemplateArgumentLoc(TArgs[I]); 2919 } 2920 2921 TemplateSpecializationKind FunctionDecl::getTemplateSpecializationKind() const { 2922 // For a function template specialization, query the specialization 2923 // information object. 2924 FunctionTemplateSpecializationInfo *FTSInfo 2925 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>(); 2926 if (FTSInfo) 2927 return FTSInfo->getTemplateSpecializationKind(); 2928 2929 MemberSpecializationInfo *MSInfo 2930 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>(); 2931 if (MSInfo) 2932 return MSInfo->getTemplateSpecializationKind(); 2933 2934 return TSK_Undeclared; 2935 } 2936 2937 void 2938 FunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 2939 SourceLocation PointOfInstantiation) { 2940 if (FunctionTemplateSpecializationInfo *FTSInfo 2941 = TemplateOrSpecialization.dyn_cast< 2942 FunctionTemplateSpecializationInfo*>()) { 2943 FTSInfo->setTemplateSpecializationKind(TSK); 2944 if (TSK != TSK_ExplicitSpecialization && 2945 PointOfInstantiation.isValid() && 2946 FTSInfo->getPointOfInstantiation().isInvalid()) 2947 FTSInfo->setPointOfInstantiation(PointOfInstantiation); 2948 } else if (MemberSpecializationInfo *MSInfo 2949 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) { 2950 MSInfo->setTemplateSpecializationKind(TSK); 2951 if (TSK != TSK_ExplicitSpecialization && 2952 PointOfInstantiation.isValid() && 2953 MSInfo->getPointOfInstantiation().isInvalid()) 2954 MSInfo->setPointOfInstantiation(PointOfInstantiation); 2955 } else 2956 llvm_unreachable("Function cannot have a template specialization kind"); 2957 } 2958 2959 SourceLocation FunctionDecl::getPointOfInstantiation() const { 2960 if (FunctionTemplateSpecializationInfo *FTSInfo 2961 = TemplateOrSpecialization.dyn_cast< 2962 FunctionTemplateSpecializationInfo*>()) 2963 return FTSInfo->getPointOfInstantiation(); 2964 else if (MemberSpecializationInfo *MSInfo 2965 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) 2966 return MSInfo->getPointOfInstantiation(); 2967 2968 return SourceLocation(); 2969 } 2970 2971 bool FunctionDecl::isOutOfLine() const { 2972 if (Decl::isOutOfLine()) 2973 return true; 2974 2975 // If this function was instantiated from a member function of a 2976 // class template, check whether that member function was defined out-of-line. 2977 if (FunctionDecl *FD = getInstantiatedFromMemberFunction()) { 2978 const FunctionDecl *Definition; 2979 if (FD->hasBody(Definition)) 2980 return Definition->isOutOfLine(); 2981 } 2982 2983 // If this function was instantiated from a function template, 2984 // check whether that function template was defined out-of-line. 2985 if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) { 2986 const FunctionDecl *Definition; 2987 if (FunTmpl->getTemplatedDecl()->hasBody(Definition)) 2988 return Definition->isOutOfLine(); 2989 } 2990 2991 return false; 2992 } 2993 2994 SourceRange FunctionDecl::getSourceRange() const { 2995 return SourceRange(getOuterLocStart(), EndRangeLoc); 2996 } 2997 2998 unsigned FunctionDecl::getMemoryFunctionKind() const { 2999 IdentifierInfo *FnInfo = getIdentifier(); 3000 3001 if (!FnInfo) 3002 return 0; 3003 3004 // Builtin handling. 3005 switch (getBuiltinID()) { 3006 case Builtin::BI__builtin_memset: 3007 case Builtin::BI__builtin___memset_chk: 3008 case Builtin::BImemset: 3009 return Builtin::BImemset; 3010 3011 case Builtin::BI__builtin_memcpy: 3012 case Builtin::BI__builtin___memcpy_chk: 3013 case Builtin::BImemcpy: 3014 return Builtin::BImemcpy; 3015 3016 case Builtin::BI__builtin_memmove: 3017 case Builtin::BI__builtin___memmove_chk: 3018 case Builtin::BImemmove: 3019 return Builtin::BImemmove; 3020 3021 case Builtin::BIstrlcpy: 3022 return Builtin::BIstrlcpy; 3023 case Builtin::BIstrlcat: 3024 return Builtin::BIstrlcat; 3025 3026 case Builtin::BI__builtin_memcmp: 3027 case Builtin::BImemcmp: 3028 return Builtin::BImemcmp; 3029 3030 case Builtin::BI__builtin_strncpy: 3031 case Builtin::BI__builtin___strncpy_chk: 3032 case Builtin::BIstrncpy: 3033 return Builtin::BIstrncpy; 3034 3035 case Builtin::BI__builtin_strncmp: 3036 case Builtin::BIstrncmp: 3037 return Builtin::BIstrncmp; 3038 3039 case Builtin::BI__builtin_strncasecmp: 3040 case Builtin::BIstrncasecmp: 3041 return Builtin::BIstrncasecmp; 3042 3043 case Builtin::BI__builtin_strncat: 3044 case Builtin::BI__builtin___strncat_chk: 3045 case Builtin::BIstrncat: 3046 return Builtin::BIstrncat; 3047 3048 case Builtin::BI__builtin_strndup: 3049 case Builtin::BIstrndup: 3050 return Builtin::BIstrndup; 3051 3052 case Builtin::BI__builtin_strlen: 3053 case Builtin::BIstrlen: 3054 return Builtin::BIstrlen; 3055 3056 default: 3057 if (isExternC()) { 3058 if (FnInfo->isStr("memset")) 3059 return Builtin::BImemset; 3060 else if (FnInfo->isStr("memcpy")) 3061 return Builtin::BImemcpy; 3062 else if (FnInfo->isStr("memmove")) 3063 return Builtin::BImemmove; 3064 else if (FnInfo->isStr("memcmp")) 3065 return Builtin::BImemcmp; 3066 else if (FnInfo->isStr("strncpy")) 3067 return Builtin::BIstrncpy; 3068 else if (FnInfo->isStr("strncmp")) 3069 return Builtin::BIstrncmp; 3070 else if (FnInfo->isStr("strncasecmp")) 3071 return Builtin::BIstrncasecmp; 3072 else if (FnInfo->isStr("strncat")) 3073 return Builtin::BIstrncat; 3074 else if (FnInfo->isStr("strndup")) 3075 return Builtin::BIstrndup; 3076 else if (FnInfo->isStr("strlen")) 3077 return Builtin::BIstrlen; 3078 } 3079 break; 3080 } 3081 return 0; 3082 } 3083 3084 //===----------------------------------------------------------------------===// 3085 // FieldDecl Implementation 3086 //===----------------------------------------------------------------------===// 3087 3088 FieldDecl *FieldDecl::Create(const ASTContext &C, DeclContext *DC, 3089 SourceLocation StartLoc, SourceLocation IdLoc, 3090 IdentifierInfo *Id, QualType T, 3091 TypeSourceInfo *TInfo, Expr *BW, bool Mutable, 3092 InClassInitStyle InitStyle) { 3093 return new (C) FieldDecl(Decl::Field, DC, StartLoc, IdLoc, Id, T, TInfo, 3094 BW, Mutable, InitStyle); 3095 } 3096 3097 FieldDecl *FieldDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3098 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FieldDecl)); 3099 return new (Mem) FieldDecl(Field, 0, SourceLocation(), SourceLocation(), 3100 0, QualType(), 0, 0, false, ICIS_NoInit); 3101 } 3102 3103 bool FieldDecl::isAnonymousStructOrUnion() const { 3104 if (!isImplicit() || getDeclName()) 3105 return false; 3106 3107 if (const RecordType *Record = getType()->getAs<RecordType>()) 3108 return Record->getDecl()->isAnonymousStructOrUnion(); 3109 3110 return false; 3111 } 3112 3113 unsigned FieldDecl::getBitWidthValue(const ASTContext &Ctx) const { 3114 assert(isBitField() && "not a bitfield"); 3115 Expr *BitWidth = InitializerOrBitWidth.getPointer(); 3116 return BitWidth->EvaluateKnownConstInt(Ctx).getZExtValue(); 3117 } 3118 3119 unsigned FieldDecl::getFieldIndex() const { 3120 const FieldDecl *Canonical = getCanonicalDecl(); 3121 if (Canonical != this) 3122 return Canonical->getFieldIndex(); 3123 3124 if (CachedFieldIndex) return CachedFieldIndex - 1; 3125 3126 unsigned Index = 0; 3127 const RecordDecl *RD = getParent(); 3128 3129 for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end(); 3130 I != E; ++I, ++Index) 3131 I->getCanonicalDecl()->CachedFieldIndex = Index + 1; 3132 3133 assert(CachedFieldIndex && "failed to find field in parent"); 3134 return CachedFieldIndex - 1; 3135 } 3136 3137 SourceRange FieldDecl::getSourceRange() const { 3138 if (const Expr *E = InitializerOrBitWidth.getPointer()) 3139 return SourceRange(getInnerLocStart(), E->getLocEnd()); 3140 return DeclaratorDecl::getSourceRange(); 3141 } 3142 3143 void FieldDecl::setBitWidth(Expr *Width) { 3144 assert(!InitializerOrBitWidth.getPointer() && !hasInClassInitializer() && 3145 "bit width or initializer already set"); 3146 InitializerOrBitWidth.setPointer(Width); 3147 } 3148 3149 void FieldDecl::setInClassInitializer(Expr *Init) { 3150 assert(!InitializerOrBitWidth.getPointer() && hasInClassInitializer() && 3151 "bit width or initializer already set"); 3152 InitializerOrBitWidth.setPointer(Init); 3153 } 3154 3155 //===----------------------------------------------------------------------===// 3156 // TagDecl Implementation 3157 //===----------------------------------------------------------------------===// 3158 3159 SourceLocation TagDecl::getOuterLocStart() const { 3160 return getTemplateOrInnerLocStart(this); 3161 } 3162 3163 SourceRange TagDecl::getSourceRange() const { 3164 SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation(); 3165 return SourceRange(getOuterLocStart(), E); 3166 } 3167 3168 TagDecl *TagDecl::getCanonicalDecl() { return getFirstDecl(); } 3169 3170 void TagDecl::setTypedefNameForAnonDecl(TypedefNameDecl *TDD) { 3171 NamedDeclOrQualifier = TDD; 3172 if (TypeForDecl) 3173 assert(TypeForDecl->isLinkageValid()); 3174 assert(isLinkageValid()); 3175 } 3176 3177 void TagDecl::startDefinition() { 3178 IsBeingDefined = true; 3179 3180 if (CXXRecordDecl *D = dyn_cast<CXXRecordDecl>(this)) { 3181 struct CXXRecordDecl::DefinitionData *Data = 3182 new (getASTContext()) struct CXXRecordDecl::DefinitionData(D); 3183 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) 3184 cast<CXXRecordDecl>(*I)->DefinitionData = Data; 3185 } 3186 } 3187 3188 void TagDecl::completeDefinition() { 3189 assert((!isa<CXXRecordDecl>(this) || 3190 cast<CXXRecordDecl>(this)->hasDefinition()) && 3191 "definition completed but not started"); 3192 3193 IsCompleteDefinition = true; 3194 IsBeingDefined = false; 3195 3196 if (ASTMutationListener *L = getASTMutationListener()) 3197 L->CompletedTagDefinition(this); 3198 } 3199 3200 TagDecl *TagDecl::getDefinition() const { 3201 if (isCompleteDefinition()) 3202 return const_cast<TagDecl *>(this); 3203 3204 // If it's possible for us to have an out-of-date definition, check now. 3205 if (MayHaveOutOfDateDef) { 3206 if (IdentifierInfo *II = getIdentifier()) { 3207 if (II->isOutOfDate()) { 3208 updateOutOfDate(*II); 3209 } 3210 } 3211 } 3212 3213 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(this)) 3214 return CXXRD->getDefinition(); 3215 3216 for (redecl_iterator R = redecls_begin(), REnd = redecls_end(); 3217 R != REnd; ++R) 3218 if (R->isCompleteDefinition()) 3219 return *R; 3220 3221 return 0; 3222 } 3223 3224 void TagDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) { 3225 if (QualifierLoc) { 3226 // Make sure the extended qualifier info is allocated. 3227 if (!hasExtInfo()) 3228 NamedDeclOrQualifier = new (getASTContext()) ExtInfo; 3229 // Set qualifier info. 3230 getExtInfo()->QualifierLoc = QualifierLoc; 3231 } else { 3232 // Here Qualifier == 0, i.e., we are removing the qualifier (if any). 3233 if (hasExtInfo()) { 3234 if (getExtInfo()->NumTemplParamLists == 0) { 3235 getASTContext().Deallocate(getExtInfo()); 3236 NamedDeclOrQualifier = (TypedefNameDecl*) 0; 3237 } 3238 else 3239 getExtInfo()->QualifierLoc = QualifierLoc; 3240 } 3241 } 3242 } 3243 3244 void TagDecl::setTemplateParameterListsInfo(ASTContext &Context, 3245 unsigned NumTPLists, 3246 TemplateParameterList **TPLists) { 3247 assert(NumTPLists > 0); 3248 // Make sure the extended decl info is allocated. 3249 if (!hasExtInfo()) 3250 // Allocate external info struct. 3251 NamedDeclOrQualifier = new (getASTContext()) ExtInfo; 3252 // Set the template parameter lists info. 3253 getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists); 3254 } 3255 3256 //===----------------------------------------------------------------------===// 3257 // EnumDecl Implementation 3258 //===----------------------------------------------------------------------===// 3259 3260 void EnumDecl::anchor() { } 3261 3262 EnumDecl *EnumDecl::Create(ASTContext &C, DeclContext *DC, 3263 SourceLocation StartLoc, SourceLocation IdLoc, 3264 IdentifierInfo *Id, 3265 EnumDecl *PrevDecl, bool IsScoped, 3266 bool IsScopedUsingClassTag, bool IsFixed) { 3267 EnumDecl *Enum = new (C) EnumDecl(DC, StartLoc, IdLoc, Id, PrevDecl, 3268 IsScoped, IsScopedUsingClassTag, IsFixed); 3269 Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3270 C.getTypeDeclType(Enum, PrevDecl); 3271 return Enum; 3272 } 3273 3274 EnumDecl *EnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3275 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(EnumDecl)); 3276 EnumDecl *Enum = new (Mem) EnumDecl(0, SourceLocation(), SourceLocation(), 3277 0, 0, false, false, false); 3278 Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3279 return Enum; 3280 } 3281 3282 void EnumDecl::completeDefinition(QualType NewType, 3283 QualType NewPromotionType, 3284 unsigned NumPositiveBits, 3285 unsigned NumNegativeBits) { 3286 assert(!isCompleteDefinition() && "Cannot redefine enums!"); 3287 if (!IntegerType) 3288 IntegerType = NewType.getTypePtr(); 3289 PromotionType = NewPromotionType; 3290 setNumPositiveBits(NumPositiveBits); 3291 setNumNegativeBits(NumNegativeBits); 3292 TagDecl::completeDefinition(); 3293 } 3294 3295 TemplateSpecializationKind EnumDecl::getTemplateSpecializationKind() const { 3296 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 3297 return MSI->getTemplateSpecializationKind(); 3298 3299 return TSK_Undeclared; 3300 } 3301 3302 void EnumDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 3303 SourceLocation PointOfInstantiation) { 3304 MemberSpecializationInfo *MSI = getMemberSpecializationInfo(); 3305 assert(MSI && "Not an instantiated member enumeration?"); 3306 MSI->setTemplateSpecializationKind(TSK); 3307 if (TSK != TSK_ExplicitSpecialization && 3308 PointOfInstantiation.isValid() && 3309 MSI->getPointOfInstantiation().isInvalid()) 3310 MSI->setPointOfInstantiation(PointOfInstantiation); 3311 } 3312 3313 EnumDecl *EnumDecl::getInstantiatedFromMemberEnum() const { 3314 if (SpecializationInfo) 3315 return cast<EnumDecl>(SpecializationInfo->getInstantiatedFrom()); 3316 3317 return 0; 3318 } 3319 3320 void EnumDecl::setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED, 3321 TemplateSpecializationKind TSK) { 3322 assert(!SpecializationInfo && "Member enum is already a specialization"); 3323 SpecializationInfo = new (C) MemberSpecializationInfo(ED, TSK); 3324 } 3325 3326 //===----------------------------------------------------------------------===// 3327 // RecordDecl Implementation 3328 //===----------------------------------------------------------------------===// 3329 3330 RecordDecl::RecordDecl(Kind DK, TagKind TK, DeclContext *DC, 3331 SourceLocation StartLoc, SourceLocation IdLoc, 3332 IdentifierInfo *Id, RecordDecl *PrevDecl) 3333 : TagDecl(DK, TK, DC, IdLoc, Id, PrevDecl, StartLoc) { 3334 HasFlexibleArrayMember = false; 3335 AnonymousStructOrUnion = false; 3336 HasObjectMember = false; 3337 HasVolatileMember = false; 3338 LoadedFieldsFromExternalStorage = false; 3339 assert(classof(static_cast<Decl*>(this)) && "Invalid Kind!"); 3340 } 3341 3342 RecordDecl *RecordDecl::Create(const ASTContext &C, TagKind TK, DeclContext *DC, 3343 SourceLocation StartLoc, SourceLocation IdLoc, 3344 IdentifierInfo *Id, RecordDecl* PrevDecl) { 3345 RecordDecl* R = new (C) RecordDecl(Record, TK, DC, StartLoc, IdLoc, Id, 3346 PrevDecl); 3347 R->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3348 3349 C.getTypeDeclType(R, PrevDecl); 3350 return R; 3351 } 3352 3353 RecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) { 3354 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(RecordDecl)); 3355 RecordDecl *R = new (Mem) RecordDecl(Record, TTK_Struct, 0, SourceLocation(), 3356 SourceLocation(), 0, 0); 3357 R->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3358 return R; 3359 } 3360 3361 bool RecordDecl::isInjectedClassName() const { 3362 return isImplicit() && getDeclName() && getDeclContext()->isRecord() && 3363 cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName(); 3364 } 3365 3366 RecordDecl::field_iterator RecordDecl::field_begin() const { 3367 if (hasExternalLexicalStorage() && !LoadedFieldsFromExternalStorage) 3368 LoadFieldsFromExternalStorage(); 3369 3370 return field_iterator(decl_iterator(FirstDecl)); 3371 } 3372 3373 /// completeDefinition - Notes that the definition of this type is now 3374 /// complete. 3375 void RecordDecl::completeDefinition() { 3376 assert(!isCompleteDefinition() && "Cannot redefine record!"); 3377 TagDecl::completeDefinition(); 3378 } 3379 3380 /// isMsStruct - Get whether or not this record uses ms_struct layout. 3381 /// This which can be turned on with an attribute, pragma, or the 3382 /// -mms-bitfields command-line option. 3383 bool RecordDecl::isMsStruct(const ASTContext &C) const { 3384 return hasAttr<MsStructAttr>() || C.getLangOpts().MSBitfields == 1; 3385 } 3386 3387 static bool isFieldOrIndirectField(Decl::Kind K) { 3388 return FieldDecl::classofKind(K) || IndirectFieldDecl::classofKind(K); 3389 } 3390 3391 void RecordDecl::LoadFieldsFromExternalStorage() const { 3392 ExternalASTSource *Source = getASTContext().getExternalSource(); 3393 assert(hasExternalLexicalStorage() && Source && "No external storage?"); 3394 3395 // Notify that we have a RecordDecl doing some initialization. 3396 ExternalASTSource::Deserializing TheFields(Source); 3397 3398 SmallVector<Decl*, 64> Decls; 3399 LoadedFieldsFromExternalStorage = true; 3400 switch (Source->FindExternalLexicalDecls(this, isFieldOrIndirectField, 3401 Decls)) { 3402 case ELR_Success: 3403 break; 3404 3405 case ELR_AlreadyLoaded: 3406 case ELR_Failure: 3407 return; 3408 } 3409 3410 #ifndef NDEBUG 3411 // Check that all decls we got were FieldDecls. 3412 for (unsigned i=0, e=Decls.size(); i != e; ++i) 3413 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i])); 3414 #endif 3415 3416 if (Decls.empty()) 3417 return; 3418 3419 llvm::tie(FirstDecl, LastDecl) = BuildDeclChain(Decls, 3420 /*FieldsAlreadyLoaded=*/false); 3421 } 3422 3423 //===----------------------------------------------------------------------===// 3424 // BlockDecl Implementation 3425 //===----------------------------------------------------------------------===// 3426 3427 void BlockDecl::setParams(ArrayRef<ParmVarDecl *> NewParamInfo) { 3428 assert(ParamInfo == 0 && "Already has param info!"); 3429 3430 // Zero params -> null pointer. 3431 if (!NewParamInfo.empty()) { 3432 NumParams = NewParamInfo.size(); 3433 ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()]; 3434 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo); 3435 } 3436 } 3437 3438 void BlockDecl::setCaptures(ASTContext &Context, 3439 const Capture *begin, 3440 const Capture *end, 3441 bool capturesCXXThis) { 3442 CapturesCXXThis = capturesCXXThis; 3443 3444 if (begin == end) { 3445 NumCaptures = 0; 3446 Captures = 0; 3447 return; 3448 } 3449 3450 NumCaptures = end - begin; 3451 3452 // Avoid new Capture[] because we don't want to provide a default 3453 // constructor. 3454 size_t allocationSize = NumCaptures * sizeof(Capture); 3455 void *buffer = Context.Allocate(allocationSize, /*alignment*/sizeof(void*)); 3456 memcpy(buffer, begin, allocationSize); 3457 Captures = static_cast<Capture*>(buffer); 3458 } 3459 3460 bool BlockDecl::capturesVariable(const VarDecl *variable) const { 3461 for (capture_const_iterator 3462 i = capture_begin(), e = capture_end(); i != e; ++i) 3463 // Only auto vars can be captured, so no redeclaration worries. 3464 if (i->getVariable() == variable) 3465 return true; 3466 3467 return false; 3468 } 3469 3470 SourceRange BlockDecl::getSourceRange() const { 3471 return SourceRange(getLocation(), Body? Body->getLocEnd() : getLocation()); 3472 } 3473 3474 //===----------------------------------------------------------------------===// 3475 // Other Decl Allocation/Deallocation Method Implementations 3476 //===----------------------------------------------------------------------===// 3477 3478 void TranslationUnitDecl::anchor() { } 3479 3480 TranslationUnitDecl *TranslationUnitDecl::Create(ASTContext &C) { 3481 return new (C) TranslationUnitDecl(C); 3482 } 3483 3484 void LabelDecl::anchor() { } 3485 3486 LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC, 3487 SourceLocation IdentL, IdentifierInfo *II) { 3488 return new (C) LabelDecl(DC, IdentL, II, 0, IdentL); 3489 } 3490 3491 LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC, 3492 SourceLocation IdentL, IdentifierInfo *II, 3493 SourceLocation GnuLabelL) { 3494 assert(GnuLabelL != IdentL && "Use this only for GNU local labels"); 3495 return new (C) LabelDecl(DC, IdentL, II, 0, GnuLabelL); 3496 } 3497 3498 LabelDecl *LabelDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3499 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(LabelDecl)); 3500 return new (Mem) LabelDecl(0, SourceLocation(), 0, 0, SourceLocation()); 3501 } 3502 3503 void ValueDecl::anchor() { } 3504 3505 bool ValueDecl::isWeak() const { 3506 for (attr_iterator I = attr_begin(), E = attr_end(); I != E; ++I) 3507 if (isa<WeakAttr>(*I) || isa<WeakRefAttr>(*I)) 3508 return true; 3509 3510 return isWeakImported(); 3511 } 3512 3513 void ImplicitParamDecl::anchor() { } 3514 3515 ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, DeclContext *DC, 3516 SourceLocation IdLoc, 3517 IdentifierInfo *Id, 3518 QualType Type) { 3519 return new (C) ImplicitParamDecl(DC, IdLoc, Id, Type); 3520 } 3521 3522 ImplicitParamDecl *ImplicitParamDecl::CreateDeserialized(ASTContext &C, 3523 unsigned ID) { 3524 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ImplicitParamDecl)); 3525 return new (Mem) ImplicitParamDecl(0, SourceLocation(), 0, QualType()); 3526 } 3527 3528 FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC, 3529 SourceLocation StartLoc, 3530 const DeclarationNameInfo &NameInfo, 3531 QualType T, TypeSourceInfo *TInfo, 3532 StorageClass SC, 3533 bool isInlineSpecified, 3534 bool hasWrittenPrototype, 3535 bool isConstexprSpecified) { 3536 FunctionDecl *New = new (C) FunctionDecl(Function, DC, StartLoc, NameInfo, 3537 T, TInfo, SC, 3538 isInlineSpecified, 3539 isConstexprSpecified); 3540 New->HasWrittenPrototype = hasWrittenPrototype; 3541 return New; 3542 } 3543 3544 FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3545 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FunctionDecl)); 3546 return new (Mem) FunctionDecl(Function, 0, SourceLocation(), 3547 DeclarationNameInfo(), QualType(), 0, 3548 SC_None, false, false); 3549 } 3550 3551 BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) { 3552 return new (C) BlockDecl(DC, L); 3553 } 3554 3555 BlockDecl *BlockDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3556 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(BlockDecl)); 3557 return new (Mem) BlockDecl(0, SourceLocation()); 3558 } 3559 3560 MSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C, 3561 unsigned ID) { 3562 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(MSPropertyDecl)); 3563 return new (Mem) MSPropertyDecl(0, SourceLocation(), DeclarationName(), 3564 QualType(), 0, SourceLocation(), 3565 0, 0); 3566 } 3567 3568 CapturedDecl *CapturedDecl::Create(ASTContext &C, DeclContext *DC, 3569 unsigned NumParams) { 3570 unsigned Size = sizeof(CapturedDecl) + NumParams * sizeof(ImplicitParamDecl*); 3571 return new (C.Allocate(Size)) CapturedDecl(DC, NumParams); 3572 } 3573 3574 CapturedDecl *CapturedDecl::CreateDeserialized(ASTContext &C, unsigned ID, 3575 unsigned NumParams) { 3576 unsigned Size = sizeof(CapturedDecl) + NumParams * sizeof(ImplicitParamDecl*); 3577 void *Mem = AllocateDeserializedDecl(C, ID, Size); 3578 return new (Mem) CapturedDecl(0, NumParams); 3579 } 3580 3581 EnumConstantDecl *EnumConstantDecl::Create(ASTContext &C, EnumDecl *CD, 3582 SourceLocation L, 3583 IdentifierInfo *Id, QualType T, 3584 Expr *E, const llvm::APSInt &V) { 3585 return new (C) EnumConstantDecl(CD, L, Id, T, E, V); 3586 } 3587 3588 EnumConstantDecl * 3589 EnumConstantDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3590 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(EnumConstantDecl)); 3591 return new (Mem) EnumConstantDecl(0, SourceLocation(), 0, QualType(), 0, 3592 llvm::APSInt()); 3593 } 3594 3595 void IndirectFieldDecl::anchor() { } 3596 3597 IndirectFieldDecl * 3598 IndirectFieldDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, 3599 IdentifierInfo *Id, QualType T, NamedDecl **CH, 3600 unsigned CHS) { 3601 return new (C) IndirectFieldDecl(DC, L, Id, T, CH, CHS); 3602 } 3603 3604 IndirectFieldDecl *IndirectFieldDecl::CreateDeserialized(ASTContext &C, 3605 unsigned ID) { 3606 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(IndirectFieldDecl)); 3607 return new (Mem) IndirectFieldDecl(0, SourceLocation(), DeclarationName(), 3608 QualType(), 0, 0); 3609 } 3610 3611 SourceRange EnumConstantDecl::getSourceRange() const { 3612 SourceLocation End = getLocation(); 3613 if (Init) 3614 End = Init->getLocEnd(); 3615 return SourceRange(getLocation(), End); 3616 } 3617 3618 void TypeDecl::anchor() { } 3619 3620 TypedefDecl *TypedefDecl::Create(ASTContext &C, DeclContext *DC, 3621 SourceLocation StartLoc, SourceLocation IdLoc, 3622 IdentifierInfo *Id, TypeSourceInfo *TInfo) { 3623 return new (C) TypedefDecl(DC, StartLoc, IdLoc, Id, TInfo); 3624 } 3625 3626 void TypedefNameDecl::anchor() { } 3627 3628 TypedefDecl *TypedefDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3629 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TypedefDecl)); 3630 return new (Mem) TypedefDecl(0, SourceLocation(), SourceLocation(), 0, 0); 3631 } 3632 3633 TypeAliasDecl *TypeAliasDecl::Create(ASTContext &C, DeclContext *DC, 3634 SourceLocation StartLoc, 3635 SourceLocation IdLoc, IdentifierInfo *Id, 3636 TypeSourceInfo *TInfo) { 3637 return new (C) TypeAliasDecl(DC, StartLoc, IdLoc, Id, TInfo); 3638 } 3639 3640 TypeAliasDecl *TypeAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3641 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TypeAliasDecl)); 3642 return new (Mem) TypeAliasDecl(0, SourceLocation(), SourceLocation(), 0, 0); 3643 } 3644 3645 SourceRange TypedefDecl::getSourceRange() const { 3646 SourceLocation RangeEnd = getLocation(); 3647 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) { 3648 if (typeIsPostfix(TInfo->getType())) 3649 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd(); 3650 } 3651 return SourceRange(getLocStart(), RangeEnd); 3652 } 3653 3654 SourceRange TypeAliasDecl::getSourceRange() const { 3655 SourceLocation RangeEnd = getLocStart(); 3656 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) 3657 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd(); 3658 return SourceRange(getLocStart(), RangeEnd); 3659 } 3660 3661 void FileScopeAsmDecl::anchor() { } 3662 3663 FileScopeAsmDecl *FileScopeAsmDecl::Create(ASTContext &C, DeclContext *DC, 3664 StringLiteral *Str, 3665 SourceLocation AsmLoc, 3666 SourceLocation RParenLoc) { 3667 return new (C) FileScopeAsmDecl(DC, Str, AsmLoc, RParenLoc); 3668 } 3669 3670 FileScopeAsmDecl *FileScopeAsmDecl::CreateDeserialized(ASTContext &C, 3671 unsigned ID) { 3672 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FileScopeAsmDecl)); 3673 return new (Mem) FileScopeAsmDecl(0, 0, SourceLocation(), SourceLocation()); 3674 } 3675 3676 void EmptyDecl::anchor() {} 3677 3678 EmptyDecl *EmptyDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) { 3679 return new (C) EmptyDecl(DC, L); 3680 } 3681 3682 EmptyDecl *EmptyDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3683 void *Mem = AllocateDeserializedDecl(C, ID, sizeof(EmptyDecl)); 3684 return new (Mem) EmptyDecl(0, SourceLocation()); 3685 } 3686 3687 //===----------------------------------------------------------------------===// 3688 // ImportDecl Implementation 3689 //===----------------------------------------------------------------------===// 3690 3691 /// \brief Retrieve the number of module identifiers needed to name the given 3692 /// module. 3693 static unsigned getNumModuleIdentifiers(Module *Mod) { 3694 unsigned Result = 1; 3695 while (Mod->Parent) { 3696 Mod = Mod->Parent; 3697 ++Result; 3698 } 3699 return Result; 3700 } 3701 3702 ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc, 3703 Module *Imported, 3704 ArrayRef<SourceLocation> IdentifierLocs) 3705 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, true), 3706 NextLocalImport() 3707 { 3708 assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size()); 3709 SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(this + 1); 3710 memcpy(StoredLocs, IdentifierLocs.data(), 3711 IdentifierLocs.size() * sizeof(SourceLocation)); 3712 } 3713 3714 ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc, 3715 Module *Imported, SourceLocation EndLoc) 3716 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, false), 3717 NextLocalImport() 3718 { 3719 *reinterpret_cast<SourceLocation *>(this + 1) = EndLoc; 3720 } 3721 3722 ImportDecl *ImportDecl::Create(ASTContext &C, DeclContext *DC, 3723 SourceLocation StartLoc, Module *Imported, 3724 ArrayRef<SourceLocation> IdentifierLocs) { 3725 void *Mem = C.Allocate(sizeof(ImportDecl) + 3726 IdentifierLocs.size() * sizeof(SourceLocation)); 3727 return new (Mem) ImportDecl(DC, StartLoc, Imported, IdentifierLocs); 3728 } 3729 3730 ImportDecl *ImportDecl::CreateImplicit(ASTContext &C, DeclContext *DC, 3731 SourceLocation StartLoc, 3732 Module *Imported, 3733 SourceLocation EndLoc) { 3734 void *Mem = C.Allocate(sizeof(ImportDecl) + sizeof(SourceLocation)); 3735 ImportDecl *Import = new (Mem) ImportDecl(DC, StartLoc, Imported, EndLoc); 3736 Import->setImplicit(); 3737 return Import; 3738 } 3739 3740 ImportDecl *ImportDecl::CreateDeserialized(ASTContext &C, unsigned ID, 3741 unsigned NumLocations) { 3742 void *Mem = AllocateDeserializedDecl(C, ID, 3743 (sizeof(ImportDecl) + 3744 NumLocations * sizeof(SourceLocation))); 3745 return new (Mem) ImportDecl(EmptyShell()); 3746 } 3747 3748 ArrayRef<SourceLocation> ImportDecl::getIdentifierLocs() const { 3749 if (!ImportedAndComplete.getInt()) 3750 return None; 3751 3752 const SourceLocation *StoredLocs 3753 = reinterpret_cast<const SourceLocation *>(this + 1); 3754 return ArrayRef<SourceLocation>(StoredLocs, 3755 getNumModuleIdentifiers(getImportedModule())); 3756 } 3757 3758 SourceRange ImportDecl::getSourceRange() const { 3759 if (!ImportedAndComplete.getInt()) 3760 return SourceRange(getLocation(), 3761 *reinterpret_cast<const SourceLocation *>(this + 1)); 3762 3763 return SourceRange(getLocation(), getIdentifierLocs().back()); 3764 } 3765