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

187 lines
5.7 KiB
Mathematica
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 x86_64-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 -emit-llvm -fobjc-exceptions -O2 -o - %s | FileCheck %s
NeXT/EH: When generating the rethrow code for a finally block, make sure to chain outwards when inside a nested exception scope. - A real test for this is going into LLVM test-suite. llvm-svn: 102204
2010-04-24 03:12:32 +08:00
//
// <rdar://problem/7471679> [irgen] [eh] Exception code built with clang (x86_64) crashes
// Just check that we don't emit any dead blocks.
@interface NSArray @end
void f0() {
@try {
@try {
@throw @"a";
} @catch(NSArray *e) {
}
} @catch (id e) {
}
}
Validated by nightly-test runs on x86 and x86-64 darwin, including after self-host. Hopefully these results hold up on different platforms. I tried to keep the GNU ObjC runtime happy, but it's hard for me to test. Reimplement how clang generates IR for exceptions. Instead of creating new invoke destinations which sequentially chain to the previous destination, push a more semantic representation of *why* we need the cleanup/catch/filter behavior, then collect that information into a single landing pad upon request. Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional control flow) are generated, since it's actually fairly closely tied in with the former. Remove the need to track which cleanup scope a block is associated with. Document a lot of previously poorly-understood (by me, at least) behavior. The new framework implements the Horrible Hack (tm), which requires every landing pad to have a catch-all so that inlining will work. Clang no longer requires the Horrible Hack just to make exceptions flow correctly within a function, however. The HH is an unfortunate requirement of LLVM's EH IR. llvm-svn: 107631
2010-07-06 09:34:17 +08:00
CHECK-LABEL-ify some code gen tests to improve diagnostic experience when tests fail. llvm-svn: 188447
2013-08-15 14:47:53 +08:00
// CHECK-LABEL: define void @f1()
Validated by nightly-test runs on x86 and x86-64 darwin, including after self-host. Hopefully these results hold up on different platforms. I tried to keep the GNU ObjC runtime happy, but it's hard for me to test. Reimplement how clang generates IR for exceptions. Instead of creating new invoke destinations which sequentially chain to the previous destination, push a more semantic representation of *why* we need the cleanup/catch/filter behavior, then collect that information into a single landing pad upon request. Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional control flow) are generated, since it's actually fairly closely tied in with the former. Remove the need to track which cleanup scope a block is associated with. Document a lot of previously poorly-understood (by me, at least) behavior. The new framework implements the Horrible Hack (tm), which requires every landing pad to have a catch-all so that inlining will work. Clang no longer requires the Horrible Hack just to make exceptions flow correctly within a function, however. The HH is an unfortunate requirement of LLVM's EH IR. llvm-svn: 107631
2010-07-06 09:34:17 +08:00
void f1() {
extern void foo(void);
while (1) {
// CHECK: call void @objc_exception_try_enter
// CHECK-NEXT: getelementptr
// CHECK-NEXT: call i32 @_setjmp(
// CHECK-NEXT: icmp
// CHECK-NEXT: br i1
@try {
Some more correctness fixes and code-size optimizations for fragile-ABI ObjC exceptions: - don't enter a try for the catch blocks unless there's a finally - put the setjmp buffer in the locals set for liveness reasons - dump the sync object into an alloca in the locals set for liveness reasons Some of this can go away if the backend starts to properly calculate liveness in the presence of setjmp (which would also be a *much* stabler solution). llvm-svn: 110188
2010-08-04 13:59:32 +08:00
// CHECK: call void asm sideeffect "", "*m"
// CHECK-NEXT: call void @foo()
Validated by nightly-test runs on x86 and x86-64 darwin, including after self-host. Hopefully these results hold up on different platforms. I tried to keep the GNU ObjC runtime happy, but it's hard for me to test. Reimplement how clang generates IR for exceptions. Instead of creating new invoke destinations which sequentially chain to the previous destination, push a more semantic representation of *why* we need the cleanup/catch/filter behavior, then collect that information into a single landing pad upon request. Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional control flow) are generated, since it's actually fairly closely tied in with the former. Remove the need to track which cleanup scope a block is associated with. Document a lot of previously poorly-understood (by me, at least) behavior. The new framework implements the Horrible Hack (tm), which requires every landing pad to have a catch-all so that inlining will work. Clang no longer requires the Horrible Hack just to make exceptions flow correctly within a function, however. The HH is an unfortunate requirement of LLVM's EH IR. llvm-svn: 107631
2010-07-06 09:34:17 +08:00
foo();
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: call void @objc_exception_try_exit
Validated by nightly-test runs on x86 and x86-64 darwin, including after self-host. Hopefully these results hold up on different platforms. I tried to keep the GNU ObjC runtime happy, but it's hard for me to test. Reimplement how clang generates IR for exceptions. Instead of creating new invoke destinations which sequentially chain to the previous destination, push a more semantic representation of *why* we need the cleanup/catch/filter behavior, then collect that information into a single landing pad upon request. Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional control flow) are generated, since it's actually fairly closely tied in with the former. Remove the need to track which cleanup scope a block is associated with. Document a lot of previously poorly-understood (by me, at least) behavior. The new framework implements the Horrible Hack (tm), which requires every landing pad to have a catch-all so that inlining will work. Clang no longer requires the Horrible Hack just to make exceptions flow correctly within a function, however. The HH is an unfortunate requirement of LLVM's EH IR. llvm-svn: 107631
2010-07-06 09:34:17 +08:00
Some more correctness fixes and code-size optimizations for fragile-ABI ObjC exceptions: - don't enter a try for the catch blocks unless there's a finally - put the setjmp buffer in the locals set for liveness reasons - dump the sync object into an alloca in the locals set for liveness reasons Some of this can go away if the backend starts to properly calculate liveness in the presence of setjmp (which would also be a *much* stabler solution). llvm-svn: 110188
2010-08-04 13:59:32 +08:00
// CHECK: call void asm sideeffect "", "=*m"
Validated by nightly-test runs on x86 and x86-64 darwin, including after self-host. Hopefully these results hold up on different platforms. I tried to keep the GNU ObjC runtime happy, but it's hard for me to test. Reimplement how clang generates IR for exceptions. Instead of creating new invoke destinations which sequentially chain to the previous destination, push a more semantic representation of *why* we need the cleanup/catch/filter behavior, then collect that information into a single landing pad upon request. Also reorganizes how normal cleanups (i.e. cleanups triggered by non-exceptional control flow) are generated, since it's actually fairly closely tied in with the former. Remove the need to track which cleanup scope a block is associated with. Document a lot of previously poorly-understood (by me, at least) behavior. The new framework implements the Horrible Hack (tm), which requires every landing pad to have a catch-all so that inlining will work. Clang no longer requires the Horrible Hack just to make exceptions flow correctly within a function, however. The HH is an unfortunate requirement of LLVM's EH IR. llvm-svn: 107631
2010-07-06 09:34:17 +08:00
} @finally {
break;
}
}
}
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
// Test that modifications to local variables are respected under
// optimization. rdar://problem/8160285
CHECK-LABEL-ify some code gen tests to improve diagnostic experience when tests fail. llvm-svn: 188447
2013-08-15 14:47:53 +08:00
// CHECK-LABEL: define i32 @f2()
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
int f2() {
extern void foo(void);
// CHECK: [[X:%.*]] = alloca i32
Some more correctness fixes and code-size optimizations for fragile-ABI ObjC exceptions: - don't enter a try for the catch blocks unless there's a finally - put the setjmp buffer in the locals set for liveness reasons - dump the sync object into an alloca in the locals set for liveness reasons Some of this can go away if the backend starts to properly calculate liveness in the presence of setjmp (which would also be a *much* stabler solution). llvm-svn: 110188
2010-08-04 13:59:32 +08:00
// CHECK: store i32 5, i32* [[X]]
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
int x = 0;
Some more correctness fixes and code-size optimizations for fragile-ABI ObjC exceptions: - don't enter a try for the catch blocks unless there's a finally - put the setjmp buffer in the locals set for liveness reasons - dump the sync object into an alloca in the locals set for liveness reasons Some of this can go away if the backend starts to properly calculate liveness in the presence of setjmp (which would also be a *much* stabler solution). llvm-svn: 110188
2010-08-04 13:59:32 +08:00
x += 5;
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
// CHECK: [[SETJMP:%.*]] = call i32 @_setjmp
// CHECK-NEXT: [[CAUGHT:%.*]] = icmp eq i32 [[SETJMP]], 0
// CHECK-NEXT: br i1 [[CAUGHT]]
@try {
The optimizers figured out how to make this store 6. llvm-svn: 144597
2011-11-15 08:19:16 +08:00
// CHECK: store i32 6, i32* [[X]]
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
x++;
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 asm sideeffect "", "*m,*m"(i32* nonnull [[X]]
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
// CHECK-NEXT: call void @foo()
Some more correctness fixes and code-size optimizations for fragile-ABI ObjC exceptions: - don't enter a try for the catch blocks unless there's a finally - put the setjmp buffer in the locals set for liveness reasons - dump the sync object into an alloca in the locals set for liveness reasons Some of this can go away if the backend starts to properly calculate liveness in the presence of setjmp (which would also be a *much* stabler solution). llvm-svn: 110188
2010-08-04 13:59:32 +08:00
// CHECK-NEXT: call void @objc_exception_try_exit
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: [[T:%.*]] = load i32, i32* [[X]]
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
foo();
} @catch (id) {
Some more correctness fixes and code-size optimizations for fragile-ABI ObjC exceptions: - don't enter a try for the catch blocks unless there's a finally - put the setjmp buffer in the locals set for liveness reasons - dump the sync object into an alloca in the locals set for liveness reasons Some of this can go away if the backend starts to properly calculate liveness in the presence of setjmp (which would also be a *much* stabler solution). llvm-svn: 110188
2010-08-04 13:59:32 +08:00
// Landing pad. Note that we elide the re-enter.
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 asm sideeffect "", "=*m,=*m"(i32* nonnull [[X]]
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
// CHECK-NEXT: call i8* @objc_exception_extract
Update Clang tests to handle explicitly typed load changes in LLVM. llvm-svn: 230795
2015-02-28 05:19:58 +08:00
// CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[X]]
update this test now that reassociate isn't stripping nsw's pointlessly. llvm-svn: 125705
2011-02-17 10:02:42 +08:00
// CHECK-NEXT: [[T2:%.*]] = add nsw i32 [[T1]], -1
Some more correctness fixes and code-size optimizations for fragile-ABI ObjC exceptions: - don't enter a try for the catch blocks unless there's a finally - put the setjmp buffer in the locals set for liveness reasons - dump the sync object into an alloca in the locals set for liveness reasons Some of this can go away if the backend starts to properly calculate liveness in the presence of setjmp (which would also be a *much* stabler solution). llvm-svn: 110188
2010-08-04 13:59:32 +08:00
// This store is dead.
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
// CHECK-NEXT: store i32 [[T2]], i32* [[X]]
x--;
}
Not really any point to testing control flow in this test without ret duplication. llvm-svn: 124476
2011-01-28 14:05:16 +08:00
Fix fragile-ABI ObjC exceptions in the presence of optimization with the magic of inline assembly. Essentially we use read and write hazards on the set of local variables to force flushing locals to memory immediately before any protected calls and to inhibit optimizing locals across the setjmp->catch edge. Fixes rdar://problem/8160285 llvm-svn: 109960
2010-08-01 07:20:56 +08:00
return x;
}
Fix a bug in @finally emission in both the fragile and non-fragile EH schemes where we weren't accounting for the possibility that a @finally block might have internal cleanups and therefore might write to the cleanup destination slot. Fixes <rdar://problem/8293901>. llvm-svn: 110760
2010-08-11 08:16:14 +08:00
// Test that the cleanup destination is saved when entering a finally
// block. rdar://problem/8293901
CHECK-LABEL-ify some code gen tests to improve diagnostic experience when tests fail. llvm-svn: 188447
2013-08-15 14:47:53 +08:00
// CHECK-LABEL: define void @f3()
Fix a bug in @finally emission in both the fragile and non-fragile EH schemes where we weren't accounting for the possibility that a @finally block might have internal cleanups and therefore might write to the cleanup destination slot. Fixes <rdar://problem/8293901>. llvm-svn: 110760
2010-08-11 08:16:14 +08:00
void f3() {
extern void f3_helper(int, int*);
// CHECK: [[X:%.*]] = alloca i32
Revert "Revert r234581, it might have caused a few miscompiles in Chromium." This reverts commit r234700. It turns out that the lifetime markers were not the cause of Chromium failing but a bug which was uncovered by optimizations exposed by the markers. llvm-svn: 235553
2015-04-23 05:38:15 +08:00
// CHECK: [[XPTR:%.*]] = bitcast i32* [[X]] to i8*
Update for lifetime intrinsic signature change llvm-svn: 299877
2017-04-11 04:18:45 +08:00
// CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull [[XPTR]])
Fix a bug in @finally emission in both the fragile and non-fragile EH schemes where we weren't accounting for the possibility that a @finally block might have internal cleanups and therefore might write to the cleanup destination slot. Fixes <rdar://problem/8293901>. llvm-svn: 110760
2010-08-11 08:16:14 +08:00
// CHECK: store i32 0, i32* [[X]]
int x = 0;
// CHECK: call void @objc_exception_try_enter(
// CHECK: call i32 @_setjmp
// CHECK-NEXT: icmp eq
// CHECK-NEXT: br i1
@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 @f3_helper(i32 0, i32* nonnull [[X]])
Fix a bug in @finally emission in both the fragile and non-fragile EH schemes where we weren't accounting for the possibility that a @finally block might have internal cleanups and therefore might write to the cleanup destination slot. Fixes <rdar://problem/8293901>. llvm-svn: 110760
2010-08-11 08:16:14 +08:00
// CHECK: call void @objc_exception_try_exit(
f3_helper(0, &x);
} @finally {
// CHECK: [[DEST1:%.*]] = phi i32 [ 0, {{%.*}} ], [ 3, {{%.*}} ]
// CHECK: call void @objc_exception_try_enter
// CHECK: call i32 @_setjmp
@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 @f3_helper(i32 1, i32* nonnull [[X]])
Fix a bug in @finally emission in both the fragile and non-fragile EH schemes where we weren't accounting for the possibility that a @finally block might have internal cleanups and therefore might write to the cleanup destination slot. Fixes <rdar://problem/8293901>. llvm-svn: 110760
2010-08-11 08:16:14 +08:00
// CHECK: call void @objc_exception_try_exit(
f3_helper(1, &x);
} @finally {
// CHECK: [[DEST2:%.*]] = phi i32 [ 0, {{%.*}} ], [ 5, {{%.*}} ]
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 @f3_helper(i32 2, i32* nonnull [[X]])
Fix a bug in @finally emission in both the fragile and non-fragile EH schemes where we weren't accounting for the possibility that a @finally block might have internal cleanups and therefore might write to the cleanup destination slot. Fixes <rdar://problem/8293901>. llvm-svn: 110760
2010-08-11 08:16:14 +08:00
f3_helper(2, &x);
// This loop is large enough to dissuade the optimizer from just
// duplicating the finally block.
while (x) f3_helper(3, &x);
Make this test a little less dependent on exact optimizer results. llvm-svn: 110770
2010-08-11 10:06:44 +08:00
// This is a switch or maybe some chained branches, but relying
// on a specific result from the optimizer is really unstable.
// CHECK: [[DEST2]]
Fix a bug in @finally emission in both the fragile and non-fragile EH schemes where we weren't accounting for the possibility that a @finally block might have internal cleanups and therefore might write to the cleanup destination slot. Fixes <rdar://problem/8293901>. llvm-svn: 110760
2010-08-11 08:16:14 +08:00
}
Make this test a little less dependent on exact optimizer results. llvm-svn: 110770
2010-08-11 10:06:44 +08:00
// This is a switch or maybe some chained branches, but relying
// on a specific result from the optimizer is really unstable.
// CHECK: [[DEST1]]
Fix a bug in @finally emission in both the fragile and non-fragile EH schemes where we weren't accounting for the possibility that a @finally block might have internal cleanups and therefore might write to the cleanup destination slot. Fixes <rdar://problem/8293901>. llvm-svn: 110760
2010-08-11 08:16:14 +08:00
}
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 @f3_helper(i32 4, i32* nonnull [[X]])
Update for lifetime intrinsic signature change llvm-svn: 299877
2017-04-11 04:18:45 +08:00
// CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull [[XPTR]])
Fix a bug in @finally emission in both the fragile and non-fragile EH schemes where we weren't accounting for the possibility that a @finally block might have internal cleanups and therefore might write to the cleanup destination slot. Fixes <rdar://problem/8293901>. llvm-svn: 110760
2010-08-11 08:16:14 +08:00
// CHECK-NEXT: ret void
f3_helper(4, &x);
}
In the fragile ObjC ABI, save the caught exception to the side if there are both @catches and a @finally, because the second call to @objc_exception_try_enter will clobber the exception slot. Fixes rdar://problem/8440970. llvm-svn: 115575
2010-10-05 07:42:51 +08:00
// rdar://problem/8440970
void f4() {
extern void f4_help(int);
CHECK-LABEL-ify some code gen tests to improve diagnostic experience when tests fail. llvm-svn: 188447
2013-08-15 14:47:53 +08:00
// CHECK-LABEL: define void @f4()
In the fragile ObjC ABI, save the caught exception to the side if there are both @catches and a @finally, because the second call to @objc_exception_try_enter will clobber the exception slot. Fixes rdar://problem/8440970. llvm-svn: 115575
2010-10-05 07:42:51 +08:00
// CHECK: [[EXNDATA:%.*]] = alloca [[EXNDATA_T:%.*]], align
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([[EXNDATA_T]]* nonnull [[EXNDATA]])
In the fragile ObjC ABI, save the caught exception to the side if there are both @catches and a @finally, because the second call to @objc_exception_try_enter will clobber the exception slot. Fixes rdar://problem/8440970. llvm-svn: 115575
2010-10-05 07:42:51 +08:00
// CHECK: call i32 @_setjmp
@try {
// CHECK: call void @f4_help(i32 0)
f4_help(0);
// The finally cleanup has two threaded entrypoints after optimization:
// finally.no-call-exit: Predecessor is when the catch throws.
Adjust clang side tests effected by 239795 before reapplying said change llvm-svn: 239848
2015-06-17 04:24:06 +08:00
// CHECK: call i8* @objc_exception_extract([[EXNDATA_T]]* nonnull [[EXNDATA]])
In the fragile ObjC ABI, save the caught exception to the side if there are both @catches and a @finally, because the second call to @objc_exception_try_enter will clobber the exception slot. Fixes rdar://problem/8440970. llvm-svn: 115575
2010-10-05 07:42:51 +08:00
// CHECK-NEXT: call void @f4_help(i32 2)
// CHECK-NEXT: br label
// -> rethrow
// finally.call-exit: Predecessors are the @try and @catch fallthroughs
// as well as the no-match case in the catch mechanism. The i1 is whether
// to rethrow and should be true only in the last case.
Update the Clang tests which run with a full optimization pipeline for the new SROA pass. This is a benign change: the order of PHI nodes changed. llvm-svn: 164481
2012-09-24 09:10:25 +08:00
// CHECK: phi i8*
// CHECK-NEXT: phi i1
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([[EXNDATA_T]]* nonnull [[EXNDATA]])
In the fragile ObjC ABI, save the caught exception to the side if there are both @catches and a @finally, because the second call to @objc_exception_try_enter will clobber the exception slot. Fixes rdar://problem/8440970. llvm-svn: 115575
2010-10-05 07:42:51 +08:00
// CHECK-NEXT: call void @f4_help(i32 2)
// CHECK-NEXT: br i1
// -> ret, rethrow
// ret:
// CHECK: ret void
// Catch mechanism:
Adjust clang side tests effected by 239795 before reapplying said change llvm-svn: 239848
2015-06-17 04:24:06 +08:00
// CHECK: call i8* @objc_exception_extract([[EXNDATA_T]]* nonnull [[EXNDATA]])
// CHECK-NEXT: call void @objc_exception_try_enter([[EXNDATA_T]]* nonnull [[EXNDATA]])
In the fragile ObjC ABI, save the caught exception to the side if there are both @catches and a @finally, because the second call to @objc_exception_try_enter will clobber the exception slot. Fixes rdar://problem/8440970. llvm-svn: 115575
2010-10-05 07:42:51 +08:00
// CHECK: call i32 @_setjmp
// -> next, finally.no-call-exit
// CHECK: call i32 @objc_exception_match
// -> finally.call-exit, match
} @catch (NSArray *a) {
// match:
// CHECK: call void @f4_help(i32 1)
// CHECK-NEXT: br label
// -> finally.call-exit
f4_help(1);
} @finally {
f4_help(2);
}
// rethrow:
// CHECK: phi i8*
// CHECK-NEXT: call void @objc_exception_throw(i8*
// CHECK-NEXT: unreachable
}