From 50919f0f24dc74467e0bb43fba0aa8e4062e503b Mon Sep 17 00:00:00 2001 From: Larisse Voufo Date: Wed, 4 Feb 2015 02:34:32 +0000 Subject: [PATCH] Generalize r228066 to give all implicit global allocation functions default visibility. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@228107 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/AST/Decl.cpp | 7 +-- lib/Sema/SemaExprCXX.cpp | 4 ++ .../cxx14-implicit-sized-delete.cpp | 27 ---------- .../implicit-allocation-functions.cpp | 54 +++++++++++++++++++ 4 files changed, 59 insertions(+), 33 deletions(-) delete mode 100644 test/CodeGenCXX/cxx14-implicit-sized-delete.cpp create mode 100644 test/CodeGenCXX/implicit-allocation-functions.cpp diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp index c66cd5d952..9988c71d97 100644 --- a/lib/AST/Decl.cpp +++ b/lib/AST/Decl.cpp @@ -666,12 +666,7 @@ static LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D, // Use global type/value visibility as appropriate. Visibility globalVisibility; if (computation == LVForValue) { - const FunctionDecl *FD = D->getAsFunction(); - if (FD && FD->getCorrespondingUnsizedGlobalDeallocationFunction()) - // C++14's implicit sized deallocation functions always have default visibility. - globalVisibility = DefaultVisibility; - else - globalVisibility = Context.getLangOpts().getValueVisibilityMode(); + globalVisibility = Context.getLangOpts().getValueVisibilityMode(); } else { assert(computation == LVForType); globalVisibility = Context.getLangOpts().getTypeVisibilityMode(); diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp index 716e59458a..c142efb11d 100644 --- a/lib/Sema/SemaExprCXX.cpp +++ b/lib/Sema/SemaExprCXX.cpp @@ -2116,6 +2116,10 @@ void Sema::DeclareGlobalAllocationFunction(DeclarationName Name, SourceLocation(), Name, FnType, /*TInfo=*/nullptr, SC_None, false, true); Alloc->setImplicit(); + + // Implicit sized deallocation functions always have default visibility. + Alloc->addAttr(VisibilityAttr::CreateImplicit(Context, + VisibilityAttr::Default)); if (AddMallocAttr) Alloc->addAttr(MallocAttr::CreateImplicit(Context)); diff --git a/test/CodeGenCXX/cxx14-implicit-sized-delete.cpp b/test/CodeGenCXX/cxx14-implicit-sized-delete.cpp deleted file mode 100644 index 8a89fcb5f0..0000000000 --- a/test/CodeGenCXX/cxx14-implicit-sized-delete.cpp +++ /dev/null @@ -1,27 +0,0 @@ -// RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown-unknown -o - -std=c++14 %s 2>&1 | FileCheck %s -check-prefix=CHECKDEF -check-prefix=CHECK -// RUN: %clang_cc1 -emit-llvm -triple x86_64-unknown-unknown -o - -std=c++14 -fvisibility hidden %s 2>&1 | FileCheck %s -check-prefix=CHECKHID -check-prefix=CHECK - -// PR22419: Implicit sized deallocation functions always have default visibility. - -// CHECKDEF-DAG: define void @_Z3fooPi(i32* %is) -// CHECKHID-DAG: define hidden void @_Z3fooPi(i32* %is) -void foo(int* is) { - - // CHECK-DAG: call void @_ZdlPvm(i8* %{{.+}}, i64 4) - delete is; -} - -// CHECK-DAG: define linkonce void @_ZdlPvm(i8*, i64) - -// CHECK-DAG: %struct.A = type { i8 } -struct A { ~A() { }}; - -// CHECKDEF-DAG: define void @_Z1fP1A(%struct.A* %p) -// CHECKHID-DAG: define hidden void @_Z1fP1A(%struct.A* %p) -void f(A *p) { - - // CHECK-DAG: call void @_ZdaPvm(i8* %{{.+}}, i64 %{{.+}}) - delete[] p; -} - -// CHECK-DAG: define linkonce void @_ZdaPvm(i8*, i64) diff --git a/test/CodeGenCXX/implicit-allocation-functions.cpp b/test/CodeGenCXX/implicit-allocation-functions.cpp new file mode 100644 index 0000000000..b66b685c9b --- /dev/null +++ b/test/CodeGenCXX/implicit-allocation-functions.cpp @@ -0,0 +1,54 @@ +// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - -std=c++11 %s 2>&1 | FileCheck %s -check-prefix=CHECKDEF -check-prefix=CHECK11 +// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - -std=c++11 -fvisibility hidden %s 2>&1 | FileCheck %s -check-prefix=CHECKHID -check-prefix=CHECK11 +// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - -std=c++14 %s 2>&1 | FileCheck %s -check-prefix=CHECKDEF -check-prefix=CHECK14 +// RUN: %clang_cc1 -emit-llvm -triple %itanium_abi_triple -o - -std=c++14 -fvisibility hidden %s 2>&1 | FileCheck %s -check-prefix=CHECKHID -check-prefix=CHECK14 + +// PR22419: Implicit sized deallocation functions always have default visibility. +// Generalized to all implicit allocation functions. + + +// CHECK14-DAG: %struct.A = type { i8 } +struct A { }; + +// CHECKDEF-DAG: define void @_Z3fooP1A(%struct.A* %is) +// CHECKHID-DAG: define hidden void @_Z3fooP1A(%struct.A* %is) +void foo(A* is) { + + // CHECK11-DAG: call noalias i8* @_Znwm(i64 1) + // CHECK14-DAG: call noalias i8* @_Znwm(i64 1) + is = new A(); + + // CHECK11-DAG: call void @_ZdlPv(i8* %{{.+}}) + // CHECK14-DAG: call void @_ZdlPvm(i8* %{{.+}}, i64 1) + delete is; +} + +// CHECK11-DAG: declare noalias i8* @_Znwm(i64) +// CHECK11-DAG: declare void @_ZdlPv(i8*) + +// CHECK14-DAG: declare noalias i8* @_Znwm(i64) +// CHECK14-DAG: define linkonce void @_ZdlPvm(i8*, i64) +// CHECK14-DAG: declare void @_ZdlPv(i8*) + +// CHECK14-DAG: %struct.B = type { i8 } +struct B { ~B() { }}; + +// CHECKDEF-DAG: define void @_Z1fP1B(%struct.B* %p) +// CHECKHID-DAG: define hidden void @_Z1fP1B(%struct.B* %p) +void f(B *p) { + + // CHECK11-DAG: call noalias i8* @_Znam(i64 13) + // CHECK14-DAG: call noalias i8* @_Znam(i64 13) + p = new B[5]; + + // CHECK11-DAG: call void @_ZdaPv(i8* %{{.+}}) + // CHECK14-DAG: call void @_ZdaPvm(i8* %{{.+}}, i64 %{{.+}}) + delete[] p; +} + +// CHECK11-DAG: declare noalias i8* @_Znam(i64) +// CHECK11-DAG: declare void @_ZdaPv(i8*) + +// CHECK14-DAG: declare noalias i8* @_Znam(i64) +// CHECK14-DAG: define linkonce void @_ZdaPvm(i8*, i64) +// CHECK14-DAG: declare void @_ZdaPv(i8*) -- 2.40.0