a4772cbaf0
This reverts commit 4e545bdb355a470d601e9bb7f7b2693c99e61a3e. The newly added test is the third infinite combine loop caused by this change. In this case, it's a combination of the branch to common dest and jump threading folds that keeps peeling off loop iterations. The core problem here is that we ideally would not thread over loop backedges, both because it is potentially non-profitable (it may break canonical loop structure) and because it may result in these kinds of loops. Unfortunately, due to the lack of a dominator tree in SimplifyCFG, there is no good way to prevent this. While we have LoopHeaders, this is an optional structure and we don't do a good job of keeping it up to date. It would be fine for a profitability check, but is not suitable for a correctness check. So for now I'm just giving up here, as I don't see a good way to robustly prevent infinite combine loops. Fixes https://github.com/llvm/llvm-project/issues/56203.
185 lines
5.8 KiB
Objective-C
185 lines
5.8 KiB
Objective-C
// RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-apple-darwin10 -fobjc-runtime=macosx-fragile-10.5 -emit-llvm -fobjc-exceptions -mllvm -simplifycfg-sink-common=false -O2 -o - %s | FileCheck %s
|
|
//
|
|
// <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(void) {
|
|
@try {
|
|
@try {
|
|
@throw @"a";
|
|
} @catch(NSArray *e) {
|
|
}
|
|
} @catch (id e) {
|
|
}
|
|
}
|
|
|
|
// CHECK-LABEL: define{{.*}} void @f1()
|
|
void f1(void) {
|
|
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 {
|
|
// CHECK: call void asm sideeffect "", "=*m"
|
|
// CHECK: call void asm sideeffect "", "*m"
|
|
// CHECK-NEXT: call void @foo()
|
|
foo();
|
|
// CHECK: call void @objc_exception_try_exit
|
|
|
|
} @finally {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test that modifications to local variables are respected under
|
|
// optimization. rdar://problem/8160285
|
|
|
|
// CHECK-LABEL: define{{.*}} i32 @f2()
|
|
int f2(void) {
|
|
extern void foo(void);
|
|
|
|
// CHECK: [[X:%.*]] = alloca i32
|
|
// CHECK: store i32 5, i32* [[X]]
|
|
int x = 0;
|
|
x += 5;
|
|
|
|
// CHECK: [[SETJMP:%.*]] = call i32 @_setjmp
|
|
// CHECK-NEXT: [[CAUGHT:%.*]] = icmp eq i32 [[SETJMP]], 0
|
|
// CHECK-NEXT: br i1 [[CAUGHT]]
|
|
@try {
|
|
// Landing pad. Note that we elide the re-enter.
|
|
// CHECK: call void asm sideeffect "", "=*m,=*m"(i32* nonnull elementtype(i32) [[X]]
|
|
// CHECK-NEXT: call i8* @objc_exception_extract
|
|
// CHECK-NEXT: [[T1:%.*]] = load i32, i32* [[X]]
|
|
// CHECK-NEXT: [[T2:%.*]] = add nsw i32 [[T1]], -1
|
|
|
|
// CHECK: store i32 6, i32* [[X]]
|
|
x++;
|
|
// CHECK-NEXT: call void asm sideeffect "", "*m,*m"(i32* nonnull elementtype(i32) [[X]]
|
|
// CHECK-NEXT: call void @foo()
|
|
// CHECK-NEXT: call void @objc_exception_try_exit
|
|
// CHECK-NEXT: [[T:%.*]] = load i32, i32* [[X]]
|
|
foo();
|
|
} @catch (id) {
|
|
x--;
|
|
}
|
|
|
|
return x;
|
|
}
|
|
|
|
// Test that the cleanup destination is saved when entering a finally
|
|
// block. rdar://problem/8293901
|
|
// CHECK-LABEL: define{{.*}} void @f3()
|
|
void f3(void) {
|
|
extern void f3_helper(int, int*);
|
|
|
|
// CHECK: [[X:%.*]] = alloca i32
|
|
// CHECK: [[XPTR:%.*]] = bitcast i32* [[X]] to i8*
|
|
// CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull [[XPTR]])
|
|
// CHECK: store i32 0, i32* [[X]]
|
|
int x = 0;
|
|
|
|
// CHECK: call void @objc_exception_try_enter(
|
|
// CHECK: call i32 @_setjmp
|
|
// CHECK-NEXT: [[DEST1:%.*]] = icmp eq
|
|
// CHECK-NEXT: br i1 [[DEST1]]
|
|
|
|
@try {
|
|
// CHECK: call void @f3_helper(i32 noundef 0, i32* noundef nonnull [[X]])
|
|
// CHECK: call void @objc_exception_try_exit(
|
|
f3_helper(0, &x);
|
|
} @finally {
|
|
// CHECK: call void @objc_exception_try_enter
|
|
// CHECK: call i32 @_setjmp
|
|
// CHECK-NEXT: [[DEST2:%.*]] = icmp eq
|
|
// CHECK-NEXT: br i1 [[DEST2]]
|
|
@try {
|
|
// CHECK: call void @f3_helper(i32 noundef 1, i32* noundef nonnull [[X]])
|
|
// CHECK: call void @objc_exception_try_exit(
|
|
f3_helper(1, &x);
|
|
} @finally {
|
|
// CHECK: call void @f3_helper(i32 noundef 2, i32* noundef nonnull [[X]])
|
|
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);
|
|
|
|
// This is a switch or maybe some chained branches, but relying
|
|
// on a specific result from the optimizer is really unstable.
|
|
// CHECK: [[DEST2]]
|
|
}
|
|
|
|
// This is a switch or maybe some chained branches, but relying
|
|
// on a specific result from the optimizer is really unstable.
|
|
// CHECK: [[DEST1]]
|
|
}
|
|
|
|
// CHECK: call void @f3_helper(i32 noundef 4, i32* noundef nonnull [[X]])
|
|
// CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull [[XPTR]])
|
|
// CHECK-NEXT: ret void
|
|
f3_helper(4, &x);
|
|
}
|
|
|
|
// rdar://problem/8440970
|
|
void f4(void) {
|
|
extern void f4_help(int);
|
|
|
|
// CHECK-LABEL: define{{.*}} void @f4()
|
|
// CHECK: [[EXNDATA:%.*]] = alloca [[EXNDATA_T:%.*]], align
|
|
// CHECK: call void @objc_exception_try_enter([[EXNDATA_T]]* nonnull [[EXNDATA]])
|
|
// CHECK: call i32 @_setjmp
|
|
@try {
|
|
// CHECK: call void @f4_help(i32 noundef 0)
|
|
f4_help(0);
|
|
|
|
// The finally cleanup has two threaded entrypoints after optimization:
|
|
|
|
// finally.no-call-exit: Predecessor is when the catch throws.
|
|
// CHECK: call i8* @objc_exception_extract([[EXNDATA_T]]* nonnull [[EXNDATA]])
|
|
// CHECK-NEXT: call void @f4_help(i32 noundef 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.
|
|
// CHECK: phi i8*
|
|
// CHECK-NEXT: phi i1
|
|
// CHECK-NEXT: call void @objc_exception_try_exit([[EXNDATA_T]]* nonnull [[EXNDATA]])
|
|
// CHECK-NEXT: call void @f4_help(i32 noundef 2)
|
|
// CHECK-NEXT: br i1
|
|
// -> ret, rethrow
|
|
|
|
// ret:
|
|
// CHECK: ret void
|
|
|
|
// Catch mechanism:
|
|
// CHECK: call i8* @objc_exception_extract([[EXNDATA_T]]* nonnull [[EXNDATA]])
|
|
// CHECK-NEXT: call void @objc_exception_try_enter([[EXNDATA_T]]* nonnull [[EXNDATA]])
|
|
// 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 noundef 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
|
|
}
|