maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/CodeGenCXX/exceptions.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

598 lines
21 KiB
C++
Raw Normal View History

[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -emit-llvm -std=c++98 -o - -fcxx-exceptions -fexceptions | FileCheck -check-prefix=CHECK -check-prefix=CHECK98 %s
// RUN: %clang_cc1 %s -triple=x86_64-linux-gnu -emit-llvm -std=c++11 -o - -fcxx-exceptions -fexceptions | FileCheck -check-prefix=CHECK -check-prefix=CHECK11 %s
When an exception needs to be freed by calling __cxa_exception_free, make sure to stash away the exception pointer somewhere. This fixes an "Instruction does not dominate all uses!" verification error when compiling TableGen. llvm-svn: 91084
2009-12-11 08:32:37 +08:00
Use the reserved keyword spelling of 'typeof' No functional change intended, just a drive-by cleanup. llvm-svn: 243826
2015-08-01 13:31:56 +08:00
typedef __typeof(sizeof(0)) size_t;
When an exception needs to be freed by calling __cxa_exception_free, make sure to stash away the exception pointer somewhere. This fixes an "Instruction does not dominate all uses!" verification error when compiling TableGen. llvm-svn: 91084
2009-12-11 08:32:37 +08:00
Don't crash when a reserved global placement operator new is paired with a non-reserved operator delete in a new-expression. llvm-svn: 248862
2015-09-30 07:55:17 +08:00
// Declare the reserved global placement new.
void *operator new(size_t, void*);
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// This just shouldn't crash.
namespace test0 {
struct allocator {
allocator();
allocator(const allocator&);
~allocator();
};
When an exception needs to be freed by calling __cxa_exception_free, make sure to stash away the exception pointer somewhere. This fixes an "Instruction does not dominate all uses!" verification error when compiling TableGen. llvm-svn: 91084
2009-12-11 08:32:37 +08:00
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
void f();
void g(bool b, bool c) {
if (b) {
if (!c)
throw allocator();
return;
}
f();
}
}
namespace test1 {
struct A { A(int); A(int, int); ~A(); void *p; };
A *a() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test11aEv()
[clang] Annotating C++'s `operator new` with more attributes Summary: Right now we annotate C++'s `operator new` with `noalias` attribute, which very much is healthy for optimizations. However as per [[ http://eel.is/c++draft/basic.stc.dynamic.allocation | `[basic.stc.dynamic.allocation]` ]], there are more promises on global `operator new`, namely: * non-`std::nothrow_t` `operator new` *never* returns `nullptr` * If `std::align_val_t align` parameter is taken, the pointer will also be `align`-aligned * ~~global `operator new`-returned pointer is `__STDCPP_DEFAULT_NEW_ALIGNMENT__`-aligned ~~ It's more caveated than that. Supplying this information may not cause immediate landslide effects on any specific benchmarks, but it for sure will be healthy for optimizer in the sense that the IR will better reflect the guarantees provided in the source code. The caveat is `-fno-assume-sane-operator-new`, which currently prevents emitting `noalias` attribute, and is automatically passed by Sanitizers ([[ https://bugs.llvm.org/show_bug.cgi?id=16386 | PR16386 ]]) - should it also cover these attributes? The problem is that the flag is back-end-specific, as seen in `test/Modules/explicit-build-flags.cpp`. But while it is okay to add `noalias` metadata in backend, we really should be adding at least the alignment metadata to the AST, since that allows us to perform sema checks on it. Reviewers: erichkeane, rjmccall, jdoerfert, eugenis, rsmith Reviewed By: rsmith Subscribers: xbolva00, jrtc27, atanasyan, nlopes, cfe-commits Tags: #llvm, #clang Differential Revision: https://reviews.llvm.org/D73380
2020-02-26 06:37:17 +08:00
// CHECK: [[NEW:%.*]] = call noalias nonnull i8* @_Znwm(i64 8)
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 5)
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: ret [[A]]* [[CAST]]
// CHECK: call void @_ZdlPv(i8* [[NEW]])
return new A(5);
}
A *b() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test11bEv()
[clang] Annotating C++'s `operator new` with more attributes Summary: Right now we annotate C++'s `operator new` with `noalias` attribute, which very much is healthy for optimizations. However as per [[ http://eel.is/c++draft/basic.stc.dynamic.allocation | `[basic.stc.dynamic.allocation]` ]], there are more promises on global `operator new`, namely: * non-`std::nothrow_t` `operator new` *never* returns `nullptr` * If `std::align_val_t align` parameter is taken, the pointer will also be `align`-aligned * ~~global `operator new`-returned pointer is `__STDCPP_DEFAULT_NEW_ALIGNMENT__`-aligned ~~ It's more caveated than that. Supplying this information may not cause immediate landslide effects on any specific benchmarks, but it for sure will be healthy for optimizer in the sense that the IR will better reflect the guarantees provided in the source code. The caveat is `-fno-assume-sane-operator-new`, which currently prevents emitting `noalias` attribute, and is automatically passed by Sanitizers ([[ https://bugs.llvm.org/show_bug.cgi?id=16386 | PR16386 ]]) - should it also cover these attributes? The problem is that the flag is back-end-specific, as seen in `test/Modules/explicit-build-flags.cpp`. But while it is okay to add `noalias` metadata in backend, we really should be adding at least the alignment metadata to the AST, since that allows us to perform sema checks on it. Reviewers: erichkeane, rjmccall, jdoerfert, eugenis, rsmith Reviewed By: rsmith Subscribers: xbolva00, jrtc27, atanasyan, nlopes, cfe-commits Tags: #llvm, #clang Differential Revision: https://reviews.llvm.org/D73380
2020-02-26 06:37:17 +08:00
// CHECK: [[NEW:%.*]] = call noalias nonnull i8* @_Znwm(i64 8)
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
// CHECK-NEXT: [[FOO:%.*]] = invoke i32 @_ZN5test13fooEv()
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[FOO]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: ret [[A]]* [[CAST]]
// CHECK: call void @_ZdlPv(i8* [[NEW]])
extern int foo();
return new A(foo());
}
struct B { B(); ~B(); operator int(); int x; };
B makeB();
A *c() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test11cEv()
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[ACTIVE:%.*]] = alloca i1
[clang] Annotating C++'s `operator new` with more attributes Summary: Right now we annotate C++'s `operator new` with `noalias` attribute, which very much is healthy for optimizations. However as per [[ http://eel.is/c++draft/basic.stc.dynamic.allocation | `[basic.stc.dynamic.allocation]` ]], there are more promises on global `operator new`, namely: * non-`std::nothrow_t` `operator new` *never* returns `nullptr` * If `std::align_val_t align` parameter is taken, the pointer will also be `align`-aligned * ~~global `operator new`-returned pointer is `__STDCPP_DEFAULT_NEW_ALIGNMENT__`-aligned ~~ It's more caveated than that. Supplying this information may not cause immediate landslide effects on any specific benchmarks, but it for sure will be healthy for optimizer in the sense that the IR will better reflect the guarantees provided in the source code. The caveat is `-fno-assume-sane-operator-new`, which currently prevents emitting `noalias` attribute, and is automatically passed by Sanitizers ([[ https://bugs.llvm.org/show_bug.cgi?id=16386 | PR16386 ]]) - should it also cover these attributes? The problem is that the flag is back-end-specific, as seen in `test/Modules/explicit-build-flags.cpp`. But while it is okay to add `noalias` metadata in backend, we really should be adding at least the alignment metadata to the AST, since that allows us to perform sema checks on it. Reviewers: erichkeane, rjmccall, jdoerfert, eugenis, rsmith Reviewed By: rsmith Subscribers: xbolva00, jrtc27, atanasyan, nlopes, cfe-commits Tags: #llvm, #clang Differential Revision: https://reviews.llvm.org/D73380
2020-02-26 06:37:17 +08:00
// CHECK-NEXT: [[NEW:%.*]] = call noalias nonnull i8* @_Znwm(i64 8)
// CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]])
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK: [[T1:%.*]] = getelementptr inbounds [[B]], [[B]]* [[T0]], i32 0, i32 0
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: [[T2:%.*]] = load i32, i32* [[T1]], align 4
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T2]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: store i1 false, i1* [[ACTIVE]]
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
// CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: ret [[A]]* [[CAST]]
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: br i1 [[ISACTIVE]]
// CHECK: call void @_ZdlPv(i8* [[NEW]])
return new A(B().x);
}
Call __cxa_begin_catch with the current exception before calling std::terminate(). rdar://11904428 llvm-svn: 174940
2013-02-12 11:51:46 +08:00
// rdar://11904428
// Terminate landing pads should call __cxa_begin_catch first.
IR: print value numbers for unnamed function arguments For consistency with normal instructions and clarity when reading IR, it's best to print the %0, %1, ... names of function arguments in definitions. Also modifies the parser to accept IR in that form for obvious reasons. llvm-svn: 367755
2019-08-03 22:28:34 +08:00
// CHECK98: define linkonce_odr hidden void @__clang_call_terminate(i8* %0) [[NI_NR_NUW:#[0-9]+]] comdat
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98-NEXT: [[T0:%.*]] = call i8* @__cxa_begin_catch(i8* %0) [[NUW:#[0-9]+]]
// CHECK98-NEXT: call void @_ZSt9terminatev() [[NR_NUW:#[0-9]+]]
// CHECK98-NEXT: unreachable
Call __cxa_begin_catch with the current exception before calling std::terminate(). rdar://11904428 llvm-svn: 174940
2013-02-12 11:51:46 +08:00
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
A *d() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test11dEv()
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[ACTIVE:%.*]] = alloca i1
[clang] Annotating C++'s `operator new` with more attributes Summary: Right now we annotate C++'s `operator new` with `noalias` attribute, which very much is healthy for optimizations. However as per [[ http://eel.is/c++draft/basic.stc.dynamic.allocation | `[basic.stc.dynamic.allocation]` ]], there are more promises on global `operator new`, namely: * non-`std::nothrow_t` `operator new` *never* returns `nullptr` * If `std::align_val_t align` parameter is taken, the pointer will also be `align`-aligned * ~~global `operator new`-returned pointer is `__STDCPP_DEFAULT_NEW_ALIGNMENT__`-aligned ~~ It's more caveated than that. Supplying this information may not cause immediate landslide effects on any specific benchmarks, but it for sure will be healthy for optimizer in the sense that the IR will better reflect the guarantees provided in the source code. The caveat is `-fno-assume-sane-operator-new`, which currently prevents emitting `noalias` attribute, and is automatically passed by Sanitizers ([[ https://bugs.llvm.org/show_bug.cgi?id=16386 | PR16386 ]]) - should it also cover these attributes? The problem is that the flag is back-end-specific, as seen in `test/Modules/explicit-build-flags.cpp`. But while it is okay to add `noalias` metadata in backend, we really should be adding at least the alignment metadata to the AST, since that allows us to perform sema checks on it. Reviewers: erichkeane, rjmccall, jdoerfert, eugenis, rsmith Reviewed By: rsmith Subscribers: xbolva00, jrtc27, atanasyan, nlopes, cfe-commits Tags: #llvm, #clang Differential Revision: https://reviews.llvm.org/D73380
2020-02-26 06:37:17 +08:00
// CHECK-NEXT: [[NEW:%.*]] = call noalias nonnull i8* @_Znwm(i64 8)
// CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]])
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T1]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: store i1 false, i1* [[ACTIVE]]
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
// CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: ret [[A]]* [[CAST]]
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: br i1 [[ISACTIVE]]
// CHECK: call void @_ZdlPv(i8* [[NEW]])
return new A(B());
}
A *e() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test11eEv()
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[ACTIVE:%.*]] = alloca i1
[clang] Annotating C++'s `operator new` with more attributes Summary: Right now we annotate C++'s `operator new` with `noalias` attribute, which very much is healthy for optimizations. However as per [[ http://eel.is/c++draft/basic.stc.dynamic.allocation | `[basic.stc.dynamic.allocation]` ]], there are more promises on global `operator new`, namely: * non-`std::nothrow_t` `operator new` *never* returns `nullptr` * If `std::align_val_t align` parameter is taken, the pointer will also be `align`-aligned * ~~global `operator new`-returned pointer is `__STDCPP_DEFAULT_NEW_ALIGNMENT__`-aligned ~~ It's more caveated than that. Supplying this information may not cause immediate landslide effects on any specific benchmarks, but it for sure will be healthy for optimizer in the sense that the IR will better reflect the guarantees provided in the source code. The caveat is `-fno-assume-sane-operator-new`, which currently prevents emitting `noalias` attribute, and is automatically passed by Sanitizers ([[ https://bugs.llvm.org/show_bug.cgi?id=16386 | PR16386 ]]) - should it also cover these attributes? The problem is that the flag is back-end-specific, as seen in `test/Modules/explicit-build-flags.cpp`. But while it is okay to add `noalias` metadata in backend, we really should be adding at least the alignment metadata to the AST, since that allows us to perform sema checks on it. Reviewers: erichkeane, rjmccall, jdoerfert, eugenis, rsmith Reviewed By: rsmith Subscribers: xbolva00, jrtc27, atanasyan, nlopes, cfe-commits Tags: #llvm, #clang Differential Revision: https://reviews.llvm.org/D73380
2020-02-26 06:37:17 +08:00
// CHECK-NEXT: [[NEW:%.*]] = call noalias nonnull i8* @_Znwm(i64 8)
// CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN5test11BC1Ev([[B:%.*]]* [[T0:%.*]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]])
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK: invoke void @_ZN5test11BC1Ev([[B]]* [[T2:%.*]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[T3:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T2]])
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK: invoke void @_ZN5test11AC1Eii([[A]]* [[CAST]], i32 [[T1]], i32 [[T3]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: store i1 false, i1* [[ACTIVE]]
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98-NEXT: invoke void @_ZN5test11BD1Ev([[B]]* [[T2]])
// CHECK11-NEXT: call void @_ZN5test11BD1Ev([[B]]* [[T2]])
// CHECK98: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
// CHECK11: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: ret [[A]]* [[CAST]]
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: br i1 [[ISACTIVE]]
// CHECK: call void @_ZdlPv(i8* [[NEW]])
return new A(B(), B());
}
A *f() {
return new A(makeB().x);
}
A *g() {
return new A(makeB());
}
A *h() {
return new A(makeB(), makeB());
When an exception needs to be freed by calling __cxa_exception_free, make sure to stash away the exception pointer somewhere. This fixes an "Instruction does not dominate all uses!" verification error when compiling TableGen. llvm-svn: 91084
2009-12-11 08:32:37 +08:00
}
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
A *i() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test11iEv()
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[X:%.*]] = alloca [[A]]*, align 8
// CHECK: [[ACTIVE:%.*]] = alloca i1
[clang] Annotating C++'s `operator new` with more attributes Summary: Right now we annotate C++'s `operator new` with `noalias` attribute, which very much is healthy for optimizations. However as per [[ http://eel.is/c++draft/basic.stc.dynamic.allocation | `[basic.stc.dynamic.allocation]` ]], there are more promises on global `operator new`, namely: * non-`std::nothrow_t` `operator new` *never* returns `nullptr` * If `std::align_val_t align` parameter is taken, the pointer will also be `align`-aligned * ~~global `operator new`-returned pointer is `__STDCPP_DEFAULT_NEW_ALIGNMENT__`-aligned ~~ It's more caveated than that. Supplying this information may not cause immediate landslide effects on any specific benchmarks, but it for sure will be healthy for optimizer in the sense that the IR will better reflect the guarantees provided in the source code. The caveat is `-fno-assume-sane-operator-new`, which currently prevents emitting `noalias` attribute, and is automatically passed by Sanitizers ([[ https://bugs.llvm.org/show_bug.cgi?id=16386 | PR16386 ]]) - should it also cover these attributes? The problem is that the flag is back-end-specific, as seen in `test/Modules/explicit-build-flags.cpp`. But while it is okay to add `noalias` metadata in backend, we really should be adding at least the alignment metadata to the AST, since that allows us to perform sema checks on it. Reviewers: erichkeane, rjmccall, jdoerfert, eugenis, rsmith Reviewed By: rsmith Subscribers: xbolva00, jrtc27, atanasyan, nlopes, cfe-commits Tags: #llvm, #clang Differential Revision: https://reviews.llvm.org/D73380
2020-02-26 06:37:17 +08:00
// CHECK: [[NEW:%.*]] = call noalias nonnull i8* @_Znwm(i64 8)
// CHECK-NEXT: store i1 true, i1* [[ACTIVE]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
[CodeGen] Add an alignment attribute to all sret parameters This fixes a miscompile when the parameter is actually underaligned. rdar://58316406 Differential revision: https://reviews.llvm.org/D74183
2020-03-25 00:36:19 +08:00
// CHECK-NEXT: invoke void @_ZN5test15makeBEv([[B:%.*]]* sret align 4 [[T0:%.*]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[T1:%.*]] = invoke i32 @_ZN5test11BcviEv([[B]]* [[T0]])
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK: invoke void @_ZN5test11AC1Ei([[A]]* [[CAST]], i32 [[T1]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: store i1 false, i1* [[ACTIVE]]
// CHECK-NEXT: store [[A]]* [[CAST]], [[A]]** [[X]], align 8
[CodeGen] Add an alignment attribute to all sret parameters This fixes a miscompile when the parameter is actually underaligned. rdar://58316406 Differential revision: https://reviews.llvm.org/D74183
2020-03-25 00:36:19 +08:00
// CHECK: invoke void @_ZN5test15makeBEv([[B:%.*]]* sret align 4 [[T2:%.*]])
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[RET:%.*]] = load [[A]]*, [[A]]** [[X]], align 8
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: invoke void @_ZN5test11BD1Ev([[B]]* [[T2]])
// CHECK11: call void @_ZN5test11BD1Ev([[B]]* [[T2]])
// CHECK98: invoke void @_ZN5test11BD1Ev([[B]]* [[T0]])
// CHECK11: call void @_ZN5test11BD1Ev([[B]]* [[T0]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: ret [[A]]* [[RET]]
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[ACTIVE]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: br i1 [[ISACTIVE]]
// CHECK: call void @_ZdlPv(i8* [[NEW]])
A *x;
return (x = new A(makeB()), makeB(), x);
}
}
namespace test2 {
struct A {
A(int); A(int, int); ~A();
void *p;
void *operator new(size_t);
void operator delete(void*, size_t);
};
A *a() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test21aEv()
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[NEW:%.*]] = call i8* @_ZN5test21AnwEm(i64 8)
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN5test21AC1Ei([[A]]* [[CAST]], i32 5)
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: ret [[A]]* [[CAST]]
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: invoke void @_ZN5test21AdlEPvm(i8* [[NEW]], i64 8)
// CHECK11: call void @_ZN5test21AdlEPvm(i8* [[NEW]], i64 8)
// CHECK98: call void @__clang_call_terminate(i8* {{%.*}}) [[NR_NUW]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
return new A(5);
}
}
namespace test3 {
struct A {
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
A(int); A(int, int); A(const A&); ~A();
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
void *p;
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
void *operator new(size_t, void*, double);
void operator delete(void*, void*, double);
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
};
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
void *foo();
double bar();
A makeA(), *makeAPtr();
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
A *a() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test31aEv()
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[FOO:%.*]] = call i8* @_ZN5test33fooEv()
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
// CHECK: [[BAR:%.*]] = call double @_ZN5test33barEv()
// CHECK: [[NEW:%.*]] = call i8* @_ZN5test31AnwEmPvd(i64 8, i8* [[FOO]], double [[BAR]])
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN5test31AC1Ei([[A]]* [[CAST]], i32 5)
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: ret [[A]]* [[CAST]]
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: invoke void @_ZN5test31AdlEPvS1_d(i8* [[NEW]], i8* [[FOO]], double [[BAR]])
// CHECK11: call void @_ZN5test31AdlEPvS1_d(i8* [[NEW]], i8* [[FOO]], double [[BAR]])
// CHECK98: call void @__clang_call_terminate(i8* {{%.*}}) [[NR_NUW]]
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
return new(foo(),bar()) A(5);
}
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
// rdar://problem/8439196
A *b(bool cond) {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test31bEb(i1 zeroext
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
// CHECK: [[SAVED0:%.*]] = alloca i8*
// CHECK-NEXT: [[SAVED1:%.*]] = alloca i8*
// CHECK-NEXT: [[CLEANUPACTIVE:%.*]] = alloca i1
// CHECK: [[COND:%.*]] = trunc i8 {{.*}} to i1
Whenever explicitly activating or deactivating a cleanup, we need to provide a 'dominating IP' which is guaranteed to dominate the (de)activation point but which cannot be avoided along any execution path from the (de)activation point to the push-point of the cleanup. Using the entry block is bad mojo. llvm-svn: 144276
2011-11-10 18:43:54 +08:00
// CHECK-NEXT: store i1 false, i1* [[CLEANUPACTIVE]]
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
// CHECK-NEXT: br i1 [[COND]]
return (cond ?
// CHECK: [[FOO:%.*]] = call i8* @_ZN5test33fooEv()
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test31AnwEmPvd(i64 8, i8* [[FOO]], double [[CONST:.*]])
// CHECK-NEXT: store i8* [[NEW]], i8** [[SAVED0]]
// CHECK-NEXT: store i8* [[FOO]], i8** [[SAVED1]]
// CHECK-NEXT: store i1 true, i1* [[CLEANUPACTIVE]]
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
[CodeGen] Add an alignment attribute to all sret parameters This fixes a miscompile when the parameter is actually underaligned. rdar://58316406 Differential revision: https://reviews.llvm.org/D74183
2020-03-25 00:36:19 +08:00
// CHECK-NEXT: invoke void @_ZN5test35makeAEv([[A]]* sret align 8 [[CAST]])
Elide copy construction in new expressions. PR11757. llvm-svn: 150738
2012-02-17 06:45:48 +08:00
// CHECK: br label
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
// -> cond.end
new(foo(),10.0) A(makeA()) :
Elide copy construction in new expressions. PR11757. llvm-svn: 150738
2012-02-17 06:45:48 +08:00
// CHECK: [[MAKE:%.*]] = call [[A]]* @_ZN5test38makeAPtrEv()
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
// CHECK: br label
// -> cond.end
makeAPtr());
// cond.end:
// CHECK: [[RESULT:%.*]] = phi [[A]]* {{.*}}[[CAST]]{{.*}}[[MAKE]]
// CHECK: ret [[A]]* [[RESULT]]
// in the EH path:
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[ISACTIVE:%.*]] = load i1, i1* [[CLEANUPACTIVE]]
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
// CHECK-NEXT: br i1 [[ISACTIVE]]
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[V0:%.*]] = load i8*, i8** [[SAVED0]]
// CHECK-NEXT: [[V1:%.*]] = load i8*, i8** [[SAVED1]]
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98-NEXT: invoke void @_ZN5test31AdlEPvS1_d(i8* [[V0]], i8* [[V1]], double [[CONST]])
// CHECK11-NEXT: call void @_ZN5test31AdlEPvS1_d(i8* [[V0]], i8* [[V1]], double [[CONST]])
When emitting a new-expression inside a conditional expression, the cleanup might not be dominated by the allocation code. In this case, we have to store aside all the delete arguments in case we need them later. There's room for optimization here in cases where we end up not actually needing the cleanup in different branches (or being able to pop it after the initialization code). Also make sure we only call this operator delete along the path where we actually allocated something. Fixes rdar://problem/8439196. llvm-svn: 114145
2010-09-17 08:50:28 +08:00
}
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
}
namespace test4 {
struct A {
A(int); A(int, int); ~A();
void *p;
void *operator new(size_t, void*, void*);
void operator delete(void*, size_t, void*, void*); // not a match
};
A *a() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[A:%.*]]* @_ZN5test41aEv()
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK: [[FOO:%.*]] = call i8* @_ZN5test43fooEv()
// CHECK-NEXT: [[BAR:%.*]] = call i8* @_ZN5test43barEv()
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test41AnwEmPvS1_(i64 8, i8* [[FOO]], i8* [[BAR]])
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[NEW]] to [[A]]*
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: call void @_ZN5test41AC1Ei([[A]]* [[CAST]], i32 5)
Implement the EH cleanup to call 'operator delete' if a new-expression throws (but not if destructors associated with the full-expression throw). llvm-svn: 113836
2010-09-14 15:57:04 +08:00
// CHECK-NEXT: ret [[A]]* [[CAST]]
extern void *foo(), *bar();
return new(foo(),bar()) A(5);
}
When an exception needs to be freed by calling __cxa_exception_free, make sure to stash away the exception pointer somewhere. This fixes an "Instruction does not dominate all uses!" verification error when compiling TableGen. llvm-svn: 91084
2009-12-11 08:32:37 +08:00
}
Save a copy expression for non-trivial copy constructions of catch variables. llvm-svn: 125661
2011-02-16 16:02:54 +08:00
// PR7908
namespace test5 {
struct T { T(); ~T(); };
struct A {
A(const A &x, const T &t = T());
~A();
};
void foo();
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK-LABEL: define void @_ZN5test54testEv()
Save a copy expression for non-trivial copy constructions of catch variables. llvm-svn: 125661
2011-02-16 16:02:54 +08:00
// CHECK: [[EXNSLOT:%.*]] = alloca i8*
Convert Clang over to resuming from landing pads with llvm.eh.resume. It's quite likely that this will explode, but I need to know how. :) llvm-svn: 132269
2011-05-29 05:13:02 +08:00
// CHECK-NEXT: [[SELECTORSLOT:%.*]] = alloca i32
Save a copy expression for non-trivial copy constructions of catch variables. llvm-svn: 125661
2011-02-16 16:02:54 +08:00
// CHECK-NEXT: [[A:%.*]] = alloca [[A_T:%.*]], align 1
// CHECK-NEXT: [[T:%.*]] = alloca [[T_T:%.*]], align 1
// CHECK-NEXT: invoke void @_ZN5test53fooEv()
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[EXN:%.*]] = load i8*, i8** [[EXNSLOT]]
Save a copy expression for non-trivial copy constructions of catch variables. llvm-svn: 125661
2011-02-16 16:02:54 +08:00
// CHECK-NEXT: [[ADJ:%.*]] = call i8* @__cxa_get_exception_ptr(i8* [[EXN]])
// CHECK-NEXT: [[SRC:%.*]] = bitcast i8* [[ADJ]] to [[A_T]]*
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN5test51TC1Ev([[T_T]]* [[T]])
[CGCall] Annotate references with "align" attribute. If we're going to assume references are dereferenceable, we should also assume they're aligned: otherwise, we can't actually dereference them. See also D80072. Differential Revision: https://reviews.llvm.org/D80166
2020-05-19 02:29:11 +08:00
// CHECK: invoke void @_ZN5test51AC1ERKS0_RKNS_1TE([[A_T]]* [[A]], [[A_T]]* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[SRC]], [[T_T]]* nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) [[T]])
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: invoke void @_ZN5test51TD1Ev([[T_T]]* [[T]])
// CHECK11: call void @_ZN5test51TD1Ev([[T_T]]* [[T]])
// CHECK98: call i8* @__cxa_begin_catch(i8* [[EXN]]) [[NUW]]
// CHECK98-NEXT: invoke void @_ZN5test51AD1Ev([[A_T]]* [[A]])
Save a copy expression for non-trivial copy constructions of catch variables. llvm-svn: 125661
2011-02-16 16:02:54 +08:00
// CHECK: call void @__cxa_end_catch()
void test() {
try {
foo();
} catch (A a) {
}
}
}
Tame an assert; the scope depth of a jump destination does not necessarily enclose the innermost normal cleanup depth, because the top of the jump scope stack might be an EH cleanup or EH scope. Fixes PR9303. llvm-svn: 126472
2011-02-25 12:19:13 +08:00
// PR9303: invalid assert on this
namespace test6 {
bool cond();
void test() {
try {
lbl:
if (cond()) goto lbl;
} catch (...) {
}
}
}
An operator new with an empty exception specifier returns null on a bad allocation and therefore requires a null-check. We were doing that, but we weren't treating the new-initializer as being conditionally executed, which means it was possible to get ill-formed IR as in PR9298. llvm-svn: 127147
2011-03-07 09:52:56 +08:00
// PR9298
namespace test7 {
struct A { A(); ~A(); };
struct B {
// The throw() operator means that a bad allocation is signalled
// with a null return, which means that the initializer is
// evaluated conditionally.
static void *operator new(size_t size) throw();
B(const A&, B*);
~B();
};
B *test() {
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define [[B:%.*]]* @_ZN5test74testEv()
The conditional needs to be pushed before the branch. Make the test less trivial to check this. Adjust for style. llvm-svn: 127151
2011-03-07 11:12:35 +08:00
// CHECK: [[OUTER_NEW:%.*]] = alloca i1
// CHECK-NEXT: alloca [[A:%.*]],
// CHECK-NEXT: alloca i8*
// CHECK-NEXT: alloca i32
// CHECK-NEXT: [[OUTER_A:%.*]] = alloca i1
// CHECK-NEXT: alloca i8*
// CHECK-NEXT: [[INNER_NEW:%.*]] = alloca i1
// CHECK-NEXT: alloca [[A]]
// CHECK-NEXT: [[INNER_A:%.*]] = alloca i1
// Allocate the outer object.
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm(
// CHECK-NEXT: icmp eq i8* [[NEW]], null
// These stores, emitted before the outermost conditional branch,
// deactivate the temporary cleanups.
Whenever explicitly activating or deactivating a cleanup, we need to provide a 'dominating IP' which is guaranteed to dominate the (de)activation point but which cannot be avoided along any execution path from the (de)activation point to the push-point of the cleanup. Using the entry block is bad mojo. llvm-svn: 144276
2011-11-10 18:43:54 +08:00
// CHECK-NEXT: store i1 false, i1* [[OUTER_NEW]]
The conditional needs to be pushed before the branch. Make the test less trivial to check this. Adjust for style. llvm-svn: 127151
2011-03-07 11:12:35 +08:00
// CHECK-NEXT: store i1 false, i1* [[OUTER_A]]
Whenever explicitly activating or deactivating a cleanup, we need to provide a 'dominating IP' which is guaranteed to dominate the (de)activation point but which cannot be avoided along any execution path from the (de)activation point to the push-point of the cleanup. Using the entry block is bad mojo. llvm-svn: 144276
2011-11-10 18:43:54 +08:00
// CHECK-NEXT: store i1 false, i1* [[INNER_NEW]]
The conditional needs to be pushed before the branch. Make the test less trivial to check this. Adjust for style. llvm-svn: 127151
2011-03-07 11:12:35 +08:00
// CHECK-NEXT: store i1 false, i1* [[INNER_A]]
// CHECK-NEXT: br i1
// We passed the first null check; activate that cleanup and continue.
// CHECK: store i1 true, i1* [[OUTER_NEW]]
// CHECK-NEXT: bitcast
// Create the first A temporary and activate that cleanup.
// CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
// CHECK: store i1 true, i1* [[OUTER_A]]
// Allocate the inner object.
// CHECK-NEXT: [[NEW:%.*]] = call i8* @_ZN5test71BnwEm(
// CHECK-NEXT: icmp eq i8* [[NEW]], null
// CHECK-NEXT: br i1
// We passed the second null check; save that pointer, activate
// that cleanup, and continue.
// CHECK: store i8* [[NEW]]
// CHECK-NEXT: store i1 true, i1* [[INNER_NEW]]
// CHECK-NEXT: bitcast
// Build the second A temporary and activate that cleanup.
// CHECK-NEXT: invoke void @_ZN5test71AC1Ev(
// CHECK: store i1 true, i1* [[INNER_A]]
// Build the inner B object and deactivate the inner delete cleanup.
// CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_(
// CHECK: store i1 false, i1* [[INNER_NEW]]
// CHECK: phi
// Build the outer B object and deactivate the outer delete cleanup.
// CHECK-NEXT: invoke void @_ZN5test71BC1ERKNS_1AEPS0_(
// CHECK: store i1 false, i1* [[OUTER_NEW]]
// CHECK: phi
During jump-scope checking, build an ExprWithCleanups immediately into the enclosing scope; this is a more accurate model but is (I believe) unnecessary in my test case due to other flaws. However, one of those flaws is now intentional: blocks which appear in return statements can be trivially observed to not extend in lifetime past the return, and so we can allow a jump past them. Do the necessary magic in IR-generation to make this work. llvm-svn: 164589
2012-09-25 14:56:03 +08:00
// CHECK-NEXT: store [[B]]*
The conditional needs to be pushed before the branch. Make the test less trivial to check this. Adjust for style. llvm-svn: 127151
2011-03-07 11:12:35 +08:00
// Destroy the inner A object.
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: load i1, i1* [[INNER_A]]
The conditional needs to be pushed before the branch. Make the test less trivial to check this. Adjust for style. llvm-svn: 127151
2011-03-07 11:12:35 +08:00
// CHECK-NEXT: br i1
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: invoke void @_ZN5test71AD1Ev(
// CHECK11: call void @_ZN5test71AD1Ev(
The conditional needs to be pushed before the branch. Make the test less trivial to check this. Adjust for style. llvm-svn: 127151
2011-03-07 11:12:35 +08:00
// Destroy the outer A object.
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: load i1, i1* [[OUTER_A]]
The conditional needs to be pushed before the branch. Make the test less trivial to check this. Adjust for style. llvm-svn: 127151
2011-03-07 11:12:35 +08:00
// CHECK-NEXT: br i1
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: invoke void @_ZN5test71AD1Ev(
// CHECK11: call void @_ZN5test71AD1Ev(
The conditional needs to be pushed before the branch. Make the test less trivial to check this. Adjust for style. llvm-svn: 127151
2011-03-07 11:12:35 +08:00
An operator new with an empty exception specifier returns null on a bad allocation and therefore requires a null-check. We were doing that, but we weren't treating the new-initializer as being conditionally executed, which means it was possible to get ill-formed IR as in PR9298. llvm-svn: 127147
2011-03-07 09:52:56 +08:00
return new B(A(), new B(A(), 0));
}
}
The allocated exception slot does not alias anything; should fix self-host. llvm-svn: 138615
2011-08-26 08:46:38 +08:00
// Just don't crash.
namespace test8 {
struct A {
An initialization does not alias. llvm-svn: 138624
2011-08-26 13:38:08 +08:00
// Having both of these is required to trigger the assert we're
// trying to avoid.
The allocated exception slot does not alias anything; should fix self-host. llvm-svn: 138615
2011-08-26 08:46:38 +08:00
A(const A&);
An initialization does not alias. llvm-svn: 138624
2011-08-26 13:38:08 +08:00
A&operator=(const A&);
The allocated exception slot does not alias anything; should fix self-host. llvm-svn: 138615
2011-08-26 08:46:38 +08:00
~A();
};
A makeA();
void test() {
throw makeA();
}
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK-LABEL: define void @_ZN5test84testEv
Rearrange code so that we pass the right pointer to delete[] when an exception is thrown constructing the array elements in an array new expression. Fixes PR10870. llvm-svn: 139158
2011-09-07 02:53:03 +08:00
}
// Make sure we generate the correct code for the delete[] call which
// happens if A::A() throws. (We were previously calling delete[] on
// a pointer to the first array element, not the pointer returned by new[].)
// PR10870
namespace test9 {
struct A {
A();
~A();
};
A* test() {
return new A[10];
}
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK: define {{%.*}}* @_ZN5test94testEv
[clang] Annotating C++'s `operator new` with more attributes Summary: Right now we annotate C++'s `operator new` with `noalias` attribute, which very much is healthy for optimizations. However as per [[ http://eel.is/c++draft/basic.stc.dynamic.allocation | `[basic.stc.dynamic.allocation]` ]], there are more promises on global `operator new`, namely: * non-`std::nothrow_t` `operator new` *never* returns `nullptr` * If `std::align_val_t align` parameter is taken, the pointer will also be `align`-aligned * ~~global `operator new`-returned pointer is `__STDCPP_DEFAULT_NEW_ALIGNMENT__`-aligned ~~ It's more caveated than that. Supplying this information may not cause immediate landslide effects on any specific benchmarks, but it for sure will be healthy for optimizer in the sense that the IR will better reflect the guarantees provided in the source code. The caveat is `-fno-assume-sane-operator-new`, which currently prevents emitting `noalias` attribute, and is automatically passed by Sanitizers ([[ https://bugs.llvm.org/show_bug.cgi?id=16386 | PR16386 ]]) - should it also cover these attributes? The problem is that the flag is back-end-specific, as seen in `test/Modules/explicit-build-flags.cpp`. But while it is okay to add `noalias` metadata in backend, we really should be adding at least the alignment metadata to the AST, since that allows us to perform sema checks on it. Reviewers: erichkeane, rjmccall, jdoerfert, eugenis, rsmith Reviewed By: rsmith Subscribers: xbolva00, jrtc27, atanasyan, nlopes, cfe-commits Tags: #llvm, #clang Differential Revision: https://reviews.llvm.org/D73380
2020-02-26 06:37:17 +08:00
// CHECK: [[TEST9_NEW:%.*]] = call noalias nonnull i8* @_Znam
Rearrange code so that we pass the right pointer to delete[] when an exception is thrown constructing the array elements in an array new expression. Fixes PR10870. llvm-svn: 139158
2011-09-07 02:53:03 +08:00
// CHECK: call void @_ZdaPv(i8* [[TEST9_NEW]])
The allocated exception slot does not alias anything; should fix self-host. llvm-svn: 138615
2011-08-26 08:46:38 +08:00
}
It turns out that implementing the rethrow-on-fallthrough semantics of a ctor/dtor function-try-block catch handler by pushing a normal cleanup is not just overkill but actually actively wrong when the handler contains an explicit return (which is only legal in a dtor). Just emit the rethrow as ordinary code at the fallthrough point. Fixes PR13102. llvm-svn: 158488
2012-06-15 13:27:05 +08:00
// In a destructor with a function-try-block, a return statement in a
// catch handler behaves differently from running off the end of the
// catch handler. PR13102.
namespace test10 {
extern void cleanup();
extern bool suppress;
struct A { ~A(); };
A::~A() try { cleanup(); } catch (...) { return; }
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK-LABEL: define void @_ZN6test101AD1Ev(
It turns out that implementing the rethrow-on-fallthrough semantics of a ctor/dtor function-try-block catch handler by pushing a normal cleanup is not just overkill but actually actively wrong when the handler contains an explicit return (which is only legal in a dtor). Just emit the rethrow as ordinary code at the fallthrough point. Fixes PR13102. llvm-svn: 158488
2012-06-15 13:27:05 +08:00
// CHECK: invoke void @_ZN6test107cleanupEv()
// CHECK-NOT: rethrow
// CHECK: ret void
struct B { ~B(); };
B::~B() try { cleanup(); } catch (...) {}
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK-LABEL: define void @_ZN6test101BD1Ev(
It turns out that implementing the rethrow-on-fallthrough semantics of a ctor/dtor function-try-block catch handler by pushing a normal cleanup is not just overkill but actually actively wrong when the handler contains an explicit return (which is only legal in a dtor). Just emit the rethrow as ordinary code at the fallthrough point. Fixes PR13102. llvm-svn: 158488
2012-06-15 13:27:05 +08:00
// CHECK: invoke void @_ZN6test107cleanupEv()
// CHECK: call i8* @__cxa_begin_catch
// CHECK-NEXT: invoke void @__cxa_rethrow()
// CHECK: unreachable
struct C { ~C(); };
C::~C() try { cleanup(); } catch (...) { if (suppress) return; }
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK-LABEL: define void @_ZN6test101CD1Ev(
It turns out that implementing the rethrow-on-fallthrough semantics of a ctor/dtor function-try-block catch handler by pushing a normal cleanup is not just overkill but actually actively wrong when the handler contains an explicit return (which is only legal in a dtor). Just emit the rethrow as ordinary code at the fallthrough point. Fixes PR13102. llvm-svn: 158488
2012-06-15 13:27:05 +08:00
// CHECK: invoke void @_ZN6test107cleanupEv()
// CHECK: call i8* @__cxa_begin_catch
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: load i8, i8* @_ZN6test108suppressE, align 1
It turns out that implementing the rethrow-on-fallthrough semantics of a ctor/dtor function-try-block catch handler by pushing a normal cleanup is not just overkill but actually actively wrong when the handler contains an explicit return (which is only legal in a dtor). Just emit the rethrow as ordinary code at the fallthrough point. Fixes PR13102. llvm-svn: 158488
2012-06-15 13:27:05 +08:00
// CHECK-NEXT: trunc
// CHECK-NEXT: br i1
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: call void @__cxa_end_catch()
// CHECK98-NEXT: br label
// CHECK11: invoke void @__cxa_end_catch()
// CHECK11-NEXT: to label
It turns out that implementing the rethrow-on-fallthrough semantics of a ctor/dtor function-try-block catch handler by pushing a normal cleanup is not just overkill but actually actively wrong when the handler contains an explicit return (which is only legal in a dtor). Just emit the rethrow as ordinary code at the fallthrough point. Fixes PR13102. llvm-svn: 158488
2012-06-15 13:27:05 +08:00
// CHECK: invoke void @__cxa_rethrow()
// CHECK: unreachable
}
Destroy arrays and ARC fields when throwing out of ctors. Previously we were only handling non-array fields of class type. Testcases derived from a patch by WenHan Gu. llvm-svn: 174146
2013-02-01 13:11:40 +08:00
// Ensure that an exception in a constructor destroys
// already-constructed array members. PR14514
namespace test11 {
struct A {
A();
~A() {}
};
struct C {
A single;
A array[2][3];
C();
};
C::C() {
throw 0;
}
Revert "[CodeGenModule] Assume dso_local for -fpic -fno-semantic-interposition" This reverts commit 789a46f2d742e11edaade28cb59a0f4d2a1d770e. Accidentally committed.
2020-02-04 02:09:39 +08:00
// CHECK-LABEL: define void @_ZN6test111CC2Ev(
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[THIS:%.*]] = load [[C:%.*]]*, [[C:%.*]]** {{%.*}}
Destroy arrays and ARC fields when throwing out of ctors. Previously we were only handling non-array fields of class type. Testcases derived from a patch by WenHan Gu. llvm-svn: 174146
2013-02-01 13:11:40 +08:00
// Construct single.
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[SINGLE:%.*]] = getelementptr inbounds [[C]], [[C]]* [[THIS]], i32 0, i32 0
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: call void @_ZN6test111AC1Ev([[A:%.*]]* [[SINGLE]])
Destroy arrays and ARC fields when throwing out of ctors. Previously we were only handling non-array fields of class type. Testcases derived from a patch by WenHan Gu. llvm-svn: 174146
2013-02-01 13:11:40 +08:00
// Construct array.
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[ARRAY:%.*]] = getelementptr inbounds [[C]], [[C]]* [[THIS]], i32 0, i32 1
// CHECK-NEXT: [[ARRAYBEGIN:%.*]] = getelementptr inbounds [2 x [3 x [[A]]]], [2 x [3 x [[A]]]]* [[ARRAY]], i32 0, i32 0, i32 0
// CHECK-NEXT: [[ARRAYEND:%.*]] = getelementptr inbounds [[A]], [[A]]* [[ARRAYBEGIN]], i64 6
Destroy arrays and ARC fields when throwing out of ctors. Previously we were only handling non-array fields of class type. Testcases derived from a patch by WenHan Gu. llvm-svn: 174146
2013-02-01 13:11:40 +08:00
// CHECK-NEXT: br label
// CHECK: [[CUR:%.*]] = phi [[A]]* [ [[ARRAYBEGIN]], {{%.*}} ], [ [[NEXT:%.*]], {{%.*}} ]
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN6test111AC1Ev([[A:%.*]]* [[CUR]])
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK: [[NEXT]] = getelementptr inbounds [[A]], [[A]]* [[CUR]], i64 1
Destroy arrays and ARC fields when throwing out of ctors. Previously we were only handling non-array fields of class type. Testcases derived from a patch by WenHan Gu. llvm-svn: 174146
2013-02-01 13:11:40 +08:00
// CHECK-NEXT: [[DONE:%.*]] = icmp eq [[A]]* [[NEXT]], [[ARRAYEND]]
// CHECK-NEXT: br i1 [[DONE]],
// throw 0;
// CHECK: invoke void @__cxa_throw(
// Landing pad 1, from constructor in array-initialization loop:
// CHECK: landingpad
// - First, destroy already-constructed bits of array.
// CHECK: [[EMPTY:%.*]] = icmp eq [[A]]* [[ARRAYBEGIN]], [[CUR]]
// CHECK-NEXT: br i1 [[EMPTY]]
// CHECK: [[AFTER:%.*]] = phi [[A]]* [ [[CUR]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A]], [[A]]* [[AFTER]], i64 -1
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98-NEXT: invoke void @_ZN6test111AD1Ev([[A]]* [[ELT]])
// CHECK11-NEXT: call void @_ZN6test111AD1Ev([[A]]* [[ELT]])
Destroy arrays and ARC fields when throwing out of ctors. Previously we were only handling non-array fields of class type. Testcases derived from a patch by WenHan Gu. llvm-svn: 174146
2013-02-01 13:11:40 +08:00
// CHECK: [[DONE:%.*]] = icmp eq [[A]]* [[ELT]], [[ARRAYBEGIN]]
// CHECK-NEXT: br i1 [[DONE]],
// - Next, chain to cleanup for single.
// CHECK: br label
// Landing pad 2, from throw site.
// CHECK: landingpad
// - First, destroy all of array.
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK: [[ARRAYBEGIN:%.*]] = getelementptr inbounds [2 x [3 x [[A]]]], [2 x [3 x [[A]]]]* [[ARRAY]], i32 0, i32 0, i32 0
// CHECK-NEXT: [[ARRAYEND:%.*]] = getelementptr inbounds [[A]], [[A]]* [[ARRAYBEGIN]], i64 6
Destroy arrays and ARC fields when throwing out of ctors. Previously we were only handling non-array fields of class type. Testcases derived from a patch by WenHan Gu. llvm-svn: 174146
2013-02-01 13:11:40 +08:00
// CHECK-NEXT: br label
// CHECK: [[AFTER:%.*]] = phi [[A]]* [ [[ARRAYEND]], {{%.*}} ], [ [[ELT:%.*]], {{%.*}} ]
Update Clang tests to handle explicitly typed gep changes in LLVM. llvm-svn: 230783
2015-02-28 03:18:17 +08:00
// CHECK-NEXT: [[ELT]] = getelementptr inbounds [[A]], [[A]]* [[AFTER]], i64 -1
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98-NEXT: invoke void @_ZN6test111AD1Ev([[A]]* [[ELT]])
// CHECK11-NEXT: call void @_ZN6test111AD1Ev([[A]]* [[ELT]])
Destroy arrays and ARC fields when throwing out of ctors. Previously we were only handling non-array fields of class type. Testcases derived from a patch by WenHan Gu. llvm-svn: 174146
2013-02-01 13:11:40 +08:00
// CHECK: [[DONE:%.*]] = icmp eq [[A]]* [[ELT]], [[ARRAYBEGIN]]
// CHECK-NEXT: br i1 [[DONE]],
// - Next, chain to cleanup for single.
// CHECK: br label
// Finally, the cleanup for single.
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: invoke void @_ZN6test111AD1Ev([[A]]* [[SINGLE]])
// CHECK11: call void @_ZN6test111AD1Ev([[A]]* [[SINGLE]])
Destroy arrays and ARC fields when throwing out of ctors. Previously we were only handling non-array fields of class type. Testcases derived from a patch by WenHan Gu. llvm-svn: 174146
2013-02-01 13:11:40 +08:00
// CHECK: br label
// CHECK: resume
// (After this is a terminate landingpad.)
}
Modify the tests to use attribute group references instead of listing the function attributes. llvm-svn: 175606
2013-02-20 15:22:19 +08:00
Don't crash when a reserved global placement operator new is paired with a non-reserved operator delete in a new-expression. llvm-svn: 248862
2015-09-30 07:55:17 +08:00
namespace test12 {
struct A {
void operator delete(void *, void *);
A();
};
A *test(void *ptr) {
return new (ptr) A();
}
// CHECK-LABEL: define {{.*}} @_ZN6test124testEPv(
// CHECK: [[PTR:%.*]] = load i8*, i8*
// CHECK-NEXT: [[CAST:%.*]] = bitcast i8* [[PTR]] to [[A:%.*]]*
Revert "[CodeGenCXX] Treat 'this' as noalias in constructors" This reverts commit https://reviews.llvm.org/rL344150 which causes MachineOutliner related failures on the ppc64le multistage buildbot. llvm-svn: 344526
2018-10-15 23:43:00 +08:00
// CHECK-NEXT: invoke void @_ZN6test121AC1Ev([[A]]* [[CAST]])
Don't crash when a reserved global placement operator new is paired with a non-reserved operator delete in a new-expression. llvm-svn: 248862
2015-09-30 07:55:17 +08:00
// CHECK: ret [[A]]* [[CAST]]
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: invoke void @_ZN6test121AdlEPvS1_(i8* [[PTR]], i8* [[PTR]])
// CHECK11: call void @_ZN6test121AdlEPvS1_(i8* [[PTR]], i8* [[PTR]])
Don't crash when a reserved global placement operator new is paired with a non-reserved operator delete in a new-expression. llvm-svn: 248862
2015-09-30 07:55:17 +08:00
}
[Lit Test] Make tests C++11 compatible - nothrow destructors In C++11, a destructor's implicit exception-spec is nothrow. The IR for the destructor's invocation changed from invoke to call. Differential Revision: https://reviews.llvm.org/D28425 llvm-svn: 291458
2017-01-10 02:24:16 +08:00
// CHECK98: attributes [[NI_NR_NUW]] = { noinline noreturn nounwind }