From 7572e58b66bc4312b299ab00a2b780d900d735ed Mon Sep 17 00:00:00 2001 From: Aaron Ballman Date: Thu, 16 Jul 2015 17:06:53 +0000 Subject: [PATCH] Disable #pragma redefine_extname for C++ code as it does not make sense in such a context. Patch by Andrey Bokhanko! llvm-svn: 242420 --- .../clang/Basic/DiagnosticSemaKinds.td | 4 ++ clang/lib/Sema/SemaDecl.cpp | 49 ++++++++++--------- clang/test/CodeGen/redefine_extname.c | 6 +++ clang/test/CodeGenCXX/redefine_extname.cpp | 6 +++ clang/test/SemaCXX/redefine_extname.cpp | 6 +++ 5 files changed, 49 insertions(+), 22 deletions(-) create mode 100644 clang/test/SemaCXX/redefine_extname.cpp diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 23e1714adb30..7174bbe95ef0 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -6343,6 +6343,10 @@ def warn_cast_qual : Warning<"cast from %0 to %1 drops %select{const and " InGroup, DefaultIgnore; def warn_cast_qual2 : Warning<"cast from %0 to %1 must have all intermediate " "pointers const qualified to be safe">, InGroup, DefaultIgnore; +def warn_redefine_extname_not_applied : Warning< + "#pragma redefine_extname is applicable to external C declarations only; " + "not applied to %select{function|variable}0 %1">, + InGroup; } // End of general sema category. // inline asm. diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 99d4a79c4669..2bf7356bf2a6 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -5568,15 +5568,12 @@ bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) { return true; } -/// \brief Returns true if given declaration is TU-scoped and externally -/// visible. -static bool isDeclTUScopedExternallyVisible(const Decl *D) { - if (auto *FD = dyn_cast(D)) - return (FD->getDeclContext()->isTranslationUnit() || FD->isExternC()) && - FD->hasExternalFormalLinkage(); - else if (auto *VD = dyn_cast(D)) - return (VD->getDeclContext()->isTranslationUnit() || VD->isExternC()) && - VD->hasExternalFormalLinkage(); +/// \brief Returns true if given declaration has external C language linkage. +static bool isDeclExternC(const Decl *D) { + if (const auto *FD = dyn_cast(D)) + return FD->isExternC(); + if (const auto *VD = dyn_cast(D)) + return VD->isExternC(); llvm_unreachable("Unknown type of decl!"); } @@ -6005,13 +6002,16 @@ Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, Label, 0)); - } else if (!ExtnameUndeclaredIdentifiers.empty() && - isDeclTUScopedExternallyVisible(NewVD)) { + } else if (!ExtnameUndeclaredIdentifiers.empty()) { llvm::DenseMap::iterator I = ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier()); if (I != ExtnameUndeclaredIdentifiers.end()) { - NewVD->addAttr(I->second); - ExtnameUndeclaredIdentifiers.erase(I); + if (isDeclExternC(NewVD)) { + NewVD->addAttr(I->second); + ExtnameUndeclaredIdentifiers.erase(I); + } else + Diag(NewVD->getLocation(), diag::warn_redefine_extname_not_applied) + << /*Variable*/1 << NewVD; } } @@ -7533,13 +7533,16 @@ Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, StringLiteral *SE = cast(E); NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context, SE->getString(), 0)); - } else if (!ExtnameUndeclaredIdentifiers.empty() && - isDeclTUScopedExternallyVisible(NewFD)) { + } else if (!ExtnameUndeclaredIdentifiers.empty()) { llvm::DenseMap::iterator I = ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier()); if (I != ExtnameUndeclaredIdentifiers.end()) { - NewFD->addAttr(I->second); - ExtnameUndeclaredIdentifiers.erase(I); + if (isDeclExternC(NewFD)) { + NewFD->addAttr(I->second); + ExtnameUndeclaredIdentifiers.erase(I); + } else + Diag(NewFD->getLocation(), diag::warn_redefine_extname_not_applied) + << /*Variable*/0 << NewFD; } } @@ -14388,12 +14391,14 @@ void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name, // 1) declares a function or a variable // 2) has external linkage // already exists, add a label attribute to it. - if (PrevDecl && - (isa(PrevDecl) || isa(PrevDecl)) && - PrevDecl->hasExternalFormalLinkage()) - PrevDecl->addAttr(Attr); + if (PrevDecl && (isa(PrevDecl) || isa(PrevDecl))) { + if (isDeclExternC(PrevDecl)) + PrevDecl->addAttr(Attr); + else + Diag(PrevDecl->getLocation(), diag::warn_redefine_extname_not_applied) + << /*Variable*/(isa(PrevDecl) ? 0 : 1) << PrevDecl; // Otherwise, add a label atttibute to ExtnameUndeclaredIdentifiers. - else + } else (void)ExtnameUndeclaredIdentifiers.insert(std::make_pair(Name, Attr)); } diff --git a/clang/test/CodeGen/redefine_extname.c b/clang/test/CodeGen/redefine_extname.c index ad4106dd4535..d56527a88953 100644 --- a/clang/test/CodeGen/redefine_extname.c +++ b/clang/test/CodeGen/redefine_extname.c @@ -24,3 +24,9 @@ int f() { extern int foo() { return 1; } // CHECK: define i32 @bar() +// Check that pragma redefine_extname applies to external declarations only. +#pragma redefine_extname foo_static bar_static +static int foo_static() { return 1; } +int baz() { return foo_static(); } +// CHECK-NOT: call i32 @bar_static() + diff --git a/clang/test/CodeGenCXX/redefine_extname.cpp b/clang/test/CodeGenCXX/redefine_extname.cpp index f76fe6252fef..6e8285a3b0fb 100644 --- a/clang/test/CodeGenCXX/redefine_extname.cpp +++ b/clang/test/CodeGenCXX/redefine_extname.cpp @@ -28,3 +28,9 @@ extern "C" { // CHECK: define i32 @bar() } +// Check that pragma redefine_extname applies to C code only, and shouldn't be +// applied to C++. +#pragma redefine_extname foo_cpp bar_cpp +extern int foo_cpp() { return 1; } +// CHECK-NOT: define i32 @bar_cpp() + diff --git a/clang/test/SemaCXX/redefine_extname.cpp b/clang/test/SemaCXX/redefine_extname.cpp new file mode 100644 index 000000000000..460df4ba1b4d --- /dev/null +++ b/clang/test/SemaCXX/redefine_extname.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -triple=x86_64-unknown-linux -Wpragmas -verify %s + +// Check that pragma redefine_extname applies to C code only, and shouldn't be +// applied to C++. +#pragma redefine_extname foo_cpp bar_cpp +extern int foo_cpp() { return 1; } // expected-warning {{#pragma redefine_extname is applicable to external C declarations only; not applied to function 'foo_cpp'}}