26 changes: 12 additions & 14 deletions llvm/test/Transforms/SCCP/pr45185-range-predinfo.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,29 +3,27 @@

;Test for PR45185.

define void @spam([4 x [24 x float]]* %arg) {
define void @spam(ptr %arg) {
; CHECK-LABEL: @spam(
; CHECK-NEXT: bb:
; CHECK-NEXT: [[TMP:%.*]] = getelementptr inbounds [4 x [24 x float]], [4 x [24 x float]]* [[ARG:%.*]], i64 0, i64 0, i64 0
; CHECK-NEXT: call void @blam(i32 0, float* nonnull [[TMP]])
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [4 x [24 x float]], [4 x [24 x float]]* [[ARG]], i64 0, i64 1, i64 0
; CHECK-NEXT: call void @blam(i32 1, float* nonnull [[TMP1]])
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds [4 x [24 x float]], [4 x [24 x float]]* [[ARG]], i64 0, i64 2, i64 0
; CHECK-NEXT: call void @blam(i32 2, float* nonnull [[TMP2]])
; CHECK-NEXT: call void @blam(i32 0, ptr nonnull [[ARG:%.*]])
; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds [4 x [24 x float]], ptr [[ARG]], i64 0, i64 1, i64 0
; CHECK-NEXT: call void @blam(i32 1, ptr nonnull [[TMP1]])
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds [4 x [24 x float]], ptr [[ARG]], i64 0, i64 2, i64 0
; CHECK-NEXT: call void @blam(i32 2, ptr nonnull [[TMP2]])
; CHECK-NEXT: ret void
;
bb:
%tmp = getelementptr inbounds [4 x [24 x float]], [4 x [24 x float]]* %arg, i64 0, i64 0, i64 0
call void @blam(i32 0, float* nonnull %tmp)
%tmp1 = getelementptr inbounds [4 x [24 x float]], [4 x [24 x float]]* %arg, i64 0, i64 1, i64 0
call void @blam(i32 1, float* nonnull %tmp1)
%tmp2 = getelementptr inbounds [4 x [24 x float]], [4 x [24 x float]]* %arg, i64 0, i64 2, i64 0
call void @blam(i32 2, float* nonnull %tmp2)
call void @blam(i32 0, ptr nonnull %arg)
%tmp1 = getelementptr inbounds [4 x [24 x float]], ptr %arg, i64 0, i64 1, i64 0
call void @blam(i32 1, ptr nonnull %tmp1)
%tmp2 = getelementptr inbounds [4 x [24 x float]], ptr %arg, i64 0, i64 2, i64 0
call void @blam(i32 2, ptr nonnull %tmp2)
ret void
}

; Make sure we do not incorrectly eliminate the checks in @blam.
define internal void @blam(i32 %arg, float* nocapture %arg1) {
define internal void @blam(i32 %arg, ptr nocapture %arg1) {
; CHECK-LABEL: define {{.*}} @blam(
; CHECK-NEXT: bb:
; CHECK-NEXT: [[TMP:%.*]] = icmp eq i32 [[ARG:%.*]], 0
Expand Down
42 changes: 21 additions & 21 deletions llvm/test/Transforms/SCCP/pr49582-iterator-invalidation.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,7 +2,7 @@
; PR49582: This test checks for an iterator invalidation issue, which only gets
; exposed on a large-enough test case. We intentionally do not check the output.

@c = external dso_local global i32*, align 8
@c = external dso_local global ptr, align 8
@d = external dso_local global i32, align 4

define void @f(i32 %i) {
Expand All @@ -13,12 +13,12 @@ for.cond: ; preds = %if.end628, %entry
%e.0 = phi i32 [ 1, %entry ], [ %e.15, %if.end628 ]
%cmp = icmp slt i32 %e.0, %i
call void @llvm.assume(i1 %cmp)
%0 = load i32*, i32** @c, align 8
%tobool = icmp ne i32* %0, null
%0 = load ptr, ptr @c, align 8
%tobool = icmp ne ptr %0, null
br i1 %tobool, label %if.then, label %if.end628

if.then: ; preds = %for.cond
%1 = load i32, i32* %0, align 4
%1 = load i32, ptr %0, align 4
%tobool1 = icmp ne i32 %1, 0
br i1 %tobool1, label %if.then2, label %if.else78

Expand Down Expand Up @@ -105,8 +105,8 @@ if.then49: ; preds = %if.end47

if.end51: ; preds = %if.then49, %if.end47
%e.5 = phi i32 [ %inc50, %if.then49 ], [ %e.4, %if.end47 ]
%2 = load i32*, i32** @c, align 8
%tobool52 = icmp ne i32* %2, null
%2 = load ptr, ptr @c, align 8
%tobool52 = icmp ne ptr %2, null
br i1 %tobool52, label %if.then53, label %if.else

if.then53: ; preds = %if.end51
Expand All @@ -117,7 +117,7 @@ if.then55: ; preds = %if.then53
unreachable

if.else: ; preds = %if.end51
%3 = load i32, i32* @d, align 4
%3 = load i32, ptr @d, align 4
%tobool57 = icmp ne i32 %3, 0
br i1 %tobool57, label %if.then58, label %if.else68

Expand Down Expand Up @@ -273,8 +273,8 @@ if.then162: ; preds = %if.end160
unreachable

if.else164: ; preds = %if.then126
%4 = load i32*, i32** @c, align 8
%tobool165 = icmp ne i32* %4, null
%4 = load ptr, ptr @c, align 8
%tobool165 = icmp ne ptr %4, null
br i1 %tobool165, label %if.then166, label %if.else195

if.then166: ; preds = %if.else164
Expand Down Expand Up @@ -307,7 +307,7 @@ if.then190: ; preds = %if.end187
br label %if.end628

if.else195: ; preds = %if.else164
%5 = load i32, i32* @d, align 4
%5 = load i32, ptr @d, align 4
%tobool196 = icmp ne i32 %5, 0
br i1 %tobool196, label %if.then197, label %if.else205

Expand Down Expand Up @@ -339,8 +339,8 @@ if.end215: ; preds = %if.then208
br label %if.end628

if.else217: ; preds = %if.else205
%7 = load i32*, i32** @c, align 8
%tobool218 = icmp ne i32* %7, null
%7 = load ptr, ptr @c, align 8
%tobool218 = icmp ne ptr %7, null
br i1 %tobool218, label %if.then219, label %if.else227

if.then219: ; preds = %if.else217
Expand Down Expand Up @@ -374,8 +374,8 @@ if.then240: ; preds = %if.end237
br label %if.end628

if.else245: ; preds = %if.else227
%8 = load i32*, i32** @c, align 8
%tobool246 = icmp ne i32* %8, null
%8 = load ptr, ptr @c, align 8
%tobool246 = icmp ne ptr %8, null
br i1 %tobool246, label %if.then247, label %if.else258

if.then247: ; preds = %if.else245
Expand All @@ -392,7 +392,7 @@ if.end254: ; preds = %if.then247
br label %if.end628

if.else258: ; preds = %if.else245
%10 = load i32, i32* @d, align 4
%10 = load i32, ptr @d, align 4
%tobool259 = icmp ne i32 %10, 0
br i1 %tobool259, label %if.then260, label %if.else268

Expand Down Expand Up @@ -420,8 +420,8 @@ if.then274: ; preds = %if.then271
br label %if.end628

if.else279: ; preds = %if.else268
%11 = load i32*, i32** @c, align 8
%tobool280 = icmp ne i32* %11, null
%11 = load ptr, ptr @c, align 8
%tobool280 = icmp ne ptr %11, null
br i1 %tobool280, label %if.then281, label %if.else287

if.then281: ; preds = %if.else279
Expand All @@ -438,8 +438,8 @@ if.else287: ; preds = %if.else279
br i1 %tobool289, label %if.then290, label %if.else307

if.then290: ; preds = %if.else287
%12 = load i32*, i32** @c, align 8
%tobool291 = icmp ne i32* %12, null
%12 = load ptr, ptr @c, align 8
%tobool291 = icmp ne ptr %12, null
br i1 %tobool291, label %if.then292, label %if.else298

if.then292: ; preds = %if.then290
Expand All @@ -460,8 +460,8 @@ if.then301: ; preds = %if.else298
br label %if.end628

if.else307: ; preds = %if.else287
%13 = load i32*, i32** @c, align 8
%tobool308 = icmp ne i32* %13, null
%13 = load ptr, ptr @c, align 8
%tobool308 = icmp ne ptr %13, null
br i1 %tobool308, label %if.then309, label %if.else324

if.then309: ; preds = %if.else307
Expand Down
30 changes: 15 additions & 15 deletions llvm/test/Transforms/SCCP/pthreads.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,10 +3,10 @@
;
; #include <pthread.h>
;
; void *GlobalVPtr;
; ptr GlobalVPtr;
;
; static void *foo(void *arg) { return arg; }
; static void *bar(void *arg) { return arg; }
; static ptr foo(ptr arg) { return arg; }
; static ptr bar(ptr arg) { return arg; }
;
; int main() {
; pthread_t thread;
Expand All @@ -22,41 +22,41 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"

%union.pthread_attr_t = type { i64, [48 x i8] }

@GlobalVPtr = common dso_local global i8* null, align 8
@GlobalVPtr = common dso_local global ptr null, align 8

define dso_local i32 @main() {
; CHECK-LABEL: @main(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[THREAD:%.*]] = alloca i64, align 8
; CHECK-NEXT: [[CALL:%.*]] = call i32 @pthread_create(i64* nonnull [[THREAD]], %union.pthread_attr_t* null, i8* (i8*)* nonnull @foo, i8* null)
; CHECK-NEXT: [[CALL1:%.*]] = call i32 @pthread_create(i64* nonnull [[THREAD]], %union.pthread_attr_t* null, i8* (i8*)* nonnull @bar, i8* bitcast (i8** @GlobalVPtr to i8*))
; CHECK-NEXT: [[CALL:%.*]] = call i32 @pthread_create(ptr nonnull [[THREAD]], ptr null, ptr nonnull @foo, ptr null)
; CHECK-NEXT: [[CALL1:%.*]] = call i32 @pthread_create(ptr nonnull [[THREAD]], ptr null, ptr nonnull @bar, ptr @GlobalVPtr)
; CHECK-NEXT: ret i32 0
;
entry:
%thread = alloca i64, align 8
%call = call i32 @pthread_create(i64* nonnull %thread, %union.pthread_attr_t* null, i8* (i8*)* nonnull @foo, i8* null)
%call1 = call i32 @pthread_create(i64* nonnull %thread, %union.pthread_attr_t* null, i8* (i8*)* nonnull @bar, i8* bitcast (i8** @GlobalVPtr to i8*))
%call = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @foo, ptr null)
%call1 = call i32 @pthread_create(ptr nonnull %thread, ptr null, ptr nonnull @bar, ptr @GlobalVPtr)
ret i32 0
}

declare !callback !0 dso_local i32 @pthread_create(i64*, %union.pthread_attr_t*, i8* (i8*)*, i8*)
declare !callback !0 dso_local i32 @pthread_create(ptr, ptr, ptr, ptr)

define internal i8* @foo(i8* %arg) {
define internal ptr @foo(ptr %arg) {
; CHECK-LABEL: @foo(
; CHECK-NEXT: entry:
; CHECK-NEXT: ret i8* [[ARG:%.*]]
; CHECK-NEXT: ret ptr [[ARG:%.*]]
;
entry:
ret i8* %arg
ret ptr %arg
}

define internal i8* @bar(i8* %arg) {
define internal ptr @bar(ptr %arg) {
; CHECK-LABEL: @bar(
; CHECK-NEXT: entry:
; CHECK-NEXT: ret i8* [[ARG:%.*]]
; CHECK-NEXT: ret ptr [[ARG:%.*]]
;
entry:
ret i8* %arg
ret ptr %arg
}

!1 = !{i64 2, i64 3, i1 false}
Expand Down
50 changes: 25 additions & 25 deletions llvm/test/Transforms/SCCP/replace-dereferenceable-ptr-with-undereferenceable.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,82 +4,82 @@
@y = common global [1 x i32] zeroinitializer, align 4
@x = common global [1 x i32] zeroinitializer, align 4

define i32 @eq_undereferenceable(i32* %p) {
define i32 @eq_undereferenceable(ptr %p) {
; CHECK-LABEL: @eq_undereferenceable(
; CHECK-NEXT: entry:
; CHECK-NEXT: store i32 1, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @y, i64 0, i64 0), align 4
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[P:%.*]], getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 1, i64 0)
; CHECK-NEXT: store i32 1, ptr @y, align 4
; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[P:%.*]], getelementptr inbounds (i32, ptr @x, i64 1)
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: store i32 2, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 1, i64 0), align 4
; CHECK-NEXT: store i32 2, ptr getelementptr inbounds (i32, ptr @x, i64 1), align 4
; CHECK-NEXT: br label [[IF_END]]
; CHECK: if.end:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @y, i64 0, i64 0), align 4
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr @y, align 4
; CHECK-NEXT: ret i32 [[TMP0]]
;
entry:
store i32 1, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @y, i64 0, i64 0), align 4
%cmp = icmp eq i32* %p, getelementptr inbounds (i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 0, i64 0), i64 1)
store i32 1, ptr @y, align 4
%cmp = icmp eq ptr %p, getelementptr inbounds (i32, ptr @x, i64 1)
br i1 %cmp, label %if.then, label %if.end

if.then: ; preds = %entry
store i32 2, i32* %p, align 4
store i32 2, ptr %p, align 4
br label %if.end

if.end: ; preds = %if.then, %entry
%0 = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @y, i64 0, i64 0), align 4
%0 = load i32, ptr @y, align 4
ret i32 %0
}


define i32 @eq_dereferenceable(i32* %p) {
define i32 @eq_dereferenceable(ptr %p) {
; CHECK-LABEL: @eq_dereferenceable(
; CHECK-NEXT: entry:
; CHECK-NEXT: store i32 1, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @y, i64 0, i64 0), align 4
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32* [[P:%.*]], getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 0, i64 0)
; CHECK-NEXT: store i32 1, ptr @y, align 4
; CHECK-NEXT: [[CMP:%.*]] = icmp eq ptr [[P:%.*]], @x
; CHECK-NEXT: br i1 [[CMP]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: store i32 2, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 0, i64 0), align 4
; CHECK-NEXT: store i32 2, ptr @x, align 4
; CHECK-NEXT: br label [[IF_END]]
; CHECK: if.end:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @y, i64 0, i64 0), align 4
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr @y, align 4
; CHECK-NEXT: ret i32 [[TMP0]]
;
entry:
store i32 1, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @y, i64 0, i64 0), align 4
%cmp = icmp eq i32* %p, getelementptr inbounds (i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 0, i64 0), i64 0)
store i32 1, ptr @y, align 4
%cmp = icmp eq ptr %p, @x
br i1 %cmp, label %if.then, label %if.end

if.then: ; preds = %entry
store i32 2, i32* %p, align 4
store i32 2, ptr %p, align 4
br label %if.end

if.end: ; preds = %if.then, %entry
%0 = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @y, i64 0, i64 0), align 4
%0 = load i32, ptr @y, align 4
ret i32 %0
}

define i1 @eq_undereferenceable_cmp_simp(i32* %p) {
define i1 @eq_undereferenceable_cmp_simp(ptr %p) {
; CHECK-LABEL: @eq_undereferenceable_cmp_simp(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP_0:%.*]] = icmp eq i32* [[P:%.*]], getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 1, i64 0)
; CHECK-NEXT: [[CMP_0:%.*]] = icmp eq ptr [[P:%.*]], getelementptr inbounds (i32, ptr @x, i64 1)
; CHECK-NEXT: br i1 [[CMP_0]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
; CHECK: if.then:
; CHECK-NEXT: store i32 2, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 1, i64 0), align 4
; CHECK-NEXT: store i32 2, ptr getelementptr inbounds (i32, ptr @x, i64 1), align 4
; CHECK-NEXT: ret i1 true
; CHECK: if.end:
; CHECK-NEXT: ret i1 false
;
entry:
%cmp.0 = icmp eq i32* %p, getelementptr inbounds (i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 0, i64 0), i64 1)
%cmp.0 = icmp eq ptr %p, getelementptr inbounds (i32, ptr @x, i64 1)
br i1 %cmp.0, label %if.then, label %if.end

if.then: ; preds = %entry
store i32 2, i32* %p, align 4
%cmp.1 = icmp eq i32* %p, getelementptr inbounds (i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 0, i64 0), i64 1)
store i32 2, ptr %p, align 4
%cmp.1 = icmp eq ptr %p, getelementptr inbounds (i32, ptr @x, i64 1)
ret i1 %cmp.1

if.end: ; preds = %if.then, %entry
%cmp.2 = icmp eq i32* %p, getelementptr inbounds (i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @x, i64 0, i64 0), i64 1)
%cmp.2 = icmp eq ptr %p, getelementptr inbounds (i32, ptr @x, i64 1)
ret i1 %cmp.2
}
20 changes: 10 additions & 10 deletions llvm/test/Transforms/SCCP/report-changed.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,27 +8,27 @@ entry:
ret i16 0
}

declare i16 (i16, i16)* @add_fp2()
declare ptr @add_fp2()

define internal i16 (i16, i16)* ()* @add_fp3() {
define internal ptr @add_fp3() {
entry:
ret i16 (i16, i16)* ()* @add_fp2
ret ptr @add_fp2
}

define internal i16 @test_local_fp3(i16 %tnr) {
entry:
%tnr.addr = alloca i16, align 1
%call10 = call i16 @apply_fp3_local(i16 (i16, i16)* ()* ()* @add_fp3, i16 181, i16 16384)
%0 = load i16, i16* %tnr.addr, align 1
%call10 = call i16 @apply_fp3_local(ptr @add_fp3, i16 181, i16 16384)
%0 = load i16, ptr %tnr.addr, align 1
ret i16 %0
}

define internal i16 @apply_fp3_local(i16 (i16, i16)* ()* ()* %fp, i16 %p1, i16 %p2) {
define internal i16 @apply_fp3_local(ptr %fp, i16 %p1, i16 %p2) {
entry:
%fp.addr = alloca i16 (i16, i16)* ()* ()*, align 1
store i16 (i16, i16)* ()* ()* %fp, i16 (i16, i16)* ()* ()** %fp.addr, align 1
%0 = load i16 (i16, i16)* ()* ()*, i16 (i16, i16)* ()* ()** %fp.addr, align 1
%call = call i16 (i16, i16)* ()* %0()
%fp.addr = alloca ptr, align 1
store ptr %fp, ptr %fp.addr, align 1
%0 = load ptr, ptr %fp.addr, align 1
%call = call ptr %0()
%call2 = call i16 undef(i16 undef, i16 undef)
ret i16 %call2
}
154 changes: 76 additions & 78 deletions llvm/test/Transforms/SCCP/resolvedundefsin-tracked-fn.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,16 +14,16 @@ define i32 @test1_m(i32 %h) {
; CHECK-NEXT: [[CONV:%.*]] = trunc i32 [[H]] to i8
; CHECK-NEXT: [[CALL:%.*]] = call i32 @test1_k(i8 [[CONV]], i32 0)
; CHECK-NEXT: [[CONV1:%.*]] = sext i32 [[H]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = inttoptr i64 [[CONV1]] to %t1*
; CHECK-NEXT: [[CALL2:%.*]] = call i1 @test1_g(%t1* [[TMP0]], i32 1)
; CHECK-NEXT: [[TMP0:%.*]] = inttoptr i64 [[CONV1]] to ptr
; CHECK-NEXT: [[CALL2:%.*]] = call i1 @test1_g(ptr [[TMP0]], i32 1)
; CHECK-NEXT: ret i32 undef
;
entry:
%conv = trunc i32 %h to i8
%call = call i32 @test1_k(i8 %conv, i32 0)
%conv1 = sext i32 %h to i64
%0 = inttoptr i64 %conv1 to %t1*
%call2 = call i1 @test1_g(%t1* %0, i32 1)
%0 = inttoptr i64 %conv1 to ptr
%call2 = call i1 @test1_g(ptr %0, i32 1)
ret i32 undef

; uselistorder directives
Expand All @@ -36,27 +36,27 @@ define internal i32 @test1_k(i8 %h, i32 %i) {
; CHECK-LABEL: define {{[^@]+}}@test1_k
; CHECK-SAME: (i8 [[H:%.*]], i32 [[I:%.*]])
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @e, align 4
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr @e, align 4
; CHECK-NEXT: [[CONV:%.*]] = sext i32 [[TMP0]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = inttoptr i64 [[CONV]] to %t1*
; CHECK-NEXT: [[CALL:%.*]] = call i1 @test1_g(%t1* [[TMP1]], i32 0)
; CHECK-NEXT: [[TMP1:%.*]] = inttoptr i64 [[CONV]] to ptr
; CHECK-NEXT: [[CALL:%.*]] = call i1 @test1_g(ptr [[TMP1]], i32 0)
; CHECK-NEXT: call void @use.1(i1 false)
; CHECK-NEXT: ret i32 undef
;
entry:
%0 = load i32, i32* @e, align 4
%0 = load i32, ptr @e, align 4
%conv = sext i32 %0 to i64
%1 = inttoptr i64 %conv to %t1*
%call = call i1 @test1_g(%t1* %1, i32 %i)
%1 = inttoptr i64 %conv to ptr
%call = call i1 @test1_g(ptr %1, i32 %i)
%frombool.1 = zext i1 %call to i8
%tobool.1 = trunc i8 %frombool.1 to i1
call void @use.1(i1 %tobool.1)
ret i32 undef
}

define internal i1 @test1_g(%t1* %h, i32 %i) #0 {
define internal i1 @test1_g(ptr %h, i32 %i) #0 {
; CHECK-LABEL: define {{[^@]+}}@test1_g
; CHECK-SAME: (%t1* [[H:%.*]], i32 [[I:%.*]])
; CHECK-SAME: (ptr [[H:%.*]], i32 [[I:%.*]])
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[I]], 0
; CHECK-NEXT: br i1 [[TOBOOL]], label [[LAND_RHS:%.*]], label [[LAND_END:%.*]]
Expand Down Expand Up @@ -91,16 +91,16 @@ define i32 @test2_m(i32 %h) #0 {
; CHECK-NEXT: [[CONV:%.*]] = trunc i32 [[H]] to i8
; CHECK-NEXT: [[CALL:%.*]] = call i32 @test2_k(i8 [[CONV]], i32 0)
; CHECK-NEXT: [[CONV1:%.*]] = sext i32 [[H]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = inttoptr i64 [[CONV1]] to %t1*
; CHECK-NEXT: [[CALL2:%.*]] = call i1 @test2_g(%t1* [[TMP0]], i32 1)
; CHECK-NEXT: [[TMP0:%.*]] = inttoptr i64 [[CONV1]] to ptr
; CHECK-NEXT: [[CALL2:%.*]] = call i1 @test2_g(ptr [[TMP0]], i32 1)
; CHECK-NEXT: ret i32 undef
;
entry:
%conv = trunc i32 %h to i8
%call = call i32 @test2_k(i8 %conv, i32 0)
%conv1 = sext i32 %h to i64
%0 = inttoptr i64 %conv1 to %t1*
%call2 = call i1 @test2_g(%t1* %0, i32 1)
%0 = inttoptr i64 %conv1 to ptr
%call2 = call i1 @test2_g(ptr %0, i32 1)
ret i32 undef

; uselistorder directives
Expand All @@ -113,28 +113,28 @@ define internal i32 @test2_k(i8 %h, i32 %i) {
; CHECK-LABEL: define {{[^@]+}}@test2_k
; CHECK-SAME: (i8 [[H:%.*]], i32 [[I:%.*]])
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @e, align 4
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr @e, align 4
; CHECK-NEXT: [[CONV:%.*]] = sext i32 [[TMP0]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = inttoptr i64 [[CONV]] to %t1*
; CHECK-NEXT: [[CALL:%.*]] = call i1 @test3_g(%t1* [[TMP1]], i32 0)
; CHECK-NEXT: [[TMP1:%.*]] = inttoptr i64 [[CONV]] to ptr
; CHECK-NEXT: [[CALL:%.*]] = call i1 @test3_g(ptr [[TMP1]], i32 0)
; CHECK-NEXT: call void @use.1(i1 false)
; CHECK-NEXT: ret i32 undef
;
entry:
%0 = load i32, i32* @e, align 4
%0 = load i32, ptr @e, align 4
%conv = sext i32 %0 to i64
%1 = inttoptr i64 %conv to %t1*
%call = call i1 @test3_g(%t1* %1, i32 %i)
%1 = inttoptr i64 %conv to ptr
%call = call i1 @test3_g(ptr %1, i32 %i)
%frombool = icmp slt i1 %call, 1
%add = add i1 %frombool, %frombool
call void @use.1(i1 %frombool)
ret i32 undef

}

define internal i1 @test2_g(%t1* %h, i32 %i) {
define internal i1 @test2_g(ptr %h, i32 %i) {
; CHECK-LABEL: define {{[^@]+}}@test2_g
; CHECK-SAME: (%t1* [[H:%.*]], i32 [[I:%.*]])
; CHECK-SAME: (ptr [[H:%.*]], i32 [[I:%.*]])
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LAND_RHS:%.*]]
; CHECK: land.rhs:
Expand Down Expand Up @@ -170,16 +170,16 @@ define i32 @test3_m(i32 %h) #0 {
; CHECK-NEXT: [[CONV:%.*]] = trunc i32 [[H]] to i8
; CHECK-NEXT: [[CALL:%.*]] = call i32 @test3_k(i8 [[CONV]], i32 0)
; CHECK-NEXT: [[CONV1:%.*]] = sext i32 [[H]] to i64
; CHECK-NEXT: [[TMP0:%.*]] = inttoptr i64 [[CONV1]] to %t1*
; CHECK-NEXT: [[CALL2:%.*]] = call i1 @test3_g(%t1* [[TMP0]], i32 1)
; CHECK-NEXT: [[TMP0:%.*]] = inttoptr i64 [[CONV1]] to ptr
; CHECK-NEXT: [[CALL2:%.*]] = call i1 @test3_g(ptr [[TMP0]], i32 1)
; CHECK-NEXT: ret i32 undef
;
entry:
%conv = trunc i32 %h to i8
%call = call i32 @test3_k(i8 %conv, i32 0)
%conv1 = sext i32 %h to i64
%0 = inttoptr i64 %conv1 to %t1*
%call2 = call i1 @test3_g(%t1* %0, i32 1)
%0 = inttoptr i64 %conv1 to ptr
%call2 = call i1 @test3_g(ptr %0, i32 1)
ret i32 undef

; uselistorder directives
Expand All @@ -190,26 +190,26 @@ define internal i32 @test3_k(i8 %h, i32 %i) {
; CHECK-LABEL: define {{[^@]+}}@test3_k
; CHECK-SAME: (i8 [[H:%.*]], i32 [[I:%.*]])
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @e, align 4
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr @e, align 4
; CHECK-NEXT: [[CONV:%.*]] = sext i32 [[TMP0]] to i64
; CHECK-NEXT: [[TMP1:%.*]] = inttoptr i64 [[CONV]] to %t1*
; CHECK-NEXT: [[TMP1:%.*]] = inttoptr i64 [[CONV]] to ptr
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: [[CALL:%.*]] = call i1 @test3_g(%t1* [[TMP1]], i32 0)
; CHECK-NEXT: [[CALL:%.*]] = call i1 @test3_g(ptr [[TMP1]], i32 0)
; CHECK-NEXT: call void @use.1(i1 false)
; CHECK-NEXT: br label [[EXIT:%.*]]
; CHECK: exit:
; CHECK-NEXT: ret i32 undef
;
entry:
%0 = load i32, i32* @e, align 4
%0 = load i32, ptr @e, align 4
%conv = sext i32 %0 to i64
%1 = inttoptr i64 %conv to %t1*
%1 = inttoptr i64 %conv to ptr
br label %loop

loop:
%phi = phi i1 [ undef, %entry], [ %call, %loop ]
%call = call i1 @test3_g(%t1* %1, i32 %i)
%call = call i1 @test3_g(ptr %1, i32 %i)
%frombool = icmp slt i1 %call, 1
%add = add i1 %frombool, %frombool
call void @use.1(i1 %frombool)
Expand All @@ -219,9 +219,9 @@ exit:
ret i32 undef
}

define internal i1 @test3_g(%t1* %h, i32 %i) {
define internal i1 @test3_g(ptr %h, i32 %i) {
; CHECK-LABEL: define {{[^@]+}}@test3_g
; CHECK-SAME: (%t1* [[H:%.*]], i32 [[I:%.*]])
; CHECK-SAME: (ptr [[H:%.*]], i32 [[I:%.*]])
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TOBOOL:%.*]] = icmp ne i32 [[I]], 0
; CHECK-NEXT: br i1 [[TOBOOL]], label [[LAND_RHS:%.*]], label [[LAND_END:%.*]]
Expand Down Expand Up @@ -253,50 +253,48 @@ declare i32 @test3_j(...)
; TODO: We can eliminate the bitcast, if we resolve the unknown argument of
; @test4_b first.

declare void @use.16(i16*)
declare void @use.8(i8*)
declare void @use.16(ptr)
declare void @use.8(ptr)

define void @test4_a() {
; CHECK-LABEL: define {{[^@]+}}@test4_a()
; CHECK-NEXT: bb:
; CHECK-NEXT: [[TMP:%.*]] = call i8* @test4_c(i8* null)
; CHECK-NEXT: call void @test4_b(i8* null)
; CHECK-NEXT: [[TMP:%.*]] = call ptr @test4_c(ptr null)
; CHECK-NEXT: call void @test4_b(ptr null)
; CHECK-NEXT: ret void
;
bb:
%tmp = call i8* @test4_c(i8* null)
call void @test4_b(i8* %tmp)
%tmp = call ptr @test4_c(ptr null)
call void @test4_b(ptr %tmp)
ret void
}

define internal void @test4_b(i8* %arg) {
define internal void @test4_b(ptr %arg) {
; CHECK-LABEL: define {{[^@]+}}@test4_b
; CHECK-SAME: (i8* [[ARG:%.*]])
; CHECK-SAME: (ptr [[ARG:%.*]])
; CHECK-NEXT: bb:
; CHECK-NEXT: [[TMP:%.*]] = bitcast i8* null to i16*
; CHECK-NEXT: [[SEL:%.*]] = select i1 false, i8* null, i8* null
; CHECK-NEXT: call void @use.16(i16* [[TMP]])
; CHECK-NEXT: call void @use.8(i8* [[SEL]])
; CHECK-NEXT: [[SEL:%.*]] = select i1 false, ptr null, ptr null
; CHECK-NEXT: call void @use.16(ptr null)
; CHECK-NEXT: call void @use.8(ptr [[SEL]])
; CHECK-NEXT: ret void
;
bb:
%tmp = bitcast i8* %arg to i16*
%sel = select i1 false, i8* %arg, i8* %arg
call void @use.16(i16* %tmp)
call void @use.8(i8* %sel)
%sel = select i1 false, ptr %arg, ptr %arg
call void @use.16(ptr %arg)
call void @use.8(ptr %sel)
ret void
}

define internal i8* @test4_c(i8* %arg) {
define internal ptr @test4_c(ptr %arg) {
; CHECK-LABEL: define {{[^@]+}}@test4_c
; CHECK-SAME: (i8* [[ARG:%.*]])
; CHECK-SAME: (ptr [[ARG:%.*]])
; CHECK-NEXT: bb1:
; CHECK-NEXT: [[TMP:%.*]] = and i1 undef, undef
; CHECK-NEXT: br i1 [[TMP]], label [[BB3:%.*]], label [[BB2:%.*]]
; CHECK: bb2:
; CHECK-NEXT: unreachable
; CHECK: bb3:
; CHECK-NEXT: ret i8* undef
; CHECK-NEXT: ret ptr undef
;
bb1: ; preds = %bb
%tmp = and i1 undef, undef
Expand All @@ -306,48 +304,48 @@ bb2: ; preds = %bb1
unreachable

bb3: ; preds = %bb1
ret i8* null
ret ptr null
}

; TODO: Same as test4, but with a select instead of a bitcast.

define void @test5_a() {
; CHECK-LABEL: define {{[^@]+}}@test5_a()
; CHECK-NEXT: bb:
; CHECK-NEXT: [[TMP:%.*]] = call i8* @test5_c(i8* null)
; CHECK-NEXT: call void @test5_b(i8* null)
; CHECK-NEXT: [[TMP:%.*]] = call ptr @test5_c(ptr null)
; CHECK-NEXT: call void @test5_b(ptr null)
; CHECK-NEXT: ret void
;
bb:
%tmp = call i8* @test5_c(i8* null)
call void @test5_b(i8* %tmp)
%tmp = call ptr @test5_c(ptr null)
call void @test5_b(ptr %tmp)
ret void
}

define internal void @test5_b(i8* %arg) {
define internal void @test5_b(ptr %arg) {
; CHECK-LABEL: define {{[^@]+}}@test5_b
; CHECK-SAME: (i8* [[ARG:%.*]])
; CHECK-SAME: (ptr [[ARG:%.*]])
; CHECK-NEXT: bb:
; CHECK-NEXT: [[SEL:%.*]] = select i1 false, i8* null, i8* null
; CHECK-NEXT: call void @use.8(i8* [[SEL]])
; CHECK-NEXT: [[SEL:%.*]] = select i1 false, ptr null, ptr null
; CHECK-NEXT: call void @use.8(ptr [[SEL]])
; CHECK-NEXT: ret void
;
bb:
%sel = select i1 false, i8* %arg, i8* %arg
call void @use.8(i8* %sel)
%sel = select i1 false, ptr %arg, ptr %arg
call void @use.8(ptr %sel)
ret void
}

define internal i8* @test5_c(i8* %arg) {
define internal ptr @test5_c(ptr %arg) {
; CHECK-LABEL: define {{[^@]+}}@test5_c
; CHECK-SAME: (i8* [[ARG:%.*]])
; CHECK-SAME: (ptr [[ARG:%.*]])
; CHECK-NEXT: bb1:
; CHECK-NEXT: [[TMP:%.*]] = and i1 undef, undef
; CHECK-NEXT: br i1 [[TMP]], label [[BB3:%.*]], label [[BB2:%.*]]
; CHECK: bb2:
; CHECK-NEXT: unreachable
; CHECK: bb3:
; CHECK-NEXT: ret i8* undef
; CHECK-NEXT: ret ptr undef
;
bb1: ; preds = %bb
%tmp = and i1 undef, undef
Expand All @@ -357,7 +355,7 @@ bb2: ; preds = %bb1
unreachable

bb3: ; preds = %bb1
ret i8* null
ret ptr null
}


Expand All @@ -371,18 +369,18 @@ define void @test3() {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[IF_END16:%.*]]
; CHECK: if.end16:
; CHECK-NEXT: [[TMP0:%.*]] = load i32, i32* @contextsize, align 4
; CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr @contextsize, align 4
; CHECK-NEXT: [[SUB18:%.*]] = sub i32 undef, [[TMP0]]
; CHECK-NEXT: [[SUB19:%.*]] = sub i32 [[SUB18]], undef
; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* @maxposslen, align 4
; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr @maxposslen, align 4
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP1]], 8
; CHECK-NEXT: [[DIV:%.*]] = sdiv i32 undef, [[ADD]]
; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* @pcount, align 4
; CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr @pcount, align 4
; CHECK-NEXT: [[MUL:%.*]] = mul nsw i32 [[DIV]], [[SUB19]]
; CHECK-NEXT: [[CMP20:%.*]] = icmp sgt i32 [[TMP2]], [[MUL]]
; CHECK-NEXT: br i1 [[CMP20]], label [[IF_THEN22:%.*]], label [[IF_END24:%.*]]
; CHECK: if.then22:
; CHECK-NEXT: store i32 [[MUL]], i32* @pcount, align 4
; CHECK-NEXT: store i32 [[MUL]], ptr @pcount, align 4
; CHECK-NEXT: ret void
; CHECK: if.end24:
; CHECK-NEXT: [[CMP25474:%.*]] = icmp sgt i32 [[TMP2]], 0
Expand All @@ -396,19 +394,19 @@ entry:
br label %if.end16

if.end16: ; preds = %entry
%0 = load i32, i32* @contextsize, align 4
%0 = load i32, ptr @contextsize, align 4
%sub18 = sub i32 undef, %0
%sub19 = sub i32 %sub18, undef
%1 = load i32, i32* @maxposslen, align 4
%1 = load i32, ptr @maxposslen, align 4
%add = add nsw i32 %1, 8
%div = sdiv i32 undef, %add
%2 = load i32, i32* @pcount, align 4
%2 = load i32, ptr @pcount, align 4
%mul = mul nsw i32 %div, %sub19
%cmp20 = icmp sgt i32 %2, %mul
br i1 %cmp20, label %if.then22, label %if.end24

if.then22: ; preds = %if.end16
store i32 %mul, i32* @pcount, align 4
store i32 %mul, ptr @pcount, align 4
ret void

if.end24: ; preds = %if.end16
Expand Down
36 changes: 18 additions & 18 deletions llvm/test/Transforms/SCCP/return-argument.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,31 +2,31 @@
; RUN: opt < %s -passes=ipsccp -S | FileCheck %s

;; This function returns its second argument on all return statements
define internal i32* @incdec(i1 %C, i32* %V) {
define internal ptr @incdec(i1 %C, ptr %V) {
; CHECK-LABEL: @incdec(
; CHECK-NEXT: [[X:%.*]] = load i32, i32* [[V:%.*]], align 4
; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[V:%.*]], align 4
; CHECK-NEXT: br i1 [[C:%.*]], label [[T:%.*]], label [[F:%.*]]
; CHECK: T:
; CHECK-NEXT: [[X1:%.*]] = add i32 [[X]], 1
; CHECK-NEXT: store i32 [[X1]], i32* [[V]], align 4
; CHECK-NEXT: ret i32* [[V]]
; CHECK-NEXT: store i32 [[X1]], ptr [[V]], align 4
; CHECK-NEXT: ret ptr [[V]]
; CHECK: F:
; CHECK-NEXT: [[X2:%.*]] = sub i32 [[X]], 1
; CHECK-NEXT: store i32 [[X2]], i32* [[V]], align 4
; CHECK-NEXT: ret i32* [[V]]
; CHECK-NEXT: store i32 [[X2]], ptr [[V]], align 4
; CHECK-NEXT: ret ptr [[V]]
;
%X = load i32, i32* %V
%X = load i32, ptr %V
br i1 %C, label %T, label %F

T: ; preds = %0
%X1 = add i32 %X, 1
store i32 %X1, i32* %V
ret i32* %V
store i32 %X1, ptr %V
ret ptr %V

F: ; preds = %0
%X2 = sub i32 %X, 1
store i32 %X2, i32* %V
ret i32* %V
store i32 %X2, ptr %V
ret ptr %V
}

;; This function returns its first argument as a part of a multiple return
Expand All @@ -44,29 +44,29 @@ define internal { i32, i32 } @foo(i32 %A, i32 %B) {
ret { i32, i32 } %Z
}

define void @caller(i1 %C) personality i32 (...)* @__gxx_personality_v0 {
define void @caller(i1 %C) personality ptr @__gxx_personality_v0 {
; CHECK-LABEL: @caller(
; CHECK-NEXT: [[Q:%.*]] = alloca i32, align 4
; CHECK-NEXT: [[W:%.*]] = call i32* @incdec(i1 [[C:%.*]], i32* [[Q]])
; CHECK-NEXT: [[W:%.*]] = call ptr @incdec(i1 [[C:%.*]], ptr [[Q]])
; CHECK-NEXT: [[S1:%.*]] = call { i32, i32 } @foo(i32 1, i32 2)
; CHECK-NEXT: [[X1:%.*]] = extractvalue { i32, i32 } [[S1]], 0
; CHECK-NEXT: [[S2:%.*]] = invoke { i32, i32 } @foo(i32 3, i32 4)
; CHECK-NEXT: to label [[OK:%.*]] unwind label [[LPAD:%.*]]
; CHECK: OK:
; CHECK-NEXT: [[X2:%.*]] = extractvalue { i32, i32 } [[S2]], 0
; CHECK-NEXT: [[Z:%.*]] = add i32 [[X1]], [[X2]]
; CHECK-NEXT: store i32 [[Z]], i32* [[W]], align 4
; CHECK-NEXT: store i32 [[Z]], ptr [[W]], align 4
; CHECK-NEXT: br label [[RET:%.*]]
; CHECK: LPAD:
; CHECK-NEXT: [[EXN:%.*]] = landingpad { i8*, i32 }
; CHECK-NEXT: [[EXN:%.*]] = landingpad { ptr, i32 }
; CHECK-NEXT: cleanup
; CHECK-NEXT: br label [[RET]]
; CHECK: RET:
; CHECK-NEXT: ret void
;
%Q = alloca i32
;; Call incdec to see if %W is properly replaced by %Q
%W = call i32* @incdec(i1 %C, i32* %Q ) ; <i32> [#uses=1]
%W = call ptr @incdec(i1 %C, ptr %Q ) ; <i32> [#uses=1]
;; Call @foo twice, to prevent the arguments from propagating into the
;; function (so we can check the returned argument is properly
;; propagated per-caller).
Expand All @@ -78,11 +78,11 @@ OK:
%X2 = extractvalue { i32, i32 } %S2, 0
;; Do some stuff with the returned values which we can grep for
%Z = add i32 %X1, %X2
store i32 %Z, i32* %W
store i32 %Z, ptr %W
br label %RET

LPAD:
%exn = landingpad {i8*, i32}
%exn = landingpad {ptr, i32}
cleanup
br label %RET

Expand Down
6 changes: 3 additions & 3 deletions llvm/test/Transforms/SCCP/return-constant.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,14 +28,14 @@ define i1 @caller(i1 %C) {
ret i1 %Y
}

define i1 @invokecaller(i1 %C) personality i32 (...)* @__gxx_personality_v0 {
define i1 @invokecaller(i1 %C) personality ptr @__gxx_personality_v0 {
; CHECK-LABEL: @invokecaller(
; CHECK-NEXT: [[X:%.*]] = invoke i32 @foo(i1 [[C:%.*]])
; CHECK-NEXT: to label [[OK:%.*]] unwind label [[FAIL:%.*]]
; CHECK: OK:
; CHECK-NEXT: ret i1 true
; CHECK: FAIL:
; CHECK-NEXT: [[EXN:%.*]] = landingpad { i8*, i32 }
; CHECK-NEXT: [[EXN:%.*]] = landingpad { ptr, i32 }
; CHECK-NEXT: cleanup
; CHECK-NEXT: ret i1 false
;
Expand All @@ -44,7 +44,7 @@ OK:
%Y = icmp ne i32 %X, 0 ; <i1> [#uses=1]
ret i1 %Y
FAIL:
%exn = landingpad {i8*, i32}
%exn = landingpad {ptr, i32}
cleanup
ret i1 false
}
Expand Down
10 changes: 5 additions & 5 deletions llvm/test/Transforms/SCCP/retvalue-undef.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,8 +3,8 @@
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
target triple = "x86_64-unknown-linux-gnu"

define internal i32 ()* @f() {
ret i32 ()* @g
define internal ptr @f() {
ret ptr @g
}

define internal i32 @g() {
Expand All @@ -15,17 +15,17 @@ define internal i32 @g() {
; CHECK-NEXT: ret i32 8

define internal void @outer_mod() {
%1 = call i32 ()* () @f() ; <i32 ()*> [#uses=1]
%1 = call ptr () @f() ; <ptr> [#uses=1]
%2 = call i32 %1() ; <i32> [#uses=0]
ret void
}

define internal void @module_init() {
call void @register_outer_mod(void ()* @outer_mod)
call void @register_outer_mod(ptr @outer_mod)
ret void
}

declare void @register_outer_mod(void ()*)
declare void @register_outer_mod(ptr)

define i32 @main() {
ret i32 0
Expand Down
18 changes: 9 additions & 9 deletions llvm/test/Transforms/SCCP/switch.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -73,12 +73,12 @@ end:
ret i32 %phi
}

define i32 @test_duplicate_successors_phi_3(i1 %c1, i32* %p, i32 %y) {
define i32 @test_duplicate_successors_phi_3(i1 %c1, ptr %p, i32 %y) {
; CHECK-LABEL: @test_duplicate_successors_phi_3(
; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[C1:%.*]], label [[SWITCH:%.*]], label [[SWITCH_1:%.*]]
; CHECK: switch:
; CHECK-NEXT: [[X:%.*]] = load i32, i32* [[P:%.*]], align 4, !range !0
; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[P:%.*]], align 4, !range !0
; CHECK-NEXT: switch i32 [[X]], label [[SWITCH_DEFAULT:%.*]] [
; CHECK-NEXT: i32 0, label [[SWITCH_DEFAULT]]
; CHECK-NEXT: i32 1, label [[SWITCH_0:%.*]]
Expand All @@ -95,7 +95,7 @@ entry:
br i1 %c1, label %switch, label %switch.1

switch:
%x = load i32, i32* %p, !range !{i32 0, i32 3}
%x = load i32, ptr %p, !range !{i32 0, i32 3}
switch i32 %x, label %switch.default [
i32 0, label %switch.default
i32 1, label %switch.0
Expand All @@ -116,9 +116,9 @@ switch.1:
}

; TODO: Determine that the default destination is dead.
define i32 @test_local_range(i32* %p) {
define i32 @test_local_range(ptr %p) {
; CHECK-LABEL: @test_local_range(
; CHECK-NEXT: [[X:%.*]] = load i32, i32* [[P:%.*]], align 4, !range !0
; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[P:%.*]], align 4, !range !0
; CHECK-NEXT: switch i32 [[X]], label [[SWITCH_DEFAULT:%.*]] [
; CHECK-NEXT: i32 0, label [[SWITCH_0:%.*]]
; CHECK-NEXT: i32 1, label [[SWITCH_1:%.*]]
Expand All @@ -133,7 +133,7 @@ define i32 @test_local_range(i32* %p) {
; CHECK: switch.2:
; CHECK-NEXT: ret i32 2
;
%x = load i32, i32* %p, !range !{i32 0, i32 3}
%x = load i32, ptr %p, !range !{i32 0, i32 3}
switch i32 %x, label %switch.default [
i32 0, label %switch.0
i32 1, label %switch.1
Expand All @@ -158,9 +158,9 @@ switch.3:
}

; TODO: Determine that case i3 is dead, even though the edge is shared?
define i32 @test_duplicate_successors(i32* %p) {
define i32 @test_duplicate_successors(ptr %p) {
; CHECK-LABEL: @test_duplicate_successors(
; CHECK-NEXT: [[X:%.*]] = load i32, i32* [[P:%.*]], align 4, !range !0
; CHECK-NEXT: [[X:%.*]] = load i32, ptr [[P:%.*]], align 4, !range !0
; CHECK-NEXT: switch i32 [[X]], label [[SWITCH_DEFAULT:%.*]] [
; CHECK-NEXT: i32 0, label [[SWITCH_0:%.*]]
; CHECK-NEXT: i32 1, label [[SWITCH_0]]
Expand All @@ -174,7 +174,7 @@ define i32 @test_duplicate_successors(i32* %p) {
; CHECK: switch.1:
; CHECK-NEXT: ret i32 1
;
%x = load i32, i32* %p, !range !{i32 0, i32 3}
%x = load i32, ptr %p, !range !{i32 0, i32 3}
switch i32 %x, label %switch.default [
i32 0, label %switch.0
i32 1, label %switch.0
Expand Down
16 changes: 8 additions & 8 deletions llvm/test/Transforms/SCCP/thread_local_acs.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,33 +20,33 @@ target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
@gtl = dso_local thread_local global i32 0, align 4
@gsh = dso_local global i32 0, align 4

define internal i32 @callee(i32* %thread_local_ptr, i32* %shared_ptr) {
define internal i32 @callee(ptr %thread_local_ptr, ptr %shared_ptr) {
; CHECK-LABEL: @callee(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP:%.*]] = load i32, i32* [[THREAD_LOCAL_PTR:%.*]], align 4
; CHECK-NEXT: [[TMP1:%.*]] = load i32, i32* [[SHARED_PTR:%.*]], align 4
; CHECK-NEXT: [[TMP:%.*]] = load i32, ptr [[THREAD_LOCAL_PTR:%.*]], align 4
; CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[SHARED_PTR:%.*]], align 4
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[TMP]], [[TMP1]]
; CHECK-NEXT: ret i32 [[ADD]]
;
entry:
%tmp = load i32, i32* %thread_local_ptr, align 4
%tmp1 = load i32, i32* %shared_ptr, align 4
%tmp = load i32, ptr %thread_local_ptr, align 4
%tmp1 = load i32, ptr %shared_ptr, align 4
%add = add nsw i32 %tmp, %tmp1
ret i32 %add
}

define dso_local void @caller() {
; CHECK-LABEL: @caller(
; CHECK-NEXT: entry:
; CHECK-NEXT: call void @broker(i32* nonnull @gtl, i32 (i32*, i32*)* nonnull @callee, i32* nonnull @gsh)
; CHECK-NEXT: call void @broker(ptr nonnull @gtl, ptr nonnull @callee, ptr nonnull @gsh)
; CHECK-NEXT: ret void
;
entry:
call void @broker(i32* nonnull @gtl, i32 (i32*, i32*)* nonnull @callee, i32* nonnull @gsh)
call void @broker(ptr nonnull @gtl, ptr nonnull @callee, ptr nonnull @gsh)
ret void
}

declare !callback !0 dso_local void @broker(i32*, i32 (i32*, i32*)*, i32*)
declare !callback !0 dso_local void @broker(ptr, ptr, ptr)

!1 = !{i64 1, i64 0, i64 2, i1 false}
!0 = !{!1}
56 changes: 28 additions & 28 deletions llvm/test/Transforms/SCCP/ub-shift.ll
View file
Original file line number Diff line number Diff line change
@@ -1,82 +1,82 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -passes=sccp -S | FileCheck %s

define void @shift_undef_64(i64* %p) {
define void @shift_undef_64(ptr %p) {
; CHECK-LABEL: @shift_undef_64(
; CHECK-NEXT: store i64 0, i64* [[P:%.*]]
; CHECK-NEXT: store i64 -1, i64* [[P]]
; CHECK-NEXT: store i64 0, ptr [[P:%.*]]
; CHECK-NEXT: store i64 -1, ptr [[P]]
; CHECK-NEXT: [[R3:%.*]] = shl i64 -1, 4294967298
; CHECK-NEXT: store i64 [[R3]], i64* [[P]]
; CHECK-NEXT: store i64 [[R3]], ptr [[P]]
; CHECK-NEXT: ret void
;
%r1 = lshr i64 -1, 4294967296 ; 2^32
store i64 %r1, i64* %p
store i64 %r1, ptr %p

%r2 = ashr i64 -1, 4294967297 ; 2^32 + 1
store i64 %r2, i64* %p
store i64 %r2, ptr %p

%r3 = shl i64 -1, 4294967298 ; 2^32 + 2
store i64 %r3, i64* %p
store i64 %r3, ptr %p

ret void
}

define void @shift_undef_65(i65* %p) {
define void @shift_undef_65(ptr %p) {
; CHECK-LABEL: @shift_undef_65(
; CHECK-NEXT: store i65 0, i65* [[P:%.*]]
; CHECK-NEXT: store i65 0, i65* [[P]]
; CHECK-NEXT: store i65 0, ptr [[P:%.*]]
; CHECK-NEXT: store i65 0, ptr [[P]]
; CHECK-NEXT: [[R3:%.*]] = shl i65 1, -18446744073709551615
; CHECK-NEXT: store i65 [[R3]], i65* [[P]]
; CHECK-NEXT: store i65 [[R3]], ptr [[P]]
; CHECK-NEXT: ret void
;
%r1 = lshr i65 2, 18446744073709551617
store i65 %r1, i65* %p
store i65 %r1, ptr %p

%r2 = ashr i65 4, 18446744073709551617
store i65 %r2, i65* %p
store i65 %r2, ptr %p

%r3 = shl i65 1, 18446744073709551617
store i65 %r3, i65* %p
store i65 %r3, ptr %p

ret void
}

define void @shift_undef_256(i256* %p) {
define void @shift_undef_256(ptr %p) {
; CHECK-LABEL: @shift_undef_256(
; CHECK-NEXT: store i256 0, i256* [[P:%.*]]
; CHECK-NEXT: store i256 0, i256* [[P]]
; CHECK-NEXT: store i256 0, ptr [[P:%.*]]
; CHECK-NEXT: store i256 0, ptr [[P]]
; CHECK-NEXT: [[R3:%.*]] = shl i256 1, 18446744073709551619
; CHECK-NEXT: store i256 [[R3]], i256* [[P]]
; CHECK-NEXT: store i256 [[R3]], ptr [[P]]
; CHECK-NEXT: ret void
;
%r1 = lshr i256 2, 18446744073709551617
store i256 %r1, i256* %p
store i256 %r1, ptr %p

%r2 = ashr i256 4, 18446744073709551618
store i256 %r2, i256* %p
store i256 %r2, ptr %p

%r3 = shl i256 1, 18446744073709551619
store i256 %r3, i256* %p
store i256 %r3, ptr %p

ret void
}

define void @shift_undef_511(i511* %p) {
define void @shift_undef_511(ptr %p) {
; CHECK-LABEL: @shift_undef_511(
; CHECK-NEXT: store i511 0, i511* [[P:%.*]]
; CHECK-NEXT: store i511 -1, i511* [[P]]
; CHECK-NEXT: store i511 0, ptr [[P:%.*]]
; CHECK-NEXT: store i511 -1, ptr [[P]]
; CHECK-NEXT: [[R3:%.*]] = shl i511 -3, 1208925819614629174706180
; CHECK-NEXT: store i511 [[R3]], i511* [[P]]
; CHECK-NEXT: store i511 [[R3]], ptr [[P]]
; CHECK-NEXT: ret void
;
%r1 = lshr i511 -1, 1208925819614629174706276 ; 2^80 + 100
store i511 %r1, i511* %p
store i511 %r1, ptr %p

%r2 = ashr i511 -2, 1208925819614629174706200
store i511 %r2, i511* %p
store i511 %r2, ptr %p

%r3 = shl i511 -3, 1208925819614629174706180
store i511 %r3, i511* %p
store i511 %r3, ptr %p

ret void
}
4 changes: 2 additions & 2 deletions llvm/test/Transforms/SCCP/ubsan_overflow.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@ define i8 @foo() {
entry:
%0 = add nuw nsw i64 0, -1
%1 = lshr i64 %0, 1
%2 = getelementptr inbounds [4 x [4 x i8]], [4 x [4 x i8]]* bitcast ([16 x i8]* @0 to [4 x [4 x i8]]*), i64 0, i64 0, i64 %1
%3 = load i8, i8* %2, align 1
%2 = getelementptr inbounds [4 x [4 x i8]], ptr @0, i64 0, i64 0, i64 %1
%3 = load i8, ptr %2, align 1
ret i8 %3
}
4 changes: 2 additions & 2 deletions llvm/test/Transforms/SCCP/undef-resolve.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -258,11 +258,11 @@ entry:
define i32 @test11(i1 %tobool) {
; CHECK-LABEL: @test11(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[SHR4:%.*]] = ashr i32 undef, zext (i1 icmp eq (i32* bitcast (i32 (i1)* @test11 to i32*), i32* @GV) to i32)
; CHECK-NEXT: [[SHR4:%.*]] = ashr i32 undef, zext (i1 icmp eq (ptr @test11, ptr @GV) to i32)
; CHECK-NEXT: ret i32 [[SHR4]]
;
entry:
%shr4 = ashr i32 undef, zext (i1 icmp eq (i32* bitcast (i32 (i1)* @test11 to i32*), i32* @GV) to i32)
%shr4 = ashr i32 undef, zext (i1 icmp eq (ptr @test11, ptr @GV) to i32)
ret i32 %shr4
}

Expand Down
10 changes: 5 additions & 5 deletions llvm/test/Transforms/SCCP/vector-bitcast.ll
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,15 +7,15 @@ target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f3

declare void @use(i1)

define void @foo(<2 x i64>* %p) nounwind {
define void @foo(ptr %p) nounwind {
; CHECK-LABEL: @foo(
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[WHILE_BODY_I:%.*]]
; CHECK: while.body.i:
; CHECK-NEXT: [[VWORKEXPONENT_I_033:%.*]] = phi <4 x i32> [ [[SUB_I_I:%.*]], [[WHILE_BODY_I]] ], [ <i32 939524096, i32 939524096, i32 939524096, i32 939524096>, [[ENTRY:%.*]] ]
; CHECK-NEXT: [[SUB_I_I]] = add <4 x i32> [[VWORKEXPONENT_I_033]], <i32 -8388608, i32 -8388608, i32 -8388608, i32 -8388608>
; CHECK-NEXT: [[TMP0:%.*]] = bitcast <4 x i32> [[SUB_I_I]] to <2 x i64>
; CHECK-NEXT: store volatile <2 x i64> zeroinitializer, <2 x i64>* [[P:%.*]], align 16
; CHECK-NEXT: store volatile <2 x i64> zeroinitializer, ptr [[P:%.*]], align 16
; CHECK-NEXT: br label [[WHILE_BODY_I]]
;
entry:
Expand All @@ -26,7 +26,7 @@ while.body.i: ; preds = %while.body.i, %entr
%sub.i.i = add <4 x i32> %vWorkExponent.i.033, <i32 -8388608, i32 -8388608, i32 -8388608, i32 -8388608>
%0 = bitcast <4 x i32> %sub.i.i to <2 x i64>
%and.i119.i = and <2 x i64> %0, zeroinitializer
store volatile <2 x i64> %and.i119.i, <2 x i64>* %p
store volatile <2 x i64> %and.i119.i, ptr %p
br label %while.body.i
}

Expand All @@ -39,7 +39,7 @@ declare <64 x i8> @llvm.abs.v64i8(<64 x i8>, i1 immarg)
define void @vec_cast_abs() {
; CHECK-LABEL: @vec_cast_abs(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP1:%.*]] = load <64 x i8>, <64 x i8>* bitcast (%union.V512* @i8_mix to <64 x i8>*), align 64
; CHECK-NEXT: [[TMP1:%.*]] = load <64 x i8>, ptr @i8_mix, align 64
; CHECK-NEXT: [[TMP2:%.*]] = tail call <64 x i8> @llvm.abs.v64i8(<64 x i8> [[TMP1]], i1 false)
; CHECK-NEXT: [[TMP3:%.*]] = bitcast <64 x i8> [[TMP2]] to i512
; CHECK-NEXT: [[CMP_1:%.*]] = icmp eq i512 [[TMP3]], 12
Expand All @@ -54,7 +54,7 @@ define void @vec_cast_abs() {
; CHECK-NEXT: ret void
;
entry:
%tmp1 = load <64 x i8>, <64 x i8>* bitcast (%union.V512* @i8_mix to <64 x i8>*)
%tmp1 = load <64 x i8>, ptr @i8_mix
%tmp2 = tail call <64 x i8> @llvm.abs.v64i8(<64 x i8> %tmp1, i1 false)

%tmp3 = bitcast <64 x i8> %tmp2 to i512
Expand Down
184 changes: 83 additions & 101 deletions llvm/test/Transforms/SCCP/widening.ll
View file

Large diffs are not rendered by default.