| ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py |
| ; RUN: opt -passes=instcombine -S < %s | FileCheck %s |
| |
| ; Function Attrs: noinline uwtable |
| define i32 @foo(i32* nocapture writeonly %arg) { |
| ; CHECK-LABEL: @foo( |
| ; CHECK-NEXT: bb: |
| ; CHECK-NEXT: [[VAR:%.*]] = call i32 @baz() |
| ; CHECK-NEXT: store i32 [[VAR]], i32* [[ARG:%.*]], align 4 |
| ; CHECK-NEXT: [[VAR1:%.*]] = call i32 @baz() |
| ; CHECK-NEXT: ret i32 [[VAR1]] |
| ; |
| bb: |
| %var = call i32 @baz() |
| store i32 %var, i32* %arg, align 4 |
| %var1 = call i32 @baz() |
| ret i32 %var1 |
| } |
| declare i32 @baz() |
| |
| ; Function Attrs: uwtable |
| ; This is an equivalent IR for a c-style example with a large function (foo) |
| ; with out-params which are unused in the caller(test8). Note that foo is |
| ; marked noinline to prevent IPO transforms. |
| ; int foo(); |
| ; |
| ; extern int foo(int *out) __attribute__((noinline)); |
| ; int foo(int *out) { |
| ; *out = baz(); |
| ; return baz(); |
| ; } |
| ; |
| ; int test() { |
| ; |
| ; int notdead; |
| ; if (foo(¬dead)) |
| ; return 0; |
| ; |
| ; int dead; |
| ; int tmp = foo(&dead); |
| ; if (notdead) |
| ; return tmp; |
| ; return bar(); |
| ; } |
| |
| ; TODO: We should be able to sink the second call @foo at bb5 down to bb_crit_edge |
| define i32 @test() { |
| ; CHECK-LABEL: @test( |
| ; CHECK-NEXT: bb: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: [[VAR1:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: [[VAR2:%.*]] = bitcast i32* [[VAR]] to i8* |
| ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull [[VAR2]]) |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @foo(i32* nonnull writeonly [[VAR]]) |
| ; CHECK-NEXT: [[VAR4:%.*]] = icmp eq i32 [[VAR3]], 0 |
| ; CHECK-NEXT: br i1 [[VAR4]], label [[BB5:%.*]], label [[BB14:%.*]] |
| ; CHECK: bb5: |
| ; CHECK-NEXT: [[VAR6:%.*]] = bitcast i32* [[VAR1]] to i8* |
| ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull [[VAR6]]) |
| ; CHECK-NEXT: [[VAR8:%.*]] = load i32, i32* [[VAR]], align 4 |
| ; CHECK-NEXT: [[VAR9:%.*]] = icmp eq i32 [[VAR8]], 0 |
| ; CHECK-NEXT: [[VAR7:%.*]] = call i32 @foo(i32* nonnull writeonly [[VAR1]]) |
| ; CHECK-NEXT: br i1 [[VAR9]], label [[BB10:%.*]], label [[BB_CRIT_EDGE:%.*]] |
| ; CHECK: bb10: |
| ; CHECK-NEXT: [[VAR11:%.*]] = call i32 @bar() |
| ; CHECK-NEXT: br label [[BB12:%.*]] |
| ; CHECK: bb_crit_edge: |
| ; CHECK-NEXT: br label [[BB12]] |
| ; CHECK: bb12: |
| ; CHECK-NEXT: [[VAR13:%.*]] = phi i32 [ [[VAR11]], [[BB10]] ], [ [[VAR7]], [[BB_CRIT_EDGE]] ] |
| ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull [[VAR6]]) |
| ; CHECK-NEXT: br label [[BB14]] |
| ; CHECK: bb14: |
| ; CHECK-NEXT: [[VAR15:%.*]] = phi i32 [ [[VAR13]], [[BB12]] ], [ 0, [[BB:%.*]] ] |
| ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull [[VAR2]]) |
| ; CHECK-NEXT: ret i32 [[VAR15]] |
| ; |
| bb: |
| %var = alloca i32, align 4 |
| %var1 = alloca i32, align 4 |
| %var2 = bitcast i32* %var to i8* |
| call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %var2) #4 |
| %var3 = call i32 @foo(i32* nonnull writeonly %var) |
| %var4 = icmp eq i32 %var3, 0 |
| br i1 %var4, label %bb5, label %bb14 |
| |
| bb5: ; preds = %bb |
| %var6 = bitcast i32* %var1 to i8* |
| call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %var6) #4 |
| %var8 = load i32, i32* %var, align 4 |
| %var9 = icmp eq i32 %var8, 0 |
| %var7 = call i32 @foo(i32* nonnull writeonly %var1) |
| br i1 %var9, label %bb10, label %bb_crit_edge |
| |
| bb10: ; preds = %bb5 |
| %var11 = call i32 @bar() |
| br label %bb12 |
| |
| bb_crit_edge: |
| br label %bb12 |
| |
| bb12: ; preds = %bb10, %bb5 |
| %var13 = phi i32 [ %var11, %bb10 ], [ %var7, %bb_crit_edge ] |
| call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %var6) #4 |
| br label %bb14 |
| |
| bb14: ; preds = %bb12, %bb |
| %var15 = phi i32 [ %var13, %bb12 ], [ 0, %bb ] |
| call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %var2) |
| ret i32 %var15 |
| } |
| |
| declare i32 @unknown(i32* %dest) |
| declare i32 @unknown.as2(i32 addrspace(2)* %dest) |
| |
| define i32 @sink_write_to_use(i1 %c) { |
| ; CHECK-LABEL: @sink_write_to_use( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull writeonly [[VAR]]) #[[ATTR1:[0-9]+]] |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %var3 = call i32 @unknown(i32* writeonly %var) argmemonly nounwind willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| define i32 @sink_readwrite_to_use(i1 %c) { |
| ; CHECK-LABEL: @sink_readwrite_to_use( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[VAR]]) #[[ATTR1]] |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %var3 = call i32 @unknown(i32* %var) argmemonly nounwind willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| define i32 @sink_bitcast(i1 %c) { |
| ; CHECK-LABEL: @sink_bitcast( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i8, align 8 |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i8* [[VAR]] to i32* |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[BITCAST]]) #[[ATTR1]] |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i8, align 8 |
| %bitcast = bitcast i8* %var to i32* |
| %var3 = call i32 @unknown(i32* %bitcast) argmemonly nounwind willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| |
| define i32 @sink_gep1(i1 %c) { |
| ; CHECK-LABEL: @sink_gep1( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR1:%.*]] = alloca [2 x i32], align 8 |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[VAR1]], i64 0, i64 1 |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[GEP]]) #[[ATTR1]] |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i64, align 8 |
| %bitcast = bitcast i64* %var to i32* |
| %gep = getelementptr i32, i32* %bitcast, i32 1 |
| %var3 = call i32 @unknown(i32* %gep) argmemonly nounwind willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| define i32 @sink_gep2(i1 %c) { |
| ; CHECK-LABEL: @sink_gep2( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR1:%.*]] = alloca [2 x i32], align 8 |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: [[VAR1_SUB:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[VAR1]], i64 0, i64 0 |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[VAR1_SUB]]) #[[ATTR1]] |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i64, align 8 |
| %bitcast = bitcast i64* %var to i32* |
| %var3 = call i32 @unknown(i32* %bitcast) argmemonly nounwind willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| define i32 @sink_addrspacecast(i1 %c) { |
| ; CHECK-LABEL: @sink_addrspacecast( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 8 |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: [[CAST:%.*]] = addrspacecast i32* [[VAR]] to i32 addrspace(2)* |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown.as2(i32 addrspace(2)* [[CAST]]) #[[ATTR1]] |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 8 |
| %cast = addrspacecast i32* %var to i32 addrspace(2)* |
| %var3 = call i32 @unknown.as2(i32 addrspace(2)* %cast) argmemonly nounwind willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| define i32 @neg_infinite_loop(i1 %c) { |
| ; CHECK-LABEL: @neg_infinite_loop( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[VAR]]) #[[ATTR2:[0-9]+]] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %var3 = call i32 @unknown(i32* %var) argmemonly nounwind |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| define i32 @neg_throw(i1 %c) { |
| ; CHECK-LABEL: @neg_throw( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[VAR]]) #[[ATTR3:[0-9]+]] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %var3 = call i32 @unknown(i32* %var) argmemonly willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| define i32 @neg_unknown_write(i1 %c) { |
| ; CHECK-LABEL: @neg_unknown_write( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[VAR]]) #[[ATTR4:[0-9]+]] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %var3 = call i32 @unknown(i32* %var) nounwind willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| define i32 @sink_lifetime1(i1 %c) { |
| ; CHECK-LABEL: @sink_lifetime1( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[VAR]] to i8* |
| ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull [[BITCAST]]) |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[VAR]]) #[[ATTR1]] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull [[BITCAST]]) |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %bitcast = bitcast i32* %var to i8* |
| call void @llvm.lifetime.start.p0i8(i64 4, i8* %bitcast) |
| %var3 = call i32 @unknown(i32* %var) argmemonly nounwind willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| call void @llvm.lifetime.end.p0i8(i64 4, i8* %bitcast) |
| ret i32 %var3 |
| } |
| |
| define i32 @sink_lifetime2(i1 %c) { |
| ; CHECK-LABEL: @sink_lifetime2( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[VAR]] to i8* |
| ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull [[BITCAST]]) |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[VAR]]) #[[ATTR1]] |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[MERGE:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: merge: |
| ; CHECK-NEXT: [[RET:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[VAR3]], [[USE_BLOCK]] ] |
| ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull [[BITCAST]]) |
| ; CHECK-NEXT: ret i32 [[RET]] |
| ; CHECK: use_block: |
| ; CHECK-NEXT: br label [[MERGE]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %bitcast = bitcast i32* %var to i8* |
| call void @llvm.lifetime.start.p0i8(i64 4, i8* %bitcast) |
| %var3 = call i32 @unknown(i32* %var) argmemonly nounwind willreturn |
| br i1 %c, label %merge, label %use_block |
| |
| merge: |
| %ret = phi i32 [0, %entry], [%var3, %use_block] |
| call void @llvm.lifetime.end.p0i8(i64 4, i8* %bitcast) |
| ret i32 %ret |
| |
| use_block: |
| br label %merge |
| } |
| |
| define i32 @sink_lifetime3(i1 %c) { |
| ; CHECK-LABEL: @sink_lifetime3( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[VAR]]) #[[ATTR1]] |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %bitcast = bitcast i32* %var to i8* |
| call void @llvm.lifetime.start.p0i8(i64 4, i8* %bitcast) |
| call void @llvm.lifetime.end.p0i8(i64 4, i8* %bitcast) |
| ; If unknown accesses %var, that's UB |
| %var3 = call i32 @unknown(i32* %var) argmemonly nounwind willreturn |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| define i32 @sink_lifetime4a(i1 %c) { |
| ; CHECK-LABEL: @sink_lifetime4a( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[VAR]] to i8* |
| ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull [[BITCAST]]) |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull [[VAR]]) #[[ATTR1]] |
| ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull [[BITCAST]]) |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %bitcast = bitcast i32* %var to i8* |
| call void @llvm.lifetime.start.p0i8(i64 4, i8* %bitcast) |
| %var3 = call i32 @unknown(i32* %var) argmemonly nounwind willreturn |
| call void @llvm.lifetime.end.p0i8(i64 4, i8* %bitcast) |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| ; Version which only writes to var, and thus can't rely on may-read scan for |
| ; clobbers to prevent the transform |
| define i32 @sink_lifetime4b(i1 %c) { |
| ; CHECK-LABEL: @sink_lifetime4b( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: [[BITCAST:%.*]] = bitcast i32* [[VAR]] to i8* |
| ; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull [[BITCAST]]) |
| ; CHECK-NEXT: [[VAR3:%.*]] = call i32 @unknown(i32* nonnull writeonly [[VAR]]) #[[ATTR1]] |
| ; CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull [[BITCAST]]) |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| %bitcast = bitcast i32* %var to i8* |
| call void @llvm.lifetime.start.p0i8(i64 4, i8* %bitcast) |
| %var3 = call i32 @unknown(i32* writeonly %var) argmemonly nounwind willreturn |
| call void @llvm.lifetime.end.p0i8(i64 4, i8* %bitcast) |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| ; Mostly checking that trying to sink a non-call doesn't crash (i.e. prior bug) |
| define i32 @sink_atomicrmw_to_use(i1 %c) { |
| ; CHECK-LABEL: @sink_atomicrmw_to_use( |
| ; CHECK-NEXT: entry: |
| ; CHECK-NEXT: [[VAR:%.*]] = alloca i32, align 4 |
| ; CHECK-NEXT: store i32 0, i32* [[VAR]], align 4 |
| ; CHECK-NEXT: [[VAR3:%.*]] = atomicrmw add i32* [[VAR]], i32 1 seq_cst, align 4 |
| ; CHECK-NEXT: br i1 [[C:%.*]], label [[EARLY_RETURN:%.*]], label [[USE_BLOCK:%.*]] |
| ; CHECK: early_return: |
| ; CHECK-NEXT: ret i32 0 |
| ; CHECK: use_block: |
| ; CHECK-NEXT: ret i32 [[VAR3]] |
| ; |
| entry: |
| %var = alloca i32, align 4 |
| store i32 0, i32* %var |
| %var3 = atomicrmw add i32* %var, i32 1 seq_cst, align 4 |
| br i1 %c, label %early_return, label %use_block |
| |
| early_return: |
| ret i32 0 |
| |
| use_block: |
| ret i32 %var3 |
| } |
| |
| |
| declare i32 @bar() |
| declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) |
| declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) |
| |
