[llvm] d288411 - [Attributor] Name instructions in tests (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Tue Apr 11 08:16:54 PDT 2023
Author: Nikita Popov
Date: 2023-04-11T17:16:44+02:00
New Revision: d288411c8aef1820366d477aa8f90ed6a52d70ee
URL: https://github.com/llvm/llvm-project/commit/d288411c8aef1820366d477aa8f90ed6a52d70ee
DIFF: https://github.com/llvm/llvm-project/commit/d288411c8aef1820366d477aa8f90ed6a52d70ee.diff
LOG: [Attributor] Name instructions in tests (NFC)
Added:
Modified:
llvm/test/Transforms/Attributor/heap_to_stack.ll
llvm/test/Transforms/Attributor/heap_to_stack_gpu.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/Attributor/heap_to_stack.ll b/llvm/test/Transforms/Attributor/heap_to_stack.ll
index ffe5bd878daae..c7902836d0278 100644
--- a/llvm/test/Transforms/Attributor/heap_to_stack.ll
+++ b/llvm/test/Transforms/Attributor/heap_to_stack.ll
@@ -57,35 +57,41 @@ define void @h2s_value_simplify_interaction(i1 %c, i8* %A) {
;
entry:
%add = add i64 2, 2
- %m = tail call align 16 noalias i8* @malloc(i64 %add)
+ %m = tail call noalias align 16 i8* @malloc(i64 %add)
br i1 %c, label %t, label %f
+
t:
br i1 false, label %dead, label %f2
+
f:
br label %j
+
f2:
%c1 = bitcast i8* %m to i32*
%c2 = bitcast i32* %c1 to i8*
- %l = load i8, i8* %c2
+ %l = load i8, i8* %c2, align 1
call void @usei8(i8 %l)
call void @no_sync_func(i8* noundef %c2) nounwind
br label %j
+
dead:
br label %j
+
j:
%phi = phi i8* [ %m, %f ], [ null, %f2 ], [ %A, %dead ]
tail call void @no_sync_func(i8* noundef %phi) nounwind
- ;tail call void @free(i8* %m)
ret void
}
define void @nofree_arg_only(i8* %p1, i8* %p2) {
; CHECK-LABEL: define {{[^@]+}}@nofree_arg_only
; CHECK-SAME: (i8* nocapture nofree [[P1:%.*]], i8* nocapture [[P2:%.*]]) {
+; CHECK-NEXT: bb:
; CHECK-NEXT: tail call void @free(i8* nocapture [[P2]])
; CHECK-NEXT: tail call void @nofree_func(i8* nocapture nofree [[P1]])
; CHECK-NEXT: ret void
;
+bb:
tail call void @free(i8* %p2)
tail call void @nofree_func(i8* %p1)
ret void
@@ -95,16 +101,18 @@ define void @nofree_arg_only(i8* %p1, i8* %p2) {
define void @test1() {
; CHECK-LABEL: define {{[^@]+}}@test1() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @nocapture_func_frees_pointer(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @nocapture_func_frees_pointer(i8* noalias nocapture [[I]])
; CHECK-NEXT: tail call void (...) @func_throws()
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @nocapture_func_frees_pointer(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @nocapture_func_frees_pointer(i8* %i)
tail call void (...) @func_throws()
- tail call void @free(i8* %1)
+ tail call void @free(i8* %i)
ret void
}
@@ -112,14 +120,16 @@ define void @test1() {
define void @test2() {
; CHECK-LABEL: define {{[^@]+}}@test2() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @sync_func(i8* [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @sync_func(i8* [[I]])
+; CHECK-NEXT: tail call void @free(i8* nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
@@ -127,26 +137,30 @@ define void @test2() {
define void @test3() {
; CHECK-LABEL: define {{[^@]+}}@test3() {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I_H2S]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
define void @test3a(i8* %p) {
; CHECK-LABEL: define {{[^@]+}}@test3a
; CHECK-SAME: (i8* nocapture [[P:%.*]]) {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[I_H2S]], i8* nocapture [[P]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @nofree_arg_only(i8* %1, i8* %p)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @nofree_arg_only(i8* %i, i8* %p)
+ tail call void @free(i8* %i)
ret void
}
@@ -155,13 +169,15 @@ declare noalias i8* @aligned_alloc(i64 allocalign, i64) allockind("alloc,uniniti
define void @test3b(i8* %p) {
; CHECK-LABEL: define {{[^@]+}}@test3b
; CHECK-SAME: (i8* nocapture [[P:%.*]]) {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 128, align 32
-; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 128, align 32
+; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[I_H2S]], i8* nocapture [[P]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @aligned_alloc(i64 32, i64 128)
- tail call void @nofree_arg_only(i8* %1, i8* %p)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @aligned_alloc(i64 32, i64 128)
+ tail call void @nofree_arg_only(i8* %i, i8* %p)
+ tail call void @free(i8* %i)
ret void
}
@@ -169,12 +185,14 @@ define void @test3b(i8* %p) {
define void @test3c(i64 %alignment) {
; CHECK-LABEL: define {{[^@]+}}@test3c
; CHECK-SAME: (i64 [[ALIGNMENT:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 [[ALIGNMENT]], i64 noundef 128)
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @aligned_alloc(i64 [[ALIGNMENT]], i64 noundef 128)
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @aligned_alloc(i64 %alignment, i64 128)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @aligned_alloc(i64 %alignment, i64 128)
+ tail call void @free(i8* %i)
ret void
}
@@ -182,15 +200,16 @@ define void @test3c(i64 %alignment) {
define void @test3d(i8* %p) {
; CHECK-LABEL: define {{[^@]+}}@test3d
; CHECK-SAME: (i8* nocapture [[P:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 33, i64 noundef 128)
-; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP1]], i8* nocapture [[P]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 33, i64 noundef 128)
+; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[I]], i8* nocapture [[P]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
-; CHECK-SAME; (i8* nocapture [[P:%.*]]) {
- %1 = tail call noalias i8* @aligned_alloc(i64 33, i64 128)
- tail call void @nofree_arg_only(i8* %1, i8* %p)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @aligned_alloc(i64 33, i64 128)
+ tail call void @nofree_arg_only(i8* %i, i8* %p)
+ tail call void @free(i8* %i)
ret void
}
@@ -198,94 +217,102 @@ declare noalias i8* @calloc(i64, i64) allockind("alloc,zeroed") allocsize(0,1)
define void @test0() {
; CHECK-LABEL: define {{[^@]+}}@test0() {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 8, align 1
-; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* [[DOTH2S]], i8 0, i64 8, i1 false)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 8, align 1
+; CHECK-NEXT: call void @llvm.memset.p0i8.i64(i8* [[I_H2S]], i8 0, i64 8, i1 false)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I_H2S]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @calloc(i64 2, i64 4)
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @calloc(i64 2, i64 4)
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
; TEST 4
define void @test4() {
; CHECK-LABEL: define {{[^@]+}}@test4() {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[DOTH2S]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[I_H2S]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @nofree_func(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @nofree_func(i8* %i)
ret void
}
; TEST 5 - not all exit paths have a call to free, but all uses of malloc
; are in nofree functions and are not captured
-define void @test5(i32, i8* %p) {
+define void @test5(i32 %arg, i8* %p) {
; CHECK-LABEL: define {{[^@]+}}@test5
-; CHECK-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP0]], 0
-; CHECK-NEXT: br i1 [[TMP2]], label [[TMP4:%.*]], label [[TMP3:%.*]]
-; CHECK: 3:
-; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[DOTH2S]])
-; CHECK-NEXT: br label [[TMP5:%.*]]
-; CHECK: 4:
-; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[DOTH2S]], i8* nocapture [[P]])
-; CHECK-NEXT: br label [[TMP5]]
-; CHECK: 5:
+; CHECK-SAME: (i32 [[ARG:%.*]], i8* nocapture [[P:%.*]]) {
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: [[I1:%.*]] = icmp eq i32 [[ARG]], 0
+; CHECK-NEXT: br i1 [[I1]], label [[BB3:%.*]], label [[BB2:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[I_H2S]])
+; CHECK-NEXT: br label [[BB4:%.*]]
+; CHECK: bb3:
+; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[I_H2S]], i8* nocapture [[P]])
+; CHECK-NEXT: br label [[BB4]]
+; CHECK: bb4:
; CHECK-NEXT: ret void
;
- %2 = tail call noalias i8* @malloc(i64 4)
- %3 = icmp eq i32 %0, 0
- br i1 %3, label %5, label %4
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ %i1 = icmp eq i32 %arg, 0
+ br i1 %i1, label %bb3, label %bb2
-4: ; preds = %1
- tail call void @nofree_func(i8* %2)
- br label %6
+bb2:
+ tail call void @nofree_func(i8* %i)
+ br label %bb4
-5: ; preds = %1
- tail call void @nofree_arg_only(i8* %2, i8* %p)
- tail call void @free(i8* %2)
- br label %6
+bb3:
+ tail call void @nofree_arg_only(i8* %i, i8* %p)
+ tail call void @free(i8* %i)
+ br label %bb4
-6: ; preds = %5, %4
+bb4:
ret void
}
; TEST 6 - all exit paths have a call to free
-define void @test6(i32) {
+define void @test6(i32 %arg) {
; CHECK-LABEL: define {{[^@]+}}@test6
-; CHECK-SAME: (i32 [[TMP0:%.*]]) {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: [[TMP2:%.*]] = icmp eq i32 [[TMP0]], 0
-; CHECK-NEXT: br i1 [[TMP2]], label [[TMP4:%.*]], label [[TMP3:%.*]]
-; CHECK: 3:
-; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[DOTH2S]])
-; CHECK-NEXT: br label [[TMP5:%.*]]
-; CHECK: 4:
-; CHECK-NEXT: br label [[TMP5]]
-; CHECK: 5:
+; CHECK-SAME: (i32 [[ARG:%.*]]) {
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: [[I1:%.*]] = icmp eq i32 [[ARG]], 0
+; CHECK-NEXT: br i1 [[I1]], label [[BB3:%.*]], label [[BB2:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[I_H2S]])
+; CHECK-NEXT: br label [[BB4:%.*]]
+; CHECK: bb3:
+; CHECK-NEXT: br label [[BB4]]
+; CHECK: bb4:
; CHECK-NEXT: ret void
;
- %2 = tail call noalias i8* @malloc(i64 4)
- %3 = icmp eq i32 %0, 0
- br i1 %3, label %5, label %4
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ %i1 = icmp eq i32 %arg, 0
+ br i1 %i1, label %bb3, label %bb2
-4: ; preds = %1
- tail call void @nofree_func(i8* %2)
- tail call void @free(i8* %2)
- br label %6
+bb2:
+ tail call void @nofree_func(i8* %i)
+ tail call void @free(i8* %i)
+ br label %bb4
-5: ; preds = %1
- tail call void @free(i8* %2)
- br label %6
+bb3:
+ tail call void @free(i8* %i)
+ br label %bb4
-6: ; preds = %5, %4
+bb4:
ret void
}
@@ -293,13 +320,15 @@ define void @test6(i32) {
define void @test7() {
; CHECK-LABEL: define {{[^@]+}}@test7() {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: [[TMP1:%.*]] = tail call i32 @no_return_call() #[[ATTR4:[0-9]+]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: [[I1:%.*]] = tail call i32 @no_return_call() #[[ATTR4:[0-9]+]]
; CHECK-NEXT: unreachable
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call i32 @no_return_call()
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ %i1 = tail call i32 @no_return_call()
+ tail call void @free(i8* %i)
ret void
}
@@ -307,42 +336,46 @@ define void @test7() {
define void @test8() {
; CHECK-LABEL: define {{[^@]+}}@test8() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @foo(i32* noundef align 4 [[TMP2]])
-; CHECK-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @foo(i32* noundef align 4 [[I1]])
+; CHECK-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @foo(i32* %2)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @foo(i32* %i1)
+ tail call void @free(i8* %i)
ret void
}
; TEST 9 - FIXME: malloc should be converted.
define void @test9() {
; CHECK-LABEL: define {{[^@]+}}@test9() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) #[[ATTR11]]
-; CHECK-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @foo_nounw(i32* nofree noundef align 4 [[I1]]) #[[ATTR11]]
+; CHECK-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @foo_nounw(i32* %2)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @foo_nounw(i32* %i1)
+ tail call void @free(i8* %i)
ret void
}
@@ -350,307 +383,335 @@ define void @test9() {
define i32 @test10() {
; CHECK-LABEL: define {{[^@]+}}@test10() {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[DOTH2S]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP1]], align 4
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
-; CHECK-NEXT: ret i32 [[TMP2]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I_H2S]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I_H2S]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: ret i32 [[I2]]
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
define i32 @test_lifetime() {
; CHECK-LABEL: define {{[^@]+}}@test_lifetime() {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[DOTH2S]])
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[DOTH2S]])
-; CHECK-NEXT: [[TMP1:%.*]] = bitcast i8* [[DOTH2S]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP1]], align 4
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[TMP1]], align 4
-; CHECK-NEXT: ret i32 [[TMP2]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I_H2S]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[I_H2S]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I_H2S]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: ret i32 [[I2]]
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ call void @llvm.lifetime.start.p0i8(i64 4, i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
; TEST 11
define void @test11() {
; CHECK-LABEL: define {{[^@]+}}@test11() {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: tail call void @sync_will_return(i8* [[DOTH2S]]) #[[ATTR11]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: tail call void @sync_will_return(i8* [[I_H2S]]) #[[ATTR11]]
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @sync_will_return(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @sync_will_return(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
; TEST 12
-define i32 @irreducible_cfg(i32 %0) {
+define i32 @irreducible_cfg(i32 %arg) {
; CHECK-LABEL: define {{[^@]+}}@irreducible_cfg
-; CHECK-SAME: (i32 [[TMP0:%.*]]) {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[DOTH2S]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 1
-; CHECK-NEXT: br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP6:%.*]]
-; CHECK: 4:
-; CHECK-NEXT: [[TMP5:%.*]] = add nsw i32 [[TMP0]], 5
-; CHECK-NEXT: br label [[TMP12:%.*]]
-; CHECK: 6:
-; CHECK-NEXT: br label [[TMP7:%.*]]
-; CHECK: 7:
-; CHECK-NEXT: [[DOT0:%.*]] = phi i32 [ [[TMP13:%.*]], [[TMP12]] ], [ 1, [[TMP6]] ]
-; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP9:%.*]] = add nsw i32 [[TMP8]], -1
-; CHECK-NEXT: store i32 [[TMP9]], i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP10:%.*]] = icmp ne i32 [[TMP8]], 0
-; CHECK-NEXT: br i1 [[TMP10]], label [[TMP11:%.*]], label [[TMP14:%.*]]
-; CHECK: 11:
-; CHECK-NEXT: br label [[TMP12]]
-; CHECK: 12:
-; CHECK-NEXT: [[DOT1:%.*]] = phi i32 [ [[TMP5]], [[TMP4]] ], [ [[DOT0]], [[TMP11]] ]
-; CHECK-NEXT: [[TMP13]] = add nsw i32 [[DOT1]], 1
-; CHECK-NEXT: br label [[TMP7]]
-; CHECK: 14:
-; CHECK-NEXT: [[TMP15:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: ret i32 [[TMP15]]
+; CHECK-SAME: (i32 [[ARG:%.*]]) {
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I_H2S]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = icmp eq i32 [[ARG]], 1
+; CHECK-NEXT: br i1 [[I2]], label [[BB3:%.*]], label [[BB5:%.*]]
+; CHECK: bb3:
+; CHECK-NEXT: [[I4:%.*]] = add nsw i32 [[ARG]], 5
+; CHECK-NEXT: br label [[BB11:%.*]]
+; CHECK: bb5:
+; CHECK-NEXT: br label [[BB6:%.*]]
+; CHECK: bb6:
+; CHECK-NEXT: [[DOT0:%.*]] = phi i32 [ [[I12:%.*]], [[BB11]] ], [ 1, [[BB5]] ]
+; CHECK-NEXT: [[I7:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: [[I8:%.*]] = add nsw i32 [[I7]], -1
+; CHECK-NEXT: store i32 [[I8]], i32* [[I1]], align 4
+; CHECK-NEXT: [[I9:%.*]] = icmp ne i32 [[I7]], 0
+; CHECK-NEXT: br i1 [[I9]], label [[BB10:%.*]], label [[BB13:%.*]]
+; CHECK: bb10:
+; CHECK-NEXT: br label [[BB11]]
+; CHECK: bb11:
+; CHECK-NEXT: [[DOT1:%.*]] = phi i32 [ [[I4]], [[BB3]] ], [ [[DOT0]], [[BB10]] ]
+; CHECK-NEXT: [[I12]] = add nsw i32 [[DOT1]], 1
+; CHECK-NEXT: br label [[BB6]]
+; CHECK: bb13:
+; CHECK-NEXT: [[I16:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: ret i32 [[I16]]
;
- %2 = call noalias i8* @malloc(i64 4)
- %3 = bitcast i8* %2 to i32*
- store i32 10, i32* %3, align 4
- %4 = icmp eq i32 %0, 1
- br i1 %4, label %5, label %7
-
-5: ; preds = %1
- %6 = add nsw i32 %0, 5
- br label %13
-
-7: ; preds = %1
- br label %8
-
-8: ; preds = %13, %7
- %.0 = phi i32 [ %14, %13 ], [ 1, %7 ]
- %9 = load i32, i32* %3, align 4
- %10 = add nsw i32 %9, -1
- store i32 %10, i32* %3, align 4
- %11 = icmp ne i32 %9, 0
- br i1 %11, label %12, label %15
-
-12: ; preds = %8
- br label %13
-
-13: ; preds = %12, %5
- %.1 = phi i32 [ %6, %5 ], [ %.0, %12 ]
- %14 = add nsw i32 %.1, 1
- br label %8
-
-15: ; preds = %8
- %16 = load i32, i32* %3, align 4
- %17 = bitcast i32* %3 to i8*
- call void @free(i8* %17)
- %18 = load i32, i32* %3, align 4
- ret i32 %18
+bb:
+ %i = call noalias i8* @malloc(i64 4)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = icmp eq i32 %arg, 1
+ br i1 %i2, label %bb3, label %bb5
+
+bb3:
+ %i4 = add nsw i32 %arg, 5
+ br label %bb11
+
+bb5:
+ br label %bb6
+
+bb6:
+ %.0 = phi i32 [ %i12, %bb11 ], [ 1, %bb5 ]
+ %i7 = load i32, i32* %i1, align 4
+ %i8 = add nsw i32 %i7, -1
+ store i32 %i8, i32* %i1, align 4
+ %i9 = icmp ne i32 %i7, 0
+ br i1 %i9, label %bb10, label %bb13
+
+bb10:
+ br label %bb11
+
+bb11:
+ %.1 = phi i32 [ %i4, %bb3 ], [ %.0, %bb10 ]
+ %i12 = add nsw i32 %.1, 1
+ br label %bb6
+
+bb13:
+ %i14 = load i32, i32* %i1, align 4
+ %i15 = bitcast i32* %i1 to i8*
+ call void @free(i8* %i15)
+ %i16 = load i32, i32* %i1, align 4
+ ret i32 %i16
}
-define i32 @malloc_in_loop(i32 %0) {
+define i32 @malloc_in_loop(i32 %arg) {
; CHECK-LABEL: define {{[^@]+}}@malloc_in_loop
-; CHECK-SAME: (i32 [[TMP0:%.*]]) {
-; CHECK-NEXT: [[TMP2:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[TMP3:%.*]] = alloca i32*, align 8
-; CHECK-NEXT: store i32 [[TMP0]], i32* [[TMP2]], align 4
-; CHECK-NEXT: br label [[TMP4:%.*]]
-; CHECK: 4:
-; CHECK-NEXT: [[TMP5:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP5]], -1
-; CHECK-NEXT: store i32 [[TMP6]], i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP7:%.*]] = icmp sgt i32 [[TMP6]], 0
-; CHECK-NEXT: br i1 [[TMP7]], label [[TMP8:%.*]], label [[TMP10:%.*]]
-; CHECK: 8:
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: [[TMP9:%.*]] = bitcast i8* [[DOTH2S]] to i32*
-; CHECK-NEXT: br label [[TMP4]]
-; CHECK: 10:
+; CHECK-SAME: (i32 [[ARG:%.*]]) {
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[I1:%.*]] = alloca i32*, align 8
+; CHECK-NEXT: store i32 [[ARG]], i32* [[I]], align 4
+; CHECK-NEXT: br label [[BB2:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: [[I3:%.*]] = load i32, i32* [[I]], align 4
+; CHECK-NEXT: [[I4:%.*]] = add nsw i32 [[I3]], -1
+; CHECK-NEXT: store i32 [[I4]], i32* [[I]], align 4
+; CHECK-NEXT: [[I5:%.*]] = icmp sgt i32 [[I4]], 0
+; CHECK-NEXT: br i1 [[I5]], label [[BB6:%.*]], label [[BB9:%.*]]
+; CHECK: bb6:
+; CHECK-NEXT: [[I7_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: [[I8:%.*]] = bitcast i8* [[I7_H2S]] to i32*
+; CHECK-NEXT: br label [[BB2]]
+; CHECK: bb9:
; CHECK-NEXT: ret i32 5
;
- %2 = alloca i32, align 4
- %3 = alloca i32*, align 8
- store i32 %0, i32* %2, align 4
- br label %4
-
-4: ; preds = %8, %1
- %5 = load i32, i32* %2, align 4
- %6 = add nsw i32 %5, -1
- store i32 %6, i32* %2, align 4
- %7 = icmp sgt i32 %6, 0
- br i1 %7, label %8, label %11
-
-8: ; preds = %4
- %9 = call noalias i8* @malloc(i64 4)
- %10 = bitcast i8* %9 to i32*
- store i32 1, i32* %10, align 8
- br label %4
-
-11: ; preds = %4
+bb:
+ %i = alloca i32, align 4
+ %i1 = alloca i32*, align 8
+ store i32 %arg, i32* %i, align 4
+ br label %bb2
+
+bb2:
+ %i3 = load i32, i32* %i, align 4
+ %i4 = add nsw i32 %i3, -1
+ store i32 %i4, i32* %i, align 4
+ %i5 = icmp sgt i32 %i4, 0
+ br i1 %i5, label %bb6, label %bb9
+
+bb6:
+ %i7 = call noalias i8* @malloc(i64 4)
+ %i8 = bitcast i8* %i7 to i32*
+ store i32 1, i32* %i8, align 8
+ br label %bb2
+
+bb9:
ret i32 5
}
; Malloc/Calloc too large
define i32 @test13() {
; CHECK-LABEL: define {{[^@]+}}@test13() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 256)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; CHECK-NEXT: ret i32 [[TMP3]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 256)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
+; CHECK-NEXT: ret i32 [[I2]]
;
- %1 = tail call noalias i8* @malloc(i64 256)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+bb:
+ %i = tail call noalias i8* @malloc(i64 256)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
define i32 @test_sle() {
; CHECK-LABEL: define {{[^@]+}}@test_sle() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef -1)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; CHECK-NEXT: ret i32 [[TMP3]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef -1)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
+; CHECK-NEXT: ret i32 [[I2]]
;
- %1 = tail call noalias i8* @malloc(i64 -1)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+bb:
+ %i = tail call noalias i8* @malloc(i64 -1)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
define i32 @test_overflow() {
; CHECK-LABEL: define {{[^@]+}}@test_overflow() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 noundef 65537, i64 noundef 65537)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; CHECK-NEXT: ret i32 [[TMP3]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @calloc(i64 noundef 65537, i64 noundef 65537)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
+; CHECK-NEXT: ret i32 [[I2]]
;
- %1 = tail call noalias i8* @calloc(i64 65537, i64 65537)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+bb:
+ %i = tail call noalias i8* @calloc(i64 65537, i64 65537)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
define void @test14() {
; CHECK-LABEL: define {{[^@]+}}@test14() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 noundef 64, i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @calloc(i64 noundef 64, i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @calloc(i64 64, i64 4)
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @calloc(i64 64, i64 4)
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
define void @test15(i64 %S) {
; CHECK-LABEL: define {{[^@]+}}@test15
; CHECK-SAME: (i64 [[S:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 [[S]])
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 [[S]])
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 %S)
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 %S)
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
define void @test16a(i8 %v, i8** %P) {
; CHECK-LABEL: define {{[^@]+}}@test16a
; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: store i8 [[V]], i8* [[DOTH2S]], align 1
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[DOTH2S]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: store i8 [[V]], i8* [[I_H2S]], align 1
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[I_H2S]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- store i8 %v, i8* %1
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* nonnull dereferenceable(1) %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ store i8 %v, i8* %i, align 1
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* nonnull dereferenceable(1) %i)
ret void
}
define void @test16b(i8 %v, i8** %P) {
; CHECK-LABEL: define {{[^@]+}}@test16b
; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: store i8* [[TMP1]], i8** [[P]], align 8
-; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: store i8* [[I]], i8** [[P]], align 8
+; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[I]])
+; CHECK-NEXT: tail call void @free(i8* nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- store i8* %1, i8** %P
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ store i8* %i, i8** %P, align 8
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
define void @test16c(i8 %v, i8** %P) {
; CHECK-LABEL: define {{[^@]+}}@test16c
; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: store i8* [[DOTH2S]], i8** [[P]], align 8
-; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[DOTH2S]]) #[[ATTR11]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: store i8* [[I_H2S]], i8** [[P]], align 8
+; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[I_H2S]]) #[[ATTR11]]
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- store i8* %1, i8** %P
- tail call void @no_sync_func(i8* %1) nounwind
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ store i8* %i, i8** %P, align 8
+ tail call void @no_sync_func(i8* %i) nounwind
+ tail call void @free(i8* %i)
ret void
}
define void @test16d(i8 %v, i8** %P) {
; CHECK-LABEL: define {{[^@]+}}@test16d
; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: store i8* [[TMP1]], i8** [[P]], align 8
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: store i8* [[I]], i8** [[P]], align 8
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- store i8* %1, i8** %P
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ store i8* %i, i8** %P, align 8
ret void
}
@@ -659,16 +720,18 @@ define void @test16e(i8 %v) norecurse {
; CHECK: Function Attrs: norecurse
; CHECK-LABEL: define {{[^@]+}}@test16e
; CHECK-SAME: (i8 [[V:%.*]]) #[[ATTR9:[0-9]+]] {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1
-; CHECK-NEXT: store i8* [[DOTH2S]], i8** @G, align 8
-; CHECK-NEXT: call void @usei8p(i8* nocapture nofree [[DOTH2S]]) #[[ATTR12:[0-9]+]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1
+; CHECK-NEXT: store i8* [[I_H2S]], i8** @G, align 8
+; CHECK-NEXT: call void @usei8p(i8* nocapture nofree [[I_H2S]]) #[[ATTR12:[0-9]+]]
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- store i8* %1, i8** @G
- %2 = load i8*, i8** @G
- call void @usei8p(i8* nofree nocapture %2) nocallback nosync willreturn nounwind
- call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ store i8* %i, i8** @G, align 8
+ %i1 = load i8*, i8** @G, align 8
+ call void @usei8p(i8* nocapture nofree %i1) nocallback nosync nounwind willreturn
+ call void @free(i8* %i)
ret void
}
diff --git a/llvm/test/Transforms/Attributor/heap_to_stack_gpu.ll b/llvm/test/Transforms/Attributor/heap_to_stack_gpu.ll
index ef7a80c1e00a2..116a942f5d999 100644
--- a/llvm/test/Transforms/Attributor/heap_to_stack_gpu.ll
+++ b/llvm/test/Transforms/Attributor/heap_to_stack_gpu.ll
@@ -41,10 +41,12 @@ declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) nounwind
define void @nofree_arg_only(i8* %p1, i8* %p2) {
; CHECK-LABEL: define {{[^@]+}}@nofree_arg_only
; CHECK-SAME: (i8* nocapture nofree [[P1:%.*]], i8* nocapture [[P2:%.*]]) {
+; CHECK-NEXT: bb:
; CHECK-NEXT: tail call void @free(i8* nocapture [[P2]])
; CHECK-NEXT: tail call void @nofree_func(i8* nocapture nofree [[P1]])
; CHECK-NEXT: ret void
;
+bb:
tail call void @free(i8* %p2)
tail call void @nofree_func(i8* %p1)
ret void
@@ -54,16 +56,18 @@ define void @nofree_arg_only(i8* %p1, i8* %p2) {
define void @test1() {
; CHECK-LABEL: define {{[^@]+}}@test1() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @nocapture_func_frees_pointer(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @nocapture_func_frees_pointer(i8* noalias nocapture [[I]])
; CHECK-NEXT: tail call void (...) @func_throws()
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @nocapture_func_frees_pointer(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @nocapture_func_frees_pointer(i8* %i)
tail call void (...) @func_throws()
- tail call void @free(i8* %1)
+ tail call void @free(i8* %i)
ret void
}
@@ -71,14 +75,16 @@ define void @test1() {
define void @test2() {
; CHECK-LABEL: define {{[^@]+}}@test2() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @sync_func(i8* [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @sync_func(i8* [[I]])
+; CHECK-NEXT: tail call void @free(i8* nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
@@ -86,28 +92,32 @@ define void @test2() {
define void @test3() {
; CHECK-LABEL: define {{[^@]+}}@test3() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
define void @test3a(i8* %p) {
; CHECK-LABEL: define {{[^@]+}}@test3a
; CHECK-SAME: (i8* nocapture [[P:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP1]], i8* nocapture [[P]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[I]], i8* nocapture [[P]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @nofree_arg_only(i8* %1, i8* %p)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @nofree_arg_only(i8* %i, i8* %p)
+ tail call void @free(i8* %i)
ret void
}
@@ -116,14 +126,16 @@ declare noalias i8* @aligned_alloc(i64, i64)
define void @test3b(i8* %p) {
; CHECK-LABEL: define {{[^@]+}}@test3b
; CHECK-SAME: (i8* nocapture [[P:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 32, i64 noundef 128)
-; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP1]], i8* nocapture [[P]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 32, i64 noundef 128)
+; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[I]], i8* nocapture [[P]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @aligned_alloc(i64 32, i64 128)
- tail call void @nofree_arg_only(i8* %1, i8* %p)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @aligned_alloc(i64 32, i64 128)
+ tail call void @nofree_arg_only(i8* %i, i8* %p)
+ tail call void @free(i8* %i)
ret void
}
@@ -131,12 +143,14 @@ define void @test3b(i8* %p) {
define void @test3c(i64 %alignment) {
; CHECK-LABEL: define {{[^@]+}}@test3c
; CHECK-SAME: (i64 [[ALIGNMENT:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 [[ALIGNMENT]], i64 noundef 128)
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @aligned_alloc(i64 [[ALIGNMENT]], i64 noundef 128)
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @aligned_alloc(i64 %alignment, i64 128)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @aligned_alloc(i64 %alignment, i64 128)
+ tail call void @free(i8* %i)
ret void
}
@@ -144,97 +158,105 @@ declare noalias i8* @calloc(i64, i64)
define void @test0() {
; CHECK-LABEL: define {{[^@]+}}@test0() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 noundef 2, i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @calloc(i64 noundef 2, i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @calloc(i64 2, i64 4)
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @calloc(i64 2, i64 4)
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
; TEST 4
define void @test4() {
; CHECK-LABEL: define {{[^@]+}}@test4() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @nofree_func(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @nofree_func(i8* %i)
ret void
}
; TEST 5 - not all exit paths have a call to free, but all uses of malloc
; are in nofree functions and are not captured
-define void @test5(i32, i8* %p) {
+define void @test5(i32 %arg, i8* %p) {
; CHECK-LABEL: define {{[^@]+}}@test5
-; CHECK-SAME: (i32 [[TMP0:%.*]], i8* nocapture [[P:%.*]]) {
-; CHECK-NEXT: [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
-; CHECK-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
-; CHECK: 4:
-; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[TMP2]])
-; CHECK-NEXT: br label [[TMP6:%.*]]
-; CHECK: 5:
-; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP2]], i8* nocapture [[P]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP2]])
-; CHECK-NEXT: br label [[TMP6]]
-; CHECK: 6:
+; CHECK-SAME: (i32 [[ARG:%.*]], i8* nocapture [[P:%.*]]) {
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: [[I1:%.*]] = icmp eq i32 [[ARG]], 0
+; CHECK-NEXT: br i1 [[I1]], label [[BB3:%.*]], label [[BB2:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: br label [[BB4:%.*]]
+; CHECK: bb3:
+; CHECK-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[I]], i8* nocapture [[P]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
+; CHECK-NEXT: br label [[BB4]]
+; CHECK: bb4:
; CHECK-NEXT: ret void
;
- %2 = tail call noalias i8* @malloc(i64 4)
- %3 = icmp eq i32 %0, 0
- br i1 %3, label %5, label %4
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ %i1 = icmp eq i32 %arg, 0
+ br i1 %i1, label %bb3, label %bb2
-4: ; preds = %1
- tail call void @nofree_func(i8* %2)
- br label %6
+bb2:
+ tail call void @nofree_func(i8* %i)
+ br label %bb4
-5: ; preds = %1
- tail call void @nofree_arg_only(i8* %2, i8* %p)
- tail call void @free(i8* %2)
- br label %6
+bb3:
+ tail call void @nofree_arg_only(i8* %i, i8* %p)
+ tail call void @free(i8* %i)
+ br label %bb4
-6: ; preds = %5, %4
+bb4:
ret void
}
; TEST 6 - all exit paths have a call to free
-define void @test6(i32) {
+define void @test6(i32 %arg) {
; CHECK-LABEL: define {{[^@]+}}@test6
-; CHECK-SAME: (i32 [[TMP0:%.*]]) {
-; CHECK-NEXT: [[TMP2:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: [[TMP3:%.*]] = icmp eq i32 [[TMP0]], 0
-; CHECK-NEXT: br i1 [[TMP3]], label [[TMP5:%.*]], label [[TMP4:%.*]]
-; CHECK: 4:
-; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[TMP2]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP2]])
-; CHECK-NEXT: br label [[TMP6:%.*]]
-; CHECK: 5:
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP2]])
-; CHECK-NEXT: br label [[TMP6]]
-; CHECK: 6:
+; CHECK-SAME: (i32 [[ARG:%.*]]) {
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: [[I1:%.*]] = icmp eq i32 [[ARG]], 0
+; CHECK-NEXT: br i1 [[I1]], label [[BB3:%.*]], label [[BB2:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: tail call void @nofree_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
+; CHECK-NEXT: br label [[BB4:%.*]]
+; CHECK: bb3:
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
+; CHECK-NEXT: br label [[BB4]]
+; CHECK: bb4:
; CHECK-NEXT: ret void
;
- %2 = tail call noalias i8* @malloc(i64 4)
- %3 = icmp eq i32 %0, 0
- br i1 %3, label %5, label %4
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ %i1 = icmp eq i32 %arg, 0
+ br i1 %i1, label %bb3, label %bb2
-4: ; preds = %1
- tail call void @nofree_func(i8* %2)
- tail call void @free(i8* %2)
- br label %6
+bb2:
+ tail call void @nofree_func(i8* %i)
+ tail call void @free(i8* %i)
+ br label %bb4
-5: ; preds = %1
- tail call void @free(i8* %2)
- br label %6
+bb3:
+ tail call void @free(i8* %i)
+ br label %bb4
-6: ; preds = %5, %4
+bb4:
ret void
}
@@ -242,13 +264,15 @@ define void @test6(i32) {
define void @test7() {
; CHECK-LABEL: define {{[^@]+}}@test7() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: [[TMP2:%.*]] = tail call i32 @no_return_call() #[[ATTR3:[0-9]+]]
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: [[I1:%.*]] = tail call i32 @no_return_call() #[[ATTR3:[0-9]+]]
; CHECK-NEXT: unreachable
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call i32 @no_return_call()
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ %i1 = tail call i32 @no_return_call()
+ tail call void @free(i8* %i)
ret void
}
@@ -256,42 +280,46 @@ define void @test7() {
define void @test8() {
; CHECK-LABEL: define {{[^@]+}}@test8() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @foo(i32* noundef align 4 [[TMP2]])
-; CHECK-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @foo(i32* noundef align 4 [[I1]])
+; CHECK-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @foo(i32* %2)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @foo(i32* %i1)
+ tail call void @free(i8* %i)
ret void
}
; TEST 9 - FIXME: malloc should be converted.
define void @test9() {
; CHECK-LABEL: define {{[^@]+}}@test9() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @foo_nounw(i32* nofree noundef align 4 [[TMP2]]) #[[ATTR6:[0-9]+]]
-; CHECK-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @foo_nounw(i32* nofree noundef align 4 [[I1]]) #[[ATTR6:[0-9]+]]
+; CHECK-NEXT: tail call void @free(i8* nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @foo_nounw(i32* %2)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @foo_nounw(i32* %i1)
+ tail call void @free(i8* %i)
ret void
}
@@ -299,315 +327,342 @@ define void @test9() {
define i32 @test10() {
; CHECK-LABEL: define {{[^@]+}}@test10() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; CHECK-NEXT: ret i32 [[TMP3]]
-;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
+; CHECK-NEXT: ret i32 [[I2]]
+;
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
define i32 @test_lifetime() {
; CHECK-LABEL: define {{[^@]+}}@test_lifetime() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; CHECK-NEXT: ret i32 [[TMP3]]
-;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @no_sync_func(i8* %1)
- call void @llvm.lifetime.start.p0i8(i64 4, i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 noundef 4, i8* noalias nocapture nofree noundef nonnull align 4 dereferenceable(4) [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
+; CHECK-NEXT: ret i32 [[I2]]
+;
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @no_sync_func(i8* %i)
+ call void @llvm.lifetime.start.p0i8(i64 4, i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
; TEST 11
define void @test11() {
; CHECK-LABEL: define {{[^@]+}}@test11() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: tail call void @sync_will_return(i8* [[TMP1]]) #[[ATTR6]]
-; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: tail call void @sync_will_return(i8* [[I]]) #[[ATTR6]]
+; CHECK-NEXT: tail call void @free(i8* nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- tail call void @sync_will_return(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ tail call void @sync_will_return(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
; TEST 12
-define i32 @irreducible_cfg(i32 %0) {
-;
+define i32 @irreducible_cfg(i32 %arg) {
; CHECK-LABEL: define {{[^@]+}}@irreducible_cfg
-; CHECK-SAME: (i32 [[TMP0:%.*]]) {
-; CHECK-NEXT: [[TMP2:%.*]] = call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: [[TMP3:%.*]] = bitcast i8* [[TMP2]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP3]], align 4
-; CHECK-NEXT: [[TMP4:%.*]] = icmp eq i32 [[TMP0]], 1
-; CHECK-NEXT: br i1 [[TMP4]], label [[TMP5:%.*]], label [[TMP7:%.*]]
-; CHECK: 5:
-; CHECK-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP0]], 5
-; CHECK-NEXT: br label [[TMP13:%.*]]
-; CHECK: 7:
-; CHECK-NEXT: br label [[TMP8:%.*]]
-; CHECK: 8:
-; CHECK-NEXT: [[DOT0:%.*]] = phi i32 [ [[TMP14:%.*]], [[TMP13]] ], [ 1, [[TMP7]] ]
-; CHECK-NEXT: [[TMP9:%.*]] = load i32, i32* [[TMP3]], align 4
-; CHECK-NEXT: [[TMP10:%.*]] = add nsw i32 [[TMP9]], -1
-; CHECK-NEXT: store i32 [[TMP10]], i32* [[TMP3]], align 4
-; CHECK-NEXT: [[TMP11:%.*]] = icmp ne i32 [[TMP9]], 0
-; CHECK-NEXT: br i1 [[TMP11]], label [[TMP12:%.*]], label [[TMP15:%.*]]
-; CHECK: 12:
-; CHECK-NEXT: br label [[TMP13]]
-; CHECK: 13:
-; CHECK-NEXT: [[DOT1:%.*]] = phi i32 [ [[TMP6]], [[TMP5]] ], [ [[DOT0]], [[TMP12]] ]
-; CHECK-NEXT: [[TMP14]] = add nsw i32 [[DOT1]], 1
-; CHECK-NEXT: br label [[TMP8]]
-; CHECK: 15:
-; CHECK-NEXT: [[TMP16:%.*]] = load i32, i32* [[TMP3]], align 4
-; CHECK-NEXT: call void @free(i8* nocapture noundef [[TMP2]])
-; CHECK-NEXT: [[TMP17:%.*]] = load i32, i32* [[TMP3]], align 4
-; CHECK-NEXT: ret i32 [[TMP17]]
-;
- %2 = call noalias i8* @malloc(i64 4)
- %3 = bitcast i8* %2 to i32*
- store i32 10, i32* %3, align 4
- %4 = icmp eq i32 %0, 1
- br i1 %4, label %5, label %7
-
-5: ; preds = %1
- %6 = add nsw i32 %0, 5
- br label %13
-
-7: ; preds = %1
- br label %8
-
-8: ; preds = %13, %7
- %.0 = phi i32 [ %14, %13 ], [ 1, %7 ]
- %9 = load i32, i32* %3, align 4
- %10 = add nsw i32 %9, -1
- store i32 %10, i32* %3, align 4
- %11 = icmp ne i32 %9, 0
- br i1 %11, label %12, label %15
-
-12: ; preds = %8
- br label %13
-
-13: ; preds = %12, %5
- %.1 = phi i32 [ %6, %5 ], [ %.0, %12 ]
- %14 = add nsw i32 %.1, 1
- br label %8
-
-15: ; preds = %8
- %16 = load i32, i32* %3, align 4
- %17 = bitcast i32* %3 to i8*
- call void @free(i8* %17)
- %18 = load i32, i32* %3, align 4
- ret i32 %18
-}
-
-
-define i32 @malloc_in_loop(i32 %0) {
+; CHECK-SAME: (i32 [[ARG:%.*]]) {
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = icmp eq i32 [[ARG]], 1
+; CHECK-NEXT: br i1 [[I2]], label [[BB3:%.*]], label [[BB5:%.*]]
+; CHECK: bb3:
+; CHECK-NEXT: [[I4:%.*]] = add nsw i32 [[ARG]], 5
+; CHECK-NEXT: br label [[BB11:%.*]]
+; CHECK: bb5:
+; CHECK-NEXT: br label [[BB6:%.*]]
+; CHECK: bb6:
+; CHECK-NEXT: [[DOT0:%.*]] = phi i32 [ [[I12:%.*]], [[BB11]] ], [ 1, [[BB5]] ]
+; CHECK-NEXT: [[I7:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: [[I8:%.*]] = add nsw i32 [[I7]], -1
+; CHECK-NEXT: store i32 [[I8]], i32* [[I1]], align 4
+; CHECK-NEXT: [[I9:%.*]] = icmp ne i32 [[I7]], 0
+; CHECK-NEXT: br i1 [[I9]], label [[BB10:%.*]], label [[BB13:%.*]]
+; CHECK: bb10:
+; CHECK-NEXT: br label [[BB11]]
+; CHECK: bb11:
+; CHECK-NEXT: [[DOT1:%.*]] = phi i32 [ [[I4]], [[BB3]] ], [ [[DOT0]], [[BB10]] ]
+; CHECK-NEXT: [[I12]] = add nsw i32 [[DOT1]], 1
+; CHECK-NEXT: br label [[BB6]]
+; CHECK: bb13:
+; CHECK-NEXT: [[I14:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: call void @free(i8* nocapture noundef [[I]])
+; CHECK-NEXT: [[I16:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: ret i32 [[I16]]
+;
+bb:
+ %i = call noalias i8* @malloc(i64 4)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = icmp eq i32 %arg, 1
+ br i1 %i2, label %bb3, label %bb5
+
+bb3:
+ %i4 = add nsw i32 %arg, 5
+ br label %bb11
+
+bb5:
+ br label %bb6
+
+bb6:
+ %.0 = phi i32 [ %i12, %bb11 ], [ 1, %bb5 ]
+ %i7 = load i32, i32* %i1, align 4
+ %i8 = add nsw i32 %i7, -1
+ store i32 %i8, i32* %i1, align 4
+ %i9 = icmp ne i32 %i7, 0
+ br i1 %i9, label %bb10, label %bb13
+
+bb10:
+ br label %bb11
+
+bb11:
+ %.1 = phi i32 [ %i4, %bb3 ], [ %.0, %bb10 ]
+ %i12 = add nsw i32 %.1, 1
+ br label %bb6
+
+bb13:
+ %i14 = load i32, i32* %i1, align 4
+ %i15 = bitcast i32* %i1 to i8*
+ call void @free(i8* %i15)
+ %i16 = load i32, i32* %i1, align 4
+ ret i32 %i16
+}
+
+
+define i32 @malloc_in_loop(i32 %arg) {
; CHECK-LABEL: define {{[^@]+}}@malloc_in_loop
-; CHECK-SAME: (i32 [[TMP0:%.*]]) {
-; CHECK-NEXT: [[TMP2:%.*]] = alloca i32, align 4
-; CHECK-NEXT: [[TMP3:%.*]] = alloca i32*, align 8
-; CHECK-NEXT: store i32 [[TMP0]], i32* [[TMP2]], align 4
-; CHECK-NEXT: br label [[TMP4:%.*]]
-; CHECK: 4:
-; CHECK-NEXT: [[TMP5:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP6:%.*]] = add nsw i32 [[TMP5]], -1
-; CHECK-NEXT: store i32 [[TMP6]], i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP7:%.*]] = icmp sgt i32 [[TMP6]], 0
-; CHECK-NEXT: br i1 [[TMP7]], label [[TMP8:%.*]], label [[TMP11:%.*]]
-; CHECK: 8:
-; CHECK-NEXT: [[TMP9:%.*]] = call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: [[TMP10:%.*]] = bitcast i8* [[TMP9]] to i32*
-; CHECK-NEXT: br label [[TMP4]]
-; CHECK: 11:
+; CHECK-SAME: (i32 [[ARG:%.*]]) {
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = alloca i32, align 4
+; CHECK-NEXT: [[I1:%.*]] = alloca i32*, align 8
+; CHECK-NEXT: store i32 [[ARG]], i32* [[I]], align 4
+; CHECK-NEXT: br label [[BB2:%.*]]
+; CHECK: bb2:
+; CHECK-NEXT: [[I3:%.*]] = load i32, i32* [[I]], align 4
+; CHECK-NEXT: [[I4:%.*]] = add nsw i32 [[I3]], -1
+; CHECK-NEXT: store i32 [[I4]], i32* [[I]], align 4
+; CHECK-NEXT: [[I5:%.*]] = icmp sgt i32 [[I4]], 0
+; CHECK-NEXT: br i1 [[I5]], label [[BB6:%.*]], label [[BB9:%.*]]
+; CHECK: bb6:
+; CHECK-NEXT: [[I7:%.*]] = call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: [[I8:%.*]] = bitcast i8* [[I7]] to i32*
+; CHECK-NEXT: br label [[BB2]]
+; CHECK: bb9:
; CHECK-NEXT: ret i32 5
;
- %2 = alloca i32, align 4
- %3 = alloca i32*, align 8
- store i32 %0, i32* %2, align 4
- br label %4
-
-4: ; preds = %8, %1
- %5 = load i32, i32* %2, align 4
- %6 = add nsw i32 %5, -1
- store i32 %6, i32* %2, align 4
- %7 = icmp sgt i32 %6, 0
- br i1 %7, label %8, label %11
-
-8: ; preds = %4
- %9 = call noalias i8* @malloc(i64 4)
- %10 = bitcast i8* %9 to i32*
- store i32 1, i32* %10, align 8
- br label %4
-
-11: ; preds = %4
+bb:
+ %i = alloca i32, align 4
+ %i1 = alloca i32*, align 8
+ store i32 %arg, i32* %i, align 4
+ br label %bb2
+
+bb2:
+ %i3 = load i32, i32* %i, align 4
+ %i4 = add nsw i32 %i3, -1
+ store i32 %i4, i32* %i, align 4
+ %i5 = icmp sgt i32 %i4, 0
+ br i1 %i5, label %bb6, label %bb9
+
+bb6:
+ %i7 = call noalias i8* @malloc(i64 4)
+ %i8 = bitcast i8* %i7 to i32*
+ store i32 1, i32* %i8, align 8
+ br label %bb2
+
+bb9:
ret i32 5
}
; Malloc/Calloc too large
define i32 @test13() {
; CHECK-LABEL: define {{[^@]+}}@test13() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 256)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; CHECK-NEXT: ret i32 [[TMP3]]
-;
- %1 = tail call noalias i8* @malloc(i64 256)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 256)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
+; CHECK-NEXT: ret i32 [[I2]]
+;
+bb:
+ %i = tail call noalias i8* @malloc(i64 256)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
define i32 @test_sle() {
; CHECK-LABEL: define {{[^@]+}}@test_sle() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef -1)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; CHECK-NEXT: ret i32 [[TMP3]]
-;
- %1 = tail call noalias i8* @malloc(i64 -1)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef -1)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
+; CHECK-NEXT: ret i32 [[I2]]
+;
+bb:
+ %i = tail call noalias i8* @malloc(i64 -1)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
define i32 @test_overflow() {
; CHECK-LABEL: define {{[^@]+}}@test_overflow() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 noundef 65537, i64 noundef 65537)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: [[TMP2:%.*]] = bitcast i8* [[TMP1]] to i32*
-; CHECK-NEXT: store i32 10, i32* [[TMP2]], align 4
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[TMP2]], align 4
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[TMP1]])
-; CHECK-NEXT: ret i32 [[TMP3]]
-;
- %1 = tail call noalias i8* @calloc(i64 65537, i64 65537)
- tail call void @no_sync_func(i8* %1)
- %2 = bitcast i8* %1 to i32*
- store i32 10, i32* %2
- %3 = load i32, i32* %2
- tail call void @free(i8* %1)
- ret i32 %3
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @calloc(i64 noundef 65537, i64 noundef 65537)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: [[I1:%.*]] = bitcast i8* [[I]] to i32*
+; CHECK-NEXT: store i32 10, i32* [[I1]], align 4
+; CHECK-NEXT: [[I2:%.*]] = load i32, i32* [[I1]], align 4
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull align 4 dereferenceable(4) [[I]])
+; CHECK-NEXT: ret i32 [[I2]]
+;
+bb:
+ %i = tail call noalias i8* @calloc(i64 65537, i64 65537)
+ tail call void @no_sync_func(i8* %i)
+ %i1 = bitcast i8* %i to i32*
+ store i32 10, i32* %i1, align 4
+ %i2 = load i32, i32* %i1, align 4
+ tail call void @free(i8* %i)
+ ret i32 %i2
}
define void @test14() {
; CHECK-LABEL: define {{[^@]+}}@test14() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @calloc(i64 noundef 64, i64 noundef 4)
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @calloc(i64 noundef 64, i64 noundef 4)
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @calloc(i64 64, i64 4)
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @calloc(i64 64, i64 4)
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
define void @test15(i64 %S) {
; CHECK-LABEL: define {{[^@]+}}@test15
; CHECK-SAME: (i64 [[S:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 [[S]])
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 [[S]])
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree [[I]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 %S)
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 %S)
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
define void @test16a(i8 %v, i8** %P) {
; CHECK-LABEL: define {{[^@]+}}@test16a
; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree readnone [[P:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: store i8 [[V]], i8* [[TMP1]], align 1
-; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull dereferenceable(1) [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: store i8 [[V]], i8* [[I]], align 1
+; CHECK-NEXT: tail call void @no_sync_func(i8* noalias nocapture nofree noundef nonnull dereferenceable(1) [[I]])
+; CHECK-NEXT: tail call void @free(i8* noalias nocapture noundef nonnull dereferenceable(1) [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- store i8 %v, i8* %1
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* nonnull dereferenceable(1) %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ store i8 %v, i8* %i, align 1
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* nonnull dereferenceable(1) %i)
ret void
}
define void @test16b(i8 %v, i8** %P) {
; CHECK-LABEL: define {{[^@]+}}@test16b
; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: store i8* [[TMP1]], i8** [[P]], align 8
-; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[TMP1]])
-; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: store i8* [[I]], i8** [[P]], align 8
+; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[I]])
+; CHECK-NEXT: tail call void @free(i8* nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- store i8* %1, i8** %P
- tail call void @no_sync_func(i8* %1)
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ store i8* %i, i8** %P, align 8
+ tail call void @no_sync_func(i8* %i)
+ tail call void @free(i8* %i)
ret void
}
define void @test16c(i8 %v, i8** %P) {
; CHECK-LABEL: define {{[^@]+}}@test16c
; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: store i8* [[TMP1]], i8** [[P]], align 8
-; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[TMP1]]) #[[ATTR6]]
-; CHECK-NEXT: tail call void @free(i8* nocapture [[TMP1]])
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: store i8* [[I]], i8** [[P]], align 8
+; CHECK-NEXT: tail call void @no_sync_func(i8* nocapture nofree [[I]]) #[[ATTR6]]
+; CHECK-NEXT: tail call void @free(i8* nocapture [[I]])
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- store i8* %1, i8** %P
- tail call void @no_sync_func(i8* %1) nounwind
- tail call void @free(i8* %1)
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ store i8* %i, i8** %P, align 8
+ tail call void @no_sync_func(i8* %i) nounwind
+ tail call void @free(i8* %i)
ret void
}
define void @test16d(i8 %v, i8** %P) {
; CHECK-LABEL: define {{[^@]+}}@test16d
; CHECK-SAME: (i8 [[V:%.*]], i8** nocapture nofree writeonly [[P:%.*]]) {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
-; CHECK-NEXT: store i8* [[TMP1]], i8** [[P]], align 8
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @malloc(i64 noundef 4)
+; CHECK-NEXT: store i8* [[I]], i8** [[P]], align 8
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @malloc(i64 4)
- store i8* %1, i8** %P
+bb:
+ %i = tail call noalias i8* @malloc(i64 4)
+ store i8* %i, i8** %P, align 8
ret void
}
@@ -616,37 +671,41 @@ declare void @__kmpc_free_shared(i8* nocapture, i64)
define void @test17() {
; CHECK-LABEL: define {{[^@]+}}@test17() {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1, addrspace(5)
-; CHECK-NEXT: [[MALLOC_CAST:%.*]] = addrspacecast i8 addrspace(5)* [[DOTH2S]] to i8*
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1, addrspace(5)
+; CHECK-NEXT: [[MALLOC_CAST:%.*]] = addrspacecast i8 addrspace(5)* [[I_H2S]] to i8*
; CHECK-NEXT: tail call void @usei8(i8* noalias nocapture nofree [[MALLOC_CAST]]) #[[ATTR7:[0-9]+]]
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
- tail call void @usei8(i8* nocapture nofree %1) willreturn nounwind nosync
- tail call void @__kmpc_free_shared(i8* %1, i64 4)
+bb:
+ %i = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
+ tail call void @usei8(i8* nocapture nofree %i) nosync nounwind willreturn
+ tail call void @__kmpc_free_shared(i8* %i, i64 4)
ret void
}
define void @test17b() {
; CHECK-LABEL: define {{[^@]+}}@test17b() {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @__kmpc_alloc_shared(i64 noundef 4)
-; CHECK-NEXT: tail call void @usei8(i8* nofree [[TMP1]]) #[[ATTR7]]
-; CHECK-NEXT: tail call void @__kmpc_free_shared(i8* nocapture [[TMP1]], i64 noundef 4)
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @__kmpc_alloc_shared(i64 noundef 4)
+; CHECK-NEXT: tail call void @usei8(i8* nofree [[I]]) #[[ATTR7]]
+; CHECK-NEXT: tail call void @__kmpc_free_shared(i8* nocapture [[I]], i64 noundef 4)
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
- tail call void @usei8(i8* nofree %1) willreturn nounwind nosync
- tail call void @__kmpc_free_shared(i8* %1, i64 4)
+bb:
+ %i = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
+ tail call void @usei8(i8* nofree %i) nosync nounwind willreturn
+ tail call void @__kmpc_free_shared(i8* %i, i64 4)
ret void
}
define void @move_alloca() {
; CHECK-LABEL: define {{[^@]+}}@move_alloca() {
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1, addrspace(5)
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1, addrspace(5)
; CHECK-NEXT: br label [[NOT_ENTRY:%.*]]
; CHECK: not_entry:
-; CHECK-NEXT: [[MALLOC_CAST:%.*]] = addrspacecast i8 addrspace(5)* [[DOTH2S]] to i8*
+; CHECK-NEXT: [[MALLOC_CAST:%.*]] = addrspacecast i8 addrspace(5)* [[I_H2S]] to i8*
; CHECK-NEXT: tail call void @usei8(i8* noalias nocapture nofree [[MALLOC_CAST]]) #[[ATTR7]]
; CHECK-NEXT: ret void
;
@@ -654,9 +713,9 @@ entry:
br label %not_entry
not_entry:
- %0 = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
- tail call void @usei8(i8* nocapture nofree %0) willreturn nounwind nosync
- tail call void @__kmpc_free_shared(i8* %0, i64 4)
+ %i = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
+ tail call void @usei8(i8* nocapture nofree %i) nosync nounwind willreturn
+ tail call void @__kmpc_free_shared(i8* %i, i64 4)
ret void
}
@@ -665,17 +724,19 @@ define void @test16e(i8 %v) norecurse {
; CHECK: Function Attrs: norecurse
; CHECK-LABEL: define {{[^@]+}}@test16e
; CHECK-SAME: (i8 [[V:%.*]]) #[[ATTR5:[0-9]+]] {
-; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @__kmpc_alloc_shared(i64 noundef 4)
-; CHECK-NEXT: store i8* [[TMP1]], i8** @G, align 8
-; CHECK-NEXT: call void @usei8(i8* nocapture nofree [[TMP1]]) #[[ATTR8:[0-9]+]]
-; CHECK-NEXT: tail call void @__kmpc_free_shared(i8* noalias nocapture [[TMP1]], i64 noundef 4)
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I:%.*]] = tail call noalias i8* @__kmpc_alloc_shared(i64 noundef 4)
+; CHECK-NEXT: store i8* [[I]], i8** @G, align 8
+; CHECK-NEXT: call void @usei8(i8* nocapture nofree [[I]]) #[[ATTR8:[0-9]+]]
+; CHECK-NEXT: tail call void @__kmpc_free_shared(i8* noalias nocapture [[I]], i64 noundef 4)
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
- store i8* %1, i8** @G
- %2 = load i8*, i8** @G
- call void @usei8(i8* nofree nocapture %2) nocallback nosync willreturn nounwind
- tail call void @__kmpc_free_shared(i8* %1, i64 4)
+bb:
+ %i = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
+ store i8* %i, i8** @G, align 8
+ %i1 = load i8*, i8** @G, align 8
+ call void @usei8(i8* nocapture nofree %i1) nocallback nosync nounwind willreturn
+ tail call void @__kmpc_free_shared(i8* %i, i64 4)
ret void
}
@@ -684,17 +745,19 @@ define void @test16f(i8 %v) norecurse {
; CHECK: Function Attrs: norecurse
; CHECK-LABEL: define {{[^@]+}}@test16f
; CHECK-SAME: (i8 [[V:%.*]]) #[[ATTR5]] {
-; CHECK-NEXT: [[DOTH2S:%.*]] = alloca i8, i64 4, align 1, addrspace(5)
-; CHECK-NEXT: [[MALLOC_CAST:%.*]] = addrspacecast i8 addrspace(5)* [[DOTH2S]] to i8*
+; CHECK-NEXT: bb:
+; CHECK-NEXT: [[I_H2S:%.*]] = alloca i8, i64 4, align 1, addrspace(5)
+; CHECK-NEXT: [[MALLOC_CAST:%.*]] = addrspacecast i8 addrspace(5)* [[I_H2S]] to i8*
; CHECK-NEXT: store i8* [[MALLOC_CAST]], i8** @Gtl, align 8
; CHECK-NEXT: call void @usei8(i8* nocapture nofree [[MALLOC_CAST]]) #[[ATTR8]]
; CHECK-NEXT: ret void
;
- %1 = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
- store i8* %1, i8** @Gtl
- %2 = load i8*, i8** @Gtl
- call void @usei8(i8* nofree nocapture %2) nocallback nosync willreturn nounwind
- tail call void @__kmpc_free_shared(i8* %1, i64 4)
+bb:
+ %i = tail call noalias i8* @__kmpc_alloc_shared(i64 4)
+ store i8* %i, i8** @Gtl, align 8
+ %i1 = load i8*, i8** @Gtl, align 8
+ call void @usei8(i8* nocapture nofree %i1) nocallback nosync nounwind willreturn
+ tail call void @__kmpc_free_shared(i8* %i, i64 4)
ret void
}
More information about the llvm-commits
mailing list