[llvm] 4b53f86 - GuardWidening: Convert tests to opaque pointers
Matt Arsenault via llvm-commits
llvm-commits at lists.llvm.org
Mon Nov 28 06:47:59 PST 2022
Author: Matt Arsenault
Date: 2022-11-28T09:35:27-05:00
New Revision: 4b53f8667016617ba853ff557a156cd5b55d1400
URL: https://github.com/llvm/llvm-project/commit/4b53f8667016617ba853ff557a156cd5b55d1400
DIFF: https://github.com/llvm/llvm-project/commit/4b53f8667016617ba853ff557a156cd5b55d1400.diff
LOG: GuardWidening: Convert tests to opaque pointers
Added:
Modified:
llvm/test/Transforms/GuardWidening/basic-loop.ll
llvm/test/Transforms/GuardWidening/basic.ll
llvm/test/Transforms/GuardWidening/basic_widenable_condition_guards.ll
llvm/test/Transforms/GuardWidening/loop-schedule.ll
llvm/test/Transforms/GuardWidening/posion.ll
llvm/test/Transforms/GuardWidening/range-check-merging.ll
Removed:
################################################################################
diff --git a/llvm/test/Transforms/GuardWidening/basic-loop.ll b/llvm/test/Transforms/GuardWidening/basic-loop.ll
index 9da721a53edd9..1626cca93cad3 100644
--- a/llvm/test/Transforms/GuardWidening/basic-loop.ll
+++ b/llvm/test/Transforms/GuardWidening/basic-loop.ll
@@ -12,54 +12,54 @@ define void @widen_within_loop(i1 %cond_0, i1 %cond_1, i1 %cond_2) {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: store i32 0, i32* @G, align 4
+; CHECK-NEXT: store i32 0, ptr @G, align 4
; CHECK-NEXT: [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
; CHECK-NEXT: [[WIDE_CHK1:%.*]] = and i1 [[WIDE_CHK]], [[COND_2:%.*]]
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK1]]) [ "deopt"(i32 0) ]
-; CHECK-NEXT: store i32 1, i32* @G, align 4
-; CHECK-NEXT: store i32 2, i32* @G, align 4
-; CHECK-NEXT: store i32 3, i32* @G, align 4
+; CHECK-NEXT: store i32 1, ptr @G, align 4
+; CHECK-NEXT: store i32 2, ptr @G, align 4
+; CHECK-NEXT: store i32 3, ptr @G, align 4
; CHECK-NEXT: br label [[LOOP]]
;
entry:
br label %loop
loop:
- store i32 0, i32* @G
+ store i32 0, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"(i32 0) ]
- store i32 1, i32* @G
+ store i32 1, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"(i32 1) ]
- store i32 2, i32* @G
+ store i32 2, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_2) [ "deopt"(i32 2) ]
- store i32 3, i32* @G
+ store i32 3, ptr @G
br label %loop
}
define void @widen_into_preheader(i1 %cond_0, i1 %cond_1, i1 %cond_2) {
; CHECK-LABEL: @widen_into_preheader(
; CHECK-NEXT: entry:
-; CHECK-NEXT: store i32 0, i32* @G, align 4
+; CHECK-NEXT: store i32 0, ptr @G, align 4
; CHECK-NEXT: [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_1:%.*]]
; CHECK-NEXT: [[WIDE_CHK1:%.*]] = and i1 [[WIDE_CHK]], [[COND_2:%.*]]
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK1]]) [ "deopt"(i32 0) ]
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: store i32 1, i32* @G, align 4
-; CHECK-NEXT: store i32 2, i32* @G, align 4
-; CHECK-NEXT: store i32 3, i32* @G, align 4
+; CHECK-NEXT: store i32 1, ptr @G, align 4
+; CHECK-NEXT: store i32 2, ptr @G, align 4
+; CHECK-NEXT: store i32 3, ptr @G, align 4
; CHECK-NEXT: br label [[LOOP]]
;
entry:
- store i32 0, i32* @G
+ store i32 0, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"(i32 0) ]
br label %loop
loop:
- store i32 1, i32* @G
+ store i32 1, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"(i32 1) ]
- store i32 2, i32* @G
+ store i32 2, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_2) [ "deopt"(i32 2) ]
- store i32 3, i32* @G
+ store i32 3, ptr @G
br label %loop
}
@@ -68,14 +68,14 @@ define void @dont_widen_over_common_exit(i1 %cond_0, i1 %cond_1, i1 %cond_2) {
; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: store i32 0, i32* @G, align 4
+; CHECK-NEXT: store i32 0, ptr @G, align 4
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0:%.*]]) [ "deopt"(i32 0) ]
-; CHECK-NEXT: store i32 1, i32* @G, align 4
+; CHECK-NEXT: store i32 1, ptr @G, align 4
; CHECK-NEXT: br i1 [[COND_1:%.*]], label [[BACKEDGE:%.*]], label [[EXIT:%.*]]
; CHECK: backedge:
-; CHECK-NEXT: store i32 2, i32* @G, align 4
+; CHECK-NEXT: store i32 2, ptr @G, align 4
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND_2:%.*]]) [ "deopt"(i32 2) ]
-; CHECK-NEXT: store i32 3, i32* @G, align 4
+; CHECK-NEXT: store i32 3, ptr @G, align 4
; CHECK-NEXT: br label [[LOOP]]
; CHECK: exit:
; CHECK-NEXT: ret void
@@ -84,15 +84,15 @@ entry:
br label %loop
loop:
- store i32 0, i32* @G
+ store i32 0, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"(i32 0) ]
- store i32 1, i32* @G
+ store i32 1, ptr @G
br i1 %cond_1, label %backedge, label %exit
backedge:
- store i32 2, i32* @G
+ store i32 2, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_2) [ "deopt"(i32 2) ]
- store i32 3, i32* @G
+ store i32 3, ptr @G
br label %loop
exit:
@@ -102,33 +102,33 @@ exit:
define void @widen_over_common_exit_to_ph(i1 %cond_0, i1 %cond_1, i1 %cond_2) {
; CHECK-LABEL: @widen_over_common_exit_to_ph(
; CHECK-NEXT: entry:
-; CHECK-NEXT: store i32 0, i32* @G, align 4
+; CHECK-NEXT: store i32 0, ptr @G, align 4
; CHECK-NEXT: [[WIDE_CHK:%.*]] = and i1 [[COND_0:%.*]], [[COND_2:%.*]]
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"(i32 0) ]
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
-; CHECK-NEXT: store i32 1, i32* @G, align 4
+; CHECK-NEXT: store i32 1, ptr @G, align 4
; CHECK-NEXT: br i1 [[COND_1:%.*]], label [[BACKEDGE:%.*]], label [[EXIT:%.*]]
; CHECK: backedge:
-; CHECK-NEXT: store i32 2, i32* @G, align 4
-; CHECK-NEXT: store i32 3, i32* @G, align 4
+; CHECK-NEXT: store i32 2, ptr @G, align 4
+; CHECK-NEXT: store i32 3, ptr @G, align 4
; CHECK-NEXT: br label [[LOOP]]
; CHECK: exit:
; CHECK-NEXT: ret void
;
entry:
- store i32 0, i32* @G
+ store i32 0, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"(i32 0) ]
br label %loop
loop:
- store i32 1, i32* @G
+ store i32 1, ptr @G
br i1 %cond_1, label %backedge, label %exit
backedge:
- store i32 2, i32* @G
+ store i32 2, ptr @G
call void(i1, ...) @llvm.experimental.guard(i1 %cond_2) [ "deopt"(i32 2) ]
- store i32 3, i32* @G
+ store i32 3, ptr @G
br label %loop
exit:
diff --git a/llvm/test/Transforms/GuardWidening/basic.ll b/llvm/test/Transforms/GuardWidening/basic.ll
index 7e61f14853223..fbca82b55c5f7 100644
--- a/llvm/test/Transforms/GuardWidening/basic.ll
+++ b/llvm/test/Transforms/GuardWidening/basic.ll
@@ -180,35 +180,35 @@ right:
; Negative test: the load from %a can be safely speculated to before
; the first guard, but there is no guarantee that it will produce the
; same value.
-define void @f_6(i1* dereferenceable(32) %a, i1* %b, i1 %unknown) {
+define void @f_6(ptr dereferenceable(32) %a, ptr %b, i1 %unknown) {
; CHECK-LABEL: @f_6(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[COND_0:%.*]] = load i1, i1* [[A:%.*]], align 1
+; CHECK-NEXT: [[COND_0:%.*]] = load i1, ptr [[A:%.*]], align 1
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND_0]]) [ "deopt"() ]
-; CHECK-NEXT: store i1 [[UNKNOWN:%.*]], i1* [[B:%.*]], align 1
-; CHECK-NEXT: [[COND_1:%.*]] = load i1, i1* [[A]], align 1
+; CHECK-NEXT: store i1 [[UNKNOWN:%.*]], ptr [[B:%.*]], align 1
+; CHECK-NEXT: [[COND_1:%.*]] = load i1, ptr [[A]], align 1
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND_1]]) [ "deopt"() ]
; CHECK-NEXT: ret void
;
entry:
- %cond_0 = load i1, i1* %a
+ %cond_0 = load i1, ptr %a
call void(i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
- store i1 %unknown, i1* %b
- %cond_1 = load i1, i1* %a
+ store i1 %unknown, ptr %b
+ %cond_1 = load i1, ptr %a
call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
ret void
}
; All else equal, we try to widen the earliest guard we can. This
; heuristic can use some tuning.
-define void @f_7(i32 %a, i1* %cond_buf) {
+define void @f_7(i32 %a, ptr %cond_buf) {
; CHECK-LABEL: @f_7(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[COND_1:%.*]] = load volatile i1, i1* [[COND_BUF:%.*]], align 1
+; CHECK-NEXT: [[COND_1:%.*]] = load volatile i1, ptr [[COND_BUF:%.*]], align 1
; CHECK-NEXT: [[COND_3:%.*]] = icmp ult i32 [[A:%.*]], 7
; CHECK-NEXT: [[WIDE_CHK:%.*]] = and i1 [[COND_1]], [[COND_3]]
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
-; CHECK-NEXT: [[COND_2:%.*]] = load volatile i1, i1* [[COND_BUF]], align 1
+; CHECK-NEXT: [[COND_2:%.*]] = load volatile i1, ptr [[COND_BUF]], align 1
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[COND_2]]) [ "deopt"() ]
; CHECK-NEXT: br i1 undef, label [[LEFT:%.*]], label [[RIGHT:%.*]]
; CHECK: left:
@@ -218,9 +218,9 @@ define void @f_7(i32 %a, i1* %cond_buf) {
;
entry:
- %cond_1 = load volatile i1, i1* %cond_buf
+ %cond_1 = load volatile i1, ptr %cond_buf
call void(i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
- %cond_2 = load volatile i1, i1* %cond_buf
+ %cond_2 = load volatile i1, ptr %cond_buf
call void(i1, ...) @llvm.experimental.guard(i1 %cond_2) [ "deopt"() ]
br i1 undef, label %left, label %right
diff --git a/llvm/test/Transforms/GuardWidening/basic_widenable_condition_guards.ll b/llvm/test/Transforms/GuardWidening/basic_widenable_condition_guards.ll
index bbf2a3c71c01f..dd30d86c8905a 100644
--- a/llvm/test/Transforms/GuardWidening/basic_widenable_condition_guards.ll
+++ b/llvm/test/Transforms/GuardWidening/basic_widenable_condition_guards.ll
@@ -344,10 +344,10 @@ right: ; preds = %guarded
; Negative test: the load from %a can be safely speculated to before
; the first guard, but there is no guarantee that it will produce the
; same value.
-define void @f_6(i1* dereferenceable(32) %a, i1* %b, i1 %unknown) {
+define void @f_6(ptr dereferenceable(32) %a, ptr %b, i1 %unknown) {
; CHECK-LABEL: @f_6(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[COND_0:%.*]] = load i1, i1* [[A:%.*]], align 1
+; CHECK-NEXT: [[COND_0:%.*]] = load i1, ptr [[A:%.*]], align 1
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND:%.*]] = and i1 [[COND_0]], [[WIDENABLE_COND]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND]], label [[GUARDED:%.*]], label [[DEOPT:%.*]], !prof [[PROF0]]
@@ -355,8 +355,8 @@ define void @f_6(i1* dereferenceable(32) %a, i1* %b, i1 %unknown) {
; CHECK-NEXT: call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
; CHECK-NEXT: ret void
; CHECK: guarded:
-; CHECK-NEXT: store i1 [[UNKNOWN:%.*]], i1* [[B:%.*]], align 1
-; CHECK-NEXT: [[COND_1:%.*]] = load i1, i1* [[A]], align 1
+; CHECK-NEXT: store i1 [[UNKNOWN:%.*]], ptr [[B:%.*]], align 1
+; CHECK-NEXT: [[COND_1:%.*]] = load i1, ptr [[A]], align 1
; CHECK-NEXT: [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[COND_1]], [[WIDENABLE_COND3]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof [[PROF0]]
@@ -367,7 +367,7 @@ define void @f_6(i1* dereferenceable(32) %a, i1* %b, i1 %unknown) {
; CHECK-NEXT: ret void
;
entry:
- %cond_0 = load i1, i1* %a
+ %cond_0 = load i1, ptr %a
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_0, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
@@ -377,8 +377,8 @@ deopt: ; preds = %entry
ret void
guarded: ; preds = %entry
- store i1 %unknown, i1* %b
- %cond_1 = load i1, i1* %a
+ store i1 %unknown, ptr %b
+ %cond_1 = load i1, ptr %a
%widenable_cond3 = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond4 = and i1 %cond_1, %widenable_cond3
br i1 %exiplicit_guard_cond4, label %guarded1, label %deopt2, !prof !0
@@ -393,10 +393,10 @@ guarded1: ; preds = %guarded
; All else equal, we try to widen the earliest guard we can. This
; heuristic can use some tuning.
-define void @f_7(i32 %a, i1* %cond_buf) {
+define void @f_7(i32 %a, ptr %cond_buf) {
; CHECK-LABEL: @f_7(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[COND_1:%.*]] = load volatile i1, i1* [[COND_BUF:%.*]], align 1
+; CHECK-NEXT: [[COND_1:%.*]] = load volatile i1, ptr [[COND_BUF:%.*]], align 1
; CHECK-NEXT: [[WIDENABLE_COND:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[COND_3:%.*]] = icmp ult i32 [[A:%.*]], 7
; CHECK-NEXT: [[WIDE_CHK:%.*]] = and i1 [[COND_1]], [[COND_3]]
@@ -406,7 +406,7 @@ define void @f_7(i32 %a, i1* %cond_buf) {
; CHECK-NEXT: call void (...) @llvm.experimental.deoptimize.isVoid() [ "deopt"() ]
; CHECK-NEXT: ret void
; CHECK: guarded:
-; CHECK-NEXT: [[COND_2:%.*]] = load volatile i1, i1* [[COND_BUF]], align 1
+; CHECK-NEXT: [[COND_2:%.*]] = load volatile i1, ptr [[COND_BUF]], align 1
; CHECK-NEXT: [[WIDENABLE_COND3:%.*]] = call i1 @llvm.experimental.widenable.condition()
; CHECK-NEXT: [[EXIPLICIT_GUARD_COND4:%.*]] = and i1 [[COND_2]], [[WIDENABLE_COND3]]
; CHECK-NEXT: br i1 [[EXIPLICIT_GUARD_COND4]], label [[GUARDED1:%.*]], label [[DEOPT2:%.*]], !prof [[PROF0]]
@@ -428,7 +428,7 @@ define void @f_7(i32 %a, i1* %cond_buf) {
; CHECK-NEXT: ret void
;
entry:
- %cond_1 = load volatile i1, i1* %cond_buf
+ %cond_1 = load volatile i1, ptr %cond_buf
%widenable_cond = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond = and i1 %cond_1, %widenable_cond
br i1 %exiplicit_guard_cond, label %guarded, label %deopt, !prof !0
@@ -438,7 +438,7 @@ deopt: ; preds = %entry
ret void
guarded: ; preds = %entry
- %cond_2 = load volatile i1, i1* %cond_buf
+ %cond_2 = load volatile i1, ptr %cond_buf
%widenable_cond3 = call i1 @llvm.experimental.widenable.condition()
%exiplicit_guard_cond4 = and i1 %cond_2, %widenable_cond3
br i1 %exiplicit_guard_cond4, label %guarded1, label %deopt2, !prof !0
diff --git a/llvm/test/Transforms/GuardWidening/loop-schedule.ll b/llvm/test/Transforms/GuardWidening/loop-schedule.ll
index 600034e6ac2bb..2abdf6c0bb7a4 100644
--- a/llvm/test/Transforms/GuardWidening/loop-schedule.ll
+++ b/llvm/test/Transforms/GuardWidening/loop-schedule.ll
@@ -10,14 +10,14 @@
declare void @llvm.experimental.guard(i1,...)
-define void @iter(i32 %a, i32 %b, i1* %c_p) {
+define void @iter(i32 %a, i32 %b, ptr %c_p) {
; CHECK-LABEL: @iter(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
; CHECK-NEXT: [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
; CHECK-NEXT: [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[COND_1]]
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
-; CHECK-NEXT: [[CND:%.*]] = load i1, i1* [[C_P:%.*]], align 1
+; CHECK-NEXT: [[CND:%.*]] = load i1, ptr [[C_P:%.*]], align 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: br i1 [[CND]], label [[LOOP]], label [[LEAVE_LOOPEXIT:%.*]]
@@ -35,7 +35,7 @@ entry:
loop: ; preds = %loop.preheader, %loop
%cond_1 = icmp ult i32 %b, 10
call void (i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
- %cnd = load i1, i1* %c_p
+ %cnd = load i1, ptr %c_p
br i1 %cnd, label %loop, label %leave.loopexit
leave.loopexit: ; preds = %loop
@@ -45,14 +45,14 @@ leave: ; preds = %leave.loopexit, %en
ret void
}
-define void @within_loop(i32 %a, i32 %b, i1* %c_p) {
+define void @within_loop(i32 %a, i32 %b, ptr %c_p) {
; CHECK-LABEL: @within_loop(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[COND_0:%.*]] = icmp ult i32 [[A:%.*]], 10
; CHECK-NEXT: [[COND_1:%.*]] = icmp ult i32 [[B:%.*]], 10
; CHECK-NEXT: [[WIDE_CHK:%.*]] = and i1 [[COND_0]], [[COND_1]]
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK]]) [ "deopt"() ]
-; CHECK-NEXT: [[CND:%.*]] = load i1, i1* [[C_P:%.*]], align 1
+; CHECK-NEXT: [[CND:%.*]] = load i1, ptr [[C_P:%.*]], align 1
; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop:
; CHECK-NEXT: br i1 [[CND]], label [[LOOP]], label [[LEAVE_LOOPEXIT:%.*]]
@@ -70,7 +70,7 @@ loop: ; preds = %loop.preheader, %lo
call void (i1, ...) @llvm.experimental.guard(i1 %cond_0) [ "deopt"() ]
%cond_1 = icmp ult i32 %b, 10
call void (i1, ...) @llvm.experimental.guard(i1 %cond_1) [ "deopt"() ]
- %cnd = load i1, i1* %c_p
+ %cnd = load i1, ptr %c_p
br i1 %cnd, label %loop, label %leave.loopexit
leave.loopexit: ; preds = %loop
diff --git a/llvm/test/Transforms/GuardWidening/posion.ll b/llvm/test/Transforms/GuardWidening/posion.ll
index b628a39e48262..fac087927f7b3 100644
--- a/llvm/test/Transforms/GuardWidening/posion.ll
+++ b/llvm/test/Transforms/GuardWidening/posion.ll
@@ -65,7 +65,7 @@ out:
; go to deoptimization. But after guard widening freeze of c3 and c4 may return
; true due to c3 and c4 are poisons and we pass guard executing side effect store
; which never been executed in original program.
-define void @combine_range_checks_with_side_effect(i32 %x, i32* %p) {
+define void @combine_range_checks_with_side_effect(i32 %x, ptr %p) {
; CHECK-LABEL: @combine_range_checks_with_side_effect(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[X2:%.*]] = add i32 [[X:%.*]], 0
@@ -76,7 +76,7 @@ define void @combine_range_checks_with_side_effect(i32 %x, i32* %p) {
; CHECK-NEXT: [[C4:%.*]] = icmp ult i32 [[X4]], 100
; CHECK-NEXT: [[WIDE_CHK2:%.*]] = and i1 [[C4]], [[C3]]
; CHECK-NEXT: call void (i1, ...) @llvm.experimental.guard(i1 [[WIDE_CHK2]]) [ "deopt"(i64 1) ]
-; CHECK-NEXT: store i32 0, i32* [[P:%.*]], align 4
+; CHECK-NEXT: store i32 0, ptr [[P:%.*]], align 4
; CHECK-NEXT: br i1 [[C2]], label [[OK:%.*]], label [[OUT:%.*]]
; CHECK: ok:
; CHECK-NEXT: br label [[OUT]]
@@ -96,7 +96,7 @@ entry:
%c5 = icmp ult i32 %x5, 100
call void(i1, ...) @llvm.experimental.guard(i1 %c1) [ "deopt"(i64 1) ]
call void(i1, ...) @llvm.experimental.guard(i1 %c5) [ "deopt"(i64 5) ]
- store i32 0, i32* %p
+ store i32 0, ptr %p
br i1 %c2, label %ok, label %out
ok:
call void(i1, ...) @llvm.experimental.guard(i1 %c4) [ "deopt"(i64 4) ]
diff --git a/llvm/test/Transforms/GuardWidening/range-check-merging.ll b/llvm/test/Transforms/GuardWidening/range-check-merging.ll
index b2e229fd72110..f0338c559f0df 100644
--- a/llvm/test/Transforms/GuardWidening/range-check-merging.ll
+++ b/llvm/test/Transforms/GuardWidening/range-check-merging.ll
@@ -3,10 +3,10 @@
declare void @llvm.experimental.guard(i1,...)
-define void @f_0(i32 %x, i32* %length_buf) {
+define void @f_0(i32 %x, ptr %length_buf) {
; CHECK-LABEL: @f_0(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0:![0-9]+]]
+; CHECK-NEXT: [[LENGTH:%.*]] = load i32, ptr [[LENGTH_BUF:%.*]], align 4, !range [[RNG0:![0-9]+]]
; CHECK-NEXT: [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
; CHECK-NEXT: [[X_INC1:%.*]] = add i32 [[X]], 1
; CHECK-NEXT: [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
@@ -21,7 +21,7 @@ define void @f_0(i32 %x, i32* %length_buf) {
; CHECK-NEXT: ret void
;
entry:
- %length = load i32, i32* %length_buf, !range !0
+ %length = load i32, ptr %length_buf, !range !0
%chk0 = icmp ult i32 %x, %length
call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
@@ -39,10 +39,10 @@ entry:
ret void
}
-define void @f_1(i32 %x, i32* %length_buf) {
+define void @f_1(i32 %x, ptr %length_buf) {
; CHECK-LABEL: @f_1(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
+; CHECK-NEXT: [[LENGTH:%.*]] = load i32, ptr [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
; CHECK-NEXT: [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
; CHECK-NEXT: [[X_INC1:%.*]] = add i32 [[X]], 1
; CHECK-NEXT: [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
@@ -57,7 +57,7 @@ define void @f_1(i32 %x, i32* %length_buf) {
; CHECK-NEXT: ret void
;
entry:
- %length = load i32, i32* %length_buf, !range !0
+ %length = load i32, ptr %length_buf, !range !0
%chk0 = icmp ult i32 %x, %length
call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
@@ -75,11 +75,11 @@ entry:
ret void
}
-define void @f_2(i32 %a, i32* %length_buf) {
+define void @f_2(i32 %a, ptr %length_buf) {
; CHECK-LABEL: @f_2(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[X:%.*]] = and i32 [[A:%.*]], -256
-; CHECK-NEXT: [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
+; CHECK-NEXT: [[LENGTH:%.*]] = load i32, ptr [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
; CHECK-NEXT: [[CHK0:%.*]] = icmp ult i32 [[X]], [[LENGTH]]
; CHECK-NEXT: [[X_INC1:%.*]] = or i32 [[X]], 1
; CHECK-NEXT: [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
@@ -95,7 +95,7 @@ define void @f_2(i32 %a, i32* %length_buf) {
;
entry:
%x = and i32 %a, 4294967040 ;; 4294967040 == 0xffffff00
- %length = load i32, i32* %length_buf, !range !0
+ %length = load i32, ptr %length_buf, !range !0
%chk0 = icmp ult i32 %x, %length
call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
@@ -113,11 +113,11 @@ entry:
ret void
}
-define void @f_3(i32 %a, i32* %length_buf) {
+define void @f_3(i32 %a, ptr %length_buf) {
; CHECK-LABEL: @f_3(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[X:%.*]] = and i32 [[A:%.*]], -256
-; CHECK-NEXT: [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
+; CHECK-NEXT: [[LENGTH:%.*]] = load i32, ptr [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
; CHECK-NEXT: [[CHK0:%.*]] = icmp ult i32 [[X]], [[LENGTH]]
; CHECK-NEXT: [[X_INC1:%.*]] = add i32 [[X]], 1
; CHECK-NEXT: [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
@@ -133,7 +133,7 @@ define void @f_3(i32 %a, i32* %length_buf) {
;
entry:
%x = and i32 %a, 4294967040 ;; 4294967040 == 0xffffff00
- %length = load i32, i32* %length_buf, !range !0
+ %length = load i32, ptr %length_buf, !range !0
%chk0 = icmp ult i32 %x, %length
call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
@@ -151,10 +151,10 @@ entry:
ret void
}
-define void @f_4(i32 %x, i32* %length_buf) {
+define void @f_4(i32 %x, ptr %length_buf) {
; CHECK-LABEL: @f_4(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
+; CHECK-NEXT: [[LENGTH:%.*]] = load i32, ptr [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
; CHECK-NEXT: [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
; CHECK-NEXT: [[X_INC1:%.*]] = add i32 [[X]], -1024
; CHECK-NEXT: [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
@@ -171,7 +171,7 @@ define void @f_4(i32 %x, i32* %length_buf) {
; Note: we NOT guarding on "and i1 %chk3, %chk0", that would be incorrect.
entry:
- %length = load i32, i32* %length_buf, !range !0
+ %length = load i32, ptr %length_buf, !range !0
%chk0 = icmp ult i32 %x, %length
call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
@@ -189,10 +189,10 @@ entry:
ret void
}
-define void @f_5(i32 %x, i32* %length_buf) {
+define void @f_5(i32 %x, ptr %length_buf) {
; CHECK-LABEL: @f_5(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
+; CHECK-NEXT: [[LENGTH:%.*]] = load i32, ptr [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
; CHECK-NEXT: [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
; CHECK-NEXT: [[X_INC1:%.*]] = add i32 [[X]], 1
; CHECK-NEXT: [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
@@ -207,7 +207,7 @@ define void @f_5(i32 %x, i32* %length_buf) {
; CHECK-NEXT: ret void
;
entry:
- %length = load i32, i32* %length_buf, !range !0
+ %length = load i32, ptr %length_buf, !range !0
%chk0 = icmp ult i32 %x, %length
call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
@@ -237,10 +237,10 @@ entry:
;
; But (%x + 2) == -1 is not u< L
;
-define void @f_6(i32 %x, i32* %length_buf) {
+define void @f_6(i32 %x, ptr %length_buf) {
; CHECK-LABEL: @f_6(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
+; CHECK-NEXT: [[LENGTH:%.*]] = load i32, ptr [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
; CHECK-NEXT: [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
; CHECK-NEXT: [[X_INC1:%.*]] = add i32 [[X]], -2147483647
; CHECK-NEXT: [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
@@ -255,7 +255,7 @@ define void @f_6(i32 %x, i32* %length_buf) {
; CHECK-NEXT: ret void
;
entry:
- %length = load i32, i32* %length_buf, !range !0
+ %length = load i32, ptr %length_buf, !range !0
%chk0 = icmp ult i32 %x, %length
call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
@@ -274,11 +274,11 @@ entry:
}
-define void @f_7(i32 %x, i32* %length_buf) {
+define void @f_7(i32 %x, ptr %length_buf) {
; CHECK-LABEL: @f_7(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[LENGTH_A:%.*]] = load volatile i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
-; CHECK-NEXT: [[LENGTH_B:%.*]] = load volatile i32, i32* [[LENGTH_BUF]], align 4, !range [[RNG0]]
+; CHECK-NEXT: [[LENGTH_A:%.*]] = load volatile i32, ptr [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
+; CHECK-NEXT: [[LENGTH_B:%.*]] = load volatile i32, ptr [[LENGTH_BUF]], align 4, !range [[RNG0]]
; CHECK-NEXT: [[CHK0_A:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH_A]]
; CHECK-NEXT: [[CHK0_B:%.*]] = icmp ult i32 [[X]], [[LENGTH_B]]
; CHECK-NEXT: [[CHK0:%.*]] = and i1 [[CHK0_A]], [[CHK0_B]]
@@ -307,8 +307,8 @@ define void @f_7(i32 %x, i32* %length_buf) {
entry:
- %length_a = load volatile i32, i32* %length_buf, !range !0
- %length_b = load volatile i32, i32* %length_buf, !range !0
+ %length_a = load volatile i32, ptr %length_buf, !range !0
+ %length_b = load volatile i32, ptr %length_buf, !range !0
%chk0.a = icmp ult i32 %x, %length_a
%chk0.b = icmp ult i32 %x, %length_b
%chk0 = and i1 %chk0.a, %chk0.b
@@ -334,11 +334,11 @@ entry:
ret void
}
-define void @f_8(i32 %x, i32* %length_buf) {
+define void @f_8(i32 %x, ptr %length_buf) {
; Check that we clean nuw nsw flags
; CHECK-LABEL: @f_8(
; CHECK-NEXT: entry:
-; CHECK-NEXT: [[LENGTH:%.*]] = load i32, i32* [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
+; CHECK-NEXT: [[LENGTH:%.*]] = load i32, ptr [[LENGTH_BUF:%.*]], align 4, !range [[RNG0]]
; CHECK-NEXT: [[CHK0:%.*]] = icmp ult i32 [[X:%.*]], [[LENGTH]]
; CHECK-NEXT: [[X_INC1:%.*]] = add i32 [[X]], 1
; CHECK-NEXT: [[CHK1:%.*]] = icmp ult i32 [[X_INC1]], [[LENGTH]]
@@ -347,7 +347,7 @@ define void @f_8(i32 %x, i32* %length_buf) {
; CHECK-NEXT: ret void
;
entry:
- %length = load i32, i32* %length_buf, !range !0
+ %length = load i32, ptr %length_buf, !range !0
%chk0 = icmp ult i32 %x, %length
call void(i1, ...) @llvm.experimental.guard(i1 %chk0) [ "deopt"() ]
More information about the llvm-commits
mailing list