From 68584ed35ad819a1668e3f527ba7f5dd4ae6a333 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Thu, 18 Jun 2009 16:11:24 +0000 Subject: Move the static DeclAttrs map into ASTContext. Fixes . git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@73702 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/CodeGenModule.cpp | 65 +++++++++++++++++++++++-------------------- 1 file changed, 35 insertions(+), 30 deletions(-) (limited to 'lib/CodeGen/CodeGenModule.cpp') diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp index a0f0492378..f8dfbfb532 100644 --- a/lib/CodeGen/CodeGenModule.cpp +++ b/lib/CodeGen/CodeGenModule.cpp @@ -102,7 +102,7 @@ CodeGenModule::getDeclVisibilityMode(const Decl *D) const { if (VD->getStorageClass() == VarDecl::PrivateExtern) return LangOptions::Hidden; - if (const VisibilityAttr *attr = D->getAttr()) { + if (const VisibilityAttr *attr = D->getAttr(getContext())) { switch (attr->getVisibility()) { default: assert(0 && "Unknown visibility!"); case VisibilityAttr::DefaultVisibility: @@ -241,7 +241,8 @@ void CodeGenModule::EmitAnnotations() { } static CodeGenModule::GVALinkage -GetLinkageForFunction(const FunctionDecl *FD, const LangOptions &Features) { +GetLinkageForFunction(ASTContext &Context, const FunctionDecl *FD, + const LangOptions &Features) { if (const CXXMethodDecl *MD = dyn_cast(FD)) { // C++ member functions defined inside the class are always inline. if (MD->isInline() || !MD->isOutOfLine()) @@ -265,11 +266,11 @@ GetLinkageForFunction(const FunctionDecl *FD, const LangOptions &Features) { return CodeGenModule::GVA_C99Inline; // Normal inline is a strong symbol. return CodeGenModule::GVA_StrongExternal; - } else if (FD->hasActiveGNUInlineAttribute()) { + } else if (FD->hasActiveGNUInlineAttribute(Context)) { // GCC in C99 mode seems to use a different decision-making // process for extern inline, which factors in previous // declarations. - if (FD->isExternGNUInline()) + if (FD->isExternGNUInline(Context)) return CodeGenModule::GVA_C99Inline; // Normal inline is a strong symbol. return CodeGenModule::GVA_StrongExternal; @@ -293,13 +294,13 @@ GetLinkageForFunction(const FunctionDecl *FD, const LangOptions &Features) { /// variables (these details are set in EmitGlobalVarDefinition for variables). void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, llvm::GlobalValue *GV) { - GVALinkage Linkage = GetLinkageForFunction(D, Features); + GVALinkage Linkage = GetLinkageForFunction(getContext(), D, Features); if (Linkage == GVA_Internal) { GV->setLinkage(llvm::Function::InternalLinkage); - } else if (D->hasAttr()) { + } else if (D->hasAttr(getContext())) { GV->setLinkage(llvm::Function::DLLExportLinkage); - } else if (D->hasAttr()) { + } else if (D->hasAttr(getContext())) { GV->setLinkage(llvm::Function::WeakAnyLinkage); } else if (Linkage == GVA_C99Inline) { // In C99 mode, 'inline' functions are guaranteed to have a strong @@ -332,10 +333,10 @@ void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, AttributeList.size())); // Set the appropriate calling convention for the Function. - if (D->hasAttr()) + if (D->hasAttr(getContext())) F->setCallingConv(llvm::CallingConv::X86_FastCall); - if (D->hasAttr()) + if (D->hasAttr(getContext())) F->setCallingConv(llvm::CallingConv::X86_StdCall); } @@ -344,10 +345,10 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, if (!Features.Exceptions && !Features.ObjCNonFragileABI) F->addFnAttr(llvm::Attribute::NoUnwind); - if (D->hasAttr()) + if (D->hasAttr(getContext())) F->addFnAttr(llvm::Attribute::AlwaysInline); - if (D->hasAttr()) + if (D->hasAttr(getContext())) F->addFnAttr(llvm::Attribute::NoInline); } @@ -355,10 +356,10 @@ void CodeGenModule::SetCommonAttributes(const Decl *D, llvm::GlobalValue *GV) { setGlobalVisibility(GV, D); - if (D->hasAttr()) + if (D->hasAttr(getContext())) AddUsedGlobal(GV); - if (const SectionAttr *SA = D->getAttr()) + if (const SectionAttr *SA = D->getAttr(getContext())) GV->setSection(SA->getName()); } @@ -382,9 +383,10 @@ void CodeGenModule::SetFunctionAttributes(const FunctionDecl *FD, // Only a few attributes are set on declarations; these may later be // overridden by a definition. - if (FD->hasAttr()) { + if (FD->hasAttr(getContext())) { F->setLinkage(llvm::Function::DLLImportLinkage); - } else if (FD->hasAttr() || FD->hasAttr()) { + } else if (FD->hasAttr(getContext()) || + FD->hasAttr(getContext())) { // "extern_weak" is overloaded in LLVM; we probably should have // separate linkage types for this. F->setLinkage(llvm::Function::ExternalWeakLinkage); @@ -392,7 +394,7 @@ void CodeGenModule::SetFunctionAttributes(const FunctionDecl *FD, F->setLinkage(llvm::Function::ExternalLinkage); } - if (const SectionAttr *SA = FD->getAttr()) + if (const SectionAttr *SA = FD->getAttr(getContext())) F->setSection(SA->getName()); } @@ -499,15 +501,16 @@ llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { // Never defer when EmitAllDecls is specified or the decl has // attribute used. - if (Features.EmitAllDecls || Global->hasAttr()) + if (Features.EmitAllDecls || Global->hasAttr(getContext())) return false; if (const FunctionDecl *FD = dyn_cast(Global)) { // Constructors and destructors should never be deferred. - if (FD->hasAttr() || FD->hasAttr()) + if (FD->hasAttr(getContext()) || + FD->hasAttr(getContext())) return false; - GVALinkage Linkage = GetLinkageForFunction(FD, Features); + GVALinkage Linkage = GetLinkageForFunction(getContext(), FD, Features); // static, static inline, always_inline, and extern inline functions can // always be deferred. Normal inline functions can be deferred in C99/C++. @@ -528,7 +531,7 @@ void CodeGenModule::EmitGlobal(GlobalDecl GD) { // If this is an alias definition (which otherwise looks like a declaration) // emit it now. - if (Global->hasAttr()) + if (Global->hasAttr(getContext())) return EmitAliasDefinition(Global); // Ignore declarations, they will be emitted on their first use. @@ -717,7 +720,8 @@ llvm::Constant *CodeGenModule::GetOrCreateLLVMGlobal(const char *MangledName, if (D->getStorageClass() == VarDecl::PrivateExtern) GV->setVisibility(llvm::GlobalValue::HiddenVisibility); - if (D->hasAttr() || D->hasAttr()) + if (D->hasAttr(getContext()) || + D->hasAttr(getContext())) GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); GV->setThreadLocal(D->isThreadSpecified()); @@ -837,7 +841,7 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { cast(Entry)->eraseFromParent(); } - if (const AnnotateAttr *AA = D->getAttr()) { + if (const AnnotateAttr *AA = D->getAttr(getContext())) { SourceManager &SM = Context.getSourceManager(); AddAnnotation(EmitAnnotateAttr(GV, AA, SM.getInstantiationLineNumber(D->getLocation()))); @@ -850,11 +854,11 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { // Set the llvm linkage type as appropriate. if (D->getStorageClass() == VarDecl::Static) GV->setLinkage(llvm::Function::InternalLinkage); - else if (D->hasAttr()) + else if (D->hasAttr(getContext())) GV->setLinkage(llvm::Function::DLLImportLinkage); - else if (D->hasAttr()) + else if (D->hasAttr(getContext())) GV->setLinkage(llvm::Function::DLLExportLinkage); - else if (D->hasAttr()) + else if (D->hasAttr(getContext())) GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage); else if (!CompileOpts.NoCommon && (!D->hasExternalStorage() && !D->getInit())) @@ -1017,14 +1021,14 @@ void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { SetFunctionDefinitionAttributes(D, Fn); SetLLVMFunctionAttributesForDefinition(D, Fn); - if (const ConstructorAttr *CA = D->getAttr()) + if (const ConstructorAttr *CA = D->getAttr(getContext())) AddGlobalCtor(Fn, CA->getPriority()); - if (const DestructorAttr *DA = D->getAttr()) + if (const DestructorAttr *DA = D->getAttr(getContext())) AddGlobalDtor(Fn, DA->getPriority()); } void CodeGenModule::EmitAliasDefinition(const ValueDecl *D) { - const AliasAttr *AA = D->getAttr(); + const AliasAttr *AA = D->getAttr(getContext()); assert(AA && "Not an alias?"); const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); @@ -1080,7 +1084,7 @@ void CodeGenModule::EmitAliasDefinition(const ValueDecl *D) { // Set attributes which are particular to an alias; this is a // specialization of the attributes which may be set on a global // variable/function. - if (D->hasAttr()) { + if (D->hasAttr(getContext())) { if (const FunctionDecl *FD = dyn_cast(D)) { // The dllexport attribute is ignored for undefined symbols. if (FD->getBody(getContext())) @@ -1088,7 +1092,8 @@ void CodeGenModule::EmitAliasDefinition(const ValueDecl *D) { } else { GA->setLinkage(llvm::Function::DLLExportLinkage); } - } else if (D->hasAttr() || D->hasAttr()) { + } else if (D->hasAttr(getContext()) || + D->hasAttr(getContext())) { GA->setLinkage(llvm::Function::WeakAnyLinkage); } -- cgit v1.2.3-18-g5258