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