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

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

83 lines
2.8 KiB
Plaintext
Raw Normal View History

In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// RUN: %clang_cc1 -triple i386-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 -emit-llvm -fexceptions -fobjc-exceptions -O2 -o - %s | FileCheck %s
// Test we maintain at least a basic amount of interoperation between
// ObjC and C++ exceptions in the legacy runtime.
// rdar://12364847
void foo(void);
void test0(id obj) {
@synchronized(obj) {
foo();
}
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @_Z5test0P11objc_object(
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// Enter the @synchronized block.
// CHECK: call i32 @objc_sync_enter(i8* [[OBJ:%.*]])
Adjust clang side tests effected by 239795 before reapplying said change llvm-svn: 239848
2015-06-17 04:24:06 +08:00
// CHECK: call void @objc_exception_try_enter([[BUF_T:%.*]]* nonnull [[BUF:%.*]])
Update clang tests for LLVM r277950 We infer inbounds on GEPs of allocas leading to minor perturbations in tests. llvm-svn: 277953
2016-08-07 16:28:58 +08:00
// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[BUF_T]], [[BUF_T]]* [[BUF]], i32 0, i32 0, i32 0
Update clang unittests for rL281586. The change in rL281586 is in llvm component and tests updated here are in clang component, so I have to commit them consecutively. llvm-svn: 281587
2016-09-15 14:31:30 +08:00
// CHECK-NEXT: [[T1:%.*]] = call i32 @_setjmp(i32* nonnull [[T0]])
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// CHECK-NEXT: [[T2:%.*]] = icmp eq i32 [[T1]], 0
// CHECK-NEXT: br i1 [[T2]],
// Body.
// CHECK: invoke void @_Z3foov()
// Leave the @synchronized. The reload of obj here is unnecessary.
Adjust clang side tests effected by 239795 before reapplying said change llvm-svn: 239848
2015-06-17 04:24:06 +08:00
// CHECK: call void @objc_exception_try_exit([[BUF_T]]* nonnull [[BUF]])
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: [[T0:%.*]] = load i8*, i8**
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// CHECK-NEXT: call i32 @objc_sync_exit(i8* [[T0]])
// CHECK-NEXT: ret void
// Real EH cleanup.
// CHECK: [[T0:%.*]] = landingpad
// CHECK-NEXT: cleanup
Adjust clang side tests effected by 239795 before reapplying said change llvm-svn: 239848
2015-06-17 04:24:06 +08:00
// CHECK-NEXT: call void @objc_exception_try_exit([[BUF_T]]* nonnull [[BUF]])
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: [[T0:%.*]] = load i8*, i8**
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// CHECK-NEXT: call i32 @objc_sync_exit(i8* [[T0]])
// CHECK-NEXT: resume
// ObjC EH "cleanup".
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK: [[T0:%.*]] = load i8*, i8**
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// CHECK-NEXT: call i32 @objc_sync_exit(i8* [[T0]])
Adjust clang side tests effected by 239795 before reapplying said change llvm-svn: 239848
2015-06-17 04:24:06 +08:00
// CHECK-NEXT: [[T0:%.*]] = call i8* @objc_exception_extract([[BUF_T]]* nonnull [[BUF]])
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// CHECK-NEXT: call void @objc_exception_throw(i8* [[T0]])
// CHECK-NEXT: unreachable
void test1(id obj, bool *failed) {
@try {
foo();
} @catch (...) {
*failed = true;
}
}
[test] Add {{.*}} to make tests immune to dso_local/dso_preemptable/(none) differences For a definition (of most linkage types), dso_local is set for ELF -fno-pic/-fpie and COFF, but not for Mach-O. This nuance causes unneeded binary format differences. This patch replaces (function) `define ` with `define{{.*}} `, (variable/constant/alias) `= ` with `={{.*}} `, or inserts appropriate `{{.*}} ` if there is an explicit linkage. * Clang will set dso_local for Mach-O, which is currently implied by TargetMachine.cpp. This will make COFF/Mach-O and executable ELF similar. * Eventually I hope we can make dso_local the textual LLVM IR default (write explicit "dso_preemptable" when applicable) and -fpic ELF will be similar to everything else. This patch helps move toward that goal.
2020-12-31 12:45:56 +08:00
// CHECK-LABEL: define{{.*}} void @_Z5test1P11objc_objectPb(
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// Enter the @try block.
Adjust clang side tests effected by 239795 before reapplying said change llvm-svn: 239848
2015-06-17 04:24:06 +08:00
// CHECK: call void @objc_exception_try_enter([[BUF_T]]* nonnull [[BUF:%.*]])
Update clang tests for LLVM r277950 We infer inbounds on GEPs of allocas leading to minor perturbations in tests. llvm-svn: 277953
2016-08-07 16:28:58 +08:00
// CHECK-NEXT: [[T0:%.*]] = getelementptr inbounds [[BUF_T]], [[BUF_T]]* [[BUF]], i32 0, i32 0, i32 0
Update clang unittests for rL281586. The change in rL281586 is in llvm component and tests updated here are in clang component, so I have to commit them consecutively. llvm-svn: 281587
2016-09-15 14:31:30 +08:00
// CHECK-NEXT: [[T1:%.*]] = call i32 @_setjmp(i32* nonnull [[T0]])
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// CHECK-NEXT: [[T2:%.*]] = icmp eq i32 [[T1]], 0
// CHECK-NEXT: br i1 [[T2]],
// Body.
// CHECK: invoke void @_Z3foov()
Re-enable "[InstCombine] Simplify boolean Phis with const inputs using CFG" This reverts commit b893822e32ffe3c1dcf4d5ac0571a282582d72b2. + Clang test fixes + Insertion point fix for landing pads
2020-07-16 14:29:16 +08:00
// Catch handler. Reload of 'failed' address is unnecessary.
// CHECK: [[T0:%.*]] = load i8*, i8**
// CHECK-NEXT: store i8 1, i8* [[T0]],
// CHECK-NEXT: br label
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// Leave the @try.
Adjust clang side tests effected by 239795 before reapplying said change llvm-svn: 239848
2015-06-17 04:24:06 +08:00
// CHECK: call void @objc_exception_try_exit([[BUF_T]]* nonnull [[BUF]])
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// CHECK-NEXT: br label
// CHECK: ret void
Re-enable "[InstCombine] Simplify boolean Phis with const inputs using CFG" This reverts commit b893822e32ffe3c1dcf4d5ac0571a282582d72b2. + Clang test fixes + Insertion point fix for landing pads
2020-07-16 14:29:16 +08:00
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// Real EH cleanup.
// CHECK: [[T0:%.*]] = landingpad
// CHECK-NEXT: cleanup
Adjust clang side tests effected by 239795 before reapplying said change llvm-svn: 239848
2015-06-17 04:24:06 +08:00
// CHECK-NEXT: call void @objc_exception_try_exit([[BUF_T]]* nonnull [[BUF]])
In ObjC++ on legacy runtimes, push an EH cleanup as well as a normal cleanup when entering a @try or @synchronized to ensure that we clean that up if an exception is triggered. Apparently GCC did this, so it's hard to argue that we shouldn't do at least as much. rdar://12364847 llvm-svn: 178599
2013-04-03 08:56:07 +08:00
// CHECK-NEXT: resume