1193326Sed//===--- Decl.cpp - Declaration AST Node Implementation -------------------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This file implements the Decl subclasses. 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13193326Sed 14193326Sed#include "clang/AST/Decl.h" 15249423Sdim#include "clang/AST/ASTContext.h" 16249423Sdim#include "clang/AST/ASTMutationListener.h" 17249423Sdim#include "clang/AST/Attr.h" 18193326Sed#include "clang/AST/DeclCXX.h" 19193326Sed#include "clang/AST/DeclObjC.h" 20193326Sed#include "clang/AST/DeclTemplate.h" 21193326Sed#include "clang/AST/Expr.h" 22201361Srdivacky#include "clang/AST/ExprCXX.h" 23193326Sed#include "clang/AST/PrettyPrinter.h" 24249423Sdim#include "clang/AST/Stmt.h" 25249423Sdim#include "clang/AST/TypeLoc.h" 26194179Sed#include "clang/Basic/Builtins.h" 27193326Sed#include "clang/Basic/IdentifierTable.h" 28234353Sdim#include "clang/Basic/Module.h" 29208600Srdivacky#include "clang/Basic/Specifiers.h" 30221345Sdim#include "clang/Basic/TargetInfo.h" 31198092Srdivacky#include "llvm/Support/ErrorHandling.h" 32249423Sdim#include "llvm/Support/type_traits.h" 33226633Sdim#include <algorithm> 34226633Sdim 35193326Sedusing namespace clang; 36193326Sed 37263508SdimDecl *clang::getPrimaryMergedDecl(Decl *D) { 38263508Sdim return D->getASTContext().getPrimaryMergedDecl(D); 39263508Sdim} 40263508Sdim 41193326Sed//===----------------------------------------------------------------------===// 42203955Srdivacky// NamedDecl Implementation 43193326Sed//===----------------------------------------------------------------------===// 44193326Sed 45249423Sdim// Visibility rules aren't rigorously externally specified, but here 46249423Sdim// are the basic principles behind what we implement: 47249423Sdim// 48249423Sdim// 1. An explicit visibility attribute is generally a direct expression 49249423Sdim// of the user's intent and should be honored. Only the innermost 50249423Sdim// visibility attribute applies. If no visibility attribute applies, 51249423Sdim// global visibility settings are considered. 52249423Sdim// 53249423Sdim// 2. There is one caveat to the above: on or in a template pattern, 54249423Sdim// an explicit visibility attribute is just a default rule, and 55249423Sdim// visibility can be decreased by the visibility of template 56249423Sdim// arguments. But this, too, has an exception: an attribute on an 57249423Sdim// explicit specialization or instantiation causes all the visibility 58249423Sdim// restrictions of the template arguments to be ignored. 59249423Sdim// 60249423Sdim// 3. A variable that does not otherwise have explicit visibility can 61249423Sdim// be restricted by the visibility of its type. 62249423Sdim// 63249423Sdim// 4. A visibility restriction is explicit if it comes from an 64249423Sdim// attribute (or something like it), not a global visibility setting. 65249423Sdim// When emitting a reference to an external symbol, visibility 66249423Sdim// restrictions are ignored unless they are explicit. 67249423Sdim// 68249423Sdim// 5. When computing the visibility of a non-type, including a 69249423Sdim// non-type member of a class, only non-type visibility restrictions 70249423Sdim// are considered: the 'visibility' attribute, global value-visibility 71249423Sdim// settings, and a few special cases like __private_extern. 72249423Sdim// 73249423Sdim// 6. When computing the visibility of a type, including a type member 74249423Sdim// of a class, only type visibility restrictions are considered: 75249423Sdim// the 'type_visibility' attribute and global type-visibility settings. 76249423Sdim// However, a 'visibility' attribute counts as a 'type_visibility' 77249423Sdim// attribute on any declaration that only has the former. 78249423Sdim// 79249423Sdim// The visibility of a "secondary" entity, like a template argument, 80249423Sdim// is computed using the kind of that entity, not the kind of the 81249423Sdim// primary entity for which we are computing visibility. For example, 82249423Sdim// the visibility of a specialization of either of these templates: 83249423Sdim// template <class T, bool (&compare)(T, X)> bool has_match(list<T>, X); 84249423Sdim// template <class T, bool (&compare)(T, X)> class matcher; 85249423Sdim// is restricted according to the type visibility of the argument 'T', 86249423Sdim// the type visibility of 'bool(&)(T,X)', and the value visibility of 87249423Sdim// the argument function 'compare'. That 'has_match' is a value 88249423Sdim// and 'matcher' is a type only matters when looking for attributes 89249423Sdim// and settings from the immediate context. 90249423Sdim 91249423Sdimconst unsigned IgnoreExplicitVisibilityBit = 2; 92263508Sdimconst unsigned IgnoreAllVisibilityBit = 4; 93249423Sdim 94249423Sdim/// Kinds of LV computation. The linkage side of the computation is 95249423Sdim/// always the same, but different things can change how visibility is 96249423Sdim/// computed. 97249423Sdimenum LVComputationKind { 98249423Sdim /// Do an LV computation for, ultimately, a type. 99249423Sdim /// Visibility may be restricted by type visibility settings and 100249423Sdim /// the visibility of template arguments. 101249423Sdim LVForType = NamedDecl::VisibilityForType, 102249423Sdim 103249423Sdim /// Do an LV computation for, ultimately, a non-type declaration. 104249423Sdim /// Visibility may be restricted by value visibility settings and 105249423Sdim /// the visibility of template arguments. 106249423Sdim LVForValue = NamedDecl::VisibilityForValue, 107249423Sdim 108249423Sdim /// Do an LV computation for, ultimately, a type that already has 109249423Sdim /// some sort of explicit visibility. Visibility may only be 110249423Sdim /// restricted by the visibility of template arguments. 111249423Sdim LVForExplicitType = (LVForType | IgnoreExplicitVisibilityBit), 112249423Sdim 113249423Sdim /// Do an LV computation for, ultimately, a non-type declaration 114249423Sdim /// that already has some sort of explicit visibility. Visibility 115249423Sdim /// may only be restricted by the visibility of template arguments. 116263508Sdim LVForExplicitValue = (LVForValue | IgnoreExplicitVisibilityBit), 117263508Sdim 118263508Sdim /// Do an LV computation when we only care about the linkage. 119263508Sdim LVForLinkageOnly = 120263508Sdim LVForValue | IgnoreExplicitVisibilityBit | IgnoreAllVisibilityBit 121249423Sdim}; 122249423Sdim 123249423Sdim/// Does this computation kind permit us to consider additional 124249423Sdim/// visibility settings from attributes and the like? 125249423Sdimstatic bool hasExplicitVisibilityAlready(LVComputationKind computation) { 126249423Sdim return ((unsigned(computation) & IgnoreExplicitVisibilityBit) != 0); 127249423Sdim} 128249423Sdim 129249423Sdim/// Given an LVComputationKind, return one of the same type/value sort 130249423Sdim/// that records that it already has explicit visibility. 131249423Sdimstatic LVComputationKind 132249423SdimwithExplicitVisibilityAlready(LVComputationKind oldKind) { 133249423Sdim LVComputationKind newKind = 134249423Sdim static_cast<LVComputationKind>(unsigned(oldKind) | 135249423Sdim IgnoreExplicitVisibilityBit); 136249423Sdim assert(oldKind != LVForType || newKind == LVForExplicitType); 137249423Sdim assert(oldKind != LVForValue || newKind == LVForExplicitValue); 138249423Sdim assert(oldKind != LVForExplicitType || newKind == LVForExplicitType); 139249423Sdim assert(oldKind != LVForExplicitValue || newKind == LVForExplicitValue); 140249423Sdim return newKind; 141249423Sdim} 142249423Sdim 143249423Sdimstatic Optional<Visibility> getExplicitVisibility(const NamedDecl *D, 144249423Sdim LVComputationKind kind) { 145249423Sdim assert(!hasExplicitVisibilityAlready(kind) && 146249423Sdim "asking for explicit visibility when we shouldn't be"); 147249423Sdim return D->getExplicitVisibility((NamedDecl::ExplicitVisibilityKind) kind); 148249423Sdim} 149249423Sdim 150249423Sdim/// Is the given declaration a "type" or a "value" for the purposes of 151249423Sdim/// visibility computation? 152249423Sdimstatic bool usesTypeVisibility(const NamedDecl *D) { 153249423Sdim return isa<TypeDecl>(D) || 154249423Sdim isa<ClassTemplateDecl>(D) || 155249423Sdim isa<ObjCInterfaceDecl>(D); 156249423Sdim} 157249423Sdim 158249423Sdim/// Does the given declaration have member specialization information, 159249423Sdim/// and if so, is it an explicit specialization? 160249423Sdimtemplate <class T> static typename 161249423Sdimllvm::enable_if_c<!llvm::is_base_of<RedeclarableTemplateDecl, T>::value, 162249423Sdim bool>::type 163249423SdimisExplicitMemberSpecialization(const T *D) { 164249423Sdim if (const MemberSpecializationInfo *member = 165249423Sdim D->getMemberSpecializationInfo()) { 166249423Sdim return member->isExplicitSpecialization(); 167249423Sdim } 168249423Sdim return false; 169249423Sdim} 170249423Sdim 171249423Sdim/// For templates, this question is easier: a member template can't be 172249423Sdim/// explicitly instantiated, so there's a single bit indicating whether 173249423Sdim/// or not this is an explicit member specialization. 174249423Sdimstatic bool isExplicitMemberSpecialization(const RedeclarableTemplateDecl *D) { 175249423Sdim return D->isMemberSpecialization(); 176249423Sdim} 177249423Sdim 178249423Sdim/// Given a visibility attribute, return the explicit visibility 179249423Sdim/// associated with it. 180249423Sdimtemplate <class T> 181249423Sdimstatic Visibility getVisibilityFromAttr(const T *attr) { 182249423Sdim switch (attr->getVisibility()) { 183249423Sdim case T::Default: 184249423Sdim return DefaultVisibility; 185249423Sdim case T::Hidden: 186249423Sdim return HiddenVisibility; 187249423Sdim case T::Protected: 188249423Sdim return ProtectedVisibility; 189249423Sdim } 190249423Sdim llvm_unreachable("bad visibility kind"); 191249423Sdim} 192249423Sdim 193249423Sdim/// Return the explicit visibility of the given declaration. 194249423Sdimstatic Optional<Visibility> getVisibilityOf(const NamedDecl *D, 195249423Sdim NamedDecl::ExplicitVisibilityKind kind) { 196249423Sdim // If we're ultimately computing the visibility of a type, look for 197249423Sdim // a 'type_visibility' attribute before looking for 'visibility'. 198249423Sdim if (kind == NamedDecl::VisibilityForType) { 199249423Sdim if (const TypeVisibilityAttr *A = D->getAttr<TypeVisibilityAttr>()) { 200249423Sdim return getVisibilityFromAttr(A); 201249423Sdim } 202249423Sdim } 203249423Sdim 204221345Sdim // If this declaration has an explicit visibility attribute, use it. 205221345Sdim if (const VisibilityAttr *A = D->getAttr<VisibilityAttr>()) { 206249423Sdim return getVisibilityFromAttr(A); 207221345Sdim } 208218893Sdim 209221345Sdim // If we're on Mac OS X, an 'availability' for Mac OS X attribute 210221345Sdim // implies visibility(default). 211226633Sdim if (D->getASTContext().getTargetInfo().getTriple().isOSDarwin()) { 212221345Sdim for (specific_attr_iterator<AvailabilityAttr> 213221345Sdim A = D->specific_attr_begin<AvailabilityAttr>(), 214221345Sdim AEnd = D->specific_attr_end<AvailabilityAttr>(); 215221345Sdim A != AEnd; ++A) 216221345Sdim if ((*A)->getPlatform()->getName().equals("macosx")) 217221345Sdim return DefaultVisibility; 218218893Sdim } 219218893Sdim 220249423Sdim return None; 221218893Sdim} 222218893Sdim 223263508Sdimstatic LinkageInfo 224263508SdimgetLVForType(const Type &T, LVComputationKind computation) { 225263508Sdim if (computation == LVForLinkageOnly) 226263508Sdim return LinkageInfo(T.getLinkage(), DefaultVisibility, true); 227263508Sdim return T.getLinkageAndVisibility(); 228263508Sdim} 229263508Sdim 230203955Srdivacky/// \brief Get the most restrictive linkage for the types in the given 231249423Sdim/// template parameter list. For visibility purposes, template 232249423Sdim/// parameters are part of the signature of a template. 233234353Sdimstatic LinkageInfo 234263508SdimgetLVForTemplateParameterList(const TemplateParameterList *params, 235263508Sdim LVComputationKind computation) { 236249423Sdim LinkageInfo LV; 237249423Sdim for (TemplateParameterList::const_iterator P = params->begin(), 238249423Sdim PEnd = params->end(); 239203955Srdivacky P != PEnd; ++P) { 240249423Sdim 241249423Sdim // Template type parameters are the most common and never 242249423Sdim // contribute to visibility, pack or not. 243249423Sdim if (isa<TemplateTypeParmDecl>(*P)) 244249423Sdim continue; 245249423Sdim 246249423Sdim // Non-type template parameters can be restricted by the value type, e.g. 247249423Sdim // template <enum X> class A { ... }; 248249423Sdim // We have to be careful here, though, because we can be dealing with 249249423Sdim // dependent types. 250218893Sdim if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 251249423Sdim // Handle the non-pack case first. 252249423Sdim if (!NTTP->isExpandedParameterPack()) { 253249423Sdim if (!NTTP->getType()->isDependentType()) { 254263508Sdim LV.merge(getLVForType(*NTTP->getType(), computation)); 255218893Sdim } 256218893Sdim continue; 257218893Sdim } 258234353Sdim 259249423Sdim // Look at all the types in an expanded pack. 260249423Sdim for (unsigned i = 0, n = NTTP->getNumExpansionTypes(); i != n; ++i) { 261249423Sdim QualType type = NTTP->getExpansionType(i); 262249423Sdim if (!type->isDependentType()) 263249423Sdim LV.merge(type->getLinkageAndVisibility()); 264203955Srdivacky } 265249423Sdim continue; 266218893Sdim } 267198092Srdivacky 268249423Sdim // Template template parameters can be restricted by their 269249423Sdim // template parameters, recursively. 270249423Sdim TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 271249423Sdim 272249423Sdim // Handle the non-pack case first. 273249423Sdim if (!TTP->isExpandedParameterPack()) { 274263508Sdim LV.merge(getLVForTemplateParameterList(TTP->getTemplateParameters(), 275263508Sdim computation)); 276249423Sdim continue; 277203955Srdivacky } 278249423Sdim 279249423Sdim // Look at all expansions in an expanded pack. 280249423Sdim for (unsigned i = 0, n = TTP->getNumExpansionTemplateParameters(); 281249423Sdim i != n; ++i) { 282249423Sdim LV.merge(getLVForTemplateParameterList( 283263508Sdim TTP->getExpansionTemplateParameters(i), computation)); 284249423Sdim } 285193326Sed } 286193326Sed 287218893Sdim return LV; 288193326Sed} 289193326Sed 290218893Sdim/// getLVForDecl - Get the linkage and visibility for the given declaration. 291249423Sdimstatic LinkageInfo getLVForDecl(const NamedDecl *D, 292249423Sdim LVComputationKind computation); 293218893Sdim 294263508Sdimstatic const Decl *getOutermostFuncOrBlockContext(const Decl *D) { 295263508Sdim const Decl *Ret = NULL; 296263508Sdim const DeclContext *DC = D->getDeclContext(); 297263508Sdim while (DC->getDeclKind() != Decl::TranslationUnit) { 298263508Sdim if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC)) 299263508Sdim Ret = cast<Decl>(DC); 300263508Sdim DC = DC->getParent(); 301263508Sdim } 302263508Sdim return Ret; 303263508Sdim} 304263508Sdim 305203955Srdivacky/// \brief Get the most restrictive linkage for the types and 306203955Srdivacky/// declarations in the given template argument list. 307249423Sdim/// 308249423Sdim/// Note that we don't take an LVComputationKind because we always 309249423Sdim/// want to honor the visibility of template arguments in the same way. 310249423Sdimstatic LinkageInfo 311263508SdimgetLVForTemplateArgumentList(ArrayRef<TemplateArgument> args, 312263508Sdim LVComputationKind computation) { 313249423Sdim LinkageInfo LV; 314193326Sed 315249423Sdim for (unsigned i = 0, e = args.size(); i != e; ++i) { 316249423Sdim const TemplateArgument &arg = args[i]; 317249423Sdim switch (arg.getKind()) { 318203955Srdivacky case TemplateArgument::Null: 319203955Srdivacky case TemplateArgument::Integral: 320203955Srdivacky case TemplateArgument::Expression: 321249423Sdim continue; 322234353Sdim 323203955Srdivacky case TemplateArgument::Type: 324263508Sdim LV.merge(getLVForType(*arg.getAsType(), computation)); 325249423Sdim continue; 326201361Srdivacky 327203955Srdivacky case TemplateArgument::Declaration: 328249423Sdim if (NamedDecl *ND = dyn_cast<NamedDecl>(arg.getAsDecl())) { 329249423Sdim assert(!usesTypeVisibility(ND)); 330263508Sdim LV.merge(getLVForDecl(ND, computation)); 331249423Sdim } 332249423Sdim continue; 333201361Srdivacky 334243830Sdim case TemplateArgument::NullPtr: 335249423Sdim LV.merge(arg.getNullPtrType()->getLinkageAndVisibility()); 336249423Sdim continue; 337243830Sdim 338203955Srdivacky case TemplateArgument::Template: 339218893Sdim case TemplateArgument::TemplateExpansion: 340234353Sdim if (TemplateDecl *Template 341249423Sdim = arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl()) 342263508Sdim LV.merge(getLVForDecl(Template, computation)); 343249423Sdim continue; 344201361Srdivacky 345203955Srdivacky case TemplateArgument::Pack: 346263508Sdim LV.merge(getLVForTemplateArgumentList(arg.getPackAsArray(), computation)); 347249423Sdim continue; 348193326Sed } 349249423Sdim llvm_unreachable("bad template argument kind"); 350193326Sed } 351193326Sed 352218893Sdim return LV; 353193326Sed} 354193326Sed 355234353Sdimstatic LinkageInfo 356263508SdimgetLVForTemplateArgumentList(const TemplateArgumentList &TArgs, 357263508Sdim LVComputationKind computation) { 358263508Sdim return getLVForTemplateArgumentList(TArgs.asArray(), computation); 359212904Sdim} 360212904Sdim 361249423Sdimstatic bool shouldConsiderTemplateVisibility(const FunctionDecl *fn, 362249423Sdim const FunctionTemplateSpecializationInfo *specInfo) { 363249423Sdim // Include visibility from the template parameters and arguments 364249423Sdim // only if this is not an explicit instantiation or specialization 365249423Sdim // with direct explicit visibility. (Implicit instantiations won't 366249423Sdim // have a direct attribute.) 367249423Sdim if (!specInfo->isExplicitInstantiationOrSpecialization()) 368249423Sdim return true; 369249423Sdim 370249423Sdim return !fn->hasAttr<VisibilityAttr>(); 371224145Sdim} 372224145Sdim 373249423Sdim/// Merge in template-related linkage and visibility for the given 374249423Sdim/// function template specialization. 375249423Sdim/// 376249423Sdim/// We don't need a computation kind here because we can assume 377249423Sdim/// LVForValue. 378249423Sdim/// 379249423Sdim/// \param[out] LV the computation to use for the parent 380249423Sdimstatic void 381249423SdimmergeTemplateLV(LinkageInfo &LV, const FunctionDecl *fn, 382263508Sdim const FunctionTemplateSpecializationInfo *specInfo, 383263508Sdim LVComputationKind computation) { 384249423Sdim bool considerVisibility = 385249423Sdim shouldConsiderTemplateVisibility(fn, specInfo); 386249423Sdim 387249423Sdim // Merge information from the template parameters. 388249423Sdim FunctionTemplateDecl *temp = specInfo->getTemplate(); 389249423Sdim LinkageInfo tempLV = 390263508Sdim getLVForTemplateParameterList(temp->getTemplateParameters(), computation); 391249423Sdim LV.mergeMaybeWithVisibility(tempLV, considerVisibility); 392249423Sdim 393249423Sdim // Merge information from the template arguments. 394249423Sdim const TemplateArgumentList &templateArgs = *specInfo->TemplateArguments; 395263508Sdim LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation); 396249423Sdim LV.mergeMaybeWithVisibility(argsLV, considerVisibility); 397224145Sdim} 398224145Sdim 399249423Sdim/// Does the given declaration have a direct visibility attribute 400249423Sdim/// that would match the given rules? 401249423Sdimstatic bool hasDirectVisibilityAttribute(const NamedDecl *D, 402249423Sdim LVComputationKind computation) { 403249423Sdim switch (computation) { 404249423Sdim case LVForType: 405249423Sdim case LVForExplicitType: 406249423Sdim if (D->hasAttr<TypeVisibilityAttr>()) 407249423Sdim return true; 408249423Sdim // fallthrough 409249423Sdim case LVForValue: 410249423Sdim case LVForExplicitValue: 411249423Sdim if (D->hasAttr<VisibilityAttr>()) 412249423Sdim return true; 413249423Sdim return false; 414263508Sdim case LVForLinkageOnly: 415263508Sdim return false; 416249423Sdim } 417249423Sdim llvm_unreachable("bad visibility computation kind"); 418249423Sdim} 419249423Sdim 420249423Sdim/// Should we consider visibility associated with the template 421249423Sdim/// arguments and parameters of the given class template specialization? 422249423Sdimstatic bool shouldConsiderTemplateVisibility( 423249423Sdim const ClassTemplateSpecializationDecl *spec, 424249423Sdim LVComputationKind computation) { 425249423Sdim // Include visibility from the template parameters and arguments 426249423Sdim // only if this is not an explicit instantiation or specialization 427249423Sdim // with direct explicit visibility (and note that implicit 428249423Sdim // instantiations won't have a direct attribute). 429249423Sdim // 430249423Sdim // Furthermore, we want to ignore template parameters and arguments 431249423Sdim // for an explicit specialization when computing the visibility of a 432249423Sdim // member thereof with explicit visibility. 433249423Sdim // 434249423Sdim // This is a bit complex; let's unpack it. 435249423Sdim // 436249423Sdim // An explicit class specialization is an independent, top-level 437249423Sdim // declaration. As such, if it or any of its members has an 438249423Sdim // explicit visibility attribute, that must directly express the 439249423Sdim // user's intent, and we should honor it. The same logic applies to 440249423Sdim // an explicit instantiation of a member of such a thing. 441249423Sdim 442249423Sdim // Fast path: if this is not an explicit instantiation or 443249423Sdim // specialization, we always want to consider template-related 444249423Sdim // visibility restrictions. 445249423Sdim if (!spec->isExplicitInstantiationOrSpecialization()) 446249423Sdim return true; 447249423Sdim 448249423Sdim // This is the 'member thereof' check. 449249423Sdim if (spec->isExplicitSpecialization() && 450249423Sdim hasExplicitVisibilityAlready(computation)) 451249423Sdim return false; 452249423Sdim 453249423Sdim return !hasDirectVisibilityAttribute(spec, computation); 454249423Sdim} 455249423Sdim 456249423Sdim/// Merge in template-related linkage and visibility for the given 457249423Sdim/// class template specialization. 458249423Sdimstatic void mergeTemplateLV(LinkageInfo &LV, 459249423Sdim const ClassTemplateSpecializationDecl *spec, 460249423Sdim LVComputationKind computation) { 461249423Sdim bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation); 462249423Sdim 463249423Sdim // Merge information from the template parameters, but ignore 464249423Sdim // visibility if we're only considering template arguments. 465249423Sdim 466249423Sdim ClassTemplateDecl *temp = spec->getSpecializedTemplate(); 467249423Sdim LinkageInfo tempLV = 468263508Sdim getLVForTemplateParameterList(temp->getTemplateParameters(), computation); 469249423Sdim LV.mergeMaybeWithVisibility(tempLV, 470249423Sdim considerVisibility && !hasExplicitVisibilityAlready(computation)); 471249423Sdim 472249423Sdim // Merge information from the template arguments. We ignore 473249423Sdim // template-argument visibility if we've got an explicit 474249423Sdim // instantiation with a visibility attribute. 475249423Sdim const TemplateArgumentList &templateArgs = spec->getTemplateArgs(); 476263508Sdim LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation); 477263508Sdim if (considerVisibility) 478263508Sdim LV.mergeVisibility(argsLV); 479263508Sdim LV.mergeExternalVisibility(argsLV); 480249423Sdim} 481249423Sdim 482239462Sdimstatic bool useInlineVisibilityHidden(const NamedDecl *D) { 483239462Sdim // FIXME: we should warn if -fvisibility-inlines-hidden is used with c. 484239462Sdim const LangOptions &Opts = D->getASTContext().getLangOpts(); 485239462Sdim if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden) 486239462Sdim return false; 487239462Sdim 488239462Sdim const FunctionDecl *FD = dyn_cast<FunctionDecl>(D); 489239462Sdim if (!FD) 490239462Sdim return false; 491239462Sdim 492239462Sdim TemplateSpecializationKind TSK = TSK_Undeclared; 493239462Sdim if (FunctionTemplateSpecializationInfo *spec 494239462Sdim = FD->getTemplateSpecializationInfo()) { 495239462Sdim TSK = spec->getTemplateSpecializationKind(); 496239462Sdim } else if (MemberSpecializationInfo *MSI = 497239462Sdim FD->getMemberSpecializationInfo()) { 498239462Sdim TSK = MSI->getTemplateSpecializationKind(); 499239462Sdim } 500239462Sdim 501239462Sdim const FunctionDecl *Def = 0; 502239462Sdim // InlineVisibilityHidden only applies to definitions, and 503239462Sdim // isInlined() only gives meaningful answers on definitions 504239462Sdim // anyway. 505239462Sdim return TSK != TSK_ExplicitInstantiationDeclaration && 506239462Sdim TSK != TSK_ExplicitInstantiationDefinition && 507243830Sdim FD->hasBody(Def) && Def->isInlined() && !Def->hasAttr<GNUInlineAttr>(); 508239462Sdim} 509239462Sdim 510251662Sdimtemplate <typename T> static bool isFirstInExternCContext(T *D) { 511263508Sdim const T *First = D->getFirstDecl(); 512251662Sdim return First->isInExternCContext(); 513249423Sdim} 514249423Sdim 515251662Sdimstatic bool isSingleLineExternC(const Decl &D) { 516251662Sdim if (const LinkageSpecDecl *SD = dyn_cast<LinkageSpecDecl>(D.getDeclContext())) 517251662Sdim if (SD->getLanguage() == LinkageSpecDecl::lang_c && !SD->hasBraces()) 518251662Sdim return true; 519251662Sdim return false; 520251662Sdim} 521251662Sdim 522239462Sdimstatic LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D, 523249423Sdim LVComputationKind computation) { 524212904Sdim assert(D->getDeclContext()->getRedeclContext()->isFileContext() && 525199990Srdivacky "Not a name having namespace scope"); 526199990Srdivacky ASTContext &Context = D->getASTContext(); 527199990Srdivacky 528199990Srdivacky // C++ [basic.link]p3: 529199990Srdivacky // A name having namespace scope (3.3.6) has internal linkage if it 530199990Srdivacky // is the name of 531199990Srdivacky // - an object, reference, function or function template that is 532199990Srdivacky // explicitly declared static; or, 533199990Srdivacky // (This bullet corresponds to C99 6.2.2p3.) 534199990Srdivacky if (const VarDecl *Var = dyn_cast<VarDecl>(D)) { 535199990Srdivacky // Explicitly declared static. 536212904Sdim if (Var->getStorageClass() == SC_Static) 537218893Sdim return LinkageInfo::internal(); 538199990Srdivacky 539243830Sdim // - a non-volatile object or reference that is explicitly declared const 540243830Sdim // or constexpr and neither explicitly declared extern nor previously 541243830Sdim // declared to have external linkage; or (there is no equivalent in C99) 542234353Sdim if (Context.getLangOpts().CPlusPlus && 543243830Sdim Var->getType().isConstQualified() && 544249423Sdim !Var->getType().isVolatileQualified()) { 545234353Sdim const VarDecl *PrevVar = Var->getPreviousDecl(); 546243830Sdim if (PrevVar) 547263508Sdim return getLVForDecl(PrevVar, computation); 548249423Sdim 549249423Sdim if (Var->getStorageClass() != SC_Extern && 550251662Sdim Var->getStorageClass() != SC_PrivateExtern && 551251662Sdim !isSingleLineExternC(*Var)) 552249423Sdim return LinkageInfo::internal(); 553224145Sdim } 554249423Sdim 555249423Sdim for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar; 556249423Sdim PrevVar = PrevVar->getPreviousDecl()) { 557249423Sdim if (PrevVar->getStorageClass() == SC_PrivateExtern && 558249423Sdim Var->getStorageClass() == SC_None) 559249423Sdim return PrevVar->getLinkageAndVisibility(); 560249423Sdim // Explicitly declared static. 561249423Sdim if (PrevVar->getStorageClass() == SC_Static) 562249423Sdim return LinkageInfo::internal(); 563249423Sdim } 564199990Srdivacky } else if (isa<FunctionDecl>(D) || isa<FunctionTemplateDecl>(D)) { 565203955Srdivacky // C++ [temp]p4: 566203955Srdivacky // A non-member function template can have internal linkage; any 567203955Srdivacky // other template name shall have external linkage. 568199990Srdivacky const FunctionDecl *Function = 0; 569199990Srdivacky if (const FunctionTemplateDecl *FunTmpl 570199990Srdivacky = dyn_cast<FunctionTemplateDecl>(D)) 571199990Srdivacky Function = FunTmpl->getTemplatedDecl(); 572199990Srdivacky else 573199990Srdivacky Function = cast<FunctionDecl>(D); 574199990Srdivacky 575199990Srdivacky // Explicitly declared static. 576249423Sdim if (Function->getCanonicalDecl()->getStorageClass() == SC_Static) 577218893Sdim return LinkageInfo(InternalLinkage, DefaultVisibility, false); 578199990Srdivacky } 579263508Sdim // - a data member of an anonymous union. 580263508Sdim assert(!isa<IndirectFieldDecl>(D) && "Didn't expect an IndirectFieldDecl!"); 581263508Sdim assert(!isa<FieldDecl>(D) && "Didn't expect a FieldDecl!"); 582199990Srdivacky 583219077Sdim if (D->isInAnonymousNamespace()) { 584219077Sdim const VarDecl *Var = dyn_cast<VarDecl>(D); 585219077Sdim const FunctionDecl *Func = dyn_cast<FunctionDecl>(D); 586251662Sdim if ((!Var || !isFirstInExternCContext(Var)) && 587251662Sdim (!Func || !isFirstInExternCContext(Func))) 588219077Sdim return LinkageInfo::uniqueExternal(); 589219077Sdim } 590218893Sdim 591218893Sdim // Set up the defaults. 592218893Sdim 593218893Sdim // C99 6.2.2p5: 594218893Sdim // If the declaration of an identifier for an object has file 595218893Sdim // scope and no storage-class specifier, its linkage is 596218893Sdim // external. 597218893Sdim LinkageInfo LV; 598218893Sdim 599249423Sdim if (!hasExplicitVisibilityAlready(computation)) { 600249423Sdim if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) { 601239462Sdim LV.mergeVisibility(*Vis, true); 602218893Sdim } else { 603218893Sdim // If we're declared in a namespace with a visibility attribute, 604249423Sdim // use that namespace's visibility, and it still counts as explicit. 605218893Sdim for (const DeclContext *DC = D->getDeclContext(); 606218893Sdim !isa<TranslationUnitDecl>(DC); 607218893Sdim DC = DC->getParent()) { 608234353Sdim const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC); 609234353Sdim if (!ND) continue; 610249423Sdim if (Optional<Visibility> Vis = getExplicitVisibility(ND, computation)) { 611239462Sdim LV.mergeVisibility(*Vis, true); 612218893Sdim break; 613218893Sdim } 614218893Sdim } 615218893Sdim } 616218893Sdim 617249423Sdim // Add in global settings if the above didn't give us direct visibility. 618249423Sdim if (!LV.isVisibilityExplicit()) { 619249423Sdim // Use global type/value visibility as appropriate. 620249423Sdim Visibility globalVisibility; 621249423Sdim if (computation == LVForValue) { 622249423Sdim globalVisibility = Context.getLangOpts().getValueVisibilityMode(); 623249423Sdim } else { 624249423Sdim assert(computation == LVForType); 625249423Sdim globalVisibility = Context.getLangOpts().getTypeVisibilityMode(); 626249423Sdim } 627249423Sdim LV.mergeVisibility(globalVisibility, /*explicit*/ false); 628249423Sdim 629249423Sdim // If we're paying attention to global visibility, apply 630249423Sdim // -finline-visibility-hidden if this is an inline method. 631249423Sdim if (useInlineVisibilityHidden(D)) 632249423Sdim LV.mergeVisibility(HiddenVisibility, true); 633249423Sdim } 634239462Sdim } 635239462Sdim 636199990Srdivacky // C++ [basic.link]p4: 637218893Sdim 638199990Srdivacky // A name having namespace scope has external linkage if it is the 639199990Srdivacky // name of 640199990Srdivacky // 641199990Srdivacky // - an object or reference, unless it has internal linkage; or 642199990Srdivacky if (const VarDecl *Var = dyn_cast<VarDecl>(D)) { 643218893Sdim // GCC applies the following optimization to variables and static 644218893Sdim // data members, but not to functions: 645218893Sdim // 646218893Sdim // Modify the variable's LV by the LV of its type unless this is 647218893Sdim // C or extern "C". This follows from [basic.link]p9: 648218893Sdim // A type without linkage shall not be used as the type of a 649218893Sdim // variable or function with external linkage unless 650218893Sdim // - the entity has C language linkage, or 651218893Sdim // - the entity is declared within an unnamed namespace, or 652218893Sdim // - the entity is not used or is defined in the same 653218893Sdim // translation unit. 654218893Sdim // and [basic.link]p10: 655218893Sdim // ...the types specified by all declarations referring to a 656218893Sdim // given variable or function shall be identical... 657218893Sdim // C does not have an equivalent rule. 658218893Sdim // 659218893Sdim // Ignore this if we've got an explicit attribute; the user 660218893Sdim // probably knows what they're doing. 661218893Sdim // 662218893Sdim // Note that we don't want to make the variable non-external 663218893Sdim // because of this, but unique-external linkage suits us. 664251662Sdim if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Var)) { 665263508Sdim LinkageInfo TypeLV = getLVForType(*Var->getType(), computation); 666249423Sdim if (TypeLV.getLinkage() != ExternalLinkage) 667218893Sdim return LinkageInfo::uniqueExternal(); 668249423Sdim if (!LV.isVisibilityExplicit()) 669249423Sdim LV.mergeVisibility(TypeLV); 670218893Sdim } 671218893Sdim 672218893Sdim if (Var->getStorageClass() == SC_PrivateExtern) 673239462Sdim LV.mergeVisibility(HiddenVisibility, true); 674218893Sdim 675243830Sdim // Note that Sema::MergeVarDecl already takes care of implementing 676243830Sdim // C99 6.2.2p4 and propagating the visibility attribute, so we don't have 677243830Sdim // to do it here. 678218893Sdim 679218893Sdim // - a function, unless it has internal linkage; or 680218893Sdim } else if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 681218893Sdim // In theory, we can modify the function's LV by the LV of its 682218893Sdim // type unless it has C linkage (see comment above about variables 683218893Sdim // for justification). In practice, GCC doesn't do this, so it's 684218893Sdim // just too painful to make work. 685203955Srdivacky 686218893Sdim if (Function->getStorageClass() == SC_PrivateExtern) 687239462Sdim LV.mergeVisibility(HiddenVisibility, true); 688199990Srdivacky 689249423Sdim // Note that Sema::MergeCompatibleFunctionDecls already takes care of 690249423Sdim // merging storage classes and visibility attributes, so we don't have to 691249423Sdim // look at previous decls in here. 692199990Srdivacky 693218893Sdim // In C++, then if the type of the function uses a type with 694218893Sdim // unique-external linkage, it's not legally usable from outside 695218893Sdim // this translation unit. However, we should use the C linkage 696218893Sdim // rules instead for extern "C" declarations. 697234353Sdim if (Context.getLangOpts().CPlusPlus && 698263508Sdim !Function->isInExternCContext()) { 699263508Sdim // Only look at the type-as-written. If this function has an auto-deduced 700263508Sdim // return type, we can't compute the linkage of that type because it could 701263508Sdim // require looking at the linkage of this function, and we don't need this 702263508Sdim // for correctness because the type is not part of the function's 703263508Sdim // signature. 704263508Sdim // FIXME: This is a hack. We should be able to solve this circularity and 705263508Sdim // the one in getLVForClassMember for Functions some other way. 706263508Sdim QualType TypeAsWritten = Function->getType(); 707263508Sdim if (TypeSourceInfo *TSI = Function->getTypeSourceInfo()) 708263508Sdim TypeAsWritten = TSI->getType(); 709263508Sdim if (TypeAsWritten->getLinkage() == UniqueExternalLinkage) 710263508Sdim return LinkageInfo::uniqueExternal(); 711263508Sdim } 712203955Srdivacky 713249423Sdim // Consider LV from the template and the template arguments. 714249423Sdim // We're at file scope, so we do not need to worry about nested 715249423Sdim // specializations. 716224145Sdim if (FunctionTemplateSpecializationInfo *specInfo 717203955Srdivacky = Function->getTemplateSpecializationInfo()) { 718263508Sdim mergeTemplateLV(LV, Function, specInfo, computation); 719203955Srdivacky } 720203955Srdivacky 721199990Srdivacky // - a named class (Clause 9), or an unnamed class defined in a 722199990Srdivacky // typedef declaration in which the class has the typedef name 723199990Srdivacky // for linkage purposes (7.1.3); or 724199990Srdivacky // - a named enumeration (7.2), or an unnamed enumeration 725199990Srdivacky // defined in a typedef declaration in which the enumeration 726199990Srdivacky // has the typedef name for linkage purposes (7.1.3); or 727218893Sdim } else if (const TagDecl *Tag = dyn_cast<TagDecl>(D)) { 728218893Sdim // Unnamed tags have no linkage. 729249423Sdim if (!Tag->hasNameForLinkage()) 730218893Sdim return LinkageInfo::none(); 731199990Srdivacky 732218893Sdim // If this is a class template specialization, consider the 733249423Sdim // linkage of the template and template arguments. We're at file 734249423Sdim // scope, so we do not need to worry about nested specializations. 735224145Sdim if (const ClassTemplateSpecializationDecl *spec 736218893Sdim = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) { 737249423Sdim mergeTemplateLV(LV, spec, computation); 738203955Srdivacky } 739203955Srdivacky 740199990Srdivacky // - an enumerator belonging to an enumeration with external linkage; 741218893Sdim } else if (isa<EnumConstantDecl>(D)) { 742239462Sdim LinkageInfo EnumLV = getLVForDecl(cast<NamedDecl>(D->getDeclContext()), 743249423Sdim computation); 744263508Sdim if (!isExternalFormalLinkage(EnumLV.getLinkage())) 745218893Sdim return LinkageInfo::none(); 746218893Sdim LV.merge(EnumLV); 747199990Srdivacky 748199990Srdivacky // - a template, unless it is a function template that has 749199990Srdivacky // internal linkage (Clause 14); 750221345Sdim } else if (const TemplateDecl *temp = dyn_cast<TemplateDecl>(D)) { 751249423Sdim bool considerVisibility = !hasExplicitVisibilityAlready(computation); 752249423Sdim LinkageInfo tempLV = 753263508Sdim getLVForTemplateParameterList(temp->getTemplateParameters(), computation); 754249423Sdim LV.mergeMaybeWithVisibility(tempLV, considerVisibility); 755249423Sdim 756199990Srdivacky // - a namespace (7.3), unless it is declared within an unnamed 757199990Srdivacky // namespace. 758218893Sdim } else if (isa<NamespaceDecl>(D) && !D->isInAnonymousNamespace()) { 759218893Sdim return LV; 760199990Srdivacky 761218893Sdim // By extension, we assign external linkage to Objective-C 762218893Sdim // interfaces. 763218893Sdim } else if (isa<ObjCInterfaceDecl>(D)) { 764218893Sdim // fallout 765218893Sdim 766218893Sdim // Everything not covered here has no linkage. 767218893Sdim } else { 768218893Sdim return LinkageInfo::none(); 769218893Sdim } 770218893Sdim 771218893Sdim // If we ended up with non-external linkage, visibility should 772218893Sdim // always be default. 773249423Sdim if (LV.getLinkage() != ExternalLinkage) 774249423Sdim return LinkageInfo(LV.getLinkage(), DefaultVisibility, false); 775218893Sdim 776218893Sdim return LV; 777199990Srdivacky} 778199990Srdivacky 779249423Sdimstatic LinkageInfo getLVForClassMember(const NamedDecl *D, 780249423Sdim LVComputationKind computation) { 781218893Sdim // Only certain class members have linkage. Note that fields don't 782218893Sdim // really have linkage, but it's convenient to say they do for the 783218893Sdim // purposes of calculating linkage of pointer-to-data-member 784218893Sdim // template arguments. 785212904Sdim if (!(isa<CXXMethodDecl>(D) || 786212904Sdim isa<VarDecl>(D) || 787218893Sdim isa<FieldDecl>(D) || 788263508Sdim isa<IndirectFieldDecl>(D) || 789249423Sdim isa<TagDecl>(D))) 790218893Sdim return LinkageInfo::none(); 791212904Sdim 792218893Sdim LinkageInfo LV; 793212904Sdim 794218893Sdim // If we have an explicit visibility attribute, merge that in. 795249423Sdim if (!hasExplicitVisibilityAlready(computation)) { 796249423Sdim if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) 797221345Sdim LV.mergeVisibility(*Vis, true); 798239462Sdim // If we're paying attention to global visibility, apply 799239462Sdim // -finline-visibility-hidden if this is an inline method. 800239462Sdim // 801239462Sdim // Note that we do this before merging information about 802239462Sdim // the class visibility. 803249423Sdim if (!LV.isVisibilityExplicit() && useInlineVisibilityHidden(D)) 804239462Sdim LV.mergeVisibility(HiddenVisibility, true); 805234982Sdim } 806218893Sdim 807239462Sdim // If this class member has an explicit visibility attribute, the only 808239462Sdim // thing that can change its visibility is the template arguments, so 809239462Sdim // only look for them when processing the class. 810249423Sdim LVComputationKind classComputation = computation; 811249423Sdim if (LV.isVisibilityExplicit()) 812249423Sdim classComputation = withExplicitVisibilityAlready(computation); 813234982Sdim 814249423Sdim LinkageInfo classLV = 815249423Sdim getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation); 816212904Sdim // If the class already has unique-external linkage, we can't improve. 817249423Sdim if (classLV.getLinkage() == UniqueExternalLinkage) 818218893Sdim return LinkageInfo::uniqueExternal(); 819212904Sdim 820263508Sdim if (!isExternallyVisible(classLV.getLinkage())) 821263508Sdim return LinkageInfo::none(); 822263508Sdim 823263508Sdim 824249423Sdim // Otherwise, don't merge in classLV yet, because in certain cases 825249423Sdim // we need to completely ignore the visibility from it. 826239462Sdim 827249423Sdim // Specifically, if this decl exists and has an explicit attribute. 828249423Sdim const NamedDecl *explicitSpecSuppressor = 0; 829249423Sdim 830212904Sdim if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 831218893Sdim // If the type of the function uses a type with unique-external 832218893Sdim // linkage, it's not legally usable from outside this translation unit. 833263508Sdim // But only look at the type-as-written. If this function has an auto-deduced 834263508Sdim // return type, we can't compute the linkage of that type because it could 835263508Sdim // require looking at the linkage of this function, and we don't need this 836263508Sdim // for correctness because the type is not part of the function's 837263508Sdim // signature. 838263508Sdim // FIXME: This is a hack. We should be able to solve this circularity and the 839263508Sdim // one in getLVForNamespaceScopeDecl for Functions some other way. 840263508Sdim { 841263508Sdim QualType TypeAsWritten = MD->getType(); 842263508Sdim if (TypeSourceInfo *TSI = MD->getTypeSourceInfo()) 843263508Sdim TypeAsWritten = TSI->getType(); 844263508Sdim if (TypeAsWritten->getLinkage() == UniqueExternalLinkage) 845263508Sdim return LinkageInfo::uniqueExternal(); 846263508Sdim } 847218893Sdim // If this is a method template specialization, use the linkage for 848218893Sdim // the template parameters and arguments. 849224145Sdim if (FunctionTemplateSpecializationInfo *spec 850212904Sdim = MD->getTemplateSpecializationInfo()) { 851263508Sdim mergeTemplateLV(LV, MD, spec, computation); 852249423Sdim if (spec->isExplicitSpecialization()) { 853249423Sdim explicitSpecSuppressor = MD; 854249423Sdim } else if (isExplicitMemberSpecialization(spec->getTemplate())) { 855249423Sdim explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl(); 856224145Sdim } 857249423Sdim } else if (isExplicitMemberSpecialization(MD)) { 858249423Sdim explicitSpecSuppressor = MD; 859212904Sdim } 860212904Sdim 861218893Sdim } else if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) { 862224145Sdim if (const ClassTemplateSpecializationDecl *spec 863218893Sdim = dyn_cast<ClassTemplateSpecializationDecl>(RD)) { 864249423Sdim mergeTemplateLV(LV, spec, computation); 865249423Sdim if (spec->isExplicitSpecialization()) { 866249423Sdim explicitSpecSuppressor = spec; 867239462Sdim } else { 868249423Sdim const ClassTemplateDecl *temp = spec->getSpecializedTemplate(); 869249423Sdim if (isExplicitMemberSpecialization(temp)) { 870249423Sdim explicitSpecSuppressor = temp->getTemplatedDecl(); 871249423Sdim } 872224145Sdim } 873249423Sdim } else if (isExplicitMemberSpecialization(RD)) { 874249423Sdim explicitSpecSuppressor = RD; 875218893Sdim } 876218893Sdim 877218893Sdim // Static data members. 878218893Sdim } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 879218893Sdim // Modify the variable's linkage by its type, but ignore the 880218893Sdim // type's visibility unless it's a definition. 881263508Sdim LinkageInfo typeLV = getLVForType(*VD->getType(), computation); 882263508Sdim if (!LV.isVisibilityExplicit() && !classLV.isVisibilityExplicit()) 883263508Sdim LV.mergeVisibility(typeLV); 884263508Sdim LV.mergeExternalVisibility(typeLV); 885249423Sdim 886249423Sdim if (isExplicitMemberSpecialization(VD)) { 887249423Sdim explicitSpecSuppressor = VD; 888249423Sdim } 889249423Sdim 890249423Sdim // Template members. 891249423Sdim } else if (const TemplateDecl *temp = dyn_cast<TemplateDecl>(D)) { 892249423Sdim bool considerVisibility = 893249423Sdim (!LV.isVisibilityExplicit() && 894249423Sdim !classLV.isVisibilityExplicit() && 895249423Sdim !hasExplicitVisibilityAlready(computation)); 896249423Sdim LinkageInfo tempLV = 897263508Sdim getLVForTemplateParameterList(temp->getTemplateParameters(), computation); 898249423Sdim LV.mergeMaybeWithVisibility(tempLV, considerVisibility); 899249423Sdim 900249423Sdim if (const RedeclarableTemplateDecl *redeclTemp = 901249423Sdim dyn_cast<RedeclarableTemplateDecl>(temp)) { 902249423Sdim if (isExplicitMemberSpecialization(redeclTemp)) { 903249423Sdim explicitSpecSuppressor = temp->getTemplatedDecl(); 904249423Sdim } 905249423Sdim } 906212904Sdim } 907212904Sdim 908249423Sdim // We should never be looking for an attribute directly on a template. 909249423Sdim assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor)); 910212904Sdim 911249423Sdim // If this member is an explicit member specialization, and it has 912249423Sdim // an explicit attribute, ignore visibility from the parent. 913249423Sdim bool considerClassVisibility = true; 914249423Sdim if (explicitSpecSuppressor && 915249423Sdim // optimization: hasDVA() is true only with explicit visibility. 916249423Sdim LV.isVisibilityExplicit() && 917249423Sdim classLV.getVisibility() != DefaultVisibility && 918249423Sdim hasDirectVisibilityAttribute(explicitSpecSuppressor, computation)) { 919249423Sdim considerClassVisibility = false; 920218893Sdim } 921249423Sdim 922249423Sdim // Finally, merge in information from the class. 923249423Sdim LV.mergeMaybeWithVisibility(classLV, considerClassVisibility); 924249423Sdim return LV; 925218893Sdim} 926218893Sdim 927234353Sdimvoid NamedDecl::anchor() { } 928234353Sdim 929263508Sdimstatic LinkageInfo computeLVForDecl(const NamedDecl *D, 930263508Sdim LVComputationKind computation); 931263508Sdim 932249423Sdimbool NamedDecl::isLinkageValid() const { 933263508Sdim if (!hasCachedLinkage()) 934249423Sdim return true; 935218893Sdim 936263508Sdim return computeLVForDecl(this, LVForLinkageOnly).getLinkage() == 937263508Sdim getCachedLinkage(); 938249423Sdim} 939218893Sdim 940263508SdimLinkage NamedDecl::getLinkageInternal() const { 941249423Sdim // We don't care about visibility here, so ask for the cheapest 942249423Sdim // possible visibility analysis. 943263508Sdim return getLVForDecl(this, LVForLinkageOnly).getLinkage(); 944218893Sdim} 945218893Sdim 946218893SdimLinkageInfo NamedDecl::getLinkageAndVisibility() const { 947249423Sdim LVComputationKind computation = 948249423Sdim (usesTypeVisibility(this) ? LVForType : LVForValue); 949263508Sdim return getLVForDecl(this, computation); 950218893Sdim} 951218893Sdim 952263508Sdimstatic Optional<Visibility> 953263508SdimgetExplicitVisibilityAux(const NamedDecl *ND, 954263508Sdim NamedDecl::ExplicitVisibilityKind kind, 955263508Sdim bool IsMostRecent) { 956263508Sdim assert(!IsMostRecent || ND == ND->getMostRecentDecl()); 957249423Sdim 958249423Sdim // Check the declaration itself first. 959263508Sdim if (Optional<Visibility> V = getVisibilityOf(ND, kind)) 960249423Sdim return V; 961249423Sdim 962249423Sdim // If this is a member class of a specialization of a class template 963249423Sdim // and the corresponding decl has explicit visibility, use that. 964263508Sdim if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(ND)) { 965249423Sdim CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass(); 966249423Sdim if (InstantiatedFrom) 967249423Sdim return getVisibilityOf(InstantiatedFrom, kind); 968249423Sdim } 969249423Sdim 970249423Sdim // If there wasn't explicit visibility there, and this is a 971249423Sdim // specialization of a class template, check for visibility 972249423Sdim // on the pattern. 973249423Sdim if (const ClassTemplateSpecializationDecl *spec 974263508Sdim = dyn_cast<ClassTemplateSpecializationDecl>(ND)) 975249423Sdim return getVisibilityOf(spec->getSpecializedTemplate()->getTemplatedDecl(), 976249423Sdim kind); 977249423Sdim 978249423Sdim // Use the most recent declaration. 979263508Sdim if (!IsMostRecent && !isa<NamespaceDecl>(ND)) { 980263508Sdim const NamedDecl *MostRecent = ND->getMostRecentDecl(); 981263508Sdim if (MostRecent != ND) 982263508Sdim return getExplicitVisibilityAux(MostRecent, kind, true); 983263508Sdim } 984249423Sdim 985263508Sdim if (const VarDecl *Var = dyn_cast<VarDecl>(ND)) { 986239462Sdim if (Var->isStaticDataMember()) { 987239462Sdim VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember(); 988239462Sdim if (InstantiatedFrom) 989249423Sdim return getVisibilityOf(InstantiatedFrom, kind); 990239462Sdim } 991239462Sdim 992249423Sdim return None; 993239462Sdim } 994249423Sdim // Also handle function template specializations. 995263508Sdim if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND)) { 996221345Sdim // If the function is a specialization of a template with an 997221345Sdim // explicit visibility attribute, use that. 998221345Sdim if (FunctionTemplateSpecializationInfo *templateInfo 999221345Sdim = fn->getTemplateSpecializationInfo()) 1000249423Sdim return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(), 1001249423Sdim kind); 1002221345Sdim 1003234353Sdim // If the function is a member of a specialization of a class template 1004234353Sdim // and the corresponding decl has explicit visibility, use that. 1005234353Sdim FunctionDecl *InstantiatedFrom = fn->getInstantiatedFromMemberFunction(); 1006234353Sdim if (InstantiatedFrom) 1007249423Sdim return getVisibilityOf(InstantiatedFrom, kind); 1008234353Sdim 1009249423Sdim return None; 1010221345Sdim } 1011221345Sdim 1012239462Sdim // The visibility of a template is stored in the templated decl. 1013263508Sdim if (const TemplateDecl *TD = dyn_cast<TemplateDecl>(ND)) 1014249423Sdim return getVisibilityOf(TD->getTemplatedDecl(), kind); 1015239462Sdim 1016249423Sdim return None; 1017249423Sdim} 1018221345Sdim 1019263508SdimOptional<Visibility> 1020263508SdimNamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const { 1021263508Sdim return getExplicitVisibilityAux(this, kind, false); 1022263508Sdim} 1023263508Sdim 1024263508Sdimstatic LinkageInfo getLVForClosure(const DeclContext *DC, Decl *ContextDecl, 1025263508Sdim LVComputationKind computation) { 1026263508Sdim // This lambda has its linkage/visibility determined by its owner. 1027263508Sdim if (ContextDecl) { 1028263508Sdim if (isa<ParmVarDecl>(ContextDecl)) 1029263508Sdim DC = ContextDecl->getDeclContext()->getRedeclContext(); 1030263508Sdim else 1031263508Sdim return getLVForDecl(cast<NamedDecl>(ContextDecl), computation); 1032263508Sdim } 1033263508Sdim 1034263508Sdim if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC)) 1035263508Sdim return getLVForDecl(ND, computation); 1036263508Sdim 1037263508Sdim return LinkageInfo::external(); 1038263508Sdim} 1039263508Sdim 1040249423Sdimstatic LinkageInfo getLVForLocalDecl(const NamedDecl *D, 1041249423Sdim LVComputationKind computation) { 1042249423Sdim if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 1043249423Sdim if (Function->isInAnonymousNamespace() && 1044251662Sdim !Function->isInExternCContext()) 1045249423Sdim return LinkageInfo::uniqueExternal(); 1046249423Sdim 1047249423Sdim // This is a "void f();" which got merged with a file static. 1048249423Sdim if (Function->getCanonicalDecl()->getStorageClass() == SC_Static) 1049249423Sdim return LinkageInfo::internal(); 1050249423Sdim 1051249423Sdim LinkageInfo LV; 1052249423Sdim if (!hasExplicitVisibilityAlready(computation)) { 1053249423Sdim if (Optional<Visibility> Vis = 1054249423Sdim getExplicitVisibility(Function, computation)) 1055249423Sdim LV.mergeVisibility(*Vis, true); 1056249423Sdim } 1057249423Sdim 1058249423Sdim // Note that Sema::MergeCompatibleFunctionDecls already takes care of 1059249423Sdim // merging storage classes and visibility attributes, so we don't have to 1060249423Sdim // look at previous decls in here. 1061249423Sdim 1062249423Sdim return LV; 1063234353Sdim } 1064234353Sdim 1065249423Sdim if (const VarDecl *Var = dyn_cast<VarDecl>(D)) { 1066249423Sdim if (Var->hasExternalStorage()) { 1067251662Sdim if (Var->isInAnonymousNamespace() && !Var->isInExternCContext()) 1068249423Sdim return LinkageInfo::uniqueExternal(); 1069249423Sdim 1070249423Sdim LinkageInfo LV; 1071249423Sdim if (Var->getStorageClass() == SC_PrivateExtern) 1072249423Sdim LV.mergeVisibility(HiddenVisibility, true); 1073249423Sdim else if (!hasExplicitVisibilityAlready(computation)) { 1074249423Sdim if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation)) 1075249423Sdim LV.mergeVisibility(*Vis, true); 1076249423Sdim } 1077249423Sdim 1078249423Sdim if (const VarDecl *Prev = Var->getPreviousDecl()) { 1079249423Sdim LinkageInfo PrevLV = getLVForDecl(Prev, computation); 1080249423Sdim if (PrevLV.getLinkage()) 1081249423Sdim LV.setLinkage(PrevLV.getLinkage()); 1082249423Sdim LV.mergeVisibility(PrevLV); 1083249423Sdim } 1084249423Sdim 1085249423Sdim return LV; 1086249423Sdim } 1087263508Sdim 1088263508Sdim if (!Var->isStaticLocal()) 1089263508Sdim return LinkageInfo::none(); 1090249423Sdim } 1091249423Sdim 1092263508Sdim ASTContext &Context = D->getASTContext(); 1093263508Sdim if (!Context.getLangOpts().CPlusPlus) 1094263508Sdim return LinkageInfo::none(); 1095263508Sdim 1096263508Sdim const Decl *OuterD = getOutermostFuncOrBlockContext(D); 1097263508Sdim if (!OuterD) 1098263508Sdim return LinkageInfo::none(); 1099263508Sdim 1100263508Sdim LinkageInfo LV; 1101263508Sdim if (const BlockDecl *BD = dyn_cast<BlockDecl>(OuterD)) { 1102263508Sdim if (!BD->getBlockManglingNumber()) 1103263508Sdim return LinkageInfo::none(); 1104263508Sdim 1105263508Sdim LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(), 1106263508Sdim BD->getBlockManglingContextDecl(), computation); 1107263508Sdim } else { 1108263508Sdim const FunctionDecl *FD = cast<FunctionDecl>(OuterD); 1109263508Sdim if (!FD->isInlined() && 1110263508Sdim FD->getTemplateSpecializationKind() == TSK_Undeclared) 1111263508Sdim return LinkageInfo::none(); 1112263508Sdim 1113263508Sdim LV = getLVForDecl(FD, computation); 1114263508Sdim } 1115263508Sdim if (!isExternallyVisible(LV.getLinkage())) 1116263508Sdim return LinkageInfo::none(); 1117263508Sdim return LinkageInfo(VisibleNoLinkage, LV.getVisibility(), 1118263508Sdim LV.isVisibilityExplicit()); 1119221345Sdim} 1120221345Sdim 1121263508Sdimstatic inline const CXXRecordDecl* 1122263508SdimgetOutermostEnclosingLambda(const CXXRecordDecl *Record) { 1123263508Sdim const CXXRecordDecl *Ret = Record; 1124263508Sdim while (Record && Record->isLambda()) { 1125263508Sdim Ret = Record; 1126263508Sdim if (!Record->getParent()) break; 1127263508Sdim // Get the Containing Class of this Lambda Class 1128263508Sdim Record = dyn_cast_or_null<CXXRecordDecl>( 1129263508Sdim Record->getParent()->getParent()); 1130263508Sdim } 1131263508Sdim return Ret; 1132263508Sdim} 1133263508Sdim 1134263508Sdimstatic LinkageInfo computeLVForDecl(const NamedDecl *D, 1135263508Sdim LVComputationKind computation) { 1136207619Srdivacky // Objective-C: treat all Objective-C declarations as having external 1137207619Srdivacky // linkage. 1138218893Sdim switch (D->getKind()) { 1139207619Srdivacky default: 1140207619Srdivacky break; 1141234353Sdim case Decl::ParmVar: 1142234353Sdim return LinkageInfo::none(); 1143218893Sdim case Decl::TemplateTemplateParm: // count these as external 1144218893Sdim case Decl::NonTypeTemplateParm: 1145207619Srdivacky case Decl::ObjCAtDefsField: 1146207619Srdivacky case Decl::ObjCCategory: 1147207619Srdivacky case Decl::ObjCCategoryImpl: 1148207619Srdivacky case Decl::ObjCCompatibleAlias: 1149207619Srdivacky case Decl::ObjCImplementation: 1150207619Srdivacky case Decl::ObjCMethod: 1151207619Srdivacky case Decl::ObjCProperty: 1152207619Srdivacky case Decl::ObjCPropertyImpl: 1153207619Srdivacky case Decl::ObjCProtocol: 1154218893Sdim return LinkageInfo::external(); 1155234353Sdim 1156234353Sdim case Decl::CXXRecord: { 1157234353Sdim const CXXRecordDecl *Record = cast<CXXRecordDecl>(D); 1158234353Sdim if (Record->isLambda()) { 1159234353Sdim if (!Record->getLambdaManglingNumber()) { 1160234353Sdim // This lambda has no mangling number, so it's internal. 1161234353Sdim return LinkageInfo::internal(); 1162234353Sdim } 1163234353Sdim 1164263508Sdim // This lambda has its linkage/visibility determined: 1165263508Sdim // - either by the outermost lambda if that lambda has no mangling 1166263508Sdim // number. 1167263508Sdim // - or by the parent of the outer most lambda 1168263508Sdim // This prevents infinite recursion in settings such as nested lambdas 1169263508Sdim // used in NSDMI's, for e.g. 1170263508Sdim // struct L { 1171263508Sdim // int t{}; 1172263508Sdim // int t2 = ([](int a) { return [](int b) { return b; };})(t)(t); 1173263508Sdim // }; 1174263508Sdim const CXXRecordDecl *OuterMostLambda = 1175263508Sdim getOutermostEnclosingLambda(Record); 1176263508Sdim if (!OuterMostLambda->getLambdaManglingNumber()) 1177263508Sdim return LinkageInfo::internal(); 1178234353Sdim 1179263508Sdim return getLVForClosure( 1180263508Sdim OuterMostLambda->getDeclContext()->getRedeclContext(), 1181263508Sdim OuterMostLambda->getLambdaContextDecl(), computation); 1182234353Sdim } 1183234353Sdim 1184234353Sdim break; 1185234353Sdim } 1186207619Srdivacky } 1187207619Srdivacky 1188199990Srdivacky // Handle linkage for namespace-scope names. 1189218893Sdim if (D->getDeclContext()->getRedeclContext()->isFileContext()) 1190249423Sdim return getLVForNamespaceScopeDecl(D, computation); 1191199990Srdivacky 1192199990Srdivacky // C++ [basic.link]p5: 1193199990Srdivacky // In addition, a member function, static data member, a named 1194199990Srdivacky // class or enumeration of class scope, or an unnamed class or 1195199990Srdivacky // enumeration defined in a class-scope typedef declaration such 1196199990Srdivacky // that the class or enumeration has the typedef name for linkage 1197199990Srdivacky // purposes (7.1.3), has external linkage if the name of the class 1198199990Srdivacky // has external linkage. 1199218893Sdim if (D->getDeclContext()->isRecord()) 1200249423Sdim return getLVForClassMember(D, computation); 1201199990Srdivacky 1202199990Srdivacky // C++ [basic.link]p6: 1203199990Srdivacky // The name of a function declared in block scope and the name of 1204199990Srdivacky // an object declared by a block scope extern declaration have 1205199990Srdivacky // linkage. If there is a visible declaration of an entity with 1206199990Srdivacky // linkage having the same name and type, ignoring entities 1207199990Srdivacky // declared outside the innermost enclosing namespace scope, the 1208199990Srdivacky // block scope declaration declares that same entity and receives 1209199990Srdivacky // the linkage of the previous declaration. If there is more than 1210199990Srdivacky // one such matching entity, the program is ill-formed. Otherwise, 1211199990Srdivacky // if no matching entity is found, the block scope entity receives 1212199990Srdivacky // external linkage. 1213249423Sdim if (D->getDeclContext()->isFunctionOrMethod()) 1214249423Sdim return getLVForLocalDecl(D, computation); 1215203955Srdivacky 1216199990Srdivacky // C++ [basic.link]p6: 1217199990Srdivacky // Names not covered by these rules have no linkage. 1218218893Sdim return LinkageInfo::none(); 1219218893Sdim} 1220199990Srdivacky 1221263508Sdimnamespace clang { 1222263508Sdimclass LinkageComputer { 1223263508Sdimpublic: 1224263508Sdim static LinkageInfo getLVForDecl(const NamedDecl *D, 1225263508Sdim LVComputationKind computation) { 1226263508Sdim if (computation == LVForLinkageOnly && D->hasCachedLinkage()) 1227263508Sdim return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false); 1228263508Sdim 1229263508Sdim LinkageInfo LV = computeLVForDecl(D, computation); 1230263508Sdim if (D->hasCachedLinkage()) 1231263508Sdim assert(D->getCachedLinkage() == LV.getLinkage()); 1232263508Sdim 1233263508Sdim D->setCachedLinkage(LV.getLinkage()); 1234263508Sdim 1235263508Sdim#ifndef NDEBUG 1236263508Sdim // In C (because of gnu inline) and in c++ with microsoft extensions an 1237263508Sdim // static can follow an extern, so we can have two decls with different 1238263508Sdim // linkages. 1239263508Sdim const LangOptions &Opts = D->getASTContext().getLangOpts(); 1240263508Sdim if (!Opts.CPlusPlus || Opts.MicrosoftExt) 1241263508Sdim return LV; 1242263508Sdim 1243263508Sdim // We have just computed the linkage for this decl. By induction we know 1244263508Sdim // that all other computed linkages match, check that the one we just 1245263508Sdim // computed 1246263508Sdim // also does. 1247263508Sdim NamedDecl *Old = NULL; 1248263508Sdim for (NamedDecl::redecl_iterator I = D->redecls_begin(), 1249263508Sdim E = D->redecls_end(); 1250263508Sdim I != E; ++I) { 1251263508Sdim NamedDecl *T = cast<NamedDecl>(*I); 1252263508Sdim if (T == D) 1253263508Sdim continue; 1254263508Sdim if (T->hasCachedLinkage()) { 1255263508Sdim Old = T; 1256263508Sdim break; 1257263508Sdim } 1258263508Sdim } 1259263508Sdim assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage()); 1260263508Sdim#endif 1261263508Sdim 1262263508Sdim return LV; 1263263508Sdim } 1264263508Sdim}; 1265263508Sdim} 1266263508Sdim 1267263508Sdimstatic LinkageInfo getLVForDecl(const NamedDecl *D, 1268263508Sdim LVComputationKind computation) { 1269263508Sdim return clang::LinkageComputer::getLVForDecl(D, computation); 1270263508Sdim} 1271263508Sdim 1272193326Sedstd::string NamedDecl::getQualifiedNameAsString() const { 1273234353Sdim return getQualifiedNameAsString(getASTContext().getPrintingPolicy()); 1274198092Srdivacky} 1275198092Srdivacky 1276198092Srdivackystd::string NamedDecl::getQualifiedNameAsString(const PrintingPolicy &P) const { 1277249423Sdim std::string QualName; 1278249423Sdim llvm::raw_string_ostream OS(QualName); 1279249423Sdim printQualifiedName(OS, P); 1280249423Sdim return OS.str(); 1281249423Sdim} 1282249423Sdim 1283249423Sdimvoid NamedDecl::printQualifiedName(raw_ostream &OS) const { 1284249423Sdim printQualifiedName(OS, getASTContext().getPrintingPolicy()); 1285249423Sdim} 1286249423Sdim 1287249423Sdimvoid NamedDecl::printQualifiedName(raw_ostream &OS, 1288249423Sdim const PrintingPolicy &P) const { 1289193326Sed const DeclContext *Ctx = getDeclContext(); 1290193326Sed 1291249423Sdim if (Ctx->isFunctionOrMethod()) { 1292249423Sdim printName(OS); 1293249423Sdim return; 1294249423Sdim } 1295193326Sed 1296226633Sdim typedef SmallVector<const DeclContext *, 8> ContextsTy; 1297207619Srdivacky ContextsTy Contexts; 1298207619Srdivacky 1299207619Srdivacky // Collect contexts. 1300207619Srdivacky while (Ctx && isa<NamedDecl>(Ctx)) { 1301207619Srdivacky Contexts.push_back(Ctx); 1302207619Srdivacky Ctx = Ctx->getParent(); 1303249423Sdim } 1304207619Srdivacky 1305207619Srdivacky for (ContextsTy::reverse_iterator I = Contexts.rbegin(), E = Contexts.rend(); 1306207619Srdivacky I != E; ++I) { 1307198092Srdivacky if (const ClassTemplateSpecializationDecl *Spec 1308207619Srdivacky = dyn_cast<ClassTemplateSpecializationDecl>(*I)) { 1309249423Sdim OS << Spec->getName(); 1310193326Sed const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1311249423Sdim TemplateSpecializationType::PrintTemplateArgumentList(OS, 1312249423Sdim TemplateArgs.data(), 1313249423Sdim TemplateArgs.size(), 1314249423Sdim P); 1315207619Srdivacky } else if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(*I)) { 1316201361Srdivacky if (ND->isAnonymousNamespace()) 1317207619Srdivacky OS << "<anonymous namespace>"; 1318201361Srdivacky else 1319226633Sdim OS << *ND; 1320207619Srdivacky } else if (const RecordDecl *RD = dyn_cast<RecordDecl>(*I)) { 1321207619Srdivacky if (!RD->getIdentifier()) 1322207619Srdivacky OS << "<anonymous " << RD->getKindName() << '>'; 1323207619Srdivacky else 1324226633Sdim OS << *RD; 1325207619Srdivacky } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { 1326201361Srdivacky const FunctionProtoType *FT = 0; 1327201361Srdivacky if (FD->hasWrittenPrototype()) 1328243830Sdim FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>()); 1329201361Srdivacky 1330226633Sdim OS << *FD << '('; 1331201361Srdivacky if (FT) { 1332201361Srdivacky unsigned NumParams = FD->getNumParams(); 1333201361Srdivacky for (unsigned i = 0; i < NumParams; ++i) { 1334201361Srdivacky if (i) 1335207619Srdivacky OS << ", "; 1336239462Sdim OS << FD->getParamDecl(i)->getType().stream(P); 1337201361Srdivacky } 1338201361Srdivacky 1339201361Srdivacky if (FT->isVariadic()) { 1340201361Srdivacky if (NumParams > 0) 1341207619Srdivacky OS << ", "; 1342207619Srdivacky OS << "..."; 1343201361Srdivacky } 1344201361Srdivacky } 1345207619Srdivacky OS << ')'; 1346207619Srdivacky } else { 1347226633Sdim OS << *cast<NamedDecl>(*I); 1348207619Srdivacky } 1349207619Srdivacky OS << "::"; 1350193326Sed } 1351193326Sed 1352205408Srdivacky if (getDeclName()) 1353226633Sdim OS << *this; 1354205408Srdivacky else 1355207619Srdivacky OS << "<anonymous>"; 1356249423Sdim} 1357193326Sed 1358249423Sdimvoid NamedDecl::getNameForDiagnostic(raw_ostream &OS, 1359249423Sdim const PrintingPolicy &Policy, 1360249423Sdim bool Qualified) const { 1361249423Sdim if (Qualified) 1362249423Sdim printQualifiedName(OS, Policy); 1363249423Sdim else 1364249423Sdim printName(OS); 1365193326Sed} 1366193326Sed 1367193326Sedbool NamedDecl::declarationReplaces(NamedDecl *OldD) const { 1368193326Sed assert(getDeclName() == OldD->getDeclName() && "Declaration name mismatch"); 1369193326Sed 1370193326Sed // UsingDirectiveDecl's are not really NamedDecl's, and all have same name. 1371193326Sed // We want to keep it, unless it nominates same namespace. 1372193326Sed if (getKind() == Decl::UsingDirective) { 1373219077Sdim return cast<UsingDirectiveDecl>(this)->getNominatedNamespace() 1374219077Sdim ->getOriginalNamespace() == 1375219077Sdim cast<UsingDirectiveDecl>(OldD)->getNominatedNamespace() 1376219077Sdim ->getOriginalNamespace(); 1377193326Sed } 1378198092Srdivacky 1379193326Sed if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) 1380193326Sed // For function declarations, we keep track of redeclarations. 1381234353Sdim return FD->getPreviousDecl() == OldD; 1382193326Sed 1383195099Sed // For function templates, the underlying function declarations are linked. 1384195099Sed if (const FunctionTemplateDecl *FunctionTemplate 1385195099Sed = dyn_cast<FunctionTemplateDecl>(this)) 1386195099Sed if (const FunctionTemplateDecl *OldFunctionTemplate 1387195099Sed = dyn_cast<FunctionTemplateDecl>(OldD)) 1388195099Sed return FunctionTemplate->getTemplatedDecl() 1389195099Sed ->declarationReplaces(OldFunctionTemplate->getTemplatedDecl()); 1390198092Srdivacky 1391193326Sed // For method declarations, we keep track of redeclarations. 1392193326Sed if (isa<ObjCMethodDecl>(this)) 1393193326Sed return false; 1394198092Srdivacky 1395198092Srdivacky if (isa<ObjCInterfaceDecl>(this) && isa<ObjCCompatibleAliasDecl>(OldD)) 1396198092Srdivacky return true; 1397198092Srdivacky 1398199482Srdivacky if (isa<UsingShadowDecl>(this) && isa<UsingShadowDecl>(OldD)) 1399199482Srdivacky return cast<UsingShadowDecl>(this)->getTargetDecl() == 1400199482Srdivacky cast<UsingShadowDecl>(OldD)->getTargetDecl(); 1401199482Srdivacky 1402219077Sdim if (isa<UsingDecl>(this) && isa<UsingDecl>(OldD)) { 1403219077Sdim ASTContext &Context = getASTContext(); 1404219077Sdim return Context.getCanonicalNestedNameSpecifier( 1405219077Sdim cast<UsingDecl>(this)->getQualifier()) == 1406219077Sdim Context.getCanonicalNestedNameSpecifier( 1407219077Sdim cast<UsingDecl>(OldD)->getQualifier()); 1408219077Sdim } 1409218893Sdim 1410263508Sdim if (isa<UnresolvedUsingValueDecl>(this) && 1411263508Sdim isa<UnresolvedUsingValueDecl>(OldD)) { 1412263508Sdim ASTContext &Context = getASTContext(); 1413263508Sdim return Context.getCanonicalNestedNameSpecifier( 1414263508Sdim cast<UnresolvedUsingValueDecl>(this)->getQualifier()) == 1415263508Sdim Context.getCanonicalNestedNameSpecifier( 1416263508Sdim cast<UnresolvedUsingValueDecl>(OldD)->getQualifier()); 1417263508Sdim } 1418263508Sdim 1419234353Sdim // A typedef of an Objective-C class type can replace an Objective-C class 1420234353Sdim // declaration or definition, and vice versa. 1421234353Sdim if ((isa<TypedefNameDecl>(this) && isa<ObjCInterfaceDecl>(OldD)) || 1422234353Sdim (isa<ObjCInterfaceDecl>(this) && isa<TypedefNameDecl>(OldD))) 1423234353Sdim return true; 1424234353Sdim 1425193326Sed // For non-function declarations, if the declarations are of the 1426193326Sed // same kind then this must be a redeclaration, or semantic analysis 1427193326Sed // would not have given us the new declaration. 1428193326Sed return this->getKind() == OldD->getKind(); 1429193326Sed} 1430193326Sed 1431193326Sedbool NamedDecl::hasLinkage() const { 1432263508Sdim return getFormalLinkage() != NoLinkage; 1433193326Sed} 1434193326Sed 1435234353SdimNamedDecl *NamedDecl::getUnderlyingDeclImpl() { 1436195099Sed NamedDecl *ND = this; 1437234353Sdim while (UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(ND)) 1438234353Sdim ND = UD->getTargetDecl(); 1439234353Sdim 1440234353Sdim if (ObjCCompatibleAliasDecl *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND)) 1441234353Sdim return AD->getClassInterface(); 1442234353Sdim 1443234353Sdim return ND; 1444195099Sed} 1445195099Sed 1446207619Srdivackybool NamedDecl::isCXXInstanceMember() const { 1447234353Sdim if (!isCXXClassMember()) 1448234353Sdim return false; 1449234353Sdim 1450207619Srdivacky const NamedDecl *D = this; 1451207619Srdivacky if (isa<UsingShadowDecl>(D)) 1452207619Srdivacky D = cast<UsingShadowDecl>(D)->getTargetDecl(); 1453207619Srdivacky 1454251662Sdim if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D)) 1455207619Srdivacky return true; 1456207619Srdivacky if (isa<CXXMethodDecl>(D)) 1457207619Srdivacky return cast<CXXMethodDecl>(D)->isInstance(); 1458207619Srdivacky if (isa<FunctionTemplateDecl>(D)) 1459207619Srdivacky return cast<CXXMethodDecl>(cast<FunctionTemplateDecl>(D) 1460207619Srdivacky ->getTemplatedDecl())->isInstance(); 1461207619Srdivacky return false; 1462207619Srdivacky} 1463207619Srdivacky 1464193326Sed//===----------------------------------------------------------------------===// 1465198092Srdivacky// DeclaratorDecl Implementation 1466198092Srdivacky//===----------------------------------------------------------------------===// 1467198092Srdivacky 1468210299Sedtemplate <typename DeclT> 1469210299Sedstatic SourceLocation getTemplateOrInnerLocStart(const DeclT *decl) { 1470210299Sed if (decl->getNumTemplateParameterLists() > 0) 1471210299Sed return decl->getTemplateParameterList(0)->getTemplateLoc(); 1472210299Sed else 1473210299Sed return decl->getInnerLocStart(); 1474210299Sed} 1475210299Sed 1476198092SrdivackySourceLocation DeclaratorDecl::getTypeSpecStartLoc() const { 1477210299Sed TypeSourceInfo *TSI = getTypeSourceInfo(); 1478210299Sed if (TSI) return TSI->getTypeLoc().getBeginLoc(); 1479198092Srdivacky return SourceLocation(); 1480198092Srdivacky} 1481198092Srdivacky 1482219077Sdimvoid DeclaratorDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) { 1483219077Sdim if (QualifierLoc) { 1484205219Srdivacky // Make sure the extended decl info is allocated. 1485205219Srdivacky if (!hasExtInfo()) { 1486205219Srdivacky // Save (non-extended) type source info pointer. 1487205219Srdivacky TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>(); 1488205219Srdivacky // Allocate external info struct. 1489205219Srdivacky DeclInfo = new (getASTContext()) ExtInfo; 1490205219Srdivacky // Restore savedTInfo into (extended) decl info. 1491205219Srdivacky getExtInfo()->TInfo = savedTInfo; 1492205219Srdivacky } 1493205219Srdivacky // Set qualifier info. 1494219077Sdim getExtInfo()->QualifierLoc = QualifierLoc; 1495226633Sdim } else { 1496205219Srdivacky // Here Qualifier == 0, i.e., we are removing the qualifier (if any). 1497205219Srdivacky if (hasExtInfo()) { 1498221345Sdim if (getExtInfo()->NumTemplParamLists == 0) { 1499221345Sdim // Save type source info pointer. 1500221345Sdim TypeSourceInfo *savedTInfo = getExtInfo()->TInfo; 1501221345Sdim // Deallocate the extended decl info. 1502221345Sdim getASTContext().Deallocate(getExtInfo()); 1503221345Sdim // Restore savedTInfo into (non-extended) decl info. 1504221345Sdim DeclInfo = savedTInfo; 1505221345Sdim } 1506221345Sdim else 1507221345Sdim getExtInfo()->QualifierLoc = QualifierLoc; 1508205219Srdivacky } 1509205219Srdivacky } 1510205219Srdivacky} 1511205219Srdivacky 1512221345Sdimvoid 1513221345SdimDeclaratorDecl::setTemplateParameterListsInfo(ASTContext &Context, 1514221345Sdim unsigned NumTPLists, 1515221345Sdim TemplateParameterList **TPLists) { 1516221345Sdim assert(NumTPLists > 0); 1517221345Sdim // Make sure the extended decl info is allocated. 1518221345Sdim if (!hasExtInfo()) { 1519221345Sdim // Save (non-extended) type source info pointer. 1520221345Sdim TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>(); 1521221345Sdim // Allocate external info struct. 1522221345Sdim DeclInfo = new (getASTContext()) ExtInfo; 1523221345Sdim // Restore savedTInfo into (extended) decl info. 1524221345Sdim getExtInfo()->TInfo = savedTInfo; 1525221345Sdim } 1526221345Sdim // Set the template parameter lists info. 1527221345Sdim getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists); 1528221345Sdim} 1529221345Sdim 1530210299SedSourceLocation DeclaratorDecl::getOuterLocStart() const { 1531210299Sed return getTemplateOrInnerLocStart(this); 1532210299Sed} 1533210299Sed 1534221345Sdimnamespace { 1535221345Sdim 1536221345Sdim// Helper function: returns true if QT is or contains a type 1537221345Sdim// having a postfix component. 1538221345Sdimbool typeIsPostfix(clang::QualType QT) { 1539221345Sdim while (true) { 1540221345Sdim const Type* T = QT.getTypePtr(); 1541221345Sdim switch (T->getTypeClass()) { 1542221345Sdim default: 1543221345Sdim return false; 1544221345Sdim case Type::Pointer: 1545221345Sdim QT = cast<PointerType>(T)->getPointeeType(); 1546221345Sdim break; 1547221345Sdim case Type::BlockPointer: 1548221345Sdim QT = cast<BlockPointerType>(T)->getPointeeType(); 1549221345Sdim break; 1550221345Sdim case Type::MemberPointer: 1551221345Sdim QT = cast<MemberPointerType>(T)->getPointeeType(); 1552221345Sdim break; 1553221345Sdim case Type::LValueReference: 1554221345Sdim case Type::RValueReference: 1555221345Sdim QT = cast<ReferenceType>(T)->getPointeeType(); 1556221345Sdim break; 1557221345Sdim case Type::PackExpansion: 1558221345Sdim QT = cast<PackExpansionType>(T)->getPattern(); 1559221345Sdim break; 1560221345Sdim case Type::Paren: 1561221345Sdim case Type::ConstantArray: 1562221345Sdim case Type::DependentSizedArray: 1563221345Sdim case Type::IncompleteArray: 1564221345Sdim case Type::VariableArray: 1565221345Sdim case Type::FunctionProto: 1566221345Sdim case Type::FunctionNoProto: 1567221345Sdim return true; 1568221345Sdim } 1569221345Sdim } 1570221345Sdim} 1571221345Sdim 1572221345Sdim} // namespace 1573221345Sdim 1574221345SdimSourceRange DeclaratorDecl::getSourceRange() const { 1575221345Sdim SourceLocation RangeEnd = getLocation(); 1576221345Sdim if (TypeSourceInfo *TInfo = getTypeSourceInfo()) { 1577221345Sdim if (typeIsPostfix(TInfo->getType())) 1578221345Sdim RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd(); 1579221345Sdim } 1580221345Sdim return SourceRange(getOuterLocStart(), RangeEnd); 1581221345Sdim} 1582221345Sdim 1583210299Sedvoid 1584210299SedQualifierInfo::setTemplateParameterListsInfo(ASTContext &Context, 1585210299Sed unsigned NumTPLists, 1586210299Sed TemplateParameterList **TPLists) { 1587210299Sed assert((NumTPLists == 0 || TPLists != 0) && 1588210299Sed "Empty array of template parameters with positive size!"); 1589210299Sed 1590210299Sed // Free previous template parameters (if any). 1591210299Sed if (NumTemplParamLists > 0) { 1592210299Sed Context.Deallocate(TemplParamLists); 1593210299Sed TemplParamLists = 0; 1594210299Sed NumTemplParamLists = 0; 1595210299Sed } 1596210299Sed // Set info on matched template parameter lists (if any). 1597210299Sed if (NumTPLists > 0) { 1598210299Sed TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 1599210299Sed NumTemplParamLists = NumTPLists; 1600210299Sed for (unsigned i = NumTPLists; i-- > 0; ) 1601210299Sed TemplParamLists[i] = TPLists[i]; 1602210299Sed } 1603210299Sed} 1604210299Sed 1605198092Srdivacky//===----------------------------------------------------------------------===// 1606193326Sed// VarDecl Implementation 1607193326Sed//===----------------------------------------------------------------------===// 1608193326Sed 1609203955Srdivackyconst char *VarDecl::getStorageClassSpecifierString(StorageClass SC) { 1610203955Srdivacky switch (SC) { 1611226633Sdim case SC_None: break; 1612226633Sdim case SC_Auto: return "auto"; 1613226633Sdim case SC_Extern: return "extern"; 1614226633Sdim case SC_OpenCLWorkGroupLocal: return "<<work-group-local>>"; 1615226633Sdim case SC_PrivateExtern: return "__private_extern__"; 1616226633Sdim case SC_Register: return "register"; 1617226633Sdim case SC_Static: return "static"; 1618203955Srdivacky } 1619203955Srdivacky 1620226633Sdim llvm_unreachable("Invalid storage class"); 1621203955Srdivacky} 1622203955Srdivacky 1623263508SdimVarDecl::VarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc, 1624263508Sdim SourceLocation IdLoc, IdentifierInfo *Id, QualType T, 1625263508Sdim TypeSourceInfo *TInfo, StorageClass SC) 1626263508Sdim : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc), Init() { 1627263508Sdim assert(sizeof(VarDeclBitfields) <= sizeof(unsigned)); 1628263508Sdim assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned)); 1629263508Sdim AllBits = 0; 1630263508Sdim VarDeclBits.SClass = SC; 1631263508Sdim // Everything else is implicitly initialized to false. 1632263508Sdim} 1633263508Sdim 1634221345SdimVarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC, 1635221345Sdim SourceLocation StartL, SourceLocation IdL, 1636200583Srdivacky IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, 1637249423Sdim StorageClass S) { 1638249423Sdim return new (C) VarDecl(Var, DC, StartL, IdL, Id, T, TInfo, S); 1639193326Sed} 1640193326Sed 1641234353SdimVarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 1642234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(VarDecl)); 1643234353Sdim return new (Mem) VarDecl(Var, 0, SourceLocation(), SourceLocation(), 0, 1644249423Sdim QualType(), 0, SC_None); 1645234353Sdim} 1646234353Sdim 1647218893Sdimvoid VarDecl::setStorageClass(StorageClass SC) { 1648218893Sdim assert(isLegalForVariable(SC)); 1649221345Sdim VarDeclBits.SClass = SC; 1650218893Sdim} 1651218893Sdim 1652210299SedSourceRange VarDecl::getSourceRange() const { 1653243830Sdim if (const Expr *Init = getInit()) { 1654243830Sdim SourceLocation InitEnd = Init->getLocEnd(); 1655249423Sdim // If Init is implicit, ignore its source range and fallback on 1656249423Sdim // DeclaratorDecl::getSourceRange() to handle postfix elements. 1657249423Sdim if (InitEnd.isValid() && InitEnd != getLocation()) 1658243830Sdim return SourceRange(getOuterLocStart(), InitEnd); 1659243830Sdim } 1660221345Sdim return DeclaratorDecl::getSourceRange(); 1661194613Sed} 1662194613Sed 1663249423Sdimtemplate<typename T> 1664249423Sdimstatic LanguageLinkage getLanguageLinkageTemplate(const T &D) { 1665249423Sdim // C++ [dcl.link]p1: All function types, function names with external linkage, 1666249423Sdim // and variable names with external linkage have a language linkage. 1667263508Sdim if (!D.hasExternalFormalLinkage()) 1668249423Sdim return NoLanguageLinkage; 1669203955Srdivacky 1670249423Sdim // Language linkage is a C++ concept, but saying that everything else in C has 1671249423Sdim // C language linkage fits the implementation nicely. 1672249423Sdim ASTContext &Context = D.getASTContext(); 1673249423Sdim if (!Context.getLangOpts().CPlusPlus) 1674249423Sdim return CLanguageLinkage; 1675249423Sdim 1676249423Sdim // C++ [dcl.link]p4: A C language linkage is ignored in determining the 1677249423Sdim // language linkage of the names of class members and the function type of 1678249423Sdim // class member functions. 1679249423Sdim const DeclContext *DC = D.getDeclContext(); 1680234353Sdim if (DC->isRecord()) 1681249423Sdim return CXXLanguageLinkage; 1682249423Sdim 1683249423Sdim // If the first decl is in an extern "C" context, any other redeclaration 1684249423Sdim // will have C language linkage. If the first one is not in an extern "C" 1685249423Sdim // context, we would have reported an error for any other decl being in one. 1686251662Sdim if (isFirstInExternCContext(&D)) 1687249423Sdim return CLanguageLinkage; 1688249423Sdim return CXXLanguageLinkage; 1689249423Sdim} 1690249423Sdim 1691249423Sdimtemplate<typename T> 1692249423Sdimstatic bool isExternCTemplate(const T &D) { 1693249423Sdim // Since the context is ignored for class members, they can only have C++ 1694249423Sdim // language linkage or no language linkage. 1695249423Sdim const DeclContext *DC = D.getDeclContext(); 1696249423Sdim if (DC->isRecord()) { 1697249423Sdim assert(D.getASTContext().getLangOpts().CPlusPlus); 1698219077Sdim return false; 1699249423Sdim } 1700219077Sdim 1701249423Sdim return D.getLanguageLinkage() == CLanguageLinkage; 1702203955Srdivacky} 1703203955Srdivacky 1704249423SdimLanguageLinkage VarDecl::getLanguageLinkage() const { 1705249423Sdim return getLanguageLinkageTemplate(*this); 1706249423Sdim} 1707249423Sdim 1708249423Sdimbool VarDecl::isExternC() const { 1709249423Sdim return isExternCTemplate(*this); 1710249423Sdim} 1711249423Sdim 1712251662Sdimbool VarDecl::isInExternCContext() const { 1713263508Sdim return getLexicalDeclContext()->isExternCContext(); 1714251662Sdim} 1715251662Sdim 1716251662Sdimbool VarDecl::isInExternCXXContext() const { 1717263508Sdim return getLexicalDeclContext()->isExternCXXContext(); 1718251662Sdim} 1719251662Sdim 1720263508SdimVarDecl *VarDecl::getCanonicalDecl() { return getFirstDecl(); } 1721203955Srdivacky 1722234353SdimVarDecl::DefinitionKind VarDecl::isThisDeclarationADefinition( 1723234353Sdim ASTContext &C) const 1724234353Sdim{ 1725203955Srdivacky // C++ [basic.def]p2: 1726203955Srdivacky // A declaration is a definition unless [...] it contains the 'extern' 1727203955Srdivacky // specifier or a linkage-specification and neither an initializer [...], 1728203955Srdivacky // it declares a static data member in a class declaration [...]. 1729263508Sdim // C++1y [temp.expl.spec]p15: 1730263508Sdim // An explicit specialization of a static data member or an explicit 1731263508Sdim // specialization of a static data member template is a definition if the 1732263508Sdim // declaration includes an initializer; otherwise, it is a declaration. 1733263508Sdim // 1734263508Sdim // FIXME: How do you declare (but not define) a partial specialization of 1735263508Sdim // a static data member template outside the containing class? 1736203955Srdivacky if (isStaticDataMember()) { 1737263508Sdim if (isOutOfLine() && 1738263508Sdim (hasInit() || 1739263508Sdim // If the first declaration is out-of-line, this may be an 1740263508Sdim // instantiation of an out-of-line partial specialization of a variable 1741263508Sdim // template for which we have not yet instantiated the initializer. 1742263508Sdim (getFirstDecl()->isOutOfLine() 1743263508Sdim ? getTemplateSpecializationKind() == TSK_Undeclared 1744263508Sdim : getTemplateSpecializationKind() != 1745263508Sdim TSK_ExplicitSpecialization) || 1746263508Sdim isa<VarTemplatePartialSpecializationDecl>(this))) 1747203955Srdivacky return Definition; 1748203955Srdivacky else 1749203955Srdivacky return DeclarationOnly; 1750203955Srdivacky } 1751203955Srdivacky // C99 6.7p5: 1752203955Srdivacky // A definition of an identifier is a declaration for that identifier that 1753203955Srdivacky // [...] causes storage to be reserved for that object. 1754203955Srdivacky // Note: that applies for all non-file-scope objects. 1755203955Srdivacky // C99 6.9.2p1: 1756203955Srdivacky // If the declaration of an identifier for an object has file scope and an 1757203955Srdivacky // initializer, the declaration is an external definition for the identifier 1758203955Srdivacky if (hasInit()) 1759203955Srdivacky return Definition; 1760251662Sdim 1761263508Sdim if (hasAttr<AliasAttr>()) 1762263508Sdim return Definition; 1763263508Sdim 1764263508Sdim // A variable template specialization (other than a static data member 1765263508Sdim // template or an explicit specialization) is a declaration until we 1766263508Sdim // instantiate its initializer. 1767263508Sdim if (isa<VarTemplateSpecializationDecl>(this) && 1768263508Sdim getTemplateSpecializationKind() != TSK_ExplicitSpecialization) 1769263508Sdim return DeclarationOnly; 1770263508Sdim 1771203955Srdivacky if (hasExternalStorage()) 1772203955Srdivacky return DeclarationOnly; 1773249423Sdim 1774251662Sdim // [dcl.link] p7: 1775251662Sdim // A declaration directly contained in a linkage-specification is treated 1776251662Sdim // as if it contains the extern specifier for the purpose of determining 1777251662Sdim // the linkage of the declared name and whether it is a definition. 1778251662Sdim if (isSingleLineExternC(*this)) 1779251662Sdim return DeclarationOnly; 1780251662Sdim 1781203955Srdivacky // C99 6.9.2p2: 1782203955Srdivacky // A declaration of an object that has file scope without an initializer, 1783203955Srdivacky // and without a storage class specifier or the scs 'static', constitutes 1784203955Srdivacky // a tentative definition. 1785203955Srdivacky // No such thing in C++. 1786234353Sdim if (!C.getLangOpts().CPlusPlus && isFileVarDecl()) 1787203955Srdivacky return TentativeDefinition; 1788203955Srdivacky 1789203955Srdivacky // What's left is (in C, block-scope) declarations without initializers or 1790203955Srdivacky // external storage. These are definitions. 1791203955Srdivacky return Definition; 1792203955Srdivacky} 1793203955Srdivacky 1794203955SrdivackyVarDecl *VarDecl::getActingDefinition() { 1795203955Srdivacky DefinitionKind Kind = isThisDeclarationADefinition(); 1796203955Srdivacky if (Kind != TentativeDefinition) 1797203955Srdivacky return 0; 1798203955Srdivacky 1799210299Sed VarDecl *LastTentative = 0; 1800263508Sdim VarDecl *First = getFirstDecl(); 1801203955Srdivacky for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 1802203955Srdivacky I != E; ++I) { 1803203955Srdivacky Kind = (*I)->isThisDeclarationADefinition(); 1804203955Srdivacky if (Kind == Definition) 1805203955Srdivacky return 0; 1806203955Srdivacky else if (Kind == TentativeDefinition) 1807203955Srdivacky LastTentative = *I; 1808203955Srdivacky } 1809203955Srdivacky return LastTentative; 1810203955Srdivacky} 1811203955Srdivacky 1812234353SdimVarDecl *VarDecl::getDefinition(ASTContext &C) { 1813263508Sdim VarDecl *First = getFirstDecl(); 1814203955Srdivacky for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 1815203955Srdivacky I != E; ++I) { 1816234353Sdim if ((*I)->isThisDeclarationADefinition(C) == Definition) 1817203955Srdivacky return *I; 1818203955Srdivacky } 1819203955Srdivacky return 0; 1820203955Srdivacky} 1821203955Srdivacky 1822234353SdimVarDecl::DefinitionKind VarDecl::hasDefinition(ASTContext &C) const { 1823218893Sdim DefinitionKind Kind = DeclarationOnly; 1824218893Sdim 1825263508Sdim const VarDecl *First = getFirstDecl(); 1826218893Sdim for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 1827234353Sdim I != E; ++I) { 1828234353Sdim Kind = std::max(Kind, (*I)->isThisDeclarationADefinition(C)); 1829234353Sdim if (Kind == Definition) 1830234353Sdim break; 1831234353Sdim } 1832218893Sdim 1833218893Sdim return Kind; 1834218893Sdim} 1835218893Sdim 1836203955Srdivackyconst Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const { 1837203955Srdivacky redecl_iterator I = redecls_begin(), E = redecls_end(); 1838203955Srdivacky while (I != E && !I->getInit()) 1839203955Srdivacky ++I; 1840203955Srdivacky 1841203955Srdivacky if (I != E) { 1842203955Srdivacky D = *I; 1843203955Srdivacky return I->getInit(); 1844203955Srdivacky } 1845203955Srdivacky return 0; 1846203955Srdivacky} 1847203955Srdivacky 1848198112Srdivackybool VarDecl::isOutOfLine() const { 1849204643Srdivacky if (Decl::isOutOfLine()) 1850204643Srdivacky return true; 1851204643Srdivacky 1852198112Srdivacky if (!isStaticDataMember()) 1853198112Srdivacky return false; 1854204643Srdivacky 1855198112Srdivacky // If this static data member was instantiated from a static data member of 1856198112Srdivacky // a class template, check whether that static data member was defined 1857198112Srdivacky // out-of-line. 1858198112Srdivacky if (VarDecl *VD = getInstantiatedFromStaticDataMember()) 1859198112Srdivacky return VD->isOutOfLine(); 1860198112Srdivacky 1861198112Srdivacky return false; 1862198112Srdivacky} 1863198112Srdivacky 1864198893SrdivackyVarDecl *VarDecl::getOutOfLineDefinition() { 1865198893Srdivacky if (!isStaticDataMember()) 1866198893Srdivacky return 0; 1867198893Srdivacky 1868198893Srdivacky for (VarDecl::redecl_iterator RD = redecls_begin(), RDEnd = redecls_end(); 1869198893Srdivacky RD != RDEnd; ++RD) { 1870198893Srdivacky if (RD->getLexicalDeclContext()->isFileContext()) 1871198893Srdivacky return *RD; 1872198893Srdivacky } 1873198893Srdivacky 1874198893Srdivacky return 0; 1875198893Srdivacky} 1876198893Srdivacky 1877203955Srdivackyvoid VarDecl::setInit(Expr *I) { 1878203955Srdivacky if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) { 1879203955Srdivacky Eval->~EvaluatedStmt(); 1880203955Srdivacky getASTContext().Deallocate(Eval); 1881203955Srdivacky } 1882203955Srdivacky 1883203955Srdivacky Init = I; 1884203955Srdivacky} 1885203955Srdivacky 1886234353Sdimbool VarDecl::isUsableInConstantExpressions(ASTContext &C) const { 1887234353Sdim const LangOptions &Lang = C.getLangOpts(); 1888234353Sdim 1889234353Sdim if (!Lang.CPlusPlus) 1890234353Sdim return false; 1891234353Sdim 1892234353Sdim // In C++11, any variable of reference type can be used in a constant 1893234353Sdim // expression if it is initialized by a constant expression. 1894249423Sdim if (Lang.CPlusPlus11 && getType()->isReferenceType()) 1895234353Sdim return true; 1896234353Sdim 1897234353Sdim // Only const objects can be used in constant expressions in C++. C++98 does 1898234353Sdim // not require the variable to be non-volatile, but we consider this to be a 1899234353Sdim // defect. 1900234353Sdim if (!getType().isConstQualified() || getType().isVolatileQualified()) 1901234353Sdim return false; 1902234353Sdim 1903234353Sdim // In C++, const, non-volatile variables of integral or enumeration types 1904234353Sdim // can be used in constant expressions. 1905234353Sdim if (getType()->isIntegralOrEnumerationType()) 1906234353Sdim return true; 1907234353Sdim 1908234353Sdim // Additionally, in C++11, non-volatile constexpr variables can be used in 1909234353Sdim // constant expressions. 1910249423Sdim return Lang.CPlusPlus11 && isConstexpr(); 1911234353Sdim} 1912234353Sdim 1913234353Sdim/// Convert the initializer for this declaration to the elaborated EvaluatedStmt 1914234353Sdim/// form, which contains extra information on the evaluated value of the 1915234353Sdim/// initializer. 1916234353SdimEvaluatedStmt *VarDecl::ensureEvaluatedStmt() const { 1917234353Sdim EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>(); 1918234353Sdim if (!Eval) { 1919234353Sdim Stmt *S = Init.get<Stmt *>(); 1920263508Sdim // Note: EvaluatedStmt contains an APValue, which usually holds 1921263508Sdim // resources not allocated from the ASTContext. We need to do some 1922263508Sdim // work to avoid leaking those, but we do so in VarDecl::evaluateValue 1923263508Sdim // where we can detect whether there's anything to clean up or not. 1924234353Sdim Eval = new (getASTContext()) EvaluatedStmt; 1925234353Sdim Eval->Value = S; 1926234353Sdim Init = Eval; 1927234353Sdim } 1928234353Sdim return Eval; 1929234353Sdim} 1930234353Sdim 1931234353SdimAPValue *VarDecl::evaluateValue() const { 1932249423Sdim SmallVector<PartialDiagnosticAt, 8> Notes; 1933234353Sdim return evaluateValue(Notes); 1934234353Sdim} 1935234353Sdim 1936263508Sdimnamespace { 1937263508Sdim// Destroy an APValue that was allocated in an ASTContext. 1938263508Sdimvoid DestroyAPValue(void* UntypedValue) { 1939263508Sdim static_cast<APValue*>(UntypedValue)->~APValue(); 1940263508Sdim} 1941263508Sdim} // namespace 1942263508Sdim 1943234353SdimAPValue *VarDecl::evaluateValue( 1944249423Sdim SmallVectorImpl<PartialDiagnosticAt> &Notes) const { 1945234353Sdim EvaluatedStmt *Eval = ensureEvaluatedStmt(); 1946234353Sdim 1947234353Sdim // We only produce notes indicating why an initializer is non-constant the 1948234353Sdim // first time it is evaluated. FIXME: The notes won't always be emitted the 1949234353Sdim // first time we try evaluation, so might not be produced at all. 1950234353Sdim if (Eval->WasEvaluated) 1951234353Sdim return Eval->Evaluated.isUninit() ? 0 : &Eval->Evaluated; 1952234353Sdim 1953234353Sdim const Expr *Init = cast<Expr>(Eval->Value); 1954234353Sdim assert(!Init->isValueDependent()); 1955234353Sdim 1956234353Sdim if (Eval->IsEvaluating) { 1957234353Sdim // FIXME: Produce a diagnostic for self-initialization. 1958234353Sdim Eval->CheckedICE = true; 1959234353Sdim Eval->IsICE = false; 1960234353Sdim return 0; 1961234353Sdim } 1962234353Sdim 1963234353Sdim Eval->IsEvaluating = true; 1964234353Sdim 1965234353Sdim bool Result = Init->EvaluateAsInitializer(Eval->Evaluated, getASTContext(), 1966234353Sdim this, Notes); 1967234353Sdim 1968263508Sdim // Ensure the computed APValue is cleaned up later if evaluation succeeded, 1969263508Sdim // or that it's empty (so that there's nothing to clean up) if evaluation 1970263508Sdim // failed. 1971234353Sdim if (!Result) 1972234353Sdim Eval->Evaluated = APValue(); 1973263508Sdim else if (Eval->Evaluated.needsCleanup()) 1974263508Sdim getASTContext().AddDeallocation(DestroyAPValue, &Eval->Evaluated); 1975234353Sdim 1976234353Sdim Eval->IsEvaluating = false; 1977234353Sdim Eval->WasEvaluated = true; 1978234353Sdim 1979234353Sdim // In C++11, we have determined whether the initializer was a constant 1980234353Sdim // expression as a side-effect. 1981249423Sdim if (getASTContext().getLangOpts().CPlusPlus11 && !Eval->CheckedICE) { 1982234353Sdim Eval->CheckedICE = true; 1983234353Sdim Eval->IsICE = Result && Notes.empty(); 1984234353Sdim } 1985234353Sdim 1986234353Sdim return Result ? &Eval->Evaluated : 0; 1987234353Sdim} 1988234353Sdim 1989234353Sdimbool VarDecl::checkInitIsICE() const { 1990234353Sdim // Initializers of weak variables are never ICEs. 1991234353Sdim if (isWeak()) 1992234353Sdim return false; 1993234353Sdim 1994234353Sdim EvaluatedStmt *Eval = ensureEvaluatedStmt(); 1995234353Sdim if (Eval->CheckedICE) 1996234353Sdim // We have already checked whether this subexpression is an 1997234353Sdim // integral constant expression. 1998234353Sdim return Eval->IsICE; 1999234353Sdim 2000234353Sdim const Expr *Init = cast<Expr>(Eval->Value); 2001234353Sdim assert(!Init->isValueDependent()); 2002234353Sdim 2003234353Sdim // In C++11, evaluate the initializer to check whether it's a constant 2004234353Sdim // expression. 2005249423Sdim if (getASTContext().getLangOpts().CPlusPlus11) { 2006249423Sdim SmallVector<PartialDiagnosticAt, 8> Notes; 2007234353Sdim evaluateValue(Notes); 2008234353Sdim return Eval->IsICE; 2009234353Sdim } 2010234353Sdim 2011234353Sdim // It's an ICE whether or not the definition we found is 2012234353Sdim // out-of-line. See DR 721 and the discussion in Clang PR 2013234353Sdim // 6206 for details. 2014234353Sdim 2015234353Sdim if (Eval->CheckingICE) 2016234353Sdim return false; 2017234353Sdim Eval->CheckingICE = true; 2018234353Sdim 2019234353Sdim Eval->IsICE = Init->isIntegerConstantExpr(getASTContext()); 2020234353Sdim Eval->CheckingICE = false; 2021234353Sdim Eval->CheckedICE = true; 2022234353Sdim return Eval->IsICE; 2023234353Sdim} 2024234353Sdim 2025198112SrdivackyVarDecl *VarDecl::getInstantiatedFromStaticDataMember() const { 2026198092Srdivacky if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 2027198092Srdivacky return cast<VarDecl>(MSI->getInstantiatedFrom()); 2028198092Srdivacky 2029198092Srdivacky return 0; 2030198092Srdivacky} 2031198092Srdivacky 2032198112SrdivackyTemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const { 2033263508Sdim if (const VarTemplateSpecializationDecl *Spec = 2034263508Sdim dyn_cast<VarTemplateSpecializationDecl>(this)) 2035263508Sdim return Spec->getSpecializationKind(); 2036263508Sdim 2037203955Srdivacky if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 2038198092Srdivacky return MSI->getTemplateSpecializationKind(); 2039263508Sdim 2040198092Srdivacky return TSK_Undeclared; 2041198092Srdivacky} 2042198092Srdivacky 2043263508SdimSourceLocation VarDecl::getPointOfInstantiation() const { 2044263508Sdim if (const VarTemplateSpecializationDecl *Spec = 2045263508Sdim dyn_cast<VarTemplateSpecializationDecl>(this)) 2046263508Sdim return Spec->getPointOfInstantiation(); 2047263508Sdim 2048263508Sdim if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 2049263508Sdim return MSI->getPointOfInstantiation(); 2050263508Sdim 2051263508Sdim return SourceLocation(); 2052263508Sdim} 2053263508Sdim 2054263508SdimVarTemplateDecl *VarDecl::getDescribedVarTemplate() const { 2055263508Sdim return getASTContext().getTemplateOrSpecializationInfo(this) 2056263508Sdim .dyn_cast<VarTemplateDecl *>(); 2057263508Sdim} 2058263508Sdim 2059263508Sdimvoid VarDecl::setDescribedVarTemplate(VarTemplateDecl *Template) { 2060263508Sdim getASTContext().setTemplateOrSpecializationInfo(this, Template); 2061263508Sdim} 2062263508Sdim 2063198112SrdivackyMemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const { 2064263508Sdim if (isStaticDataMember()) 2065263508Sdim // FIXME: Remove ? 2066263508Sdim // return getASTContext().getInstantiatedFromStaticDataMember(this); 2067263508Sdim return getASTContext().getTemplateOrSpecializationInfo(this) 2068263508Sdim .dyn_cast<MemberSpecializationInfo *>(); 2069263508Sdim return 0; 2070198092Srdivacky} 2071198092Srdivacky 2072198398Srdivackyvoid VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 2073198398Srdivacky SourceLocation PointOfInstantiation) { 2074263508Sdim assert((isa<VarTemplateSpecializationDecl>(this) || 2075263508Sdim getMemberSpecializationInfo()) && 2076263508Sdim "not a variable or static data member template specialization"); 2077263508Sdim 2078263508Sdim if (VarTemplateSpecializationDecl *Spec = 2079263508Sdim dyn_cast<VarTemplateSpecializationDecl>(this)) { 2080263508Sdim Spec->setSpecializationKind(TSK); 2081263508Sdim if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() && 2082263508Sdim Spec->getPointOfInstantiation().isInvalid()) 2083263508Sdim Spec->setPointOfInstantiation(PointOfInstantiation); 2084263508Sdim } 2085263508Sdim 2086263508Sdim if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) { 2087263508Sdim MSI->setTemplateSpecializationKind(TSK); 2088263508Sdim if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() && 2089263508Sdim MSI->getPointOfInstantiation().isInvalid()) 2090263508Sdim MSI->setPointOfInstantiation(PointOfInstantiation); 2091263508Sdim } 2092198092Srdivacky} 2093198092Srdivacky 2094263508Sdimvoid 2095263508SdimVarDecl::setInstantiationOfStaticDataMember(VarDecl *VD, 2096263508Sdim TemplateSpecializationKind TSK) { 2097263508Sdim assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() && 2098263508Sdim "Previous template or instantiation?"); 2099263508Sdim getASTContext().setInstantiatedFromStaticDataMember(this, VD, TSK); 2100263508Sdim} 2101263508Sdim 2102203955Srdivacky//===----------------------------------------------------------------------===// 2103203955Srdivacky// ParmVarDecl Implementation 2104203955Srdivacky//===----------------------------------------------------------------------===// 2105193326Sed 2106203955SrdivackyParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC, 2107221345Sdim SourceLocation StartLoc, 2108221345Sdim SourceLocation IdLoc, IdentifierInfo *Id, 2109203955Srdivacky QualType T, TypeSourceInfo *TInfo, 2110249423Sdim StorageClass S, Expr *DefArg) { 2111221345Sdim return new (C) ParmVarDecl(ParmVar, DC, StartLoc, IdLoc, Id, T, TInfo, 2112249423Sdim S, DefArg); 2113193326Sed} 2114193326Sed 2115263508SdimQualType ParmVarDecl::getOriginalType() const { 2116263508Sdim TypeSourceInfo *TSI = getTypeSourceInfo(); 2117263508Sdim QualType T = TSI ? TSI->getType() : getType(); 2118263508Sdim if (const DecayedType *DT = dyn_cast<DecayedType>(T)) 2119263508Sdim return DT->getOriginalType(); 2120263508Sdim return T; 2121263508Sdim} 2122263508Sdim 2123234353SdimParmVarDecl *ParmVarDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 2124234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ParmVarDecl)); 2125234353Sdim return new (Mem) ParmVarDecl(ParmVar, 0, SourceLocation(), SourceLocation(), 2126249423Sdim 0, QualType(), 0, SC_None, 0); 2127234353Sdim} 2128234353Sdim 2129226633SdimSourceRange ParmVarDecl::getSourceRange() const { 2130226633Sdim if (!hasInheritedDefaultArg()) { 2131226633Sdim SourceRange ArgRange = getDefaultArgRange(); 2132226633Sdim if (ArgRange.isValid()) 2133226633Sdim return SourceRange(getOuterLocStart(), ArgRange.getEnd()); 2134226633Sdim } 2135226633Sdim 2136251662Sdim // DeclaratorDecl considers the range of postfix types as overlapping with the 2137251662Sdim // declaration name, but this is not the case with parameters in ObjC methods. 2138251662Sdim if (isa<ObjCMethodDecl>(getDeclContext())) 2139251662Sdim return SourceRange(DeclaratorDecl::getLocStart(), getLocation()); 2140251662Sdim 2141226633Sdim return DeclaratorDecl::getSourceRange(); 2142226633Sdim} 2143226633Sdim 2144203955SrdivackyExpr *ParmVarDecl::getDefaultArg() { 2145203955Srdivacky assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!"); 2146203955Srdivacky assert(!hasUninstantiatedDefaultArg() && 2147203955Srdivacky "Default argument is not yet instantiated!"); 2148203955Srdivacky 2149203955Srdivacky Expr *Arg = getInit(); 2150218893Sdim if (ExprWithCleanups *E = dyn_cast_or_null<ExprWithCleanups>(Arg)) 2151203955Srdivacky return E->getSubExpr(); 2152193326Sed 2153203955Srdivacky return Arg; 2154203955Srdivacky} 2155203955Srdivacky 2156203955SrdivackySourceRange ParmVarDecl::getDefaultArgRange() const { 2157203955Srdivacky if (const Expr *E = getInit()) 2158203955Srdivacky return E->getSourceRange(); 2159203955Srdivacky 2160203955Srdivacky if (hasUninstantiatedDefaultArg()) 2161203955Srdivacky return getUninstantiatedDefaultArg()->getSourceRange(); 2162203955Srdivacky 2163203955Srdivacky return SourceRange(); 2164203955Srdivacky} 2165203955Srdivacky 2166218893Sdimbool ParmVarDecl::isParameterPack() const { 2167218893Sdim return isa<PackExpansionType>(getType()); 2168218893Sdim} 2169218893Sdim 2170226633Sdimvoid ParmVarDecl::setParameterIndexLarge(unsigned parameterIndex) { 2171226633Sdim getASTContext().setParameterIndex(this, parameterIndex); 2172226633Sdim ParmVarDeclBits.ParameterIndex = ParameterIndexSentinel; 2173226633Sdim} 2174226633Sdim 2175226633Sdimunsigned ParmVarDecl::getParameterIndexLarge() const { 2176226633Sdim return getASTContext().getParameterIndex(this); 2177226633Sdim} 2178226633Sdim 2179193326Sed//===----------------------------------------------------------------------===// 2180193326Sed// FunctionDecl Implementation 2181193326Sed//===----------------------------------------------------------------------===// 2182193326Sed 2183249423Sdimvoid FunctionDecl::getNameForDiagnostic( 2184249423Sdim raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const { 2185249423Sdim NamedDecl::getNameForDiagnostic(OS, Policy, Qualified); 2186198092Srdivacky const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs(); 2187198092Srdivacky if (TemplateArgs) 2188249423Sdim TemplateSpecializationType::PrintTemplateArgumentList( 2189249423Sdim OS, TemplateArgs->data(), TemplateArgs->size(), Policy); 2190198092Srdivacky} 2191193326Sed 2192207619Srdivackybool FunctionDecl::isVariadic() const { 2193207619Srdivacky if (const FunctionProtoType *FT = getType()->getAs<FunctionProtoType>()) 2194207619Srdivacky return FT->isVariadic(); 2195207619Srdivacky return false; 2196207619Srdivacky} 2197207619Srdivacky 2198210299Sedbool FunctionDecl::hasBody(const FunctionDecl *&Definition) const { 2199210299Sed for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 2200221345Sdim if (I->Body || I->IsLateTemplateParsed) { 2201210299Sed Definition = *I; 2202210299Sed return true; 2203210299Sed } 2204210299Sed } 2205210299Sed 2206210299Sed return false; 2207210299Sed} 2208210299Sed 2209223017Sdimbool FunctionDecl::hasTrivialBody() const 2210223017Sdim{ 2211223017Sdim Stmt *S = getBody(); 2212223017Sdim if (!S) { 2213223017Sdim // Since we don't have a body for this function, we don't know if it's 2214223017Sdim // trivial or not. 2215223017Sdim return false; 2216223017Sdim } 2217223017Sdim 2218223017Sdim if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty()) 2219223017Sdim return true; 2220223017Sdim return false; 2221223017Sdim} 2222223017Sdim 2223223017Sdimbool FunctionDecl::isDefined(const FunctionDecl *&Definition) const { 2224223017Sdim for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 2225263508Sdim if (I->IsDeleted || I->IsDefaulted || I->Body || I->IsLateTemplateParsed || 2226263508Sdim I->hasAttr<AliasAttr>()) { 2227223017Sdim Definition = I->IsDeleted ? I->getCanonicalDecl() : *I; 2228223017Sdim return true; 2229223017Sdim } 2230223017Sdim } 2231223017Sdim 2232223017Sdim return false; 2233223017Sdim} 2234223017Sdim 2235195341SedStmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const { 2236263508Sdim if (!hasBody(Definition)) 2237263508Sdim return 0; 2238193326Sed 2239263508Sdim if (Definition->Body) 2240263508Sdim return Definition->Body.get(getASTContext().getExternalSource()); 2241263508Sdim 2242193326Sed return 0; 2243193326Sed} 2244193326Sed 2245194613Sedvoid FunctionDecl::setBody(Stmt *B) { 2246194613Sed Body = B; 2247194711Sed if (B) 2248194613Sed EndRangeLoc = B->getLocEnd(); 2249194613Sed} 2250194613Sed 2251218893Sdimvoid FunctionDecl::setPure(bool P) { 2252218893Sdim IsPure = P; 2253218893Sdim if (P) 2254218893Sdim if (CXXRecordDecl *Parent = dyn_cast<CXXRecordDecl>(getDeclContext())) 2255218893Sdim Parent->markedVirtualFunctionPure(); 2256218893Sdim} 2257218893Sdim 2258263508Sdimtemplate<std::size_t Len> 2259263508Sdimstatic bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) { 2260263508Sdim IdentifierInfo *II = ND->getIdentifier(); 2261263508Sdim return II && II->isStr(Str); 2262263508Sdim} 2263263508Sdim 2264193326Sedbool FunctionDecl::isMain() const { 2265223017Sdim const TranslationUnitDecl *tunit = 2266223017Sdim dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext()); 2267223017Sdim return tunit && 2268234353Sdim !tunit->getASTContext().getLangOpts().Freestanding && 2269263508Sdim isNamed(this, "main"); 2270193326Sed} 2271193326Sed 2272263508Sdimbool FunctionDecl::isMSVCRTEntryPoint() const { 2273263508Sdim const TranslationUnitDecl *TUnit = 2274263508Sdim dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext()); 2275263508Sdim if (!TUnit) 2276263508Sdim return false; 2277263508Sdim 2278263508Sdim // Even though we aren't really targeting MSVCRT if we are freestanding, 2279263508Sdim // semantic analysis for these functions remains the same. 2280263508Sdim 2281263508Sdim // MSVCRT entry points only exist on MSVCRT targets. 2282263508Sdim if (!TUnit->getASTContext().getTargetInfo().getTriple().isOSMSVCRT()) 2283263508Sdim return false; 2284263508Sdim 2285263508Sdim // Nameless functions like constructors cannot be entry points. 2286263508Sdim if (!getIdentifier()) 2287263508Sdim return false; 2288263508Sdim 2289263508Sdim return llvm::StringSwitch<bool>(getName()) 2290263508Sdim .Cases("main", // an ANSI console app 2291263508Sdim "wmain", // a Unicode console App 2292263508Sdim "WinMain", // an ANSI GUI app 2293263508Sdim "wWinMain", // a Unicode GUI app 2294263508Sdim "DllMain", // a DLL 2295263508Sdim true) 2296263508Sdim .Default(false); 2297263508Sdim} 2298263508Sdim 2299223017Sdimbool FunctionDecl::isReservedGlobalPlacementOperator() const { 2300223017Sdim assert(getDeclName().getNameKind() == DeclarationName::CXXOperatorName); 2301223017Sdim assert(getDeclName().getCXXOverloadedOperator() == OO_New || 2302223017Sdim getDeclName().getCXXOverloadedOperator() == OO_Delete || 2303223017Sdim getDeclName().getCXXOverloadedOperator() == OO_Array_New || 2304223017Sdim getDeclName().getCXXOverloadedOperator() == OO_Array_Delete); 2305223017Sdim 2306223017Sdim if (isa<CXXRecordDecl>(getDeclContext())) return false; 2307223017Sdim assert(getDeclContext()->getRedeclContext()->isTranslationUnit()); 2308223017Sdim 2309223017Sdim const FunctionProtoType *proto = getType()->castAs<FunctionProtoType>(); 2310223017Sdim if (proto->getNumArgs() != 2 || proto->isVariadic()) return false; 2311223017Sdim 2312223017Sdim ASTContext &Context = 2313223017Sdim cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext()) 2314223017Sdim ->getASTContext(); 2315223017Sdim 2316223017Sdim // The result type and first argument type are constant across all 2317223017Sdim // these operators. The second argument must be exactly void*. 2318223017Sdim return (proto->getArgType(1).getCanonicalType() == Context.VoidPtrTy); 2319223017Sdim} 2320223017Sdim 2321263508Sdimstatic bool isNamespaceStd(const DeclContext *DC) { 2322263508Sdim const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC->getRedeclContext()); 2323263508Sdim return ND && isNamed(ND, "std") && 2324263508Sdim ND->getParent()->getRedeclContext()->isTranslationUnit(); 2325263508Sdim} 2326263508Sdim 2327263508Sdimbool FunctionDecl::isReplaceableGlobalAllocationFunction() const { 2328263508Sdim if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName) 2329263508Sdim return false; 2330263508Sdim if (getDeclName().getCXXOverloadedOperator() != OO_New && 2331263508Sdim getDeclName().getCXXOverloadedOperator() != OO_Delete && 2332263508Sdim getDeclName().getCXXOverloadedOperator() != OO_Array_New && 2333263508Sdim getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) 2334263508Sdim return false; 2335263508Sdim 2336263508Sdim if (isa<CXXRecordDecl>(getDeclContext())) 2337263508Sdim return false; 2338263508Sdim assert(getDeclContext()->getRedeclContext()->isTranslationUnit()); 2339263508Sdim 2340263508Sdim const FunctionProtoType *FPT = getType()->castAs<FunctionProtoType>(); 2341263508Sdim if (FPT->getNumArgs() > 2 || FPT->isVariadic()) 2342263508Sdim return false; 2343263508Sdim 2344263508Sdim // If this is a single-parameter function, it must be a replaceable global 2345263508Sdim // allocation or deallocation function. 2346263508Sdim if (FPT->getNumArgs() == 1) 2347263508Sdim return true; 2348263508Sdim 2349263508Sdim // Otherwise, we're looking for a second parameter whose type is 2350263508Sdim // 'const std::nothrow_t &', or, in C++1y, 'std::size_t'. 2351263508Sdim QualType Ty = FPT->getArgType(1); 2352263508Sdim ASTContext &Ctx = getASTContext(); 2353263508Sdim if (Ctx.getLangOpts().SizedDeallocation && 2354263508Sdim Ctx.hasSameType(Ty, Ctx.getSizeType())) 2355263508Sdim return true; 2356263508Sdim if (!Ty->isReferenceType()) 2357263508Sdim return false; 2358263508Sdim Ty = Ty->getPointeeType(); 2359263508Sdim if (Ty.getCVRQualifiers() != Qualifiers::Const) 2360263508Sdim return false; 2361263508Sdim // FIXME: Recognise nothrow_t in an inline namespace inside std? 2362263508Sdim const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl(); 2363263508Sdim return RD && isNamed(RD, "nothrow_t") && isNamespaceStd(RD->getDeclContext()); 2364263508Sdim} 2365263508Sdim 2366263508SdimFunctionDecl * 2367263508SdimFunctionDecl::getCorrespondingUnsizedGlobalDeallocationFunction() const { 2368263508Sdim ASTContext &Ctx = getASTContext(); 2369263508Sdim if (!Ctx.getLangOpts().SizedDeallocation) 2370263508Sdim return 0; 2371263508Sdim 2372263508Sdim if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName) 2373263508Sdim return 0; 2374263508Sdim if (getDeclName().getCXXOverloadedOperator() != OO_Delete && 2375263508Sdim getDeclName().getCXXOverloadedOperator() != OO_Array_Delete) 2376263508Sdim return 0; 2377263508Sdim if (isa<CXXRecordDecl>(getDeclContext())) 2378263508Sdim return 0; 2379263508Sdim assert(getDeclContext()->getRedeclContext()->isTranslationUnit()); 2380263508Sdim 2381263508Sdim if (getNumParams() != 2 || isVariadic() || 2382263508Sdim !Ctx.hasSameType(getType()->castAs<FunctionProtoType>()->getArgType(1), 2383263508Sdim Ctx.getSizeType())) 2384263508Sdim return 0; 2385263508Sdim 2386263508Sdim // This is a sized deallocation function. Find the corresponding unsized 2387263508Sdim // deallocation function. 2388263508Sdim lookup_const_result R = getDeclContext()->lookup(getDeclName()); 2389263508Sdim for (lookup_const_result::iterator RI = R.begin(), RE = R.end(); RI != RE; 2390263508Sdim ++RI) 2391263508Sdim if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*RI)) 2392263508Sdim if (FD->getNumParams() == 1 && !FD->isVariadic()) 2393263508Sdim return FD; 2394263508Sdim return 0; 2395263508Sdim} 2396263508Sdim 2397249423SdimLanguageLinkage FunctionDecl::getLanguageLinkage() const { 2398249423Sdim return getLanguageLinkageTemplate(*this); 2399249423Sdim} 2400234353Sdim 2401249423Sdimbool FunctionDecl::isExternC() const { 2402249423Sdim return isExternCTemplate(*this); 2403193326Sed} 2404193326Sed 2405251662Sdimbool FunctionDecl::isInExternCContext() const { 2406263508Sdim return getLexicalDeclContext()->isExternCContext(); 2407251662Sdim} 2408251662Sdim 2409251662Sdimbool FunctionDecl::isInExternCXXContext() const { 2410263508Sdim return getLexicalDeclContext()->isExternCXXContext(); 2411251662Sdim} 2412251662Sdim 2413193326Sedbool FunctionDecl::isGlobal() const { 2414193326Sed if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(this)) 2415193326Sed return Method->isStatic(); 2416193326Sed 2417249423Sdim if (getCanonicalDecl()->getStorageClass() == SC_Static) 2418193326Sed return false; 2419193326Sed 2420198092Srdivacky for (const DeclContext *DC = getDeclContext(); 2421193326Sed DC->isNamespace(); 2422193326Sed DC = DC->getParent()) { 2423193326Sed if (const NamespaceDecl *Namespace = cast<NamespaceDecl>(DC)) { 2424193326Sed if (!Namespace->getDeclName()) 2425193326Sed return false; 2426193326Sed break; 2427193326Sed } 2428193326Sed } 2429193326Sed 2430193326Sed return true; 2431193326Sed} 2432193326Sed 2433249423Sdimbool FunctionDecl::isNoReturn() const { 2434249423Sdim return hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() || 2435249423Sdim hasAttr<C11NoReturnAttr>() || 2436249423Sdim getType()->getAs<FunctionType>()->getNoReturnAttr(); 2437249423Sdim} 2438249423Sdim 2439203955Srdivackyvoid 2440203955SrdivackyFunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) { 2441263508Sdim redeclarable_base::setPreviousDecl(PrevDecl); 2442203955Srdivacky 2443203955Srdivacky if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) { 2444203955Srdivacky FunctionTemplateDecl *PrevFunTmpl 2445203955Srdivacky = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : 0; 2446203955Srdivacky assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch"); 2447263508Sdim FunTmpl->setPreviousDecl(PrevFunTmpl); 2448203955Srdivacky } 2449218893Sdim 2450234353Sdim if (PrevDecl && PrevDecl->IsInline) 2451218893Sdim IsInline = true; 2452203955Srdivacky} 2453203955Srdivacky 2454203955Srdivackyconst FunctionDecl *FunctionDecl::getCanonicalDecl() const { 2455263508Sdim return getFirstDecl(); 2456203955Srdivacky} 2457203955Srdivacky 2458263508SdimFunctionDecl *FunctionDecl::getCanonicalDecl() { return getFirstDecl(); } 2459203955Srdivacky 2460193326Sed/// \brief Returns a value indicating whether this function 2461193326Sed/// corresponds to a builtin function. 2462193326Sed/// 2463193326Sed/// The function corresponds to a built-in function if it is 2464193326Sed/// declared at translation scope or within an extern "C" block and 2465193326Sed/// its name matches with the name of a builtin. The returned value 2466193326Sed/// will be 0 for functions that do not correspond to a builtin, a 2467198092Srdivacky/// value of type \c Builtin::ID if in the target-independent range 2468193326Sed/// \c [1,Builtin::First), or a target-specific builtin value. 2469198092Srdivackyunsigned FunctionDecl::getBuiltinID() const { 2470234353Sdim if (!getIdentifier()) 2471193326Sed return 0; 2472193326Sed 2473193326Sed unsigned BuiltinID = getIdentifier()->getBuiltinID(); 2474234353Sdim if (!BuiltinID) 2475234353Sdim return 0; 2476234353Sdim 2477234353Sdim ASTContext &Context = getASTContext(); 2478263508Sdim if (Context.getLangOpts().CPlusPlus) { 2479263508Sdim const LinkageSpecDecl *LinkageDecl = dyn_cast<LinkageSpecDecl>( 2480263508Sdim getFirstDecl()->getDeclContext()); 2481263508Sdim // In C++, the first declaration of a builtin is always inside an implicit 2482263508Sdim // extern "C". 2483263508Sdim // FIXME: A recognised library function may not be directly in an extern "C" 2484263508Sdim // declaration, for instance "extern "C" { namespace std { decl } }". 2485263508Sdim if (!LinkageDecl || LinkageDecl->getLanguage() != LinkageSpecDecl::lang_c) 2486263508Sdim return 0; 2487263508Sdim } 2488263508Sdim 2489263508Sdim // If the function is marked "overloadable", it has a different mangled name 2490263508Sdim // and is not the C library function. 2491263508Sdim if (getAttr<OverloadableAttr>()) 2492263508Sdim return 0; 2493263508Sdim 2494193326Sed if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) 2495193326Sed return BuiltinID; 2496193326Sed 2497193326Sed // This function has the name of a known C library 2498193326Sed // function. Determine whether it actually refers to the C library 2499193326Sed // function or whether it just has the same name. 2500193326Sed 2501193326Sed // If this is a static function, it's not a builtin. 2502212904Sdim if (getStorageClass() == SC_Static) 2503193326Sed return 0; 2504193326Sed 2505263508Sdim return BuiltinID; 2506193326Sed} 2507193326Sed 2508193326Sed 2509193326Sed/// getNumParams - Return the number of parameters this function must have 2510218893Sdim/// based on its FunctionType. This is the length of the ParamInfo array 2511193326Sed/// after it has been created. 2512193326Sedunsigned FunctionDecl::getNumParams() const { 2513243830Sdim const FunctionType *FT = getType()->castAs<FunctionType>(); 2514193326Sed if (isa<FunctionNoProtoType>(FT)) 2515193326Sed return 0; 2516193326Sed return cast<FunctionProtoType>(FT)->getNumArgs(); 2517198092Srdivacky 2518193326Sed} 2519193326Sed 2520218893Sdimvoid FunctionDecl::setParams(ASTContext &C, 2521249423Sdim ArrayRef<ParmVarDecl *> NewParamInfo) { 2522193326Sed assert(ParamInfo == 0 && "Already has param info!"); 2523226633Sdim assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!"); 2524198092Srdivacky 2525193326Sed // Zero params -> null pointer. 2526226633Sdim if (!NewParamInfo.empty()) { 2527226633Sdim ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()]; 2528226633Sdim std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo); 2529193326Sed } 2530193326Sed} 2531193326Sed 2532249423Sdimvoid FunctionDecl::setDeclsInPrototypeScope(ArrayRef<NamedDecl *> NewDecls) { 2533234353Sdim assert(DeclsInPrototypeScope.empty() && "Already has prototype decls!"); 2534234353Sdim 2535234353Sdim if (!NewDecls.empty()) { 2536234353Sdim NamedDecl **A = new (getASTContext()) NamedDecl*[NewDecls.size()]; 2537234353Sdim std::copy(NewDecls.begin(), NewDecls.end(), A); 2538249423Sdim DeclsInPrototypeScope = ArrayRef<NamedDecl *>(A, NewDecls.size()); 2539234353Sdim } 2540234353Sdim} 2541234353Sdim 2542193326Sed/// getMinRequiredArguments - Returns the minimum number of arguments 2543193326Sed/// needed to call this function. This may be fewer than the number of 2544193326Sed/// function parameters, if some of the parameters have default 2545218893Sdim/// arguments (in C++) or the last parameter is a parameter pack. 2546193326Sedunsigned FunctionDecl::getMinRequiredArguments() const { 2547234353Sdim if (!getASTContext().getLangOpts().CPlusPlus) 2548218893Sdim return getNumParams(); 2549218893Sdim 2550218893Sdim unsigned NumRequiredArgs = getNumParams(); 2551218893Sdim 2552218893Sdim // If the last parameter is a parameter pack, we don't need an argument for 2553218893Sdim // it. 2554218893Sdim if (NumRequiredArgs > 0 && 2555218893Sdim getParamDecl(NumRequiredArgs - 1)->isParameterPack()) 2556193326Sed --NumRequiredArgs; 2557218893Sdim 2558218893Sdim // If this parameter has a default argument, we don't need an argument for 2559218893Sdim // it. 2560218893Sdim while (NumRequiredArgs > 0 && 2561218893Sdim getParamDecl(NumRequiredArgs-1)->hasDefaultArg()) 2562218893Sdim --NumRequiredArgs; 2563193326Sed 2564218893Sdim // We might have parameter packs before the end. These can't be deduced, 2565218893Sdim // but they can still handle multiple arguments. 2566218893Sdim unsigned ArgIdx = NumRequiredArgs; 2567218893Sdim while (ArgIdx > 0) { 2568218893Sdim if (getParamDecl(ArgIdx - 1)->isParameterPack()) 2569218893Sdim NumRequiredArgs = ArgIdx; 2570218893Sdim 2571218893Sdim --ArgIdx; 2572218893Sdim } 2573218893Sdim 2574193326Sed return NumRequiredArgs; 2575193326Sed} 2576193326Sed 2577234353Sdimstatic bool RedeclForcesDefC99(const FunctionDecl *Redecl) { 2578234353Sdim // Only consider file-scope declarations in this test. 2579234353Sdim if (!Redecl->getLexicalDeclContext()->isTranslationUnit()) 2580234353Sdim return false; 2581234353Sdim 2582234353Sdim // Only consider explicit declarations; the presence of a builtin for a 2583234353Sdim // libcall shouldn't affect whether a definition is externally visible. 2584234353Sdim if (Redecl->isImplicit()) 2585234353Sdim return false; 2586234353Sdim 2587234353Sdim if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern) 2588234353Sdim return true; // Not an inline definition 2589234353Sdim 2590234353Sdim return false; 2591234353Sdim} 2592234353Sdim 2593226633Sdim/// \brief For a function declaration in C or C++, determine whether this 2594226633Sdim/// declaration causes the definition to be externally visible. 2595226633Sdim/// 2596234353Sdim/// Specifically, this determines if adding the current declaration to the set 2597234353Sdim/// of redeclarations of the given functions causes 2598234353Sdim/// isInlineDefinitionExternallyVisible to change from false to true. 2599226633Sdimbool FunctionDecl::doesDeclarationForceExternallyVisibleDefinition() const { 2600226633Sdim assert(!doesThisDeclarationHaveABody() && 2601226633Sdim "Must have a declaration without a body."); 2602226633Sdim 2603226633Sdim ASTContext &Context = getASTContext(); 2604226633Sdim 2605234353Sdim if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) { 2606234353Sdim // With GNU inlining, a declaration with 'inline' but not 'extern', forces 2607234353Sdim // an externally visible definition. 2608234353Sdim // 2609234353Sdim // FIXME: What happens if gnu_inline gets added on after the first 2610234353Sdim // declaration? 2611249423Sdim if (!isInlineSpecified() || getStorageClass() == SC_Extern) 2612234353Sdim return false; 2613234353Sdim 2614234353Sdim const FunctionDecl *Prev = this; 2615234353Sdim bool FoundBody = false; 2616234353Sdim while ((Prev = Prev->getPreviousDecl())) { 2617263508Sdim FoundBody |= Prev->Body.isValid(); 2618234353Sdim 2619234353Sdim if (Prev->Body) { 2620234353Sdim // If it's not the case that both 'inline' and 'extern' are 2621234353Sdim // specified on the definition, then it is always externally visible. 2622234353Sdim if (!Prev->isInlineSpecified() || 2623249423Sdim Prev->getStorageClass() != SC_Extern) 2624234353Sdim return false; 2625234353Sdim } else if (Prev->isInlineSpecified() && 2626249423Sdim Prev->getStorageClass() != SC_Extern) { 2627234353Sdim return false; 2628234353Sdim } 2629234353Sdim } 2630234353Sdim return FoundBody; 2631234353Sdim } 2632234353Sdim 2633234353Sdim if (Context.getLangOpts().CPlusPlus) 2634226633Sdim return false; 2635234353Sdim 2636234353Sdim // C99 6.7.4p6: 2637234353Sdim // [...] If all of the file scope declarations for a function in a 2638234353Sdim // translation unit include the inline function specifier without extern, 2639234353Sdim // then the definition in that translation unit is an inline definition. 2640234353Sdim if (isInlineSpecified() && getStorageClass() != SC_Extern) 2641226633Sdim return false; 2642234353Sdim const FunctionDecl *Prev = this; 2643234353Sdim bool FoundBody = false; 2644234353Sdim while ((Prev = Prev->getPreviousDecl())) { 2645263508Sdim FoundBody |= Prev->Body.isValid(); 2646234353Sdim if (RedeclForcesDefC99(Prev)) 2647234353Sdim return false; 2648234353Sdim } 2649234353Sdim return FoundBody; 2650226633Sdim} 2651226633Sdim 2652249423Sdim/// \brief For an inline function definition in C, or for a gnu_inline function 2653249423Sdim/// in C++, determine whether the definition will be externally visible. 2654198092Srdivacky/// 2655198092Srdivacky/// Inline function definitions are always available for inlining optimizations. 2656198092Srdivacky/// However, depending on the language dialect, declaration specifiers, and 2657198092Srdivacky/// attributes, the definition of an inline function may or may not be 2658198092Srdivacky/// "externally" visible to other translation units in the program. 2659198092Srdivacky/// 2660198092Srdivacky/// In C99, inline definitions are not externally visible by default. However, 2661202379Srdivacky/// if even one of the global-scope declarations is marked "extern inline", the 2662198092Srdivacky/// inline definition becomes externally visible (C99 6.7.4p6). 2663198092Srdivacky/// 2664198092Srdivacky/// In GNU89 mode, or if the gnu_inline attribute is attached to the function 2665198092Srdivacky/// definition, we use the GNU semantics for inline, which are nearly the 2666198092Srdivacky/// opposite of C99 semantics. In particular, "inline" by itself will create 2667198092Srdivacky/// an externally visible symbol, but "extern inline" will not create an 2668198092Srdivacky/// externally visible symbol. 2669198092Srdivackybool FunctionDecl::isInlineDefinitionExternallyVisible() const { 2670223017Sdim assert(doesThisDeclarationHaveABody() && "Must have the function definition"); 2671198893Srdivacky assert(isInlined() && "Function must be inline"); 2672198893Srdivacky ASTContext &Context = getASTContext(); 2673198092Srdivacky 2674234353Sdim if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) { 2675234353Sdim // Note: If you change the logic here, please change 2676234353Sdim // doesDeclarationForceExternallyVisibleDefinition as well. 2677234353Sdim // 2678218893Sdim // If it's not the case that both 'inline' and 'extern' are 2679218893Sdim // specified on the definition, then this inline definition is 2680218893Sdim // externally visible. 2681249423Sdim if (!(isInlineSpecified() && getStorageClass() == SC_Extern)) 2682218893Sdim return true; 2683218893Sdim 2684218893Sdim // If any declaration is 'inline' but not 'extern', then this definition 2685218893Sdim // is externally visible. 2686198092Srdivacky for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end(); 2687198092Srdivacky Redecl != RedeclEnd; 2688198092Srdivacky ++Redecl) { 2689218893Sdim if (Redecl->isInlineSpecified() && 2690249423Sdim Redecl->getStorageClass() != SC_Extern) 2691198092Srdivacky return true; 2692218893Sdim } 2693198092Srdivacky 2694193326Sed return false; 2695193326Sed } 2696234353Sdim 2697249423Sdim // The rest of this function is C-only. 2698249423Sdim assert(!Context.getLangOpts().CPlusPlus && 2699249423Sdim "should not use C inline rules in C++"); 2700249423Sdim 2701198092Srdivacky // C99 6.7.4p6: 2702198092Srdivacky // [...] If all of the file scope declarations for a function in a 2703198092Srdivacky // translation unit include the inline function specifier without extern, 2704198092Srdivacky // then the definition in that translation unit is an inline definition. 2705198092Srdivacky for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end(); 2706198092Srdivacky Redecl != RedeclEnd; 2707198092Srdivacky ++Redecl) { 2708234353Sdim if (RedeclForcesDefC99(*Redecl)) 2709234353Sdim return true; 2710198092Srdivacky } 2711198092Srdivacky 2712198092Srdivacky // C99 6.7.4p6: 2713198092Srdivacky // An inline definition does not provide an external definition for the 2714198092Srdivacky // function, and does not forbid an external definition in another 2715198092Srdivacky // translation unit. 2716193326Sed return false; 2717193326Sed} 2718193326Sed 2719193326Sed/// getOverloadedOperator - Which C++ overloaded operator this 2720193326Sed/// function represents, if any. 2721193326SedOverloadedOperatorKind FunctionDecl::getOverloadedOperator() const { 2722193326Sed if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName) 2723193326Sed return getDeclName().getCXXOverloadedOperator(); 2724193326Sed else 2725193326Sed return OO_None; 2726193326Sed} 2727193326Sed 2728202379Srdivacky/// getLiteralIdentifier - The literal suffix identifier this function 2729202379Srdivacky/// represents, if any. 2730202379Srdivackyconst IdentifierInfo *FunctionDecl::getLiteralIdentifier() const { 2731202379Srdivacky if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName) 2732202379Srdivacky return getDeclName().getCXXLiteralIdentifier(); 2733202379Srdivacky else 2734202379Srdivacky return 0; 2735202379Srdivacky} 2736202379Srdivacky 2737210299SedFunctionDecl::TemplatedKind FunctionDecl::getTemplatedKind() const { 2738210299Sed if (TemplateOrSpecialization.isNull()) 2739210299Sed return TK_NonTemplate; 2740210299Sed if (TemplateOrSpecialization.is<FunctionTemplateDecl *>()) 2741210299Sed return TK_FunctionTemplate; 2742210299Sed if (TemplateOrSpecialization.is<MemberSpecializationInfo *>()) 2743210299Sed return TK_MemberSpecialization; 2744210299Sed if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>()) 2745210299Sed return TK_FunctionTemplateSpecialization; 2746210299Sed if (TemplateOrSpecialization.is 2747210299Sed <DependentFunctionTemplateSpecializationInfo*>()) 2748210299Sed return TK_DependentFunctionTemplateSpecialization; 2749210299Sed 2750226633Sdim llvm_unreachable("Did we miss a TemplateOrSpecialization type?"); 2751210299Sed} 2752210299Sed 2753198092SrdivackyFunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const { 2754198092Srdivacky if (MemberSpecializationInfo *Info = getMemberSpecializationInfo()) 2755198092Srdivacky return cast<FunctionDecl>(Info->getInstantiatedFrom()); 2756198092Srdivacky 2757198092Srdivacky return 0; 2758198092Srdivacky} 2759198092Srdivacky 2760198092Srdivackyvoid 2761218893SdimFunctionDecl::setInstantiationOfMemberFunction(ASTContext &C, 2762218893Sdim FunctionDecl *FD, 2763198092Srdivacky TemplateSpecializationKind TSK) { 2764198092Srdivacky assert(TemplateOrSpecialization.isNull() && 2765198092Srdivacky "Member function is already a specialization"); 2766198092Srdivacky MemberSpecializationInfo *Info 2767218893Sdim = new (C) MemberSpecializationInfo(FD, TSK); 2768198092Srdivacky TemplateOrSpecialization = Info; 2769198092Srdivacky} 2770198092Srdivacky 2771198893Srdivackybool FunctionDecl::isImplicitlyInstantiable() const { 2772208600Srdivacky // If the function is invalid, it can't be implicitly instantiated. 2773208600Srdivacky if (isInvalidDecl()) 2774198893Srdivacky return false; 2775198893Srdivacky 2776198893Srdivacky switch (getTemplateSpecializationKind()) { 2777198893Srdivacky case TSK_Undeclared: 2778198893Srdivacky case TSK_ExplicitInstantiationDefinition: 2779198893Srdivacky return false; 2780198893Srdivacky 2781198893Srdivacky case TSK_ImplicitInstantiation: 2782198893Srdivacky return true; 2783198893Srdivacky 2784226633Sdim // It is possible to instantiate TSK_ExplicitSpecialization kind 2785226633Sdim // if the FunctionDecl has a class scope specialization pattern. 2786226633Sdim case TSK_ExplicitSpecialization: 2787226633Sdim return getClassScopeSpecializationPattern() != 0; 2788226633Sdim 2789198893Srdivacky case TSK_ExplicitInstantiationDeclaration: 2790198893Srdivacky // Handled below. 2791198893Srdivacky break; 2792198893Srdivacky } 2793198893Srdivacky 2794198893Srdivacky // Find the actual template from which we will instantiate. 2795198893Srdivacky const FunctionDecl *PatternDecl = getTemplateInstantiationPattern(); 2796210299Sed bool HasPattern = false; 2797198893Srdivacky if (PatternDecl) 2798210299Sed HasPattern = PatternDecl->hasBody(PatternDecl); 2799198893Srdivacky 2800198893Srdivacky // C++0x [temp.explicit]p9: 2801198893Srdivacky // Except for inline functions, other explicit instantiation declarations 2802198893Srdivacky // have the effect of suppressing the implicit instantiation of the entity 2803198893Srdivacky // to which they refer. 2804210299Sed if (!HasPattern || !PatternDecl) 2805198893Srdivacky return true; 2806198893Srdivacky 2807198893Srdivacky return PatternDecl->isInlined(); 2808234353Sdim} 2809234353Sdim 2810234353Sdimbool FunctionDecl::isTemplateInstantiation() const { 2811234353Sdim switch (getTemplateSpecializationKind()) { 2812234353Sdim case TSK_Undeclared: 2813234353Sdim case TSK_ExplicitSpecialization: 2814234353Sdim return false; 2815234353Sdim case TSK_ImplicitInstantiation: 2816234353Sdim case TSK_ExplicitInstantiationDeclaration: 2817234353Sdim case TSK_ExplicitInstantiationDefinition: 2818234353Sdim return true; 2819234353Sdim } 2820234353Sdim llvm_unreachable("All TSK values handled."); 2821234353Sdim} 2822198893Srdivacky 2823198893SrdivackyFunctionDecl *FunctionDecl::getTemplateInstantiationPattern() const { 2824226633Sdim // Handle class scope explicit specialization special case. 2825226633Sdim if (getTemplateSpecializationKind() == TSK_ExplicitSpecialization) 2826226633Sdim return getClassScopeSpecializationPattern(); 2827226633Sdim 2828198893Srdivacky if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) { 2829198893Srdivacky while (Primary->getInstantiatedFromMemberTemplate()) { 2830198893Srdivacky // If we have hit a point where the user provided a specialization of 2831198893Srdivacky // this template, we're done looking. 2832198893Srdivacky if (Primary->isMemberSpecialization()) 2833198893Srdivacky break; 2834198893Srdivacky 2835198893Srdivacky Primary = Primary->getInstantiatedFromMemberTemplate(); 2836198893Srdivacky } 2837198893Srdivacky 2838198893Srdivacky return Primary->getTemplatedDecl(); 2839198893Srdivacky } 2840198893Srdivacky 2841198893Srdivacky return getInstantiatedFromMemberFunction(); 2842198893Srdivacky} 2843198893Srdivacky 2844195341SedFunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const { 2845198092Srdivacky if (FunctionTemplateSpecializationInfo *Info 2846195341Sed = TemplateOrSpecialization 2847195341Sed .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 2848195341Sed return Info->Template.getPointer(); 2849195341Sed } 2850195341Sed return 0; 2851195341Sed} 2852195341Sed 2853226633SdimFunctionDecl *FunctionDecl::getClassScopeSpecializationPattern() const { 2854226633Sdim return getASTContext().getClassScopeSpecializationPattern(this); 2855226633Sdim} 2856226633Sdim 2857195341Sedconst TemplateArgumentList * 2858195341SedFunctionDecl::getTemplateSpecializationArgs() const { 2859198092Srdivacky if (FunctionTemplateSpecializationInfo *Info 2860198092Srdivacky = TemplateOrSpecialization 2861198092Srdivacky .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 2862195341Sed return Info->TemplateArguments; 2863195341Sed } 2864195341Sed return 0; 2865195341Sed} 2866195341Sed 2867226633Sdimconst ASTTemplateArgumentListInfo * 2868208600SrdivackyFunctionDecl::getTemplateSpecializationArgsAsWritten() const { 2869208600Srdivacky if (FunctionTemplateSpecializationInfo *Info 2870208600Srdivacky = TemplateOrSpecialization 2871208600Srdivacky .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 2872208600Srdivacky return Info->TemplateArgumentsAsWritten; 2873208600Srdivacky } 2874208600Srdivacky return 0; 2875208600Srdivacky} 2876208600Srdivacky 2877198092Srdivackyvoid 2878218893SdimFunctionDecl::setFunctionTemplateSpecialization(ASTContext &C, 2879218893Sdim FunctionTemplateDecl *Template, 2880195341Sed const TemplateArgumentList *TemplateArgs, 2881198092Srdivacky void *InsertPos, 2882208600Srdivacky TemplateSpecializationKind TSK, 2883210299Sed const TemplateArgumentListInfo *TemplateArgsAsWritten, 2884210299Sed SourceLocation PointOfInstantiation) { 2885198092Srdivacky assert(TSK != TSK_Undeclared && 2886198092Srdivacky "Must specify the type of function template specialization"); 2887198092Srdivacky FunctionTemplateSpecializationInfo *Info 2888195341Sed = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>(); 2889195099Sed if (!Info) 2890218893Sdim Info = FunctionTemplateSpecializationInfo::Create(C, this, Template, TSK, 2891218893Sdim TemplateArgs, 2892218893Sdim TemplateArgsAsWritten, 2893218893Sdim PointOfInstantiation); 2894195099Sed TemplateOrSpecialization = Info; 2895234353Sdim Template->addSpecialization(Info, InsertPos); 2896195099Sed} 2897195099Sed 2898207619Srdivackyvoid 2899207619SrdivackyFunctionDecl::setDependentTemplateSpecialization(ASTContext &Context, 2900207619Srdivacky const UnresolvedSetImpl &Templates, 2901207619Srdivacky const TemplateArgumentListInfo &TemplateArgs) { 2902207619Srdivacky assert(TemplateOrSpecialization.isNull()); 2903207619Srdivacky size_t Size = sizeof(DependentFunctionTemplateSpecializationInfo); 2904207619Srdivacky Size += Templates.size() * sizeof(FunctionTemplateDecl*); 2905207619Srdivacky Size += TemplateArgs.size() * sizeof(TemplateArgumentLoc); 2906207619Srdivacky void *Buffer = Context.Allocate(Size); 2907207619Srdivacky DependentFunctionTemplateSpecializationInfo *Info = 2908207619Srdivacky new (Buffer) DependentFunctionTemplateSpecializationInfo(Templates, 2909207619Srdivacky TemplateArgs); 2910207619Srdivacky TemplateOrSpecialization = Info; 2911207619Srdivacky} 2912207619Srdivacky 2913207619SrdivackyDependentFunctionTemplateSpecializationInfo:: 2914207619SrdivackyDependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts, 2915207619Srdivacky const TemplateArgumentListInfo &TArgs) 2916207619Srdivacky : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) { 2917207619Srdivacky 2918207619Srdivacky d.NumTemplates = Ts.size(); 2919207619Srdivacky d.NumArgs = TArgs.size(); 2920207619Srdivacky 2921207619Srdivacky FunctionTemplateDecl **TsArray = 2922207619Srdivacky const_cast<FunctionTemplateDecl**>(getTemplates()); 2923207619Srdivacky for (unsigned I = 0, E = Ts.size(); I != E; ++I) 2924207619Srdivacky TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl()); 2925207619Srdivacky 2926207619Srdivacky TemplateArgumentLoc *ArgsArray = 2927207619Srdivacky const_cast<TemplateArgumentLoc*>(getTemplateArgs()); 2928207619Srdivacky for (unsigned I = 0, E = TArgs.size(); I != E; ++I) 2929207619Srdivacky new (&ArgsArray[I]) TemplateArgumentLoc(TArgs[I]); 2930207619Srdivacky} 2931207619Srdivacky 2932198092SrdivackyTemplateSpecializationKind FunctionDecl::getTemplateSpecializationKind() const { 2933198092Srdivacky // For a function template specialization, query the specialization 2934198092Srdivacky // information object. 2935198092Srdivacky FunctionTemplateSpecializationInfo *FTSInfo 2936195341Sed = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>(); 2937198092Srdivacky if (FTSInfo) 2938198092Srdivacky return FTSInfo->getTemplateSpecializationKind(); 2939198092Srdivacky 2940198092Srdivacky MemberSpecializationInfo *MSInfo 2941198092Srdivacky = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>(); 2942198092Srdivacky if (MSInfo) 2943198092Srdivacky return MSInfo->getTemplateSpecializationKind(); 2944195341Sed 2945198092Srdivacky return TSK_Undeclared; 2946195341Sed} 2947195341Sed 2948198092Srdivackyvoid 2949198398SrdivackyFunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 2950198398Srdivacky SourceLocation PointOfInstantiation) { 2951198092Srdivacky if (FunctionTemplateSpecializationInfo *FTSInfo 2952198092Srdivacky = TemplateOrSpecialization.dyn_cast< 2953198398Srdivacky FunctionTemplateSpecializationInfo*>()) { 2954198092Srdivacky FTSInfo->setTemplateSpecializationKind(TSK); 2955198398Srdivacky if (TSK != TSK_ExplicitSpecialization && 2956198398Srdivacky PointOfInstantiation.isValid() && 2957198398Srdivacky FTSInfo->getPointOfInstantiation().isInvalid()) 2958198398Srdivacky FTSInfo->setPointOfInstantiation(PointOfInstantiation); 2959198398Srdivacky } else if (MemberSpecializationInfo *MSInfo 2960198398Srdivacky = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) { 2961198092Srdivacky MSInfo->setTemplateSpecializationKind(TSK); 2962198398Srdivacky if (TSK != TSK_ExplicitSpecialization && 2963198398Srdivacky PointOfInstantiation.isValid() && 2964198398Srdivacky MSInfo->getPointOfInstantiation().isInvalid()) 2965198398Srdivacky MSInfo->setPointOfInstantiation(PointOfInstantiation); 2966198398Srdivacky } else 2967226633Sdim llvm_unreachable("Function cannot have a template specialization kind"); 2968195341Sed} 2969195341Sed 2970198398SrdivackySourceLocation FunctionDecl::getPointOfInstantiation() const { 2971198398Srdivacky if (FunctionTemplateSpecializationInfo *FTSInfo 2972198398Srdivacky = TemplateOrSpecialization.dyn_cast< 2973198398Srdivacky FunctionTemplateSpecializationInfo*>()) 2974198398Srdivacky return FTSInfo->getPointOfInstantiation(); 2975198398Srdivacky else if (MemberSpecializationInfo *MSInfo 2976198398Srdivacky = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) 2977198398Srdivacky return MSInfo->getPointOfInstantiation(); 2978198398Srdivacky 2979198398Srdivacky return SourceLocation(); 2980198398Srdivacky} 2981198398Srdivacky 2982198092Srdivackybool FunctionDecl::isOutOfLine() const { 2983198092Srdivacky if (Decl::isOutOfLine()) 2984198092Srdivacky return true; 2985198092Srdivacky 2986198092Srdivacky // If this function was instantiated from a member function of a 2987198092Srdivacky // class template, check whether that member function was defined out-of-line. 2988198092Srdivacky if (FunctionDecl *FD = getInstantiatedFromMemberFunction()) { 2989198092Srdivacky const FunctionDecl *Definition; 2990210299Sed if (FD->hasBody(Definition)) 2991198092Srdivacky return Definition->isOutOfLine(); 2992198092Srdivacky } 2993198092Srdivacky 2994198092Srdivacky // If this function was instantiated from a function template, 2995198092Srdivacky // check whether that function template was defined out-of-line. 2996198092Srdivacky if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) { 2997198092Srdivacky const FunctionDecl *Definition; 2998210299Sed if (FunTmpl->getTemplatedDecl()->hasBody(Definition)) 2999198092Srdivacky return Definition->isOutOfLine(); 3000198092Srdivacky } 3001198092Srdivacky 3002198092Srdivacky return false; 3003198092Srdivacky} 3004198092Srdivacky 3005221345SdimSourceRange FunctionDecl::getSourceRange() const { 3006221345Sdim return SourceRange(getOuterLocStart(), EndRangeLoc); 3007221345Sdim} 3008221345Sdim 3009234353Sdimunsigned FunctionDecl::getMemoryFunctionKind() const { 3010234353Sdim IdentifierInfo *FnInfo = getIdentifier(); 3011234353Sdim 3012234353Sdim if (!FnInfo) 3013234353Sdim return 0; 3014234353Sdim 3015234353Sdim // Builtin handling. 3016234353Sdim switch (getBuiltinID()) { 3017234353Sdim case Builtin::BI__builtin_memset: 3018234353Sdim case Builtin::BI__builtin___memset_chk: 3019234353Sdim case Builtin::BImemset: 3020234353Sdim return Builtin::BImemset; 3021234353Sdim 3022234353Sdim case Builtin::BI__builtin_memcpy: 3023234353Sdim case Builtin::BI__builtin___memcpy_chk: 3024234353Sdim case Builtin::BImemcpy: 3025234353Sdim return Builtin::BImemcpy; 3026234353Sdim 3027234353Sdim case Builtin::BI__builtin_memmove: 3028234353Sdim case Builtin::BI__builtin___memmove_chk: 3029234353Sdim case Builtin::BImemmove: 3030234353Sdim return Builtin::BImemmove; 3031234353Sdim 3032234353Sdim case Builtin::BIstrlcpy: 3033234353Sdim return Builtin::BIstrlcpy; 3034234353Sdim case Builtin::BIstrlcat: 3035234353Sdim return Builtin::BIstrlcat; 3036234353Sdim 3037234353Sdim case Builtin::BI__builtin_memcmp: 3038234353Sdim case Builtin::BImemcmp: 3039234353Sdim return Builtin::BImemcmp; 3040234353Sdim 3041234353Sdim case Builtin::BI__builtin_strncpy: 3042234353Sdim case Builtin::BI__builtin___strncpy_chk: 3043234353Sdim case Builtin::BIstrncpy: 3044234353Sdim return Builtin::BIstrncpy; 3045234353Sdim 3046234353Sdim case Builtin::BI__builtin_strncmp: 3047234353Sdim case Builtin::BIstrncmp: 3048234353Sdim return Builtin::BIstrncmp; 3049234353Sdim 3050234353Sdim case Builtin::BI__builtin_strncasecmp: 3051234353Sdim case Builtin::BIstrncasecmp: 3052234353Sdim return Builtin::BIstrncasecmp; 3053234353Sdim 3054234353Sdim case Builtin::BI__builtin_strncat: 3055234353Sdim case Builtin::BI__builtin___strncat_chk: 3056234353Sdim case Builtin::BIstrncat: 3057234353Sdim return Builtin::BIstrncat; 3058234353Sdim 3059234353Sdim case Builtin::BI__builtin_strndup: 3060234353Sdim case Builtin::BIstrndup: 3061234353Sdim return Builtin::BIstrndup; 3062234353Sdim 3063234353Sdim case Builtin::BI__builtin_strlen: 3064234353Sdim case Builtin::BIstrlen: 3065234353Sdim return Builtin::BIstrlen; 3066234353Sdim 3067234353Sdim default: 3068234353Sdim if (isExternC()) { 3069234353Sdim if (FnInfo->isStr("memset")) 3070234353Sdim return Builtin::BImemset; 3071234353Sdim else if (FnInfo->isStr("memcpy")) 3072234353Sdim return Builtin::BImemcpy; 3073234353Sdim else if (FnInfo->isStr("memmove")) 3074234353Sdim return Builtin::BImemmove; 3075234353Sdim else if (FnInfo->isStr("memcmp")) 3076234353Sdim return Builtin::BImemcmp; 3077234353Sdim else if (FnInfo->isStr("strncpy")) 3078234353Sdim return Builtin::BIstrncpy; 3079234353Sdim else if (FnInfo->isStr("strncmp")) 3080234353Sdim return Builtin::BIstrncmp; 3081234353Sdim else if (FnInfo->isStr("strncasecmp")) 3082234353Sdim return Builtin::BIstrncasecmp; 3083234353Sdim else if (FnInfo->isStr("strncat")) 3084234353Sdim return Builtin::BIstrncat; 3085234353Sdim else if (FnInfo->isStr("strndup")) 3086234353Sdim return Builtin::BIstrndup; 3087234353Sdim else if (FnInfo->isStr("strlen")) 3088234353Sdim return Builtin::BIstrlen; 3089234353Sdim } 3090234353Sdim break; 3091234353Sdim } 3092234353Sdim return 0; 3093234353Sdim} 3094234353Sdim 3095193326Sed//===----------------------------------------------------------------------===// 3096203955Srdivacky// FieldDecl Implementation 3097203955Srdivacky//===----------------------------------------------------------------------===// 3098203955Srdivacky 3099218893SdimFieldDecl *FieldDecl::Create(const ASTContext &C, DeclContext *DC, 3100221345Sdim SourceLocation StartLoc, SourceLocation IdLoc, 3101221345Sdim IdentifierInfo *Id, QualType T, 3102223017Sdim TypeSourceInfo *TInfo, Expr *BW, bool Mutable, 3103239462Sdim InClassInitStyle InitStyle) { 3104221345Sdim return new (C) FieldDecl(Decl::Field, DC, StartLoc, IdLoc, Id, T, TInfo, 3105239462Sdim BW, Mutable, InitStyle); 3106203955Srdivacky} 3107203955Srdivacky 3108234353SdimFieldDecl *FieldDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3109234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FieldDecl)); 3110234353Sdim return new (Mem) FieldDecl(Field, 0, SourceLocation(), SourceLocation(), 3111239462Sdim 0, QualType(), 0, 0, false, ICIS_NoInit); 3112234353Sdim} 3113234353Sdim 3114203955Srdivackybool FieldDecl::isAnonymousStructOrUnion() const { 3115203955Srdivacky if (!isImplicit() || getDeclName()) 3116203955Srdivacky return false; 3117203955Srdivacky 3118203955Srdivacky if (const RecordType *Record = getType()->getAs<RecordType>()) 3119203955Srdivacky return Record->getDecl()->isAnonymousStructOrUnion(); 3120203955Srdivacky 3121203955Srdivacky return false; 3122203955Srdivacky} 3123203955Srdivacky 3124226633Sdimunsigned FieldDecl::getBitWidthValue(const ASTContext &Ctx) const { 3125226633Sdim assert(isBitField() && "not a bitfield"); 3126226633Sdim Expr *BitWidth = InitializerOrBitWidth.getPointer(); 3127226633Sdim return BitWidth->EvaluateKnownConstInt(Ctx).getZExtValue(); 3128226633Sdim} 3129226633Sdim 3130218893Sdimunsigned FieldDecl::getFieldIndex() const { 3131263508Sdim const FieldDecl *Canonical = getCanonicalDecl(); 3132263508Sdim if (Canonical != this) 3133263508Sdim return Canonical->getFieldIndex(); 3134263508Sdim 3135218893Sdim if (CachedFieldIndex) return CachedFieldIndex - 1; 3136218893Sdim 3137234353Sdim unsigned Index = 0; 3138221345Sdim const RecordDecl *RD = getParent(); 3139218893Sdim 3140234353Sdim for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end(); 3141263508Sdim I != E; ++I, ++Index) 3142263508Sdim I->getCanonicalDecl()->CachedFieldIndex = Index + 1; 3143234353Sdim 3144234353Sdim assert(CachedFieldIndex && "failed to find field in parent"); 3145234353Sdim return CachedFieldIndex - 1; 3146218893Sdim} 3147218893Sdim 3148221345SdimSourceRange FieldDecl::getSourceRange() const { 3149226633Sdim if (const Expr *E = InitializerOrBitWidth.getPointer()) 3150226633Sdim return SourceRange(getInnerLocStart(), E->getLocEnd()); 3151221345Sdim return DeclaratorDecl::getSourceRange(); 3152221345Sdim} 3153221345Sdim 3154239462Sdimvoid FieldDecl::setBitWidth(Expr *Width) { 3155239462Sdim assert(!InitializerOrBitWidth.getPointer() && !hasInClassInitializer() && 3156239462Sdim "bit width or initializer already set"); 3157239462Sdim InitializerOrBitWidth.setPointer(Width); 3158239462Sdim} 3159239462Sdim 3160223017Sdimvoid FieldDecl::setInClassInitializer(Expr *Init) { 3161239462Sdim assert(!InitializerOrBitWidth.getPointer() && hasInClassInitializer() && 3162223017Sdim "bit width or initializer already set"); 3163223017Sdim InitializerOrBitWidth.setPointer(Init); 3164223017Sdim} 3165223017Sdim 3166203955Srdivacky//===----------------------------------------------------------------------===// 3167193326Sed// TagDecl Implementation 3168193326Sed//===----------------------------------------------------------------------===// 3169193326Sed 3170210299SedSourceLocation TagDecl::getOuterLocStart() const { 3171210299Sed return getTemplateOrInnerLocStart(this); 3172210299Sed} 3173210299Sed 3174198092SrdivackySourceRange TagDecl::getSourceRange() const { 3175198092Srdivacky SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation(); 3176210299Sed return SourceRange(getOuterLocStart(), E); 3177198092Srdivacky} 3178198092Srdivacky 3179263508SdimTagDecl *TagDecl::getCanonicalDecl() { return getFirstDecl(); } 3180198092Srdivacky 3181249423Sdimvoid TagDecl::setTypedefNameForAnonDecl(TypedefNameDecl *TDD) { 3182263508Sdim NamedDeclOrQualifier = TDD; 3183208600Srdivacky if (TypeForDecl) 3184249423Sdim assert(TypeForDecl->isLinkageValid()); 3185249423Sdim assert(isLinkageValid()); 3186208600Srdivacky} 3187208600Srdivacky 3188193326Sedvoid TagDecl::startDefinition() { 3189212904Sdim IsBeingDefined = true; 3190203955Srdivacky 3191249423Sdim if (CXXRecordDecl *D = dyn_cast<CXXRecordDecl>(this)) { 3192203955Srdivacky struct CXXRecordDecl::DefinitionData *Data = 3193203955Srdivacky new (getASTContext()) struct CXXRecordDecl::DefinitionData(D); 3194206084Srdivacky for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) 3195206084Srdivacky cast<CXXRecordDecl>(*I)->DefinitionData = Data; 3196203955Srdivacky } 3197193326Sed} 3198193326Sed 3199193326Sedvoid TagDecl::completeDefinition() { 3200203955Srdivacky assert((!isa<CXXRecordDecl>(this) || 3201203955Srdivacky cast<CXXRecordDecl>(this)->hasDefinition()) && 3202203955Srdivacky "definition completed but not started"); 3203203955Srdivacky 3204226633Sdim IsCompleteDefinition = true; 3205212904Sdim IsBeingDefined = false; 3206218893Sdim 3207218893Sdim if (ASTMutationListener *L = getASTMutationListener()) 3208218893Sdim L->CompletedTagDefinition(this); 3209193326Sed} 3210193326Sed 3211226633SdimTagDecl *TagDecl::getDefinition() const { 3212226633Sdim if (isCompleteDefinition()) 3213198092Srdivacky return const_cast<TagDecl *>(this); 3214249423Sdim 3215249423Sdim // If it's possible for us to have an out-of-date definition, check now. 3216249423Sdim if (MayHaveOutOfDateDef) { 3217249423Sdim if (IdentifierInfo *II = getIdentifier()) { 3218249423Sdim if (II->isOutOfDate()) { 3219249423Sdim updateOutOfDate(*II); 3220249423Sdim } 3221249423Sdim } 3222249423Sdim } 3223249423Sdim 3224218893Sdim if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(this)) 3225218893Sdim return CXXRD->getDefinition(); 3226198092Srdivacky 3227198092Srdivacky for (redecl_iterator R = redecls_begin(), REnd = redecls_end(); 3228198092Srdivacky R != REnd; ++R) 3229226633Sdim if (R->isCompleteDefinition()) 3230198092Srdivacky return *R; 3231198092Srdivacky 3232198092Srdivacky return 0; 3233193326Sed} 3234193326Sed 3235219077Sdimvoid TagDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) { 3236219077Sdim if (QualifierLoc) { 3237205219Srdivacky // Make sure the extended qualifier info is allocated. 3238205219Srdivacky if (!hasExtInfo()) 3239263508Sdim NamedDeclOrQualifier = new (getASTContext()) ExtInfo; 3240205219Srdivacky // Set qualifier info. 3241219077Sdim getExtInfo()->QualifierLoc = QualifierLoc; 3242226633Sdim } else { 3243205219Srdivacky // Here Qualifier == 0, i.e., we are removing the qualifier (if any). 3244205219Srdivacky if (hasExtInfo()) { 3245221345Sdim if (getExtInfo()->NumTemplParamLists == 0) { 3246221345Sdim getASTContext().Deallocate(getExtInfo()); 3247263508Sdim NamedDeclOrQualifier = (TypedefNameDecl*) 0; 3248221345Sdim } 3249221345Sdim else 3250221345Sdim getExtInfo()->QualifierLoc = QualifierLoc; 3251205219Srdivacky } 3252205219Srdivacky } 3253205219Srdivacky} 3254205219Srdivacky 3255221345Sdimvoid TagDecl::setTemplateParameterListsInfo(ASTContext &Context, 3256221345Sdim unsigned NumTPLists, 3257221345Sdim TemplateParameterList **TPLists) { 3258221345Sdim assert(NumTPLists > 0); 3259221345Sdim // Make sure the extended decl info is allocated. 3260221345Sdim if (!hasExtInfo()) 3261221345Sdim // Allocate external info struct. 3262263508Sdim NamedDeclOrQualifier = new (getASTContext()) ExtInfo; 3263221345Sdim // Set the template parameter lists info. 3264221345Sdim getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists); 3265221345Sdim} 3266221345Sdim 3267193326Sed//===----------------------------------------------------------------------===// 3268203955Srdivacky// EnumDecl Implementation 3269203955Srdivacky//===----------------------------------------------------------------------===// 3270203955Srdivacky 3271234353Sdimvoid EnumDecl::anchor() { } 3272234353Sdim 3273221345SdimEnumDecl *EnumDecl::Create(ASTContext &C, DeclContext *DC, 3274221345Sdim SourceLocation StartLoc, SourceLocation IdLoc, 3275221345Sdim IdentifierInfo *Id, 3276218893Sdim EnumDecl *PrevDecl, bool IsScoped, 3277218893Sdim bool IsScopedUsingClassTag, bool IsFixed) { 3278221345Sdim EnumDecl *Enum = new (C) EnumDecl(DC, StartLoc, IdLoc, Id, PrevDecl, 3279218893Sdim IsScoped, IsScopedUsingClassTag, IsFixed); 3280249423Sdim Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3281203955Srdivacky C.getTypeDeclType(Enum, PrevDecl); 3282203955Srdivacky return Enum; 3283203955Srdivacky} 3284203955Srdivacky 3285234353SdimEnumDecl *EnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3286234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(EnumDecl)); 3287249423Sdim EnumDecl *Enum = new (Mem) EnumDecl(0, SourceLocation(), SourceLocation(), 3288249423Sdim 0, 0, false, false, false); 3289249423Sdim Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3290249423Sdim return Enum; 3291210299Sed} 3292210299Sed 3293203955Srdivackyvoid EnumDecl::completeDefinition(QualType NewType, 3294208600Srdivacky QualType NewPromotionType, 3295208600Srdivacky unsigned NumPositiveBits, 3296208600Srdivacky unsigned NumNegativeBits) { 3297226633Sdim assert(!isCompleteDefinition() && "Cannot redefine enums!"); 3298218893Sdim if (!IntegerType) 3299218893Sdim IntegerType = NewType.getTypePtr(); 3300203955Srdivacky PromotionType = NewPromotionType; 3301208600Srdivacky setNumPositiveBits(NumPositiveBits); 3302208600Srdivacky setNumNegativeBits(NumNegativeBits); 3303203955Srdivacky TagDecl::completeDefinition(); 3304203955Srdivacky} 3305203955Srdivacky 3306234353SdimTemplateSpecializationKind EnumDecl::getTemplateSpecializationKind() const { 3307234353Sdim if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 3308234353Sdim return MSI->getTemplateSpecializationKind(); 3309234353Sdim 3310234353Sdim return TSK_Undeclared; 3311234353Sdim} 3312234353Sdim 3313234353Sdimvoid EnumDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 3314234353Sdim SourceLocation PointOfInstantiation) { 3315234353Sdim MemberSpecializationInfo *MSI = getMemberSpecializationInfo(); 3316234353Sdim assert(MSI && "Not an instantiated member enumeration?"); 3317234353Sdim MSI->setTemplateSpecializationKind(TSK); 3318234353Sdim if (TSK != TSK_ExplicitSpecialization && 3319234353Sdim PointOfInstantiation.isValid() && 3320234353Sdim MSI->getPointOfInstantiation().isInvalid()) 3321234353Sdim MSI->setPointOfInstantiation(PointOfInstantiation); 3322234353Sdim} 3323234353Sdim 3324234353SdimEnumDecl *EnumDecl::getInstantiatedFromMemberEnum() const { 3325234353Sdim if (SpecializationInfo) 3326234353Sdim return cast<EnumDecl>(SpecializationInfo->getInstantiatedFrom()); 3327234353Sdim 3328234353Sdim return 0; 3329234353Sdim} 3330234353Sdim 3331234353Sdimvoid EnumDecl::setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED, 3332234353Sdim TemplateSpecializationKind TSK) { 3333234353Sdim assert(!SpecializationInfo && "Member enum is already a specialization"); 3334234353Sdim SpecializationInfo = new (C) MemberSpecializationInfo(ED, TSK); 3335234353Sdim} 3336234353Sdim 3337203955Srdivacky//===----------------------------------------------------------------------===// 3338193326Sed// RecordDecl Implementation 3339193326Sed//===----------------------------------------------------------------------===// 3340193326Sed 3341221345SdimRecordDecl::RecordDecl(Kind DK, TagKind TK, DeclContext *DC, 3342221345Sdim SourceLocation StartLoc, SourceLocation IdLoc, 3343221345Sdim IdentifierInfo *Id, RecordDecl *PrevDecl) 3344221345Sdim : TagDecl(DK, TK, DC, IdLoc, Id, PrevDecl, StartLoc) { 3345193326Sed HasFlexibleArrayMember = false; 3346193326Sed AnonymousStructOrUnion = false; 3347198092Srdivacky HasObjectMember = false; 3348249423Sdim HasVolatileMember = false; 3349218893Sdim LoadedFieldsFromExternalStorage = false; 3350193326Sed assert(classof(static_cast<Decl*>(this)) && "Invalid Kind!"); 3351193326Sed} 3352193326Sed 3353218893SdimRecordDecl *RecordDecl::Create(const ASTContext &C, TagKind TK, DeclContext *DC, 3354221345Sdim SourceLocation StartLoc, SourceLocation IdLoc, 3355221345Sdim IdentifierInfo *Id, RecordDecl* PrevDecl) { 3356221345Sdim RecordDecl* R = new (C) RecordDecl(Record, TK, DC, StartLoc, IdLoc, Id, 3357221345Sdim PrevDecl); 3358249423Sdim R->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3359249423Sdim 3360193326Sed C.getTypeDeclType(R, PrevDecl); 3361193326Sed return R; 3362193326Sed} 3363193326Sed 3364234353SdimRecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) { 3365234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(RecordDecl)); 3366249423Sdim RecordDecl *R = new (Mem) RecordDecl(Record, TTK_Struct, 0, SourceLocation(), 3367249423Sdim SourceLocation(), 0, 0); 3368249423Sdim R->MayHaveOutOfDateDef = C.getLangOpts().Modules; 3369249423Sdim return R; 3370210299Sed} 3371210299Sed 3372193326Sedbool RecordDecl::isInjectedClassName() const { 3373198092Srdivacky return isImplicit() && getDeclName() && getDeclContext()->isRecord() && 3374193326Sed cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName(); 3375193326Sed} 3376193326Sed 3377218893SdimRecordDecl::field_iterator RecordDecl::field_begin() const { 3378218893Sdim if (hasExternalLexicalStorage() && !LoadedFieldsFromExternalStorage) 3379218893Sdim LoadFieldsFromExternalStorage(); 3380218893Sdim 3381218893Sdim return field_iterator(decl_iterator(FirstDecl)); 3382218893Sdim} 3383218893Sdim 3384193326Sed/// completeDefinition - Notes that the definition of this type is now 3385193326Sed/// complete. 3386203955Srdivackyvoid RecordDecl::completeDefinition() { 3387226633Sdim assert(!isCompleteDefinition() && "Cannot redefine record!"); 3388193326Sed TagDecl::completeDefinition(); 3389193326Sed} 3390193326Sed 3391243830Sdim/// isMsStruct - Get whether or not this record uses ms_struct layout. 3392243830Sdim/// This which can be turned on with an attribute, pragma, or the 3393243830Sdim/// -mms-bitfields command-line option. 3394243830Sdimbool RecordDecl::isMsStruct(const ASTContext &C) const { 3395243830Sdim return hasAttr<MsStructAttr>() || C.getLangOpts().MSBitfields == 1; 3396243830Sdim} 3397243830Sdim 3398243830Sdimstatic bool isFieldOrIndirectField(Decl::Kind K) { 3399243830Sdim return FieldDecl::classofKind(K) || IndirectFieldDecl::classofKind(K); 3400243830Sdim} 3401243830Sdim 3402218893Sdimvoid RecordDecl::LoadFieldsFromExternalStorage() const { 3403218893Sdim ExternalASTSource *Source = getASTContext().getExternalSource(); 3404218893Sdim assert(hasExternalLexicalStorage() && Source && "No external storage?"); 3405208600Srdivacky 3406218893Sdim // Notify that we have a RecordDecl doing some initialization. 3407218893Sdim ExternalASTSource::Deserializing TheFields(Source); 3408218893Sdim 3409226633Sdim SmallVector<Decl*, 64> Decls; 3410224145Sdim LoadedFieldsFromExternalStorage = true; 3411243830Sdim switch (Source->FindExternalLexicalDecls(this, isFieldOrIndirectField, 3412243830Sdim Decls)) { 3413224145Sdim case ELR_Success: 3414224145Sdim break; 3415224145Sdim 3416224145Sdim case ELR_AlreadyLoaded: 3417224145Sdim case ELR_Failure: 3418218893Sdim return; 3419224145Sdim } 3420218893Sdim 3421218893Sdim#ifndef NDEBUG 3422218893Sdim // Check that all decls we got were FieldDecls. 3423218893Sdim for (unsigned i=0, e=Decls.size(); i != e; ++i) 3424243830Sdim assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i])); 3425218893Sdim#endif 3426218893Sdim 3427218893Sdim if (Decls.empty()) 3428218893Sdim return; 3429218893Sdim 3430226633Sdim llvm::tie(FirstDecl, LastDecl) = BuildDeclChain(Decls, 3431226633Sdim /*FieldsAlreadyLoaded=*/false); 3432208600Srdivacky} 3433208600Srdivacky 3434193326Sed//===----------------------------------------------------------------------===// 3435193326Sed// BlockDecl Implementation 3436193326Sed//===----------------------------------------------------------------------===// 3437193326Sed 3438249423Sdimvoid BlockDecl::setParams(ArrayRef<ParmVarDecl *> NewParamInfo) { 3439193326Sed assert(ParamInfo == 0 && "Already has param info!"); 3440198092Srdivacky 3441193326Sed // Zero params -> null pointer. 3442226633Sdim if (!NewParamInfo.empty()) { 3443226633Sdim NumParams = NewParamInfo.size(); 3444226633Sdim ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()]; 3445226633Sdim std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo); 3446193326Sed } 3447193326Sed} 3448193326Sed 3449218893Sdimvoid BlockDecl::setCaptures(ASTContext &Context, 3450218893Sdim const Capture *begin, 3451218893Sdim const Capture *end, 3452218893Sdim bool capturesCXXThis) { 3453218893Sdim CapturesCXXThis = capturesCXXThis; 3454218893Sdim 3455218893Sdim if (begin == end) { 3456218893Sdim NumCaptures = 0; 3457218893Sdim Captures = 0; 3458218893Sdim return; 3459218893Sdim } 3460218893Sdim 3461218893Sdim NumCaptures = end - begin; 3462218893Sdim 3463218893Sdim // Avoid new Capture[] because we don't want to provide a default 3464218893Sdim // constructor. 3465218893Sdim size_t allocationSize = NumCaptures * sizeof(Capture); 3466218893Sdim void *buffer = Context.Allocate(allocationSize, /*alignment*/sizeof(void*)); 3467218893Sdim memcpy(buffer, begin, allocationSize); 3468218893Sdim Captures = static_cast<Capture*>(buffer); 3469193326Sed} 3470203955Srdivacky 3471224145Sdimbool BlockDecl::capturesVariable(const VarDecl *variable) const { 3472224145Sdim for (capture_const_iterator 3473224145Sdim i = capture_begin(), e = capture_end(); i != e; ++i) 3474224145Sdim // Only auto vars can be captured, so no redeclaration worries. 3475224145Sdim if (i->getVariable() == variable) 3476224145Sdim return true; 3477224145Sdim 3478224145Sdim return false; 3479224145Sdim} 3480224145Sdim 3481218893SdimSourceRange BlockDecl::getSourceRange() const { 3482218893Sdim return SourceRange(getLocation(), Body? Body->getLocEnd() : getLocation()); 3483218893Sdim} 3484203955Srdivacky 3485203955Srdivacky//===----------------------------------------------------------------------===// 3486203955Srdivacky// Other Decl Allocation/Deallocation Method Implementations 3487203955Srdivacky//===----------------------------------------------------------------------===// 3488203955Srdivacky 3489234353Sdimvoid TranslationUnitDecl::anchor() { } 3490234353Sdim 3491203955SrdivackyTranslationUnitDecl *TranslationUnitDecl::Create(ASTContext &C) { 3492203955Srdivacky return new (C) TranslationUnitDecl(C); 3493203955Srdivacky} 3494203955Srdivacky 3495234353Sdimvoid LabelDecl::anchor() { } 3496234353Sdim 3497218893SdimLabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC, 3498221345Sdim SourceLocation IdentL, IdentifierInfo *II) { 3499221345Sdim return new (C) LabelDecl(DC, IdentL, II, 0, IdentL); 3500218893Sdim} 3501218893Sdim 3502221345SdimLabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC, 3503221345Sdim SourceLocation IdentL, IdentifierInfo *II, 3504221345Sdim SourceLocation GnuLabelL) { 3505221345Sdim assert(GnuLabelL != IdentL && "Use this only for GNU local labels"); 3506221345Sdim return new (C) LabelDecl(DC, IdentL, II, 0, GnuLabelL); 3507221345Sdim} 3508218893Sdim 3509234353SdimLabelDecl *LabelDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3510234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(LabelDecl)); 3511234353Sdim return new (Mem) LabelDecl(0, SourceLocation(), 0, 0, SourceLocation()); 3512203955Srdivacky} 3513203955Srdivacky 3514234353Sdimvoid ValueDecl::anchor() { } 3515218893Sdim 3516249423Sdimbool ValueDecl::isWeak() const { 3517249423Sdim for (attr_iterator I = attr_begin(), E = attr_end(); I != E; ++I) 3518249423Sdim if (isa<WeakAttr>(*I) || isa<WeakRefAttr>(*I)) 3519249423Sdim return true; 3520249423Sdim 3521249423Sdim return isWeakImported(); 3522249423Sdim} 3523249423Sdim 3524234353Sdimvoid ImplicitParamDecl::anchor() { } 3525234353Sdim 3526203955SrdivackyImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, DeclContext *DC, 3527221345Sdim SourceLocation IdLoc, 3528221345Sdim IdentifierInfo *Id, 3529221345Sdim QualType Type) { 3530221345Sdim return new (C) ImplicitParamDecl(DC, IdLoc, Id, Type); 3531203955Srdivacky} 3532203955Srdivacky 3533234353SdimImplicitParamDecl *ImplicitParamDecl::CreateDeserialized(ASTContext &C, 3534234353Sdim unsigned ID) { 3535234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(ImplicitParamDecl)); 3536234353Sdim return new (Mem) ImplicitParamDecl(0, SourceLocation(), 0, QualType()); 3537234353Sdim} 3538234353Sdim 3539203955SrdivackyFunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC, 3540221345Sdim SourceLocation StartLoc, 3541212904Sdim const DeclarationNameInfo &NameInfo, 3542212904Sdim QualType T, TypeSourceInfo *TInfo, 3543249423Sdim StorageClass SC, 3544218893Sdim bool isInlineSpecified, 3545226633Sdim bool hasWrittenPrototype, 3546226633Sdim bool isConstexprSpecified) { 3547221345Sdim FunctionDecl *New = new (C) FunctionDecl(Function, DC, StartLoc, NameInfo, 3548249423Sdim T, TInfo, SC, 3549226633Sdim isInlineSpecified, 3550226633Sdim isConstexprSpecified); 3551203955Srdivacky New->HasWrittenPrototype = hasWrittenPrototype; 3552203955Srdivacky return New; 3553203955Srdivacky} 3554203955Srdivacky 3555234353SdimFunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3556234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FunctionDecl)); 3557234353Sdim return new (Mem) FunctionDecl(Function, 0, SourceLocation(), 3558234353Sdim DeclarationNameInfo(), QualType(), 0, 3559249423Sdim SC_None, false, false); 3560234353Sdim} 3561234353Sdim 3562203955SrdivackyBlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) { 3563203955Srdivacky return new (C) BlockDecl(DC, L); 3564203955Srdivacky} 3565203955Srdivacky 3566234353SdimBlockDecl *BlockDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3567234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(BlockDecl)); 3568234353Sdim return new (Mem) BlockDecl(0, SourceLocation()); 3569234353Sdim} 3570234353Sdim 3571251662SdimMSPropertyDecl *MSPropertyDecl::CreateDeserialized(ASTContext &C, 3572251662Sdim unsigned ID) { 3573251662Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(MSPropertyDecl)); 3574251662Sdim return new (Mem) MSPropertyDecl(0, SourceLocation(), DeclarationName(), 3575251662Sdim QualType(), 0, SourceLocation(), 3576251662Sdim 0, 0); 3577251662Sdim} 3578251662Sdim 3579251662SdimCapturedDecl *CapturedDecl::Create(ASTContext &C, DeclContext *DC, 3580251662Sdim unsigned NumParams) { 3581251662Sdim unsigned Size = sizeof(CapturedDecl) + NumParams * sizeof(ImplicitParamDecl*); 3582251662Sdim return new (C.Allocate(Size)) CapturedDecl(DC, NumParams); 3583251662Sdim} 3584251662Sdim 3585251662SdimCapturedDecl *CapturedDecl::CreateDeserialized(ASTContext &C, unsigned ID, 3586251662Sdim unsigned NumParams) { 3587251662Sdim unsigned Size = sizeof(CapturedDecl) + NumParams * sizeof(ImplicitParamDecl*); 3588251662Sdim void *Mem = AllocateDeserializedDecl(C, ID, Size); 3589251662Sdim return new (Mem) CapturedDecl(0, NumParams); 3590251662Sdim} 3591251662Sdim 3592203955SrdivackyEnumConstantDecl *EnumConstantDecl::Create(ASTContext &C, EnumDecl *CD, 3593203955Srdivacky SourceLocation L, 3594203955Srdivacky IdentifierInfo *Id, QualType T, 3595203955Srdivacky Expr *E, const llvm::APSInt &V) { 3596203955Srdivacky return new (C) EnumConstantDecl(CD, L, Id, T, E, V); 3597203955Srdivacky} 3598203955Srdivacky 3599234353SdimEnumConstantDecl * 3600234353SdimEnumConstantDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3601234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(EnumConstantDecl)); 3602234353Sdim return new (Mem) EnumConstantDecl(0, SourceLocation(), 0, QualType(), 0, 3603234353Sdim llvm::APSInt()); 3604234353Sdim} 3605234353Sdim 3606234353Sdimvoid IndirectFieldDecl::anchor() { } 3607234353Sdim 3608218893SdimIndirectFieldDecl * 3609218893SdimIndirectFieldDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, 3610218893Sdim IdentifierInfo *Id, QualType T, NamedDecl **CH, 3611218893Sdim unsigned CHS) { 3612218893Sdim return new (C) IndirectFieldDecl(DC, L, Id, T, CH, CHS); 3613218893Sdim} 3614218893Sdim 3615234353SdimIndirectFieldDecl *IndirectFieldDecl::CreateDeserialized(ASTContext &C, 3616234353Sdim unsigned ID) { 3617234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(IndirectFieldDecl)); 3618234353Sdim return new (Mem) IndirectFieldDecl(0, SourceLocation(), DeclarationName(), 3619234353Sdim QualType(), 0, 0); 3620234353Sdim} 3621234353Sdim 3622212904SdimSourceRange EnumConstantDecl::getSourceRange() const { 3623212904Sdim SourceLocation End = getLocation(); 3624212904Sdim if (Init) 3625212904Sdim End = Init->getLocEnd(); 3626212904Sdim return SourceRange(getLocation(), End); 3627203955Srdivacky} 3628203955Srdivacky 3629234353Sdimvoid TypeDecl::anchor() { } 3630234353Sdim 3631203955SrdivackyTypedefDecl *TypedefDecl::Create(ASTContext &C, DeclContext *DC, 3632221345Sdim SourceLocation StartLoc, SourceLocation IdLoc, 3633221345Sdim IdentifierInfo *Id, TypeSourceInfo *TInfo) { 3634221345Sdim return new (C) TypedefDecl(DC, StartLoc, IdLoc, Id, TInfo); 3635203955Srdivacky} 3636203955Srdivacky 3637234353Sdimvoid TypedefNameDecl::anchor() { } 3638234353Sdim 3639234353SdimTypedefDecl *TypedefDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3640234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TypedefDecl)); 3641234353Sdim return new (Mem) TypedefDecl(0, SourceLocation(), SourceLocation(), 0, 0); 3642234353Sdim} 3643234353Sdim 3644221345SdimTypeAliasDecl *TypeAliasDecl::Create(ASTContext &C, DeclContext *DC, 3645221345Sdim SourceLocation StartLoc, 3646221345Sdim SourceLocation IdLoc, IdentifierInfo *Id, 3647221345Sdim TypeSourceInfo *TInfo) { 3648221345Sdim return new (C) TypeAliasDecl(DC, StartLoc, IdLoc, Id, TInfo); 3649221345Sdim} 3650221345Sdim 3651234353SdimTypeAliasDecl *TypeAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3652234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(TypeAliasDecl)); 3653234353Sdim return new (Mem) TypeAliasDecl(0, SourceLocation(), SourceLocation(), 0, 0); 3654234353Sdim} 3655234353Sdim 3656221345SdimSourceRange TypedefDecl::getSourceRange() const { 3657221345Sdim SourceLocation RangeEnd = getLocation(); 3658221345Sdim if (TypeSourceInfo *TInfo = getTypeSourceInfo()) { 3659221345Sdim if (typeIsPostfix(TInfo->getType())) 3660221345Sdim RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd(); 3661221345Sdim } 3662221345Sdim return SourceRange(getLocStart(), RangeEnd); 3663221345Sdim} 3664221345Sdim 3665221345SdimSourceRange TypeAliasDecl::getSourceRange() const { 3666221345Sdim SourceLocation RangeEnd = getLocStart(); 3667221345Sdim if (TypeSourceInfo *TInfo = getTypeSourceInfo()) 3668221345Sdim RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd(); 3669221345Sdim return SourceRange(getLocStart(), RangeEnd); 3670221345Sdim} 3671221345Sdim 3672234353Sdimvoid FileScopeAsmDecl::anchor() { } 3673234353Sdim 3674203955SrdivackyFileScopeAsmDecl *FileScopeAsmDecl::Create(ASTContext &C, DeclContext *DC, 3675221345Sdim StringLiteral *Str, 3676221345Sdim SourceLocation AsmLoc, 3677221345Sdim SourceLocation RParenLoc) { 3678221345Sdim return new (C) FileScopeAsmDecl(DC, Str, AsmLoc, RParenLoc); 3679203955Srdivacky} 3680234353Sdim 3681234353SdimFileScopeAsmDecl *FileScopeAsmDecl::CreateDeserialized(ASTContext &C, 3682234353Sdim unsigned ID) { 3683234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(FileScopeAsmDecl)); 3684234353Sdim return new (Mem) FileScopeAsmDecl(0, 0, SourceLocation(), SourceLocation()); 3685234353Sdim} 3686234353Sdim 3687249423Sdimvoid EmptyDecl::anchor() {} 3688249423Sdim 3689249423SdimEmptyDecl *EmptyDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) { 3690249423Sdim return new (C) EmptyDecl(DC, L); 3691249423Sdim} 3692249423Sdim 3693249423SdimEmptyDecl *EmptyDecl::CreateDeserialized(ASTContext &C, unsigned ID) { 3694249423Sdim void *Mem = AllocateDeserializedDecl(C, ID, sizeof(EmptyDecl)); 3695249423Sdim return new (Mem) EmptyDecl(0, SourceLocation()); 3696249423Sdim} 3697249423Sdim 3698234353Sdim//===----------------------------------------------------------------------===// 3699234353Sdim// ImportDecl Implementation 3700234353Sdim//===----------------------------------------------------------------------===// 3701234353Sdim 3702234353Sdim/// \brief Retrieve the number of module identifiers needed to name the given 3703234353Sdim/// module. 3704234353Sdimstatic unsigned getNumModuleIdentifiers(Module *Mod) { 3705234353Sdim unsigned Result = 1; 3706234353Sdim while (Mod->Parent) { 3707234353Sdim Mod = Mod->Parent; 3708234353Sdim ++Result; 3709234353Sdim } 3710234353Sdim return Result; 3711234353Sdim} 3712234353Sdim 3713234353SdimImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc, 3714234353Sdim Module *Imported, 3715234353Sdim ArrayRef<SourceLocation> IdentifierLocs) 3716234353Sdim : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, true), 3717234353Sdim NextLocalImport() 3718234353Sdim{ 3719234353Sdim assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size()); 3720234353Sdim SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(this + 1); 3721234353Sdim memcpy(StoredLocs, IdentifierLocs.data(), 3722234353Sdim IdentifierLocs.size() * sizeof(SourceLocation)); 3723234353Sdim} 3724234353Sdim 3725234353SdimImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc, 3726234353Sdim Module *Imported, SourceLocation EndLoc) 3727234353Sdim : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, false), 3728234353Sdim NextLocalImport() 3729234353Sdim{ 3730234353Sdim *reinterpret_cast<SourceLocation *>(this + 1) = EndLoc; 3731234353Sdim} 3732234353Sdim 3733234353SdimImportDecl *ImportDecl::Create(ASTContext &C, DeclContext *DC, 3734234353Sdim SourceLocation StartLoc, Module *Imported, 3735234353Sdim ArrayRef<SourceLocation> IdentifierLocs) { 3736234353Sdim void *Mem = C.Allocate(sizeof(ImportDecl) + 3737234353Sdim IdentifierLocs.size() * sizeof(SourceLocation)); 3738234353Sdim return new (Mem) ImportDecl(DC, StartLoc, Imported, IdentifierLocs); 3739234353Sdim} 3740234353Sdim 3741234353SdimImportDecl *ImportDecl::CreateImplicit(ASTContext &C, DeclContext *DC, 3742234353Sdim SourceLocation StartLoc, 3743234353Sdim Module *Imported, 3744234353Sdim SourceLocation EndLoc) { 3745234353Sdim void *Mem = C.Allocate(sizeof(ImportDecl) + sizeof(SourceLocation)); 3746234353Sdim ImportDecl *Import = new (Mem) ImportDecl(DC, StartLoc, Imported, EndLoc); 3747234353Sdim Import->setImplicit(); 3748234353Sdim return Import; 3749234353Sdim} 3750234353Sdim 3751234353SdimImportDecl *ImportDecl::CreateDeserialized(ASTContext &C, unsigned ID, 3752234353Sdim unsigned NumLocations) { 3753234353Sdim void *Mem = AllocateDeserializedDecl(C, ID, 3754234353Sdim (sizeof(ImportDecl) + 3755234353Sdim NumLocations * sizeof(SourceLocation))); 3756234353Sdim return new (Mem) ImportDecl(EmptyShell()); 3757234353Sdim} 3758234353Sdim 3759234353SdimArrayRef<SourceLocation> ImportDecl::getIdentifierLocs() const { 3760234353Sdim if (!ImportedAndComplete.getInt()) 3761251662Sdim return None; 3762234353Sdim 3763234353Sdim const SourceLocation *StoredLocs 3764234353Sdim = reinterpret_cast<const SourceLocation *>(this + 1); 3765234353Sdim return ArrayRef<SourceLocation>(StoredLocs, 3766234353Sdim getNumModuleIdentifiers(getImportedModule())); 3767234353Sdim} 3768234353Sdim 3769234353SdimSourceRange ImportDecl::getSourceRange() const { 3770234353Sdim if (!ImportedAndComplete.getInt()) 3771234353Sdim return SourceRange(getLocation(), 3772234353Sdim *reinterpret_cast<const SourceLocation *>(this + 1)); 3773234353Sdim 3774234353Sdim return SourceRange(getLocation(), getIdentifierLocs().back()); 3775234353Sdim} 3776